The 2023 LSFMM+BPF Summit

By Jonathan Corbet
May 11, 2023

The 2023 Linux Storage, Filesystem, Memory-Management, and BPF Summit was held May 8 to 10 in Vancouver, British Columbia, Canada. This year, a slightly enlarged crowd (150 developers) met to discuss ongoing core-kernel development projects, solve problems, and chart a course for the next year. LWN was, of course, there as well.

Videos of the talks are now available on YouTube.

Plenary sessions

A small subset of the sessions involved the whole group (minus the BPF contingent, which mostly met independently). These sessions included:

A storage-standards update: an overview of what is coming in the storage area, with a focus on CXL 3.0.
Peer-to-peer DMA: transferring data directly between NVMe devices.
The state of the page in 2023: an update on the project to use folios everywhere and, eventually, reduce struct page to a single pointer.
Sunsetting buffer heads: nobody likes the venerable buffer-head data structure, but getting rid of it is not an easy task.
Supporting large block sizes: a discussion on what needs to be done to support block sizes larger than the page size.
Backporting XFS fixes to stable: a case-study of the XFS stable backports team and its activities, with an eye toward applying the idea to other filesystems.
A development-process discussion: trying to come to grips, again, with the problems of maintainer overload and frustrated contributors.

Combined storage and filesystem sessions

Computational storage: a new NVMe feature for offloading computation on data to NVMe devices of various kinds.
Zoned storage and filesystems: a discussion of a few issues around using zoned storage for filesystems.
Cloud-storage optimizations: discussion on I/O hints for cloud-based emulated block devices—and how to see them get implemented relatively quickly.
Atomic block-write operations: discussion on support for atomically writing data in sizes that are multiples of a device's block size.
Merging copy offload: handing off copy operations to block storage devices has been a feature floating around for a decade now; merging it would seem to be on the (near) horizon.
Testing for storage and filesystems: the perennial testing topic was discussed at length.

Combined filesystem and BPF sessions

BPF iterators for filesystems: a way to use BPF iterators to retrieve various kinds of filesystem information.
The FUSE BPF filesystem: a FUSE implementation that uses BPF to reduce the number of transitions in and out of the kernel.

Memory-management sessions

Reconsidering the direct-map fragmentation problem: for years, kernel developers have worried about the performance impacts of breaking up the kernel's direct map. Perhaps that worry was misplaced.
Memory-management changes for CXL: a discussion of suggested changes to enable better management of CXL-attached memory.
The future of memory tiering: there is a lot of interest in tiered-memory systems, but a lot of implementation questions remain.
Live migration of virtual machines over CXL. Using CXL shared-memory pools to move VMs with no gap in service.
Memory overcommit in containerized environments: helping virtual-machine managers get memory to the right places.
User-space control of memory management: another proposed mechanism to allow user space to make memory-management decisions.
A 2023 DAMON update: an overview of recent enhancements to the DAMON user-space memory-management tool and a look forward to what is coming next.
High-granularity mappings for huge pages: a technique for using huge pages while suffering less internal fragmentation.
Page aging with hardware counters: can the kernel's understanding of memory access patterns be usefully improved with hardware assistance?
The intersection of lazy RCU and memory reclaim: a discussion of the memory-management implications of the lazy RCU mechanism.
Memory passthrough for virtual machines: an effort to improve the efficiency of memory management in virtualized workloads.
Phyr: a potential scatterlist replacement: working toward a better representation of DMA operations in both the CPU and device spaces.
Fighting the zombie-memcg invasion: memory control groups have long presented memory-management problems of their own. This session explored the current difficulties and how they might be fixed.
Toward a swap abstraction layer: a proposal to bring some much-needed structure to the swap subsystem.
A slab allocator (removal) update: what is being done to reduce the number of slab allocators in the kernel.
Reliable user-space stack traces with SFrame: a derivative of the kernel's ORC format may provide a more efficient way to reliably produce user-space stack traces.
Flexible-order anonymous folios: the page cache can handle folios of multiple sizes; work is underway to bring the same flexibility to anonymous memory.
Optimizing single-owner memory: a proposal to optimize the management of memory that will never be shared.
Mitigating vmap lock contention allocations in the kernel's vmap area can be subject to significant lock contention; this session looked at the problem and a proposed way to improve the situation.
Improving page-fault scalability the 2023 version of this regular LSFMM+BPF discussion.
Code tagging and memory-allocation profiling: for the second year in a row, the memory-management developers consider the code-tagging patches.
Memory-management documentation and development process: two brief discussions on documentation and development process.

Filesystem sessions

FUSE passthrough for file I/O: optimizing Filesystem in Userspace (FUSE) for "passthrough" filesystems.
FUSE and io_uring: an effort to use io_uring in FUSE to improve performance.
Fanotify and hierarchical storage management: fanotify can be used for HSM, but some additions would make it better; meanwhile, there are some deadlocks and races that need to be addressed.
Monitoring mount operations: discussion on the needs for monitoring mount and unmount activity in the system.
A decision on composefs: the proposed composefs read-only, integrity-protected filesystem was discussed along with alternatives to solve the same set of problems.
An introduction to EROFS: an overview and discussion of the EROFS read-only filesystem.
Two VFS topics: discussion of a sequence number to prevent mount races and on the mount-beneath feature.
Mounting images inside a user namespace: a solution to enable unprivileged users to mount filesystem images.
Hardening magic links: files like /proc/[PID]/exe are actually magic links, which can be used to cause security problems, so hardening them is desired.
Retrieving mount and filesystem information in user space: there is a need for an API to gather information about mounted filesystems, what should it look like?
XFS online filesystem check and repair: a discussion on an online fsck feature for XFS.
Merging bcachefs: the time has come to merge this new filesystem, and there are questions about what the process is for doing so.
Removing the kthread freezer: pushing forward the removal of this long unloved API.
Converting filesystems to iomap: a discussion on the iomap documentation, especially as it relates to converting existing filesystems to use it.
Converting NFSD to use iomap and folios: the developers of the kernel NFS network filesystem server want to convert it to use iomap and folios, what will that entail?
Improving i_version: an inode's i_version value can be used for the NFSv4 change attribute, but there are still some issues to address with that.

[ Thanks to LWN subscribers for supporting our travel to Vancouver to attend this event. ]