Udev rules and the management of the plumbing layer
For a little while, it seemed like that something might be devfs, but that story did not end well. The real solution to the /dev mess turned out to be a tool called "udev," originally written by Greg Kroah-Hartman. Udev would respond to device addition and removal events from the kernel, creating and removing special files in /dev. Over time, udev gained more powerful features, such as the ability to run external programs which would help to create persistent names for transient devices. Udev is now a key component in almost all Linux systems. It's like the plumbing in a house; most people never notice it until it breaks. Then they realize how important a component it really is.
Udev is configured via a set of rules, found under /etc/udev/rules.d on most systems. These rules specify how devices should be named, what their ownership and permissions should be, which kernel modules should be loaded, which programs should be run, and so on. The udev rule set also allows distributors and system administrators to tweak the system's device-related behavior to match local needs and taste.
Or maybe not. Udev maintainer Kay Sievers has recently let it be known that he would like all distributors to be using the set of udev rules shipped with the program itself. Says Kay:
This request was surprising to some. A Linux system is full of utilities with configuration files under /etc; there is not normally a push for all distributions to use the same ones. So why should all distributors use the same udev rules? The reasoning here would appear to come down to these points:
- The udev rules files are not really configuration files - they are,
instead, code written in a domain-specific language. For a
distributor to change those files is akin to patching the underlying C
code; far from unheard of, but generally seen as being undesirable.
As a way of underscoring this point, the udev developers are moving
the udev rules out of /etc and into /lib.
- There is little reason for distributors to differentiate themselves
based on their device naming schemes, and every reason to have all
Linux systems use the same device names. For the situations where
reasonable distributions may still differ - which group should own a
device, for example - there is a mechanism to add distributor-specific
rules.
- Increasingly, other packages will depend on a specific udev setup for the underlying system. Distributors which use their own rules will have a harder time making these new tools work right.
That last point refers, in particular, to DeviceKit, a set of tools designed to make the management of devices easier. Between them, udev and DeviceKit are being positioned to replace most of the functionality in the much-maligned hal utility. See this posting from David Zeuthen for lots more information on DeviceKit and the migration away from hal in general.
The only problem is that some distributors aren't playing along. Marco
d'Itri, the Debian udev maintainer, responded that a common set of udev rules is
"not going to happen." The default rules, he says, do not meet Debian's
need to support older kernels, and, besides, "I consider my rules
much more readable and elegant than yours
". Ubuntu maintainer Scott
James Remnant is also reluctant to use the
default rules.
Scott appears to be willing to consider a change to the default rules if it can be made to work right; Marco, instead, seems determined to hold out. When encouraged to send patches to improve the default rules (and make them more elegant), he responded:
It appears likely that most of the distributors will come to see the udev rules as code which is to be maintained upstream; even Debian may come along eventually. As this happens, the layer of "plumbing" which sits just on top of the kernel should be worked into better shape. Kernel developers may find themselves involved in this process; David has posted a proposal that all new kernel subsystems, before being merged, must be provided with a set of udev rules. That would help the udev developers get a set of default rules into shape before the distributors feel the need to step in to make things work.
Increasingly, the operation of the kernel is being tied to a set of
low-level user-space applications; there is not much which can be done with
a bare kernel. How all of this low-level plumbing should work, and how it
should interoperate with the kernel, is still being worked out. The
management of udev
policies is just one of the outstanding issues. So the
upcoming Linux Plumbers
Conference would seem to be well timed; there's a lot to talk about.
