módulos

Definição

O kernel do Linux é do tipo monolítico. Isto significa que o kernel corresponde a um único arquivo executável binário. Para alterar o kernel é preciso recompilá-lo.

Na inicialização do sistema, somente um kernel residente mínimo é carregado na memória. Quando uma funcionalidade que não está presente no kernel é solicitada, um módulo do kernel é dinamicamente carregado para atender a esta necessidade. Este módulo passa a fazer parte do kernel, embora não seja parte do executável do kernel.

Portanto, é possível inicializar o sistema com um kernel qualquer e adicionar os módulos necessários sem precisar reinicializar o sistema.

Caracteríticas

Os módulos

• são executados no espaço do kernel;
• só podem executar funções definidas pelo kernel;
• são orientados a eventos (executam uma determinada tarefa apenas quando recebem uma solicitação);
• possuem uma função de inicialização que o prepara para receber as solicitações;
• possuem uma função de finalização que libera os recursos alocados antes da desinstalação.

Módulo "alomundo"

Abaixo, é apresentado o código do arquivo alomundo.c.

#include <linux/module.h>

MODULE_LICENSE("Dual BSD/GPL");

static int alo_inicio(void) {
    printk("Alo, Mundo!\n");
    return 0;
}

static void alo_fim(void) {
    printk("Adeus, Mundo Cruel!\n");
}

module_init(alo_inicio);
module_exit(alo_fim);

Inicialmente é incluido o cabeçalho module.h que possui as definições necessárias para a compilação de módulos.

• MODULE_LICENSE() - esta macro informa a licença do módulo (no exemplo, o código é disponibilizado sob as licenças BSD e GPL).
• module_init() - macro que define quais funções são chamadas quando o módulo é carregado. Neste exemplo, apenas a função alo_inicio() é chamada.
• module_exit() - macro que define quais funções são chamadas antes do módulo ser removido. Neste exemplo, apenas a função alo_fim() é chamada.
• printk() - função que escreve mensagens do kernel em /var/log/syslog.

Makefile

Para compilar e gerar o arquivo .ko do módulo, crie o arquivo Makefile.

obj-m := alomundo.o

all:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
       make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

No arquivo

• obj-m - especifica os arquivos-objeto que serão usados para gerar os módulos carregáveis do kernel. Neste exemplo, será usado o arquivo alomundo.o para gerar o arquivo alomundo.ko.
• -C diretório - esta opção muda para o diretório especificado antes de ler o Makefile (vai usar esse ambiente na geração dos módulos).
• M diretório modules - vai para o diretório especificado antes de gerar os módulos (os arquivos serão armazenados nesse diretório).

• all - compila o arquivo arquivo.c e gera o módulo. Basta digitar

  make all

  Como este é o padrão, pode-se digitar apenas

  make

• clean - deleta todos os arquivos gerados na execução do Makefile.

  make clean

Carregando o módulo

Para carregar o módulo sem verificar erros, use o comando insmod.

sudo insmod alomundo.ko

sudo modprobe -a ./alomundo.ko

Verificando os módulos

Para ver quais módulos estão carregados, use o comando lsmod

lsmod

less /proc/modules

Informações do módulo

Para ver as informações do módulo use o comando modinfo.

modinfo alomundo.ko

filename:	/home/aluno/estacao/guia/libc/testes/alomundo.ko
license:	Dual BSD/GPL
srcversion:	02E21C2D4758A60BBD6B6D9
depends:
vermagic:	3.18.1-031801-generic SMP mod_unload modversions

Dependências

Para verificar as dependências dos módulos use o comando depmod.

sudo depmod

Removendo o módulo

Para remover o módulo, use o comando rmmod.

sudo rmmod alomundo

Também é possível usar o comando modprobe. Mas, neste caso, o comando só funciona se o módulo estiver armazenado em /lib/modules.

sudo modprobe -r alomundo

Log do sistema

Para ver as mensagens do módulo no log do sistema, use o comando dmesg

dmesg

[ 3693.344434] Alo, Mundo!
[ 3900.333562] Adeus, Mundo Cruel!

less /var/log/syslog

Jan 9 17:43:36 Aluno kernel: [ 3693.344434] Alo, Mundo!
Jan 9 17:47:03 Aluno kernel: [ 3900.333562] Adeus, Mundo Cruel!

Observações

• Os módulos carregáveis são armazenados em /lib/modules/<versão do kernel>. Por exemplo, /lib/modules/3.18.1-031801-generic/kernel/drivers possui os drivers do kernel 3.18 da distribuição Ubuntu.