Portuguese (Brazilian)

Versão 6.x do kernel Linux <http://kernel.org/>

Estas são as notas de lançamento da versão 6 do Linux. Leia-as com atenção, pois elas dizem do que se trata tudo isso, explicam como instalar o kernel e o que fazer se algo der errado.

O que é o Linux?

O Linux é um clone do sistema operacional Unix, escrito do zero por Linus Torvalds com a ajuda de uma equipe pouco organizada de hackers espalhados pela Internet. Ele busca a conformidade com o POSIX e com a Single UNIX Specification.

Possui todos os recursos que você esperaria de um Unix moderno e completo, incluindo multitarefa real, memória virtual, bibliotecas compartilhadas, carregamento sob demanda (demand loading), executáveis compartilhados com cópia-na-escrita (copy-on-write), gerenciamento de memória adequado e rede multipilha, incluindo IPv4 e IPv6.

É distribuído sob a GNU General Public License v2 --- veja o arquivo COPYING que o acompanha para mais detalhes.

Em qual hardware ele roda?

Embora tenha sido originalmente desenvolvido primeiro para PCs de 32 bits baseados em x86 (386 ou superior), hoje o Linux também roda (pelo menos) nas arquiteturas Compaq Alpha AXP, Sun SPARC e UltraSPARC, Motorola 68000, PowerPC, PowerPC64, ARM, Hitachi SuperH, Cell, IBM S/390, MIPS, HP PA-RISC, Intel IA-64, DEC VAX, AMD x86-64 Xtensa e ARC.

O Linux é facilmente portável para a maioria das arquiteturas de propósito geral de 32 ou 64 bits, desde que possuam uma unidade de gerenciamento de memória paginada (PMMU) e um port do compilador C da GNU (gcc), parte da GNU Compiler Collection (GCC). O Linux também já foi portado para diversas arquiteturas sem PMMU, embora a funcionalidade fique, obviamente, um tanto limitada. O Linux também foi portado para si mesmo. Você pode agora executar o kernel como uma aplicação de espaço de usuário --- isso se chama UserMode Linux (UML).

Documentação

  • Há muita documentação disponível, tanto em formato eletrônico na Internet quanto em livros, tanto específica do Linux quanto referente a questões gerais do UNIX. Eu recomendaria procurar nos subdiretórios de documentação de qualquer site FTP do Linux pelos livros do LDP (Linux Documentation Project). Este README não pretende ser a documentação do sistema: existem fontes muito melhores disponíveis.

  • Existem vários arquivos README no subdiretório Documentation/: eles normalmente contêm notas de instalação específicas do kernel para alguns drivers, por exemplo. Por favor, leia o arquivo Requisitos mínimos para compilar o Kernel, pois ele contém informações sobre os problemas que podem resultar da atualização do seu kernel.

Instalando o código-fonte do kernel

  • Se você instalar as fontes completas, coloque o tarball do kernel em um diretório no qual você tenha permissões (por exemplo, o seu diretório pessoal) e o descompacte:

    xz -cd linux-6.x.tar.xz | tar xvf -

    Substitua “X” pelo número da versão do kernel mais recente.

    NÃO use a área /usr/src/linux! Essa área possui um conjunto (geralmente incompleto) de cabeçalhos do kernel que são usados pelos arquivos de cabeçalho da biblioteca. Eles devem corresponder à biblioteca, e não ser bagunçados por qualquer que seja o kernel-do-dia.

  • Você também pode atualizar entre versões 6.x aplicando patches. Os patches são distribuídos no formato xz. Para instalar aplicando patches, obtenha todos os arquivos de patch mais novos, entre no diretório de nível superior do código-fonte do kernel (linux-6.x) e execute:

    xz -cd ../patch-6.x.xz | patch -p1

    Substitua “x” para todas as versões maiores que a versão “x” da sua árvore de fontes atual, em ordem, e deve dar tudo certo. Talvez você queira remover os arquivos de backup (algum-nome-de-arquivo~ ou algum-nome-de-arquivo.orig) e certificar-se de que não há patches que falharam (algum-nome-de-arquivo# ou algum-nome-de-arquivo.rej). Se houver, ou você ou eu cometemos um erro.

    Diferentemente dos patches para os kernels 6.x, os patches para os kernels 6.x.y (também conhecidos como kernels -stable) não são incrementais; em vez disso, eles se aplicam diretamente ao kernel 6.x base. Por exemplo, se o seu kernel base é o 6.0 e você quer aplicar o patch 6.0.3, você não deve aplicar antes os patches 6.0.1 e 6.0.2. Da mesma forma, se você está rodando a versão 6.0.2 do kernel e quer saltar para a 6.0.3, você deve primeiro reverter o patch 6.0.2 (ou seja, patch -R) antes de aplicar o patch 6.0.3. Você pode ler mais sobre isso em Aplicando Patches ao Kernel Linux.

    Como alternativa, o script patch-kernel pode ser usado para automatizar esse processo. Ele determina a versão atual do kernel e aplica quaisquer patches encontrados:

    linux/scripts/patch-kernel linux

    O primeiro argumento no comando acima é a localização do código-fonte do kernel. Os patches são aplicados a partir do diretório atual, mas um diretório alternativo pode ser especificado como segundo argumento.

  • Certifique-se de que não há arquivos .o e dependências obsoletos espalhados por aí:

    cd linux
make mrproper

    Agora você deve ter as fontes instaladas corretamente.

Requisitos de software

Compilar e executar os kernels 6.x exige versões atualizadas de vários pacotes de software. Consulte Requisitos mínimos para compilar o Kernel para os números de versão mínimos exigidos e como obter atualizações desses pacotes. Esteja ciente de que usar versões excessivamente antigas desses pacotes pode causar erros indiretos, muito difíceis de rastrear; portanto, não presuma que basta atualizar os pacotes quando problemas óbvios surgirem durante a compilação ou a execução.

Diretório de compilação do kernel

Ao compilar o kernel, todos os arquivos de saída serão, por padrão, armazenados junto com o código-fonte do kernel. Usar a opção make O=output/dir permite especificar um local alternativo para os arquivos de saída (incluindo o .config). Exemplo:

código-fonte do kernel:    /usr/src/linux-6.x
diretório de compilação:   /home/nome/build/kernel

Para configurar e compilar o kernel, use:

cd /usr/src/linux-6.x
make O=/home/nome/build/kernel menuconfig
make O=/home/nome/build/kernel
sudo make O=/home/nome/build/kernel modules_install install

Observe: se a opção O=output/dir for usada, ela deve ser usada em todas as invocações do make.

Configurando o kernel

Não pule esta etapa, mesmo que você esteja atualizando apenas uma versão menor. Novas opções de configuração são adicionadas a cada lançamento, e problemas estranhos aparecerão se os arquivos de configuração não estiverem preparados como esperado. Se você quiser levar a sua configuração existente para uma nova versão com o mínimo de trabalho, use make oldconfig, que perguntará apenas as respostas para as novas questões.

  • Comandos alternativos de configuração são:

    "make config"      Interface em texto puro.

"make menuconfig"  Menus coloridos, listas de seleção e diálogos, em
                   modo texto.

"make nconfig"     Menus coloridos aprimorados, em modo texto.

"make xconfig"     Ferramenta de configuração baseada em Qt.

"make gconfig"     Ferramenta de configuração baseada em GTK.

"make oldconfig"   Assume o padrão para todas as questões com base no
                   conteúdo do seu arquivo ./.config existente e
                   pergunta sobre os novos símbolos de configuração.

"make olddefconfig"
                   Como o anterior, mas define os novos símbolos com
                   seus valores padrão, sem perguntar.

"make defconfig"   Cria um arquivo ./.config usando os valores padrão
                   dos símbolos, vindos de
                   arch/$ARCH/configs/defconfig ou de
                   arch/$ARCH/configs/${PLATFORM}_defconfig,
                   dependendo da arquitetura.

"make ${PLATFORM}_defconfig"
                   Cria um arquivo ./.config usando os valores padrão
                   dos símbolos vindos de
                   arch/$ARCH/configs/${PLATFORM}_defconfig.
                   Use "make help" para obter uma lista de todas as
                   plataformas disponíveis para a sua arquitetura.

"make allyesconfig"
                   Cria um arquivo ./.config definindo os valores dos
                   símbolos como 'y' sempre que possível.

"make allmodconfig"
                   Cria um arquivo ./.config definindo os valores dos
                   símbolos como 'm' sempre que possível.

"make allnoconfig" Cria um arquivo ./.config definindo os valores dos
                   símbolos como 'n' sempre que possível.

"make randconfig"  Cria um arquivo ./.config definindo os valores dos
                   símbolos aleatoriamente.

"make localmodconfig" Cria uma configuração baseada na configuração
                      atual e nos módulos carregados (lsmod). Desativa
                      qualquer opção de módulo que não seja necessária
                      para os módulos carregados.

                      Para criar um localmodconfig para outra máquina,
                      armazene o lsmod daquela máquina em um arquivo e
                      o passe como parâmetro LSMOD.

                      Além disso, você pode preservar módulos em certas
                      pastas ou arquivos kconfig especificando seus
                      caminhos no parâmetro LMC_KEEP.

              alvo$ lsmod > /tmp/mylsmod
              alvo$ scp /tmp/mylsmod host:/tmp

              host$ make LSMOD=/tmp/mylsmod \
                      LMC_KEEP="drivers/usb:drivers/gpu:fs" \
                      localmodconfig

                      O acima também funciona em compilação cruzada.

"make localyesconfig" Semelhante ao localmodconfig, exceto que converte
                      todas as opções de módulo em opções embutidas
                      (=y). Você também pode preservar módulos com o
                      LMC_KEEP.

"make kvm_guest.config"   Habilita opções adicionais para suporte a
                          kernel convidado do kvm.

"make xen.config"   Habilita opções adicionais para suporte a kernel
                    convidado dom0 do xen.

"make tinyconfig"  Configura o menor kernel possível.

    Você pode encontrar mais informações sobre o uso das ferramentas de configuração do kernel Linux em Configuration targets and editors.

  • NOTAS sobre o make config:

    • Ter drivers desnecessários deixará o kernel maior e, em algumas circunstâncias, pode levar a problemas: sondar uma placa controladora inexistente pode confundir as suas outras controladoras.

    • Um kernel com emulação matemática compilada ainda usará o coprocessador, se houver um presente: a emulação matemática simplesmente nunca será usada nesse caso. O kernel ficará um pouco maior, mas funcionará em máquinas diferentes, independentemente de terem ou não um coprocessador matemático.

    • Os detalhes de configuração de “kernel hacking” normalmente resultam em um kernel maior ou mais lento (ou ambos), e podem até tornar o kernel menos estável, ao configurar algumas rotinas para tentar ativamente quebrar código ruim e encontrar problemas no kernel (kmalloc()). Portanto, você provavelmente deve responder ‘n’ às questões sobre recursos de “development”, “experimental” ou “debugging”.

Compilando o kernel

  • Certifique-se de ter pelo menos o gcc 8.1 disponível. Para mais informações, consulte Requisitos mínimos para compilar o Kernel.

  • Execute um make para criar uma imagem compactada do kernel. Também é possível executar make install se você tiver o lilo instalado ou se a sua distribuição possuir um script de instalação reconhecido pelo instalador do kernel. A maioria das distribuições populares terá um script de instalação reconhecido. Talvez você queira verificar antes a configuração da sua distribuição.

    Para fazer a instalação de fato, você precisa ser root, mas nada da compilação normal deve exigir isso. Não tome o nome de root em vão.

  • Se você configurou qualquer parte do kernel como modules, também terá que executar make modules_install.

  • Saída detalhada (verbose) da compilação do kernel:

    Normalmente, o sistema de compilação do kernel roda em um modo bastante silencioso (mas não totalmente). No entanto, às vezes você ou outros desenvolvedores do kernel precisam ver os comandos de compilação, de ligação (link) ou outros exatamente como são executados. Para isso, use o modo de compilação “verbose”. Isso é feito passando V=1 ao comando make, por exemplo:

    make V=1 all

    Para que o sistema de compilação também informe o motivo da recompilação de cada alvo, use V=2. O padrão é V=0.

  • Mantenha um kernel de backup à mão, caso algo dê errado. Isso é especialmente verdadeiro para as versões de desenvolvimento, já que cada novo lançamento contém código novo que não foi depurado. Certifique-se de manter também um backup dos módulos correspondentes àquele kernel. Se você estiver instalando um novo kernel com o mesmo número de versão do seu kernel em funcionamento, faça um backup do seu diretório de módulos antes de executar um make modules_install.

    Como alternativa, antes de compilar, use a opção de configuração do kernel “LOCALVERSION” para acrescentar um sufixo único à versão normal do kernel. A LOCALVERSION pode ser definida no menu “General Setup”.

  • Para inicializar o seu novo kernel, você precisará copiar a imagem do kernel (por exemplo, .../linux/arch/x86/boot/bzImage após a compilação) para o local onde o seu kernel inicializável habitual se encontra.

  • Inicializar um kernel diretamente de um dispositivo de armazenamento, sem a ajuda de um gerenciador de inicialização como o LILO ou o GRUB, não é mais suportado na BIOS (sistemas não EFI). Em sistemas UEFI/EFI, no entanto, você pode usar o EFISTUB, que permite à placa-mãe inicializar diretamente no kernel. Em estações de trabalho e desktops modernos, geralmente recomenda-se usar um gerenciador de inicialização, pois podem surgir dificuldades com múltiplos kernels e com o secure boot. Para mais detalhes sobre o EFISTUB, veja “The EFI Boot Stub”.

  • É importante observar que, desde 2016, o LILO (LInux LOader) não está mais em desenvolvimento ativo, embora, por ter sido extremamente popular, apareça com frequência na documentação. Alternativas populares incluem GRUB2, rEFInd, Syslinux, systemd-boot ou EFISTUB. Por diversas razões, não é recomendável usar software que não esteja mais em desenvolvimento ativo.

  • É provável que a sua distribuição inclua um script de instalação e que executar make install seja tudo o que é necessário. Caso não seja assim, você terá que identificar o seu gerenciador de inicialização e consultar a documentação dele, ou configurar a sua EFI.

Instruções legadas do LILO

  • Se você usa o LILO, as imagens do kernel são especificadas no arquivo /etc/lilo.conf. O arquivo de imagem do kernel geralmente é /vmlinuz, /boot/vmlinuz, /bzImage ou /boot/bzImage. Para usar o novo kernel, salve uma cópia da imagem antiga e copie a nova imagem por cima da antiga. Então, você DEVE EXECUTAR O LILO NOVAMENTE para atualizar o mapa de carregamento! Se não fizer isso, não conseguirá inicializar a nova imagem do kernel.

  • Reinstalar o LILO geralmente é uma questão de executar /sbin/lilo. Talvez você queira editar o /etc/lilo.conf para especificar uma entrada para a sua imagem antiga do kernel (digamos, /vmlinux.old), caso a nova não funcione. Veja a documentação do LILO para mais informações.

  • Após reinstalar o LILO, deve estar tudo pronto. Desligue o sistema, reinicie e aproveite!

  • Se algum dia você precisar alterar o dispositivo raiz padrão, o modo de vídeo, etc. na imagem do kernel, use as opções de inicialização do seu gerenciador de inicialização onde for apropriado. Não é necessário recompilar o kernel para alterar esses parâmetros.

  • Reinicie com o novo kernel e aproveite.

Se algo der errado

Se você tiver problemas que pareçam ser causados por bugs do kernel, por favor, siga as instruções em ‘Reporting issues’.

Dicas sobre como entender os relatórios de bugs do kernel estão em ‘Bug hunting’. Mais sobre depuração do kernel com o gdb está em ‘Debugging kernel and modules via gdb’ e ‘Using kgdb, kdb and the kernel debugger internals’.