www.howtoday.com.

br

KERNEL

Como já foi visto de maneira resumida na introdução deste material, o

Kernel é o responsável por suportar e interagir com os recursos lógicos e físicos
que podem ser oferecidos pelo sistema. Uma placa de rede Wireless só
funciona se o Kernel der suporte a ela, assim como também o protocolo ipv6 só
funciona se o Kernel o suportar. Para saber das modificações que estão sendo
feitas no código-fonte do Kernel, basta observar a seção de Changelogs do site
www.kernel.org .
Antes de configurar, compilar e instalar um novo Kernel, é preciso saber
que tipo de Kernel o administrador vai querer implementar. Os tipos são:

Kernel Monolítico
Este tipo de kernel deixa junto com a imagem de boot do Kernel todo e
qualquer suporte implementado a qualquer tipo de recurso, podendo tornar a
inicialização do sistema um pouco mais demorada.

Kernel Modular
Neste caso em específico, uma grande quantidade de recursos fica em
módulos, que são instalados a parte e não precisam serem carregados juntos
com o sistema. Neste caso, há mais facilidade em gerenciar recursos, uma vez
que, se não quiser um recurso, basta adicioná-lo a uma “blacklist” de módulos.
É importante destacar também que nem todos os recursos podem ser
colocados em módulos, alguns têm que ser “built-in” mesmo, por exigência do
Kernel, sendo assim, nenhum Kernel é totalmente modular.

Versões do Kernel
A sintaxe de versão do Kernel é:
<versão maior>. <versão menor>
.<correção/patch/atualização>.<verso extra>
Antes do Kernel 2.4 ser lançado, as versões aumentavam de forma que
uma versão menor que fosse ímpar representava um Kernel instável ainda,
enquanto uma versão menor que fosse par significava em Kernel estável. Hoje
isso não é mais uma realidade, uma vez que Linus Torvalds decidiu que as
alterações seriam feitas no terceiro campo. A versão menor só será alterada se
for uma mudança muito brusca na estrutura do Kernel.
Exemplo:
Uma versão recompilada para dar suporte a Paravirtualização, no Kernel
2.6.35, teria a nomenclatura:
2.6.35-Virt

Compilação de Kernel

A possibilidade de download, reconfiguração e reinstalação de um novo

Kernel fascina os administradores de sistemas Linux ao redor do mundo. Os
motivos pelos quais um administrador pode querer recompilar um Kernel são
muito simples de se explicar: obter melhor performance de recursos de
hardware do sistema, como processador, memória RAM, placas de vídeo e
 www.howtoday.com.br

rede, por exemplo; ter que habilitar suporte a recursos adicionais, como
paravirtualização e PAE (para sistemas de 32 bits poderem reconhecer
memórias RAM de mais de 4GB); personalizar uma distro para que ela possa
ter um fim específico, como uma distro exclusiva para Firewall, como o
SmothWall, por exemplo, que tem suporte a muitos adaptadores de rede mas
não suporta placas aceleradoras gráficas funcionando em modo pleno, já que o
Kernel desta distro está compilad para ser um Firewall e não uma estação de
jogos, ou de edição gráfica.
O procedimento para a sua recompilação consiste em algumas etapas:

Configuração
Nesta etapa ocorre a escolha de quais recursos serão instalados. É
preciso entender muito bem de recursos como rede, discos, dispositivos e
recursos de hardware, redes e de sistemas de arquivos, pois as opções de
configuração do Kernel são muitas e escolher a opção errada pode custar o não
reconhecimento de alguns recursos desejados.

Compilação
A compilação de um software qualquer consiste em converter os
códigos-fonte dele para arquivos binários (linguagem de máquina). Numa
compilação de Kernel não é diferente, um vez que existe a necessidade de os
módulos e recursos “Built-in” interagirem com os hardwares de sistema.

Instalação
O conceito de instalação é a cópia de binários do um programa para um
diretório de instalação.

Procedimentos para compilação de instalação de um novo Kernel

Para este procedimento, vamos utilizar a versão 2.6.35.4 do Kernel

obtida em www.kernel.org.

Descompactar o diretório de código-fonte do Kernel em /usr/src:

#tar –xjf linux-2.6.35.4.tar.bz2 –C /usr/src

Criar um link simbólico do diretório de compilação (apenas para facilitar o

procedimento):
#ln –s /usr/src/linux-2.6.35.4 /usr/src/Linux

Instalar programas necessários, entrar no diretório do código-fonte e co-

meçar a configuração do Kernel:
#apt-get install libncurses5-dev gcc build-essential make -y
#cd /usr/src/linux
#make menuconfig
 www.howtoday.com.br

Os métodos de configuração de Kernel são os seguintes:

#make config : método de configuração em modo texto. Não tem menu
nenhum e confirma opção por opção, exigindo que o usuário diga
obrigatoriamente a qual recurso ele não quer dar suporte.
#make menuconfig : esta opção conta com um menu para terminal
que dinamiza muito mais a escolha das opções, uma vez que o administrador
só precisa configurar os recursos que ele quer.
#make oldconfig : restaura a configuração de um arquivo .config já
pronto.
#make xconfig : configuração através de interface gráfica do servidor
X.

É importante, antes de fazer a configuração do Kernel, definir qual vai ser

a versão atual do Kernel que está sendo reconfigurado, isto pode ser feito
dentro do arquivo Makefile, como no exemplo da figura a seguir:
 www.howtoday.com.br

Depois de configurada a versão do Kernel, vamos partir para a

configuração do mesmo. A figura abaixo é de uma configuração feita com o
comando #make menuconfig. Após a conclusão deste passo, Serpa gerado
um arquivo chamado .config, que irá conter as escolhas feitas na configuração
realizada com o comando em questão.
Os recursos que podem ser adicionados como “Built-in” ou como
“Modulares” estão com < >, enquanto aqueles que só podem ser
implementados em Built-in estão com [ ].

Resolvendo dependências antes de começar a compilação:

#make dep
No caso abaixo, todas as dependências estão satisfeitas, tornando assim
o uso de make dep desnecessário.

Removendo arquivos de compilações anteriores:

#make clean

Criando a imagem de boot do Kernel no diretório

arch/<arquitetura_do_kernel>/boot:
 www.howtoday.com.br

#make bzImage

É importante lembrar que até este momento nenhuma ação foi tomada
em relação aos módulos, já que a imagem de boot é totalmente independente
dos módulos do Kernel.
Este passo irá compilar a imagem do Kernel e criar um arquivo de
imagem desta imagem, assim, o gerenciador de boot poderá executar o boot
por ela.
No caso, #make bzImage usa o agente compactador BZIP2 para
comprimir a imagem, esta imagem também pode ser carregada em memória
estendida, enquanto #make zImage usa o agente COMPRESS e só pode
compactar imagens pequenas de Kernel (até 500KB). É justamente por causa
desta diferença que em grande maioria das compilações é escolhido o método
#make bzImage.

Compilando os módulos:
#make modules

Instalando os módulos em /lib/modules/<versão do kernel>:

#make modules_install

Criando uma imagem INITRD dos módulos instalados:

#cd /lib/modules
#mkinitramfs -o /boot/initrd.img-2.6.35-VIRTUAL 2.6.35-VIRTUAL
Os módulos instalados não são carregados durante o boot, a não ser que
eles sejam declarados no arquivo /etc/modules ou que estejam dentro de uma
imagem INITRD e que o boot loader aponte para ela.

Copiar a imagem do Kernel para o diretório de boot:

#cp -p arch/<arquitetura do kernel>/boot/bzImage
/boot/vmlinuz-2.6.35-VIRTUAL
Para manter o padrão de nomenclatura, deve-se copiar a imagem do
Kernel para /boot com o nome de vmlinuz-2.6.35-VIRTUAL.

Atualizar o boot loader GRUB:

#update-grub

Reiniciar o sistema:
#shutdown -r now

Comandos de Kernel

#uname
Exibe informações sobre o Kernel em execução.

Opções:
-a : exibe todas as informações sobre o Kernel instalado.
-n : exibe o hostname.
-r : exibe a versão do Kernel instalado.
-m : exibe a arquitetura do Kernel instalado.
 www.howtoday.com.br

-s : exibe o nome do Kernel instalado.

-p : exibe o processador do sistema.
-o : nome do sistema operacional.

#lsmod
Exibe módulos que foram carregados.

#modinfo
Exibibe informações detalhadas sobre um módulo específico, como
informações sobre autoria, versão, arquitetura, dependências, etc.

Sintaxe:
#modinfo <módulo>

Exemplo:

Obtendo informações sobre o módulo iptable_nat:

#modinfo iptable_nat

#depmod
Atualiza o aquivo de dependências de módulos em
/lib/modules/<versão>/modules.dep com novos módulos instalados.

#modprobe
Insere os módulos e suas depoendências no Kernel em execução.
Também tem opções de consulta e exclusão de módulos.

Sintaxe:
#modprobe <opções> <módulo>

Opções:
-l : lista localização dos módulos.
-t : indica o tipo dos módulos (seção de módulos).
Seções:
arch : módulos de arquitetura do Kernel.
crypto : módulos de criptografia.
drivers: módulos de drivers de dispositivos de hardware.
net: módulos de dispositivos de rede.
sound: módulos de recursos de som.
fs : módulos de filesystems.
lib : módulos de bibliotecas.

-r : remove um módulo.

Exemplos:

Inserindo o módulo tun no Kernel:

#modprobe tun

O caminho de uma seção de módulo é sempre

/lib/modules/<versão>/kernel/<seção>
 www.howtoday.com.br

Removendo o módulo tun do Kernel:

#modprobe -r tun

Mostrando a localização do arquivo de módulo do módulo ip_conntrack:

#modprobe -l ip_conntrack

Mostrando os 10 primeiros arquivos de módulos da seção de drivers de

dispositivos de rede:
#modprobe -l -t net | head -10

#insmod
Isere um módulo no Kernel em execução mas não resolve dependências
de módulos.

Sintaxe:
#insmod <módulo>

#rmmod
Remove módulos de um Kernel em execução.

Sintaxe:
#rmmod <opção> <módulo>

Opções:
-a : remove todos os módulos que não estão sendo usados.
-f : força a remoção do módulo.
-v : verbose.

Comandos de Hardware

#lspci
Mostra os dispositivos de hardware que utilizam o barramento PCI.

#lsusb
Mostra todos os dispositivos conectados à porta USB.