BIOS/UEFI performs POST, selects boot device, and loads bootloader—BIOS reads MBR while UEFI uses EFI System Partition. 2. Bootloader (GRUB) loads kernel and initramfs into memory, allowing kernel selection or parameter editing before execution. 3. Kernel initializes hardware, mounts initramfs as temporary root, runs its /init script to prepare storage, then switches to real root filesystem and starts systemd. 4. systemd, as PID 1, reads default target and starts services in parallel including filesystem mounting, networking, and login managers using target-based units instead of runlevels. 5. A getty process provides login prompt, authentication proceeds via PAM, and upon success, user’s shell launches with configuration files sourced, delivering an interactive prompt—this sequence from firmware to shell enables effective troubleshooting and system understanding.

When you press the power button on a Linux machine, a carefully orchestrated sequence of events takes place before you get a shell prompt. Understanding the Linux boot process—from BIOS to shell—helps with troubleshooting, system customization, and gaining deeper insight into how Linux works under the hood. Here's a breakdown of each stage, explained clearly and practically.

1. BIOS/UEFI: The First Code to Run

When the computer powers on, the first software to run is the BIOS (Basic Input/Output System) or its modern replacement, UEFI (Unified Extensible Firmware Interface).

• Power-on self-test (POST): The BIOS checks hardware components (RAM, CPU, peripherals) to ensure they’re functional.
• Boot device selection: BIOS/UEFI looks for a bootable device (hard drive, USB, CD-ROM) based on the configured boot order.
• Loads the MBR (Master Boot Record): On BIOS systems, it reads the first 512 bytes from the bootable disk (the MBR), which contains the bootloader and the partition table.

?? UEFI systems skip the MBR and instead look for a special EFI System Partition (ESP) containing bootloader files in a FAT32-formatted partition.

Once the bootloader code is loaded into memory, control is passed to it, and the BIOS/UEFI job is done.

2. Bootloader: GRUB Takes Over

The most common bootloader in Linux is GRUB (Grand Unified Bootloader), specifically GRUB 2 on modern systems.

At this stage:

• GRUB displays a menu (if multiple OS or kernel versions are installed).
• You can choose a kernel or edit boot parameters (e.g., to enter recovery mode).
• GRUB locates and loads two critical components into memory:
  • The Linux kernel image (usually /boot/vmlinuz-x.x.x)
  • The initial RAM disk (initramfs), which contains essential drivers and tools needed to mount the real root filesystem.

? Why initramfs? Because the kernel may not have built-in drivers for your storage device (e.g., RAID, LVM, encrypted drives). Initramfs acts as a temporary root filesystem to bridge the gap.

After loading both, GRUB executes the kernel and passes control to it.

3. Kernel Initialization: Setting Up the System

The Linux kernel starts executing and performs several low-level setup tasks:

• Hardware detection and driver loading: Scans and configures hardware using device trees or ACPI tables.
• Mounts the initramfs: Uses it as a temporary root filesystem.
• Executes /init (inside initramfs): This script does whatever is needed to access the real root filesystem—unlocking encrypted volumes, loading modules, activating LVM/RAID.
• Finds and mounts the real root filesystem: Once the necessary drivers are loaded, the kernel switches to the actual root (/) partition.
• Executes the first user-space process: Traditionally init, but now usually systemd on most distributions.

? The "switch_root" command is used to transition from initramfs to the real root filesystem, then the init process starts.

4. init and systemd: Starting User-Space Services

This is where user-space programs begin to run. The first process (PID 1) is responsible for starting all other processes.

• systemd has largely replaced older init systems (SysVinit, Upstart).
• It reads configuration from /etc/systemd/system/default.target (often graphical.target or multi-user.target).
• systemd starts essential services in parallel:
  • Mounting filesystems (via /etc/fstab)
  • Starting networking
  • Launching login managers (like GDM) or getty terminals
  • Running startup scripts and daemons

? systemd uses "targets" instead of traditional runlevels. For example:

• multi-user.target ≈ runlevel 3 (text mode)
• graphical.target ≈ runlevel 5 (GUI mode)

You can check the current target with:

systemctl get-default

5. Login Prompt and Shell

Once systemd finishes initializing the selected target:

• A getty process starts on a terminal (e.g., tty1), displaying a login prompt.
• When you enter your username and password, the system authenticates you via PAM (Pluggable Authentication Modules).
• Upon successful login, your shell (e.g., Bash, Zsh) is launched, reading configuration files like ~/.bashrc or /etc/profile.

At this point, you have an interactive shell prompt and can begin using the system.

?? If you're using a desktop environment, a display manager (like GDM or LightDM) may launch a graphical session instead of a text login.

Summary of the Boot Flow

Here’s the complete sequence in order:

1. BIOS/UEFI → runs POST, finds boot device, loads bootloader
2. Bootloader (GRUB) → loads kernel initramfs
3. Kernel → initializes hardware, mounts initramfs, locates real root, switches to it
4. init/systemd → starts services and essential processes
5. Login/Shell → user logs in, gets a shell prompt

Understanding this flow helps when debugging boot issues—like a stuck GRUB menu, kernel panic, or failing services. Tools like dmesg, journalctl, and GRUB rescue mode become much more useful when you know what’s supposed to happen at each stage.

Basically, from BIOS to shell, Linux follows a chain of responsibility—each stage prepares the next. It’s not magic, just well-orchestrated code.

The above is the detailed content of Understanding the Linux Boot Process from BIOS to Shell. For more information, please follow other related articles on the PHP Chinese website!