udev - gerenciamento dinâmico de dispositivos do Linux

udev é um substituto para o Sistema de Arquivos de Dispositivos ("Device File System" - ?DevFS) começando com a série de núcleos Linux 2.6. Ele permite que você identifique dispositivos com base em propriedades, como ID de fornecedor(a) e ID de dispositivo, dinamicamente. udev é executado no espaço de usuário(a) (em oposição aos devfs, que eram executados no espaço de kernel).

udev permite regras que especificam qual nome é dado a um dispositivo, independentemente da porta em que está conectado. Por exemplo, uma regra para sempre montar um disco rígido do fabricante "iRiver" e o código do dispositivo "ABC" como /dev/iriver é possível. Essa nomeação consistente de dispositivos garante que os scripts dependentes da existência de um dispositivo específico não serão quebrados.

Visão geral

O sistema udev é composto por alguns serviços do núcleo (kernel) e o daemon udevd. O núcleo informa o daemon udevd quando certos eventos acontecem. O daemon udevd é configurado para responder a eventos com as ações correspondentes. A informação do evento vem do núcleo - as ações acontecem no espaço de usuário(a). As respostas aos eventos são configuráveis em "regras".

A funcionalidade udev do espaço de usuário(a) é implementada pelo systemd-udevd.service. Seu arquivo de configuração está em /etc/udev/udev.conf. Os arquivos de regras (que fornecem mais configurações para udevd) são retirados de /run/udev/rules.d, /etc/udev/rules.d ou /lib/udev/rules.d. Os pacotes instalam regras em /lib/udev/rules.d), enquanto os locais /etc e /run fornecem uma facilidade para o(a) administrador(a) anular o comportamento de uma regra fornecida por algum pacote. Se um arquivo com o mesmo nome estiver presente em mais de um desses diretórios, o arquivo será ignorado. Os arquivos são analisados em ordem alfanumérica, desde que o nome termine com ".rules". Quando o arquivo de configuração ou os arquivos de regras são alterados, o programa udevadm deve ser usado para instruir systemd-udevd a recarregar as regras (veja abaixo).

udev foi criado para responder ao tipo de eventos hotplug ("troca quente" - troca em operação). Muita documentação refere-se à criação de dispositivos em resposta a novos dispositivos que apareceram. Mas o udev é mais genérico; pode executar comandos arbitrários de espaço de usuário(a) em resposta a um novo dispositivo que aparece - ou a quaisquer eventos que receba do núcleo.

Os períodos em que o udevd está ativo são:

  1. na inicialização, analisa todos os arquivos de configuração e arquivos de regras e constrói um banco de dados de regras na memória.
  2. quando um evento acontece, verifica seu banco de dados de regras e executa as ações apropriadas.

Regras

Regras para rules:

  1. as regras estão todas em uma linha (linhas podem ser quebradas com \ logo antes de newline)
  2. as regras consistem em "correspondências" (match) e "ações" (action)
  3. correspondências e ações são tríplices "chave" "operador" "valor"
  4. as correspondências têm == ou != no operador
  5. as ações têm = (atribuição) no operador
  6. as correspondências verificam um ou mais atributos do evento para ver se a ação será aplicada
  7. ações especificam o que vai acontecer

  8. exemplo de correspondência: BUS=="usb"

  9. exemplo de ação: NAME="mydev"

  10. exemplo de regra: 

    KERNEL=="sd*[0-9]|dasd*[0-9]", ENV{ID_SERIAL}=="?*", \
        SYMLINK+="disk/by-id/$env{ID_BUS}-$env{ID_SERIAL}-part%n"
  11. todas as regras correspondentes serão acionadas
  12. regras anteriores têm precedência sobre regras posteriores - assim, coloque suas customizações antes na lista do arquivo rules.d
  13. ações como chave="valor" sobrescrevem

  14. ações como chave+="valor" adicionam às ações que estejam sendo executadas, ou seja, SYMLINK+="foo" significa "além de quaisquer outros links simbólicos que você fará para este evento, também faça um link simbólico chamado foo"

Conjunto de regras

Regras para conjuntos de regras (rule sets):

  1. Todas as regras estão em um grande espaço de regras, embora sejam divididas em vários arquivos.

  2. A única organização no espaço de regras é a capacidade de definir rótulos (labels) e, em seguida, pular um monte de regras durante no momento em que há correspondência do evento a certas regras, saltando para a frente com uma ação GOTO.

  3. Há um outro tipo de regra chamado de label (rótulo): ou seja, LABEL="persistent_storage_end". São usadas por regras normais que têm ações "GOTO", isto é: 

    ACTION!="add", GOTO="persistent_storage_end"
    Observe que nesta regra, o termo ACTION é um atributo de um evento e está sendo usado como condição para decidir se a ação GOTO será acionada.
  4. É educado manter os GOTOs para saltar dentro de um arquivo (ou você terá que se preocupar com o reordenamento dos arquivos)
  5. Não pule para trás para um rótulo (não tentei, mas imagine que pode terminar em um loop infinito? Talvez o código udev verifique isso - mas se vai ser ignorado (na melhor das hipóteses) por que se preocupar?)
  6. Você pode definir variáveis no espaço ENV em regras anteriores e se referir a elas com regras posteriores

  7. A facilidade de criação de regras dinâmicas existe (por exemplo, veja z45_persistent-net-generator.rules)

Lista de bloqueio

ListaDeBloqueioDeMódulosDoNúcleo

Nome de dispositivo persistente

Neste exemplo, queremos ter certeza de que sua placa 3G obtenha um nome persistente.

1. Conecte a "placa" (ou o dispositivo)

2. Execute o seguinte comando no referido dispositivo; 

$ udevadm info --name=/dev/ttyS1 --attribute-walk

udevadm começa com o dispositivo especificado pelo devpath e, em seguida, sobe a cadeia de dispositivos superiores. Ele exibe cada dispositivo encontrado, todos os possíveis atributos no formato de chaves de regras udev. Para que uma regra tenha correspondência, pode ser composta por atributos do dispositivo e atributos de um único dispositivo superior. 

  looking at device '/class/tty/ttyS1':
    KERNEL=="ttyS1"
    SUBSYSTEM=="tty"
    DRIVER==""
    ATTR{dev}=="4:65"

  looking at parent device '/devices/pci0000:00/0000:00:1e.0/0000:15:00.0/0.0':
    KERNELS=="0.0"
    SUBSYSTEMS=="pcmcia"
    DRIVERS=="serial_cs"
    ATTRS{modalias}=="pcmcia:m00A4c1AAFf02fn00pfn00pa32607776pbD9E73B13pcAF9C4D7Fpd00000000"
    ATTRS{prod_id3}=="NRM6831"
    ATTRS{prod_id2}=="Merlin UMTS Modem"
    ATTRS{prod_id1}=="Novatel Wireless"
    ATTRS{card_id}=="0x1aaf"
    ATTRS{manf_id}=="0x00a4"
    ATTRS{func_id}=="0x02"
    ATTRS{pm_state}=="on"
    ATTRS{function}=="0x00"

  looking at parent device '/devices/pci0000:00/0000:00:1e.0/0000:15:00.0':
    KERNELS=="0000:15:00.0"
    SUBSYSTEMS=="pci"
    DRIVERS=="yenta_cardbus"
    ATTRS{msi_bus}=="1"
    ATTRS{broken_parity_status}=="0"
    ATTRS{enable}=="2"
    ATTRS{numa_node}=="0"
    ATTRS{modalias}=="pci:v00001180d00000476sv000017AAsd000020C6bc06sc07i00"
    ATTRS{local_cpus}=="00000003"
    ATTRS{irq}=="16"
    ATTRS{class}=="0x060700"
    ATTRS{subsystem_device}=="0x20c6"
    ATTRS{subsystem_vendor}=="0x17aa"
    ATTRS{device}=="0x0476"
    ATTRS{vendor}=="0x1180"

  looking at parent device '/devices/pci0000:00/0000:00:1e.0':
    KERNELS=="0000:00:1e.0"
    SUBSYSTEMS=="pci"
    DRIVERS==""
    ATTRS{msi_bus}=="1"
    ATTRS{broken_parity_status}=="0"
    ATTRS{enable}=="1"
    ATTRS{numa_node}=="0"
    ATTRS{modalias}=="pci:v00008086d00002448sv00000000sd00000000bc06sc04i01"
    ATTRS{local_cpus}=="00000003"
    ATTRS{irq}=="0"
    ATTRS{class}=="0x060401"
    ATTRS{subsystem_device}=="0x0000"
    ATTRS{subsystem_vendor}=="0x0000"
    ATTRS{device}=="0x2448"
    ATTRS{vendor}=="0x8086"

  looking at parent device '/devices/pci0000:00':
    KERNELS=="pci0000:00"
    SUBSYSTEMS==""
    DRIVERS==""
    ATTRS{uevent}==""

3. Crie um arquivo em /etc/udev/rules.d, tipicamente nomeado z21_persistent-local.rules. 

ATTRS{prod_id2}=="Merlin UMTS Modem", ATTRS{prod_id1}=="Novatel Wireless", SYMLINK+="MerlinUMTS"
## Alternatively we could use :
# ATTRS{card_id}=="0x1aaf", ATTRS{manf_id}=="0x00a4", SYMLINK+="MerlinUMTS"

4. Force a re-execução dos scripts (ou reinicie ;) 

udevadm control --reload-rules
udevadm test -a -p  $(udevadm info -q path -n /dev/ttyS1)

Um exemplo mais detalhado por semu5 em comp.os.linux.questions. Também há este artigo Escrevendo regras udev (em inglês).

Referências

CategorySystemAdministration | CategoryBootProcess | CategoryHardware