Hook:你写了一句 printf("hello"),双击就能跑起来。可 CPU 只认 0 和 1,磁盘上那个 hello 文件里到底装了什么?Linux 凭什么知道该从哪个字节开始执行?
Why:如果每个编译器、每个平台都自己定一套文件摆法,链接器、加载器就得为每种格式写一套解析代码。ELF 把这个约定固化成一个标准:只要文件符合 ELF,Linux 的链接器和加载器就能处理,与它是 gcc 编的还是 clang 编的无关。这也是「二进制兼容」的前提。
What:目标文件指编译器生成的文件,「目标」指的是文件对应的处理器平台(x86、x86-64、ARM)。不同架构 CPU 的机器指令集不同,所以目标文件也叫 ABI(Application Binary Interface,应用程序二进制接口)。所谓二进制兼容,就是指该目标文件已经是适配某一种 CPU 体系结构的二进制指令——一个 x86-64 的目标文件无法链接成 ARM 上的可执行文件,我们说它与 ARM 平台不二进制兼容。
How:历史脉络记一条线:a.out(最早)--> COFF --> 如今 Windows 用 PE、Linux 用 ELF。ELF 内部的组织方式是分层的:ELF 首部(ELF Header)描绘整个文件的组织结构,文件主体是大量节(section)——节是 ELF 文件里用以装载内容数据的最小容器。节有的由系统定义,有的用户可用 .section 命令自定义;链接器会把多个输入目标文件中同名的节合并。
| 格式 | 出现顺序 | 典型平台 |
|---|---|---|
| a.out | 最早 | 早期 Unix |
| COFF | 其后 | Unix / Windows 过渡 |
| PE | 现在 | Windows |
| ELF | 现在 | Linux(本课程重点) |
易错:「节(section)」和「段(segment)」不是一回事。节是链接视图(给链接器看),段是执行视图(给加载器看)。后面 6.5 会展开这个区别,别在判断题里混用。
必考
Hook:同一个 hello.c,用 gcc -c 得到 hello.o,直接链接得到 hello,还有 libc.so——这三个文件都是 ELF,为什么一个不能直接跑,另一个能跑?
Why:程序不是一步到位的。编译一个 .c 只产生一个 .o,多个 .o 才能拼成可执行文件;而库要被多个程序复用,就得单独存在。三种类型正好对应「中间态 / 终态 / 可复用件」三种角色。
What:
| 类型 | 后缀 | 能否直接运行 | 关键特征 |
|---|---|---|---|
| 可重定位目标文件 | .o / .a(静态库) | 否,需链接 | 不含绝对地址,用相对地址和符号引用;含 .text/.data/.bss/符号表/重定位表/节头表 |
| 可执行文件 | 无固定后缀 | 是 | 由多个 .o 结合而成,完成所有重定位与符号解析(动态库符号运行时才解析) |
| 动态链接库(共享目标文件) | .so | 否,被加载 | 已经过链接处理可直接加载运行,如 libc.so,位于 /usr/lib |
How:可重定位文件为什么不叫「绝对地址文件」?因为它不包含绝对地址,用相对地址和符号引用来表示代码段与数据段之间的关系——这使得它可以在不同的内存位置加载执行,这正是「可重定位」名字的由来。编译 Linux 内核时,每个 .c 生成一个同名 .o(gcc -c 源文件.c -o 目标文件.o),所有 .o 最终链接成一个文件,即内核。静态链接库就是把多个可重定位文件用 ar 打包形成的 .a。
可重定位目标文件的五大组成:代码段 .text(存放机器指令,最核心)、数据段 .data/.bss(.data 放已初始化全局/静态变量,.bss 放未初始化)、符号表 .symtab(记录定义和引用的符号,含函数名、变量名及相对地址,供链接器解析)、重定位表 .rela.text/.rela.data(记录链接时需调整的地址)、节头表 Section Header Table(描述每个节的类型、大小、文件偏移等元数据)。
易错:静态库 .a 不是「可执行文件」,它本质是「一堆 .o 打包」,仍属可重定位类型。另一个坑:可执行文件的符号解析并非全部完成——动态链接库的符号是在运行时才解析的。
必考
Hook:拿到一个 hello 可执行文件,你想知道它多大、入口在哪、有几个节——可你面对的是满屏二进制。哪里写着这些元信息?
Why:加载器和链接器不能靠猜。它们必须先读固定位置的头部,才知道「节头表在文件第几字节、有多少项、每项多大」,然后才能按图索骥找到各个节。头部就是这张地图的图例。
What:ELF Header(Elf32_Ehdr)的关键字段,定义在 /usr/include/elf.h:
| 字段 | 含义 |
|---|---|
e_ident[16] | Magic number 与其他标识(开头 7F 45 4C 46 即 \x7fELF) |
e_type | 目标文件类型(可重定位/可执行/共享) |
e_machine | 体系结构(x86/ARM 等) |
e_version | 文件版本 |
e_entry | 入口点虚拟地址(程序从哪开始执行) |
e_phoff | 程序头表在文件中的偏移 |
e_shoff | 节头表在文件中的偏移 |
e_flags | 处理器相关标志 |
e_ehsize | ELF 头大小(字节) |
e_phentsize / e_phnum | 程序头表每项大小 / 项数 |
e_shentsize / e_shnum | 节头表每项大小 / 项数 |
e_shstrndx | 节头字符串表索引 |
How:把 ELF Header 想成图书馆的「总目录页」:它不告诉你每本书的内容,只告诉你「分类目录在第几页、有多少条记录」。真正逐节描述的是 Section Header Table——每一项说明某个节的类型、大小、文件偏移。所以读 ELF 的顺序永远是:先 readelf -h 看头,再 readelf -S 看节头表。用 gcc -o hello hello.c -static 编静态版本,64 位机器上要编 32 位代码就加 -m32。
易错:e_entry 是入口点「虚拟地址」,不是文件偏移。别把 e_phoff/e_shoff(文件偏移)和 e_entry(虚拟地址)搞混——选择题常在这里设陷阱。
必考
Hook:老师让你「看看 hello 里有哪些节」,你打开文件只看到乱码。难道要手写一个解析器?
Why:这些工具就是把 6.3 那张表里的字段翻译成人话。你不必背字段偏移,只要知道「我想看什么,就用哪个开关」。
What & How:
| 命令 | 作用 |
|---|---|
man elf | 查看 ELF 格式的详细定义 |
readelf -a | 等价于所有选项全选 |
readelf -h | 显示 ELF 文件头信息 |
readelf -S | 显示节头信息(Section Headers) |
readelf -l | 显示 Program Header(程序头/段表) |
readelf -s | 显示符号表段中的项 |
readelf -r | 显示可重定位段的信息 |
readelf -H | 显示 readelf 支持的命令行选项 |
objdump -f | 显示文件整体头部摘要 |
objdump -h | 显示各 section 头部摘要 |
objdump -r | 显示重定位入口(配 -d/-D 则以反汇编格式显示) |
objdump -s | 显示指定 section 的完整内容 |
objdump -t | 显示符号表入口(类似 nm -s) |
objdump -x | 显示所有可用头信息,等价于 -a -f -h -r -t |
hexdump | 用十六进制数字显示 ELF 内容 |
实战范例——readelf -S hello.m32.static 的输出读法:
There are 31 section headers, starting at offset 0xb168c:
[Nr] Name Type Addr Off Size Flg Lk Inf
[ 6] .text PROGBITS 080482d0 0002d0 0733d4 AX 0 0
[24] .data PROGBITS 080eb060 0a2060 000f20 WA 0 0
[25] .bss NOBITS 080ebf80 0a2f80
[28] .symtab SYMTAB 00000000 0a2fa8 007bf0 29 846
[29] .strtab STRTAB 00000000 0aab98 00699a 0 0
[30] .shstrtab STRTAB 00000000 0b1532 000159 0 0
逐列读:Nr 节序号;Name 节名;Type 节类型(PROGBITS 表示含实际数据、NOBITS 表示不占文件空间、SYMTAB/STRTAB 是符号表/字符串表);Addr 加载后的虚拟地址;Off 在文件中的偏移;Size 大小;Flg 权限标志(W 可写、A 分配内存、X 可执行);Lk/Inf 链接信息(如 .symtab 的 Lk=29 指向 .strtab,Inf=846 表示第一个非局部符号索引)。
易错:.bss 是 NOBITS 类型,它在文件里不占空间——所以你在 Off 列看到偏移却看不到对应的 Size 数据。很多同学以为「文件里没数据就是解析错了」,其实这正是设计。
必考
Hook:链接器眼里 hello 是 30 多个节,可操作系统把它装进内存时只分了 6 块。中间发生了什么?
Why:节是按「内容类型」切的(代码、数据、符号),切得细便于链接;但内存映射是按「权限」整块映射的(可读可执行一块、可读写一块),整块映射才高效。所以需要另一套视图:段。段 = 连续的几个节打包。
What:程序头表由一个或多个程序头组成,每个程序头描述一个段的信息,所以程序头表也叫段头表。每个段描述一段硬盘数据和对应的内存数据。段与创建进程相关——它描述连续几个节在文件中的位置、大小,以及被放进内存后的位置和大小,告诉系统如何创建进程映像,加载器就按这个说明把可执行文件搬到内存中。用来构造进程映像的目标文件(即可执行文件)必须具有段头表。
How:32 位系统下的 Program Header 结构:
| 字段 | 含义 |
|---|---|
p_type | 段的类型(LOAD 需加载、NOTE、TLS、GNU_STACK、GNU_RELRO 等) |
p_offset | 段在文件中的偏移 |
p_vaddr | 段在内存中的虚拟地址 |
p_paddr | 物理地址(在物理内存定位相关的系统中保留) |
p_filesz | 段在文件中的长度 |
p_memsz | 段在内存中的长度 |
p_flags | 段相关标志(R/W/E) |
p_align | 段在内存中的对齐方式 |
范例 readelf -l hello.m32.static 第一行怎么读:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
LOAD 0x000000 0x08048000 0x08048000 0xa165f 0xa165f RE 0x1000
TYPE=LOAD 表示该段需要加载到内存;Offset 全 0 表示其内容从可执行文件头开始;共 0xa165f(FileSiz)个字节;加载到虚拟地址 0x08048000(VirtAddr)处;权限为可读(R)可执行(E);按 4K(Align 0x1000)对齐。整个程序有 6 个这样的段。下面的 Section to Segment mapping 说明段 00 包含了 .note、.ABI-tag、.init、.text 等多个节——这就是「段由节打包」的直接证据。
易错:可重定位文件(.o)没有程序头表。如果你对 hello.o 执行 readelf -l 看到「There are no program headers」,不是文件坏了,而是设计如此。判断题常考这一点。
必考
Hook:gcc hello.c -o hello 一条命令就完事了。可这背后 gcc 到底替你做了几件事?如果链接报错「undefined reference」,是四个步骤里的哪一步出了问题?
Why:一步做完当然也行,但拆开每步都能单独停下来检查:预处理看宏展开对不对,编译看汇编有没有问题,汇编看机器码,链接看符号能不能对上。报错定位靠的就是这个分界。
How:四步对应的完整命令与产物:
# 预处理
gcc -E hello.c -o hello.i
# 编译
gcc -S hello.i -o hello.s
# 汇编
gcc -c hello.s -o hello.o
# 链接,-static 为静态链接
gcc hello.o -o hello -static
| 步骤 | 命令 | 产物 | 做了什么 |
|---|---|---|---|
| 预处理 | gcc -E | .i | 删除所有注释;删除所有 #define 并展开宏;处理 #include 把被包含文件插入指令位置;添加行号和文件名标识 |
| 编译 | gcc -S | .s | 检查代码规范性与正确性,确定代码实际要做的工作;把代码翻译成汇编语言。-S 表示只编译不汇编;-m32 表示生成 32 位平台格式文件(与 64 位使用不同寄存器名和指令集) |
| 汇编 | gcc -c | .o | 把汇编翻译成机器指令,生成 .o 文件——此时已经是 ELF 格式 |
| 链接 | gcc hello.o -o hello -static | 可执行文件 | 把 .o 与库文件拼接,完成符号解析与重定位 |
动手观察点:用 gcc -E hello.c -o hello.i 之后对比 hello.c 与 hello.i,你会看到 hello.i 比原文件长了几百倍——因为 #include <stdio.h> 把整个头文件都插了进来,所有宏也已展开成具体值。这是理解「预处理只是文本替换」最直观的证据。
易错:-S是大写(Stop at assembly),-s是小写(strip 符号表);-E是大写。-m32不是「编译 32 位程序」的全部——它改变的是目标平台格式(寄存器名、指令集、ABI),在 64 位机器上编 32 位程序必须显式加它。
必考
Hook:你的 C 程序里有一个 int a;、一个 int b = 5;、还有一堆函数。它们在 .o 文件里被放进了三个不同的节。凭什么 a 和 b 要分开放?
Why:分节的根因是「权限不同、初始化方式不同」。代码只读(防篡改、可共享),已初始化数据必须真的写进文件(否则初值丢了),未初始化数据初值恒为 0——既然恒为 0,就没必要在文件里存一堆 0,只记「需要多大空间」即可。这就是 .bss 不占文件空间的原因,也是可执行文件能比想象中小得多的原因。
What:
| 节 | 中文名 | 存放内容 | 内存分配 | 文件占空间 | 权限 |
|---|---|---|---|---|---|
| .text | 代码段 | 程序执行的机器指令(也可能含只读常量,如字符串常量) | 大小运行前已确定 | 是 | 通常只读(某些架构允许可写) |
| .data | 数据段 | 已初始化的全局变量、静态变量、常量 | 静态内存分配 | 是 | 可读写 |
| .bss | BSS 段 | 未初始化的全局变量(Block Started by Symbol) | 静态内存分配 | 否(SHT_NOBITS) | 可读写 |
How:记法:.bss 的 section type 是 SHT_NOBITS——名字里就写着 NO BITS(没有比特/没有数据)。程序开始运行时,系统用 0 初始化该区域。所以 int a; 全局变量在文件里只留下「有个叫 a 的东西,占 4 字节」的记录,实际 4 个零字节不写进文件。对照 6.4 里 readelf -S 的输出:[25] .bss 那行 Size 列是空的,正是这个原因。
易错:ELF 格式里 Section 与 Segment 是不同的概念——PPT 里为兼顾传统名称也把 .text/.data/.bss 叫作「段」,但严格说它们是「节(Section)」。判断题若问「.text 是段还是节」,在 ELF 语境下标准答案是「节」。
必考
Hook:把 hello.o 和 hello 两个文件都 readelf -S 一下,你会发现节的数量从 13 个变成 28 个,而且 .text 的 Addr 列从 0 变成了具体地址。链接器到底动了什么手脚?
Why:.o 文件是各自独立编译的,谁也不知道别人在哪个地址,所以地址列全是 0(相对地址)。只有链接器能看到全部 .o 和库,才能统一排布地址、把同名的节合并成一个大节。没有这一步,CPU 跳转时根本不知道该跳到哪。
What:链接是将各种代码和数据部分收集起来并组合成为一个单一文件的过程,这个文件可被加载(或被复制)到内存中并执行。本例中就是把编译输出的 .o 与 libc 库文件链接,生成最终可执行文件:
gcc hello.o.m32 -o hello.m32.static -m32 -static
readelf -S hello.m32.static
通俗地说,链接就是把多个文件拼接到一起,本质上是节的拼接。
How:链接前后两个关键变化(考试重点):
| 观察项 | 链接前(hello.o) | 链接后(hello) | 为什么变 |
|---|---|---|---|
| 节的个数 | 13 个 | 28 个 | 多出来的节是从外部库添加过来的,编译器进行了整合 |
| .text 的 Addr | 0(无绝对地址) | 有具体值(如 0x080482d0) | 链接器安排了地址布局 |
| 程序(段)头表 | 无 | 有 | 可执行文件的加载执行,靠操作系统按程序头的指示把文件按布局加载到内存,再跳转到代码段 |
验证方法:在命令行分别敲 readelf -l hello.o 和 readelf -l hello 对比输出——前者会说没有程序头,后者会列出 LOAD 等段。这一步是理解「节是链接视图、段是执行视图」的最佳实验。
易错:节变多不等于「程序变复杂了」。多出的节全部来自被链接进来的库(如 .init、.plt、.fini、.rodata)。另一个坑:.text 有了地址不等于「绝对地址写死在文件里」——动态链接程序里库函数的地址仍是运行时才定的。
重点
Hook:hello.c 里你调用了 printf,可 printf 的实现根本不在你的代码里。链接器凭什么知道该去哪个库、找哪个函数?
Why:编译是分文件进行的,编译器编 hello.c 时完全不知道 printf 在哪。它只能把这个「欠账」记在符号表里(无定义),留给链接器去还。这就是「符号解析」存在的原因。
What:符号包含全局变量和全局函数,例如 printf 就是一个符号。符号表(symbol table)是一种供编译器和解释器使用的数据结构,用于保存源程序中每个标识符及其相关信息,如数据类型、作用域和内存地址;这些信息在编译器分析阶段被逐步收集,用于生成目标代码。
以 hello.c 为例:它只有两个符号——main 和 printf。main 的实现就在 hello.c 中,printf 的实现显然不在。所以 hello.o 里 main 是「有定义」的,printf 是「无定义」的。「有定义」的意思是:函数对应的机器指令地址在当前文件中(有明确的地址)。
How:符号解析的完整链路:
| 阶段 | 发生什么 |
|---|---|
| 编译 hello.c | main 记录为「有定义」;printf 记录为「无定义」,存入符号表 |
| 链接时找定义 | 编译器到其他共享库中找到 printf 的「定义(机器指令片段)」 |
| 拼接 | 把该片段机器指令与 hello.o 拼到一起(静态链接),生成 hello |
| 结果 | hello 中 printf 就存在了——有定义即有明确地址。这就是符号解析 |
| 随后重定位 | 确定各函数加载到内存的地址,反过来修改所有调用该函数的机器指令,使其跳转到正确地址 |
查看方法:objdump -t hello.o 或 readelf -s hello.o。符号表的功能是找未知函数在其他库文件中的代码段的具体位置——它就是那张「欠账清单」。
易错:符号表记录的是「有哪些符号、地址是多少」;重定位表记录的是「哪些代码位置需要改」。两者不是一回事——6.10 会讲。另一个常见误解:局部变量不是符号(符号只含全局变量和全局函数)。
必考
Hook:符号解析已经把 printf 的代码拼进来了,可程序还是跑不起来——因为 printf 的代码被放在了某个地址,而 hello.o 里那几条 call 指令还指向「0 号地址」。谁来改这些指令?
Why:符号解析解决了「东西在哪」,重定位解决「怎么指过去」。不改指令里的地址,CPU 一 call 就跳到错误位置,程序直接崩。这两步合起来才构成完整的链接。
What:重定位的两大动作:
| 步骤 | 做什么 |
|---|---|
| ① 重定位节和符号定义 | 链接器将所有相同类型的节合并为同一类型的新的聚合节;将运行时存储器地址赋给新的聚合节、输入模块定义的每个节、以及输入模块定义的每个符号。此时程序中的每个指令和全局变量都有唯一的运行时存储器地址 |
| ② 重定位节中的符号引用 | 链接器修改代码节和数据节中对每个符号的引用,使它们指向正确的运行时地址 |
How:重定位表中的每一条记录都对应一个需要重定位的符号。汇编器会为可重定位文件中每个「包含需要重定位符号的段」都建立一个重定位表。查看方法:readelf -r hello.o。
把两张表的分工记牢:符号表记录了目标文件中所有的全局函数及其地址;重定位表中记录了所有调用这些函数的代码位置。链接时这两大类数据都需要逐一修改为正确的值——符号表负责「定义在哪」,重定位表负责「引用在哪」。
易错:重定位不是「移动数据」。它改的是指令和数据里对地址的引用值,文件布局由链接器在合并节时一次排定。另一个坑:readelf -r看的是重定位表,readelf -s看的是符号表,两个开关别记反。
必考
Hook:同样一个 hello,静态链接版本 727908 字节,动态链接版本只有 7452 字节——差了将近 100 倍。多出来的 70 万字节是什么?
Why:如果每个程序都静态链接 libc,磁盘上就有几百份 printf 的副本,内存里也各存一份,纯属浪费。动态链接让同一段代码被所有程序共享。代价是运行时要多做一步「找库、加载、解析符号」,而且库升级可能不兼容。
What:
| 对比项 | 静态链接 | 动态链接 |
|---|---|---|
| 链接时机 | 编译链接时 | 程序运行或加载时 |
| 代码位置 | 直接复制到最终可执行文件中 | 不复制,只记录符号和参数,运行时传给操作系统 |
| 体积 | 较大(本例约 727KB) | 较小(本例 7452B) |
| 装载/执行速度 | 装载速度快,执行速度也比较快 | 运行时加载,可能影响程序前期执行性能 |
| 外部依赖 | 对外部环境依赖度低 | 对使用的库依赖性较高,升级时特别容易出现版本不兼容 |
| 内存占用 | 多个程序使用同一库函数会被装载多次,浪费内存 | 多个程序可以共享同一段代码,不需在内存/磁盘存多个副本 |
| 编译选项 | -static | 不加 -static 即为默认 |
How:动态链接又分两种,这是本节最容易考混的地方:
| 类型 | 机制 | 关键代码/命令 |
|---|---|---|
| 装载时动态链接 | 编译时就要提供库路径和头文件,程序启动装载时即完成链接,之后可像调用 printf 一样直接调用 | gcc -shared shlibexample.c -o libshlibexample.so |
| 运行时动态链接 | 编译时完全不需要库的信息,程序运行到相关语句时才 dlopen 加载、dlsym 找函数 | dlopen("libdllibexample.so", RTLD_NOW) --> dlsym(handle,"DynamicalLoadingLibApi") --> func() --> dlclose(handle) |
完整编译与运行范例(PPT 实验):
$ gcc main.c -o main -L/path/to/your/dir -lshlibexample -ldl
$ export LD_LIBRARY_PATH=$PWD
$ ./main
This is a Main program!
Calling SharedLibApi() function of libshlibexample.so!
This is a shared libary!
Calling DynamicalLoadingLibApi() function of libdllibexample.so!
This is a Dynamical Loading libary!
参数含义逐条:-L 指明库所在目录;-l 指明库文件名(写 libshlibexample.so 去掉 lib 前缀和 .so 后缀的部分,即 shlibexample);-ldl 指明需要使用 dlopen 等共享库函数。运行时必须确保 libdllibexample.so 能被找到,所以要 export LD_LIBRARY_PATH=$PWD(或把库复制到默认路径下),否则 main 找不到依赖的库文件。
静态库的查看方法:静态库是一组目标文件的集合。用 find /usr -name *.a 找到静态库,再用 ar -t /path/to/your/XX.a 就能看到该库由哪些 .o 打包而成。
易错:① 不加-static就是动态链接,这是默认行为,不要以为要显式加「动态」开关。②-l后面写的名字要去掉 lib 和 .so,写-llibshlibexample是错的。③ 装载时动态链接 vs 运行时动态链接的分界是「编译时是否需要库信息」,不是「是否需要 .so 文件」——两者运行时都需要 .so。
必考
Hook:你在 Shell 里敲下 ls -l /usr/bin 回车,ls 这个程序就变成了一个进程开始跑。可 Shell 自己也是个进程——它是怎么「变成」ls 的?还是说它生了个新的?
Why:为什么必须 fork + execve 两步,不能直接 execve?因为 execve 是「覆盖当前进程」——如果 Shell 直接 execve 成 ls,ls 跑完 Shell 就没了,你就再也回不到命令行。所以必须先 fork 出一个副本,让副本去 execve 送死,Shell 自己 wait 等它结束。
What:先看参数怎么传进来。execve 系统调用接口函数原型:
int execve(const char *filename, char *const argv[], char *const envp[]);
filename 为可执行文件的名字;argv 是以 NULL 结尾的命令行参数数组;envp 同样是以 NULL 结尾的环境变量数组。exec 系列库函数(execl、execlp、execle、execv、execvp、execve 共 6 个)都是 execve 系统调用接口函数的封装接口,差异只在于对命令行参数和环境变量参数的传递方式不同。
main 函数的三种写法决定了它能接收什么:
| 写法 | 能接收 |
|---|---|
int main() | 不接收参数(最常见之一) |
int main(int argc, char *argv[]) | 接收命令行参数(最常见之一) |
int main(int argc, char *argv[], char *envp[]) | 额外接收 Shell 的执行环境 |
敲 ls -l /usr/bin 时,-l 与 /usr/bin 是两个参数,会通过 int argc 和 char *argv[] 传进来。Shell 本身不限制命令行参数个数,参数个数受限于命令自身——也就是 main 函数愿意接收什么。
How:完整流程分四层理解。
第 1 层 · Shell 做的事:fork 一个子进程,pid 为 0 的分支是将来子进程要执行的,在子进程里调用 execlp 加载可执行程序。
pid = fork();
if (pid < 0) { fprintf(stderr, "Fork Failed!"); exit(-1); }
else if (pid == 0) {
/* child process */
execlp("/bin/ls", "ls", NULL);
} else {
/* parent process: wait for child */
wait(NULL);
printf("Child Complete!");
exit(0);
}
第 2 层 · 堆栈怎么重建:fork 时子进程的 PCB 复制父进程 PCB 的大部分内容(含 PCB 和堆栈)。子进程通过 execlp 加载可执行程序时,按图示结构重新布局用户态堆栈,再将程序跳转到 main 函数。用户态堆栈的栈顶就是 main 函数调用堆栈框架——这就是 main 函数起点的执行环境。
第 3 层 · 内核里做了什么:构建新用户态堆栈时,会把命令行参数和环境变量通过指针传到系统调用内核处理函数;创建新的用户态堆栈时把 char *argv[] 和 char *envp[] 等复制到用户态堆栈中,来初始化新程序的执行上下文环境。execve 加载完新的可执行程序之后,覆盖了原来父进程的上下文环境——内核帮我们重新布局了新的用户态执行环境。
静态链接程序的装载细节:用 readelf -h 查到入口点 Entry point address: 0x804887f。如果是静态链接程序,execve 加载完成后,堆栈上的返回地址会修改为程序入口点的地址;系统调用从内核态返回时,就从 0x804887f 继续执行。
第 4 层 · 动态链接程序多一步:动态链接的程序从内核态返回时首先执行 .interp 节区指向的动态链接器。用 readelf -l/-S 可观察到动态链接的可执行文件比静态链接多出 .interp 节和其他 ld 需要的节,段表也有相应的 INTERP 段。readelf -p .interp 查看节内容,能看到存储的是动态链接器的完整路径。动态链接库还可能依赖其他动态链接库,形成依赖树(用 ldd /bin/ls 观察)。动态链接器 ld 负责遍历依赖关系图装载所有需要的库,完成后把 CPU 控制权交给可执行程序入口——动态链接的过程主要是动态链接器负责,而不是 Linux 内核完成的。
fork 与 execve 的特殊性对比(高频考点):
| 系统调用 | 特殊之处 |
|---|---|
| 一般系统调用 | 陷入内核态 --> 处理后返回用户态 --> 继续执行系统调用后的下一条指令 |
| fork | 陷入内核态之后两次返回:第一次返回到原父进程位置继续向下执行(与其他系统调用一样);在子进程中也返回一次,返回到特定点 ret_from_fork,通过内核构造的堆栈从正常系统调用返回到用户态 |
| execve | 当前程序执行到 execve 时陷入内核态,内核里用 do_execve 加载可执行文件,把当前进程的可执行程序给覆盖掉;execve 返回时返回的已经不是原来那个可执行程序,而是新程序的执行起点 |
内核调用链(记住主干即可):
sys_execve / __x64_sys_execve
--> do_execve()
--> do_execveat_common()
--> __do_execve_file
--> exec_binprm()
--> search_binary_handler()
--> load_elf_binary()
--> start_thread()
这条链的含义:系统调用入口 --> 通用 exec 处理 --> 准备二进制参数 --> search_binary_handler 按文件格式找处理器(ELF 就走 load_elf_binary)--> 加载 ELF 各段 --> start_thread 设置新程序的入口和用户态堆栈。
易错:① fork 返回两次(父一次、子一次),execve 只返回一次但「返回后已换了程序」——别说成 execve 也返回两次。② execve 不创建新进程,它替换当前进程的映像(PID 不变);创建进程的是 fork。③ 动态链接的装载工作是动态链接器 ld 干的,不是内核干的;内核只负责把 ld 映射起来并跳到它。④search_binary_handler之后才是load_elf_binary,顺序别颠倒。
必考
共 28 题
答案已下载为 JSON 文件(通常在下载文件夹)。将以下命令发送给 Claude Code EPA skill,AI 会自动批改并生成报告:
将 <路径> 替换为刚下载的 JSON 文件的完整路径。