initrd vs initramfs

To understand the difference between initrd and initramfs, you have to understand the "Chicken and Egg" problem of the Linux boot process.

The Problem: The Linux kernel needs to mount the root filesystem (your hard drive) to start the OS. However, the hard drive might be on a RAID array, an encrypted partition, or a network drive that requires specific drivers to access. Those drivers are stored... on the hard drive.

The Solution: A small, temporary filesystem loaded into RAM that contains the necessary drivers to "find and unlock" the real hard drive.

initrd (The Old Way)

initrd stands for "Initial Ramdisk." It was the standard until the early 2000s (Linux Kernel 2.4 and earlier).

• How it works: It is a literal block device (like a virtual floppy disk or hard drive) that is formatted with a filesystem (usually ext2).
• The Loading Process:
  1. The kernel creates a fixed-size ramdisk in memory (/dev/ram0).
  2. The kernel copies the initrd image onto that disk.
  3. The kernel mounts that ramdisk as a filesystem.
• The Flaws:
  • Fixed Size: You have to decide how big it is in advance. If it's too small, the drivers won't fit. If it's too large, you waste RAM.
  • Double Buffering: Because it acts like a "disk," the kernel caches the files from the "disk" into the memory cache. This means every file in an initrd takes up double the space in RAM.
  • Filesystem Overhead: The kernel must have a filesystem driver (like ext2) compiled directly into the kernel just to read the initial ramdisk.

initramfs (The Modern Way)

initramfs stands for "Initial RAM Filesystem." Introduced in Linux Kernel 2.6, it is the standard used by almost every modern distro today.

• How it works: Instead of simulating a hard drive, it is a simple cpio archive (similar to a .tar or .zip file, cpio stands for "copy in, copy out") that is compressed.
• The Loading Process:
  1. The kernel creates a tmpfs (a very efficient, dynamic RAM-based filesystem).
  2. The kernel unpacks the cpio archive directly into that tmpfs.
• The Advantages:
  • Dynamic Size: It only takes up exactly as much RAM as the files it contains.
  • Efficiency: There is no "double buffering." The files in tmpfs are already in the kernel's cache.
  • Simplicity: The kernel doesn't need an ext2 driver to read it; the ability to unpack a cpio archive is built into the kernel core.
  • Early Start: It can be integrated directly into the kernel binary itself if needed.

Key Technical Differences

Feature	initrd (Old)	initramfs (New)
Type	Block Device (simulated disk)	Archive (unpacked into tmpfs)
Format	Filesystem image (ext2, etc.)	CPIO archive
RAM Usage	Inefficient (Double-caching)	Very Efficient
Scaling	Fixed size	Dynamic (Grows/shrinks)
Initial Script	/linuxrc	/init
Mechanism	Uses pivot_root	Uses switch_root

How to tell which one you are using

Even though everyone uses initramfs now, many bootloaders (like GRUB) and tools still use the command initrd in their configuration files out of habit/legacy naming.

You can inspect your current boot filesystem on a Linux machine:

1. Find your image: Usually in /boot/initrd.img-$(uname -r) or /boot/initramfs-$(uname -r).img.

2. Check the type:

   file /boot/initrd.img-$(uname -r)
   

   If it says ASCII cpio archive, it is actually an initramfs, regardless of the filename.

3. Peek inside: If you want to see the "mini-OS" that runs before your Linux starts, use the lsinitramfs tool:

   lsinitramfs /boot/initrd.img-$(uname -r) | head -n 20
   

   You will see a miniature directory structure with /bin, /etc, and /lib.

Why this matters

Understanding this transition helps you troubleshoot boot failures.

• If your kernel can't find the root partition, the problem is likely inside the initramfs.
• If you are building a custom embedded Linux system, you will likely create your own initramfs to handle custom hardware initialization before the main OS starts.