Recompilando o Kernel Tutoriais

O Kernel inclui todos os drivers de dispositivos suportados pelo sistema e até mesmo alguns programas, como o Iptables, o firewall nativo do Linux a partir do Kernel 2.4 e (opcionalmente) o Tuxserver, um servidor Web desenvolvido pela Red Hat é compilado como um módulo do Kernel para rodar mais rápido. Programas como o VMware e o Qemu (com o módulo Kqemu) utilizam um módulo no Kernel para ter acesso direto ao hardware e assim rodar com um melhor desempenho.

Para manter a compatibilidade com o maior número possível de dispositivos, as distribuições devem incluir também todos os quase todos os drivers de dispositivos disponíveis para o Linux. Para evitar que isto torne o Kernel muito grande, criam um kernel básico, com os drivers mais importantes e incluem os demais drivers como módulos. Durante a instalação, ou a rodar algum utilitário de detecção e configuração de hardware, apenas os módulos necessários são carregados.

Os módulos oferecem mais uma vantagem: podem ser carregados e descarregados conforme necessário, sem ficarem o tempo todo consumindo memória RAM e recursos do sistema. Uma distribuição típica, com o Kernel 2.6, inclui uma pasta de módulos com cerca de 50 MB, com pouco mais de mil módulos diferentes. Mas apenas 20 ou 30 deles ficam carregados durante o uso.

Recompilar o Kernel do Linux lhe dá a chance de criar um kernel adaptado às suas necessidades, ao contrário do tamanho único incluído nas distribuições. Você vai precisar recompilar o Kernel caso precise adicionar o suporte a algum dispositivo, cujo driver só está disponível na versão mais recente. USB 2.0? Wireless? Bluetooth? Estas tecnologias já eram suportadas pelo Linux bem antes dos primeiros produtos chegarem ao mercado, mas quem possui uma versão antiga do Kernel precisa atualizá-lo para adicionar o suporte.

É possível adicionar também patches com recursos experimentais, ainda não incluídos no Kernel oficial, incluindo novos drivers, suporte a novos sistemas de arquivos (como o suporte a Cloop ou UnionFS) ou melhorias de desempenho.

Felizmente, atualizar ou personalizar o Kernel é uma tarefa relativamente simples, que pode se tornar até corriqueira, já que numa máquina atual, um Athlon de 2.0 GHz por exemplo, a compilação do executável principal de um Kernel da série 2.6 demora por volta de 5 minutos. Em seguida vem a compilação dos módulos, que é bem mais demorada mas não é necessária ao fazer apenas pequenas modificações no Kernel atualmente em uso.

O processo todo pode ser dividido nos seguintes passos:

É possível manter vários Kernels instalados na mesma distribuição e escolher entre eles na hora do boot. Assim você pode manter o Kernel antigo instalado e voltar para ele em caso de problemas com o novo.

Baixando os fontes

O primeiro passo é naturalmente obter o código fonte do Kernel, que iremos compilar. Se você quer apenas criar um kernel personalizado, pode usar como base o código fonte do próprio Kernel incluído na sua distribuição. Durante a instalação quase sempre existe a opção de instalar o código fonte do Kernel (o pacote kernel-source) e os compiladores.

Você pode também instala-los posteriormente. No Mandrake por exemplo, use o comando:

# urpmi kernel-source

No Debian existem várias versões diferentes do Kernel disponíveis no apt-get. Você deve primeiro checar a versão que está usando usando o comando "uname -a" e em seguida instalar o pacote correto, como em:

# apt-get install kernel-source-2.6.8

No Kurumin, Kanotix e algumas outras distribuições, existe um comando chamado "install-kernel-source-vanilla.sh", desenvolvido pelo Kano, que se encarrega de baixar os fontes, junto com um conjunto de patches úteis.

É sempre muito mais fácil usar como base o fonte e configuração do Kernel que está usando na sua máquina, com todos os patches e modificações. Assim você começa com uma configuração que está funcionando e faz apenas as alterações desejadas, com uma possibilidade muito menor de surgirem problemas.

Depois de pegar um pouco de prática, você pode se aventurar a baixar uma versão "crua" da última versão do Kernel no http://www.kernel.org e fazer uma experiência começando do zero.

Salve o arquivo no diretório "/usr/src/" onde por padrão ficam armazenados os fontes do Kernel. Não se assuste, o arquivo com o fonte do Kernel é mesmo grande, mais 30 MB (compactado) nas versões recentes.

Depois de baixar o pacote, você ainda precisará descompactá-lo, usando o comando:

# tar -zxfv linux-2.x.x.tar.gz

Alterando o nome do arquivo para o que foi baixado.

Se o arquivo tiver a extensão tar.bz2, então o comando fica:

# tar -jxfv linux-2.x.x.tar.bz2

Aproveite que está aqui para criar o link "linux", que deve apontar para a localização do código fonte do novo kernel:

# ln -sf linux-2.x.x linux

Em geral, ao instalar o pacote "kernel-source" será apenas copiado o arquivo compactado para dentro da pasta /usr/src/. Você ainda precisará descompactar e criar o link "/usr/src/linux", como ao baixar manualmente.

Na verdade o link /usr/src/linux não é obrigatório, ele é apenas uma localização padrão, usada por muitas ferramentas, assim como um discador de Internet vai sempre tentar acessar o modem usando o device "/dev/modem". De qualquer forma, todo o trabalho de compilação será feito dentro pasta com o fonte do kernel, como em: /usr/src/linux-2.6.8.1/

Configurando

Acesse o diretório /usr/src/, e dentro dela a pasta onde está a versão do Kernel que será recompilada:

# cd /usr/src/linux

Dando um ls, você vai ver as várias pastas e arquivos que formam o código do Kernel. Se você quer realmente aprender a programar, vai aprender bastante examinando o código. Comece pela pasta Documentation. :-)

Com o código em mãos, o próximo passo é definir os componentes que serão incluídos no novo Kernel, usando o xconfig (gráfico) ou menuconfig (texto), duas opções de ferramentas de configuração.

O objetivo destas duas ferramentas é apenas ajudar a selecionar as opções disponíveis e gerar um arquivo de texto, o ".config" que será usado durante a compilação. Como todo arquivo de texto, ele pode ser até mesmo editado manualmente, mas isto não é muito prático num arquivo com quase 3.000 linhas :-)

Mãos às obra então:

# make xconfig

No Kernel 2.6 o "make xconfig" chama o qconf, um utilitário bem mais amigável, criado usando a biblioteca QT. No Kernel 2.4 o mesmo comando chamava um utilitário bem mais simples, baseado na biblioteca TK:

Em qualquer um dos casos, ao recompilar o Kernel incluído na distribuição, o primeiro passo é carregar o arquivo com a configuração atual do Kernel. Isso evita muitos problemas, pois você começa com o Kernel configurado com exatamente as mesmas opções atualmente em uso. Fica mais fácil localizar e corrigir problemas assim, pois você precisa se preocupar apenas com as opções que alterou.

Por padrão, o arquivo com a configuração do Kernel vai sempre na pasta /boot, como em: "/boot/config-2.6.8.1-kanotix-10" ou "/boot/config-2.6.8.1-12mdk".

No qconf vá em File > Load e aponte o arquivo:

As opções estão divididas em categorias, com um descrição resumida de cada opção no nível mais baixo. A esmagadora maioria das opções está relacionada justamente com suporte a dispositivos.

Para cada módulo, existem três opções: compilar no executável principal do Kernel (um símbolo de "ok" no no Qconf ou um "Y" no xconfig antigo), compilar como módulo (um ponto no Qconf ou um "M" no antigo) ou desativar.

Compilar o componente na forma de um módulo faz com que ele seja carregado apenas quando necessário, sem inchar o Kernel. Esta é a opção ideal para todos os componentes que quiser manter, mas não tem certeza se serão usados freqüentemente.

Coisas como o suporte à sua placa de rede, som, suporte a gerenciamento de energia para o seu notebook podem ser compilados diretamente no Kernel, mas não exagere, pois um Kernel muito grande vai demorar para ser compilado e terá um desempenho um pouco menor. O ideal é compilar tudo que não for essencial como módulo, como fazem as principais distribuições.

Uma ressalva importante é que você SEMPRE deve adicionar o suporte ao sistema de arquivos, no qual a partição raiz do sistema está formatada (reiserfs, ext3, xfs, etc.) diretamente no Kernel e não como módulo, caso contrário você cria um problema do tipo o ovo e a galinha: o Kernel precisa carregar o módulo reiserfs para acessar a partição, mas precisa acessar a partição para carregar o módulo. No final das contas você acaba com um Kernel panic.

Os módulos com o suporte aos sistemas de arquivos principais (ext, reiser, xfs, jfs, etc.) estão logo no diretório principal da seção "File systems" do Qconf.

O suporte a sistemas de arquivos menos comuns estão nos subdiretórios. Você deve compilar o suporte a ReiserFS diretamente no Kernel se a partição raiz do sistema está formatada neste sistema de arquivos, mas pode compilar como módulo se a partição raiz está formatada em ext2 e apenas a partição home está formatada em ReiserFS por exemplo.

O suporte à sistemas FAT, NTFS, etc. podem ser sempre compilados como módulo, enquanto o suporte a sistemas menos comuns, que você nunca vai usar (Minix e Amiga por exemplo) podem ser desabilitados. Lembre-se que no qconf um ponto indica que um componente está selecionado como módulo e um "ok" que será compilado diretamente no Kernel:

Um remendo para este tipo de situação é criar um initrd contendo o módulo necessário. O initrd é carregado diretamente pelo gerenciador de boot, o que permite que o Kernel tenha acesso ao módulo antes de ter acesso à partição. O initrd é um arquivo compactado, contendo uma imagem de sistema que vai na parta /boot. Você pode alterar seu conteúdo descompactando o arquivo e em seguida montando-o com o comando "mount -o loop initrd tmp/"

A configuração do initrd a ser usado vai no arquivo de configuração do lilo (/etc/lilo.conf) na linha:

initrd=/boot/initrd.gz

Para ativar o suporte a ACPI por exemplo, acesse a categoria "Power management options" e ative o "ACPI Support", junto com os módulos AC Adapter (usado em micros desktop ou notebooks ligados na tomada) e Battery (que monitora o estado da bateria do notebook e ativa os recursos de economia de energia suportados).

Os outros módulos adicionam mais funções úteis, a opção Fan permite diminuir a rotação dos coolers e o módulo Processor permite diminuir a frequência do processador para economizar energia e assim por diante.

Quase todas as opções possuem descrições, mas é preciso ter bons conhecimentos de hardware para entender a função da maioria delas. A pasta Documentation/, dentro da pasta com o fonte contém descrições bem mais completas sobre a função de cada módulo. Os textos falam mais sobre os componentes e recursos suportados por cada módulo do que sobre programação, por isso os textos também são muito úteis para quem está estudando sobre hardware e suporte a dispositivos no Linux.

A opção mais importante com relação ao desempenho é indicar qual processador está sendo utilizado. Isto fará com que o Kernel seja compilado com otimizações para a arquitetura, o que pode resultar em um ganho de desempenho de até 30% em alguns casos. Para isto, acesse a seção "Processador Type and Features" na tela principal do xconfig e clique na opção "Processador family":

A opção 386 gera um código que funciona em qualquer PC, desde um 386 até um Pentium 999² ou Athlon XYZCu. A opção 486 gera algumas otimizações para a arquitetura pipelinizada do 486, mas mantendo a compatibilidade com todos os processadores daí em diante.

A opção "586/K5/5x68/6x86/6x86MX" é a mais usada, pois gera um Kernel compatível com todos os processadores a partir do Pentium, com um nível de otimização razoável. Acima desta temos otimizações específicas para cada família de processadores, que garantirão um nível máximo de desempenho, em troca da compatibilidade. Compilar o Kernel com otimizações para o Pentium 4 irá torná-lo incompatível com máquinas Athlon ou Pentium III por exemplo. Mas, claro, isto não é um problema se você só utilizará este novo Kernel na sua própria máquina.

Na verdade o nível de otimização do Kernel tem um efeito pequeno sobre o desempenho geral da máquina na maioria dos casos, pois o Kernel em sí representa apenas uma pequena parte do sistema. Sobre ele temos pesos pesados com o X, KDE e o OpenOffice. Em geral, otimizar o Kernel para o seu processador, sem mexer nos demais programas gera um ganho médio de apenas 2 ou 3%.

Outra opção comum é ativar o suporte a dois processadores. Esta opção é necessária caso você esteja usando um micro com dois processadores, ou um Processador Pentium 4 com HT e queira que o sistema reconheça o segundo processador lógico.

Em troca, ativar o suporte a multiprocessamento diminui sutilmente o desempenho do sistema em máquinas com apenas um processador, pois o sistema continua com o código necessário carregado na memória. Para ativar, habilite (ainda dentro da seção "Processador Type and Features") a opção: "Symmetric multi-processing support".

Depois de terminar, clique na opção "Save and Exit" no menu principal para salvar todas as alterações.

Além do xconfig, você pode utilizar também o menuconfig, que oferece basicamente as mesmas opções, mas numa interface de texto. Ele serve como segunda opção caso o xconfig, que no Kernel 2.6 depende da biblioteca Qt esteja indisponível. Para chamá-lo, use o comando:

# make menuconfig

Tanto faz utilizar o xconfig ou o menuconfig, pois os dois gravam as alterações no mesmo arquivo, o .config, dentro do diretório /usr/src/linux. Existe ainda uma quarta opção, mais espartana o "make config" que chama um programa de modo texto que simplesmente vai perguntando um a um quais componentes devem ser incluídos (exige uma boa dose de paciência..:)

Compilando

Depois de configurar o novo Kernel, você pode compilar e instalar usando os quatro comandos abaixo. Lembre-se que para compilar qualquer programa no Linux é necessário ter o compilador gcc instalado.

# make clean

O make clean serve para limpar a casa, removendo restos de compilações anteriores e módulos desnecessários. Ao recompilar um Kernel da série 2.4 é necessário rodar também o comando "make dep", que verifica a cadeia de interdependências do Kernel.

# make bzImage

Este é o comando que compila o executável principal do Kernel, o arquivo que vai na pasta /boot. O tempo varia de acordo com a velocidade do processador, mas é sempre relativamente rápido, já que estamos falando de um executável de geralmente 1.5 ou 2 MB. num PC atual não demora mais do que 4 ou 6 minutos.

Em versões antigas do Kernel era usado o comando "make zImage" mas ele tem uma limitação quanto ao tamanho máximo do Kernel a ser gerado, por isso só funciona em Kernels muito antigos, da série 2.0. O "bzImage" permite gerar Kernels sem limite de tamanho.

# make modules

O "make modules" conclui o trabalho, compilando todos os componentes marcados como módulos. Numa distribuição típica, esta é a etapa mais demorada, pois quase tudo é compilado como módulo, gerando um total de 40 ou 50 MB de arquivos, o que demora proporcionalmente mais. O tempo de compilação cai bastante se você começar a desativar os módulos que não for usar.

Instalando

O novo Kernel será gravado no arquivo "/usr/src/linux-2.x.x/arch/i386/boot/bzImage". O próximo passo é copiá-lo para o diretório /boot e em seguida configurar o Lilo para inicializar o novo Kernel ao invés do antigo. Para copiar use o comando:

# cp /usr/src/linux-2.x.x/arch/i386/boot/bzImage /boot/novo_kernel

Substituindo sempre o "linux-2.x.x" pelo nome correto da pasta onde está o Kernel. Isso também renomeará o arquivo para "novo_kernel", que pode ser alterado para outro nome qualquer.

Além do arquivo principal é necessário instalar também os componentes compilados como módulos, que ficam armazenados num diretório separado, na pasta /lib/modules/. Para isto, basta usar o comando:

# make modules_install

Concluindo, você deve copiar também o arquivo System.map, que contém a imagem de sistema inicial, carregada durante o boot:

# cp /usr/src/linux-2.xx/System.map /boot/System.map

O próximo passo é configurar o Lilo. Para isso, abra o arquivo "/etc/lilo.conf":

# kedit /etc/lilo.conf

Aqui estão as opções de inicialização que são dadas durante o boot. O que precisamos é adicionar uma nova opção, que inicializará o novo Kernel. Basta incluir as linhas no final do arquivo e salvá-lo:

image = /boot/novo_kernel
label = novo_kernel
read-only

Ao reiniciar o sistema você verá uma nova opção no menu do lilo, justamente o "novo_kernel" que acabamos de adicionar, junto com a entrada para inicializar o Kernel antigo.

Teste o novo Kernel e quando tiver certeza que ele está funcionando adequadamente, edite novamente o /etc/lilo.conf colocando a entrada do novo Kernel no topo da lista. Isto fará com que ela seja inicializada por default.

O seu lilo.conf ficará parecido com este:

nowarn
timeout=50
message=/boot/message
menu-scheme=wb:bw:wb:bw

image = /boot/novo_kernel
label = novo_kernel
read-only

image=/boot/vmlinuz
label=linux
root=/dev/hda1
initrd=/boot/initrd.img
append="quiet devfs=mount hdc=ide-scsi"
vga=788
read-only

Você pode ter quantos Kernels diferentes quiser, basta salvar cada arquivo com um nome diferente e adicionar uma entrada no arquivo.

Recompilando o Kernel à moda Debian

O Debian oferece uma ferramenta chamada kernel-package que facilita bastante a recompilação do Kernel. Ele cuida de todo o processo de compilação e no final do processo gera um arquivo .deb com o novo Kernel, que pode ser rapidamente instalado usando o comando "dpkg -i" e, inclusive, instalado em outros micros.

Como de praxe, o primeiro passo é acessar a pasta com os fontes do Kernel. O que muda são os comandos executados dentro dela. Ao invés do make bzImage, make modules e make modules_install, todo o restante do processo é automatizado por dois comandos:

# make-kpkg clean
# make-kpkg kernel_image

No final do processo será gerado um arquivo kernel-image dentro da pasta /usr/src com o novo Kernel, como em: "/usr/src/kernel-image-2.6.11_10.00.Custom_i386.deb".

Este pacote contém a imagem completa, incluindo o arquivo vmlinuz que vai na pasta /boot , módulos e um script de instalação (executado ao instalar o pacote) que automatiza a instalação.

O processo de compilação de um Kernel da série 2.6 com uma configuração típica demora em média uma hora e meia num Athlon de 1.0 GHz, por isso tenha paciência. Você pode ir fazendo outras coisas no micro enquanto isso. Os Kernels da série 2.4 são menores, por isso mais rápidos de compilar

Caso a compilação termine em uma mensagem de erro, experimente começar novamente, desativando o módulo que deu problemas. Erros de compilação também podem ser causados por erros de hardware. No Kurumin rode o stresstest (encontrado no Kurumin em Iniciar > Sistema) ou outro teste de hardware para verificar se a sua máquina está estável.

Você poderá instalar o pacote gerado rodando o dpkg -i, como em:

# dpkg -i /usr/src/kernel-image-2.6.11_10.00.Custom_i386.deb

Durante a instalação existe uma pegadinha. O instalador pergunta *Do You Whant to stop Now? (Y/n)*. O *Y* é o default, então se você simplesmente pressionar Enter sem ler, a instalação será abortada. Para continuar você precisa digitar *n* e dar Enter. Leia as outras perguntas com atenção.

Se você quiser que sejam gerados também pacotes com o fonte e os headers do Kernel, use o comando:

# make-kpkg kernel_image kernel_source kernel_headers

Neste caso serão gerados três pacotes no total, contendo o "kit completo" do Kernel gerado. Isto vai ser muito útil se você pretende distribuir o Kernel o instala-lo em várias máquinas.

O pacote com o fonte permite que outras pessoas recompilem o seu Kernel, fazendo alterações, enquanto os headers são necessários para instalar drivers de softmodems, os drivers 3D da nVidia e outros drivers proprietários.

Patches

Os patches são muitas vezes o principal motivo para recompilar o Kernel. Muitos novos recursos demoram para serem incluídos no Kernel oficial e enquanto isso (muitas vezes durante vários anos), ficam disponíveis apenas através de patches.

Como exemplo podemos citar o Freeswan (VPN), o Bootsplash (boot gráfico) e o OpenMosix (Cluster) entre muitos outros. Lendo muitos howtos você verá a necessidade de instalar patches diversos no Kernel para utilizar várias soluções.

Em muitos casos, recursos incluídos em novas versões do Kernel, como por exemplo o lowlatency e o preempt, adicionados no Kernel 2.6 para melhorar as respostas do sistema são disponibilizados como backports para versões anteriores do Kernel, novamente primeiro na forma de patches.

Para aplicar um patch, comece descompactando o arquivo baixado. Geralmente os patches possuem a extensão .patch mas isso não é uma regra.

Muitos patches podem ser baixados diretamente pelo apt-get. Digite "apt-get install kernel-patch" e pressione a tecla TAB duas vezes para ver todas as opções disponíveis.

Como exemplo vou mostrar como instalar os patches preempt, lowlatency e debianlogo numa versão recente do Kernel 2.4. Este último altera o pinguin que aparece durante o boot pelo logo do Debian, apenas para você ter certeza que o novo Kernel foi realmente compilado com os patches. Para instalar os três pelo apt-get use os comandos:

# apt-get install kernel-patch-debianlogo
# apt-get install kernel-patch-preempt-2.4
# apt-get install kernel-patch-lowlatency-2.4

Todos os patches instalados pelo apt-get vão para a pasta "/usr/src/kernel-paches". Em geral são instalados vários arquivos compactados, com versões específicas do patch para várias versões do Kernel. Descompacte apenas o arquivo que mais se aproxima da versão do Kernel que você está compilando, como em:

# gunzip cd /usr/src/kernel-patches/diffs/debianlogo/debian-logo-2.4.x.gz

Para aplicar o patch descompactado, acesse a pasta onde estão os sources do Kernel, como em:

$ cd /usr/src/kernel-source-2.4.22-xfs/

O próximo passo é aplicar o patch usando o comando patch -p1 < localização_do_patch, como em:

# patch -p1 < /usr/src/kernel-patches/diffs/debianlogo/debian-logo-2.4.x.patch

Lembre-se que este comando deve ser usado apenas dentro da pasta com os sources do Kernel.

Depois de aplicar todos os patches, siga o procedimento normal para gerar o novo Kernel:

# make xconfig
# make dep
# make-kpkg clean
# make-kpkg kernel_image

Um bom lugar para se manter informado sobre as novidades relacionadas ao desenvolvimento do Kernel, novos patches, etc. é o http://kerneltrap.org.

» Gostou do texto? Veja nossos livros impressos

... ou use a busca para localizar outros artigos relacionados: