Kernel module (Português) - ArchWiki

Jump to content

# Kernel module (Português)

From ArchWiki
Status de tradução: Este artigo é uma tradução de Kernel module. Data da última tradução: 2020-01-18. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- Depuração de inicialização
- Kernel
- Parâmetros do kernel
- Compile kernel module

Módulos de Kernel são peças de código que podem ser carregadas e descarregadas no kernel de acordo com a demanda. Elas estendem a funcionalidade do kernel sem a necessidade de reinicialização do sistema.

Para criar um módulo de kernel, você pode ler The Linux Kernel Module Programming Guide (inglês). Um módulo pode ser configurado como para executar de modo embutido ao kernel ou ser carregado separadamente. Para carregar ou remover um módulo dinamicamente, ele deve ser configurado como em um módulo carregável na configuração do kernel (a linha relacionada ao módulo exibirá a letra `M`).

## Obtendo informações

Módulos são gravados em `/usr/lib/modules/versão_do_kernel`. O comando `uname -r` pode ser usado para obter a atual versão do kernel em execução.

Nota Nomes de módulo costumam usar underlines (`_`) ou traços (`-`); entretanto, esses símbolos são permutáveis ao usar o comando `modprobe` e nos arquivos de configuração em `/etc/modprobe.d/`.

Para exibir quais módulos do kernel estão atualmente carregados:

    $ lsmod

Para exibir informação sobre um módulo:

    $ modinfo nome_do_módulo

Para listar opções que estão definidas para um módulo carregado:

    $ systool -v -m nome_do_módulo

Para mostrar a configuração de modo mais compreensível de todos os módulos:

    $ modprobe -c | less

Para exibir a configuração de um módulo em particular:

    $ modprobe -c | grep nome_do_módulo

Listar as dependências de um módulo (ou alias), incluindo o módulo em si:

    $ modprobe --show-depends nome_do_módulo

## Carregamento automático de módulos com systemd

Hoje, todos os módulos necessários ao funcionamento do sistema são automaticamente gerenciados por udev, então se não houver necessidade de usar quaisquer módulos de kernel adicionais, não há necessidade de acrescentar módulos que deverão ser carregados na inicialização do sistema em qualquer arquivo de configuração. Entretanto, existem casos onde você pode querer adicionar um módulo extra durante o processo de inicialização do sistema, ou acrescentá-lo numa lista negra (blacklist) para que seu computador funcione adequadamente.

Módulos de kernel podem ser explicitamente listados em arquivos dentro de `/etc/modules-load.d/` para que o systemd os carregue durante a inicialização do sistema. Cada arquivo de configuração é nomeado no estilo de `/etc/modules-load.d/<programa>.conf`. Arquivos de configuração simplesmente contém uma lista de módulos de kernel a serem carregados, separados linha a linha. Linhas vazias e linhas cujo primeiro caractere sem espaço em branco seja `#` ou `;` são ignoradas.

    /etc/modules-load.d/virtio-net.conf

    # Carrega virtio_net.ko na inicialização
    virtio_net

Veja modules-load.d(5) para mais detalhes.

## Manuseio de módulos de kernel

Módulos de kernel são manuseados por ferramentas fornecidas pelo pacote kmod. Você pode usar essas ferramentas manualmente.

Nota Caso tenha atualizado seu kernel mas ainda não tenha reiniciado o sistema, modprobe irá falhar com ou sem mensagem de erro e irá fechar com código 1, porque o caminho `/usr/lib/modules/$(uname -r)/` não existirá mais neste cenário. Verifique manualmente se o caminho existe quando modprobe falhar, para determinar se este é o caso.

Para carregar um módulo:

    # modprobe nome_do_módulo

Para carregar um módulo pelo seu nome de arquivo (isto é, algum que não esteja instalado em `/usr/lib/modules/$(uname -r)/`):

    # insmod nome_de_arquivo [args]

Para descarregar um módulo:

    # modprobe -r nome_do_módulo

Ou alternativamente:

    # rmmod nome_do_módulo

## Opções de configuração de módulos

Para passar um parâmetro para um módulo de kernel, você passa-o manualmente com modprobe ou assegura certos parâmetros que sempre serão aplicados usando um arquivo de configuração do modprobe, ou ainda usando a linha de comando do kernel.

### Carregá-lo manualmente usando modprobe

A mais básica forma de passar parâmetros para um módulo é através do comando modprobe. Parâmetros são especificados em linha de comando usando simples valores `key=value`:

    # modprobe nome_do_módulo nome_do_parâmetro=valor_do_parâmetro

### Usando arquivos em /etc/modprobe.d/

Arquivos no diretório `/etc/modprobe.d/` podem ser usados para passar configurações do módulo ao udev, o qual usará `modprobe` para gerenciar o carregamento de módulos durante a inicialização do sistema. Arquivos de configuração neste diretório podem ter qualquer nome, desde termine com a extensão `.conf`. A sintaxe é:

    /etc/modprobe.d/myfilename.conf

    options nome_do_módulo nome_do_parâmetro=valor_do_parâmetro

Por exemplo:

    /etc/modprobe.d/thinkfan.conf

    # Em ThinkPads, a daemon 'thinkfan' permite controlar a velocidade da ventoinha
    options thinkpad_acpi fan_control=1

Nota Se qualquer dos módulos afetados estão carregados pela initramfs, então será necessário adicionar o arquivo `.conf` apropriado a `FILES` em mkinitcpio.conf ou usar o hook `modconf`, para que então ele seja incluído na initramfs. Para ver o conteúdo de uma initramfs padrão, use `lsinitcpio /boot/initramfs-linux.img`.

### Usando a linha de comando do kernel

Se o módulo estiver embutido dentro do kernel, você pode também passar opções ao módulo usando a linha de comando do kernel. Para todos os gerenciadores de boot comuns, a seguinte sintaxe está correta:

    nome_do_módulo.nome_do_parâmetro=valor_do_parâmetro

Por exemplo:

    thinkpad_acpi.fan_control=1

Simplesmente adicione isto à linha de comando do kernel através do seu gerenciador de boot, como descrito em Parâmetros do kernel.

## Aliasing

Aliasing é atribuir apelido (alias) a um módulo de kernel. Por exemplo: `alias meu-mód nome_de_módulo_realmente_longo` significa que você pode usar `modprobe meu-mód` ao invés de `modprobe nome_de_módulo_realmente_longo`. Você pode ainda usar caracteres curingas no estilo do shell, então `alias meu-mód* nome_de_módulo_realmente_longo` significa que `modprobe meu-mód-alguma_coisa` tem o mesmo efeito. Criar um alias:

    /etc/modprobe.d/myalias.conf

    alias meu-mód nome_de_módulo_realmente_longo

Alguns módulos tem aliases que são automaticamente carregadas quando são necessárias por uma aplicação. Desativar estes aliases pode evitar que que o módulo seja carregado automaticamente, mas o mesmo ainda poderá ser carregado manualmente.

    /etc/modprobe.d/modprobe.conf

    # Evita o carregamento automático do Bluetooth
    alias net-pf-31 off

## Adicionar um módulo em uma lista negra (Blacklisting)

Blacklisting, no contexto de módulos de kernel, é um mecanismo de evitar que módulos de kernel sejam carregados. Isto pode ser útil se, por exemplo, o hardware associado a ele não seja usado, ou se carregar seu módulo cause problemas: por exemplo, pode haver dois módulos de kernel tentando controlar a mesma parte do hardware, e carregá-los juntos resulta em conflito.

Alguns módulos são parte da initramfs. `mkinitcpio -M` irá mostrar todos os módulos automaticamente detectados: para evitar que initramfs carregue alguns deste módulos, adicione-os a uma lista negra com um arquivo .conf dentro de `/etc/modprobe.d` e ela deverá ser adicionada pelo hook `modconf` durante a criação da imagem. Executar `mkinitcpio -v` irá listar todos os módulos puxados por diversos hooks (por exemplo, hook `filesystems`, hook `block`, etc.). Lembre de adicionar este arquivo .conf à matriz `FILES` em `/etc/mkinitcpio.conf`, caso você não tenha o hook `modconf` em sua matriz `HOOKS` (por exemplo, se você não usa a configuração padrão), e uma vez que você adicionar estes módulos à lista negra, gere novamente o initramfs e reinicie o sistema em seguida.

### Usando arquivos em /etc/modprobe.d/

Crie um arquivo `.conf` dentro de `/etc/modprobe.d/` e acrescente uma linha para cada módulo que desejar colocá-lo em lista negra, usando a palavra-chave `blacklist`. Se, por exemplo, desejar evitar que o módulo `pcspkr` seja carregado:

    /etc/modprobe.d/nobeep.conf

    # Não carregar o módulo 'pcspkr' durante a inicialização.
    blacklist pcspkr

Nota O comando `blacklist` irá colocar em lista negra um módulo para que ele não seja carregado automaticamente, mas ainda assim ele poderá ser carregado se outro módulo (que não esteja na lista negra) depender dele ou se for carregado manualmente.

Contudo, há uma solução para este comportamento; o comando `install` instrui modprobe a executar um comando personalizado ao invés de normalmente inserir o módulo no kernel, então é possível forçar o módulo a sempre falhar no seu carregamento, com:

    /etc/modprobe.d/blacklist.conf

    ...
    install nome_do_módulo /bin/true
    ...

Isto irá efetivamente colocar o módulo em lista negra e qualquer outro que dependa dele.

### Usando a linha de comando do kernel

Dica Isto pode ser muito útil caso um módulo quebrado impossibilite a inicialização do sistema.

Você pode também adicionar módulos à lista negra a partir do gerenciador de boot.

Simplesmente adicione `module_blacklist=modulo1,modulo2,modulo3` para a linha de comando do kernel em seu gerenciador de boot, como descrito em Parâmetros do kernel.

Nota Ao adicionar mais do que um módulo na lista negra, perceba que eles deverão ser separados apenas por vírgulas. Espaços ou qualquer outra coisa além disso irá presumivelmente quebrar a sintaxe.

## Solução de problemas

### Módulos não podem ser carregados

No caso de algum módulo específico não ser carregado e o log de inicialização (acessível com `journalctl -b`) dizer que o módulo está em lista negra (blacklisted), mas o diretório `/etc/modprobe.d/` não exibir uma entrada correspondente, procure em outro diretório-fonte do modprobe `/usr/lib/modprobe.d/` por entradas de blacklist.

Um módulo não será carregado se a string "vermagic" contida dentro do módulo não corresponder com o valor do kernel em execução. Se houver conhecimento de que tal módulo seja compatível com o kernel em execução, a verificação "vermagic" poderá ser ignorada com `modprobe --force-vermagic`.

Atenção Ignorar verificações de versão poderá causar instabilidade no kernel e o sistema apresentará comportamento inesperado devido à incompatibilidade. Use `--force-vermagic` sempre com extrema cautela.

## Veja também

- Disable PC speaker beep
- Writing a WMI driver - uma introdução do LWM

Categories:

- Kernel (Português)
- Hardware detection and troubleshooting (Português)
- Boot process (Português)

Kernel module (Português)
Add topic