The 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit

We're bad at marketing

We can admit it, marketing is not our strong suit. Our strength is writing the kind of articles that developers, administrators, and free-software supporters depend on to know what is going on in the Linux world. Please subscribe today to help us keep doing that, and so we don’t have to get good at marketing.

Plenary sessions

• Reviewing kernel patches with LLMs: a discussion on how to use LLMs for patch review as well as how and where to continue developing the prompt files being used.

Filesystem track

• Policies for merging new filesystems: establishing criteria and policies for new kernel filesystems.
• Caching for extended attributes: creating some common infrastructure for an extended-attribute cache, rather than just developing another for FUSE.
• An update on fanotify: what has been merged in the last year and what is pending for the filesystem-event monitoring subsystem.
• An overlayfs update: what have the overlayfs developers been up to and what might be coming in the future?
• Some buffer-heads cleanup work: work on cleaning up the venerable buffer-heads code for multiple filesystems.
• Initiating writeback earlier: a discussion on whether to change when writeback is initiated and how that might be done.
• Limiting negative dentries: there are longstanding problems with negative directory entries (dentries) that pile up in ways that can cause soft lockups and other ills, so ways to limit that behavior were discussed.
• Topics in filesystem testing: a discussion on testing filesystems, especially on patches aimed at the stable kernels.

Memory-management track

• A new era for memory-management maintainership: longtime maintainer Andrew Morton has said that he is getting ready to step down; what happens next?
• A 2026 DAMON update: what is happening in this fast-moving memory-management subsystem.
• Providing 64KB base pages with 4KB kernels, two different ways: two approaches to getting the advantages of a larger base-page size while minimizing memory waste.
• Scaling transparent huge pages to 1GB: what is the next step in a world where a 2MB huge page is no longer considered huge?
• Revisiting mshare: yet another look at the longstanding goal of making page-table sharing easy.
• Managing pages outside of the direct map: removing memory from the kernel's direct map can improve security, but it hurts performance. Brendan Jackman is working on an API that avoids the performance penalty.
• Keeping COWs in context (a.k.a. anonymous reverse mapping): an attempt to update and simplify the kernel's reverse-mapping code.
• Policy groups for the kernel: is there a better interface for the administration of policies that don't fit the control-group model?
• HugeTLB preservation over live update: how to support the goal of swapping out the kernel on a running system while preserving the huge pages used by virtual machines running on that system.
• Controlling memory management with BPF: what might be possible by integrating BPF with the memory-management subsystem, and the obstacles to doing that.
• Swap tables, flash-friendly swap, swap_ops, and more: three sessions on the present and future state of the kernel's swap subsystem.
• Improving the per-CPU memory allocator: an allocator that is meant to improve scalability has scalability problems of its own.
• What's brewing in CXL: developments in the quest to support Compute Express Link (CXL) devices in the kernel.
• What is to be done about MGLRU?: the kernel has two separate reclaim implementations, one of which is the multi-generational LRU; how can those two be unified into one?
• Support for private memory nodes: how to better manage special-purpose memory provided by devices.
• Toward better handling of major page faults: despite a lot of work in this area, page-fault handling still can be subject to lock contention; how can that situation be improved?
• Custom page-cache policies with BPF: making it possible for user space to influence when pages are evicted from the page cache.
• In search of faster this_cpu operations: a scheme to make per-CPU variables faster on non-x86 architectures.
• Tier-aware memory-controller limits: adding support for tiered-memory systems to the memory controller.
• Better automatic management of transparent huge pages: the ongoing task to make transparent huge pages truly transparent.
• Further progress toward removing the page map count: the quest to simplify the accounting of page mappings continues.
• Separating memory descriptors from struct page: planning out the next steps in the big memory-descriptor transition.

BPF track

• BPF support in GCC 16 and beyond: an update on the state of BPF support in GCC.
• Representing the true signatures of kernel functions: progress on the problem of allowing functions with signatures changed by optimization to be correctly traced.
• BPF in the agentic era: Alexei Starovoitov talks about LLMs and the future of BPF development.
• BPF loop verification with scalar evolution: an algorithm used in compilers could help the BPF verifier handle more loops.
• Suspending and resuming BPF programs: a plan to introduce coroutines into BPF.
• KASAN for JIT-compiled BPF code: the kernel address sanitizer learns how to detect bugs in BPF's JIT compiler.
• A helper library for BPF arenas: a look at the libarena library and where it's going.
• Faster RCUs and lockless memory allocation: two BPF-track sessions that both touch on the costs of freeing memory.
• Shielding running kernels against exploits with BPF: John Fastabend discusses a strategy for quickly immunizing vulnerable kernels against new exploits.
• Sending packets directly from BPF: a facility to allow BPF to make outgoing network requests.
• Securing BPF LSMs against tampering: Christian Brauner leads a discussion of the problems systemd has had in deploying BPF LSMs.

Joint storage and filesystems sessions

• Buffered atomic writes, writethrough, and more: a multi-slot session on the path toward buffered atomic writes for PostgreSQL and others

Joint storage and memory-management sessions

• Using dma-bufs for read and write operations: a new, io_uring-based API to make the use of dma-bufs more efficient.
• Flash-friendly swap: how to perform swapping without wearing out your drive (covered as part of the larger swap-subsystem topic).

Group photo

The traditional group photo, as taken by the Linux Foundation. More photos from the summit can be found on the LF flickr site.

Acknowledgment

Many thanks to the Linux Foundation, LWN's travel sponsor, for supporting our travel to Zagreb to cover this event.