前言：从“平坦二进制”到“结构化可执行文件”

在前面的章节中，我们的sys_exec只能加载简单的平坦二进制（flat binary）：把整个文件读入内存，跳转到入口地址。这种方式要求代码、数据、BSS必须按固定顺序紧密排列，没有段保护，不支持符号调试，更无法兼容GCC/Clang的标准输出。现代操作系统与用户程序的契约是ELF（Executable and Linkable Format）。

ELF不是一坨字节流，而是一个自描述的容器：它告诉内核哪些区域是可执行代码、哪些是只读数据、哪些需要零初始化、入口点在哪里、栈如何设置。本章我们将实现一个完整的ELF32加载器，让你的OS首次能够运行标准工具链编译的程序，并为未来的动态链接和用户态调试打下基石。

本章里程碑：

• ✅ 解析ELF Header与Program Header Table
• ✅ 按PT_LOAD段描述符精确映射内存（含权限设置）
• ✅ 正确处理BSS段零填充与页对齐
• ✅ 提取入口点并构建初始用户栈（argc/argv/envp）
• ✅ 重构sys_exec为完整ELF加载流程
• ✅ 验证：运行GCC编译的带多段、BSS、命令行参数的程序

核心概念：ELF的“声明式加载”哲学

ELF不是指令序列，而是“内存布局蓝图”

平坦二进制的加载逻辑是隐式的：“文件内容 = 内存内容”。ELF的加载逻辑是显式的：文件内容与内存内容可以完全不同。一个PT_LOAD段可能：

• 文件中占100字节，内存中占4KB（剩余部分为零填充的BSS）
• 文件偏移0x1000映射到虚拟地址0x08048000
• 标记为RX（可读可执行），而另一个段标记为RW（可读可写）

⚠️关键洞察：ELF加载器的本质是一个内存布局解释器。它不关心文件里存的是什么机器码，只关心“这段数据应该放在哪个虚拟地址、占多大空间、有什么权限”。这种解耦使得同一份ELF可以在不同基址加载（ASLR）、可以按需分页调入（demand paging）、可以共享只读段（shared libraries）。

Program Header vs Section Header

这是初学者最常混淆的概念：

• Program Header (PHDR)：面向运行时。描述加载到内存的段（PT_LOAD, PT_DYNAMIC等）。内核只看这个。
• Section Header (SHDR)：面向链接时/调试时。描述编译产物中的节（.text, .data, .symtab等）。加载器完全忽略它。

你的ELF加载器不应该读取或依赖任何Section Header。一个被strip过的ELF没有SHDR但仍然可以完美运行。如果你的加载代码引用了.text或.bss节名，那就是设计错误。

BSS的特殊性：文件中不存在，内存中必须存在

BSS（Block Started by Symbol）存储未初始化的全局变量。它在ELF文件中不占空间（否则1MB的零数组会让文件膨胀1MB），但加载后必须在内存中占据对应大小的全零区域。这通过PT_LOAD段的p_filesz < p_memsz来表达：

[p_offset ... p_offset+p_filesz) → 从文件拷贝 [p_offset+p_filesz ... p_offset+p_memsz) → memset(0)

忘记零填充BSS是最常见的ELF加载bug，表现为全局变量读到随机垃圾值。

实战代码

ELF32结构体定义

// include/elf.h #define EI_NIDENT 16 #define ET_EXEC 2 #define PT_LOAD 1 #define PF_X 0x1 #define PF_W 0x2 #define PF_R 0x4 typedef struct __attribute__((packed)) { uint8_t e_ident[EI_NIDENT]; uint16_t e_type; // ET_EXEC=2 uint16_t e_machine; // EM_386=3 uint32_t e_version; uint32_t e_entry; // ★ 入口点虚拟地址 uint32_t e_phoff; // Program Header表文件偏移 uint32_t e_shoff; // Section Header表偏移（加载器忽略） uint32_t e_flags; uint16_t e_ehsize; uint16_t e_phentsize; // 单个PHDR大小 uint16_t e_phnum; // ★ PHDR数量 uint16_t e_shentsize; uint16_t e_shnum; uint16_t e_shstrndx; } Elf32_Ehdr; typedef struct __attribute__((packed)) { uint32_t p_type; // PT_LOAD=1 uint32_t p_offset; // 文件偏移 uint32_t p_vaddr; // ★ 目标虚拟地址 uint32_t p_paddr; // 物理地址（忽略） uint32_t p_filesz; // 文件中大小 uint32_t p_memsz; // ★ 内存中大小（>=filesz） uint32_t p_flags; // PF_R/PF_W/PF_X uint32_t p_align; // 对齐要求 } Elf32_Phdr; // 验证ELF魔数与基本兼容性 static inline int elf_check_header(const Elf32_Ehdr *ehdr) { return ehdr->e_ident[0] == 0x7F && ehdr->e_ident[1] == 'E' && ehdr->e_ident[2] == 'L' && ehdr->e_ident[3] == 'F' && ehdr->e_ident[4] == 1 && // 32-bit ehdr->e_ident[5] == 1 && // Little-endian ehdr->e_type == ET_EXEC && ehdr->e_machine == 3; // x86 }

ELF加载核心逻辑

// kernel/exec.c #include "elf.h" #include "memory.h" #include "vfs.h" #include "process.h" // ★ 将单个PT_LOAD段加载到当前进程地址空间 static int load_segment(int fd, const Elf32_Phdr *phdr) { if (phdr->p_memsz == 0) return 0; // 空段跳过 uint32_t vaddr_start = phdr->p_vaddr; uint32_t vaddr_end = phdr->p_vaddr + phdr->p_memsz; // ★ 页对齐：段可能不从页边界开始 uint32_t map_start = PAGE_ALIGN_DOWN(vaddr_start); uint32_t map_end = PAGE_ALIGN_UP(vaddr_end); uint32_t map_size = map_end - map_start; // 分配用户态页面（简化：一次性分配整个段覆盖的页范围） for (uint32_t va = map_start; va < map_end; va += PAGE_SIZE) { if (!map_user_page(va, PTE_USER | PTE_PRESENT | ((phdr->p_flags & PF_W) ? PTE_WRITE : 0))) { return -1; // ENOMEM } } // ★ 先清零整个映射区域（确保BSS和页内padding为零） memset((void *)map_start, 0, map_size); // ★ 从文件拷贝有效内容 if (phdr->p_filesz > 0) { vfs_lseek(fd, phdr->p_offset, SEEK_SET); ssize_t n = vfs_read(fd, (void *)vaddr_start, phdr->p_filesz); if (n != (ssize_t)phdr->p_filesz) return -1; } // p_filesz之后的区域已由memset清零 → BSS自动满足 return 0; } // ★ 完整ELF加载入口 int elf_load(const char *path, uint32_t *out_entry) { int fd = vfs_open(path, O_RDONLY); if (fd < 0) return -1; // 1. 读取并验证ELF Header Elf32_Ehdr ehdr; if (vfs_read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr) || !elf_check_header(&ehdr)) { vfs_close(fd); return -1; } // 2. 读取Program Header Table uint32_t phdr_total = ehdr.e_phnum * ehdr.e_phentsize; Elf32_Phdr *phdrs = kmalloc(phdr_total); if (!phdrs) { vfs_close(fd); return -1; } vfs_lseek(fd, ehdr.e_phoff, SEEK_SET); if (vfs_read(fd, phdrs, phdr_total) != (ssize_t)phdr_total) { kfree(phdrs); vfs_close(fd); return -1; } // 3. ★ 释放旧地址空间，加载所有PT_LOAD段 process_destroy_address_space(current_process); for (uint16_t i = 0; i < ehdr.e_phnum; i++) { if (phdrs[i].p_type == PT_LOAD) { if (load_segment(fd, &phdrs[i]) < 0) { kprintf("[ELF] Failed to load segment %d\n", i); kfree(phdrs); vfs_close(fd); return -1; } } } kfree(phdrs); vfs_close(fd); *out_entry = ehdr.e_entry; return 0; }

用户栈构建与sys_exec重构

// kernel/exec.c - 栈初始化 // ★ 按照System V i386 ABI构建初始栈 // 高地址 ┌─────────────┐ // │ env strings │ // │ argv strings│ // │ padding │ // │ envp[n]=NULL│ // │ ... │ // │ envp[0] │ // │ argv[argc]=NULL│ // │ ... │ // │ argv[0] │ // │ argc │ ← ESP // 低地址 └─────────────┘ static uint32_t setup_user_stack(int argc, char **argv, char **envp) { uint32_t sp = USER_STACK_TOP; // 例如 0xBFFFF000 // 1. 拷贝字符串到栈顶下方（从高到低） // 简化：假设总字符串长度<4KB char *str_area = (char *)(sp - 4096); uint32_t str_offset = 0; uint32_t argv_ptrs[64], envp_ptrs[64]; for (int i = 0; i < argc && argv[i]; i++) { int len = strlen(argv[i]) + 1; memcpy(str_area + str_offset, argv[i], len); argv_ptrs[i] = (uint32_t)(str_area + str_offset); str_offset += len; } argv_ptrs[argc] = 0; // NULL terminator int envc = 0; if (envp) { while (envp[envc]) { int len = strlen(envp[envc]) + 1; memcpy(str_area + str_offset, envp[envc], len); envp_ptrs[envc] = (uint32_t)(str_area + str_offset); str_offset += len; envc++; } } envp_ptrs[envc] = 0; // 2. 压入指针数组和argc（向低地址增长） uint32_t *stack = (uint32_t *)((uint32_t)str_area & ~0xF); // 16字节对齐 stack -= (envc + 1); // envp pointers + NULL memcpy(stack, envp_ptrs, (envc + 1) * sizeof(uint32_t)); uint32_t *envp_base = stack; stack -= (argc + 1); // argv pointers + NULL memcpy(stack, argv_ptrs, (argc + 1) * sizeof(uint32_t)); uint32_t *argv_base = stack; stack -= 3; // envp, argv, argc stack[0] = argc; stack[1] = (uint32_t)argv_base; stack[2] = (uint32_t)envp_base; return (uint32_t)stack; } // ★ 重构后的sys_exec int sys_exec(interrupt_frame_t *frame) { const char *path = (const char *)frame->ebx; char **argv = (char **)frame->ecx; char **envp = (char **)frame->edx; // 计算argc int argc = 0; if (argv) while (argv[argc]) argc++; uint32_t entry; if (elf_load(path, &entry) < 0) return -1; uint32_t new_sp = setup_user_stack(argc, argv, envp); // ★ 修改trap frame：iret后跳转到ELF入口点 frame->eip = entry; frame->esp = new_sp; frame->cs = USER_CS | 3; frame->ss = USER_DS | 3; frame->eflags = 0x202; // IF enabled return 0; // 实际不会返回 }

关键细节解析

1. 为什么必须先清零再拷贝，而非只拷贝filesz部分？

因为p_vaddr不一定页对齐。如果段的vaddr=0x08048120、filesz=0x80，而你只分配了0x08048000开始的页并拷贝0x80字节，那么0x08048000~0x0804811F之间的120字节是上一段残留或随机内存。先memset整个页对齐范围为零，再拷贝有效内容，保证了：①段前padding为零；②BSS为零；③段后padding为零。这是安全性的基本要求，也是很多自制OS出现诡异crash的根源。

2. 为什么加载器要销毁旧地址空间？

exec的语义是“用新程序完全替换当前进程”。如果保留旧映射，新程序的段可能与旧段重叠，导致数据污染或权限提升漏洞。正确的exec必须是原子的：要么完全成功（旧空间已销毁、新空间已建立），要么完全失败（旧空间不变）。本章简化为非原子实现，生产级内核会在临时空间中加载成功后才切换页表。

3. 为什么栈要16字节对齐且参数以特定顺序排列？

这是System V i386 ABI的硬性规定。GCC生成的代码假设ESP在函数入口处满足(ESP+4) % 16 == 0，SSE指令（movaps等）要求16字节对齐操作数。argc/argv/envp的布局是C运行时启动代码（crt0）解析的唯一格式。偏离ABI意味着你的OS只能运行自己手写的汇编程序，无法兼容任何标准编译器输出。

调试Checklist：ELF加载器排查

🔧黄金法则：ELF调试的终极武器是宿主机的readelf/objdump。对你的测试程序执行

readelf -l prog # 查看Program Header：vaddr, filesz, memsz, flags readelf -S prog # 查看Section Header（仅用于理解，加载器不用） objdump -d prog # 反汇编确认入口点代码 hexdump -C prog | head # 验证文件头部原始字节

永远不要凭感觉猜测ELF内部结构。当你的加载器行为异常时，先用readelf确认文件的真实布局，再对照你的代码逐步验证。推荐创建一个极简测试程序（int main(){return 42;}，静态链接，strip），排除libc和动态链接的干扰。

本章小结与下一步

今天我们完成了操作系统与用户程序之间最重要的桥梁：

• ✅ 实现了完整的ELF32解析与PT_LOAD段加载
• ✅ 正确处理了BSS零填充、页对齐、权限映射
• ✅ 按System V ABI构建了初始用户栈
• ✅ sys_exec现在能够运行GCC编译的标准ELF可执行文件

从此，你的操作系统拥有了与现代工具链对话的能力。当你第一次用gcc -static -nostdlib hello.c -o hello编译出ELF，然后在自制Shell中执行它看到输出时，你见证的是OS与编译器之间数十年协同演化的协议在你的手中重现。

下一章预告：《用户态C运行时：从裸ELF到printf》

当前的用户程序只能用内联汇编syscall。下一章将实现mini libc：封装syscall为C函数、提供malloc/free、实现printf格式化输出，让你能用纯C编写功能完整的用户程序，彻底告别内联汇编时代。

参考资料

• System V Application Binary Interface (i386): https://refspecs.linuxfoundation.org/elf/abi386-4.pdf
• ELF Specification: System V Application Binary Interface - DRAFT
• Linux Kernel:fs/binfmt_elf.c
• xv6 Source:kernel/exec.c
• 本系列完整代码：[你的GitHub仓库链接]（Commit:e1l2f3l）

📝作者注：这是《从零手写操作系统》系列的第20篇。ELF加载器是整个教程中规范依赖性最强的章节。你的代码是否正确，不取决于逻辑是否优美，而取决于是否精确符合ABI文档的每一个字节。建议先加载一个只有单个PT_LOAD段的极简ELF，确认基本流程跑通后再处理多段、BSS和对齐边界情况。ELF的正确性是用readelf逐字段验证出来的，不是用试错猜出来的。下一章，我们让用户程序真正“像C程序一样编程”！