Como recompilar o kernel
Autor: Patrick Brandão
E-mail: contato@tmsoft.com.br
Copyright: Proibida a cópia ou reprodução do conteúdo ou parte dele, exceto se o nome do autor, e-mail e este aviso constarem na cópia.

O tutorial a seguir não é uma "receita de bolo", embora se pareça muito com um! Trata-se de uma explicação de funcionalidades, princípios e procedimentos. Aplicar os comandos com pressa sem observar as explicações não resultará em sucesso.

O kernel é o nucleo de um sistema operacional, é a parte mais profunda de todos os softwares executados em um computador. Ele é responsável por gerenciar o uso de memória RAM, pelos processos (outros softwares executados sobre o sistema operacional), gerenciar o hardware (torná-lo disponível para o sistema como um todo), alem de gerenciar outros itens comuns (protocolos de rede, data/hora, sistema de arquivos, tipo de processador, etc...).

Normalmente as distribuições Linux acompanham um kernel genérico, compilado para funcionar em qualquer hardware, isso permite a inicialização normal do sistema e a rápida operação do mesmo. Em alguns casos no entanto, recompilar o kernel para um hardware específico pode tornar o sistema mais rápido, alem de permitir alguns recursos especiais (reconhecer mais de 4 Gb de memoria RAM, reconhecer algum hardware adicional, suportar recursos especiais de um tipo de processador).

Arquivos utilizados pelo kernel Linux e suas aplicações práticas

É muito importante saber os arquivos que constituem uma versão do kernel do Linux para poder manejá-los corretamente.
O kernel é constituido basicamente de duas partes:

A - Imagem do kernel: é o kernel em si, a compilação de todas as funções de núcleo dele. Normalmente este arquivo tem entre 512kb e 5 Mb e fica armazenado na pasta /boot.
root@servidor:~# cd /boot
root@servidor:/boot# ls -lah
drwxr-xr-x  2 root root  856 2009-11-29 15:17 ./
drwxr-xr-x 24 root root  568 2009-12-01 09:39 ../
lrwxrwxrwx  1 root root   37 2009-11-29 12:30 README.initrd -> /usr/doc/mkinitrd-1.3.2/README.initrd
lrwxrwxrwx  1 root root   32 2009-11-29 15:16 System.map -> System.map-huge-smp-2.6.27.7-smp
-rw-r--r--  1 root root 906K 2008-11-21 02:01 System.map-generic-2.6.27.7
-rw-r--r--  1 root root 944K 2008-11-21 01:20 System.map-generic-smp-2.6.27.7-smp
-rw-r--r--  1 root root 1.4M 2008-11-21 02:20 System.map-huge-2.6.27.7
-rw-r--r--  1 root root 1.4M 2008-11-21 01:33 System.map-huge-smp-2.6.27.7-smp
-rw-r--r--  1 root root  512 2009-11-29 15:17 boot.0800
-rw-r--r--  1 root root  168 2009-11-29 15:17 boot_message.txt
lrwxrwxrwx  1 root root   28 2009-11-29 15:16 config -> config-huge-smp-2.6.27.7-smp
-rw-r--r--  1 root root  88K 2008-11-21 02:01 config-generic-2.6.27.7
-rw-r--r--  1 root root  88K 2008-11-21 01:20 config-generic-smp-2.6.27.7-smp
-rw-r--r--  1 root root  87K 2008-11-21 02:20 config-huge-2.6.27.7
-rw-r--r--  1 root root  88K 2008-11-21 01:33 config-huge-smp-2.6.27.7-smp
-rw-r--r--  1 root root 5.0K 2008-11-29 15:43 diag1.img
-rw-------  1 root root  76K 2009-11-29 15:17 map
-rw-r--r--  1 root root  16K 2008-02-21 21:08 slack.bmp
lrwxrwxrwx  1 root root   29 2009-11-29 15:16 vmlinuz -> vmlinuz-huge-smp-2.6.27.7-smp
-rw-r--r--  1 root root 2.2M 2008-11-21 02:01 vmlinuz-generic-2.6.27.7
-rw-r--r--  1 root root 2.3M 2008-11-21 01:20 vmlinuz-generic-smp-2.6.27.7-smp
-rw-r--r--  1 root root 4.4M 2008-11-21 02:20 vmlinuz-huge-2.6.27.7
-rw-r--r--  1 root root 4.6M 2008-11-21 01:33 vmlinuz-huge-smp-2.6.27.7-smp
Na lista acima, que é uma lista de um servidor real, podemos visualizar várias imagens disponíveis com tamanhos entre 2.2 Mb e 4.6 Mb.
O nome do arquivo da imagem não é relevante e normalmente segue a mente e a preferencia de quem a fez, no entanto deverá existir uma coerência entre o nome da imagem na pasta /boot e sua referencia no software de boot (lilo, grub, initrd, etc...).

B - Modulos do kernel: são partes opcionais do kernel. Um recurso pode ser build-in ou modular.
Build-in significa que o recurso foi compilado junto com a imagem principal (item A) e é carregado na memória no momento do boot da imagem.e não necessita do modulo separado.
Modular significa que o modulo foi compilado para servir de apoio a imagem do kernel porem não será carregado automáticamente. Será necessário que um software auxiliar faça isso (hotplug, udev, etc..), ou que seja feito manualmente pelo administrador do sistema (atravéz do comando ismod ou modprob).
Os modulos são armazenados na pasta /lib/modules numa sub-pasta que possui como nome a versão e o nome simbólico da compilação.
root@servidor:/boot# cd /lib/modules
root@servidor:/boot# ls -lah
drwxr-xr-x 4 root root  104 2008-11-21 03:44 ./
drwxr-xr-x 5 root root 4.5K 2008-10-23 20:14 ../
drwxr-xr-x 3 root root  632 2008-11-21 03:44 2.6.27.7/
drwxr-xr-x 3 root root  632 2009-11-29 12:35 2.6.27.7-smp/
No exemplo acima temos uma versão do kernel (2.6.27.7) disposta em duas compilações, uma normal (pasta 2.6.27.7) e outra compilada com um nome simbólico (pasta 2.6.27-smp). O nome simbólico é opcional e não tem nenhuma utilidade alem de diferenciar compilações diferentes de uma mesma versão do kernel, como os modulos são armazenados na pasta com a versão do kernel, recompilar a mesma versão de 2 formas diferentes sem especificar um nome simbólico para a segunda compilação significará que os modulos da segunda compilação irão substituir os modulos da primeira, causando um problema sério de incompatibilidade dos modulos disponíveis na pasta com a imagem da primeira compilação.

Dica: Caso deseje fazer um pacote de sua compilação do kernel para instalá-la posteriormente sem necessidade de compilação, bastará que o pacote tenha apenas o arquivo de imagem da pasta /boot e a pasta de modulos de /lib/modules.

Escolhendo código fonte do kernel

Para recompilar o kernel, é necessário ter o código fonte do mesmo. Você pode escolher entre duas opções:

A - Usar código fonte pre-instalado
O linux Slackware instala (em sua instalação completa) os fontes do kernel na pasta /usr/src/
Um link simbólico com o nome "linux" é apontado para a pasta dos fontes. O link simbólico não é obrigatório mas facilita a localização dos fontes do kernel por outros softwares que necessitem de alguma biblioteca para compilar seus programas, como modulos de placas de rede por exemplo. Procure deixar o link sempre disponível.
root@servidor:~# cd /usr/src
root@servidor:/usr/src# ls -lah
drwxr-xr-x  4 root root 128 2009-11-29 12:38 ./
drwxr-xr-x 17 root root 528 2009-10-16 09:41 ../
lrwxrwxrwx  1 root root  14 2009-11-29 12:38 linux -> linux-2.6.27.7/
drwxr-xr-x 23 root root 904 2008-11-21 01:12 linux-2.6.27.7/
No exemplo acima, para recompilar o kernel, poderimos entrar na pasta "linux-2.6.27.7/" ou no seu link simbólico "linux", usar o caminho pelo "linux" seria mais adequado ao padrão.

B - Obter código fonte atualizado do site www.kernel.org

O site http://www.kernel.org/ é o portal que publica as últimas versões e correções do kernel Linux. Procure baixar uma versão estável e testada .(onde o quarto número é par). No exemplo abaixo, usarei a versão 2.6.31.6. Antes do download, entre na pasta /usr/src/.
root@servidor:~# cd /usr/src
root@servidor:/usr/src# wget -c --timeout=5 --tries=300 http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.31.6.tar.bz2
--2009-12-01 11:47:57--  http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.31.6.tar.bz2
Resolving www.kernel.org... 204.152.191.37, 199.6.1.164, 130.239.17.4, ...
Connecting to www.kernel.org|204.152.191.37|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 61446679 (59M) [application/x-bzip2]
Saving to: `linux-2.6.31.6.tar.bz2'
Dica: no comando wget, o parâmetro "-c" ativa a continuação do download a partir de onde parou, o parâmetro "--timeout=5" reconecta caso a conexão fique inativa por mais de 5 segundos, e "--tries=300" tenta baixar o arquivo 300 vezes antes de desistir. Esses parâmetros não tem efeito em links rápidos, mas em links lentos!

No nosso exemplo, baixamos o pacote com os fontes, compactados. É muito importante que você tenha baixado o pacote na pasta /usr/src/, caso não tenha feito isso, mova o arquivo para lá. Devemos descompactá-lo, e apontar o link simbólico "linux" para ela, antes de iniciar os procedimentos de compilação.
root@servidor:/usr/src# tar -xjvf linux-2.6.31.6.tar.bz2
root@servidor:/usr/src# rm linux
root@servidor:/usr/src# ln -s linux-2.6.31.6/ linux
root@servidor:/usr/src# ls -lah
drwxr-xr-x  4 root root 128 2009-11-29 12:38 ./
drwxr-xr-x 17 root root 528 2009-10-16 09:41 ../
lrwxrwxrwx  1 root root  14 2009-11-29 12:38 linux -> linux-2.6.31.6//
drwxr-xr-x 23 root root 904 2008-11-21 01:12 linux-2.6.27.7/
drwxrwxr-x  3 root root 184 2009-11-09 21:32 linux-2.6.31.6/
-rw-r--r--  1 root root 59M 2009-12-01 11:48 linux-2.6.31.6.tar.bz2
Agora que o código fonte atualizado está disponível e o link simbólico "linux" está apontado para ele, podemos iniciar os procedimento de compilação do kernel.

Obtendo informações sobre o hardware do servidor

Os comandos abaixo tem a intenção de descobrir detalhes do servidor, como tipo de processador, quantidade de memória RAM e quais dispositívos principais. Estude-os para obter uma recompilação eficiente do seu kernel.
Todos os recursos do kernel que forem equivalentes ao hardware devem ser marcados para build-in.
root@servidor:/usr/src# cat /proc/cpuinfo
root@servidor:/usr/src# free -m
root@servidor:/usr/src# lspci
Iniciando procedimentos de preparação para compilar o kernel

Antes de compilar o kernel, é necessário escolher algumas opções de configuração da compilação. Estas opções irão determinar, alem de questões vitais como tipo de processador, quais recursos serão build-in e quais serão modulares. As opções de configuração ficam dentro da pasta dos fontes (/usr/src/linux) no arquivo .config.

1 - Copiando opções do kernel atual (passo opcional)

Quando o kernel é iniciado em distribuições normais, uma pasta virtual é montada em /proc, contendo informações sobre o núcleo do sistema. Dentro desta pasta há um arquivo chamado config.gz, que contem as configurações que foram utilizadas na compilação do kernel nativo da distribuição (normalmente o mantenedor da distribuição).
Copiar as configurações utilizadas na compilação nativa para a sua compilação pode garantir o exito logo na primeira vez que realizar a compilação.

Entre na pasta dos fontes para iniciar a preparação das opções, copiando-as do /proc/config.gz:
root@servidor:/usr/src# cd linux
root@servidor:/usr/src/linux# cp /proc/config.gz config.gz
root@servidor:/usr/src/linux# gunzip config.gz
root@servidor:/usr/src/linux# cp config .config

2 - Personalizando opções de compilação

Dentro da pasta dos fontes (/usr/src/linux), execute o comando "make menuconfig", que abrirá o menu para as escolhas de configuração.
- Opções marcadas com * serão compiladas na imagem do kernel (para arquivo em /boot/).
- Opções marcadas com M serão compiladas como modulos (para pasta em /lib/modules/).
- Opções desmarcadas não serão compiladas.
- Opções que aparecem com -- não estão disponíveis para serem escolhidas, se outros recursos precisarem da opção, ela será compilada como build-in.

Se não souber o que fazer em alguma opção, não altere-a ou consulte o menu Help.
root@servidor:/usr/src/linux# make menuconfig


Organização importantes do menu principal:
General setup: escolher suporte a modulos experimentais, nome simbólico da compilação (recomendável alterar), opções de métodos de analise de processos e formatos internos do kernel.
Processor type and features: É aqui que se escolhe o tipo de processador e suporte a grandes quantidades de memória RAM.
Power management and ACPI options: opções de gerenciamento de energia, muito útil em notebooks, pouco útil em servidores.
Networking support: suporte a protocolos (IP, PPPoE, etc...) e firewall (iptables).
Device Drivers: drivers para reconhecimento de placa de rede, video, som, etc... marque como build-in as opções do seu tipo de hardware.
File systems: suporte a tipos de sistema de arquivos, garanta que há suporte a ReiserFS, Ext2, Ext3 e Ext4

No menu General setup, informe o nome simbólico da compilação, usarei "-srv" neste exemplo:


Volte ao menu principal, e entre no menu Processor type and features, escolha o tipo de processador, caso tenha dúvidas, consulte o arquivo /proc/cpuinfo, se o servidor possuir mais de 3 gigas de memória RAM, escolha suporte a 64 Gb.





Iniciando compilação do kernel

Agora que o cenário está pronto, saia do menu e volte ao shell, use o menu Exit para tal. Concorde em salvar as configurações.
Recompilar o kernel pode demorar, entre 20 min a 4 horas, isso irá depender do seu processador.

Execute os comando de compilação. Para não ter que esperar passo a passo, separe-os por ponto-e-virgula.
root@servidor:/usr/src/linux# make all; make modules_install; make bzImage

  CHK     include/linux/version.h
  CHK     include/linux/utsrelease.h
  UPD     include/linux/utsrelease.h
  SYMLINK include/asm -> include/asm-x86
  CALL    scripts/checksyscalls.sh
  HOSTCC  scripts/mod/modpost.o
  HOSTCC  scripts/mod/sumversion.o
  HOSTLD  scripts/mod/modpost
  HOSTCC  scripts/kallsyms
  HOSTCC  scripts/pnmtologo
  HOSTCC  scripts/conmakehash
  HOSTCC  scripts/bin2c
  CC      init/main.o
  CHK     include/linux/compile.h
  UPD     include/linux/compile.h
  CC      init/version.o
  CC      init/do_mounts.o
  CC      init/do_mounts_rd.o
  .
  .
  .
  (muitas e  muitas linhas depois)
  .
  .
  .
  IHEX2FW firmware/keyspan_pda/keyspan_pda.fw
  IHEX2FW firmware/keyspan_pda/xircom_pgs.fw
  IHEX    firmware/yam/1200.bin
  IHEX    firmware/yam/9600.bin
  CHK     include/linux/version.h
  CHK     include/linux/utsrelease.h
  SYMLINK include/asm -> include/asm-x86
  CALL    scripts/checksyscalls.sh
  CHK     include/linux/compile.h
Kernel: arch/x86/boot/bzImage is ready  (#1)
Ao finalizar a compilação, 2 coisa estão prontas: os modulos estarão instalados na pasta /lib/modules e a imagem disponível na sub-pasta "arch". Veja que na última linha está a referência da imagem: "arch/x86/boot/bzImage". Essa referencia depende do tipo de processador escolhido.

Copie-a para a pasta /boot/ com um nome único, uma forma de fazer isso é usar a versão e o nome simbólico escolhido (no nosso caso "-srv"). 
root@servidor:/usr/src/linux# cp arch/x86/boot/bzImage  /boot/kernel-2.6.31.6-srv

Registrando o novo kernel no boot

O novo kernel está pronto para ser utilizado, o último passo é colocá-lo no boot. Esse passo requer MUITA ATENÇÃO, pois programá-lo erroneamente pode invalidar o boot do servidor. Vou explicar como fazer pelo lilo, por ser o mais comum.

Primeiro passo, edite o /etc/lilo.conf
root@servidor:/usr/src/linux# mcedit /etc/lilo.conf
Vá até o final do arquivo, onde há as declarações de imagens do kernel. Em um sistema normal, apenas uma imagem é declarada. O lilo, por padrão, dá preferência em dar boot automático na primeira imagem declarada. Para testar o novo kernel, vamos colocá-lo como secundário, caso ele falhe, um novo reboot poderá iniciar a imagem original.

Duplique a declaração existente, alterando apenas o nome e o caminho da imagem do kernel, mantendo-se assim a referência da partição do disco. MUITA ATENÇÃO, replicar o exemplo abaixo é incorreto, faça guiando-se pelo modelo e não pela regra copiar-colar.

/etc/lilo.conf original no servidor de exemplo:


/etc/lilo.conf após alteração para inclusão da nova imagem do kernel:


Após configurar o arquivo /etc/lilo.conf, é necessário carregar as opções configuradas na MBR ou partição de boot, para isso, execute o comando "lilo"
root@servidor:/usr/src/linux# lilo
Warning: LBA32 addressing assumed
Added Linux *
Added Linux-2.6-srv
One warning was issued.
É normal aparecer o "Warning", pela ausencia da palavra "lba32" no lilo.conf, de desejar remover o warning, coloque no inicio do lilo.conf a palavra lba32
Se aparecer alguma mensagem de "Unrecognized", "Error" ou "Fatal error", não reinicie o servidor, descubra o que foi feito de errado até que o lilo complete a execução normal.

Depois de corrigir os erros, faça um reboot, na tela do lilo aparecerá a opção da nova imagem compilada.

Se você chegou até aqui com sucesso, parabens pelo esforço, se seu kernel funcionou de primeira sem dar "kernel panic", parabens dobrado!

Caso contrário, observe a mensagem que precede o "kernel panic" e peça ajuda ao Google!


Criando pacote para instalação rápida

Após fazer funcionar, é recomendável criar um pacote de instalação do novo kernel, para acelerar a reinstalação caso o servidor seja formatado. Para fazer o pacote, crie uma pasta vazia e copie para ela os arquivos que constituem o kernel (imagem e modulos). Aprenda com o exemplo a seguir:
root@servidor:/usr/src/linux# cd /usr/src
root@servidor:/usr/src# mkdir slackpkg
root@servidor:/usr/src# cd slackpkg
root@servidor:/usr/src/slackpkg# mkdir install
root@servidor:/usr/src/slackpkg# mkdir boot
root@servidor:/usr/src/slackpkg# mkdir -p mkdir lib/modules
root@servidor:/usr/src/slackpkg# cp /boot/kernel-2.6.31.6-srv boot/
root@servidor:/usr/src/slackpkg# cp -rva /lib/modules/boot/kernel-2.6.31.6-srv boot/
root@servidor:/usr/src/slackpkg# du -hs
33M     .
root@servidor:/usr/src/slackpkg# tar -cpzvf kernel-2.6.31.6-srv.tgz ./install ./boot ./lib
root@servidor:/usr/src/slackpkg# ls -lah
drwxr-xr-x 5 root root 160 2009-12-01 06:33 ./
drwxr-xr-x 6 root root 224 2009-12-01 06:30 ../
drwxr-xr-x 2 root root  88 2009-12-01 06:30 boot/
drwxr-xr-x 2 root root  48 2009-12-01 06:33 install/
-rw-r--r-- 1 root root 15M 2009-12-01 06:33 kernel-2.6.31.6-srv.tgz
drwxr-xr-x 3 root root  72 2009-12-01 06:30 lib/
Copie o arquivo kernel-2.6.31.6-srv.tgz para um pen-drive ou para um lugar seguro contra acidentes no servidor. Caso um dia precise formatá-lo, esperar o longo tempo de recompilação do kernel não será necessário!

O único passo que não pode ser "empacotado" é a configuração do /etc/lilo.conf

A imagem utilizada no exemplo deste tutorial está disponível na url: http://www.tmsoft.com.br/downloads/kernel/kernel-2.6.31.6-srv.tgz e foi compilado com 64 Gb de RAM para Dualcore, Core2duo ou Xeon, 32 bits. Enjoy!