Skip to main content
HashnodeLinuxcore

Command Palette

Search for a command to run...

Overview: Linux Boot Process Steps

Published
•9 min read•View as Markdown
M
MUKESH KUMAR MAHTO

🧠 Overview: Linux Boot Process Steps

The Linux boot process can be divided into six main stages:

  1. BIOS / UEFI Initialization

    • When you power on the system, the BIOS (on older systems) or UEFI (on newer ones) performs:

      • Hardware initialization (CPU, memory, storage, peripherals)

      • POST (Power-On Self Test)

      • Locates and loads the bootloader from a bootable device (hard disk, USB, network, etc.)

    • The BIOS/UEFI then passes control to the bootloader (like GRUB).

  1. Bootloader Stage (GRUB)

    • GRUB (GRand Unified Bootloader) is the most common Linux bootloader.

    • It provides a menu to select the OS or kernel version.

    • It loads the selected Linux kernel and the initial RAM disk (initramfs) into memory.

    • Configuration file: /boot/grub/grub.cfg

  1. Kernel Initialization

    • The Linux kernel takes control.

    • It:

      • Initializes core hardware components (CPU, memory, devices)

      • Mounts the initramfs (temporary filesystem in RAM)

      • Detects and loads device drivers needed for the real root filesystem

  1. initramfs (Initial RAM Filesystem)

    • Temporary root filesystem used to prepare the system for mounting the real root filesystem.

    • Contains tools and drivers needed for booting.

    • Once the real root filesystem is ready, initramfs is unloaded from memory.

  1. System Initialization (systemd / init)

    • The kernel starts the first user-space process — traditionally /sbin/init, now often systemd.

    • systemd handles:

      • Starting essential background services (network, logging, etc.)

      • Mounting filesystems

      • Managing system targets (like multi-user, graphical, etc.)

    • Default target configuration file: /etc/systemd/system/default.target

  1. User Space / Login

    • Once all services are started:

      • You’re presented with a login prompt (CLI or GUI)

      • The desktop environment (like GNOME, KDE, XFCE) loads if it’s a graphical target

    • You can now interact with the system normally.

🧩 Simplified Boot Flow

Power On
   ↓
BIOS/UEFI
   ↓
Bootloader (GRUB)
   ↓
Kernel + initramfs
   ↓
System Initialization (systemd)
   ↓
User Login (CLI/GUI)

🧩 Linux Boot Process (as shown in your diagram)

  1. Power ON

    • The computer is powered up; hardware components are energized.

  2. BIOS

    • Performs POST (Power-On Self-Test).

    • Locates a bootable device.

    • Hands control to the MBR (for BIOS systems) or EFI Partition (for UEFI systems).

  3. Master Boot Record (MBR) / EFI Partition

    • Contains information about partitions and the bootloader location.

    • Points to the Boot Loader (like GRUB).

  4. Boot Loader (GRUB)

    • Loads the Linux kernel and initramfs into memory.

    • Lets you choose between OSes or kernels if multiple are installed.

  5. Kernel

    • Initializes hardware, mounts initramfs, and starts the init process.

  6. Initial RAM Disk (initramfs)

    • Temporary filesystem that helps load essential drivers and mount the real root filesystem.

  7. /sbin/init (Parent Process)

    • The first user-space process (PID 1).

    • Starts all other services.

    • In modern systems, this is usually systemd.

  8. Command Shell (via getty)

    • Provides login prompt (for CLI access).

    • You can log in and interact through the shell.

  9. Graphical User Interface (X Window or Wayland)

    • If a desktop environment is installed, it loads here.

    • The user sees the graphical desktop (GNOME, KDE, etc.).

    • 🧠 BIOS – The First Step

      When you power on an x86-based Linux system, the BIOS (Basic Input/Output System) is the first program to run.
      It performs the POST (Power-On Self Test) to check and initialize hardware components like memory, keyboard, and display.

      The BIOS, stored on a ROM chip on the motherboard, ensures the system hardware is ready and then locates a bootable device. Once this is done, it hands control over to the operating system to continue the boot process.

BIOS vs. UEFI

💽 Master Boot Record (MBR), EFI Partition, and Boot Loader

After the POST completes, control passes from the BIOS/UEFI to the boot loader.
The boot loader resides on a storage device—either in the boot sector (for traditional BIOS/MBR systems) or the EFI partition (for modern UEFI systems).

At this stage, the system retrieves essential hardware settings like date, time, and device info from the CMOS memory, which retains data even when powered off.

Common Linux boot loaders include:

  • GRUB – GRand Unified Boot Loader (most widely used)

  • ISOLINUX – for booting from removable media

  • DAS U-Boot – for embedded systems

The boot loader’s main tasks are to:

  1. Present a menu for selecting OS or kernel options.

  2. Load the Linux kernel and initial RAM disk (initramfs) into memory.

  3. Hand control over to the kernel to continue system startup.

🧩 Stage 1 – Initial Boot Loader

  • On BIOS/MBR systems:

    • The boot loader is stored in the first 512 bytes of the hard disk, known as the Master Boot Record (MBR).

    • It checks the partition table to locate a bootable partition.

    • Once found, it loads the second-stage boot loader (e.g., GRUB) into RAM.

  • On EFI/UEFI systems:

    • The UEFI firmware reads the Boot Manager configuration to determine which UEFI application (like GRUB) to start and from which EFI partition.

    • This modern method is more flexible and powerful than the traditional MBR approach.

🧩 Stage 2 – Full Boot Loader (/boot)

  • Located in the /boot directory.

  • Displays a splash screen or menu, allowing users to select:

    • The operating system or

    • A specific kernel version to boot.

  • Once selected, the boot loader:

    1. Loads the kernel into RAM.

    2. The kernel decompresses itself (since it’s stored in a compressed format).

    3. Initializes hardware and loads built-in device drivers.

The Initial RAM Disk

🧩 The Initial RAM Disk (initramfs)

The initramfs (initial RAM filesystem) is a temporary, in-memory filesystem that plays a crucial role in the Linux boot process. It bridges the gap between the boot loader and the real root filesystem.

⚙️ Key Functions

  • Contains essential programs, binaries, and drivers needed to:

    • Detect and mount the actual root filesystem.

    • Load necessary kernel modules (e.g., storage or filesystem drivers).

    • Use the udev system to identify connected devices and load appropriate drivers.

🧠 How It Works

  1. The kernel loads the initramfs into RAM (provided by the boot loader).

  2. The udev system detects available devices.

  3. The mount program mounts the correct root filesystem.

  4. The filesystem is checked for errors and then made ready for use.

  5. Once the real root filesystem is active:

    • The initramfs is cleared from RAM to free memory.

    • The init process (/sbin/init or systemd) starts, continuing the system startup.

💻 Text-Mode Login

As the Linux boot process nears completion, the init process (or systemd) launches several text-mode login prompts on different terminals.
These allow users to log in by entering their username and password, after which they are given access to a command shell.

🧩 Accessing Terminals

  • On systems with a graphical interface, you might not see text logins by default.

  • To switch between them:

    • Text consoles: Ctrl + Alt + F1 to F6

    • Return to GUI: Ctrl + Alt + F7 (or F1, depending on the distribution)

  • Most Linux systems start six text terminals and one graphical terminal.

🧠 Shell Environment

  • The default command shell is usually bash (Bourne Again Shell).

  • The shell:

    1. Displays a prompt to indicate readiness for input.

    2. Accepts and executes commands typed by the user.

    3. Returns a new prompt when the command finishes.

🧠 The Linux Kernel

Once the boot loader finishes its job, it loads two critical components into memory:

  • The Linux kernel itself, and

  • The initial RAM filesystem (initramfs).

⚙️ What the Kernel Does

After being loaded into RAM, the kernel takes full control of the system. It performs several essential tasks:

  1. Initializes and manages system memory

    • Allocates and organizes memory for processes and the OS.

  2. Detects and configures hardware

    • Identifies and sets up CPUs, storage devices, I/O controllers, and peripheral devices.

  3. Loads essential drivers and user-space helpers

    • Ensures hardware can communicate properly.

    • Starts key user-space applications (like init or systemd) to continue the boot process.

⚙️ /sbin/init and Services

After the kernel initializes the hardware and mounts the root filesystem, it starts the very first user-space process — /sbin/init.
This process becomes the parent of all other user-space processes, except for a few kernel threads created directly by the kernel.

🧠 Role of init

  • Starts essential system services to bring the system into a usable state.

  • Monitors and manages processes, restarting or cleaning them up when they finish.

  • Handles system shutdowns and reboots, ensuring everything stops cleanly.

  • Restarts login services when users log out, maintaining continuous system operation.

🏗️ From SysVinit to Modern Systems

  • Traditionally, Linux used SysVinit, a sequential startup system derived from UNIX System V.

    • It organized startup into runlevels, each defining a specific mode (e.g., single-user, multi-user, graphical).

    • Each runlevel executed a series of shell scripts to start or stop services.

  • However, this serial process was slow and difficult to parallelize.

🚀 Modern Replacement – systemd

  • Most modern Linux distributions now use systemd instead of SysVinit.

  • systemd:

    • Starts services in parallel, greatly speeding up boot time.

    • Uses targets (instead of runlevels) to define system states.

    • Provides powerful tools for monitoring and managing services (systemctl).

    • Maintains backward compatibility with many old SysV-style scripts.

  • ⚙️ systemd Features

    systemd is the modern initialization and service management system used by most Linux distributions today.
    It significantly improves system startup speed, reliability, and manageability compared to older init systems.

    ⚡ 1. Faster Boot Times

    • systemd replaces the sequential startup of SysVinit with parallel processing.

    • Multiple services start simultaneously, reducing overall boot time.

    • Dependencies are managed intelligently, ensuring services start in the correct order.

🧩 2. Simplified Configuration

  • Instead of complex shell scripts, systemd uses simple configuration files (called unit files).

  • These files define:

    • What dependencies a service has.

    • How the service starts and stops.

    • What signals indicate successful startup.

  • The /sbin/init binary now points to /lib/systemd/systemd, meaning systemd completely replaces init.

🧠 3. Unified Management with systemctl

systemd introduces a single, powerful command — systemctl — to control services and system states.

Examples:

TaskCommand
Start, stop, or restart a service`sudo systemctl start
Enable or disable a service at boot`sudo systemctl enable
Check service statussudo systemctl status httpd.service

💡 Note: You can usually omit “.service” at the end of the command.

🧰 4. Other Advanced Features

  • Socket activation – starts services only when needed.

  • Logging integration – works with journald for centralized log management.

  • Target-based startup – replaces runlevels with more flexible “targets.”

  • Resource control – manages CPU and memory usage using cgroups (control groups).

🧠 Step-by-Step Commands

  1. Check if Apache is running

     $ sudo systemctl status httpd

  2. If it is running, stop the service

     $ sudo systemctl stop httpd

  3. Verify that it has stopped

     $ sudo systemctl status httpd

  4. Start the Apache service again

     $ sudo systemctl start httpd

  5. Confirm that it is running

     $ sudo systemctl status httpd

  6. (Optional) Stop it again when finished

     $ sudo systemctl stop httpd

Comments

Join the discussion

No comments yet. Be the first to comment.

More from this blog

Linuxcore

5 posts