LWN Articles on Kernel and 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit

posted by Roy Schestowitz on Aug 13, 2026

• LWN ☛ The beginning of a process-builder API

  The recent discussion on "spawn templates" raised questions about whether it was time to provide an alternative to the classic Unix fork()/exec() pattern for process creation. One idea that was raised there was to shift the template pattern into an interface that could be used to efficiently assemble new processes from bare cloth, without duplicating the parent process. Preferably, that interface would be able to implement posix_spawn(). Li Chen, the author of the spawn-template work, has now responded with a patch series (written with significant LLM assistance) showing what a process-builder API for Linux might look like.

  In the Unix model, a call to fork() (which ends up being a variant of clone() on Linux systems) creates a copy of the calling process, which involves a fair amount of work. The child then typically modifies its environment in whatever ways are necessary — opening or closing files, for example — before making a call to execve() to run a new program. That latter call ends up throwing away most of the work that was done to copy the parent process, which is not entirely efficient. In cases where the intent is to immediately run a different program, a better model might be to piece together the new process from the beginning, without involving (much of) the parent process's state.

• LWN ☛ Reconsidering O_CREAT|O_DIRECTORY

  Linux provides a system call (mkdir()) to create a directory, and a few variants of open() that can open a directory. There is, however, no system call in Linux that can create and open a directory in a single, race-free call. Jori Koolstra has been working on remedying that situation, most recently by repurposing a set of open() flags that currently return an error. There are, however, concerns that show just how hard it can be to create user-space interfaces that do not present traps for application developers.

  Creating and opening a directory in a single system call is simpler and more efficient than using two, of course. It also can guard against the possibility that some other process will, between the creation and open steps, replace a directory with something else. Detecting that case is possible on Linux now, but it requires some defensive programming of the type that application developers are not always good at. Thus the desire for a more straightforward way to accomplish that pair of operations.

• LWN ☛ Buffer sizes for FUSE io_uring

  The Filesystem in Userspace (FUSE) subsystem provides a way to service filesystem requests from a user-space server, which moves the format-handling code out of the kernel. The FUSE server can use the io_uring facility for better performance, but Bernd Schubert is concerned that memory is being wasted because the current implementation has a single, large buffer size that is excessive for small I/O operations. He led a discussion on that topic in the filesystem track of the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit in Zagreb, Croatia.

  Currently, libfuse sets up eight entries per ring, with each entry defaulting to the maximum payload size (8MB), though switching to 4MB is also possible, he began. Normally one or two entries per ring are needed to achieve maximum throughput to the disk (which can be local or over the network), but there is also a need to handle metadata requests, for operations like stat() or directory listings. ""You don't want to disturb your streaming I/O while you are doing these metadata requests"".

  Those smaller requests might be 16KB or 128KB. In order to saturate the I/O bandwidth with requests of that size, however, a larger number of buffers is needed. ""The question is how we do this."" The existing implementation uses entries with a separate header and payload structure, but each has the same payload size.

• LWN ☛ Examining other network namespaces using BPF

  Jordan Rife's work involves writing BPF programs for Cilium that interface with Kubernetes networking. As part of that work, he wants to enable BPF programs with appropriate permissions to iterate through the sockets of a different network namespace. He led a session about the idea at the 2026 Linux Storage, Filesystem, Memory-Management, and BPF Summit where the BPF developers in attendance were quick to suggest a number of related alternatives.

  Socket-lb is a Cilium feature that uses the hooks for sockets associated with a given control group to balance connections across remote servers, while avoiding the per-packet overhead of network-address translation (NAT). In a setup that does not use socket-lb, a client might make a request to a frontend server that then uses NAT to route the connection transparently to a chosen backend server. Socket-lb improves on this by having the routing happen directly on the client device, still transparently to user space, but avoiding the extra network hop implied by NAT. In practice, socket-lb has some limitations, Rife said. If a selected backend goes away, for example, traffic will continue to be directed at that non-existent backend until Cilium cleans things up. Today, the software does that by using BPF iterators to walk through the available sockets and destroy them if needed.

• LWN ☛ FUSE status and plans

  Filesystem in Userspace (FUSE) maintainer Miklos Szeredi led a birds-of-a-feather (BoF) discussion about the subsystem at the 2026 Linux Storage, Filesystem, Memory Management, and BPF Summit. In it, he talked about maintenance challenges, proposed features and their status, and his plans for a new FUSE API. There is a lot of interest and activity in the FUSE community these days it seems.

  He began by noting that he feels he ""is not a good maintainer"". There are two parts to being a maintainer, he thinks, ""one is to keep bugs out and the other is to let features in"". He is good at the first, but not at the second. One way to address that is for FUSE to have a co-maintainer. ""If someone volunteers, I'd be very happy."" There were some, perhaps joking, suggestions made by attendees, but no one stepped up to help co-maintain FUSE itself.

• LWN ☛ The future of libraries in BPF

  Song Liu believes that the way that programmers assemble complex BPF programs will be changing rapidly in the future. At a session of the 2026 Linux Storage, Filesystem, Memory-Management, and BPF Summit, he shared his thoughts on what that change could look like, though he did not have any concrete proposals for what, if anything, the BPF maintainers should do. He anticipates an ecosystem of Rust BPF packages developing, which is significant because BPF does not really have a package manager at the moment.

  There are not many existing, popular BPF libraries, Liu said. Those that exist are generally small header-only libraries, or deal with the user-space side of loading and managing BPF programs. It is not impossible to have BPF libraries; bpftrace has a standard library. Bpftrace can also import non-standard-library BPF C code in a manner similar to inline assembly in normal C code. ""But I'm not sure people actually do this,"" he added.