United States (change)
Shortcuts: Downloads Fedora Red Hat Network
Issue #2 December 2004
As more and more users become aware of the many advantages Linux has over other operating system such as security and flexibility, its ease of use must be improved to increase its adoption rate. One significant improvement is the introduction of udev. udev allows a Linux system to use consistent device names for devices such as removable drives and printers, which in turn allows users to experience predictable behavior when devices are added or removed from the system.
Starting with Fedora Core 3 and the upcoming release of Red Hat Enterprise
Linux 4, all system device nodes in the /dev
directory are managed by the udev program. In all previous Red Hat
releases, the /dev directory was a static list of all
possible devices that might be connected to the system. This meant that
there were over 18,000 different device nodes in that directory. Now,
with udev, only the devices that are present and available to use in the
system appear in the /dev directory.
udev manages the /dev directory by monitoring the
/sys directory. The /sys
directory is where the sysfs file system is mounted.
Through the information present in sysfs, udev knows what devices need to
have a /dev entry created and what to name the entry.
udev has different configuration files to control how it
works and how it creates the different /dev nodes. There are three
basic types of udev configuration files: the main udev configuration
file, udev permission files, and udev rules files.
The main udev configuration file, /etc/udev/udev.conf,
controls what directory contains the udev permission and rules files, where to
put the udev database, and where udev creates the device nodes. Example 1, “udev.conf Example” shows an example udev.conf
file.
# /etc/udev/udev.conf: main config file for udev # # This file can be used to override some of udev's default values # for where it looks for files, and where it places device nodes. # udev_root - where in the filesystem to place the device nodes udev_root="/dev/" # udev_db - The name and location of the udev database. # NOTE: this should be somewhere that is writable before # / is mounted rw, like /dev ... udev_db="/dev/.udevdb" # udev_rules - The name and location of the udev rules file udev_rules="/etc/udev/rules.d/" # udev_permissions - The name and location of the udev permission file udev_permissions="/etc/udev/permissions.d/" # default_mode - set the default mode for all nodes that have no # explicit match in the permissions file # NOTE: do not set to anything else if you are not # sure you have everything needed for normal # user to function in the permissions file! default_mode="0660" # udev_log - set to "yes" if you want logging udev_log="no"
udev.conf Exampleudev permission files specify what the permissions should be set to for specific device nodes. For details on how this file can be modified, refer to the udev documentation. For almost all users, the default permissions that Red Hat has specified are adequate.
udev rules files are used by udev to determine the device names used for devices present in the system. Every line in the rules files defines how a specific device attribute is mapped to a device file. If all keys that are specified in a rule match the device that was found, the specified device file is created.
The default udev rule file in Fedora Core 3 and Red Hat Enterprise Linux 4 is
located at /etc/udev/rules.d/50-udev.rules. This file
should not be modified by a user. To create new rules, create a new file in the
/etc/udev/rules.d/ directory. All rules files must have a
filename that ends with the .rules extension. Files are
read in sorted order, so to use a custom rule, create a file for it that is read
before the default rules files, such as
/etc/udev/rules.d/10-my.rules.
The basic form of a udev rule is
key, [key, ...] name [, symlink]
Every key is a field that must match with the specific device. These fields are
specified in the form of type=value. The
different types of fields are:
usb, scsi, and
ide.
hda, ttyUSB0, and
lp0.
BUS value but can sometimes be different.
Examples of this are usb and
scsi.
orinoco and
usb-storage.
If all of the specified keys are valid in a rule, then the following values are used to specify what udev does with the device:
Now that all of the different ways a rule can be written have been described, let us look at some sample rules to better understand how to put the different fields together.
A simple rule to create the device node for the CPU microcode driver might look like:
KERNEL="microcode", NAME="cpu/microcode"
This rule is valid if the kernel name is
microcode. If so, it creates the device node
cpu/microcode putting the device node in a separate
subdirectory.
Another simple rule is the one to match up the sound control device:
KERNEL="controlC[0-9]*", NAME="snd/%k"
This rule matches any device that starts with
controlC, followed by a single digit which is
then followed by any number of characters. This type of rule uses a simple form
of a regular expression to match the name of the device. Refer to the udev
man page for more details on how to specify a regular expression that udev
understands. The NAME field for this rules specifies that it should be placed
in the snd subdirectory and use the kernel
name. The %k directory name is replaced with
the kernel name. For the full list of modifier types that udev supports,
consult the udev man page.
Now for a more advanced rule. Most digital cameras are USB devices and
use the usb-storage kernel driver to talk to the
system. To always name a specific digital camera the same
device node no matter when it is plugged into the computer, use the
following rule:
BUS="scsi", SYSFS{vendor}="FUJIFILM", NAME="camera"
This rule states that if the BUS value is scsi and
the sysfs file vendor in the device directory
contains the value FUJIFILM, than the device name
should be set to camera.
Using the SYSFS{filename} type of key, we can solve a common problem for anyone who has more than one USB printers. Depending on the order in which the printers are plugged into the computer or on the order in which they power on when rebooting the computer, they could get different device nodes every other time. This makes determining which printer is connected to which printer queue quite difficult at times. If we can specify a way for a printer to always have the same name, no matter which order in which it was plugged in, that would solve the problem.
Here are two rules that users can use to always bind a specific printer to a specific name:
BUS="usb", SYSFS{serial}="W09090207101241330", NAME="lp_color"
BUS="usb", SYSFS{serial}="HXOLL0012202323480", NAME="lp_bw"
These rules cause the printer with the serial number
W09090207101241330 to be always accessed
through the device node lp_color and the
printer with the serial number
HXOLL0012202323480 always accessed
through the device node lp_bw. These
serial numbers can be found in sysfs in the directory for the usb device,
as described in the section called “Writing New Rule”.
The previous examples demonstrate simple rules, but how does the user know what
fields are best to use to specify within a rule to uniquely identify the device?
Using the program udevinfo that comes bundled with the udev
program, a wide range of information can be determined about a device that can
be used to create a new udev rule.
udevinfo can be used to list all of the sysfs
information about a specific device. For example, to name your green USB mouse,
mouse_green, refer to the the sysfs
information about the USB mouse using udevinfo:
udevinfo -a -p /sys/class/input/mouse0/
The output of this command is show in Example 2, “Example udevinfo Output”.
udevinfo starts with the device the node belongs to and then walks up the
device chain, to print for every device found, all possibly useful attributes
in the udev key format.
Only attributes within one device section may be used together in one rule,
to match the device for which the node will be created.
device '/sys/class/input/mouse0' has major:minor 13:32
looking at class device '/sys/class/input/mouse0':
SYSFS{dev}="13:33"
follow the class device's "device"
looking at the device chain at '/sys/devices/pci0000:00/0000:00:09.0/usb2/2-1/2-1:1.0':
BUS="usb"
ID="2-1:1.0"
SYSFS{bAlternateSetting}=" 0"
SYSFS{bInterfaceClass}="03"
SYSFS{bInterfaceNumber}="00"
SYSFS{bInterfaceProtocol}="02"
SYSFS{bInterfaceSubClass}="01"
SYSFS{bNumEndpoints}="01"
SYSFS{detach_state}="0"
looking at the device chain at '/sys/devices/pci0000:00/0000:00:09.0/usb2/2-1':
BUS="usb"
ID="2-1"
SYSFS{bConfigurationValue}="1"
SYSFS{bDeviceClass}="00"
SYSFS{bDeviceProtocol}="00"
SYSFS{bDeviceSubClass}="00"
SYSFS{bMaxPower}="100mA"
SYSFS{bNumConfigurations}="1"
SYSFS{bNumInterfaces}=" 1"
SYSFS{bcdDevice}="0100"
SYSFS{bmAttributes}="a0"
SYSFS{configuration}="HID-Mouse"
SYSFS{detach_state}="0"
SYSFS{devnum}="2"
SYSFS{idProduct}="1035"
SYSFS{idVendor}="047d"
SYSFS{manufacturer}="Kensington"
SYSFS{maxchild}="0"
SYSFS{product}="Kensington USB Mouse"
SYSFS{speed}="1.5"
SYSFS{version}=" 1.10"
looking at the device chain at '/sys/devices/pci0000:00/0000:00:09.0/usb2':
BUS="usb"
ID="usb2"
SYSFS{bConfigurationValue}="1"
SYSFS{bDeviceClass}="09"
SYSFS{bDeviceProtocol}="00"
SYSFS{bDeviceSubClass}="00"
SYSFS{bMaxPower}=" 0mA"
SYSFS{bNumConfigurations}="1"
SYSFS{bNumInterfaces}=" 1"
SYSFS{bcdDevice}="0206"
SYSFS{bmAttributes}="c0"
SYSFS{detach_state}="0"
SYSFS{devnum}="1"
SYSFS{idProduct}="0000"
SYSFS{idVendor}="0000"
SYSFS{manufacturer}="Linux 2.6.10-rc2 ohci_hcd"
SYSFS{maxchild}="1"
SYSFS{product}="NEC Corporation USB"
SYSFS{serial}="0000:00:09.0"
SYSFS{speed}="12"
SYSFS{version}=" 1.10"
looking at the device chain at '/sys/devices/pci0000:00/0000:00:09.0':
BUS="pci"
ID="0000:00:09.0"
SYSFS{class}="0x0c0310"
SYSFS{detach_state}="0"
SYSFS{device}="0x0035"
SYSFS{irq}="9"
SYSFS{subsystem_device}="0x11a3"
SYSFS{subsystem_vendor}="0x10cf"
SYSFS{vendor}="0x1033"
looking at the device chain at '/sys/devices/pci0000:00':
BUS=""
ID="pci0000:00"
SYSFS{detach_state}="0"
udevinfo Output
So, from the output of the udevinfo program, all of the
sysfs files and other udev fields are described. To write the best type
of rule for a device, determine the most unique way a device can be
described from the output.. For example, from Example 2, “Example udevinfo Output”, the following line shows a unique field that
distinguishes it from all other mice that might be connected to the
system:
SYSFS{product}="Kensington USB Mouse"
However, this is not true if a user has more than one kind of the same mouse. In that case, the ID value should be used since it is unique:
ID="2-1:1.0"
Using the product sysfs file, a udev rule to always name
this mouse mouse_green is as follows:
BUS="usb", SYSFS{product}="Kensington USB Mouse", NAME="mouse_green"
One of the most powerful features of udev is its ability to call other programs to determine what to name a device or if a device should be matched. This is useful if the built-in keys and rule matching sequences are not flexible enough.
As an example, what if you want to use the artist name from the currently inserted CD as the CD-ROM device name? There is no way that sysfs will be extended to provide this kind of information about the data within the device, so an external program must be used. The following rule causes udev to call the program name_cdrom.pl whenever a block device is found by the kernel:
KERNEL="[hs]d[a-z]", PROGRAM="name_cdrom.pl %M %m", NAME="%c{1}", SYMLINK="cdrom"
This rule matches any device that starts with h
or s followed by a
d and then followed by any lowercase alphabetic
character. If that name matches, the Perl script,
name_cdrom.pl is called. This script is shown in Example 3, “name_cdrom.pl Script”. There are two arguments passed in for this
script, the major and minor number of the device being matched by udev (as
specified by the %M and
%m modifiers). If this program returns a
success, then the first return value of the script is used to name the device
(that is the %c{1} modifier). A symlink to the
file cdrom is also created so that other programs are still
able to find the cdrom device in the system.
#!/usr/bin/perl
# a horribly funny script that shows how flexible udev can really be
# This is to be executed by udev with the following rules:
# KERNEL="[hs]d[a-z]", PROGRAM="name_cdrom.pl %M %m", NAME="%c{1}", SYMLINK="cdrom"
use strict;
use warnings;
use CDDB_get qw( get_cddb );
my $dev_node = "/tmp/cd_foo";
# following variables just need to be declared if different from defaults
my %config;
$config{CDDB_HOST}="freedb.freedb.org"; # set cddb host
$config{CDDB_PORT}=8880; # set cddb port
$config{CDDB_MODE}="cddb"; # set cddb mode: cddb or http
$config{CD_DEVICE}="$dev_node"; # set cd device
# No user interaction, this is a automated script!
$config{input}=0;
my $major = $ARGV[0];
my $minor = $ARGV[1];
# create our temp device node to read the cd info from
unlink($dev_node);
if (system("mknod $dev_node b $major $minor")) {
die "bad mknod failed";
}
# get it on
my %cd=get_cddb(\%config);
# remove the dev node we just created
unlink($dev_node);
# print out our cd name if we have found it or skip rule by nonzero exit
if (defined $cd{title}) {
$cd{artist} =~ s/ /_/g;
$cd{title} =~ s/ /_/g;
print "$cd{artist}-$cd{title}\n";
} else {
exit -1;
}
name_cdrom.pl Script
The name_cdrom.pl script queries the freedb database (assuming the system has an
Internet connection) to determine the artist name of the currently inserted CD.
Such a complex functionality would never have been built into udev but because
of the PROGRAM feature, udev can rely on helper programs to create complex rules
if it is desired.
There are many ways to create new udev rules, due to its wide range of key matching abilities and ability to call other programs. To learn more about how to create custom udev rules, refer to the udev documentation that comes with the program. In it are full descriptions of all of the different keys that can be used, an explanation of the regular expressions that are supported by udev, and a tutorial on how to create udev rules based on many different types of devices.
The author would like to thank Kay Sievers for all of his udev development and documentation work and Daniel Drake who created the udev tutorial provided with the program.