Boot Process In Linux And Raspberry Pi 4

Linux Boot Process

BIOS/UEFI Stage (Firmware)

When a Linux computer is powered on, the boot process begins with the firmware:

1. Power-On and POST(Power-On Self Test): The system performs basic hardware checks to ensure all computers like CPU, RAM, and connected devices are functioning properly.
2. Device Detection: The BIOS/UEFI detects all hardware components connected to the system, including CPU, RAM, and storage devices.
3. Boot Device Selection: The firmware determines the boot device according to the configured priority order, which can be a hard drive, SSD, USB drive, or even network boot.
4. BIOS/UEFI runs the boot loader (GRUB): which provides a menu to choose the OS or the kernel functions.

Reference link here

Reference link here

Different between BIOS and UEFI:

• BIOS uses Master Boot Record (MBR) and limits disk size to 2TB
• UEFI uses GUID Partition Table(GPT), has no size limitations, and provides better security features like Secure Boot

Boot Loader Stage

After the firmware identifies the boot device, the process moves to the boot loader stage:

1. Boot Loader Loading: The firmware locates and loads the boot loader (typically GRUB2-Grand Unified Bootloader) from the boot device into RAM
2. Boot Menu Display: The boot loader displays a menu allowing users to select an operating system or kernel to boot. If there's no interaction, the system automatically selects the default entry after a configured timeout.
3. Kernel and initramfs Loading: The boot loader loads the Linux kernel and initramfs (initial RAM file system) into memory.
4. Control Transfer: The boot loader transfers control to the Linux kernel to continue the boot process.

Detail about GRUB2 at this link here

Detail about initramfs at this link here

Kernel Stage

When the Linux kernel is loaded into memory and receives control, it performs the following tasks:When the Linux kernel is loaded into memory and receives control, it performs the following tasks:

1. Decompression and Initialization: The kernel decompresses itself in memory and begins initialization.
2. Hardware Initialization: The kernel initializes and configures computer memory and all connected hardware.
3. Temporary Filesystem Mounting: The kernel mounts the temporary RAM filesystem (initramfs) to access necessary drivers and modules before mounting the actual root filesystem.
4. Device Driver Loading: The kernel loads essential drivers for storage devices, network interfaces, and peripherals.
5. Root Filesystem Mounting: The kernel mounts the root filesystem (/) from disk, initially in read-only mode.
6. Transition from initramfs to Real Filesystem: The kernel performs pivot_root() to switch from the temporary filesystem to the actual root filesystem.

Init Stage (First Process)

After the kernel completes initialization, it starts the first user-space process:

1. Init/Systemd Startup: The kernel launches the init process (or systemd in modern Linux systems) with PID=1.
2. System Initialization: Init/Systemd starts the basic system services according to the configured runlevel or target.
3. Runlevel/Target: The system transitions to the predefined runlevel or target:
4. Service Startup: Services such as networking, SSH, and display managers (GDM, LightDM) are started.
5. User Login: The system displays the login screen, allowing users to authenticate and access a shell or desktop environment like GNOME or KDE.

Some target - runlevel(sysvinit)

• poweroff.target - Runlevel 0: Shutdown (turn off the system)
• rescue.target - Runlevel 1: Single-user mode (maintenance mode, no networking)
• multi-user.target - Runlevel 2: Multi-user mode (no networking on some distros)
• multi-user.target - Runlevel 3: Multi-user mode with networking (no GUI)
• Runlevel 4: Not used (can be customized by the user)
• graphical.target - Runlevel 5: Multi-user mode with GUI (X11, GDM, etc.)
• reboot.target - Runlevel 6: Reboot (restarts the system)

Minimal: runlevel 3/multi-user.target: Command-line mode

Graphic: runlevel 5/graphical.target: Graphical interface mode

Some command to search info about target or runlevel

# Check default target (runlevel)
systemctl get-default

# See content in default target file
cat /usr/lib/systemd/system/graphical.target

# Avaiable target in systemd
systemctl list-units --type=target

In summary, the Linux boot process follows this sequence:

1. BIOS/UEFI starts and performs POST
2. Boot device detection and selection
3. Boot loader (GRUB2) loading and execution
4. Kernel and initramfs loading
5. Kernel initializes hardware and mounts filesystems
6. Kernel starts the init/systemd process
7. Init/Systemd starts system services
8. System displays the login screen

Rasberry Pi 4 Boot Process

The boot process of the Raspberry Pi 4 4GB follows a complex sequence of stages from power-on until the operating system is fully loaded

Initial Boot Stage

When a Raspberry Pi 4 is powered on, the boot process begins with the VideoCore GPU:

1. BCM2711 Activation: Upon power-up, the BCM2711 chip is activated with the VPU (VideoCore Processing Unit) core powered on, while the ARM CPU cores remain in a powered-down state.
2. Boot ROM Execution: The program counter is set to address 0x60000000, which maps to the on-chip boot ROM. The VPU initially runs at a low frequency (54MHz) and performs basic initialization tasks.
3. OTP Registers Check: The Boot ROM reads One-Time Programmable (OTP) registers related to the boot process (specifically registers 17/18, 66, and 67).

Reference link here

EEPROM Stage

The Raspberry Pi 4 differs from earlier Pi models in that it uses an EEPROM chip to store the bootloader:

1. Recovery.bin Check: The Boot ROM checks for a recovery.bin file on the first FAT partition of the SD card. This provides a mechanism to recover the device if the EEPROM becomes corrupted.
2. Firmware Loading from EEPROM: The Boot ROM loads firmware from the Winbond W25X40 EEPROM chip via the SPI0 protocol on GPIO pins 40-43.
3. USB Recovery Mode: If previous steps fail, the chip enters USB device mode (via the USB Type-C port) and waits to receive a recovery image from a USB host.

Boot Loader Stage

After the firmware from the EEPROM is loaded, the process moves to the bootloader stage:

1. Bootcode.bin Loading: The GPU searches for and loads the bootcode.bin file from the boot source into the 128K L2 cache.
2. SDRAM Initialization: The bootcode.bin initializes the SDRAM and loads loader.bin.
3. Start.elf Loading: The loader.bin understands the .elf format and loads start.elf.
4. Kernel and Configuration Loading: The start.elf loads kernel.img along with configuration files such as config.txt, cmdline.txt, and bcm2835.dtb.

Kernel Stage

When the Linux kernel is loaded into memory, the process moves to the final stage:

1. CPU Wake-up: The GPU wakes up the ARM CPU cores.
2. Control Transfer: Control is transferred from the GPU to the ARM CPU. Until this point, all processes run on the GPU, but from here on, the kernel runs on the ARM.
3. System Startup: The Linux kernel boots and initiates the init process, which starts up the entire system.

USB Boot Configuration

An important feature of the Raspberry Pi 4 is its ability to boot from USB SSDs, which can significantly improve performance compared to SD cards:

1. EEPROM Update: To boot from USB, you need to ensure the bootloader EEPROM has been updated to a version that supports USB booting (versions from 09-03-2020 onwards).
2. BOOT_ORDER Configuration Check: The default BOOT_ORDER code is 0xf41, read from right to left: 1 = Try SD card, 4 = Try USB mass storage, f = Restart.
3. OS Image Copying: Use the SD Card Copier tool to copy the entire operating system from the SD card to the USB SSD.