This is Gentoo's testing wiki. It is a non-operational environment and its textual content is outdated.
Please visit our production wiki at https://wiki.gentoo.org
Manual:MIPS/Instalação/Kernel
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-sourcesIsso 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/linuxlrwxrwxrwx 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:
- O kernel é manualmente configurado e compilado, ou
- é usada uma ferramenta chamada
genkernelpara 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/pciutilsDentro 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 menuconfigA 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):
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):
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):
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):
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):
Processor type and features ---> [*] Symmetric multi-processing support
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):
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
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 > .configEssa 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 oldconfigPor enquanto apenas tecle ENTER (ou Return) em cada prompt para aceitar os defaults...
root #make menuconfigNa 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.
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:
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_installPara 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=/somewhereQuando 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É 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/.
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-gentooEm 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/genkernelroot #genkernel --install initramfsPara 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 initramfsO 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/genkernelDepois, 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/etc/fstabConfigurando o ponto de montagem /boot/dev/sda1 /boot ext2 defaults 0 2
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!
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 allQuando 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
É 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' | lessPor 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
/etc/modules-load.d/network.confForçar o carregamento do módulo 3c59x3c59x
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