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.
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
/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.
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
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.
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).
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.
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..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
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.
$ 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.
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 pelonconfigmake nconfig: Interface ncurses mais recente para linha de comandomake 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
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_CPUpara o que você escolheu emProcessor type and features > Processor Family; - Mude a chamada de flag cc-options de
-march=nativepara 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=nativetal como é.
- Nota: para kernels 32 bits, você precisa editar
arch/x86/Makefile_32.cpuem vez disso e definir-march=nativepara 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
-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 /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.
Copie o kernel para o diretório /boot
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
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.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).
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.
$ 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.