ExamPass Assistant
github.com/WUBING2023/ExamPass-Assistant

第6讲 可执行程序工作原理

第6讲 可执行程序工作原理

6.1 ELF 目标文件格式概念页1页2页3页4页1

Hook:你写了一句 printf("hello"),双击就能跑起来。可 CPU 只认 0 和 1,磁盘上那个 hello 文件里到底装了什么?Linux 凭什么知道该从哪个字节开始执行?

ELF(Executable and Linkable Format,可执行与可链接格式)是 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 会展开这个区别,别在判断题里混用。

必考

6.2 ELF 三种类型:可重定位、可执行、共享库页5页6页7页8页5

Hook:同一个 hello.c,用 gcc -c 得到 hello.o,直接链接得到 hello,还有 libc.so——这三个文件都是 ELF,为什么一个不能直接跑,另一个能跑?

ELF 有三种类型:可重定位目标文件(.o/.a,中间产物)、可执行文件(已完成重定位和符号解析)、共享目标文件(.so,动态链接库)。

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 打包」,仍属可重定位类型。另一个坑:可执行文件的符号解析并非全部完成——动态链接库的符号是在运行时才解析的。

必考

6.3 ELF Header、Section Header 与节区结构页9页10页11页12页13页9

Hook:拿到一个 hello 可执行文件,你想知道它多大、入口在哪、有几个节——可你面对的是满屏二进制。哪里写着这些元信息?

ELF 的整体布局是「ELF Header + 节(.text 等)+ 程序头表 + 节头表」;ELF Header 是文件的总索引,Section Header Table 是每个节的说明书。

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_ehsizeELF 头大小(字节)
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(虚拟地址)搞混——选择题常在这里设陷阱。

必考

6.4 readelf、objdump、hexdump 工具用法页14页15页20页14

Hook:老师让你「看看 hello 里有哪些节」,你打开文件只看到乱码。难道要手写一个解析器?

readelf 看 ELF 结构(-h 头 / -S 节头 / -l 程序头 / -s 符号表 / -r 重定位),objdump 反汇编并看段与符号,hexdump 用十六进制直接看原始字节。

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 数据。很多同学以为「文件里没数据就是解析错了」,其实这正是设计。

必考

6.5 Program Header Table 与段页16页17页18页19页16

Hook:链接器眼里 hello 是 30 多个节,可操作系统把它装进内存时只分了 6 块。中间发生了什么?

程序头表(Program Header Table,又叫段头表)描述「段(Segment)如何映射到内存」,是加载器创建进程映像的依据;它只在可执行文件和共享目标文件里存在,可重定位文件中没有。

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」,不是文件坏了,而是设计如此。判断题常考这一点。

必考

6.6 编译四步骤:预处理、编译、汇编、链接页21页22页23页24页21

Hook:gcc hello.c -o hello 一条命令就完事了。可这背后 gcc 到底替你做了几件事?如果链接报错「undefined reference」,是四个步骤里的哪一步出了问题?

从 .c 到可执行文件要经过四步:预处理(.i)--> 编译(.s)--> 汇编(.o)--> 链接(可执行文件)。

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 位程序必须显式加它。

必考

6.7 .text、.data、.bss 三大节区页25页26页25

Hook:你的 C 程序里有一个 int a;、一个 int b = 5;、还有一堆函数。它们在 .o 文件里被放进了三个不同的节。凭什么 a 和 b 要分开放?

汇编后的 .o 至少含三个节:.text 放机器指令(只读)、.data 放已初始化的全局/静态变量、.bss 放未初始化的全局/静态变量(文件里不占空间,运行时由系统清零)。

Why:分节的根因是「权限不同、初始化方式不同」。代码只读(防篡改、可共享),已初始化数据必须真的写进文件(否则初值丢了),未初始化数据初值恒为 0——既然恒为 0,就没必要在文件里存一堆 0,只记「需要多大空间」即可。这就是 .bss 不占文件空间的原因,也是可执行文件能比想象中小得多的原因。

What:

节中文名存放内容内存分配文件占空间权限
.text代码段程序执行的机器指令(也可能含只读常量,如字符串常量)大小运行前已确定是通常只读(某些架构允许可写)
.data数据段已初始化的全局变量、静态变量、常量静态内存分配是可读写
.bssBSS 段未初始化的全局变量(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 语境下标准答案是「节」。

必考

6.8 链接前后节区与段头表变化页27页28页29页27

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 的 Addr0(无绝对地址)有具体值(如 0x080482d0)链接器安排了地址布局
程序(段)头表无有可执行文件的加载执行,靠操作系统按程序头的指示把文件按布局加载到内存,再跳转到代码段

验证方法:在命令行分别敲 readelf -l hello.o 和 readelf -l hello 对比输出——前者会说没有程序头,后者会列出 LOAD 等段。这一步是理解「节是链接视图、段是执行视图」的最佳实验。

易错:节变多不等于「程序变复杂了」。多出的节全部来自被链接进来的库(如 .init、.plt、.fini、.rodata)。另一个坑:.text 有了地址不等于「绝对地址写死在文件里」——动态链接程序里库函数的地址仍是运行时才定的。

重点

6.9 符号、符号表与符号解析页30页31页32页33页34页30

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.cmain 记录为「有定义」;printf 记录为「无定义」,存入符号表
链接时找定义编译器到其他共享库中找到 printf 的「定义(机器指令片段)」
拼接把该片段机器指令与 hello.o 拼到一起(静态链接),生成 hello
结果hello 中 printf 就存在了——有定义即有明确地址。这就是符号解析
随后重定位确定各函数加载到内存的地址,反过来修改所有调用该函数的机器指令,使其跳转到正确地址

查看方法:objdump -t hello.o 或 readelf -s hello.o。符号表的功能是找未知函数在其他库文件中的代码段的具体位置——它就是那张「欠账清单」。

易错:符号表记录的是「有哪些符号、地址是多少」;重定位表记录的是「哪些代码位置需要改」。两者不是一回事——6.10 会讲。另一个常见误解:局部变量不是符号(符号只含全局变量和全局函数)。

必考

6.10 重定位与重定位表页35页36页35

Hook:符号解析已经把 printf 的代码拼进来了,可程序还是跑不起来——因为 printf 的代码被放在了某个地址,而 hello.o 里那几条 call 指令还指向「0 号地址」。谁来改这些指令?

重定位 = 把程序的逻辑地址变换成内存中实际物理地址的过程,即在装入内存时修改目标程序中指令和数据的地址。它分两步:重定位节和符号定义、重定位节中的符号引用。

Why:符号解析解决了「东西在哪」,重定位解决「怎么指过去」。不改指令里的地址,CPU 一 call 就跳到错误位置,程序直接崩。这两步合起来才构成完整的链接。

What:重定位的两大动作:

步骤做什么
① 重定位节和符号定义链接器将所有相同类型的节合并为同一类型的新的聚合节;将运行时存储器地址赋给新的聚合节、输入模块定义的每个节、以及输入模块定义的每个符号。此时程序中的每个指令和全局变量都有唯一的运行时存储器地址
② 重定位节中的符号引用链接器修改代码节和数据节中对每个符号的引用,使它们指向正确的运行时地址

How:重定位表中的每一条记录都对应一个需要重定位的符号。汇编器会为可重定位文件中每个「包含需要重定位符号的段」都建立一个重定位表。查看方法:readelf -r hello.o。

把两张表的分工记牢:符号表记录了目标文件中所有的全局函数及其地址;重定位表中记录了所有调用这些函数的代码位置。链接时这两大类数据都需要逐一修改为正确的值——符号表负责「定义在哪」,重定位表负责「引用在哪」。

易错:重定位不是「移动数据」。它改的是指令和数据里对地址的引用值,文件布局由链接器在合并节时一次排定。另一个坑:readelf -r 看的是重定位表,readelf -s 看的是符号表,两个开关别记反。

必考

6.11 静态链接与动态链接对比页37页38页39页40页41页42页43页44页37

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。

必考

6.12 execve 与 fork 装载可执行程序原理页45页46页47页48页49页50页51页52页53页54页55页56页57页45

Hook:你在 Shell 里敲下 ls -l /usr/bin 回车,ls 这个程序就变成了一个进程开始跑。可 Shell 自己也是个进程——它是怎么「变成」ls 的?还是说它生了个新的?

Shell 通过 fork 创建子进程,子进程再通过 execve 系统调用把自己「换壳」成目标程序:execve 在内核里用 do_execve 加载可执行文件、重建用户态堆栈,返回时返回的已经是新程序的入口点。

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,顺序别颠倒。
为什么 Shell 执行一条命令必须 fork 之后再 execve,而不能直接 execve?如果直接 execve 会发生什么?
参考答案execve 会覆盖当前进程的可执行程序映像,当前进程不再返回原程序。若 Shell 直接 execve 成 ls,ls 执行完后进程即结束,Shell 本身就消失了,用户回不到命令行。所以 Shell 必须先 fork 出子进程,让子进程去 execve,父进程 Shell 用 wait 等待子进程结束,从而保留自身继续接受命令。
静态链接程序与动态链接程序经 execve 加载后,内核态返回时分别从哪里开始执行?
参考答案静态链接程序:execve 加载完成后,堆栈上的返回地址被修改为程序入口点地址(如 readelf -h 看到的 Entry point address 0x804887f),从内核态返回即从该入口点开始执行。动态链接程序:从内核态返回时首先执行 .interp 节区指向的动态链接器(ld),由 ld 遍历依赖树加载所有需要的共享库并完成符号解析,最后把 CPU 控制权交给可执行程序的入口。

必考

章节测试

共 28 题

0
总分

📋 AI批改任务已生成

答案已下载为 JSON 文件(通常在下载文件夹)。将以下命令发送给 Claude Code EPA skill,AI 会自动批改并生成报告:

/exampass grade "<路径>"

将 <路径> 替换为刚下载的 JSON 文件的完整路径。