Shell / Bash
Linux initramfs 原理与实现：从内核启动到根文件系统
initramfs 是 Linux 启动过程中连接内核与真实根文件系统的临时文件系统。它采用 cpio 压缩归档格式，被加载到内存并解压至 rootfs，用于加载驱动、配置硬件及执行初始化脚本。通过 switch_root 机制，系统最终切换到真实根文件系统。深入剖析了 initramfs 的构建、加载、执行流程，对比了 initrd 区别，并提供了基于 busybox 的最小化构建实践及调试方法。
initramfs 是 Linux 启动过程中连接内核与真实根文件系统的临时文件系统。它采用 cpio 压缩归档格式，被加载到内存并解压至 rootfs，用于加载驱动、配置硬件及执行初始化脚本。通过 switch_root 机制，系统最终切换到真实根文件系统。深入剖析了 initramfs 的构建、加载、执行流程，对比了 initrd 区别，并提供了基于 busybox 的最小化构建实践及调试方法。
initramfs（Initial RAMdisk File System）是现代 Linux 系统启动过程中的关键组件，它充当了内核与真实根文件系统之间的一座桥梁。当内核完成初始化后，在挂载真实根文件系统之前，需要一个临时的文件系统来加载必要的驱动程序、运行初始化脚本，以及处理各种硬件配置。这个临时文件系统就是 initramfs。
不同于早期的 initrd（Initial RAM Disk），initramfs 是一个完整的 cpio 压缩归档文件，被嵌入到内核镜像中或作为单独的文件加载。它包含了启动所需的最小根文件系统，通常包括 init 进程、必要的二进制工具、驱动程序和配置文件。initramfs 的存在让 Linux 系统能够支持复杂的启动场景：加载磁盘驱动、配置网络、解密根分区、等待设备就绪等。
本文将从数据结构、启动流程、实现机制等多个维度深入剖析 initramfs 的工作原理，帮助读者理解现代 Linux 启动过程中这个看似神秘但又至关重要的组件。
在讨论 initramfs 之前，必须搞清它与前辈 initrd 的区别。这两个名词经常被混用，但它们代表着不同时代的启动方案。
initrd（Initial RAM Disk）是一个虚拟块设备，内核将其视为一个真实的磁盘。它包含了一个完整的文件系统镜像（通常是 ext2 格式），内核需要通过传统的块设备驱动来访问它。这意味着即使启动 initrd，内核也需要加载磁盘驱动程序，这形成了一个'鸡生蛋，蛋生鸡'的问题。initrd 的大小也受到限制，因为它必须完整地加载到内存中。
initramfs 是一个 cpio 格式的压缩归档文件，内核对其有特殊的处理方式。在内核启动时，initramfs 被直接加载到内存中，内核然后将其解压到一个虚拟文件系统（VFS, Virtual File System）上。这个过程不需要任何块设备驱动，解决了 initrd 的自引用问题。initramfs 可以被编译到内核镜像中，也可以作为单独的文件由引导加载程序（bootloader）加载。
简单来说，initrd 是'假块设备'，initramfs 是'直接的文件系统'。
initramfs 的生命周期分为三个关键阶段：
要理解 initramfs，必须理解 Linux 虚拟文件系统（VFS）和 rootfs 的概念。VFS 是 Linux 内核中的一个抽象层，它为所有文件系统提供了统一的接口，使得不同的文件系统（ext4、btrfs、NFS 等）可以以相同的方式被访问。
rootfs 是一个基于内存的文件系统实现，它是所有 Linux 系统的根基。当内核启动时，它创建一个 rootfs 实例，然后将 initramfs 的内容解压到这个 rootfs 中。因此，initramfs 本质上是对 rootfs 的初始化填充。
让我们从内核源码的角度来看 initramfs 是如何被处理的。Linux 内核在启动过程中有一个特殊的阶段来处理 initramfs，这个过程主要发生在 init/main.c 的 start_kernel() 和后续的启动函数中。
/* kernel/init/main.c - 简化版示意 */
static int __init do_populate_rootfs(void) {
/* 初始化 rootfs, 解压 initramfs 内容 */
unpack_to_rootfs(__initramfs_start, __initramfs_size);
/* 执行 init 进程 */
if (execute_command) {
/* 如果提供了自定义 init 程序 */
ret = run_init_process(execute_command);
} else {
/* 尝试多个标准 init 路径 */
ret = run_init_process("/sbin/init");
if (ret) ret = run_init_process("/etc/init");
if (ret) ret = run_init_process("/bin/init");
if (ret) ret = run_init_process("/bin/sh");
}
return ret;
}
这段代码展示了几个关键步骤：首先，unpack_to_rootfs() 函数将内核中编译进来的 initramfs（通过符号 __initramfs_start 和 __initramfs_size 标记）解压到 rootfs 中。然后，内核尝试执行一个 init 程序，这个程序将接管系统的初始化。
initramfs 使用 cpio 格式进行打包。cpio 是一个古老但仍然广泛使用的归档格式，它的优点是简单、易于解析，对于内核这样的低级代码来说特别适合。让我们看看 cpio 的基本结构：
+--------+--+--------+--+--------+--+
| Header | Padding | Data | Padding |
+--------+--+--------+--+--------+--+
现代 Linux 通常使用 newc 格式（也叫 SVR4 cpio 格式），这是一个 ASCII 十六进制格式，便于调试和验证。一个典型的 cpio header 如下：
/* cpio header 结构 - newc 格式 */
struct cpio_newc_header {
char c_magic[6]; /* "070701" for newc format */
char c_ino[8]; /* inode number */
char c_mode[8]; /* file mode */
char c_uid[8]; /* user id */
char c_gid[8]; /* group id */
char c_nlink[8]; /* number of hard links */
char c_mtime[8]; /* modification time */
char c_filesize[8]; /* file size */
char c_devmajor[8]; /* device major number */
char c_devminor[8]; /* device minor number */
char c_rdevmajor[8]; /* rdev major number */
char c_rdevminor[8]; /* rdev minor number */
char c_namesize[8]; /* length of filename */
char c_check[8]; /* checksum */
};
每个文件在 cpio 归档中都有这样的 header，后跟文件名、padding、文件数据和更多 padding。整个归档以一个名为 'TRAILER!!!' 的特殊条目结尾，标志着归档的完成。
# 使用 cpio 命令创建 initramfs
find . -print0 | cpio -0 -o -H newc -F ../initramfs.cpio
# 或者使用 cpio 直接从文件列表创建
# 然后通过 gzip 压缩
gzip initramfs.cpio
当 GRUB 或其他引导加载程序加载 Linux 内核时，如果指定了 initramfs 文件，引导加载程序会将其加载到内存中，并通过 multiboot 协议（或其他引导协议）将其位置和大小信息传递给内核。内核在启动时会识别这个 initramfs 并进行解压。
[引导加载程序]
v
[加载内核镜像到内存]
v
[加载 initramfs 到内存]
v
[内核启动并识别 initramfs]
v
[解压 initramfs 到 rootfs]
v
[执行 initramfs 中的 init]
v
[init 挂载真实根文件系统]
v
[执行 switch_root 切换到真实根]
内核中处理 initramfs 的核心函数在 init/initramfs.c 中：
/* init/initramfs.c - initramfs 解压核心逻辑 */
static int __init unpack_to_rootfs(char* buf, unsigned long len) {
long written;
dry_run = 1;
written = unpack_to_rootfs(buf, len); /* 第一遍：检查完整性 */
if (written != len) {
printk(KERN_WARNING "initramfs unpacking failed");
return -1;
}
dry_run = 0;
written = unpack_to_rootfs(buf, len); /* 第二遍：真正解压 */
if (written != len) {
panic("initramfs unpacking failed");
}
return 0;
}
static int __init unpack_to_rootfs(char* buf, unsigned long len) {
long written = 0;
while (len) {
/* 处理 cpio header */
struct cpio_newc_header *hdr = (void*)buf;
/* 验证魔数 */
if (memcmp(hdr->c_magic, "070701", 6) != 0) {
break; /* 可能是压缩格式，或者归档结束 */
}
/* 解析 header, 提取文件名大小、文件大小等 */
unsigned long namesize = hex2bin(hdr->c_namesize);
unsigned long filesize = hex2bin(hdr->c_filesize);
/* 如果是 TRAILER, 表示 cpio 归档结束 */
if (!strcmp(filename, "TRAILER!!!")) {
break;
}
/* 创建文件或目录 */
if (S_ISDIR(mode)) {
sys_mkdir(filename, mode);
} else if (S_ISLNK(mode)) {
sys_symlink(symlink_target, filename);
} else {
/* 创建普通文件 */
sys_open(filename, O_CREAT | O_WRONLY, mode);
sys_write(fd, file_data, filesize);
sys_close(fd);
}
/* 移动到下一个 cpio 条目 */
buf += header_size + name_size + file_size;
len -= header_size + name_size + file_size;
}
return written;
}
一个典型的 initramfs 包含以下目录结构：
initramfs/
├── bin/ # 必要的二进制工具
│ ├── busybox # 提供 sh, ls, cat, mount 等基础命令
│ └── init # 初始化脚本或二进制
├── sbin/ # 高级管理工具
│ ├── insmod # 加载内核模块
│ ├── modprobe # 高级模块加载
│ └── ...其他工具
├── etc/ # 配置文件
│ ├── modprobe.d/ # 模块配置
│ └── fstab # 文件系统配置
├── lib/ # 库文件和内核模块
│ ├── modules/ # 编译的内核模块
│ └── ld-linux.so # C 库
├── dev/ # 设备文件（由内核自动创建）
├── proc/ # procfs 挂载点
├── sys/ # sysfs 挂载点
├── root/ # 临时 root 用户目录
└── newroot/ # 用于 switch_root 的挂载点
这个结构虽然看起来复杂，但本质上是一个最小的 Linux 根文件系统。initramfs 的大小通常在几 MB 到几十 MB 之间，取决于需要包含的驱动和工具的数量。
当 initramfs 中的 init 程序完成了必要的初始化任务（加载驱动、挂载根文件系统等）后，它需要'切换根'到真实的根文件系统。这是通过 switch_root 命令或系统调用来完成的。
/* 核心思路：switch_root 的实现 */
int switch_root(const char* new_root) {
/* 1. 改变根目录 */
if (chroot(new_root) < 0) {
perror("chroot failed");
return -1;
}
/* 2. 改变当前工作目录到新根的根目录 */
if (chdir("/") < 0) {
perror("chdir failed");
return -1;
}
/* 3. 执行新根中的 init 程序 */
/* 使用 execve 替换当前进程的镜像，这样就不需要启动新进程 */
if (execve("/sbin/init", argv, envp) < 0) {
if (execve("/etc/init", argv, envp) < 0) {
if (execve("/bin/init", argv, envp) < 0) {
execve("/bin/sh", argv, envp);
}
}
}
/* 如果 execve 失败，才会执行到这里 */
return -1;
}
从流程图来看：
在 initramfs 出现之前，系统启动有一个根本性的问题：内核需要访问根文件系统来加载驱动程序，但要访问根文件系统首先需要驱动程序，这形成了一个死循环。早期的解决方案是将根文件系统硬编码到内核中，这样的缺点是内核体积庞大，且灵活性很差。
initramfs 优雅地解决了这个问题。它包含了启动所需的最小驱动集合和初始化工具，使得内核可以：
虽然 initramfs 基本上取代了 initrd，但理解它们之间的设计权衡很有意义。
| 方面 | initrd | initramfs |
|---|---|---|
| 存储格式 | 块设备镜像（ext2/ext3） | cpio 压缩归档 |
| 大小灵活性 | 固定大小 | 更灵活，支持更大的内容 |
| 访问方式 | 块设备驱动 | VFS 直接访问 |
| 自引用问题 | 存在（需要驱动才能访问） | 不存在 |
| 加载速度 | 较慢（需要驱动初始化） | 较快（直接解压） |
| 兼容性 | 某些旧系统 | 现代 Linux 标准 |
现代 Linux 发行版使用不同的工具来生成 initramfs，每种工具有其特点：
| 工具 | 特点 | 使用场景 |
|---|---|---|
| dracut | 功能完整，高度可配置，模块化 | Fedora, RHEL, CentOS 等 |
| mkinitramfs | 脚本式，简洁，易于理解 | Debian, Ubuntu |
| mkinitcpio | 轻量级，专为 Arch Linux 设计 | Arch Linux |
| genkernel | 与 Gentoo 包管理集成 | Gentoo Linux |
每种工具本质上做的事情相同：收集必要的驱动、二进制文件、库和配置，打包成 cpio 格式。但它们的实现策略、模块化程度和配置方式各不相同。
initramfs 的当前实现也有一些局限：
可能的改进方向包括：使用统一固件接口（UEFI）的自定义启动环境、容器技术的应用、以及更智能的模块依赖管理。
让我们从头开始构建一个最小的 initramfs，来深化理解。这个示例使用 busybox 作为基础工具。
第一步：准备目录结构
#!/bin/bash
# 创建 initramfs 工作目录
INITRAMFS_DIR="initramfs"
mkdir -p $INITRAMFS_DIR/{bin,sbin,etc,lib,lib64,dev,proc,sys,root,newroot}
# 复制必要的工具（使用 busybox）
cp /bin/busybox $INITRAMFS_DIR/bin/
# 创建 busybox 的符号链接（模拟各种命令）
cd $INITRAMFS_DIR/bin
for cmd in sh ls cat mount umount mkdir cp rm; do
ln -sf busybox $cmd
done
cd -
# 复制必要的库
cp /lib64/ld-linux-x86-64.so.2 $INITRAMFS_DIR/lib64/
cp /lib64/libc.so.6 $INITRAMFS_DIR/lib64/
cp /lib64/libm.so.6 $INITRAMFS_DIR/lib64/
第二步：创建初始化脚本
#!/bin/sh
# $INITRAMFS_DIR/init - initramfs 的核心启动脚本
# 挂载必要的伪文件系统
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs devtmpfs /dev
# 尝试挂载根文件系统
# 假设根分区是 /dev/sda1
if ! mount -r /dev/sda1 /newroot; then
echo "Failed to mount root filesystem"
# 进入应急 shell /bin/sh
exit 1
fi
# 切换到真实根文件系统
cd /newroot
pivot_root . initramfs # 或使用 switch_root 工具
# 卸载 initramfs（现在位于 /initramfs）
umount -l /initramfs
# 执行真实根中的 init
exec /sbin/init
第三步：打包成 cpio 格式
#!/bin/bash
# 生成 cpio 格式的 initramfs
cd $INITRAMFS_DIR
find . -print0 | cpio -0 -o -H newc -F ../initramfs.cpio
# 压缩
gzip -f ../initramfs.cpio
mv ../initramfs.cpio.gz ../initramfs.img
echo "initramfs 已生成：initramfs.img"
第四步：配置引导加载程序
对于 GRUB 2，编辑 /etc/default/grub：
# /etc/default/grub
GRUB_CMDLINE_LINUX="root=/dev/sda1 ro"
# 其他配置...
然后在 GRUB 菜单项中指定 initramfs：
menuentry 'Linux with Custom Initramfs' {
search --no-floppy --label --set root mylinux
echo 'Loading Linux kernel...'
insmod gzio
insmod part_msdos
insmod ext2
set root='(hd0,msdos1)'
linux16 /boot/vmlinuz-5.x.x root=/dev/sda1 ro
echo 'Loading initial ramdisk...'
initrd16 /boot/initramfs.img
}
第五步：调试和验证
# 1. 查看 initramfs 内容
gunzip -c initramfs.img | cpio -t
# 2. 解压 initramfs 进行检查
mkdir -p extracted
cd extracted
gunzip -c ../initramfs.img | cpio -idmv
ls -la
# 3. 检查库依赖
ldd init
ldd bin/busybox
# 4. 使用 initramfs-tools 的内置验证
lsinitramfs initramfs.img
这个例子虽然简化了很多细节（实际的 initramfs 需要处理多种设备、文件系统等），但展示了 initramfs 的核心工作原理。现代工具如 dracut 本质上就是自动化这些步骤。
| 工具/命令 | 用途 | 示例 |
|---|---|---|
lsinitramfs | 列出 initramfs 内容 | lsinitramfs /boot/initramfs-5.10.0.img |
cpio | 打包/解包 cpio 归档 | cpio -idmv < initramfs.cpio |
dracut | 生成 initramfs | dracut /boot/initramfs-$(uname -r).img |
mkinitramfs | Debian 风格的 initramfs 生成 | mkinitramfs -o /boot/initramfs.img |
gunzip | 解压 gzip 压缩 | gunzip -c initramfs.img.gz |
file | 识别文件格式 | file initramfs.img |
strings | 提取文本字符串 | `strings initramfs.img |
strace | 追踪系统调用 | strace -e trace=open,read init |
grub-mkconfig | 自动生成 GRUB 配置 | grub-mkconfig -o /boot/grub/grub.cfg |
查看 initramfs 解压过程
在内核启动参数中添加 rd.debug，可以看到 initramfs 解压的详细日志：
# /etc/default/grub
GRUB_CMDLINE_LINUX="root=/dev/sda1 rd.debug"
进入 initramfs 调试 shell
如果启动失败，可以进入 initramfs 的调试 shell：
# 在内核参数中添加 rd.break
这会在 initramfs 中间断，打开一个 shell 供调试使用。此时根文件系统还未挂载或切换，可以手动运行命令来诊断问题。
查看 udev 事件
# 在 initramfs 中查看 udev 事件（device enumeration）
udevadm control --log-priority=debug
# 或者查看内核日志
dmesg | grep -i "udev\|device"
下面是 Linux 系统启动中 initramfs 的完整架构：
第一阶段：引导 BIOS/UEFI -> 引导加载程序 (GRUB/LILO)
第二阶段：内核和 initramfs 加载 加载内核镜像 -> 加载 initramfs -> 内核初始化 -> 内核创建 rootfs -> 解压 initramfs 到 rootfs
第三阶段：rootfs 和 initramfs 执行 init 进程 -> 挂载 proc/sys/dev -> 加载驱动模块 -> 检测硬件设备
第四阶段：initramfs init 执行 挂载真实根文件系统 -> 执行 switch_root
第五阶段：真实根和系统初始化 执行真实 init (/sbin/init) -> 加载系统服务 -> 用户登录
initramfs 在这个启动过程中的角色是桥梁：它连接内核的早期初始化和真实根文件系统的引导。关键点包括：
下面是内存中各个组件的布局示意：
内核早期阶段
内核代码 0x1000000+
initramfs 被加载的位置
内核栈
内核堆
rootfs VFS
initramfs 内容解压到 rootfs
/bin 目录
/lib 目录 (模块和库)
/etc 配置文件
运行 init 进程
/newroot (真实根挂载点)
执行 switch_root
当 initramfs 被加载和解压时，内存管理是一个重要的考虑因素。特别是对于有限内存的系统，initramfs 可能会消耗大量的 RAM。让我们深入看看这个方面。
initramfs 在内存中有几个阶段：
/* kernel/init/initramfs.c - 内存计算示意 */
static int __init unpack_to_rootfs(char* buf, unsigned long len) {
unsigned long mem_usage = 0;
/* 第一遍（干运行）: 计算内存占用 */
dry_run = 1;
written = unpack_cpio(buf, len, &mem_usage);
/* 输出内存使用情况 */
printk(KERN_INFO "Initramfs needs %lu bytes of memory\n", mem_usage);
if (written != len) {
return -EINVAL;
}
/* 第二遍（真正解压）: 释放压缩数据 */
free_init_pages("initramfs", (unsigned long)&__initramfs_start, (unsigned long)&__initramfs_end);
return 0;
}
对于内存受限的系统，可以：
# 查看 initramfs 的大小和压缩率
ls -lh /boot/initramfs*
gunzip -l /boot/initramfs-$(uname -r).img
# 使用 xz 压缩（压缩率更高，但速度慢）
dracut --hostonly -f /boot/initramfs-$(uname -r).img
# 或者在 dracut 配置中设置
echo 'COMPRESS="xz"' >> /etc/dracut.conf.d/compress.conf
initramfs 中一个关键的工作是设备检测和驱动加载。现代 Linux 使用 udev 和 hotplug 机制来自动化这个过程。
udev 是用户空间的设备管理器，它从内核接收 uevent（设备事件）并据此创建、删除或配置设备文件。在 initramfs 中，udev 的核心任务是：
#!/bin/sh
# initramfs 中的设备初始化流程
# 启动 udevd daemon
/sbin/udevd --daemon --resolve-names=never
# 触发设备事件重新扫描
udevadm trigger --action=add
# 等待设备规则被应用
udevadm settle --timeout=30
# 现在 /dev 中应该有了必要的设备文件
ls -la /dev/sda*
udev 规则可以根据设备属性自动加载相应的驱动：
# /etc/udev/rules.d/60-module-load.rules
# 当检测到 USB 存储设备时自动加载 usb_storage 模块
ACTION=="add", SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", \nRUN+="/sbin/modprobe usb_storage"
# 当检测到 SATA 驱动器时加载 ata_piix 模块
ACTION=="add", SUBSYSTEM=="ata_port", RUN+="/sbin/modprobe ata_piix"
initramfs 是现代 Linux 启动过程中的关键组件，它优雅地解决了内核自引用的问题，并提供了支持复杂硬件配置和启动场景的灵活性。理解 initramfs 的工作原理对于系统管理员、内核开发者和嵌入式工程师都是至关重要的。
| 技术点 | 关键理解 | 实践意义 |
|---|---|---|
| cpio 格式 | 简单的归档格式，易于内核解析 | 直接使用 cpio 工具可验证和调试 |
| VFS 与 rootfs | 所有文件系统的抽象层，initramfs 初始化 rootfs | 理解文件系统的统一接口 |
| 模块加载 | insmod/modprobe 在 initramfs 中加载驱动 | 驱动加载顺序和依赖关系很重要 |
| 设备检测 | udev 自动化设备文件创建和驱动加载 | 复杂硬件需要配置 udev 规则 |
| switch_root | chroot + execve 的组合，切换到真实根 | 理解进程映像替换的原理 |
| 引导加载程序集成 | bootloader 负责加载内核和 initramfs | 不同引导方案（BIOS vs UEFI）差异大 |
启动失败 → 查看内核日志（dmesg） → 进入 initramfs shell（rd.break） → 手动挂载测试（mount 命令） → 检查驱动是否加载（lsmod） → 检查 udev 事件（udevadm） → 最后确认 init 进程存在
随着技术的发展，initramfs 的实现也在不断演进：
最后，initramfs 虽然在现代 Linux 中是必需的基础设施，但它的复杂性也常常被系统管理员忽视。理解它的工作原理，能帮助我们更好地排查启动问题、优化系统性能，以及在需要时定制专业的 Linux 部署方案。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online