When you press the power button on your computer, a complex sequence of operations begins, transforming a collection of electronic components into a functional system. This process, known as booting, is fundamental to how computers operate. This document details the steps involved, from the initial surge of electricity to the loading of the operating system.
Power On: The First Spark
The moment the power button is actuated, the Power Supply Unit (PSU) is the first component to become active. The PSU performs initial self-checks and, if successful, sends a "Power Good" signal to the motherboard. This signal indicates that the PSU can provide stable voltages (e.g., +3.3V, +5V, +12V) required by the various components. Upon receiving the Power Good signal, the motherboard's circuitry distributes power to the Central Processing Unit (CPU), Random Access Memory (RAM), and other peripherals.
The CPU, upon receiving power, is in a reset state. It then begins executing instructions from a predetermined memory address known as the reset vector. This address is hardwired into the CPU's design and typically points to a read-only memory (ROM) chip on the motherboard containing the system's firmware.
Firmware's Role: BIOS and UEFI
The firmware is a critical piece of software that initializes and tests the computer hardware before handing over control to a bootloader. Historically, this firmware was the Basic Input/Output System (BIOS), but modern systems predominantly use the Unified Extensible Firmware Interface (UEFI).
BIOS (Basic Input/Output System)
For decades, BIOS was the standard firmware. When a BIOS-based system starts:
POST (Power-On Self-Test): The BIOS performs a series of checks on essential hardware components. This includes verifying the CPU, RAM integrity (often a quick memory test), storage controllers, keyboard, and video card. If any critical errors are detected during POST, the BIOS will typically communicate this through a series of audible beeps (beep codes, which vary by BIOS manufacturer) or on-screen messages if the video system has been initialized.
Hardware Initialization: The BIOS initializes the detected hardware components to a basic operational state, making them accessible for the next stages.
Boot Device Selection: After POST, the BIOS consults a non-volatile memory store, often CMOS (Complementary Metal-Oxide-Semiconductor) RAM, which is kept powered by a small battery on the motherboard. The CMOS stores system configuration settings, including the boot order (e.g., hard drive, USB drive, optical drive). The BIOS attempts to find a bootable device according to this order.
Loading the MBR (Master Boot Record): Once a bootable device is found (typically the primary hard drive), the BIOS reads the first 512-byte sector from that device. This sector is the Master Boot Record (MBR). The BIOS loads the contents of the MBR into a specific location in RAM (usually address 0x7C00) and then transfers execution control to the code within the MBR. The MBR contains a small program (the initial bootloader code, up to 446 bytes) and the partition table for the disk.
UEFI (Unified Extensible Firmware Interface)
UEFI is the successor to BIOS, designed to overcome many of its limitations. Key advantages of UEFI include:
Support for larger storage devices: UEFI uses GUID Partition Table (GPT) which allows for vastly larger disk partitions (beyond the 2TB limit of MBR) and more partitions.
Faster boot times: UEFI can initialize hardware in parallel and has optimized driver models.
Richer pre-OS environment: UEFI offers a more sophisticated environment before the OS loads, complete with networking, graphical capabilities, and its own shell.
Security features: Secure Boot is a notable UEFI feature that helps prevent unauthorized bootloaders and rootkits from running by verifying digital signatures.
The UEFI boot process is more structured and typically involves several phases:
SEC (Security Phase): This is the initial phase responsible for handling power-on and CPU reset. It sets up a temporary RAM (often CPU cache) and passes control to the PEI phase.
PEI (Pre-EFI Initialization Phase): The PEI phase is responsible for initializing core system components, including main memory (DRAM) and determining the system state. It discovers and dispatches PEI Modules (PEIMs) which perform specific initialization tasks.
DXE (Driver Execution Environment Phase): This is the main phase where most of the system hardware initialization occurs. The DXE dispatcher loads DXE drivers for the motherboard chipsets, peripherals, and system services. These drivers provide the interfaces used by later stages, including the boot manager.
BDS (Boot Device Select Phase): The BDS architectural protocol is invoked. It attempts to load UEFI drivers for console devices and then processes the boot order configured in NVRAM (Non-Volatile RAM, similar to CMOS in BIOS systems). It identifies and attempts to run a boot application.
TSL (Transient System Load Phase): This is the phase where the actual operating system bootloader is loaded and executed. If a bootloader requires it, this phase can also load additional UEFI applications.
RT (Run Time Phase): Once the operating system bootloader (and subsequently the OS kernel) takes control, the system transitions to the Runtime phase. UEFI provides runtime services that the OS can use (e.g., for managing UEFI variables, time services, and firmware updates). However, most of the pre-boot services are terminated to free up resources.
In a UEFI system, the firmware looks for a specific partition on the boot device called the EFI System Partition (ESP). The ESP is typically formatted with FAT32 and contains bootloader applications for installed operating systems (e.g., \EFI\BOOT\BOOTX64.EFI as a fallback, or OS-specific paths like \EFI\Microsoft\Boot\bootmgfw.efi for Windows or \EFI\ubuntu\grubx64.efi for Ubuntu). The UEFI firmware directly executes the selected EFI boot application.
Boot Loaders: Bridging Firmware and OS
The bootloader is a piece of software responsible for loading the main operating system kernel. Its function differs slightly depending on whether the system is BIOS-based or UEFI-based.
BIOS-based Boot Loaders:
As mentioned, the BIOS loads the MBR. The MBR code is very small (446 bytes) and usually performs one of two actions:
Single-stage bootloader: For very simple scenarios, it might directly load the OS. This is rare for modern operating systems.
Chain loading to a second-stage bootloader: More commonly, the MBR code locates the active partition (marked in the partition table), reads its Volume Boot Record (VBR, also known as the Partition Boot Sector or PBR), and transfers execution to the code in the VBR. This VBR code is the second-stage bootloader, or it loads a more sophisticated multi-stage bootloader.
UEFI Boot Applications (Boot Managers):
In UEFI systems, the firmware directly loads an EFI boot application from the ESP. These applications are essentially boot managers.
Windows Boot Manager (bootmgfw.efi): Similar to its BIOS counterpart, it reads the BCD store and loads winload.efi.
GRUB2 for EFI (grubx64.efi): The EFI version of GRUB2. It can access files on various filesystems and offers extensive configuration options.
systemd-boot (formerly Gummiboot): A lightweight EFI boot manager often used in Linux systems that employ systemd. It reads simple configuration files from the ESP.
rEFInd: A graphical boot manager for UEFI systems, capable of auto-detecting EFI boot applications.
These boot managers typically provide a menu if multiple operating systems or kernel versions are available. Once a selection is made, the boot manager's primary task is to load the operating system kernel and, if necessary, an initial RAM disk (initrd or initramfs in Linux) into memory.
The Boot Sequence: Loading the Operating System Kernel
After the firmware has initialized the hardware and the bootloader (or EFI boot application) has been loaded and executed, the final stages of the boot process begin:
Kernel Loading: The selected bootloader locates the operating system kernel file (e.g., ntoskrnl.exe for Windows, vmlinuz for Linux) on the appropriate disk partition. It loads this kernel file, and often an associated initial RAM disk image (like initramfs in Linux, which contains essential drivers and utilities to mount the real root filesystem), into system memory (RAM).
Transfer of Control: Once the kernel and any necessary auxiliary files are in RAM, the bootloader transfers execution control to the loaded kernel. At this point, the bootloader's job is largely complete.
Kernel Initialization: The operating system kernel takes over. Its first tasks include:
Initializing its own internal data structures.
Setting up memory management.
Initializing device drivers for all detected hardware. For many devices, the kernel uses more advanced drivers than the basic ones initialized by the firmware.
Mounting the root filesystem. This is the primary storage partition where the rest of the operating system files reside.
Starting System Processes: The kernel then starts the initial user-space process.
In Linux, this is typically the init process (which might be systemd, SysVinit, or Upstart). The init process is responsible for starting all other system services and daemons according to its configuration (e.g., networking services, display managers, logging services).
In Windows, the kernel (ntoskrnl.exe) starts the Session Manager Subsystem (smss.exe), which in turn launches the Windows startup process (wininit.exe), the Client/Server Runtime Subsystem (csrss.exe), and the login process (winlogon.exe).
User Interface: Finally, system services that manage the user interface are started. For graphical environments, this involves starting the display server (e.g., X.Org Server or Wayland compositor in Linux) and the desktop environment or window manager. In Windows, winlogon.exe eventually presents the login screen.
Once the login screen or desktop environment appears, the computer has successfully completed its boot sequence and is ready for user interaction. This journey from a seemingly inert state to a fully operational system involves a precise and well-orchestrated sequence of hardware and software actions.