Dando boot no Linux

By | May 28, 2015

Já parou pra pensar como funciona o processo de boot no seu Linux? Como é que você vai de uma máquina desligada para a tela de login?

Isso não é uma lista exaustiva de todos os passos, mas é uma boa ideia do processo como um todo. Essa descrição é válida para sistemas x86 rodando GRUB. Se alguém souber como funciona em outros sistemas deixe no comentários, por favor.

Quando você pressiona o botão de power:

  • Seu hardware vai resetar para um valor padrão
  • Vai rodar o POST (Power On Self-Test) onde vai haver uma autoavaliação de:
    • Integridade da BIOS
    • DMA, timers, etc
    • Memória do sistema

Tudo estando OK a BIOS será invocada e se houver algum hardware especializado (como controladoras RAID, por exemplo) a BIOS passa o controle para o firmware desse hardware que executará seu próprio POST.

Mais uma vez com tudo OK a BIOS checará a configuração da CMOS para descobrir qual o dispositivo que deve usar para dar boot. Nesse dispositivo a BIOS vai procurar a MBR (Master Boot Record) e copiar o que estiver lá em memória e executar. Lembrando que a MBR é extremamente pequena – apenas 512 bytes – e por isso apenas uma quantidade minúscula de código pode ser colocada lá. Esse tanto de código é a chamada fase 1 do GRUB e tudo que ela faz é chamar a próxima fase. Teoricamente poderia ser a fase 2, mas até onde eu vi o normal mesmo é chamar a fase 1.5.

A fase 1.5 é um pouco maior e pode alocar espaço o suficiente para entender sistemas de arquivos e device drivers, de forma que o GRUB vai saber interpretar um disco SCSI com uma partição EXT3, por exemplo. Nessa partição (normalmente /boot) o GRUB finalmente vai invocar a fase 2.

E é na fase 2 que você vai ver o menu de boot do GRUB e ele finalmente vai invocar o kernel do Linux que foi configurado. Quando ele invoca o kernel ele passa o bastão para o mesmo e sai de cena.

Quando o kernel é chamado ele vai buscar a initrd** (que nada mais é do que um arquivo cpio compactado) que contém uma árvore de diretórios temporária para o seu sistema.

Se você quiser dar uma olhada no seu initrd faça o seguinte:

mkdir /tmp/temp
cp /boot/initrd.img-$(uname -r) /tmp/temp/
cd /tmp/temp/
zcat initrd.img-$(uname -r) | cpio -iv

É interessante. E como você vai ver agora a coisa tá bem mais completa e temos espaço e ferramentas para fazer um bocado de coisa, como suporte a sistemas de arquivos alternativos (por exemplo ZFS) ou rodar scripts customizados.

Quando o kernel termina de rodar o que estava na initrd ele vai chamar um processo chamado pivot_root onde vai montar o root do seu sistema de arquivos real. Uma vez feito isso ele desmonta o initrd e chama o processo init (ou systemd), que receberá o PID 1 e será responsável por chamar todos os outros processos no sistema.

Sei que foi uma explicação bem superficial, então use apenas como uma introdução ao assunto e use o Google para aprender mais. \o/

** Existe uma discussão sobre nomenclatura. Mais detalhes aqui.

No tag for this post.

2 thoughts on “Dando boot no Linux

  1. Silvio Fonseca

    Nos embarcados, o processo é relativamente parecido mas varia muito de sistema pra sistema. O processo mais comum é a CPU executar o codigo do ROM, tipo uma BIOS hard-coded na CPU. Esse ROM vai ler o flash em uma partição específica e passar o controle pra esse código. Normalmente esse código é o u-boot (um GRUB dos embarcados) que vai chamar o kernel que está em outra partição do flash. Tem casos que o boot é pela GPU (Raspberry Pi), outros precisam de um loader antes do u-boot (TI OMAP), etc, etc.

Comments are closed.