initramfs: The Initial RAM Filesystem Explained

What is initramfs?

initramfs (initial RAM filesystem) is a temporary root filesystem loaded into memory during the Linux boot process. It contains essential drivers and scripts needed to mount the real root filesystem and continue the boot process. Think of it as a minimal Linux environment that bridges the gap between the kernel starting and your actual system becoming available.

The Boot Process Journey

initramfs Boot Process Visualization

BIOS/UEFI

Active

Bootloader (GRUB)

Kernel Start

initramfs /init

Load Modules

Mount Real Root

switch_root

Current Stage

BIOS/UEFI

Firmware initializes hardware and loads bootloader

System State

Mounted:None

Modules:None

Understanding the Boot Sequence

The boot process transitions from firmware to bootloader to kernel, with initramfs providing the bridge to mount the real root filesystem. Each stage prepares the system for the next, loading drivers and initializing hardware.

Why Do We Need initramfs?

The Chicken-and-Egg Problem

Modern Linux systems face a fundamental challenge during boot:

Kernel needs drivers to access the root filesystem
Drivers are stored on the root filesystem
Can't load drivers without accessing the filesystem first!

initramfs solves this paradox by providing a minimal filesystem in RAM with just enough tools and drivers to:

Initialize hardware
Load necessary kernel modules
Mount the real root filesystem
Hand over control to the real init system

Real-World Scenarios

# Example: Your root filesystem is on an encrypted LVM volume
# Boot sequence without initramfs would fail:
# 1. Kernel boots
# 2. Tries to mount root from /dev/mapper/vg-root
# 3. FAILS - no LVM tools, no crypto modules!

# With initramfs:
# 1. Kernel boots with initramfs
# 2. initramfs loads dm-crypt module
# 3. initramfs prompts for encryption password
# 4. initramfs activates LVM volumes
# 5. initramfs mounts real root
# 6. Boot continues normally

initramfs vs initrd

While often used interchangeably, initramfs and initrd are different:

Aspect	initrd (Old)	initramfs (Modern)
Type	Compressed disk image	CPIO archive
Filesystem	Real filesystem (ext2, etc.)	tmpfs in RAM
Memory Usage	Fixed size, wastes space	Dynamic, efficient
Kernel Integration	Separate from kernel	Can be built into kernel
Complexity	Requires filesystem driver	Simpler, no filesystem needed
Modification	Must rebuild entire image	Easy to modify individual files
Performance	Slower (block device)	Faster (direct memory)

# Check what your system uses
file /boot/initramfs-* /boot/initrd-*

# Modern systems output:
# /boot/initramfs-5.15.0: ASCII cpio archive (gzip compressed)

# Older systems might show:
# /boot/initrd-5.15.0: Linux rev 1.0 ext2 filesystem data

Anatomy of initramfs

Directory Structure

# Extract and examine initramfs
mkdir /tmp/initramfs
cd /tmp/initramfs
zcat /boot/initramfs-$(uname -r).img | cpio -idmv

# Typical structure:
# /tmp/initramfs/
# ├── bin/           # Essential binaries (busybox, sh)
# ├── dev/           # Device files
# ├── etc/           # Configuration files
# ├── init           # Main init script (PID 1)
# ├── lib/           # Libraries
# ├── lib64/         # 64-bit libraries
# ├── proc/          # Proc filesystem mount point
# ├── run/           # Runtime data
# ├── sbin/          # System binaries
# ├── sys/           # Sysfs mount point
# ├── tmp/           # Temporary files
# └── usr/           # Additional binaries and libraries

The init Script

The heart of initramfs is the /init script (or binary):

#!/bin/sh
# Simplified init script example

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

# Parse kernel command line
for param in $(cat /proc/cmdline); do
    case $param in
        root=*)
            root="${param#root=}"
            ;;
        init=*)
            init="${param#init=}"
            ;;
    esac
done

# Load necessary modules
modprobe ahci          # SATA controller
modprobe sd_mod        # SCSI disk support
modprobe ext4          # Filesystem support

# Wait for root device
while [ ! -e "$root" ]; do
    sleep 0.1
done

# Mount real root filesystem
mount -o ro "$root" /newroot

# Switch to real root
exec switch_root /newroot ${init:-/sbin/init}

Building initramfs

Different distributions use different tools:

Dracut (Fedora, RHEL, openSUSE)

# Generate initramfs for current kernel
dracut --force

# Generate for specific kernel
dracut --force /boot/initramfs-5.15.0.img 5.15.0

# Add extra modules
dracut --add-drivers "nvidia nouveau" --force

# Include custom files
dracut --include /path/to/file /target/path --force

# Debug mode (verbose)
dracut --debug --force

mkinitcpio (Arch Linux)

# Configuration file: /etc/mkinitcpio.conf
# MODULES=(ext4 dm_crypt)
# HOOKS=(base udev autodetect modconf block encrypt lvm2 filesystems keyboard fsck)

# Generate initramfs
mkinitcpio -P

# For specific preset
mkinitcpio -p linux

# Custom configuration
mkinitcpio -c /etc/mkinitcpio-custom.conf -g /boot/initramfs-custom.img

update-initramfs (Debian, Ubuntu)

# Update initramfs for current kernel
update-initramfs -u

# Create new initramfs
update-initramfs -c -k $(uname -r)

# Update all kernels
update-initramfs -u -k all

# Debug mode
update-initramfs -u -v

Boot Sequence in Detail

1. BIOS/UEFI Phase

# Boot sequence
# Power On → POST → BIOS/UEFI → Boot Loader (GRUB)

2. Bootloader Phase

# GRUB loads kernel and initramfs into memory
linux   /vmlinuz-5.15.0 root=/dev/sda2 ro quiet
initrd  /initramfs-5.15.0.img

3. Kernel Initialization

# Kernel boot sequence
# Kernel starts → Decompress initramfs → Mount as rootfs → Execute /init

4. initramfs Phase

# /init script runs as PID 1
1. Mount virtual filesystems (/proc, /sys, /dev)
2. Initialize hardware (udev)
3. Load kernel modules
4. Locate and prepare root filesystem
5. Mount real root at /newroot
6. Clean up initramfs
7. switch_root to real root

5. Real Init System

# Final handoff
# systemd/SysV init takes over → System boots normally

Common Use Cases

1. Encrypted Root Filesystem

# initramfs handles LUKS encryption
# /init script includes:
cryptsetup luksOpen /dev/sda2 cryptroot
mount /dev/mapper/cryptroot /newroot

2. Network Boot (PXE)

# initramfs configures network and mounts NFS root
ip link set eth0 up
dhclient eth0
mount -t nfs 192.168.1.100:/nfsroot /newroot

3. RAID Arrays

# initramfs assembles RAID before mounting
mdadm --assemble --scan
mount /dev/md0 /newroot

4. LVM Volumes

# initramfs activates LVM
lvm vgchange -ay
mount /dev/mapper/vg-root /newroot

Troubleshooting initramfs

Boot to initramfs Shell

If boot fails, you often drop to an initramfs shell:

(initramfs) # You're now in the minimal environment

# Check available devices
(initramfs) ls /dev/

# Check kernel messages
(initramfs) dmesg | less

# List loaded modules
(initramfs) lsmod

# Try manual mount
(initramfs) mount /dev/sda2 /newroot
(initramfs) exec switch_root /newroot /sbin/init

Common Issues and Solutions

Missing Drivers

# Problem: Can't find root device
# Solution: Rebuild initramfs with needed drivers

# Add driver to initramfs
echo "ahci" >> /etc/modules-load.d/ahci.conf
update-initramfs -u

Wrong Root Device

# Problem: root=/dev/sda2 but disk order changed
# Solution: Use persistent naming

# Use UUID instead
root=UUID=123e4567-e89b-12d3-a456-426614174000

# Or use LABEL
root=LABEL=rootfs

Corrupted initramfs

# Boot from live USB, then:
mount /dev/sda2 /mnt
mount /dev/sda1 /mnt/boot
chroot /mnt
update-initramfs -c -k all

Advanced Features

Embedded initramfs

You can build initramfs directly into the kernel:

# Kernel config
CONFIG_INITRAMFS_SOURCE="initramfs.cpio"
CONFIG_INITRAMFS_COMPRESSION_GZIP=y

# Build kernel with embedded initramfs
make menuconfig
# General setup → Initial RAM filesystem and RAM disk support

Custom Init Programs

Instead of a shell script, you can use a compiled program:

// minimal_init.c
#include <stdio.h>
#include <unistd.h>
#include <sys/mount.h>

int main() {
    // Mount essential filesystems
    mount("none", "/proc", "proc", 0, "");
    mount("none", "/sys", "sysfs", 0, "");
    
    // Mount real root
    mount("/dev/sda2", "/newroot", "ext4", MS_RDONLY, "");
    
    // Switch root
    chdir("/newroot");
    mount(".", "/", NULL, MS_MOVE, NULL);
    chroot(".");
    
    // Execute real init
    execl("/sbin/init", "init", NULL);
    return 0;
}

Microcode Updates

Modern initramfs includes CPU microcode updates:

# Intel CPU
/kernel/x86/microcode/GenuineIntel.bin

# AMD CPU  
/kernel/x86/microcode/AuthenticAMD.bin

# Applied very early in boot process

Creating Minimal initramfs

Manual Creation

#!/bin/bash
# create_initramfs.sh

# Create directory structure
mkdir -p initramfs/{bin,dev,etc,lib,lib64,proc,sys,newroot}

# Copy busybox (provides basic utilities)
cp /bin/busybox initramfs/bin/
ln -s busybox initramfs/bin/sh
ln -s busybox initramfs/bin/mount
ln -s busybox initramfs/bin/umount

# Create init script
cat > initramfs/init << 'EOF'
#!/bin/sh
/bin/busybox --install -s /bin

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

# Parse root= from kernel command line
root=$(cat /proc/cmdline | sed 's/.*root=\([^ ]*\).*/\1/')

# Wait for root device
while [ ! -b "$root" ]; do
    sleep 0.1
done

# Mount root filesystem
mount -o ro "$root" /newroot

# Switch to real root
exec switch_root /newroot /sbin/init
EOF

chmod +x initramfs/init

# Copy necessary libraries
ldd /bin/busybox | awk '{print $3}' | xargs -I {} cp {} initramfs/lib/

# Create cpio archive
cd initramfs
find . | cpio -o -H newc | gzip > ../initramfs.img
cd ..

echo "Created initramfs.img"

Performance Optimization

Size Reduction

# Remove unnecessary modules
# Edit /etc/dracut.conf or /etc/mkinitcpio.conf

# Dracut
omit_drivers+=" bluetooth wireless "

# mkinitcpio - use autodetect hook
HOOKS=(base udev autodetect ...)

# Compression options
# XZ (smallest, slowest)
compress="xz"

# LZ4 (fastest, larger)
compress="lz4"

# ZSTD (good balance)
compress="zstd"

Boot Speed

# Parallel module loading
# Add to kernel command line
rd.driver.pre=ahci,sd_mod,ext4

# Skip unnecessary features
rd.luks=0 rd.lvm=0 rd.md=0 rd.dm=0

# Reduce timeout
rd.timeout=10

Debugging and Analysis

Extracting and Examining

# Extract initramfs
mkdir extracted
cd extracted

# For gzip compressed
zcat /boot/initramfs-*.img | cpio -idmv

# For xz compressed
xzcat /boot/initramfs-*.img | cpio -idmv

# Analyze contents
du -sh *
find . -type f -exec file {} \; | head -20

# Check included modules
find lib/modules -name "*.ko" | wc -l

Boot Debugging

# Kernel command line options for debugging

# Break at specific points
rd.break=pre-mount    # Before mounting root
rd.break=pre-pivot    # Before switch_root

# Enable debug output
rd.debug systemd.log_level=debug

# Shell on failure
rd.shell

# Save debug log
rd.debug rd.log=/run/initramfs/debug.log

Modern Alternatives

systemd in initramfs

Some distributions use systemd in initramfs:

# systemd-based initramfs structure
/usr/lib/systemd/systemd    # Init binary
/usr/lib/systemd/system/     # Unit files
/etc/systemd/system/         # Configuration

# Benefits:
# - Parallel initialization
# - Better dependency handling
# - Consistent with main system

initramfs-less Boot

For embedded systems or specific use cases:

# Kernel with built-in drivers
# No initramfs needed if:
# - Root filesystem driver compiled in
# - No encryption/LVM/RAID
# - Simple partition layout

# Kernel command line
root=/dev/sda1 init=/sbin/init

Best Practices

Keep it minimal - Only include necessary drivers
Use persistent naming - UUID/LABEL for root device
Regular updates - Rebuild after kernel/driver updates
Test changes - Keep working initramfs as backup
Document customizations - Track manual modifications

Conclusion

initramfs is a crucial component of the Linux boot process, solving the chicken-and-egg problem of mounting the root filesystem. It provides a flexible, efficient way to:

Initialize hardware before the main system
Support complex storage configurations (encryption, LVM, RAID)
Enable network booting and diskless systems
Apply early patches like microcode updates
Provide recovery environment when boot fails

Understanding initramfs helps in troubleshooting boot issues, optimizing boot time, and customizing Linux systems for specific requirements.

Table of Contents

initramfs Boot Process Visualization

Current Stage

System State

Understanding the Boot Sequence