Comandos para gerenciar módulos no Linux

Nesse post, vou falar sobre os comandos que utilizamos para gerenciar módulos no Linux. Mas antes de falar sobre os comandos, é necessário saber qual a função do kernel e o que são os módulos.

Em qualquer sistema operacional (isso inclui windows 😛 ), o kernel é o coração do sistema. É ele quem vai interagir com o hardware, gerenciar comunicação entre processos, gerenciar swap, entre outras funções.

Não confundam o kernel com uma distribuição. A distribuição é um Linux empacotado com kernel e aplicativos que vão desde clientes de e-mail a ferramentas de programação e desenvolvimento.

Quando um sistema (Debian, Ubuntu, Slackware, e outros…) é instalado, ele vem com uma configuração genérica, desenhada para executar a maior parte dos programas na maioria dos dispositivos de hardware. Como o kernel deve ser funcional para rodar em qualquer PC e suportar os principais recursos que o usuário pretende utilizar, o desenvolvedor da distro compila um kernel built-in; isto é, um kernel que fornece as funcionalidades básicas e conhece a maior parte dos drivers de dispositivos.Isso que dizer que, mesmo que não esteja usando o driver, ele já está no ar, pronto para ser usado a qualquer momento.

Algumas vezes precisamos acrescentar suporte para um novo dispositivo; para não recompilar o kernel,a cada novo hardware adicionado ao sistema; utilizamos os módulos. Módulos, nada mais são do partes do kernel, carregadas em memória quando solicitadas por algum programa ou dispositivo, e descarregadas quando não estiverem mais em uso.

Os módulos do kernel residem no diretório /lib/modules/<versão_do_kernel>; sendo que <versão_do_kernel> é a versão do kernel instalada no sistema. Caso queira conferir a versão atual, podemos usar o comando uname com a opção -r:

# uname -r
2.6.26-2-686

O comando uname exibe informações sobre o sistema, tais como arquitetura, versão do kernel, etc. Para demais opções do comando, consulte o manual:

# man uname

Bem, determinamos a versão do kernel; para entrar no diretório de módulos dessa versão, executamos:

# cd /lib/modules/2.6.26-2-686/

Ou então:

# cd /lib/modules/$(uname -r)

No comando acima, antes de entrar no diretório /lib/modules, o shell irá substituir o comando que está em parênteses pela versão do kernel. Lembrando que as duas formas para entrar no diretório de módulos está correta… é você quem escolhe qual prefere utilizar!

Sabendo onde os módulos residem no sistema, vamos agora conhecer os comandos usados para gerenciar módulos.

Comando lsmod

Para verificar os módulos estão carregados, usamos o comando lsmod. Vejam abaixo um exemplo de saída do comando:

# lsmod

Module                  Size  Used by
ipv6                  235364  12
loop                   12748  0
ext3                  105512  2
libata                140416  1 ata_generic

Vejam que a saída do comando lsmod é em colunas; é listado todos módulos que estão carregados em memória, inclusive os que não estão em uso. Onde:

Module – exibe o nome do módulo

Size – exibe em bytes, o tamanho da memória do módulo

Used by – exibe a contagem de quantas instâncias do módulo estão carregadas e o módulo que está usando; os valores são importantes porque não podemos remover um módulo que esteja sendo usado, a não ser que nesse campo, o valor seja zero. Também exibe se o módulo depende de outro para funcionar, mostrando o nome do módulo que ele depende.

Também é possível verificar os módulos carregados consultando o arquivo /proc/modules; aliás, o comando lsmod consulta esse arquivo e formata a saída para exibir quais módulos estão carregados. Abaixo, um exemplo de conteúdo do /proc/modules:

# cat /proc/modules
ipv6 235364 12 – Live 0xc8a18000
loop 12748 0 – Live 0xc88f2000
ext3 105512 2 – Live 0xc894b000
libata 140416 1 ata_generic, Live 0xc8902000

A saída do comando é o mesmo resultado que do lsmod, mas com duas colunas a mais. A coluna Live, mostra o estado do módulo, que pode ser: Live (módulo carregado na memória), Loading ou Unloading (esses dois estados acontecem quando usamos os comandos insmod e rmmod).

A última coluna, mostra o valor de memória reservada para o módulo quando é iniciado. Esses valores são úteis para fazer debug no kernel.

Comando insmod

O comando insmod carrega um módulo no kernel; é utilizado para habilitar um dispositivo ou uma funcionalidade; por exemplo, adicionar uma placa de rede ou então habilitar o suporte a um novo sistema de arquivos.

Sua sintaxe é:

# insmod nome_do_módulo

Um detalhe do comando insmod, é que ele insere o módulo de forma manual. Isso quer dizer que, se o módulo depende de outro para que seja carregado, é necessário primeiro resolver a dependência para depois sim, subir o módulo propriarmente dito.

Comando rmmod

Remove um módulo carregado. Sua sintaxe é:

# rmmod nome_do_modulo

O comando rmmod não remove módulos que possuam dependência; caso tente remover um módulo que tenha dependência, irá acusar erro.

Comando modprobe

O comando modprobe é o responsável por carregar um módulo e suas dependências. Assim como o comando insmod, também é utilizado para habilitar um dispositivo ou uma funcionalidade.A sintaxe do comando é:

# modprobe nome_módulo

Podemos usar o comando modprobe para listar os módulos disponíveis em /lib/modules/. Para isso, basta utilizar a opção -l:

# modprobe -l

O comando modprobe também pode ser utilizado para remover módulos. Diferente do comando rmmod, ele remove os módulos e suas dependências. Para executar essa ação, basta usar a opção -r:

# modprobe -r nome_do_módulo

Comando depmod

O comando depmod checa as dependências dos módulos. O resultado dessa checagem é gravado no arquivo /lib/modules/versão_kernel/modules.dep. Para fazer a checagem, usamos o comando com a opção -a, que checa todos os módulos:

# depmod -a

Comando modinfo

O comando modinfo exibe informações sobre um módulo, tais como parâmetros que um módulo aceita, dependências, descrição, etc. Sua sintaxe é:

# modinfo nome_do_módulo

Bem nesse post apenas falei sobre os comandos e suas funções! No próximo post, vou mostrar exemplos de uso desses comandos configurando dispositivos em modo texto. Até lá! 🙂

Referências:

Using Kernel Customization Tools
https://ldn.linuxfoundation.org/node/12626

/proc/modules
http://bit.ly/NdfGx

Kernel e Módulos
http://focalinux.cipsga.org.br/guia/inic_interm/ch-kern.html

Anúncios

Breve visão sobre o Linux

O Linux possui várias características que o faz diferente de outros sistemas operacionais e que o deixam bem próximo do Unix, fazendo assim, que seja uma escolha em várias aplicações que necessitam de estabilidade e segurança.

Vamos entender um pouco da arquitetura do Linux, que basicamente trabalha em camadas:

camadas do linux

Na camada mais interna da figura, temos o hardware, que é representado pelos dispositivos físicos (por exemplo, HD, cdrom, etc).

Em seguida, temos a camada do kernel, que é o coração (núcleo) do sistema operacional e que interage com o hardware. Algumas tarefas do kernel são:

✔ Implementar o sistema de arquivos e meios de acesso (leitura, escrita e execução);

✔ Gerenciar a swap

✔ Gerenciar software que implementa serviços de rede;

✔ Gerenciar comunicação entre processos;

✔ Prover facilidades para criar, examinar e modificar processos;

✔ Prover funções que tornam os recursos do sistema disponíveis aos processos.

Fechando essa camada, temos o shell. Basicamente, shell é um nome comum para um conjunto de programas que tem o propósito de fornecer uma interface interativa com o usuário, onde comandos podem ser digitados, tarefas podem ser controladas, manipuladas, etc.

Por outro lado, os shells também funcionam como linguagem de programação (interpretadas) e são uma forma relativamente eficiente de se executarem tarefas complexas.

Entre os shells conhecidos temos o bash, o csh, sh, ksh. O shell padrão do Linux é o bash.

As diversas faces do Linux

O Linux é um sistema operacional multiusuário, multitarefa e multiprocessado. Ufa!!! Além de tudo isto, ele segue o padrão POSIX/UNIX, o que garante que temos no Linux todo sistema de proteção do núcleo do kernel, ficando um pouco difícil um programa travar em Linux. (Sim! Apesar de ser difícil um Linux pode travar… ;)).

Linux multiusuário

Um sistema multiusuário é capaz de atender a vários usuários interativos simultaneamente. Isto é bem diferente de diversos usuários conectados a um servidor Novell ou NT. Esses usuários são apenas clientes do servidor de arquivos do Netware ou do NT, não são usuários interativos. Aliás, esses dois sistemas são monousuários.

A vantagem disso é que o Linux pode ser distribuído como um servidor de aplicativos; ou seja, Os usuários podem acessar um servidor Linux através da rede local e executar aplicativos no próprio servidor.

Linux multitarefa

Um sistema multitarefa é capaz de executar simultaneamente vários programas, garantindo a melhor distribuição de recursos entre esses programas. Por exemplo, você pode editar a planilha do seu fluxo de caixa enquanto baixa os seus e-mails.

Linux multiprocessado

Um sistema multiprocessado é capaz de tirar proveito de placas-mãe com várias CPUs, ou seja, permite o uso de mais de um processador.

O Linux reconhece mais de um processador e trabalha com SMP (Multiprocessamento Simétrico), clusters de máquinas, na qual uma máquina central controla os processadores das outras para formar uma “única” máquina, principalmente nas versões de kernel mais atuais (graças ao Linux, o Titanic afundou ;))

E além disso…

O Linux oferece diversas vantagens para que o utiliza. A primeira vista, pode parecer um sistema operacional complicado e difícil de trabalhar. Mas aprender Linux, é como aprender um novo idioma… no começo, as palavras são estranhas, não dá pra entender nada e parece que nunca vamos aprender.

Depois de um tempo, com dedicação,começamos arriscar umas palavrinhas, e, quando menos esperamos estamos tagarelando no novo idioma.

Assim é com o Linux. Aprende um comando aqui, um jeito de usar o gerenciador de janelas acolá… quando formos ver, estaremos utilizando o sistema… e o melhor de tudo: sempre aprendendo coisas novas; afinal de contas, no Linux não existe só um jeito pra se fazer as coisas!

Ah, e se não gostar do Linux, não se preocupe: o máximo que vai acontecer é você aprender algo novo! =)