Gerenciando Módulos do Kernel

Descreve como inspecionar módulos do kernel carregados, ajustar parâmetros e controlar quais módulos são carregados no Oracle Linux.

Use o comando lsmod para exibir quais módulos são carregados no kernel em execução. Use o comando modinfo para encontrar informações sobre um módulo kernel. Use o comando modprobe para carregar um módulo no kernel em execução ou para alterar os parâmetros do módulo do kernel. Você também pode criar arquivos de configuração em /etc/modprobe.d/ para controlar parâmetros que são usados quando os módulos do kernel são carregados. Você também pode configurar se os módulos serão carregados no momento da inicialização, editando a configuração em /etc/modules-load.d/.

Listando Informações sobre Módulos Carregados

Use o comando lsmod para listar módulos carregados no kernel e use o comando modinfo para obter mais informações sobre cada módulo. Para obter mais informações, consulte as páginas do manual lsmod(5) e modinfo(8).

Execute o comando lsmod para listar os módulos carregados no kernel.

lsmod

Module                  Size  Used by
udp_diag               16384  0
ib_core               311296  0
tcp_diag               16384  0
inet_diag              24576  2 tcp_diag,udp_diag
nfsv3                  49152  0
nfs_acl                16384  1 nfsv3
...
dm_mirror              24576  0
dm_region_hash         20480  1 dm_mirror
dm_log                 20480  2 dm_region_hash,dm_mirror
...

A saída mostra o nome do módulo, a quantidade de memória que ele usa, o número de processos que usam o módulo e os nomes de outros módulos dos quais ele depende. O módulo dm_log, por exemplo, depende dos módulos dm_region_hash e dm_mirror. O exemplo também mostra que dois processos estão usando todos os três módulos.

Use o comando modinfo para mostrar informações detalhadas sobre um módulo.
```
modinfo ahci
```
```
filename:       /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/drivers/ata/ahci.ko.xz
version:        3.0
license:        GPL
description:    AHCI SATA low-level driver
author:         Jeff Garzik
srcversion:     1DC2CDA088C5DC03187A5E0
alias:          pci:v*d*sv*sd*bc01sc06i01*
...
depends:        libata,libahci
intree:         Y
name:           ahci
retpoline:      Y
vermagic:       6.12.0-100.28.2.el10uek.x86_64 SMP preempt mod_unload modversions 
sig_id:         PKCS#7
signer:         Oracle CA Server
sig_key:        7B:38:D7:DC:38:51:E7:C7:F1:61:C5:5D:8D:CC:6B:1C:90:82:4D:05
sig_hashalgo:   sha512
signature:      64:05:FC:CC:B1:D3:88:91:B6:C9:A2:39:A3:A9:BB:8C:95:11:36:20:
                62:9C:95:D9:8B:B8:F6:5F:CC:D2:93:4E:7D:59:E1:80:DB:70:FA:4C:
                9B:8D:75:E3:98:AB:9D:BD:94:93:A7:72:0B:28:3B:15:4E:96:0D:E3:
                9F:FE:24:1A:09:B5:31:27:F2:EE:45:61:C8:4A:D3:4B:82:07:23:66:
                A1:06:F4:DF:B9:FF:D2:78:08:1D:AA:EC:DE:3C:E4:17:BD:69:6A:A5:

                ...
                64:F0:4F:E2:4E:F3:47:A5:40:E8:F7:07:68:3F:58:25:32:BA:13:E9:
                00:46:7A:2F:30:73:B4:32:48:76:6B:1E
parm:           marvell_enable:Marvell SATA via AHCI (1 = enabled) (int)
parm:           mobile_lpm_policy:Default LPM policy for mobile chipsets (int)
...
```
A saída inclui as seguintes informações:

filename

Caminho absoluto do arquivo de objeto do kernel.

version

Número de versão do módulo. Observe que o número da versão pode não ser atualizado para módulos com patch e pode estar ausente ou removido em kernels mais recentes.

license

Informações de licença para o módulo.

description

Breve descrição do módulo.

author

Crédito do autor para o módulo.

srcversion

Hash do código-fonte usado para criar o módulo.

alias

Nomes de alias internos para o módulo.

depends

Lista separada por vírgulas de todos os módulos dos quais este módulo depende.

retpoline

Um flag indicando que o módulo foi criado que inclui uma mitigação contra a vulnerabilidade de segurança do Spectre.

name

O nome do módulo.

intree

Um flag indicando que o módulo foi criado com base na origem em árvore do kernel e não está contaminado.

vermagic

A versão do kernel que foi usada para compilar o módulo, que é verificada em relação ao kernel atual quando o módulo é carregado.

sig_id

O método usado para armazenar chaves de assinatura que podem ter sido usadas para assinar um módulo para Inicialização Segura, geralmente PKCS#7

signer

O nome da chave de assinatura usada para assinar um módulo para Inicialização Segura.

sig_key

O identificador da chave de assinatura para a chave usada para assinar o módulo.

sig_hashalgo

O algoritmo usado para gerar o hash de assinatura para um módulo assinado.

signature

Os dados da assinatura de um módulo assinado.

parm

Parâmetros e descrições do módulo.
Use o comando modinfo -n para localizar o caminho do arquivo para o módulo no sistema de arquivos.
Os módulos são carregados no kernel a partir de arquivos de objeto do kernel (/lib/modules/kernel_version/kernel/*ko*). Para exibir o caminho absoluto de um arquivo de objeto do kernel, especifique a opção -n, por exemplo:
```
modinfo -n parport
```
```
/lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/drivers/parport/parport.ko.xz
```

Carregando e descarregando módulos

Os módulos são carregados e descarregados com o uso do comando modprobe. Para obter mais informações, consulte as páginas do manual modprobe(8) e modules.dep(5).

Carregue um módulo kernel usando o comando modprobe.

O comando modprobe carrega módulos kernel, por exemplo:

sudo modprobe nfs
sudo lsmod | grep nfs

nfs                   266415  0 
lockd                  66530  1 nfs
fscache                41704  1 nfs
nfs_acl                 2477  1 nfs
auth_rpcgss            38976  1 nfs
sunrpc                204268  5 nfs,lockd,nfs_acl,auth_rpcgss

Inclua a opção -v (verbosa) para mostrar se há outros módulos carregados para resolver dependências.

sudo modprobe -v nfs

insmod /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/net/sunrpc/auth_gss/auth_rpcgss.ko 
insmod /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/fs/nfs_common/nfs_acl.ko 
insmod /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/fs/fscache/fscache.ko 
...

Observação

O comando modprobe não recarrega módulos que já estão carregados. Primeiro você deve descarregar um módulo antes de carregá-lo novamente.

Descarregue um módulo usando o comando modprobe -r.
Use a opção -r para descarregar módulos de kernel:
```
sudo modprobe -rv nfs
```
```
rmmod /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/fs/nfs/nfs.ko
rmmod /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/fs/lockd/lockd.ko
rmmod /lib/modules/6.12.0-100.28.2.el10uek.x86_64/kernel/fs/fscache/fscache.ko
...
```
Os módulos são descarregados na ordem inversa em que foram carregados pela primeira vez. Os módulos não serão descarregados se um processo ou outro módulo carregado exigir.

Alterando Parâmetros do Módulo de Kernel

Os módulos de kernel, como drivers de hardware, geralmente têm parâmetros personalizados que podem ser definidos para alterar o comportamento do driver ou do módulo. Vários mecanismos estão disponíveis para atualizar os parâmetros do módulo.

Utilize sysfs para atualizar os parâmetros do módulo imediatamente.
Você pode alterar os valores de alguns parâmetros para módulos carregados e drivers incorporados gravando o novo valor em um arquivo em /sys/module/module_name/parameters, por exemplo:
```
echo 0 | sudo tee /sys/module/ahci/parameters/skip_host_reset
```
Consulte Sobre o Sistema de Arquivos Virtual /sys e Referência de Diretório sysfs.

Observe que as alterações não são persistentes e não se aplicam automaticamente após a reinicialização.
Use o comando modprobe para alterar a configuração em execução de um módulo.
Para alterar o comportamento de um módulo, especifique parâmetros para ele no comando modprobe:
```
sudo modprobe module_name parameter=value ...
```
Separe pares de parâmetro e valor com espaços. Os valores de matriz são representados por uma lista separada por vírgulas, por exemplo:
```
sudo modprobe foo parm=bar arrayparm=1,2,3,4
```
Atualize a configuração modprobe para obter alterações mais permanentes na configuração do módulo.
Os arquivos de configuração (/etc/modprobe.d/*.conf) especificam opções de módulo, criam aliases de módulo e substituem o comportamento usual de modprobe para módulos com requisitos especiais. O arquivo /etc/modprobe.conf usado com versões anteriores de modprobe também é válido se existir. As entradas nos arquivos /etc/modprobe.conf e /etc/modprobe.d/*.conf usam a mesma sintaxe. Consulte Referência de Configuração de Modprobe para obter mais informações.

Especificando módulos a serem carregados no momento da inicialização

O sistema carrega a maioria dos módulos automaticamente no momento da inicialização. Você também pode adicionar módulos a serem carregados criando um arquivo de configuração para o módulo no diretório /etc/modules-load.d. O nome do arquivo deve ter a extensão .conf.

As alterações no diretório /etc/modules-load.d persistem nas reinicializações.

Para forçar um módulo a ser carregado no momento da inicialização, crie um arquivo de configuração no /etc/modules-load.d para o módulo.
Por exemplo, para forçar o carregamento do bnxt_en.conf no momento da inicialização, execute o seguinte comando:
```
echo bnxt_en | sudo tee /etc/modules-load.d/bnxt_en.conf
```
Verifique se o arquivo existe e contém o nome do módulo.
```
cat /etc/modules-load.d/bnxt_en.conf
```
Se o módulo ainda não estiver carregado, você poderá carregá-lo manualmente utilizando o comando modprobe, ou poderá reinicializar o sistema e carregá-lo automaticamente utilizando a configuração fornecida.

Impedindo que módulos sejam carregados no momento da inicialização

É possível impedir que os módulos sejam carregados no momento da inicialização adicionando uma regra de negação em um arquivo de configuração no diretório /etc/modprobe.d e, em seguida, recriando o ramdisk inicial usado para carregar o kernel no momento da inicialização.

Advertência

A desativação de módulos pode ter consequências indesejadas e pode impedir que um sistema seja inicializado ou esteja totalmente funcional após a inicialização. Como prática recomendada, crie uma imagem de ramdisk de backup antes de fazer alterações e certifique-se de que a configuração esteja correta.

Crie um arquivo de configuração para impedir que o módulo seja carregado.

Por exemplo:

sudo tee /etc/modprobe.d/bnxt_en-deny.conf <<'EOF'
#DENY bnxt_en
blacklist bnxt_en
install bnxt_en /bin/false
EOF

Reconstrua a imagem do ramdisk inicial.
```
sudo dracut -f -v
```
Reinicialize o sistema para que as alterações entrem em vigor.
```
sudo reboot
```

Removendo módulos de atualização fracos

Em alguns casos, você pode remover módulos de atualização fracos no lugar de um kernel mais recente, por exemplo, no caso em que um problema com um driver enviado foi resolvido em um kernel mais recente. Nesse caso, você pode preferir usar o novo driver em vez do módulo externo que instalou como parte de uma atualização de driver. Consulte Sobre Módulos de Atualização Fraca para obter mais informações.

Duas abordagens diferentes podem ser usadas para remover um módulo de atualização fraco.

Remova o link simbólico manualmente.
Como os módulos de atualização fracos são vinculados simbolicamente para cada versão do kernel no sistema, você pode remover o link simbólico para o módulo de cada kernel onde você não deseja que ele seja aplicado. Por exemplo:
```
sudo rm -rf /lib/modules/6.12.0-100.28.2.el10uek.x86_64/weak-updates/kmod-kvdo
```
Neste exemplo, o módulo de atualização fraca, kmod-kvdo, é removido do kernel, 6.12.0-100.28.2.el10uek.x86_64.
Use o comando weak-modules para remover o módulo.
É possível usar o comando weak-modules para remover um módulo de atualização fraca especificado em todos os kernels compatíveis ou usar o comando para remover o módulo de atualização fraca do kernel atual. Você também pode usar o comando weak-modules de forma semelhante para adicionar módulos de atualização fraca. Para obter mais informações sobre este comando, execute:
```
weak-modules -h
```
Você também pode usar o comando weak-modules com a opção dry-run para testar os resultados sem fazer alterações reais, por exemplo:
```
weak-modules --remove-kernel --dry-run --verbose
```