Linux LPI 101.2: Detalhes sobre Início ou boot do sistema

Resumo de termos que veremos nesse post:

Termo	Explicação
dmesg	Comando usado para visualizar e controlar o buffer de mensagens do kernel. Ele mostra mensagens de diagnóstico do kernel, geralmente relacionadas à inicialização do sistema e à detecção de hardware.
journalctl	Ferramenta usada para consultar e exibir logs gerenciados pelo systemd, incluindo logs do sistema, logs de aplicativos e mensagens do kernel.
BIOS	Basic Input/Output System, firmware básico que inicializa o hardware e carrega o bootloader. É responsável pelo POST (Power-On Self Test) e pela configuração inicial do hardware.
UEFI	Unified Extensible Firmware Interface, a interface de firmware mais moderna que substitui a BIOS. Oferece suporte a interfaces gráficas, Secure Boot, e um processo de boot mais flexível e seguro.
bootloader	Programa que carrega o sistema operacional na memória e inicia sua execução. Exemplos comuns incluem GRUB e LILO.
kernel	Núcleo do sistema operacional que gerencia recursos do sistema e a comunicação entre hardware e software. Ele controla processos, memória, dispositivos de hardware e chamadas de sistema.
initramfs	Initial RAM File System, um sistema de arquivos temporário usado durante o processo de inicialização do sistema, que carrega os módulos do kernel necessários para montar o sistema de arquivos real.
init	Primeiro processo iniciado pelo kernel durante a inicialização. Ele é responsável por inicializar e gerenciar outros processos do sistema.
SysVinit	Sistema de inicialização tradicional para sistemas Unix-like, que usa scripts de inicialização localizados em `/etc/init.d/` para iniciar, parar e gerenciar serviços do sistema.
systemd	Sistema de inicialização e gerenciamento de serviços moderno para sistemas Linux. Ele oferece paralelismo de inicialização, ativação sob demanda de serviços, monitoramento de processos e logging centralizado através do `journalctl`.

Termos para Linux LPI 101.2

Bios ou UEFI

A BIOS (Basic Input/Output System) é um programa armazenado em um chip de memória não volátil na placa-mãe, executado sempre que o computador é ligado. Este firmware realiza um teste de inicialização (POST) para verificar o hardware básico, ativa componentes essenciais como vídeo e teclado, e carrega o primeiro estágio do bootloader a partir do MBR (Master Boot Record) é os primeros 512 bytes do disco e dentro dele está o MBR. O MBR contém os primeiros 440 bytes do bootloader, que posteriormente carrega o segundo estágio responsável por iniciar o kernel do sistema operacional.

A BIOS e UEFI são Firmwares(ou programas embutidos)

Por outro lado, a UEFI (Unified Extensible Firmware Interface) é uma interface de firmware mais moderna que substitui a BIOS em muitos sistemas. Além de realizar o POST e ativar componentes essenciais, a UEFI pode identificar partições e ler vários sistemas de arquivos. A UEFI lê definições armazenadas na NVRAM (Non-Volatile RAM) para executar aplicativos EFI (EFI executables) armazenados na ESP (EFI System Partition). Estes aplicativos, frequentemente bootloaders(também chamado de bootstrap), são responsáveis por carregar o kernel do sistema operacional. A UEFI também suporta a Inicialização Segura (Secure Boot), que permite apenas a execução de aplicativos EFI assinados, aumentando a proteção contra software malicioso.

BIOS: Carrega o bootloader do MBR; limitado a sistemas de arquivos e métodos de inicialização mais antigos; menos flexível e seguro.

UEFI: Lê definições da NVRAM e carrega aplicativos EFI da ESP; suporta sistemas de arquivos modernos e inicialização segura; mais flexível e seguro. Como a BIOS, a UEFI também é um firmware, mas pode identificar partições e ler muitos sistemas de arquivos nelas. A UEFI não depende do MBR, levando em consideração apenas as configurações armazenadas na memória não-volátil (NVRAM) conectada à placa-mãe. Sistemas de arquivos compatíveis padrão são FAT12, FAT16 e FAT32 para dispositivos de bloco e ISO-9660 para mídia ótica. O diretório EFI na partição ESP contém os aplicativos apontados pelas entradas salvas na NVRAM.

Inicialização com BIOS

POST (Power-On Self-Test)
- A máquina é ligada e a BIOS executa o POST para verificar se há falhas simples de hardware.
Ativação de Componentes Básicos
- A BIOS ativa componentes essenciais como saída de vídeo, teclado e mídias de armazenamento.
Carregamento do Primeiro Estágio do Bootloader
- A BIOS carrega os primeiros 440 bytes do MBR (Master Boot Record) do primeiro dispositivo de armazenamento, conforme definido na configuração da BIOS.
Carregamento do Segundo Estágio do Bootloader
- O primeiro estágio do bootloader chama o segundo estágio, que apresenta opções de inicialização e carrega o kernel do sistema operacional.

    +-------------------------------+
    |           BIOS                |
    |  (Armazenado em ROM)          |
    +-------------------------------+
               |
               v
    +-------------------------------+
    |       POST                    |
    | (Verificação de Hardware)     |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Ativação de Componentes       |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Carregamento do MBR           |
    | (Primeiros 440 bytes)         |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Carregamento do Bootloader    |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Carregamento do Kernel        |
    +-------------------------------+

Inicialização com UEFI

POST (Power-On Self-Test)
- A máquina é ligada e a UEFI executa o POST para verificar se há falhas simples de hardware.
Ativação de Componentes Básicos
- A UEFI ativa componentes essenciais como saída de vídeo, teclado e mídias de armazenamento.
Leitura das Definições na NVRAM
- O firmware da UEFI lê as definições armazenadas na NVRAM para executar o aplicativo EFI predefinido armazenado na ESP (EFI System Partition).
Carregamento do Aplicativo EFI
- O aplicativo EFI, geralmente um bootloader, carrega o kernel do sistema operacional.

    +-------------------------------+
    |           UEFI                |
    |  (Armazenado em NVRAM)        |
    +-------------------------------+
               |
               v
    +-------------------------------+
    |       POST                    |
    | (Verificação de Hardware)     |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Ativação de Componentes       |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Leitura das Definições        |
    | na NVRAM                      |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Carregamento do Aplicativo EFI|
    | (Bootloader)                  |
    +-------------------------------+
               |
               v
    +-------------------------------+
    | Carregamento do Kernel        |
    +-------------------------------+

Bootloader

O carregador de inicialização mais popular para Linux na arquitetura x86 é o GRUB (Grand Unified Bootloader). Assim que é chamado pela BIOS ou pela UEFI, o GRUB exibe uma lista de sistemas operacionais disponíveis para inicialização. Às vezes, a lista não aparece automaticamente, mas ela pode ser invocada pressionando Shift enquanto o GRUB está sendo chamado pela BIOS. Nos sistemas UEFI, a tecla a ser usada é Esc.

Ao abrirmos o GRUB, pressionando shift ou esc, é possível escolher qual dos kernels instalados deve ser carregado e passar novos parâmetros para ele.

acpi Ativa/desativa o suporte a ACPI. acpi=off desabilita o suporte a ACPI.
init Define um iniciador de sistema alternativo. Por exemplo, init=/bin/bash define o shell Bash como iniciador. Assim, uma sessão do shell será iniciada logo após o processo de inicialização do kernel.
systemd.unit Define o destino do systemd a ser ativado. Por exemplo, systemd.unit=graphical.target. O systemd também aceita os níveis de execução numéricos definidos para SysV. Para ativar o nível de execução 1, por exemplo, é necessário apenas incluir o número 1 ou a letra S(abreviação de “single”) como parâmetro do kernel.
mem Define a quantidade de RAM disponivel para o sistema. Este parâmetro é útil para limitar a RAM disponível para cada convidado em uma máquina virtual. Assim, mem=512M limita a 512 megabytes a quantidade de RAM disponível para um sistema convidado em particular.
maxcpus Limita o número de processadores (ou núcleos de processador) visíveis ao sistema em máquinas multiprocessador simétricas. Também é útil para máquinas virtuais. Um valor de 0 desativa o suporte a máquinas multiprocessador e tem o mesmo efeito do parâmetro do kernel nosmp. O parâmetro maxcpus=2 limita a dois o número de processadores disponíveis para o sistema operacional.
quiet Oculta a maioria das mensagens de inicialização.
vga Seleciona um modo de vídeo. O parâmetro vga=ask mostra uma lista dos modos disponíveis a escolher.
root Define a partição raiz, diferente da que está configurada no bootloader. Por exemplo, root=/dev/sda3.
rootflags Opções de montagem para o arquivo de sistemas raiz
ro Torna somente para leitura a montagem inicial do arquivo de sistemas raiz.
rw Permite escrever no arquivo de sistemas raiz durante a montagem inicial.

Os parâmetros do kernel devem ser adicionados ao arquivo /etc/default/grub na linha GRUB_CMDLINE_LINUX para que persistam após a inicialização.

a cada vez que /etc/default/grub é alterado é necessário gerar um novo arquivo de configuração para o bootloader. Para isso basta executar grub-mkconfig -o /boot/grub/grub.cfg

sudo grub-mkconfig -o /boot/grub/grub.cfg

Podemos também ler o conteúdo do arquivo /proc/cmdline que exibirá os parâmetros do kernel usados para carregar a sessão.

elder@debian12:~$ cat /proc/cmdline 
BOOT_IMAGE=/boot/vmlinuz-6.1.0-20-amd64 root=UUID=8a4c9719-5434-4a9f-bb85-1b7ac9168186 ro quiet

Inicialização do sistema

Além do kernel, o sistema operacional depende de outros componentes:

scripts geralmente são usados para executar tarefas de curta duração que serão finalizadas durante o processo de inicialização.
daemons Os serviços, também conhecidos como daemons, podem ficar ativos o tempo todo.

O Kernel é iniciado pelo bootloader. O kernel assume o controle da CPU e começa a detectar e configurar os aspectos fundamentais do sistema operacional, como a configuração básica de
hardware e o endereçamento de memória.

O kernel abre então o initramfs (initial RAM filesystem). O initramfs é um arquivo que contém um sistema de arquivos raiz temporário usado durante o processo de inicialização. O objetivo de um arquivo initramfs é fornecer os módulos necessários para que o kernel possa acessar o sistema de arquivos raiz “de verdade” do sistema operacional.

Logo que o sistema de arquivos raiz fica disponível, o kernel monta todos os sistemas de arquivos configurados em /etc/fstab e, em seguida, executa o primeiro programa, um utilitário chamado init. O programa init é responsável por executar todos os scripts de inicialização e daemons do sistema. Existem implementações distintas desses iniciadores de sistema além do tradicional init, como o systemd e o Upstart. Depois que o programa init é carregado, o initramfs é removido da
RAM.

Resumindo, temos:

kernel abre o initramfs
initramfs fornece módulos necessários
kernel monta os sistemas de arquivos raiz
kernel executa o programa init
programa init gerencia os scripts de inicialização
initramfs é removido da RAM

Desenhando,

+-------------------------------+
|             BIOS/UEFI         |
|-------------------------------|
| POST                          |
| Ativação de componentes       |
| Carregamento do bootloader    |
+-------------------------------+
               |
               v
+-------------------------------+
|          Bootloader           |
|-------------------------------|
| Carregamento do kernel        |
| Passagem do controle ao kernel|
+-------------------------------+
               |
               v
+-------------------------------+
|            Kernel             |
|-------------------------------|
| Carregamento do initramfs     |
+-------------------------------+
               |
               v
+-------------------------------+
|         initramfs             |
|-------------------------------|
| Fornece módulos necessários   |
| para acessar o sistema de     |
| arquivos raiz real            |
+-------------------------------+
               |
               v
+-------------------------------+
|            Kernel             |
|-------------------------------|
| Monta sistemas de arquivos    |
| configurados em /etc/fstab    |
+-------------------------------+
               |
               v
+-------------------------------+
|            init               |
|-------------------------------|
| Executa scripts e daemons     |
| de inicialização              |
| (SysVinit, systemd, Upstart)  |
+-------------------------------+
               |
               v
+-------------------------------+
|      Sistema Operacional      |
|          em Execução          |
+-------------------------------+
               |
               v
+-------------------------------+
|       initramfs Removido      |
|           da RAM              |
+-------------------------------+

SysV (System V init)

SysV init é o sistema de inicialização tradicional utilizado em muitos sistemas Unix e Unix-like, incluindo várias distribuições Linux. Deriva do sistema Unix System V.

SysV init utiliza níveis de execução (runlevels) para definir diferentes estados do sistema. Cada runlevel tem um conjunto específico de serviços que devem ser iniciados ou parados.

Exemplo de runlevels comuns:
- Runlevel 0: Desligamento.
- Runlevel 1: Modo de usuário único (manutenção).
- Runlevel 3: Modo multiusuário sem interface gráfica.
- Runlevel 5: Modo multiusuário com interface gráfica.
- Runlevel 6: Reinicialização do sistema.

Scripts de inicialização: Scripts localizados em diretórios como /etc/init.d/ e /etc/rc.d/ são usados para iniciar e parar serviços. Esses scripts são executados sequencialmente, o que pode resultar em tempos de inicialização mais longos.

Comandos Comuns:

init: Muda o nível de execução do sistema.
service: Gerencia serviços (iniciar, parar, reiniciar).
chkconfig: Configura quais serviços serão iniciados em quais runlevels.

Ainda é usado em algumas distribuições devido à sua simplicidade e legado histórico.

Systemd

systemd é um sistema de inicialização moderno e um gerenciador de serviços amplamente adotado por muitas distribuições Linux. Projetado para superar as limitações do SysV init, oferecendo uma inicialização mais rápida e recursos avançados de gerenciamento de serviços.

Projetado para superar as limitações do SysV init, oferecendo uma inicialização mais rápida e recursos avançados de gerenciamento de serviços.

Funcionamento:

Unidades de serviço: Usa arquivos de unidade (.service, .socket, .device, etc.) para definir e gerenciar serviços, dispositivos, pontos de montagem e outros recursos.
Inicialização paralela: Pode iniciar múltiplos serviços simultaneamente, o que reduz o tempo de inicialização.
Cgroups: Utiliza grupos de controle (cgroups) para gerenciar e monitorar recursos de processos.
Logging integrado: Inclui o journalctl para visualizar logs do sistema.

Comandos comuns:

systemctl: Controla o systemd e gerencia serviços (iniciar, parar, reiniciar, habilitar, desabilitar).
journalctl: Visualiza logs do sistema gerenciados pelo systemd.
systemd-analyze: Analisa o tempo de inicialização do sistema.

systemd é amplamente adotado devido às suas vantagens em termos de velocidade, flexibilidade e recursos avançados.

Upstart

Upstart é um sistema de inicialização desenvolvido pela Canonical para substituir o SysV init, focando em eventos e paralelismo. Foi usado principalmente no Ubuntu até ser substituído pelo systemd.

Foi uma tentativa de modernizar a inicialização do sistema, mas foi suplantado pelo systemd em muitas distribuições.

Comandos Comuns:

initctl: Interage com o Upstart para gerenciar serviços e emitir eventos.
start, stop, restart: Gerencia serviços específicos sob o Upstart.

Analisando a Inicialização do Sistema

dmesg (display message or driver message) é um comando em sistemas Unix-like que exibe o buffer de mensagens do kernel. Ele exibe mensagens do kernel geradas durante a inicialização do sistema, além de mensagens relacionadas a drivers e hardware. Útil para diagnósticos e solução de problemas relacionados ao hardware e drivers.

journalctl é uma ferramenta utilizada para visualizar logs gerenciados pelo systemd. Ele acessa e exibe o conteúdo do systemd journal, que inclui uma ampla variedade de logs do sistema, como mensagens de inicialização, logs de serviços, mensagens do kernel e muito mais. Oferece funcionalidades avançadas de filtragem, como busca por tempo, prioridade de log e unidade de serviço.

O espaço de memória em que o kernel armazena suas mensagens, incluindo as mensagens de inicialização, é chamado de buffer de anel do kernel. O buffer de anel do kernel perde todas as mensagens quando o sistema é desligado ou se o comando dmesg –clear for executado.

Comando	Descrição	Exemplo
`dmesg`	Mostra todas as mensagens do buffer do kernel.	`dmesg`
**`dmesg	grep <termo>`**	Filtra as mensagens do kernel para mostrar apenas as que contêm o termo especificado.
`dmesg -T`	Exibe as mensagens do kernel com timestamps legíveis para humanos.	`dmesg -T`
`dmesg -C`	Limpa o buffer de mensagens do kernel após exibi-las.	`dmesg -C`
`journalctl`	Exibe todos os logs do `systemd` journal.	`journalctl`
`journalctl -b`	Mostra logs desde a última inicialização do sistema.	`journalctl -b`
`journalctl -u <serviço>`	Mostra logs relacionados a um serviço específico.	`journalctl -u sshd`
`journalctl --since "data"`	Mostra logs desde uma data específica.	`journalctl --since "2024-07-29"`
`journalctl --until "data"`	Mostra logs até uma data específica.	`journalctl --until "2024-07-30"`
`journalctl -p <prioridade>`	Filtra logs por prioridade (0: emerg, 1: alert, …, 7: debug).	`journalctl -p err`
`journalctl -f`	Mostra logs em tempo real (seguindo o fluxo de novas entradas).	`journalctl -f`
`journalctl --no-pager`	Exibe logs sem paginador (mostra todos os logs de uma vez).	`journalctl --no-pager`

Ao executar apenas o comando dmesg, sem opções, os valores no início das linhas são a quantidade de segundos desde o início do carregamento do kernel.

elder@debian12:~$ sudo dmesg  | head
[    0.000000] Linux version 6.1.0-20-amd64 (debian-kernel@lists.debian.org) (gcc-12 (Debian 12.2.0-14) 12.2.0, GNU ld (GNU Binutils for Debian) 2.40) #1 SMP PREEMPT_DYNAMIC Debian 6.1.85-1 (2024-04-11)
[    0.000000] Command line: BOOT_IMAGE=/boot/vmlinuz-6.1.0-20-amd64 root=UUID=8a4c9719-5434-4a9f-bb85-1b7ac9168186 ro quiet
[    0.000000] [Firmware Bug]: TSC doesn't count with P0 frequency!
[    0.000000] BIOS-provided physical RAM map:
[    0.000000] BIOS-e820: [mem 0x0000000000000000-0x000000000009fbff] usable
[    0.000000] BIOS-e820: [mem 0x000000000009fc00-0x000000000009ffff] reserved
[    0.000000] BIOS-e820: [mem 0x00000000000f0000-0x00000000000fffff] reserved
[    0.000000] BIOS-e820: [mem 0x0000000000100000-0x000000003ffeffff] usable
[    0.000000] BIOS-e820: [mem 0x000000003fff0000-0x000000003fffffff] ACPI data
[    0.000000] BIOS-e820: [mem 0x00000000fec00000-0x00000000fec00fff] reserved

Nos sistemas baseados em systemd, o comando journalctl mostra as mensagens de inicialização com as opções -b, –boot, -k ou –dmesg.

O comando journalctl –list-boots mostra uma lista de números de inicialização relativos à inicialização atual, seu hash de identificação e os registros de data e hora da primeira e última mensagens correspondentes:

elder@debian12:~$ sudo journalctl --list-boots 
IDX BOOT ID                          FIRST ENTRY                 LAST ENTRY                 
 -9 ece79bd9616744e8b5a6cf209bceba16 Sat 2024-05-04 12:52:52 -03 Mon 2024-05-06 09:38:56 -03
 -8 340cc8a19fba423ea0483505e9ac80e0 Mon 2024-05-06 15:22:14 -03 Mon 2024-05-06 15:37:16 -03
 -7 b750e6f113b54ec3b2624d1c28fe4fcc Mon 2024-05-06 15:37:38 -03 Mon 2024-05-06 15:40:37 -03
 -6 6253334e9ad8424ebb702f8604f5b5b3 Mon 2024-05-06 15:40:59 -03 Tue 2024-05-07 17:42:51 -03
 -5 3190f34809c445beb402a8c5fd83dea1 Tue 2024-05-07 17:43:12 -03 Wed 2024-05-08 13:44:06 -03
 -4 0654109c9e44475f80a7d0fa49ba5922 Wed 2024-05-08 13:44:30 -03 Fri 2024-05-10 14:17:01 -03
 -3 402b522969b94f18acfdf197194e4dfd Fri 2024-05-10 17:06:23 -03 Mon 2024-05-13 15:13:55 -03
 -2 0ca725a41ffc4e60a7b82cb94a1e124c Mon 2024-05-13 15:14:16 -03 Thu 2024-06-06 09:31:33 -03
 -1 cee9e7fd93cb452a87db8e7f11b5c660 Mon 2024-06-17 10:41:12 -03 Tue 2024-07-30 15:04:03 -03
  0 9e8d4c4bc2b14ebeb31b99120a0bbd1f Tue 2024-07-30 15:27:12 -03 Tue 2024-07-30 17:55:58 -03

Os logs de inicialização anteriores também são preservados nos sistemas baseados no systemd.

Segue mais uma tabela com exemplos do comando journalctl com exemplos de uso do journalctl para inspecionar logs de inicializações anteriores em sistemas baseados no systemd:

Comando	Descrição	Exemplo
`journalctl -b 0`	Exibe as mensagens da inicialização atual.	`journalctl -b 0`
`journalctl --boot=0`	Exibe as mensagens da inicialização atual.	`journalctl --boot=0`
`journalctl -b -1`	Exibe as mensagens da inicialização anterior.	`journalctl -b -1`
`journalctl --boot=-1`	Exibe as mensagens da inicialização anterior.	`journalctl --boot=-1`
`journalctl -b -2`	Exibe as mensagens da inicialização antes da anterior.	`journalctl -b -2`
`journalctl --boot=-2`	Exibe as mensagens da inicialização antes da anterior.	`journalctl --boot=-2`
`journalctl -b -3`	Exibe as mensagens da inicialização de três inicializações atrás.	`journalctl -b -3`
`journalctl --boot=-3`	Exibe as mensagens da inicialização de três inicializações atrás.	`journalctl --boot=-3`
`journalctl -b --list-boots`	Lista todas as inicializações registradas no journal.	`journalctl -b --list-boots`
`journalctl -b -1 -u <serviço>`	Exibe logs da inicialização anterior para um serviço específico.	`journalctl -b -1 -u sshd`
`journalctl --boot=-1 -u <serviço>`	Exibe logs da inicialização anterior para um serviço específico.	`journalctl --boot=-1 -u sshd`
`journalctl -b -2 -p <prioridade>`	Exibe logs da inicialização antes da anterior com uma prioridade específica.	`journalctl -b -2 -p err`
`journalctl --boot=-2 -p <prioridade>`	Exibe logs da inicialização antes da anterior com uma prioridade específica.	`journalctl --boot=-2 -p err`
`journalctl -b -1 --since "data"`	Exibe logs da inicialização anterior a partir de uma data específica.	`journalctl -b -1 --since "2024-07-01"`
`journalctl --boot=-1 --since "data"`	Exibe logs da inicialização anterior a partir de uma data específica.	`journalctl --boot=-1 --since "2024-07-01"`

/var/log/ mensagens sobre a inicialização e outras emitidas pelo sistema operacional são armazenadas aqui.
/var/log/journal/ o journalctl ler mensagens daqui. Ao usar journalctl com -D ou –directory para ler mensagens de log em diretórios diferentes deste. Como as mensagens de log do sistema não são armazenadas em texto puro, o comando journalctl é necessário para que fiquem legíveis.