Linux initramfs 原理与实现：从内核启动到根文件系统

这段代码展示了几个关键步骤：首先，unpack_to_rootfs() 函数将内核中编译进来的 initramfs（通过符号 __initramfs_start 和 __initramfs_size 标记）解压到 rootfs 中。然后，内核尝试执行一个 init 程序，这个程序将接管系统的初始化。

initramfs 文件格式：cpio 与压缩

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

initramfs 的加载流程

当 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 包含以下目录结构：

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 之间，取决于需要包含的驱动和工具的数量。

switch_root: 从 initramfs 切换到真实根

当 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;
}

从流程图来看：

1. 内核启动
2. 解压 initramfs，执行 init
3. 加载驱动程序
4. 挂载根文件系统
5. 设置新根目录
6. switch_root，执行真实 init
7. 继续系统初始化

设计思想与架构

为什么需要 initramfs

在 initramfs 出现之前，系统启动有一个根本性的问题：内核需要访问根文件系统来加载驱动程序，但要访问根文件系统首先需要驱动程序，这形成了一个死循环。早期的解决方案是将根文件系统硬编码到内核中，这样的缺点是内核体积庞大，且灵活性很差。

initramfs 优雅地解决了这个问题。它包含了启动所需的最小驱动集合和初始化工具，使得内核可以：

1. 动态加载驱动: initramfs 中的工具（如 insmod、modprobe）可以加载额外的驱动程序，不需要将所有驱动都编译进内核。
2. 支持复杂启动场景: LUKS 加密根分区、LVM 逻辑卷、网络启动（PXE）、USB 启动等复杂场景都可以在 initramfs 中处理。
3. 灵活性和可维护性: 不同的硬件配置可以有不同的 initramfs，而内核保持不变。
4. 最小化内核体积: 不需要的驱动和工具可以从 initramfs 中省略。

initramfs 与 initrd 的权衡

虽然 initramfs 基本上取代了 initrd，但理解它们之间的设计权衡很有意义。

生成工具的对比

现代 Linux 发行版使用不同的工具来生成 initramfs，每种工具有其特点：

每种工具本质上做的事情相同：收集必要的驱动、二进制文件、库和配置，打包成 cpio 格式。但它们的实现策略、模块化程度和配置方式各不相同。

局限性与可能的改进方向

initramfs 的当前实现也有一些局限：

1. 大小成本: 即使是一个'最小'的 initramfs 也通常有几 MB 大小，这对于某些嵌入式或资源受限的设备来说可能很大。
2. 复杂性: initramfs 越复杂，出现问题的可能性就越大。某些引导问题很难调试，因为你无法像调试用户空间程序那样容易地进入 initramfs 环境。
3. 更新维护: initramfs 需要随着内核模块的更新而更新。如果驱动版本与内核版本不兼容，可能导致启动失败。
4. 动态设备发现的局限: 在某些硬件复杂的场景下（如大量网络设备或 RAID），initramfs 的启动等待时间可能很长。

可能的改进方向包括：使用统一固件接口（UEFI）的自定义启动环境、容器技术的应用、以及更智能的模块依赖管理。

实践示例

实例：构建一个最小的 initramfs

让我们从头开始构建一个最小的 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 本质上就是自动化这些步骤。

工具与调试

调试技巧

查看 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 在这个启动过程中的角色是桥梁：它连接内核的早期初始化和真实根文件系统的引导。关键点包括：

1. 独立性: initramfs 是一个完全独立的、自给自足的最小系统。
2. 临时性: initramfs 的使命在 switch_root 后就完成了，其内容被卸载。
3. 灵活性: 不同硬件配置可以有完全不同的 initramfs，但使用相同的内核。
4. 可定制性: 通过 dracut 或 mkinitramfs 的模块系统，可以灵活地添加或删除功能。

下面是内存中各个组件的布局示意：

内核早期阶段
内核代码 0x1000000+
initramfs 被加载的位置
内核栈
内核堆
rootfs VFS
initramfs 内容解压到 rootfs
/bin 目录
/lib 目录 (模块和库)
/etc 配置文件
运行 init 进程
/newroot (真实根挂载点)
执行 switch_root

系统内存管理与优化

当 initramfs 被加载和解压时，内存管理是一个重要的考虑因素。特别是对于有限内存的系统，initramfs 可能会消耗大量的 RAM。让我们深入看看这个方面。

内存使用分析

initramfs 在内存中有几个阶段：

1. 压缩态: initramfs.img（gzip 压缩）被加载到内存。
2. 解压态: 解压后的 cpio 数据存在于内存中。
3. 文件系统态: 文件被解压到 rootfs，形成 VFS 的目录树。

/* 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: 只包含绝对必要的驱动和工具。
• 动态模块加载: 将不常用的驱动放在根文件系统中，需要时才加载。
• 压缩策略: 选择压缩率更高的压缩算法（如 xz、lz4）。

大型 initramfs 的优化

# 查看 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 的角色

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 的工作原理对于系统管理员、内核开发者和嵌入式工程师都是至关重要的。

核心技术要点总结

常见问题排查思路

启动失败 → 查看内核日志（dmesg） → 进入 initramfs shell（rd.break） → 手动挂载测试（mount 命令） → 检查驱动是否加载（lsmod） → 检查 udev 事件（udevadm） → 最后确认 init 进程存在

未来演进方向

随着技术的发展，initramfs 的实现也在不断演进：

• 统一的固件接口（UEFI）: 降低了对不同启动方案的需求。
• 容器化思想: 被应用于 initramfs，使其更易于版本管理。
• 自适应 initramfs: 根据硬件自动定制，减少不必要的内容。
• 快速启动优化: 使用预计算和缓存来加速启动过程。

最后，initramfs 虽然在现代 Linux 中是必需的基础设施，但它的复杂性也常常被系统管理员忽视。理解它的工作原理，能帮助我们更好地排查启动问题、优化系统性能，以及在需要时定制专业的 Linux 部署方案。