LWN Picks: Kernel, SUSE, and Nix

posted by Roy Schestowitz on Oct 29, 2026

• Kernel Space / File Systems / Virtualization

  • LWN ☛ Development statistics for the 7.3 kernel [LWN.net]

    Linus Torvalds released the 7.3 kernel, at the end of the usual nine-week development cycle, on October 18. This cycle, abundantly fueled by LLM-assisted contributions, broke just about every record imaginable. As usual, we have compiled some statistics showing how this release, which is expected to be the next long-term-support (LTS) kernel, came together. Also included is an attempt to determine whether automated patch review is actually reducing the number of bugs introduced into the kernel.

  • LWN ☛ Vendor hooks in the Android kernel [LWN.net]

    Since Android's inception, the kernels it has used have diverged significantly from the mainline. While many of those differences have been resolved over time, and the move to the generic kernel image has helped to bring Android closer, current devices still carry a lot of out-of-tree changes. The preferred form for such changes is by way of vendor hooks. At the 2026 Linux Plumbers Conference, Todd Kjos ran a fast-paced session in the Android track to discuss vendor hooks and how they are used.

    The 6.6 kernel is the one used on the largest number of Android systems currently, he began; 6.18 can be found mostly on flagship devices at this point. The Android 6.6 kernel carries a large number (just over 3,100) of out-of-tree patches, nearly half of which (1,531) are backports of features from newer kernel releases. There is a relatively small set (287 patches) of "from list" changes that are being discussed on mailing lists but which have not yet found their way into the mainline. The remaining 1,306 patches, about 42%, are ""pure Android"" changes that are not upstream, and are not currently on their way upstream. Of those, something over a third are vendor hooks (much of the rest is build-system and configuration changes).

  • LWN ☛ Hash-based module integrity for reproducible distributions [LWN.net]

    We last looked in on hash-based integrity checking for kernel modules just over a year and half ago. Since that time, the patch set has undergone multiple revisions. At the 2026 Linux Plumbers Conference (LPC), Thomas Weißschuh described the need for kernel-module integrity guarantees while still providing reproducible builds, how his patches implement that, and some ideas for possible further work.

  • LWN ☛ Safe self-referential data structures in kernel Rust [LWN.net]

    Self-referential structures that can be used without unsafe code have posed a problem for Rust for years. There are many cases where a self-referential data structure is the elegant algorithmic choice, but implementing it in accordance with Rust's lifetime rules is all but impossible. At Kangrejos 2026, Gary Guo presented a clever solution to the problem in the context of the kernel's pin_init crate, which helps with the creation of immovable data structures, typically for interoperability with C. Guo's changes could help remove most of the unsafe code related to lifetimes in the Nova driver and, eventually, other Rust components.

  • LWN ☛ Cross-crate forward declarations in Rust [LWN.net]

    Rust has several ad-hoc mechanisms to allow user code to influence how the standard library executes. For example, custom panic handlers and custom allocators both involve registering functions that core standard library code needs to call. With more similar features planned, Jana Dönszelmann spotted the developing pattern and put together a general solution, introducing a safer, checked analogue of C's weak symbol linking. At Kangrejos 2026, she explained how this new language feature works, and proposed using it to clean up the kernel's handling of integer overflows in Rust code.

  • LWN ☛ Recent and future changes to the Linux NFS server [LWN.net]

    The NFS network filesystem protocol has a long history on Unix-like operating systems (and beyond). NFS is still evolving, though, and implementations need to keep up. At the 2026 Linux Plumbers Conference, NFS developer Jeff Layton gave an overview of recent enhancements to the Linux implementation, along with some hints for what will be coming in the near future.

    Layton jumped immediately into a long list of new features added to the NFS server, starting with LOCALIO. While NFS servers are normally on remote computers, there are situations where the client and server can be on the same physical host; this can happen with containerized workloads, for example. There is now a protocol that allows the two sides to determine whether they are on the same host and, if so, bypass most of the protocol handling and route requests directly to the filesystem, improving performance considerably.

  • LWN ☛ Discussing a rewrite of XArray [LWN.net]

    The work to support block sizes larger than the page size on XFS has been difficult. Many users of XFS run stable kernels, which means that they aren't testing new XFS code as it is released. That has made Daniel Gomez wonder whether adopting Rust for some of the data structures underlying XFS, particularly XArrays, could reduce the number of bugs lurking in the code. At Kangrejos 2026, he led a discussion about the potential problems with converting XArray to Rust. The assembled kernel developers had a number of reasons to be cautious about replacing the XArray code, but Gomez was determined to experiment with the possibility, citing both security and performance improvements.

    XFS added support for large folios in December 2021, Gomez said, as part of the general effort across the kernel to move to folios. In June 2023, some users of XFS reported filesystem corruption: pages from some files ended up mixed into other files. The cause turned out to be a bug introduced with the addition of folio support. This bug was present in the kernel for years, Gomez emphasized, and nobody saw it, possibly because users were relying on stable kernels.

• Distributions and Operating Systems

  • LWN ☛ Understanding Nix flakes [LWN.net]

    Nix flakes are an experimental feature of the Nix package-management tool designed to build projects in a more self-contained and reproducible way. Despite the feature's experimental status, it has become increasingly popular for open-source projects to publish flake.nix files that offer predefined development environments and build automation even when those repositories may not offer an upstream package or module for the NixOS Linux distribution. Although Nix flakes have a complicated history, and the path for stabilization is uncertain, flakes can provide useful capabilities for projects that choose to include them.

  • SUSE/OpenSUSE

    • LWN ☛ SUSE's efforts to disable setuid system-wide [LWN.net]

      Setuid (and setgid) binaries have long been a source of headaches, and security vulnerabilities, on Linux systems. They are largely seen as something to be avoided; SUSE's security team, for example, forbids the inclusion of setuid or setgid binaries in packages unless they have been reviewed and explicitly allowed. Thorsten Kukuk wants to go a step further and disallow them entirely. At the 2026 All Systems Go! conference, he spoke about his work to disable setuid system-wide, as well as some of the hurdles that remain.

      I did not attend the All Systems Go! conference this year, but I watched the video of this session after it was published, and followed the slides.