All posts by corbet

[$] Sub-schedulers for sched_ext

Post Syndicated from corbet original https://lwn.net/Articles/1056014/

The extensible scheduler class (sched_ext)
allows the installation of a custom CPU scheduler built as a set of BPF
programs. Its merging for the 6.12 kernel release moved the kernel away
from the “one scheduler fits all” approach that had been taken until then;
now any system can have its own scheduler optimized for its workloads.
Within any given machine, though, it’s still “one scheduler fits all”; only
one scheduler can be loaded for the system as a whole. The sched_ext
sub-scheduler patch series from Tejun Heo aims to change that situation
by allowing multiple CPU schedulers to run on a single system.

Security updates for Thursday

Post Syndicated from corbet original https://lwn.net/Articles/1056544/

Security updates have been issued by AlmaLinux (java-25-openjdk, openssl, and python3.9), Debian (gimp, libmatio, pyasn1, and python-django), Fedora (perl-HarfBuzz-Shaper, python-tinycss2, and weasyprint), Mageia (glib2.0), Oracle (curl, fence-agents, gcc-toolset-15-binutils, glibc, grafana, java-1.8.0-openjdk, kernel, mariadb, osbuild-composer, perl, php:8.2, python-urllib3, python3.11, python3.11-urllib3, python3.12, and python3.12-urllib3), SUSE (alloy, avahi, bind, buildah, busybox, container-suseconnect, coredns, gdk-pixbuf, gimp, go1.24, go1.24-openssl, go1.25, helm, kernel, kubernetes, libheif, libpcap, libpng16, openjpeg2, openssl-1_0_0, openssl-1_1, openssl-3, php8, python-jaraco.context, python-marshmallow, python-pyasn1, python-urllib3, python-virtualenv, python311, python313, rabbitmq-server, xen, zli, and zot-registry), and Ubuntu (containerd, containerd-app and wlc).

PC Gamer on the scx_horoscope scheduler

Post Syndicated from corbet original https://lwn.net/Articles/1056354/

PC Gamer has run an
amusing review of the scx_horoscope
scheduler for Linux, which uses astrology to optimize scheduling
decisions.

The scheduler is full of bizarre features, like its ability to
perform real planetary calculations based on accurate geocentric
planetary positions, lunar phase scheduling (the full moon gives a
1.4x boost to tasking, apparently) and “zodiac-based task
classification”.

That latter feature is easily one of my favourite bits. Specific
planetary bodies “rule” over specific system tasks, so the Sun is
in charge of critical system processes, the Moon (tied to emotions,
of course) rules over interactive tasks, and Jupiter is assigned to
memory-heavy applications, among others.

A critical GnuPG security update

Post Syndicated from corbet original https://lwn.net/Articles/1056209/

There is a new GnuPG update for a “critical security bug” in recent
GnuPG releases.

A crafted CMS (S/MIME) EnvelopedData message carrying an oversized
wrapped session key can cause a stack buffer overflow in gpg-agent
during the PKDECRYPT–kem=CMS handling. This can easily be used
for a DoS but, worse, the memory corruption can very likley also be
used to mount a remote code execution attack. The bug was
introduced while changing an internal API to the FIPS required KEM
API.

Only versions 2.5.13 through 2.5.16 are affected.

The GNU C Library is moving from Sourceware

Post Syndicated from corbet original https://lwn.net/Articles/1056206/

GNU C Library maintainer Carlos O’Donell has announced
that the project will be moving its core services away from Sourceware in favor of services hosted
at the Linux Foundation.

While it was clear to the GNU Toolchain leadership that
requirements were coming to improve the toolchain cyber-security
posture, these requirements were not clear to all project
developers. As part of receiving this feedback we have worked to
document and define a secure development policy for glibc and at a
higher level the GNU Toolchain. While Sourceware has started
making some critical technical changes, the GNU Toolchain still
faces serious, systemic concerns about securing a global, highly
available service and building a sustainable, diverse sponsorship
model.

This has been a long-running discussion; see this 2022 article for some background.

[$] Implicit arguments for BPF kfuncs

Post Syndicated from corbet original https://lwn.net/Articles/1055559/

The kernel’s “kfunc” mechanism is a way of exporting kernel functions so
that they can be called directly from BPF programs. There are over 300
kfuncs in current kernels, ranging in functionality from string processing
(bpf_strnlen())
to custom schedulers (scx_bpf_kick_cpu())
and beyond. Sometimes these kfuncs need access to context information that
is not directly available to BPF programs, and which thus cannot be passed
in as arguments. The implicit
arguments patch set from Ihor Solodrai is the latest attempt to solve
this problem.

Kernel prepatch 6.19-rc7

Post Syndicated from corbet original https://lwn.net/Articles/1055796/

The 6.19-rc7 kernel prepatch is out for
testing.

So normally this would be the last rc of the release, but as I’ve
mentioned every rc (because I really want people to be aware and be
able to plan for things) this release we’ll have an rc8 due to the
holiday season.

And while some of the early rc’s were smaller than usual and it
didn’t seem necessary, right now I’m quite happy I made that
call. Not because there’s anything particularly scary here – the
release seems to be going fairly smoothly – but because this rc7
really is larger than things normally are and should be at this
point.


Along with the usual fixes, this -rc also includes a new
document describing the process to replace the kernel project
leadership should that become necessary in the absence of an arranged
transition. The plan largely follows what was decided at the Maintainers Summit in December.

[$] Filesystem medley: EROFS, NTFS, and XFS

Post Syndicated from corbet original https://lwn.net/Articles/1055062/

Filesystems seem to be one of those many areas where the problems are well
understood, but there is always somebody working toward a better solution.
As a result, filesystem development in the Linux kernel continues at a fast
pace even after all these years. In recent news, the EROFS filesystem is
on the path to gain a useful page-cache-sharing feature, there is a new
NTFS implementation on the horizon, and XFS may be about to get an
infrastructure for self healing.

Ryabitsev: Tracking kernel development with korgalore

Post Syndicated from corbet original https://lwn.net/Articles/1055219/

Konstantin Ryabitsev has put up a
blog post about korgalore, a tool he has written to circumvent delivery
problems experienced by kernel developers using the large, centralized
email systems.

We cannot fix email delivery, but we can sidestep it
entirely. Public-inbox archives like lore.kernel.org store all
mailing list traffic in git repositories. In its simplest
configuration, korgalore can shallow-clone these repositories
directly and upload any new messages straight to your mailbox using
the provider’s API.

Remote authentication bypass in telnetd

Post Syndicated from corbet original https://lwn.net/Articles/1055213/

One would assume that most LWN readers stopped running network-accessible
telnet services some number of decades ago. For the rest of you, this security advisory from
Simon Josefsson is worthy of note:

The telnetd server invokes /usr/bin/login (normally running as
root) passing the value of the USER environment variable received
from the client as the last parameter.

If the client supplies a carefully crafted USER environment value
being the string “-f root”, and passes the telnet(1) -a or –login
parameter to send this USER environment to the server, the client
will be automatically logged in as root bypassing normal
authentication processes.

The end of OzLabs

Post Syndicated from corbet original https://lwn.net/Articles/1055051/

OzLabs is a collection of Australian
free-software developers that was, for most of its history, associated with
IBM. Members of OzLabs have included Hugh Blemings, Michael Ellerman, Ben
Herrenschmidt, Greg Lehey, Paul Mackerras, Martin Pool, Stephen Rothwell,
Rusty Russell, and Andrew Tridgell, among others. The OzLabs “about” page notes that, as
of January 2026, the last remaining OzLabs members have departed IBM.
“This brought to a close the Ozlabs association with IBM“. Thus
ends a quarter-century of development history.

(Thanks to Jon Masters).

[$] Task-level io_uring restrictions

Post Syndicated from corbet original https://lwn.net/Articles/1054225/

The io_uring
subsystem is more than an asynchronous I/O interface for Linux; it is,
for all practical purposes, an independent system-call API. It has enabled
high-performance applications, but it also brings challenges for code built
around classic, Unix-style system calls. For example, the seccomp()
sandboxing mechanism does not work with it, causing applications using
seccomp() to disable io_uring outright. Io_uring maintainer Jens
Axboe is seeking to improve that situation with a rapidly evolving patch
series adding a new restrictive mechanism to that subsystem.

A 0-click exploit chain for the Pixel 9 (Project Zero)

Post Syndicated from corbet original https://lwn.net/Articles/1054547/

The Project Zero blog has a
three-part series describing a working, zero-click exploit for
Pixel 9 devices.

Over the past few years, several AI-powered features have been
added to mobile phones that allow users to better search and
understand their messages. One effect of this change is increased
0-click attack surface, as efficient analysis often requires
message media to be decoded before the message is opened by the
user. One such feature is audio transcription. Incoming SMS and RCS
audio attachments received by Google Messages are now automatically
decoded with no user interaction. As a result, audio decoders are
now in the 0-click attack surface of most Android phones.

The blog entry does not question the wisdom of directly exposing audio
decoders to external attackers, but it does provide a lot of detail showing
how it can go wrong. The first part looks at compromising the codec; part
two extends the exploit to the kernel, and part
three looks at the implications:

It is alarming that it took 139 days for a vulnerability
exploitable in a 0-click context to get patched on any Android
device, and it took Pixel 54 days longer. The vulnerability was
public for 82 days before it was patched by Pixel.

[$] Removing a pointer dereference from slab allocations

Post Syndicated from corbet original https://lwn.net/Articles/1053870/

Al Viro does not often stray outside of the core virtual filesystem area;
when he does, it is usually worthy of note. Recently, he wandered into
memory management with this patch
series to the slab allocator and some of its users. Kernel developers
will often put considerable effort into small optimizations, but it is
still interesting to look at just how much effort has gone toward the purpose of
avoiding a single pointer dereference in some memory-allocation hot paths.