LWN.net Logo

Kernel development

Brief items

Kernel release status

The current development kernel is 2.5.58. Linus seemingly made a New Year's resolution to release kernels more often, with the result that four separate releases came out over the last week:

  • 2.5.58 (announcement, changelog) featured a lot of relatively small, janitorial fixes, along with the IPMI driver, a USB update, some changes to the new generic DMA layer, the "red/black tree" I/O scheduler, more sysfs work, and an RPCSEC_GSS implementation (needed for NFSv4).

  • 2.5.57 (announcement, changelog) had fixes for the information leakage bug in a number of network drivers, a few IDE changes, the low-latency page table teardown patch (covered in last week's LWN Kernel Page), an ISDN update, and a bunch of driver model/sysfs work.

  • 2.5.56 (announcement, changelog) had a bunch of netfilter work, some USB updates, an ACPI update, and a forward port of the 2.4 watchdog driver code.

  • 2.5.55 (announcement, changelog) came with with a number of big architecture updates (PowerPC, ARM, x86-64), some kbuild work, a knfsd update, more module fixes, another set of driver model patches, some device mapper updates, and a number of video4linux tweaks.

Linus's BitKeeper tree, which will likely become 2.5.59 fairly soon, contains some uClinux patches, an XFS update, and some new algorithms for the crypto API.

Note that new development kernel releases will come to a halt by Friday, when Linus takes off for a two-week vacation.

The current stable kernel is still 2.4.20; Marcelo has released no 2.4.21 prepatches over the last week.

The latest patch from Alan Cox is 2.4.21-pre3-ac4, which resumes work on the IDE layer.

Comments (none posted)

Kernel development news

2.6.0-test coming soon?

William Lee Irwin asked the question: will there be a 2.6.0-test release soon? All is working well for him, and it seems maybe time to look toward getting the kernel out to a wider testing audience.

Unfortunately, it does not look like things will happen anywhere near that quickly. From Alan Cox's response:

IDE is all broken still and will take at least another three months to fix - before we get to 'improve'. The entire tty layer locking is terminally broken and nobody has even started fixing it.... Most of the drivers still don't build either.

There are other little issues to deal with as well. For example, the process of feeding 2.4 fixes into 2.5 stalled some time ago, and is only now getting restarted again. Some developments - the driver model work and asynchronous I/O come to mind - are still very much in progress. Al Viro had all kinds of plans for the VFS and initramfs, but seems to have disappeared from the kernel list for now. The loadable module problems are mostly taken care of, but things are still changing there too. And so on.

So the truth of the matter is that the 2.5 kernel is still not stable in a number of ways. The feature freeze is holding reasonably well, but it was always understood that features that had been merged would finish their development - and that has not yet happened. Trying to widen the test community at this point is likely to just turn a lot of people off to 2.5 altogether. Truly stabilizing a kernel takes a long time.

Comments (4 posted)

The latest loadable module changes

Most of the problems with the new module loader have long since been ironed out. A few issues, remain, however. For example, module versions have not yet been implemented; kernel developers tend to dislike (and not use) that feature, so it has been relatively low on the list of priorities. There still is no modversions patch up for review, but a related issue has been resolved.

The modversions facility allows a binary kernel module to be loaded into multiple kernel versions, as long as the relevant data structures and function prototypes have not changed. It works by attaching a simple checksum to function and variable names, and refusing to load a module if the checksums no longer match. See Linux Device Drivers, Chapter 11 for details.

But modversions has never been able to catch all of the things that could make a module incompatible with a given kernel. The most common problem (a module compiled for SMP loaded into a uniprocessor kernel, or vice versa) was handled by hacking "smp" into the checksum. But other potential incompatibilities - compiler versions, memory model (for systems with high memory), whether preemption is configured in, etc. - are not detected until something goes badly wrong.

A patch from Rusty Russell fixes that problem, whether or not modversions is in use. Compilation and configuration options which can break module compatibility are stored in a special section in the kernel and in each loadable module; the information is stored as a simple string like "SMP,preempt,gcc-2.95." If the strings don't match when a module is loaded, the kernel puts out a warning.

One other loadable module issue still hasn't gone away: how to deal with modules which fail at initialization time. The new module loader, when first merged, took great pains to hide a module from the rest of the kernel until it had completed initialization. That way, the kernel could be sure that no other kernel code was already trying to use the module if its initialization fails and it is removed from the kernel. Unfortunately, that feature broke the disk subsystem, which wants to read partition tables from disks when the disks are registered. That read would fail, because the module which actually implemented disk reads was not yet available, and the partitions would fail to show up in the system. To get around this problem, the module code was changed to make modules visible during the initialization process.

That change fixed the disk problems, but it also brought back the old race condition: a module can be removed while the kernel is trying to use it. It is clearly an uncommon situation, but Rusty worries about things like this. So he has posted a new patch to address the problem. With this patch, modules are again invisible until they are properly initialized. Should there be a need to provide access to a particular module while initialization is still in progress, a call to the new module_make_live() function will make that possible. The add_disk() function calls module_make_live() itself, so there is no need to change any drivers to keep disks working. There is also a new notifier chain for any part of the kernel that wants to know when modules come online.

Some developers will likely see the new approach as another unnecessary fix for a problem which never happens in the real world. It is, however, a small change which closes off a set of possible failures, and is thus worth consideration.

Comments (none posted)

Patches and updates

Kernel trees

Core kernel code

Development tools

Device drivers

Documentation

Filesystems and block I/O

Janitorial

Memory management

Architecture-specific

Security-related

Miscellaneous

Page editor: Jonathan Corbet
Next page: Distributions>>

Copyright © 2003, Eklektix, Inc.
Comments and public postings are copyrighted by their creators.
Linux is a registered trademark of Linus Torvalds