xref: /linux/Documentation/translations/pt_BR/admin-guide/README.rst (revision 14c897740388216acd59477a382de327d5e27ba4)

.. SPDX-License-Identifier: GPL-2.0

.. _pt_BR_readme:

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
   Documentation/translations/pt_BR/process/changes.rst, 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
   Documentation/translations/pt_BR/process/applying-patches.rst.

   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
   Documentation/translations/pt_BR/process/changes.rst 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 Documentation/kbuild/kconfig.rst.

 - 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
   Documentation/translations/pt_BR/process/changes.rst.

 - 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
   "Documentation/admin-guide/efi-stub.rst".

 - É 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
'Documentation/admin-guide/reporting-issues.rst'.

Dicas sobre como entender os relatórios de bugs do kernel estão em
'Documentation/admin-guide/bug-hunting.rst'. Mais sobre depuração do kernel
com o gdb está em
'Documentation/process/debugging/gdb-kernel-debugging.rst' e
'Documentation/process/debugging/kgdb.rst'.