Recompilando o kernel no Fedora

Por que devo compilar meu kernel?

Grande parte dos usuários usuários não tem necessidade de compilar seu próprio kernel. O kernel que que costuma vir por padrão em quase todas as distribuições são preparados para funcionar em uma gama enorme de hardwares e condições adversas. Recomenda-se, no entanto, a compilação do kernel para assegurar que seu Linux é otimizado às necessidades do ambiente em que o sistema irá funcionar. Empresas que trabalham com alta demanda e necessitam de sistemas personalizados, usualmente recompilam seus kernels de modo a otimizar o hardware que têm à disposição. O processo de compilação é, de certa forma, simples e envolve passos bem documentados, mas em distribuições como Fedora, CentOS, Suse e Mandriva que se baseiam em pacotes rpm, é altamente aconselhável gerar os pacotes nesse formato para o kernel em vez de simplesmente compilá-lo e instalá-lo a partir do código fonte, uma vez que estes sistemas são construídos para trabalhar e gerenciar RPMs.

Pacotes necessários

Antes de iniciar o processo de compilar o kernel e criar um pacote rpm, é preciso baixar o pacote SRPM (.src.rpm) e ter instalado o ambiente de desenvolvimento de RPMs. Será necessário ter os seguintes pacotes:

  • rpmdevtools
  • yum-utils
  • rpmdev-setuptree
  • ncurses-devel
  • kernel-source
  • gcc
  • redhat-rpm-config

Para instalá-los,

e entre com o comando:

yum install rpmdevtools yum-utils ncurses-devel gcc redhat-rpm-config

O pacote contendo o código fonte do kernel pode/deve ser baixado sem privilégios de root. Obtenha então, o pacote com a versão mais atual do kernel a partir dos repositórios do Fedora:

yumdownloader updates-source --source kernel

Criando o ambiente para desenvolver RPMs

Por motivos de segurança, evita-se criar RPMs como root. Para ter funcionando um ambiente de desenvolvimento non-root abra um terminal e entre com o comando

rpmdev-setuptree

Isso irá criar um um diretório de nome rpmbuild e outros subdiretórios que estaram no seu diretório pessoal bem como o arquivo de configuração ~/.rpmmacros que definirá esse diretório como sendo de o construção de pacotes rpm.

Colocando tudo no lugar

Agora que você baixou o código fonte do kernel (que está dentro do arquivo .src.rpm), basta instalá-lo para que tudo fique no lugar adequado ao desenvolvimento de RPMs. Para isso, como um usuário normal, instale o pacote contendo os código fonte do kernel que você havia baixado com o comando

rpm -ivh kernel-<versão>.fc12.src.rpm

Os arquivos .src.rpm diferem de um RPM comum porque, claro, têm somente o código fonte e alguns arquivos necessários para gerar RPMs dentro do pacote mas, também, por poderem ser instalados por usuários comuns, sem necessidade da senha de root.

Preparando a compilação

Como já criamos o ambiente de desenvolvimento dos RPMs, o pacote instalado irá para os subdiretórios que se encontram dentro da pasta ~/rpmbuild. Isto é, o código fonte vai para as pastas de desenvolvimento de RPMs. Os diretórios são as seguintes:

ls ~/rpmbuild
BUILD  RPMS  SOURCES  SPECS  SRPMS

Se olhar dentro da pasta SOURCES vai perceber, além do código fonte do kernel, uma coleção de patches que devem ser aplicados. Essa deve ser a primeira etapa antes da compilação propriamente dita. Dentro da pasta SPECS execute o seguinte comando para aplicação dos patches:

rpmbuild -bp kernel.spec

Este comando usando a opção -bp, convém dizer, não compila nem cria nenhum RPM. Ele apenas descompacta o código fonte do kernel dentro do diretório ~/rpmbuild/BUILD e aplica a esse código todos os patches existentes no diretório SOURCES.

Neste ponto chegamos ao momento de personalizar nosso kernel. Aqui você tem a opção de modificar o kernel ou deixá-lo com as configurações default. Veremos também, um pouco mais adiante, que é possível importar as configurações do seu kernel atual para o kernel a ser compilado. Tudo o que você precisa para mexer no kernel antes de criar o pacote estará na pasta BUILD. Vá até ela:

cd ~/rpmbuild/BUILD/kernel-<versão>/linux-<versão>.i686

Importando a configuração do kernel atual para o futuro kernel

Pense no kernel como um grande programa onde você precisa dizer exatamente o que ele precisa para funcionar direito. Isso significa que se você está ouvindo uma música neste momento isso só é possível porque alguém compilou um kernel com o driver certo para a sua placa de som. A grosso modo, você precisa marcar (ou deixar desmarcada) cada uma das opções que acha interessantes ao seu kernel. Linuxistas mais experientes em compilação de kernel costumam ativar somente os recursos exatos para que suas máquinas funcionem. Não é preciso se assustar; embora sejam milhares de opções para marcar, o kernel já vem com uma configuração default que dá suporte para a maioria dos hardwares. Também existe a possibilidade de importar as configurações do seu kernel atual para o novo kernel; para isso, acesse a pasta com os códigos fonte do futuro kernel. Estando no diretório ~/rpmbuild/BUILD/kernel-<versão>/linux-<versão>.i686, execute:

make oldconfig
Importante: O comando make oldconfig importa do seu kernel corrente as configurações atuais. Muitos usuários preferem pegar arquivos .config prontos. Em todo caso, se o seu arquivo .config for diferente do arquivo gerado automaticamente pelo comando make oldconfig, um prompt com perguntas sobre as diferenças será mostrado, dando a possibilidade de manter ou descartar as diferenças.

As configurações são salvas no arquivo .config e é neste arquivo, de fato, que o kernel virá buscar todas as opções que serão ativadas e desativadas no momento da compilação.

Opções diversas

A este ponto, aparecem as primeiras decisões importantes. Vale à pena ressaltar que o kernel possui centenas de opções que podem ser marcadas e que cada uma destas opções tem três modos de ser colocada no kernel:

  • Y – Faz com que o componente seja carregado in kernel, ou seja, direto no kernel, mesmo que não seja necessário, o módulo estará ativo.
  • M – Faz com que o componente seja carregado como módulo. Dessa forma ele somente será carregado quando necessário, deixando o kernel livre de processos inúteis.
  • N – Não carrega o componente, deixando-o inativo.

Sabendo disso, vamos escolher uma interface para selecionar as opções e, posteriormente, iniciar a compilação do kernel.

Interfaces de seleção

Agora é preciso encarar todas as opções que podem ser adicionadas (ou não) ao seu kernel. Para tanto, existem várias interfaces (ou pseudo interfaces) que ajudam no processo:

  • make config: É a interface usada pelos primeiros linuxistas. Necessita somente de um terminal para funcionar e é recomendada para experts. Essa opção vai mostra cada uma das configurações e o usuário escolhe entre as opções Y, M, ou N de acordo com o que foi dito acima.
  • make menuconfig: É uma pseudo interface gráfica. Necessita do pacote ncurses-devel para funcionar. Ainda usa somente o terminal, mas com uma organização visual melhor, mais intuitiva e com algumas explicações sobre o que cada opção oferece. É a mais utilizada pelos usuários com boa experiência e contato razoável com o processo de compilação do kernel.
  • make gconfig: Este é uma interface gráfica em GTK que pode deixar os usuários mais confortáveis a compilar seu kernel, evitando o “traumático” contato com o terminal.
  • make xconfig: Semelhante ao make gconfig, este usa as bibliotecas Qt para funcionar (mais especificamente do pacote qt-devel).

Config.png

Depois de tudo marcado e salvo, as configurações vão para o arquivo .config (oculto).

Compilando

Compilação genérica

Era uma tarefa bastante complicada até os kernels da geração 2.4, quando era necessário cumprir (manualmente) várias etapas para no final ter o kernel compilado e rodando. Com o advento da geração 2.6, o processo de compilação e instalação do kernel passou a ser tratado como a compilação e instalação de um software qualquer. Quase tudo é automático e precisa de poucas linhas de comando:

make

Para compilar e, como root

make install

para instalar.

Uma compilação genérica vai funcionar em todos os sistemas, no entanto, não é recomendada porque é de difícil gerenciamento. Um kernel instalado dessa maneira exige muito trabalho para ser removido e atualizado já que o Fedora/Red Hat utiliza o RPM como gerenciador de pacotes. Em outras palavras, instalando seu kernel desse modo, você perde a habilidade de gerenciá-lo com as facilidades do RPM.

Criando um RPM genérico

Uma outra facilidade da geração 2.6 de kernels é a possibilidade de gerar um RPM com apenas um comando:

make rpm

Este comando vai compilar o kernel e empacotá-lo num RPM genérico. Este RPM genérico não segue os padrões Fedora/Red Hat de construção e o resultado final é algo do tipo kernel-<versão>.rpm, sem os rótulos fc10, fc11, fc12, etc que são característicos dos RPMs específicos para o Fedora. Até onde se sabe, isso não gera nenhum problema, além, é claro, dos possíveis (mas improváveis) inconvenientes de usar RPMs feitos por terceiros sem a garantia de homogeneidade dos RPMs estilo Fedora.

Criando um RPM estilo Fedora

Este é o método recomendado: RPMs ao bom e velho estilo Fedora. Para criar esses pacotes vai precisar ter em mente um pouco do conceito de criação de RPMs, mas o básico é o seguinte:

  • Instruções de como o RPM será criado estão no arquivo .spec do kernel (que fica na pasta ~/rpmbuild/SPECS). A menos que você adicione mais algum patch não é preciso mexer nele.
  • No caso de adicionar mais algum patch ao kernel ele deve ser inserido no arquivo .spec e o patch, propriamente dito, deve ser colocado na diretório ~/rpmbuild/SOURCES, já que precisa ser empacotado também.

Neste ponto você já escolheu as opções do que vai querer em seu kernel e as configurações ficaram salvas no arquivo .config que fica junto ao código fonte (diretório ~/rpmbuild/BUILD). Esse arquivo .config vai ter um papel muito importante agora. Abra-o e copie o conteúdo todo:

gedit ~/rpmbuild/BUILD/kernel-<versão>/linux-<versão>/.config

depois, olhe na pasta ~/rpmbuild/SOURCES para encontrar diversos arquivos config para várias arquiteturas. Identifique a sua (arquitetura) e substitua o que tiver lá pelo conteúdo copiado do arquivo .config:

  • config-debug
  • config-generic
  • config-i586
  • config-i686
  • config-i686-PAE
  • config-ia64-generic
  • config-nodebug
  • config-powerpc32-generic
  • config-powerpc32-smp
  • config-powerpc64
  • config-powerpc64-kdump
  • config-powerpc-generic
  • config-rhel-generic
  • config-s390x
  • config-sparc64-generic
  • config-sparc64-smp
  • config-x86_64-generic
  • config-x86-generic

Ou isso pode ser facilmente feito por uma linha de comando, como no exemplo abaixo, que joga o conteúdo do arquivo .config no arquivo config-i686:

 cd ~/rpmbuild/BUILD/kernel-<versão>/linux-<versão>
 cat .config > ~/rpmbuild/SOURCES/config-i686

Com tudo feito, chega a hora de ordenar ao rpmbuild que gere o seu RPM especialmente feito para o Fedora:

cd ~/rpmbuild/SPECS
rpmbuild -bb --target=i686 --with baseonly --without debuginfo kernel.spec

O resultado da sua compilação vai gerar um RPM dentro da pasta ~/rpmbuild/RPMS/i686.

Fonte: http://projetofedora.org/wiki/index.php/Recompilando_o_kernel

2 thoughts on “Recompilando o kernel no Fedora

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s