Computer Boot Process

What Happens When You Press the Power Button

1. Power Supply Unit (PSU) Activation

• PSU self-test: Checks if it can provide stable voltage
• Power Good signal: PSU sends signal to motherboard when stable (typically after 100-500ms)
• Voltage rails: Provides +3.3V, +5V, +12V to components

2. Motherboard Initialization

• Clock generator starts: Provides clock signals to CPU, chipset
• Reset signal released: CPU comes out of reset state
• CPU fetches first instruction: From a hardcoded memory address (reset vector)

; First instruction at reset vector (x86)
jmp BIOS_ENTRY_POINT

; BIOS/UEFI code stored in ROM/Flash on motherboard

POST (Power-On Self-Test)

Diagnostic testing sequence to verify hardware is functioning correctly.

POST Sequence

1. CPU check: Verify CPU registers and instruction execution
2. BIOS/UEFI checksum: Verify firmware integrity
3. CMOS/NVRAM check: Read saved settings (date/time, boot order)
4. Timer initialization: System timers (PIT, RTC)
5. Memory test: Quick RAM check (full test optional)
   • Write and read patterns to memory
   • Detect amount of RAM installed
   • Build memory map
6. Keyboard controller: Initialize PS/2 or USB keyboard
7. Video initialization: Initialize graphics card
   • BIOS displays POST screen
   • Shows manufacturer logo or POST codes
8. Peripheral detection: PCI/PCIe devices
   • Enumerate devices on buses
   • Execute device option ROMs (e.g., RAID controller BIOS)
   • Assign resources (IRQs, memory addresses, I/O ports)
9. Storage detection: SATA, NVMe, USB drives
   • Identify bootable devices
   • Read partition tables

Boot Device Selection

Boot Order

BIOS/UEFI checks devices in configured order:

1. USB drive (if USB boot enabled)
2. CD/DVD drive
3. Hard drive / SSD
4. Network (PXE boot)

How Boot Device is Identified

BIOS Mode (MBR):

• Reads first sector (512 bytes) of disk: Master Boot Record (MBR)
• Checks for boot signature: 0x55AA in last two bytes
• If found, MBR is valid bootable device

MBR Structure (512 bytes):
+--------------------------------------------------+
| Bootstrap code (446 bytes)                       | <- Bootloader code
+--------------------------------------------------+
| Partition Table (64 bytes)                       | <- 4 partition entries
|  - Partition 1: bootable, type, start, size      |
|  - Partition 2: ...                              |
|  - Partition 3: ...                              |
|  - Partition 4: ...                              |
+--------------------------------------------------+
| Boot Signature: 0x55 0xAA (2 bytes)              | <- Valid boot sector
+--------------------------------------------------+

UEFI Mode (GPT):

• Looks for EFI System Partition (ESP)
• ESP is FAT32 partition (typically 100-500 MB)
• Contains bootloader in /EFI/BOOT/BOOTX64.EFI
• NVRAM stores boot entries pointing to specific .efi files

GPT Disk Structure:
+--------------------------------------------------+
| Protective MBR (for backward compatibility)      |
+--------------------------------------------------+
| Primary GPT Header                               |
|  - Disk GUID                                     |
|  - Partition table location                      |
|  - CRC32 checksums                               |
+--------------------------------------------------+
| Partition Table (up to 128 entries)              |
|  Entry 1: EFI System Partition (ESP)             | <- FAT32, bootloaders
|  Entry 2: Linux root partition                   |
|  Entry 3: Linux swap                             |
|  ...                                             |
+--------------------------------------------------+
| Partitions (actual data)                         |
+--------------------------------------------------+
| Backup Partition Table                           |
+--------------------------------------------------+
| Backup GPT Header                                |
+--------------------------------------------------+

/EFI/
+-- BOOT/
|   +-- BOOTX64.EFI          # Default bootloader (fallback)
+-- ubuntu/
|   +-- grubx64.efi          # Ubuntu GRUB bootloader
+-- Microsoft/
|   +-- Boot/
|       +-- bootmgfw.efi     # Windows Boot Manager
+-- refind/
    +-- refind_x64.efi       # rEFInd boot manager

What is a Bootloader?

A small program that loads the operating system kernel into memory. Bridge between firmware (BIOS/UEFI) and OS kernel.

Common Bootloaders

GRUB Boot Process

BIOS Mode (GRUB Legacy Stages)

1. Stage 1: MBR bootstrap code (446 bytes)
   • Loaded by BIOS from MBR
   • Too small to do much
   • Loads Stage 1.5 or Stage 2
2. Stage 1.5: Filesystem driver (optional)
   • Located in first 30KB after MBR (unused space)
   • Contains filesystem driver (ext4, NTFS, etc.)
   • Allows Stage 2 to be read from filesystem
3. Stage 2: Full GRUB
   • Located in /boot/grub
   • Displays boot menu
   • Loads kernel and initramfs

UEFI Mode (GRUB 2)

• Single .efi file on ESP: /EFI/ubuntu/grubx64.efi
• No stages needed (UEFI can read FAT32)
• Reads configuration from /boot/grub/grub.cfg

menuentry 'Ubuntu' {
    set root='hd0,gpt2'                    # Partition with /boot
    linux /vmlinuz-5.15.0-generic \        # Kernel image
          root=UUID=abc-123 ro quiet       # Kernel parameters
    initrd /initrd.img-5.15.0-generic      # Initial RAM disk
}

menuentry 'Ubuntu (recovery mode)' {
    set root='hd0,gpt2'
    linux /vmlinuz-5.15.0-generic \
          root=UUID=abc-123 ro single      # Single-user mode
    initrd /initrd.img-5.15.0-generic
}

menuentry 'Windows Boot Manager' {
    chainloader /EFI/Microsoft/Boot/bootmgfw.efi
}

What GRUB Does

1. Display boot menu: Show available kernels and OSes (timeout: 5-10 seconds)
2. User selection: Wait for user input or use default
3. Load kernel: Read kernel image from /boot/vmlinuz-* into memory
4. Load initramfs: Read /boot/initrd.img-* into memory
5. Pass control to kernel: Jump to kernel entry point with parameters

Kernel Boot Process

1. Kernel Decompression

Kernel image (vmlinuz) is compressed:

• Decompression stub: Small uncompressed code at beginning
• Decompress kernel: Extract compressed kernel into memory
• Jump to kernel: Start actual kernel code

2. Kernel Initialization (start_kernel)

Main kernel initialization function: start_kernel() in init/main.c

1. Setup architecture-specific code:
   • Initialize CPU (interrupts, memory management, etc.)
   • Setup memory zones (DMA, Normal, HighMem)
   • Parse kernel command line parameters
2. Initialize memory management:
   • Setup page tables
   • Initialize memory allocators (buddy system, slab)
   • Create kernel page tables
3. Initialize scheduler:
   • Setup process scheduler
   • Create idle task (PID 0)
4. Initialize interrupts:
   • Setup Interrupt Descriptor Table (IDT)
   • Initialize interrupt controllers (APIC, PIC)
   • Enable interrupts
5. Initialize timers:
   • Setup system timers (TSC, HPET, PIT)
   • Initialize timekeeping
6. Initialize console:
   • Setup kernel console output
   • Display kernel version and boot messages
7. Initialize devices:
   • Enumerate and initialize hardware devices
   • Load built-in device drivers
   • Setup PCI/PCIe bus

[    0.000000] Linux version 5.15.0-generic (gcc version 11.2.0)
[    0.000000] Command line: root=UUID=abc-123 ro quiet splash
[    0.000000] KERNEL supported cpus: Intel GenuineIntel
[    0.000000] x86/fpu: x87 FPU will use FXSAVE
[    0.001234] Memory: 16384MB RAM
[    0.005678] Zone ranges: DMA [0-16MB], Normal [16MB-16GB]
[    0.012345] ACPI: Core revision 20210730
[    0.023456] PCI: Using configuration type 1 for base access
[    0.034567] clocksource: tsc: mask: 0xffffffff max_cycles: 0x3b...
[    0.045678] Console: colour VGA+ 80x25
[    0.056789] Calibrating delay loop... 4788.00 BogoMIPS

3. Mount initramfs

initramfs (Initial RAM Filesystem): Temporary root filesystem in memory

Why is initramfs needed?

• Chicken-and-egg problem: Kernel needs drivers to access root filesystem, but drivers might be on root filesystem!
• Solution: initramfs contains essential drivers and tools

4. Execute /init (in initramfs)

Kernel runs /init script from initramfs:

1. Load necessary modules:
   • Filesystem drivers (ext4, xfs, btrfs)
   • Block device drivers (SATA, NVMe, USB)
   • RAID/LVM modules if needed
   • Encryption modules (dm-crypt) if needed
2. Setup devices:
   • Create device nodes in /dev
   • Scan for LVM volumes, RAID arrays
   • Prompt for encryption password if root is encrypted
3. Mount real root filesystem:
   • Mount partition specified by root= kernel parameter
   • Typically mounted at /root within initramfs
4. Switch to real root:
   • switch_root - Change root to real filesystem
   • Free initramfs memory
   • Execute /sbin/init on real root filesystem

# Simplified /init script (in initramfs)
#!/bin/sh

# Mount pseudo-filesystems
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs devtmpfs /dev

# Load modules
modprobe ext4
modprobe nvme

# Setup LVM if present
lvm vgscan
lvm vgchange -ay

# Mount real root filesystem
mount -o ro /dev/nvme0n1p2 /root

# Switch to real root and run /sbin/init
exec switch_root /root /sbin/init

Init System: PID 1

First user-space process started by kernel. Parent of all other processes.

Init Systems

systemd Boot Process

1. systemd Started by Kernel

# Kernel executes (PID 1):
/sbin/init → symlink to /lib/systemd/systemd

2. Determine Boot Target

systemd uses targets instead of runlevels:

Default target: /etc/systemd/system/default.target (symlink)

$ ls -l /etc/systemd/system/default.target
lrwxrwxrwx 1 root root 36 Oct 15 10:23 \
    /etc/systemd/system/default.target -> /lib/systemd/system/graphical.target

3. Start Units in Dependency Order

systemd reads unit files and starts services based on dependencies:

Example: graphical.target Dependencies

graphical.target
+-- multi-user.target
|   +-- basic.target
|   |   +-- sysinit.target
|   |   |   +-- local-fs.target (mount filesystems)
|   |   |   +-- swap.target (enable swap)
|   |   |   +-- cryptsetup.target (decrypt volumes)
|   |   +-- sockets.target
|   |   +-- timers.target
|   +-- sshd.service
|   +-- networking.service
|   +-- cron.service
+-- display-manager.service (GDM, LightDM, SDDM)

4. Parallel Service Startup

systemd starts services in parallel when dependencies allow:

# Traditional sequential (SysV):
Start networking... [done]
Start database...   [done]
Start web server... [done]
Total: 15 seconds

# systemd parallel:
Start networking, database, logging simultaneously
Wait only for actual dependencies
Total: 6 seconds

5. Start Login Manager

Final step: Start login interface

Text mode (multi-user.target):

• getty@tty1.service - Login prompt on TTY1-6
• User logs in, shell starts

GUI mode (graphical.target):

• gdm.service - GNOME Display Manager
• lightdm.service - LightDM
• sddm.service - SDDM (KDE)
• User logs in, desktop environment starts