1.
Introducción
En sistemas tipo Unix (como Linux) los dispositivos pueden tratarse como si fuesen
ficheros, y típicamente estos ficheros que representan dispositivos se encuentran en el
directorio /dev.
Hace unos años, el sistema base incluía en el directorio /dev ficheros para todos los
posibles dispositivos del sistema. Sin embargo, esta forma de mantener /dev era
insostenible, así que se desarrollaron sistemas de gestión de dispositivos para que este
directorio, se manejase dinámicamente y solo contuviese archivos de dispositivos realmente
conectados al sistema. Por ejemplo, algunos gestores que se utilizaban antes son devfs y
hotplug.
2. ¿Qué es udev?
Udev es un gestor de dispositivos para núcleos Linux 2.6. Se encarga de mantener
actualizado el directorio /dev con los dispositivos presentes en el sistema. Además,
también puede realizar otras actividades sobre los dispositivos de las que no se encarga el
kernel (scripts de inicialización, permisos, carga de firmwares…)
Udev sustituye a otros gestores como devfs y hotplug. Utiliza la información provista por
el sistema de ficheros sysfs. Este sistema de ficheros, lo ofrece el kernel y crea un arbol de
directorios (normalmente en /sys/) con la información que el kernel tiene sobre el
hardware del sistema.
3. Las reglas de udev
La forma en la que udev gestiona los dispositivos del sistema es a través de reglas. Estas
reglas se escriben en archivos de texto con el sufijo .rules, y se leen del directorio
/etc/udev/rules.d/. Como en otros sistemas en GNU/Linux, las reglas se ejecutan en
orden lexicográfico, por eso suelen contener un número, que ayuda a ejecutar la regla en el
orden deseado. Estos archivos deben tener al menos permisos de lectura para el
superusuario (root), y están formados por varias líneas, siendo cada una de estas líneas una
regla.
Cada regla contiene uno o más parámetros descriptivos que sirven para referirse a uno o
más dispositivos concretos, y en una o más acciones a ejecutar sobre los dispositivos que
han cumplido los parámetros anteriores.
4. Cómo se escribe una regla
Como se ha mencionado antes, una regla consiste en una serie de pares clave-valor que
describen un dispositivo, y luego una o más acciones sobre el dispositivo descrito. Así, la
regla se divide en dos partes, una primera que sirve para identificar el dispositivo o los
dispositivos que la cumplen, y una segunda parte en la que se especifican una o más
acciones a realizar.
Una regla podría ser de la siguiente forma
clave1==valor1, clave2==valor2, clave3!=valor3, ..., accion1, accion2
Pero ¿cómo nos referirnos a un dispositivo concreto en la regla? ¿qué acciones podemos
hacer sobre el dispositivo?
4.1 Cómo referirnos a dispositivos en la regla de udev
Udev obtiene información de los dispositivos a partir de sysfs (ver el artículo anterior), y
obtiene estos pares clave-valor de este sistema de ficheros. Pero otra pregunta más…
¿cómo identifica sysfs a los dispositivos?
Para saber la información que sysfs (y por lo tanto udev) tienen de nuestro dispositivo, de
forma que sea ese dispositivo el que cumple en la regla, es necesario saber que nodo dentro
de sysfs corresponde al dispositivo. Para averiguar cual es este nodo, debemos distinguir
dos casos:
si el dispositivo puede conectarse y desconectarse en caliente. En este caso, usaremos la
herramienta udevadm en modo monitor:
# udevadm monitor
Al conectar y desconectar el dispositivo udevadm nos informará de los nodos que sysfs crea
y elimina. Es posible que todos los nodos que muestra udevadm en ese momento nos
sirvan. En cualquier caso, con un poco de intuición será fácil ver cual es el más adecuado
utilizar.
si el dispositivo está fijo en el sistema udevadm monitor no puede ayudarnos en este
caso. Veamos un ejemplo para una tarjeta PCI, que no podríamos conectar y desconectar
con el sistema en marcha. Tendríamos que buscar en el arbol de directorios de sysfs qué
dispositivo se trata. Podemos utilizar lspci, que nos indicaría a que nodo de
/sys/bus/pci/devices acceder, o podemos buscar a través del identificador de
fabricante/producto (gracias a lspci -n) en los archivos product y device de los nodos de
/sys/bus/pci/devices. Este sería el nodo a utilizar.
En cualquiera de los dos casos, ya sabríamos cual es el nodo de sysfs que corresponde al
dispositivo de interés. Para conocer la información que tiene sysfs, y por lo tanto udev
puede utilizar de este dispositivo utilizamos:
# udevadm info -a -p /syspath
Este comando nos ofrece pares de clave-valor, para todas las capas hardware que usa el
dispositivo. Por ejemplo, si se trata de una tarjeta de red, que se conecta por USB a un
controlador USB que va por PCI, el nodo nos ofrecerá información sobre este dispositivo
en todas esas capas. Estos pares clave-valor ofrecen información de forma jerárquica en los
siguientes niveles:
KERNELS: como llama el núcleo al dispositivo de manera inicial.
SUBSYSTEMS: el sistema al que está conectado el dispositivo.
DRIVERS: nombre del controlador que gestiona el dispositivo.
ATTRS: una gran cantidad de atributos del dispositivo, que dependen de la clase del
dispositivo: vendorId, productId, serial, adress…
También podemos usar variables de entorno, mediante ENV{var}=="value".
Todos estos pares pueden usarse directamente en la regla de udev para hacer coincidir la
regla con el dispositivo adecuado.
Si queremos referirnos a un único dispositivo concreto, podemos utilizar por ejemplo un
número de serie. Para referirnos a un modelo concreto, se suele utilizar el productId y
vendorId. Sin embargo, ¿cómo haríamos para referirnos a una familia de dispositivos, o
para hacer coincidir varios a la vez? Para eso podemos usar las siguientes sustituciones en
los pares clave-valor:
expresiones regulares básicas: por ejemplo, si el kernel llama a un dispositivo sda3,
podemos usar KERNELS=="sda*" para cualquier dispositivo que comience por sda.
%k: contiene la cadena con la que el kernel llama al dispositivo originalmente.
%n: representa el número que el kernel le da al dispositivo. Por ejemplo, 3 en sda3
4.2 ¿Qué podemos hacer sobre los dispositivos referidos?
Sobre el dispositivo que cumple la regla podemos realizar las siguientes acciones:
NAME: sirve para cambiar el nombre que el kernel da al dispositivo.
SYMLINK: en este caso no se cambia el nombre que el kernel da al dispositivo, sino que se
crea un enlace simbólico con el nombre deseado.
OWNER: el usuario propietario del dispositivo.
GROUP: el grupo propietario del dispositivo.
MODE: permisos para el dispositivo creado, por ejemplo MODE="0666".
RUN: ejecuta un programa cuando un dispositivo cumple la regla. Suele usarse mediante
RUN+="program".
PROGRAM: normalmente se usa si queremos utilizar un programa externo y recoger el
resultado mediante %c. En el caso de que la salida tenga varias partes, nos referimos a
ellas con %c{1}, %c{2}, … %c{N}.
5. Probando nuestra regla
Antes de hacer que udev trabaje con nuestra regla, podemos probarla de la siguiente forma.
Conectamos el dispositivo y ejecutamos el siguiente comando:
# udevadm test /syspath
Este comando lee las reglas que hay en el directorio de reglas (no las cargadas actualmente)
y nos informa de las acciones que udev realizaría con el dispositivo que corresponde al
nodo que se pasa como argumento. Por lo tanto es una forma de comprobar como se
comportaría udev con la nueva regla, sin tener que hacer que el gestor que realmente está
funcionando en el ordenador ejecute estos nuevos cambios que podrían no ser correctos.
6. Haciendo que udev recargue las reglas
Una vez que parece que la nueva regla está lista, debemos decirle a la instancia de udev que
ya está funcionando que vuelva a recargar las nuevas reglas. Para eso volvemos a utilizar el
comando udevadm, esta vez con la opción de control.
# udevadm control --reload-rules
Y ya tendriamos nuestra regla incorporada en nuestro udev. Por supuesto para quitarla
simplemente tendríamos que quitar el archivo de /etc/udev/rules.d o comentar el contenido
del archivo.