Manual:MIPS/Instalação/Kernel

From Gentoo Wiki
Jump to: navigation, search
This page is a translated version of the page Handbook:MIPS/Installation/Kernel and the translation is 100% complete.

Other languages:
Deutsch • ‎English • ‎español • ‎français • ‎polski • ‎português do Brasil • ‎русский • ‎українська • ‎中文(中国大陆)‎ • ‎日本語 • ‎한국어
MIPS Handbook
Installation
About the installation
Choosing the media
Configuring the network
Preparing the disks
Installing stage3
Installing base system
Configuring the kernel
Configuring the system
Installing tools
Configuring the bootloader
Finalizing
Working with Gentoo
Portage introduction
USE flags
Portage features
Initscript system
Environment variables
Working with Portage
Files and directories
Variables
Mixing software branches
Additional tools
Custom package repository
Advanced features
Network configuration
Getting started
Advanced configuration
Modular networking
Wireless
Adding functionality
Dynamic management


Instalando os fontes

O núcleo em torno do qual todas as distribuições são criadas é o kernel Linux. Ele é a camada entre os programas de usuários e o hardware do sistema. O Gentoo provê aos seus usuários diversos possíveis fontes do kernel. Uma listagem completa está disponível na Página de visão geral do kernel.

Para sistemas baseados em mips o Gentoo recomenda o pacote sys-kernel/mips-sources.

Escolha um fonte do kernel apropriado e instale-o usando o emerge:

root #emerge --ask sys-kernel/mips-sources

Isso irá instalar os fontes do kernel Linux em /usr/src/ no qual um link simbólico chamado linux estará apontando para o fonte do kernel instalado:

root #ls -l /usr/src/linux
lrwxrwxrwx    1 root   root    12 Oct 13 11:04 /usr/src/linux -> linux-3.16.5-gentoo

É chegada a hora de configurar e compilar os fontes do kernel. Há duas formas de se fazer isso:

  1. O kernel é manualmente configurado e compilado, ou
  2. é usada uma ferramenta chamada genkernel para automaticamente compilar e instalar o kernel Linux

Vamos explicar aqui a configuração manual como opção padrão por ser o melhor caminho para otimizar um ambiente.

Padrão: Configuração manual

Introdução

Configurar manualmente um kernel é geralmente visto como o procedimento mais difícil que um usuário Linux pode fazer. Nada mais falso -- depois de configurar algumas vezes o kernel ninguém irá se lembrar que era difícil.

Porém, uma coisa é verdade: é vital conhecer o sistema quando um kernel é configurado manualmente. A maioria das informações pode ser coletada fazendo emerge no sys-apps/pciutils que contém o comando lspci:

root #emerge --ask sys-apps/pciutils
Nota
Dentro do chroot, é seguro ignorar qualquer aviso da pcilib (como pcilib: cannot open /sys/bus/pci/devices) que o lspci possa emitir.

Uma outra fonte de informação do sistema é executar o lsmod para ver quais módulos do kernel o CD de instalação usa pois isso pode dar dicas sobre o que habilitar.

Agora vá para o diretório dos fontes do kernel e execute make menuconfig. Isso irá mostrar uma tela de configuração baseada em menus.

root #cd /usr/src/linux
root #make menuconfig

A configuração do kernel do Linux tem muitas, muitas seções. Vamos primeiro mostrar algumas opções que devem ser ativadas (ou senão o Gentoo não irá funcionar, ou não funcionar adequadamente sem alguns ajustes). Existe também o Guia de configuração do kernel do Gentoo no wiki do Gentoo que poderá também ajudar.

Ativando as opções necessárias

Certifique-se de que todos os drivers que forem vitais para a inicialização do sistema (tais como controladores SCSI etc) são compilados no kernel e não como módulos, ou senão o sistema não será capaz de inicializar completamente.

Em seguida selecione o tipo exato do processador. É também recomendado habilitar os recursos MCE (se disponíveis) de modo que os usuários possam ser notificados sobre quaisquer problemas de hardware. Em algumas arquiteturas (tais como a x86_64), esses erros não são impressos pelo dmesg, mas em /dev/mcelog. Isso requer o pacote app-admin/mcelog.

Selecione também Maintain a devtmpfs file system to mount at /dev assim os arquivos de dispositivos críticos estarão disponíveis logo durante o processo de inicialização (CONFIG_DEVTMPFS and CONFIG_DEVTMPFS_MOUNT):

KERNEL Habilitando suporte ao devtmpfs
Device Drivers --->
  Generic Driver Options --->
    [*] Maintain a devtmpfs filesystem to mount at /dev
    [ ]   Automount devtmpfs at /dev, after the kernel mounted the rootfs

Verifique se o suporte a discos SCSI foi ativado (CONFIG_BLK_DEV_SD):

KERNEL Habilitando suporte a discos SCSI
Device Drivers --->
   SCSI device support  --->
      <*> SCSI disk support

Vá agora para File Systems (Sistemas de Arquivos) e selecione suporte para os sistemas de arquivos que você usa. Não compile o sistema de arquivo que é usado como sistema de arquivo raiz como módulo, ou senão o sistema Gentoo não será capaz de montar a partição. Selecione também "Virtual memory" (Memória virtual) e "/proc file system" (sistema de arquivo /proc). Selecione uma ou mais das seguintes opções segundo as necessidades do sistema: (CONFIG_EXT2_FS, CONFIG_EXT3_FS, CONFIG_EXT4_FS, CONFIG_MSDOS_FS, CONFIG_VFAT_FS, CONFIG_PROC_FS, and CONFIG_TMPFS):

KERNEL Selecionando os sistemas de arquivos necessários
File systems --->
  <*> Second extended fs support
  <*> The Extended 3 (ext3) filesystem
  <*> The Extended 4 (ext4) filesystem
  <*> Reiserfs support
  <*> JFS filesystem support
  <*> XFS filesystem support
  <*> Btrfs filesystem support
  DOS/FAT/NT Filesystems  --->
   <*> MSDOS fs support
   <*> VFAT (Windows-95) fs support

  Pseudo Filesystems --->
    [*] /proc file system support
    [*] Tmpfs virtual memory file system support (former shm fs)

Se for usado PPPoE para conectar à Internet, ou um modem com discagem foi usado, então habilite as seguintes opções (CONFIG_PPP, CONFIG_PPP_ASYNC, e CONFIG_PPP_SYNC_TTY):

KERNEL Selecionando os drivers PPPoE necessários
Device Drivers --->
  Network device support --->
    <*> PPP (point-to-point protocol) support
    <*>   PPP support for async serial ports
    <*>   PPP support for sync tty ports

As duas opções de compactação não vão atrapalhar mas definitivamente não são necessárias, assim como a opção de PPP sobre Ethernet (PPP over Ethernet), que pode apenas ser usada pelo ppp quando configurado para usar PPPoE em modo kernel.

Não se esqueça de incluir suporte no kernel para as placas de rede (ethernet ou sem fio).

A maioria dos sistemas tem múltiplos núcleos à disposição, então é importante ativar a opção "Symmetric multi-processing support" (suporte a multi-processamento simétrico) (CONFIG_SMP):

KERNEL Ativando suporte a SMP
Processor type and features  --->
  [*] Symmetric multi-processing support
Nota
Em sistemas com vários núcleos, cada núcleo conta como um processador.

Se forem usados dispositivos de entrada USB (como teclado ou mouse) ou outros dispositivos USB, não se esqueça de habilitá-los também (CONFIG_HID_GENERIC and CONFIG_USB_HID, CONFIG_USB_SUPPORT, CONFIG_USB_XHCI_HCD, CONFIG_USB_EHCI_HCD, CONFIG_USB_OHCI_HCD):

KERNEL Ativando suporte a dispositivos de entrada USB
Device Drivers --->
  HID support  --->
  -*- HID bus support
  <*>  Generic HID driver
  [*]  Battery level reporting for HID devices
     USB HID support --->
        <*> USB HID transport layer
  [*] USB support  --->
  <*>    xHCI HCD (USB 3.0) support
  <*>    EHCI HCD (USB 2.0) support
  <*>    OHCI HCD (USB 1.1) support


Preparando a configuração

Importante
Nas máquinas Origin 200/2000, Indigo2 Impact (R10000), Octane/Octane2 e O2, é necessário um kernel 64 bits para dar boot. Para essas máquinas, faça emerge sys-devel/kgcc64 para criar compilador cruzado ("cross-compiler") para a compilação de kernels 64 bits.

Muitos dos sistemas suportados tem arquivo .configs de exemplo no fonte do kernel. Nem todos os sistemas tem arquivo de configuração distribuído dessa forma. Aqueles que tem podem ser configurados usando os comandos descritos na tabela abaixo.

Sistema Comando de configuração
Servidores Cobalt make cobalt_defconfig
Indy, Indigo2 (R4k), Challenge S make ip22_defconfig
Origin 200/2000 make ip27_defconfig
Indigo2 Impact (R10k) make ip28_defconfig
O2 make ip32_defconfig

Todas as imagens de instalação do Gentoo provêm o arquivo de opções de configuração do kernel como parte da imagem em si, acessível como /proc/config.gz. Ele pode ser usado em muitos casos. É melhor, entretanto, que os fontes do kernel correspondam os mais próximo possível do kernel em execução. Para extraí-lo, simplesmente use o zcat como mostrado abaixo.

root #zcat /proc/config.gz > .config
Importante
Essa configuração do kernel é feita para uma imagem de boot de rede. Isto é, ela espera encontrar uma imagem de sistema de arquivo root por perto, seja como um diretório para initramfs ou um dispositivo de loopback para initrd. Ao executar o make menuconfig, não se esqueça de ir em General Setup e desabilitar as opções para initramfs.

Customizando a configuração

Uma vez encontrado o arquivo de configuração, copie-o para o diretório dos fontes do kernel e renomeie-o para .config. A partir daí, rode make oldconfig para que tudo seja atualizado conforme as instruções acima, e customize a configuração antes de compilar.

root #cd /usr/src/linux
root #cp /path/to/example-config .config
root #make oldconfig

Por enquanto apenas tecle ENTER (ou Return) em cada prompt para aceitar os defaults...

root #make menuconfig
Importante
Na seção Hackeando o Kernel há uma opção chamada "Você Está Usando um Compilador Cruzado?". Ela instrui aos arquivos Makefile do kernel para acrescentar "mips-linux-" (ou mipsel-linux ... etc) ao gcc como comandos ao compilar o kernel. Isso deve ser desligado, mesmo em compilação cruzada. Em vez disso, se for necessário o uso de um compilador cruzado, especifique o prefixo usando a variável CROSS_COMPILE como mostrado na próxima seção.
Importante
Existe um problema conhecido com o JFS e o ALSA em sistemas Octane no qual o ALSA não funciona. Dada a natureza experimental do JFS no MIPS, recomenda-se evitar o uso do JFS por enquanto.

Compilando e instalando

Agora que o kernel está configurado, é hora de compilá-lo e instalá-lo. Saia da configuração e inicie o processo de compilação:

Nota
Em máquinas de 64 bits, especifique CROSS_COMPILE=mips64-unknown-linux-gnu- (ou mips64el-... se for um sistema little endian) para usar o compilador de 64 bits.

Para compilar nativamente:

root #make vmlinux modules modules_install

Para compilação cruzada na máquina-alvo, ajuste mips64-unknown-linux-gnu- de acordo:

root #make vmlinux modules modules_install CROSS_COMPILE=mips64-unknown-linux-gnu-

Quando compilando em outra máquina, tal como uma x86, use os seguintes comandos para compilar o kernel e instalar os módulos em um diretório específico para ser transferido para a máquina-alvo:

root #make vmlinux modules CROSS_COMPILE=mips64-unknown-linux-gnu-
root #make modules_install INSTALL_MOD_PATH=/somewhere
Importante
Quando compilar um kernel de 64 bits para a Indy, Indigo2 (R4000), Challenge S ou O2, use o alvo vmlinuz.32 em vez de vmlinux, ou a máquina não serã capaz de dar boot. Isso é para contornar o fato da PROM não entender o formato ELF64.
root #make vmlinux.32
Nota
É possível habilitar a compilação paralela usando make -jX com X sendo o número de tarefas em paralelo que o processo de compilação é permitido disparar. Isso é similar às instruções sobre o /etc/portage/make.conf vistas anteriormente, com a variável MAKEOPTS.

O comando acima irá criar o vmlinux.32, que é o kernel final.

Quando o kernel terminar de ser compilado, copie sua imagem para o /boot/.

Nota
Em servidores Cobalt, o gerenciador de boot esperará encontrar uma imagem de kernel compactada. Lembre-se de compactar o arquivo com gzip -9 após colocá-lo em /boot/.
root #cp vmlinux /boot/kernel-3.16.5-gentoo

Em servidores Cobalt, compacte a imagem do kernel:

root #gzip -9v /boot/kernel-3.16.5-gentoo


Opcional: Criando um initramfs

Em certos casos, é necessário construir um initramfs - um sistema inicial de arquivos em RAM. A razão mais comum é quando os locais importantes do sistema de arquivos (como /usr/ ou /var/) estão em partições separadas. Com um initramfs, essas partições podem ser montadas usando as ferramentas disponíveis dentro do initramfs.

Sem um initramfs, há um enorme risco de o sistema não inicializar correctamente porque as ferramentas que são responsáveis pela montagem dos sistemas de arquivos precisam de informação que reside nesses sistemas de arquivos. Um initramfs irá puxar os arquivos necessários em um arquivo que é usado logo após o kernel inicializa, mas antes que o controle é entregue para a ferramenta de init. Os scripts do initramfs, então, certificam-se de que as partições estejam devidamente montadas antes do sistema continuar a inicialização.

Para instalar um initramfs, primeiramente instale o pacote sys-kernel/genkernel, e em seguida, use-o para gerar um initramfs:

root #emerge --ask sys-kernel/genkernel
root #genkernel --install initramfs

Para habilitar suporte para recursos específicos no initramfs tais como LVM ou RAID, adicione as opções apropriadas no genkernel. Veja genkernel --help para mais informação. No exemplo a seguir é habilitado o suporte para LVM e RAID por software (mdadm):

root #genkernel --lvm --mdadm --install initramfs

O initramfs será armazenado em /boot/. O arquivo resultante pode ser encontrado listando os arquivos iniciando com "initramfs":

root #ls /boot/initramfs*

Continue agora com os Módulos do kernel

Alternativa: Usando o genkernel

Se a configuração manual parecer muito difícil, então é recomendado o uso do genkernel. Ele irá configurar e construir o kernel automaticamente.

O genkernel funciona configurando um kernel praticamente idêntico ao kernel do CD de instalação. Isso significa que quando o genkernel é usado para construir o kernel, o sistema geralmente irá detectar todo o hardware durante a inicialização, assim como o CD de instalação. Como o genkernel não necessita de nenhuma configuração manual, ele é a solução ideal para aqueles usuários que não se sintam confortáveis compilando seu próprio kernel.

Agora vamos ver como usar o genkernel. Primeiro faça emerge do pacote sys-kernel/genkernel:

root #emerge --ask sys-kernel/genkernel

Depois, edite o arquivo /etc/fstab de modo que a linha contendo o /boot/ como segundo campo tenha o primeiro campo apontando para o dispositivo correto. Se o exemplo de particionamento deste manual foi seguido, então o dispositivo é provavelmente o /dev/sda1 com o sistema de arquivo ext2. A linha completa se pareceria com:

root #nano -w /etc/fstab
FILE /etc/fstabConfigurando o ponto de montagem /boot
/dev/sda1	/boot	ext2	defaults	0 2
Nota
Mais adiante nesta instalação do Gentoo o /etc/fstab será configurado novamente. A configuração do /boot é necessária agora porque o aplicativo genkernel lê esse arquivo de configuração.

Agora, compile os fontes do kernel executando genkernel all. Note que, como genkernel all compila um kernel com suporte para quase todo tipo de hardware, a compilação pode demorar para terminar!

Nota
Se a partição de boot não usa ext2 ou ext3 como sistema de arquivos, pode ser necessário configurar manualmente o kernel usando genkernel --menuconfig all e adicionar suporte para esse sistema de arquivo em particular no kernel (não como módulo). Usuários de LVM2 provavelmente irão querer adicionar --lvm como argumento também.
root #genkernel all

Quando o genkernel terminar, estarão criados um kernel, um conjunto completo de módulos e um ramdisk inicial (initrd). Usaremos o kernel e o initrd quando configurarmos o gerenciador de boot mais tarde neste documento. Anote os nomes do kernel e do initrd pois essas informações são utilizadas quando o arquivo de configuração do gerenciador de boot for editado. O initrd será executado imediatamente após o boot para fazer a autodetecção de hardware (como no CD de instalação) antes do sistema "real" inicializar.

root #ls /boot/kernel* /boot/initramfs*

Módulos do kernel

Configurando os módulos

Nota
É opcional listar manualmente os módulos de hardware. udev irá normalmente carregar todos os módulos de hardware que forem detectados ou conectados na maioria dos casos. Entretanto, não causa problema que módulos carregados automaticamente sejam listados. As vezes, algum hardware mais exótico requer alguma ajuda para carregar seus drivers.

Liste os módulos que precisem ser carregados no arquivo /etc/modules-load.d/*.conf, um módulo por linha. Opções extra para os módulos, se necessárias, devem ser configuradas nos arquivos /etc/modprobe.d/*.conf.

Para visualizar todos os módulos disponíveis, execute o seguinte comando find. Não se esqueça de substituir "<kernel version>" pela versão do kernel recém compilada:

root #find /lib/modules/<kernel version>/ -type f -iname '*.o' -or -iname '*.ko' | less

Por exemplo, para carregar automaticamente o módulo 3c59x.ko (que é o driver para uma placa de rede específica da família 3Com), edite o arquivo /etc/modules-load.d/network.conf e entre com o nome do módulo nele. O nome real do arquivo não é significativo para o carregador.

root #mkdir -p /etc/modules-load.d
root #nano -w /etc/modules-load.d/network.conf
FILE /etc/modules-load.d/network.confForçar o carregamento do módulo 3c59x
3c59x

Continue a instalação em Configurando o sistema.

Opcional: Instalando firmware

Alguns drivers requerem que firmware adicionais sejam instalados no sistema antes para funcionarem. Isso ocorre normalmente com interfaces de rede, especialmente as interfaces de rede sem fio. Também placas de vídeo modernas de fabricantes como AMD, NVidia e Intel, quando usando drivers open source, frequentemente precisam de arquivos de firmware externos. A maioria dos firmwares estão empacotados em sys-kernel/linux-firmware:

root #emerge --ask sys-kernel/linux-firmware