Brief items
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
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)
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>>