Jump to content
From ArchWiki
< Kernel (Português)
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.

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.

## 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, cpio, perl, tar, xz.

### 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 `kernelbuild` 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 (`tar.xz`) da versão pretendida.

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

Nota: É uma boa ideia verificar a assinatura PGP de qualquer tarball de kernel que se faça download. Isso garante que é um arquivo legítimo e ajuda a construir uma Internet de Confiança. Veja kernel.org/signature.

No seguinte exemplo de linha de comando, wget foi instalado e é usado dentro do diretório `~/kernelbuild` 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 `.tar`), não para o arquivo comprimido `.tar.xz` que você baixou. Você precisa extrair esse último apenas parcialmente (apenas o .tar). Verifique que você tem xz 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

Nota: O destino de Make `mrproper` depende do destino de `clean`, e portanto, não é necessário executar ambos. Veja [1] para referência.

## 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 `.config`, que inclui o uso de módulos de kernel.

Nota: Não é necessário usar a conta de superusuário ou privilégios de superusuário nessa etapa.

Por um ajuste apropriado das opções em `.config`, 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).

Nota: Especialmente se você escolher a opção **B**, você será advertido a configurar manualmente seu kernel com ferramentas descritas em `Configuração Avançada`.

#### A. Configuração padrão do Arch

Esse método irá criar um arquivo `.config` 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.

Dica: Se você está atualizando kernels, algumas opções podem ter se alterado ou sido removidas. Nesse caso, ao rodar `make` em #Compilação, você será inquirido(a/e) a responder questões para cada opção que tenha se alterado entre as versões. Para aceitar as definições padrão sem questões, execute `make olddefconfig`.
Atenção: Se você está compilando um kernel usando seu atual arquivo `.config`, não se esqueça de renomear a versão de kernel em "CONFIG_LOCALVERSION" no novo `.config` ou em General Setup > Local version - append to kernel release usando uma das interfaces de usuário listadas em #Configuração avançada. Se você pular essa etapa, há risco de sobreposição de um de seus kernels existentes por engano.

#### B. Gerar configuração a partir da atual

Dica: Plugue todos os dispositivos que planejas usar no sistema ao seguir este método.

Desde o kernel 2.6.32, o comando `localmodconfig` irá criar um arquivo `.config` 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

Dica: A menos que você deseje ver várias mensagens extra ao ligar e desligar com um kernel customizado, é uma boa ideia desativar as relevantes opções de debugação (debugging).

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:

- `make menuconfig`: Interface de linha de comando ncurses suplantada pelo `nconfig`
- `make nconfig`: Interface ncurses mais recente para linha de comando
- `make xconfig`: Interface amigável ao usuário final (user-friendly) que requer o pacote packagekit-qt5 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.
- `make gconfig`: 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 `.config`, 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 `.config` de um kernel mais antigo) possam não ser automaticamente seleciondas.

Assim que as mudanças forem feitas salve o arquivo `.config`. É 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 `$ lspci -k #` 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

Dica: Se você quiser ter o gcc otimizado para os conjuntos de instrução do seu processador, edite `arch/x86/Makefile` (tanto para 32 quanto para 64 bits, veja [2]) dentro do diretório de fontes do kernel:

- Consulte `CONFIG_MK8,CONFIG_MPSC,CONFIG_MCORE2,CONFIG_MATOM,CONFIG_GENERIC_CPU` para o que você escolheu em `Processor type and features > Processor Family`;
- Mude a chamada de flag cc-options de `-march=native` para a que tiveres escolhido em Processor Family, por ex. `cflags-$(CONFIG_MK8) += $(call cc-option,-march=native)`. Essa é provavelmente a melhor via para compilar com `-march=native` tal como é.

- Nota: para kernels 32 bits, você precisa editar `arch/x86/Makefile_32.cpu` em vez disso e definir `-march=native` para seu processador.

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 `.config` 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

Atenção: Dessa etapa em diante, os comandos devem ser executados como superusuário ou com privilégios de superusuário. Caso contrário, irão falhar.

### 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 `/lib/modules/<versão do kernel>-<versão local de config>`. Por exemplo, para a versão de kernel 4.8 instalada acima, podem ser copiados para `/lib/modules/4.8.6-ARCH`. Isso mantém os módulos para cada específico kernel sendo usados separadamente.

Dica: Se o seu sistema requer módulos que não são distribuídos regularmente com o kernel Linux, você precisa compilá-los para seu kernel customizado assim que o tiver finalizado. Tais módulos são tipicamente aqueles que são explícita e separadamente instalados para seu sistema em execução. Veja NVIDIA#Custom kernel como um exemplo.

### 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 `bzImage` (da versão maior zImage) comprimida desse kernel, que deve ser copiada para o diretório `/boot` e renomeada. Atendendo a exigência de que o nome seja prefixado com `vmlinuz-`, você pode nomear o kernel como desejar. Nos exemplos abaixo, o kernel 4.8 compilado e instalado é, enfim, copiado e renomeado para `vmlinuz-linux48`:

- 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.
Dica: Se você estiver usando o bootloader LILO e esse não for capaz de se comunicar com o driver de mapeamento de dispositivos do kernel, você deve executar `modprobe dm-mod` primeiro.

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 `/boot/vmlinuz-` ao copiar a imagem `bzImage` (nesse caso, `linux48`):

    # 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 `ALL_kver=` também deve se igualar ao nome do kernel customizado especificado quando copiamos a `bzImage`:

    /etc/mkinitcpio.d/linux48.preset

    ...
    ALL_kver="/boot/vmlinuz-linux48"
    ...
    default_image="/boot/initramfs-linux48.img"
    ...
    fallback_image="/boot/initramfs-linux48-fallback.img"

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

- `-k` (--kernel <versão do kernel>): Especifica os módulos a serem usados para a geração da imagem initramfs. O parâmetro `<versão do kernel>` 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/`).
- `-g` (--generate <nome do arquivo>): Especifica o nome do arquivo initramfs a ser gerado no diretório `/boot`. 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).

Dica: Partições UEFI são formatadas usando FAT32, o qual não suporta links simbólicos.

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

    # 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 `/boot` junto de quaisquer arquivos pré-existentes:

- Kernel: `vmlinuz-SeuNomeDeKernel`
- Initramfs: `Initramfs-SeuNomeDeKernel.img`
- System Map: `System.map-SeuNomeDeKernel`
- 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.

Dica: Fontes do kernel incluem um script para automatizar o processo para o LILO: `$ arch/x86/boot/install.sh`. Lembre-se de digitar `lilo` como superusuário no terminal para atualizá-lo.

## 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.

Category:

- Kernel (Português)