Post Syndicated from daroc original https://lwn.net/Articles/1082642/

Security updates have been issued by Debian (chromium, libxfont, mesa, opam, and wireless-regdb), Fedora (acl, attr, chromium, cjson, composer, docker-compose, jfrog-cli, librabbitmq, libssh2, libXfont2, log4cxx, OpenImageIO, openssh, p11-kit, perl-Crypt-DSA, perl-HTML-Gumbo, prometheus, python-dulwich, python-idna, python-pillow, python-tornado, sssd, tmux, upower, webkitgtk, xorg-x11-server, and xorg-x11-server-Xwayland), Mageia (libarchive and vim), Oracle (389-ds:1.4, buildah, cups, edk2, freerdp, golang, grafana, gstreamer1-plugins-bad-free, gstreamer1-plugins-good, gstreamer1-plugins-ugly-free, kernel, libexif, libsolv, libtasn1, libxml2, nginx:1.24, nginx:1.26, nodejs:22, nodejs:24, oci-seccomp-bpf-hook, podman, postgresql:18, python-urllib3, tigervnc, tomcat, unbound, and xorg-x11-server), Slackware (p11-kit), and SUSE (agama, dash, dracut, flannel, go1.26, gsasl, gstreamer-plugins-good, ImageMagick, imagemagick, kernel, krb5, krb5, krb5-mini, libIex-3_4-33, libmbedtls23, libxfont2, nasm, nghttp2, perl-CGI-Session, perl-dbi, perl-List-SomeUtils-XS, python-pillow, python-social-auth-app-django, python-urllib3, python313-Django4, python313-Django6, python313-pytest-html, python313-sqlparse, python313-websockets, rclone, rust-keylime, rustup, sccache, spectre-meltdown-checker, sssd, terraform-provider-aws, terraform-provider-azurerm, terraform-provider-external, terraform-provider-google, terraform-provider-helm, terraform-provider-kubernetes, terraform-provid, thunderbird, tiff, traefik2, xorg-x11-server, and xwayland).

Post Syndicated from daroc original https://lwn.net/Articles/1080519/

QBE, a compact compiler backend developed by Quentin Carbonneaux, is a
lightweight alternative to larger compiler backends such as LLVM and GCC.
Designed to be small enough for a single developer to understand, QBE uses a

static single-assignment (SSA) intermediate representation (IR), supports the C ABI,
and serves as the backend for projects such as Hare and
the cproc C11 compiler. Frontends
emit the textual form of QBE’s IR directly; QBE then takes care of register allocation,
optimization, and native-code generation, producing assembly for the target
architecture.

Post Syndicated from daroc original https://lwn.net/Articles/1081009/

Puranjay Mohan shared some of the

work he’s been doing recently on improving the
performance of read-copy-update (RCU) at the 2026

Linux
Storage, Filesystem, Memory-Management, and BPF Summit; his talk would have
been nice context to have earlier in the day when Harry Yoo and Alexei
Starovoitov led a session about the

new kmalloc_nolock() function that
allows for lockless allocation from any kernel context, and which interacts with
the RCU subsystem to allow that. This article therefore covers the two sessions
together and in the reverse order, to provide that missing context.

Post Syndicated from daroc original https://lwn.net/Articles/1078968/

When a BPF program is used to filter or redirect packets in the networking
subsystem, the program will often want to associate data with each packet as it
moves through the kernel. The kernel’s

local BPF storage API, which
associates extra data with some kernel objects, provides a way to do that. (See also
the BPF map types that end
in STORAGE.)
Amery Hung and Jakub Sitnicki led two sessions
at the 2026

Linux Storage, Filesystem, Memory-Management, and BPF Summit
about how to make accesses to local storage data more efficient. Hung spoke
about general performance problems related to locking, while Sitnicki examined
the use of local storage in the networking subsystem in particular.

Post Syndicated from daroc original https://lwn.net/Articles/1079001/

Lisp-like languages have historically led the world in metaprogramming and
flexibility. While many modern languages have adopted the idea of macros,
Lisp-like languages such as

Racket have continued pushing the envelope,
attempting to make macros as easy as possible to incorporate into everyday
programs. On the other hand, Lisp’s minimal, parenthesis-based syntax can be hard
to adapt to — to the point that Lisp is sometimes said to stand
for “Lots of Irritating Silly Parentheses”.

Rhombus is a new programming
language that aims to have the best of both worlds, marrying Racket’s
metaprogramming capabilities to a simple Python-like syntax and reasonable
standard-library defaults.

Post Syndicated from daroc original https://lwn.net/Articles/1078526/

BPF arenas are areas of memory (potentially shared with user space)
where programs have free reign to build their
own data structures, unburdened by the verifier’s bounds checks. Many of those
data structures are potentially usable in multiple programs. Emil Tsalapatis
brought his work on libarena, a library containing generic utilities for use in
BPF arenas, to the 2026

Linux Storage, Filesystem, Memory-Management, and BPF
Summit. Although the library is already available as part of the kernel, it
is still in its early stages and he has more work planned.

Post Syndicated from daroc original https://lwn.net/Articles/1077740/

Alexis Lothoré has been working to add support for the kernel’s memory-access
checker,

KASAN, to just-in-time-compiled BPF code. He spoke about that work at
the 2026

Linux Storage, Filesystem, Memory-Management, and BPF Summit.
KASAN support is needed, he said, to help catch bugs in the BPF just-in-time (JIT)
compiler. KASAN is a great tool for catching memory-management problems in the
kernel, but only in code that can be monitored by it.

Post Syndicated from daroc original https://lwn.net/Articles/1076210/

BPF programs can be used to extend many aspects the Linux kernel, but
BPF programs must run to completion in the same context that they began.
Kumar Kartikeya Dwivedi is working on changing that by
allowing BPF programs to be expressed as coroutines. He spoke about his work at
the 2026

Linux Storage, Filesystem, Memory-Management and BPF Summit. While
still experimental, the change promises to make long-running BPF tasks
significantly easier to write.

Post Syndicated from daroc original https://lwn.net/Articles/1074291/

How can cloud providers efficiently supply durable virtual block devices? Remote
Direct Memory Access (RDMA) provides a way for servers in a cluster to share
chunks of memory, but there still needs to be a protocol that operates on top of
RDMA to provide the guarantees expected of a block device. The kernel’s RDMA transport
library (RTRS) provides a way to send messages via RDMA. I
presented about two
new components built on top of RTRS at the 2026
Linux
Storage, Filesystem, Memory Management and BPF Summit: Reliable Multicast
over RTRS (RMR) and Block device over RMR (BRMR). These modules, which I
am working on with Jia Li, could be a way for cloud providers to
expose durable block devices with as little overhead as possible. To accomplish
that, however, we need some discussion and feedback from the community before
sending the modules upstream.

Post Syndicated from daroc original https://lwn.net/Articles/1076121/

The BPF verifier has, in the course of wrestling with the difficult problem of
statically analyzing loops, grown special support for many kinds of loops over its
history, but its fundamental approach to simple for loops has not
changed.
When it encounters a loop, it evaluates it, iteration by iteration, until reaching
an exit condition — a process that can cause the verifier to mistakenly hit the
limit on the number of allowed instructions where a better implementation
would not.
Eduard Zingerman
spoke at the 2026

Linux Storage, Filesystem, Memory-Management, and BPF Summit
about his in-progress work on improving the verifier’s treatment of loops, especially nested
loops.

Post Syndicated from daroc original https://lwn.net/Articles/1075067/

Alexei Starovoitov gave “less of a presentation, more of a scream of
realization” at the BPF track of the 2026

Linux Storage, Filesystem,
Memory-Management, and BPF Summit. He shared a set of ideas for how BPF could
change to avoid being swept away by the sea-change in programming represented by modern
large language models (LLMs) and the coding agents based on them.
In a follow-up session, the discussion covered
more problems with how coding agents use tools like bpftrace, and the current deluge of
patches in need of review in the BPF subsystem.

Post Syndicated from daroc original https://lwn.net/Articles/1073762/

Optimizing compilers can, under some circumstances, infer when a parameter to a
function is not needed, and remove it. This is all well and good until the
kernel’s tracing or BPF subsystems need information on how to call the function
or where its arguments are stored.
Alan Maguire and Yonghong Song spoke at the 2026

Linux
Storage, Filesystem, Memory-Management, and BPF Summit about their work on
recording information regarding changed function signatures in the kernel’s BTF debugging
information, to better support tracing such functions.

Post Syndicated from daroc original https://lwn.net/Articles/1070218/

MeshCore is a relatively new project, started in January 2025, that aims
to build a scalable mesh network using low-power long-distance radios. While
many other projects of the same general nature have been tried before, MeshCore
grew quickly because of its more efficient message routing and enthusiastic
community. In early 2026, an early proponent of the project made a sudden shift
that left the rest of the community stunned and embroiled in a trademark dispute.

Post Syndicated from daroc original https://lwn.net/Articles/1071973/

José Marchesi and the GCC-BPF developers opened the BPF track at the 2026

Linux Storage,
Filesystem, Memory-management, and BPF Summit
with a 90-minute summary of what has changed for GCC’s BPF support in the past year.
This kind of session has become something of a tradition. There were similar
updates in

2025 and

2024. This time around, GCC seems to be closing in on
feature parity with the LLVM toolchain — as the slides detail.

Post Syndicated from daroc original https://lwn.net/Articles/1069954/

A recent

patch set from Steffen Eiden and others has set the groundwork for allowing
hardware-assisted emulation of Arm CPUs on s390 CPUs.

Version two of the posting fixes a handful of smaller problems, but does not
differ much.
The patches were welcomed
by the Arm maintainers, pending some discussion of how the collaboration between the
architectures could be structured to prevent maintainability problems on the Arm
side. When those details are resolved, the patches could pave the way for
transparently running Arm-based virtual machines (VMs) on s390 hosts at native or
near-native speeds.

Post Syndicated from daroc original https://lwn.net/Articles/1068864/

Modern database and filesystems make pervasive use of

B-trees, which are tree
structures optimized for storing sorted lists of keys and values on block
devices.

Dolt is an Apache 2.0-licensed project that makes clever use of a
variant of a B-tree to support efficient version control for an entire database.
The data structure it uses could well be of interest to other projects.

Post Syndicated from daroc original https://lwn.net/Articles/1070454/

Security analysis firm Xint has disclosed a security bug in the Linux kernel
that allows for arbitrary 4-byte writes to the page cache, and which has been
present since 2017.
The vulnerability has

been fixed in mainline kernels. A
proof-of-concept script demonstrates how to use the flaw to corrupt a setuid
binary, which works on
multiple distributions, by requesting an AEAD-encrypted socket from user space
and splicing a particular payload into it.
A supplemental blog
post gives more details about the discovery and remediation.

A core primitive underlying this bug is splice(): it transfers data between file
descriptors and pipes without copying, passing page cache pages by reference.
When a user splices a file into a pipe and then into an AF_ALG socket, the
socket’s input scatterlist holds direct references to the kernel’s cached pages
of that file. The pages are not duplicated; the scatterlist entries point at the
same physical pages that back every read(), mmap(), and
execve() of that file.

Post Syndicated from daroc original https://lwn.net/Articles/1068409/

Version 0.16.0 of the Zig programming language was

recently announced, and with
it an expanded version of the new Io interface that we

covered in December.
The new interface is based on an idea called structured concurrency that makes writing
correct concurrent applications easier. Zig’s implementation of
the idea is more explicit and verbose than other languages, however, which could
offer an opportunity to explore the consequences of different designs.

Post Syndicated from daroc original https://lwn.net/Articles/1067220/

In Rust, types either possess a constant size known at compile time, or a
dynamically calculated size known at
run time. That is fine for most purposes, but recent proposals for the language
have shown the need for a more fine-grained hierarchy.

RFC 3729 from David Wood and Rémy Rakic would add a hierarchy of
traits to describe types with sizes known under different circumstances. While
the idea has been subject to discussion for many years, a growing number of
use cases for the feature have come to light.

Post Syndicated from daroc original https://lwn.net/Articles/1066156/

Shor’s algorithm is the main practical example of an algorithm that runs more
quickly on a quantum computer than a classical computer — at least in theory.
Shor’s algorithm allows large numbers to be factored
into their component prime factors quickly.
In reality, existing quantum computers do not have nearly
enough memory to factor interesting numbers using Shor’s algorithm, despite
decades of research.
A new paper provides a major step
in that direction, however. While still impractical on today’s quantum
computers, the recent discovery
cuts the amount of memory needed to attack 256-bit elliptic-curve cryptography
by a factor of 20. More interesting, however, is that the researchers chose to
publish a zero-knowledge proof demonstrating that they know a quantum circuit
that shows these improvements, rather than publishing the actual
knowledge of how to do it.