Kernel (Português)/Traditional compilation (Português)

Esse artigo é uma introdução para compilar kernels customizados dos códigos-fonte do kernel.org. Esse método de compilação para kernels é o tradicional, comum a todas as distribuições. Dependendo de seu contexto, o processo pode ser mais complicado que usar o Arch Build System. Considere que as ferramentas do Arch Build System são desenvolvidas e mantidas a fim de tornar tarefas de compilação repetitivas mais eficientes e seguras.

Status de tradução: Esse artigo é uma tradução de Kernel/Traditional compilation. Data da última tradução: 2021-03-11. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Preparação

Não é necessário (ou recomendado) que se use a conta de superusuário ou privilégios de superusuário (i.e. via Sudo) para preparar o kernel.

Instalação de pacotes essenciais

Instale o grupo de pacotes base-devel, que contém pacotes necessários como make e gcc. Também é recomendado que se instale os seguintes pacotes, conforme listado no PKGBUILD do kernel Arch padrão: xmlto, kmod, inetutils, bc, libelf, git, , , , .

Crie uma pasta de compilação do kernel

É recomendado que se crie um diretório separado de compilação para seu(s) kernel(s). Neste exemplo, o diretório será criado no diretório home:

$ mkdir ~/kernelbuild

Baixe o código-fonte

Atenção: systemd requer, pelo menos, a versão 3.12 do kernel (4.2 ou superior para suporte a hierarquia de cgroups unificados). Veja /usr/share/doc/systemd/README para mais informações.

Baixe o código-fonte do kernel de https://www.kernel.org. Deve ser baixado o arquivo tarball () da versão pretendida.

Esse arquivo pode ser baixado com um simples clique direito no link para o arquivo em seu navegador, e um clique na opção , ou qualquer outro caminho para download via ferramenta de interface gráfica ou de linha de comando que utilize HTTP, TFTP, Rsync, ou Git.

No seguinte exemplo de linha de comando, foi instalado e é usado dentro do diretório para obter a versão 4.8.6 do kernel:

$ cd ~/kernelbuild
$ wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.8.6.tar.xz

Você deve também verificar a autenticidade do download antes, a fim de se certificar. Primeiro obtenha a assinatura; depois, use-a para obter a identificação da chave de assinatura, e use essa identificação para obter a verdadeira chave de assinatura:

$ wget https://www.kernel.org/pub/linux/kernel/v4.x/linux-4.8.6.tar.sign
$ gpg --list-packets linux-4.8.6.tar.sign
$ gpg --recv-keys <identificação-saída-do-comando-prévio>

Perceba que a assinatura foi gerada para o arquivo tar (i.e. extensão ), não para o arquivo comprimido que você baixou. Você precisa extrair esse último apenas parcialmente (apenas o .tar). Verifique que você tem instalado, a fim de que proceda de acordo com os comandos:

$ unxz linux-4.8.6.tar.xz
$ gpg --verify linux-4.8.6.tar.sign linux-4.8.6.tar

Não prossiga se isso não resultar em uma saída que inclua o texto "Boa assinatura" ("Good signature").

Se wget não foi usado dentro do diretório de compilação, será necessário mover o tarball para ele com, por ex.

$ mv /path/to/linux-4.8.6.tar.xz ~/kernelbuild/

Extraia o código-fonte

No diretório de compilação, extraia o tarball do kernel:

$ tar -xvf linux-4.8.6.tar

Para finalizar a preparação, garanta que a árvore do kernel está absolutamente limpa; não dependa de que a árvore esteja limpa após o desempacotamento. Para isso, primeiro navegue ao novo diretório do código-fonte que foi criado, e execute o comando make mrproper:

$ cd linux-4.8.6/
$ make mrproper

Configuração

Essa é a etapa mais crucial em customizar o kernel padrão para refletir precisamente as especificações de seu computador. A configuração do kernel é definida em seu arquivo , que inclui o uso de módulos de kernel.

Por um ajuste apropriado das opções em , seu kernel e computador funcionarão de forma mais eficiente.

Configuração do kernel

Você pode escolher entre duas opções para definir sua configuração de kernel:

• A. Usar as configurações padrão do Arch para o kernel oficial (recomendado);
• B. Gerar um arquivo de configuração que combina com a configuração do kernel que se está rodando (útil se você quiser customizar suas configurações de kernel futuramente).

A. Configuração padrão do Arch

Esse método irá criar um arquivo para o kernel customizado usando as configurações padrão de kernel do Arch. Se estás a rodar um kernel padrão do Arch, podes executar o seguinte comando dentro do diretório de código-fonte do kernel customizado (o que estás a compilar):

$ zcat /proc/config.gz > .config

Outrossim, a configuração padrão pode ser encontrada online no pacote do kernel oficial do Arch Linux.

B. Gerar configuração a partir da atual

Desde o kernel 2.6.32, o comando irá criar um arquivo para o kernel customizado desabilitando toda e qualquer opção que não estiver atualmente em uso pelo atual kernel, em tempo de execução. Noutras palavras, apenas opções que estiverem em uso serão habilitadas.

Por um lado, essa abordagem minimalista irá resultar em um kernel altamente simplificado e uma configuração lapidada especificamente para seu sistema; por outro, existirão algumas desvantagens, tais como a potencial incapacidade do kernel em suportar novos hardware, periféricos, e outros recursos.

Nota: Mais uma vez, tenha certeza de que todos os dispositivos que pretendes usar estejam conectados ao (e sejam detectados pelo) seu sistema antes de executar o seguinte comando

$ make localmodconfig

Configuração avançada

Existem muitas ferramentas disponíveis para ajustes finos na configuração do kernel, que provêm uma a alternativa àquilo que, noutro cenário, poderia se converter em muitas horas dispendidas configurando manualmente cada uma das opções ajustáveis para a compilação.

Nota: As ferramentas listadas abaixo irão disponibilizar a você três configurações para cada recurso do kernel: y para habilitado, n para desabilitado, e m para habilitado como um módulo de kernel (carregado quando necessário, gerenciável com o modprobe).

Estas ferramentas são:

• : Interface de linha de comando ncurses suplantada pelo
• : Interface ncurses mais recente para linha de comando
• : Interface amigável ao usuário final (user-friendly) que requer o pacote como dependência. Esse também é o método recomendado - especialmente para usuários menos experientes - já que é fácil de navegar, e apresenta informações sobre cada uma das opções.
• : Configuração de forma gráfica similar a xconfig mas usando gtk.

O método escolhido deve ser executado dentro do diretório do código-fonte do kernel, e todos irão ou criar um novo arquivo , ou sobrescrever um já existente, quando presente. Todas as configurações opcionais serão automaticamente habilitadas, ainda que quaisquer novas opções de configuração (i.e. em relação ao de um kernel mais antigo) possam não ser automaticamente seleciondas.

Assim que as mudanças forem feitas salve o arquivo . É uma boa ideia fazer uma cópia de backup fora do diretório dos fontes. Você pode ter de fazer isso diversas vezes antes de escolher todas as opções apropriadamente.

Se incerta(o/e), apenas mude algumas poucas opções a cada compilação. Caso não consiga fazer boot em um kernel recém compilado, veja uma lista dos recursos de kernel necessários aqui (em inglês).

Rodar em um liveCD faz obter uma lista de módulos de kernel em uso. Ainda mais importante, você deve manter suporte a CGROUPS. Isso é necessário para o systemd.

Compilação

O tempo de compilação pode variar de quinze minutos até mais de uma hora, dependendo de suas configurações de kernel e capacidade do processador. Assim que o arquivo tiver sido definido para o kernel customizado, dentro do diretório de fontes execute o seguinte comando para compilar:

$ make

Dica: Para acelerar a compilação, make pode ser executado com o argumento -jX, onde X é um número inteiro de processos paralelos. Os melhores resultados são geralmente obtidos usando o número de núcleos de CPU da máquina; por exemplo, com um processador dual-core rode make -j2. Veja Makepkg (Português)#Melhorando os tempos de compilação para mais informações.

Instalação

Instale os módulos

Assim que o kernel for compilado, de mesmo modo os módulos devem ser processados. Como superusuário ou com privilégios de superusuário, execute o seguinte comando para o fazer:

# make modules_install

Isso irá copiar os módulos compilados em . Por exemplo, para a versão de kernel 4.8 instalada acima, podem ser copiados para . Isso mantém os módulos para cada específico kernel sendo usados separadamente.

Copie o kernel para o diretório /boot

Nota: Garanta que o arquivo bzImage do kernel tenha sido copiado da pasta adequada para a arquitetura do seu sistema. Veja abaixo.

O processo de compilação do kernel irá gerar uma (da versão maior zImage) comprimida desse kernel, que deve ser copiada para o diretório e renomeada. Atendendo a exigência de que o nome seja prefixado com , você pode nomear o kernel como desejar. Nos exemplos abaixo, o kernel 4.8 compilado e instalado é, enfim, copiado e renomeado para :

• Kernel de 32-bit (i686):

# cp -v arch/x86/boot/bzImage /boot/vmlinuz-linux48

• Kernel de 64-bit (x86_64):

# cp -v arch/x86_64/boot/bzImage /boot/vmlinuz-linux48

Criar o disco RAM inicial

Nota: Você é livre para nomear o arquivo de imagem initramfs da forma que quiser ao gerá-lo. Contudo, é recomendado que use a convenção linux<revisão><subrevisão>. Por exemplo, no nome 'linux48' está dado que '4' é o número da revisão e '8' o da subrevisão para o kernel 4.8. Essa convenção tornará mais fácil manter múltiplos kernels, usar o mkinitcpio regularmente, e compilar módulos de terceiros.

Se você não sabe o que é exatamente fazer um disco RAM inicial, veja Initramfs e mkinitcpio.

Método de pré-definição automatizado

Uma já existente pré-definição do mkinitcpio pode ser copiada e modificada de modo que as imagens initramfs do kernel customizado sejam geradas de mesmo modo que para o kernel oficial. Isso é útil quando há intenção de se recompilar o kernel (por ex. quando atualizado). No exemplo abaixo, o arquivo de pré-definição para o kernel padrão do Arch será copiado e modificado para o kernel 4.8, instalado acima.

Primeiramente, copie o arquivo de pré-definição já existente, renomeando-o para combinar com o nome do kernel customizado especificado como sufixo para ao copiar a imagem (nesse caso, ):

# cp /etc/mkinitcpio.d/linux.preset /etc/mkinitcpio.d/linux48.preset

Após, edite o arquivo e corrija para o kernel customizado. Perceba (novamente) que o parâmetro também deve se igualar ao nome do kernel customizado especificado quando copiamos a :

Por fim, gere as imagens initramfs para o kernel customizado de mesmo modo que para um kernel oficial:

# mkinitcpio -p linux48

Método manual

Em vez de usar um arquivo de pré-definição, o mkinitcpio também pode ser usado para gerar um arquivo initramfs manualmente. A sintaxe do comando é:

# mkinitcpio -k <versão do kernel> -g /boot/initramfs-<nome do arquivo>.img

• (--kernel <versão do kernel>): Especifica os módulos a serem usados para a geração da imagem initramfs. O parâmetro deverá ter mesmo nome do diretório de fontes do kernel (e do diretório de módulos para ele, localizado em /usr/lib/modules/).
• (--generate <nome do arquivo>): Especifica o nome do arquivo initramfs a ser gerado no diretório . Mais uma vez, o uso da convenção de nomeação mencionada acima é recomendada.

Por exemplo, o comando para o kernel 4.8 customizado, instalado acima, seria:

# mkinitcpio -k linux-4.8.6 -g /boot/initramfs-linux48.img

Copiar o System.map

O arquivo System.map não é necessário para fazer boot no Linux. É um tipo de "agenda" que lista as funções de uma compilação individual do kernel. O System.map contém uma lista de símbolos do kernel (i.e. nomes de funções, de variáveis etc) e seus endereços correspondentes. Esse "mapeamento símbolo-endereço" é usado por:

• Alguns processos como klogd, ksymoops etc;
• Pelo handler OOPS quando há despejo de informação para a tela durante uma ruptura do kernel (i.e. informação como em qual função a falha teria ocorrido).

Se seu ponto de montagem está em um sistema de arquivos que suporta links simbólicos (i.e., não FAT32), copie System.map para , anexando o nome do kernel no arquivo de destino. Então crie um link simbólico desse arquivo para :

# cp System.map /boot/System.map-SeuNomeDeKernel
# ln -sf /boot/System.map-SeuNomeDeKernel /boot/System.map

Após completar todas as etapas acima, você deve ter os seguintes 3 arquivos e 1 link simbólico em seu diretório junto de quaisquer arquivos pré-existentes:

• Kernel:
• Initramfs:
• System Map:
• Link simbólico para o System Map

Configuração do bootloader

Adicione uma entrada para seu novo kernel no arquivo de configuração do bootloader. Veja Arch boot process (Português)#Comparação de recursos para possíveis bootloaders, seus artigos wiki e outras informações.

Ver também

• https://cateee.net/lkddb/web-lkddb/ (em inglês) inclui uma lista compreensiva das chaves de configuração do kernel e textos de acompanhamento, sorteados alfabeticamente.