Latest

Technology

Linux 7.4-rc1 closes the largest merge window in its history

Linux 7.4-rc1 is now out after the largest merge window on record. What's in it, who cares, and when it will reach your distribution.

Linux 7.4-rc1 closes the largest merge window in its history
Linux 7.4-rc1 closes the largest merge window in its history

The busiest Linux development cycle in memory now has its first release candidate. Linux 7.4-rc1 shipped this week after a merge window that the subsystem maintainers themselves described as the largest in the project's history, with more than 6,700 changes merged in two weeks. That volume does not come from cosmetic polish: it comes from work built up in memory, networking, virtualization and emerging architectures.

For anyone who does not follow the kernel's pace, the translation is simple. When the merge window grows like this, the next release touches more than usual and the stabilization period matters more. The initial count for the window, with 6,753 changes merged, is in the merge window tracking. The weekly RCs exist for that, and the first one is the one that shows what has broken.

The interest in this release is spread out. There are performance improvements you notice on the desktop, such as large writes in ext4 and direct EFI boot with systemd support. There are others that only matter on servers, such as PML support for EPYC Zen 6 in KVM. And there is a third category that anticipates where hardware is heading: RISC-V and ARM are gaining ground in places where previously there was only x86. The question most often repeated in the forums is when it will reach each person's distribution. The short answer is that the final release does not yet have a firm date and that each distribution then decides whether to adopt it whole or in pieces. The useful answer lies in the detail of what goes in and what stays out.

RISC-V stops being a promise

The most discussed change is the 11% performance increase on RISC-V thanks to an unaligned access runtime that avoids the traps the processor previously generated. Twelve percentage points do not sound like a revolution, but on an architecture competing to get into servers and devices, every point counts.

The technical detail is interesting because it tackles a classic problem of new architectures. When software accesses an unaligned memory address, some processors resolve it in hardware and others raise an exception. RISC-V belongs to the second group, and the kernel has to emulate the access. That slow path is what the new runtime avoids in most cases.

For a home user this changes nothing today. For anyone evaluating RISC-V boards for a small server or an industrial device, the difference between having to emulate and not having to can be the one that decides whether performance is acceptable. The rest of the work in the unaligned access runtime for RISC-V completes an improvement that had been two cycles in the making.

ext4 gets its act together on large writes

The ext4 improvements with iomap tackle one of the weak points of the most widely used file system on Linux: large block writes, which until now went through paths inherited from the original design. The work does not change the on-disk format or break compatibility, so an updated machine can benefit without migrating anything.

On a laptop with an SSD, the difference shows when copying files of several gigabytes, when unpacking system images or when exporting video. On servers with a high volume of sequential writes, the impact is greater because the bottleneck was precisely in how operations were grouped. The details of the change in the ext4 write path explain why the on-disk format does not change and performance does.

There is a warning worth giving. Changes to the write path are delicate and the first RCs usually receive fixes in this area. If your server relies on ext4 for critical data, the opportunity to test is in the RCs and the time for production is the stable release.

Virtualization, networking and the rest of the package

Two distinct blocks go into KVM. On the one hand, PML support for AMD's upcoming EPYC Zen 6, which reduces the cost of modified pages in virtual machines with a lot of memory. On the other, ARM64 support on s390, a combination that sounds exotic and makes sense in test environments and in migrating workloads between architectures.

The networking part adds hardware rate control offload, a feature that delegates to the card the task of spacing out packets. On servers with constant traffic and large queues, that frees up CPU and improves latency with less manual tuning. For anyone administering proxies or load balancers on Linux, it is one of the improvements that justify trying the release.

Direct EFI boot with systemd support completes the visible package. The idea is to reduce dependence on intermediate boot managers on modern machines, with a shorter path between the firmware and the kernel. There are still manufacturers that resist and configurations that do not support it, so it is worth trying on a lab machine. The detail of how direct EFI boot with systemd turns out clarifies which configurations benefit from day one.

Rust, perf and the invisible work

The performance tools written in Python for `perf` arrive faster and more robust, a change that affects anyone who analyzes bottlenecks daily. It is not a feature you see on the cover of the release notes, but it is one that saves minutes every time a process has to be profiled.

The work on Rust continues without surprises. Each release integrates more drivers and more modules written in a language with memory guarantees, and each one leaves the feeling that the change is deeper than it is loud. Coexistence with C holds and will continue to do so for years.

Linus Torvalds, for his part, removed dangerous kernel functions in this window, a pattern that has been repeated in recent cycles. Cleaning up interfaces with potential for abuse is less visible than a new file system, but it explains why the kernel accumulates less debt than its size would suggest.

When will you see it in your distribution?

RC1 opens a cycle of between six and eight weeks with weekly candidates and a final release that usually lands at the end of the year or the beginning of the next. That date is an estimate based on the historical pace, not a commitment from the project.

From there, each distribution decides. Arch and openSUSE Tumbleweed usually adopt the stable release within weeks. Fedora does so in its next cycle, and Ubuntu packages it with its April and October schedule. Enterprise distributions wait much longer, because their model requires months of validation before moving the system base.

The practical recommendation is the usual one, with a nuance. If your hardware is recent and you have graphics or wireless driver problems, the improvements in the new kernel may be the solution. If your machine works, the update brings nothing that justifies the risk in production.

What this cycle says about the kernel

A project that has been going for more than three decades and is still signing its largest merge window is not aging, but neither is it growing for the sake of it. Most of that volume comes from supporting hardware that did not exist before and from paying off technical debt accumulated in subsystems that were designed for much simpler machines.

The weekly RCs are the best thermometer for that tension. Four releases to stabilize an enormous window, with thousands of people testing in parallel and a handful of maintainers deciding what goes in and what waits for the next cycle. It is a model that works at a scale no company has replicated.

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading