The 2022 Linux Storage, Filesystem, Memory-Management, and BPF Summit

The Linux Storage, Filesystem, Memory-Management, and BPF Summit (LSFMM) has long been one of the key events for many core kernel developers. The last LSFMM event, though, was held in the innocent, pre-pandemic days of early 2019. After three years, it finally was possible to hold an in-person gathering at beginning of May 2022 in Palm Springs, California, USA. As usual, LWN was there.

Plenary sessions

There were no truly plenary sessions at LSFMM 2022, since the BPF group was always on its own schedule. The sessions listed below covered the storage, filesystem, and memory-management tracks.

• A memory-folio update: the current status and future direction of the folio project.
• Remote participation at LSFMM: a discussion with the remote participants on what worked—and didn't—for them.

Joint filesystem/memory-management sessions

• Coping with hardware-poisoned page-cache pages: What should the kernel do when memory errors corrupt a page in the page cache?
• Dealing with negative dentries: how the kernel can manage the cache of file-name lookup failures better.
• Recent RCU changes: a quick overview of read-copy-update (RCU) followed by descriptions of some of the bigger changes that have gone into it over the last few years.
• Page pinning and filesystems: this year's discussion on how to solve the problems with get_user_pages().
• Sharing memory for shared file extents: exploring a way to stop wasting memory with extents that are shared between multiple files.

Joint storage/filesystem sessions

• Unique identifiers for NFS: how to create and manage unique IDs needed by NFS.
• Challenges with fstests and blktests: testing for filesystems and the block layer is an area that needs more work—and collaboration.
• Adding an in-kernel TLS handshake: what is the best way to add support for initiating a TLS handshake from the kernel?
• Maintainers don't scale: a discussion on some of the challenges faced by Linux kernel maintainers.
• Best practices for fstests: how to collaborate on better testing infrastructure for filesystems.
• ioctl() forever?: a session looking at some of the problems with using the ioctl() system call along with a few alternatives to it.
• Zoned storage: the challenges with supporting zoned storage and sequential-write-only zones in particular.
• A discussion on readahead: how much data should the kernel be speculatively reading ahead into the page cache?

Memory-management sessions

• Ways to reclaim unused page-table pages: a lot of the memory used to hold page tables is not needed in that role and could be put to better uses.
• The ongoing search for mmap_lock scalability: the 2022 version of the perennial page-fault scalability topic, perhaps with some solutions on the horizon this time.
• Improving memory-management documentation: how to capture some of the "tribal knowledge" behind memory management and make it available to more developers.
• The state of memory-management development: Andrew Morton describes some changes to how memory-management patches are handled.
• Seeking an API for protection keys supervisor: protection keys can help to harden the kernel, but the best way of managing them is still unclear.
• Better tools for out-of-memory debugging: understanding out-of-memory problems is not easy; what can be done to improve the situation?
• Solutions for direct-map fragmentation: a number of new technologies need to carve pages out of the kernel's direct map; how can that functionality be supported without hurting performance?
• CXL 1: Management and tiering: the first three sessions on the Compute Express Link and how it should be managed by the Linux kernel.
• Proactive reclaim: there are reasons to want to reclaim memory in a more proactive manner, but it is not clear how any such feature should be controlled.
• Merging the multi-generational LRU: an extended discussion concluded that the time has come to merge this huge change, but some open questions remain.
• Sharing page tables with mshare(): page tables are not normally shared between processes, which can lead to massive overhead in situations where memory is highly shared. This session discussed a proposal for a new system call to enable page-table sharing between cooperating processes.
• CXL 2: Pooling, sharing, and I/O-memory resources: CXL memory can be highly dynamic, making it hard to support in the kernel.
• Cleaning up dying control groups, 2022 edition: progress has been made with regard to getting dying memory control groups out of the way, but the problem is not yet fully solved.
• get_user_pages() and COW, 2022 edition: the long slog toward making page pinning work properly in the kernel.
• Fixing a race in hugetlbfs: using hugetlbfs can save a lot of page-table overhead for massively shared regions, but the implementation currently has an unpleasant and difficult-to-fix bug.
• Preserving guest memory across kexec: a proposed mechanism to allow a host kernel to be updated while minimally disturbing guest virtual machines.

Filesystem sessions

• Changing filesystem resize patterns: filesystems that are created small, but continually resized to be much larger, are causing some headaches.
• The netfslib helper library: a relatively new library to collect up common operations for network filesystems.
• Dynamically allocated pseudo-filesystems: a discussion on the right path for adding a general facility that would allow pseudo-filesystems (e.g. tracefs, debugfs) to reduce their memory footprint by allocating inodes and directory entries only when needed.
• Bringing bcachefs to the mainline: The bcachefs filesystem may be getting close to ready for merging.
• Snapshots, inodes, and filesystem identifiers: Filesystems that support snapshots, thus duplicate inode numbers, can be problematic.
• Change notifications for network filesystems: how to allow Linux clients to monitor additions, deletions, and other changes in network filesystems.
• Making O_TMPFILE atomic (and statx() additions): two half-sessions looking at features that could be added for filesystems.
• ID-mapped mounts: a discussion on the relatively new ID-mapped mounts feature for Linux filesystems.
• Filesystems, testing, and stable trees: the stable and, especially, LTS trees need more filesystem testing, but it is currently hard to do.
• Retrieving kernel attributes: a discussion on a proposed interface for getting information out of the kernel using the extended-attribute API.
• Disabling an extent optimization: filesystems do not necessarily maintain holes in files as holes, rather than just regions with zeroes, which can lead to some problems.

Other resources

• Christoph Hellwig has posted a summary of the action items from the BPF-track session on standardization.

The obligatory group photo

We would like to thank LWN subscribers for supporting our travel to and reporting from LSFMM 2022.

Index entries for this article
Conference	Storage, Filesystem, Memory-Management and BPF Summit/2022

---

to post comments