ExamPass Assistant
github.com/WUBING2023/ExamPass-Assistant

第2讲

第2讲 How the OS works 操作系统如何工作

2.1 函数调用堆栈框架的作用页1页2页1

Hook:C 语言的函数可以一层套一层地调用,可是函数返回时它怎么知道该回到哪里?它把答案写在了内存里——写在一块叫「堆栈」的地方。

堆栈是 C 语言程序运行时必须的一个记录调用路径和参数的空间,它承担四件事:函数调用框架、传递参数、保存返回地址、提供局部变量空间。

Why:编译器必须解决「嵌套调用后如何正确返回」这个核心问题。递归调用时同一个函数会同时存在多份局部变量,因此不能放在固定地址,只能放在一块后进先出、随调用自动伸缩的内存里。C 语言编译器对堆栈的使用有一套规则,不同编译器规则有差异;而了解堆栈存在的目的和编译器使用堆栈的规则,是理解操作系统一些关键性代码的基础——后面讲中断、系统调用、进程切换,全都复用这套栈帧机制。

What:堆栈在函数调用中提供四项服务:① 函数调用框架——记录每个活跃函数的栈帧边界;② 传递参数——32 位 x86 通过压栈传参(讲义特别标注 x86-64 改为使用寄存器传递参数);③ 保存返回地址——函数执行完能回到调用点;④ 提供局部变量空间——函数内的局部变量就分配在自己的栈帧里。

How:把这四项对应到后面要学的具体指令:保存返回地址靠 call 压栈、ret 弹栈;传递参数靠调用前的 pushl 与被调函数的 8(%ebp)、0xc(%ebp) 读取;提供局部变量空间靠 subl $0x18, %esp 这类减法开辟、靠 -4(%ebp) 之类负偏移访问;而「调用框架」本身由 pushl %ebp + movl %esp,%ebp 建立、由 movl %ebp,%esp + popl %ebp 拆除。一句话串起来:栈帧就是「一块用 EBP 圈定边界的内存」,返回地址在它上面、参数在它上面更远处、局部变量在它下面。

易错:把「传递参数」当成堆栈的普适职责。讲义明确提示 x86-64 改用寄存器传参,堆栈传参只是 32 位 x86 的约定,做 64 位题目前先确认位宽。

必考

2.2 esp/ebp 寄存器与 push/pop 堆栈操作页3页3

Hook:堆栈在内存里只是一段普通地址,没有任何「栈」的物理标记。是谁在维护这个抽象的栈?只有两个寄存器。

esp 是堆栈指针(stack pointer),ebp 是基址指针(base pointer);push 使栈顶地址减少 4 个字节(32 位)、pop 使栈顶地址增加 4 个字节;ebp 在 C 语言中用作记录当前函数调用的基址。

Why:栈的「后进先出」完全由 esp 的移动方向实现。既然 push 让地址变小,说明栈是从高地址向低地址生长的——所以「栈顶」在数值上反而是较小的地址。这个反直觉的约定是画栈题的第一道坎,也是缓冲区溢出利用中「往低地址写、覆盖高地址的返回地址」这一方向的来源。

What:两个堆栈寄存器:esp(堆栈指针)永远指向当前栈顶,随 push/pop 自动移动;ebp(基址指针)在函数内固定不动,用作记录当前函数调用的基址,是访问参数与局部变量的锚点。两个操作:push 栈顶地址减 4 字节、pop 栈顶地址加 4 字节(均指 32 位环境)。

项目espebp
全称stack pointerbase pointer
指向当前栈顶当前函数栈帧基址
是否自动变push/pop 时自动变函数内固定不变
典型用途定位栈顶、分配局部空间定位参数与局部变量

How:画图时把讲义的两个标注记牢:图上低地址在上、高地址在下,ebp 在中间、esp 在下方(更靠高地址一侧)——因为栈向低地址生长,esp 越往下移表示栈越「深」。实操验证:在 gdb 里执行 info registers esp ebp 看两值,再 stepi 单步一条 push,立刻看到 esp 减 4;执行 pop 看到 esp 加 4。用 x/8xw $esp 还能看到每格的 4 字节内容,与讲义堆栈图一一对应。

易错:把栈图画成「低地址在下」。x86 栈向低地址生长,push 之后新数据在更小的地址上,画图时务必标清哪端是低地址,否则栈帧里参数与局部变量的上下关系会全部颠倒。

必考

2.3 cs:eip 与 call/ret 调用返回机制页4页5页4

Hook:函数调用看起来是个高级概念,但 CPU 眼里它只是两条指令:一条把「回来的路」记在栈上,另一条照着这条路跳回去。

cs:eip 总是指向下一条要执行的指令的地址;call 把当前 cs:eip 的值压入栈顶,再让 cs:eip 指向被调用函数的入口;ret 从栈顶弹出保存的 cs:eip 值放回寄存器,从而回到调用点之后。

Why:CPU 只有一套 cs:eip,函数调用却是嵌套的——所以「回来的路」必须存在某个可嵌套的地方,而栈天然满足后进先出:最后调用的函数最先返回,正好对应栈顶。这也解释了为什么破坏栈上的返回地址就能劫持控制流。

What:cs:eip 的行为分三种情形:顺序执行时总指向地址连续的下一条指令;跳转/分支时其值根据程序需要被修改;call 时先把 eip 中下一条指令的地址 A 保存到栈顶,再把 eip 设为被调用函数代码的起始处;ret 时从栈顶弹出原来保存的值(即执行跳转/调用之前 eip 指向的指令),放入 cs:eip。

How:讲义给出的完整框架分三段:
建立 func() 的堆栈框架:pushl %ebp、movl %esp, %ebp;
拆除 func() 的堆栈框架:movl %ebp, %esp、popl %ebp、ret;
调用者:... call func() ...,func 函数体 do sth.。
注意 call 的两步语义:先保存「下一条指令地址 A」到栈顶(不是当前 eip,而是已经自增后的下一条),再把 eip 指向 func 入口。ret 做的事正好相反:把地址 A 恢复到 eip 中。所以 call 与 ret 是一对严格对称的操作,中间夹着的 pushl %ebp 与 popl %ebp 只是在保护调用者的基址。

易错:以为 call 保存的是「call 指令自身的地址」。保存的是 call 之后那条指令的地址,所以函数返回后不会重新执行 call,而是继续往下走。

必考

2.4 函数堆栈框架建立与拆除全过程页6页7页8页9页10页11页12页13页14页6

Hook:一次函数调用,内存里其实只发生了四次指针移动和一个入栈。把这五步背下来,任何画栈题都只是照着走一遍。

调用全过程五步:call 压返回地址 --> pushl %ebp 保存旧基址 --> movl %esp,%ebp 建立新基址 --> 执行函数体(堆栈相应变化)--> 退出时 movl %ebp,%esp、popl %ebp、ret。

Why:为什么要先保存旧 ebp 再赋新值?因为 ebp 只有一个,被调用函数要用它定位自己的栈帧,就必须先把调用者的基址存起来,等自己退出时再恢复——否则返回后调用者就找不到自己的局部变量了。这就是「保存现场 / 恢复现场」的最小版本,进程切换、中断处理都是它的放大版。

What:按讲义 slides 6–14 的推进顺序:① 执行 call 前的堆栈布局;② 执行 call 时,cs:eip 原来的值指向 call 下一条指令,该值被保存到栈顶,然后 cs:eip 指向 func() 入口地址;③ 进入 func() 第一条指令 pushl %ebp——把调用者的 ebp 压栈;④ 第二条指令 movl %esp, %ebp——ebp 从此指向保存旧 ebp 的那一格;⑤ 执行函数体 do sth.,堆栈会相应变化(压参数、开局部空间);⑥ 退出时 movl %ebp,%esp 把 esp 重新指回 ebp 的位置(因为函数执行过程中 esp 已经变了),再 popl %ebp 恢复调用者基址,最后 ret 弹出返回地址。

步骤指令esp 变化ebp 变化
调用call func减 4,写入返回地址不变
建立①pushl %ebp减 4,写入旧 ebp不变
建立②movl %esp, %ebp不变= 新 esp
函数体do sth.随指令变化固定不变
拆除①movl %ebp, %esp= ebp不变
拆除②popl %ebp加 4= 旧 ebp
返回ret加 4不变

How:拆解退出阶段三个动作的因果:函数体里可能反复 push/pop、可能 subl 开了局部空间,所以此刻 esp 的位置已经不能代表栈帧底部;movl %ebp,%esp 就是「把 esp 强行拉回 ebp」这一动作,一步丢弃所有局部变量空间;接着 popl %ebp 弹出的是当初 pushl 保存的旧 ebp,栈顶因此上移到返回地址;最后 ret 弹出返回地址写入 cs:eip,程序回到 call 的下一句。三步缺一不可:少第一步会漏掉局部空间,少第二步 ebp 会永久错位,少第三步就回不去。

易错:以为 movl %ebp,%esp 之后局部变量就「被清零」了。它只是移动指针,数据仍留在栈上——这正是后续课程里栈上残留信息泄露与格式化字符串读取栈内容的物理基础。

必考

2.5 objdump 反汇编观察堆栈框架页15页16页17页18页19页15

Hook:怎么证明书上画的栈帧是真的?不看源码,看机器码——objdump 会把编译器偷偷做的事全打印出来。

先用 gcc -g test.c 生成带调试信息的可执行文件,再用 objdump -S 反汇编,就能把汇编指令与 C 源码交错显示;重点观察三件事:构建堆栈框架的指令、如何传递参数、main 中局部变量在堆栈中的存放。

Why:教材上的栈帧图是抽象的,而真实编译器会插入额外的对齐、优化和冗余指令。只有亲自反汇编一次,你才知道哪些指令是「必须的骨架」、哪些是编译器自由发挥。这也是后续逆向分析与漏洞定位的基本功——拿到一个未知二进制,第一件事就是 objdump 看函数序和函数尾声。

What:操作链:gcc -g test.c 获得 test.c 的可执行文件 --> objdump -S 获得 test 的反汇编文件(-S 让源码与汇编交错)。以 int p2(int x, int y){return x+y;} 为例,反汇编里能看到:建立堆栈 pushl %ebp + movl %esp,%ebp;函数体 movl 0xc(%ebp), %eax + addl 0x8(%ebp), %eax;拆除堆栈 movl %ebp,%esp + popl %ebp + ret。

How:对着反汇编读参数偏移:ebp 指向保存的旧 ebp,ebp+4 是返回地址,于是 第一个参数 x 在 0x8(%ebp)、第二个参数 y 在 0xc(%ebp)。注意 p2 里先取 0xc(%ebp) 再 addl 0x8(%ebp)——因为 addl 是「把源加到目的」,目的必须是 eax,所以先把 y 装进 eax,再把 x 加上去。这解释了为什么加法函数的反汇编看起来是「先取第二个参数」。函数尾声用 movl %ebp,%esp 而不是 leave,本质等价。图上还要标注:ebp 以上(高地址侧)是调用者的堆栈框架与参数,ebp 以下(低地址侧)是被调用函数的局部空间。

易错:把 0x8(%ebp) 读成「ebp 加 8 个元素」。偏移单位是字节,0x8 就是 8 字节,正好跳过 4 字节旧 ebp 与 4 字节返回地址,所以它才是第一个参数。

重点

2.6 堆栈传参、eax 返回值与局部变量存储页20页21页22页23页24页25页26页27页28页20

Hook:一句 z = p2(x, y); 编译出来是五行汇编,其中一行的作用是「把栈擦干净」。谁擦的、为什么擦,直接关系到参数由谁负责回收。

32 位 x86 的参数从右往左依次压栈;返回值通过 eax 传递;局部变量在 subl 开辟的空间里用 ebp 的负偏移存放;调用返回后由调用者用 add $0x8, %esp 清理参数。

Why:参数从右往左压,是为了让第一个参数落在最低地址、也就是离 ebp+8 最近的位置,这样被调用函数用固定偏移 0x8(%ebp)、0xc(%ebp) 就能顺序访问所有参数,不必知道实参个数。返回值走 eax 而不是栈,是因为栈上的返回值需要调用者预先分配空间并处理尺寸,寄存器最快且天然只有一个返回值。

What:z = p2(x, y); 的汇编:
pushl 0xfffffff8(%ebp) —— 压 y(即 -8(%ebp));
pushl 0xfffffff4(%ebp) —— 压 x(即 -4(%ebp));
call 804839b <p2> —— 调用;
add $0x8, %esp —— 调用者清理 8 字节参数;
movl %eax, 0xffffffc(%ebp) —— 把返回值存入 z。
局部变量存储:main 用 subl $0x18, %esp 一次开辟 24 字节,然后 char c = 'a' 写成 movb $0x61, 0xffffff3(%ebp),x = 1 写成 movl $0x1, 0xffffff4(%ebp),y = 2 写成 movl $0x2, 0xffffff8(%ebp)。

变量/动作汇编表示说明
局部空间subl $0x18, %esp一次开 24 字节
c = 'a'movb $0x61, -0xd(%ebp)1 字节,用 movb
x = 1movl $0x1, -0xc(%ebp)4 字节,用 movl
y = 2movl $0x2, -0x8(%ebp)4 字节,用 movl
z = 返回值movl %eax, -0x4(%ebp)返回值走 eax

How:printf 调用进一步验证「从右往左压栈」:printf("%d = %d + %d\n", z, x, y) 编译为 pushl -8(%ebp)(y)、pushl -4(%ebp)(x)、pushl -0xc(%ebp)(z)、pushl $0x8048510(格式串地址)、call printf@plt。压栈顺序是 y --> x --> z --> 格式串,正好与参数列表从右往左一致,于是栈顶是格式串、第一个可变参数紧邻其后。这也解释了格式化字符串漏洞为什么能按顺序读栈:%d 一个个往上取,就是依次取到 z、x、y。

易错:以为被调用函数负责清理参数。32 位 cdecl 约定下是调用者在 call 之后执行 add $0x8, %esp 清理,因为只有调用者知道压了几个参数。另外注意 0xfffffff8(%ebp) 与 -0x8(%ebp) 是同一个地址的两种写法(补码)。

必考

2.7 多函数调用 main/p1/p2 堆栈演练页29页30页31页32页33页34页29

Hook:代码段里 main、p1、p2 三个函数各占一块固定位置,而堆栈里会同时出现三份栈帧——同一个程序,两种「空间」。

程序的代码段是静态的(main/p1/p2 各有固定入口),堆栈是动态的;每发生一次调用就在栈上多叠一层栈帧,p1 的栈帧里存参数 c 与返回地址,p2 的栈帧里存 x、y 与返回地址,返回时逐层弹出。

Why:这个演练把前面所有零散知识合成一张图。理解了「代码段固定 + 堆栈随调用增长」,就能理解递归为什么会栈溢出、为什么深度嵌套调用会耗尽栈空间——因为栈帧是一层叠一层占内存的。

What:讲义练习题代码:void p1(char c){printf("%c\n", c);};int p2(int x,int y){char c='a'; p1(c); return x+y;};int main(void){int x,y,z; x=1; y=2; z=p2(x,y); printf("%d + %d = %d\n", x, y, z); return 0;}。图上要求补全 main、p1、p2 三层堆栈内容,并标出每层的 eip(返回地址)位置。

How:按调用顺序叠栈:① main 建立自己的栈帧,subl 开辟局部空间,x=1、y=2 落在负偏移处;② z = p2(x, y) 时先压 y 再压 x,call 压返回地址,p2 建立栈帧,此时栈上从低到高是:p2 的局部 c、p2 保存的旧 ebp、p2 的返回地址、参数 x、参数 y、main 的局部变量……③ p2 内 p1(c) 再压 c 与返回地址,p1 建立栈帧,于是栈顶是 p1 的帧;④ p1 返回,printf 输出字符,拆除 p1 栈帧;⑤ p2 执行 return x+y 把结果放 eax,拆除 p2 栈帧,返回地址把控制权交回 main;⑥ main 执行 add $0x8,%esp 清参数,把 eax 存入 z,再调 printf。画图要点:三层栈帧的 ebp 各自指向本层的「保存旧 ebp」格,每层的返回地址都在本层 ebp+4,参数在 ebp+8 及以上;p1 的帧在最上方(地址最小),main 的帧在最下方(地址最大)。

易错:把三层栈帧画成并列的三块,或把 p1 的栈帧画在 main 之下。栈是向下生长的,后调用的 p1 帧地址最小,必须画在最上面(低地址端)。

重点

2.8 C 内嵌汇编语法与 gcc -m32 编译页35页36页37页35

Hook:想验证「寄存器到底怎么被用」,最直接的办法是把汇编直接写进 C 代码里——让编译器别管这一段,你说了算。

内嵌汇编用 asm volatile(指令串 : 输出 : 输入);指令里的 %%eax 表示寄存器(双百分号避免与占位符冲突),%0、%1、%2 是操作数占位符;"=m" 表示只写内存输出,"c"/"d" 表示使用 ecx/edx 寄存器。

Why:操作系统内核里有大量必须精确控制寄存器和指令的代码(开关中断、切换页表、读写特殊寄存器),C 语言无法表达,只能内嵌汇编。掌握这套语法,才能读懂后续课程里的内核源码片段。同时它也是实验手段:写一段内嵌汇编,就能亲手验证 eax、ecx、edx 的取值。

What:讲义示例把 val1 + val2 存入 val3:
asm volatile(
"movl $0,%%eax\n\t" —— 把 eax 清零;
"addl %1,%%eax\n\t" —— eax += val1;
"addl %2,%%eax\n\t" —— eax += val2;
"movl %%eax,%0\n\t" —— val3 = eax;
: "=m" (val3) —— 输出部分,"=m" 表示只写内存变量;
: "c" (val1), "d" (val2) —— 输入部分,c/d 表示使用 %ecx/%edx;
);

符号含义
%%eax真实寄存器 eax(双 % 转义)
%0 / %1 / %2操作数占位符,按输出、输入顺序编号
"=m"只写(output)内存变量
"c" / "d"约束使用 ecx / edx 寄存器
volatile禁止编译器优化掉这段汇编

How:编译与观察:gcc -S -o assembly_in_C.s assembly_in_C.c 生成汇编文件,打开就能看到内嵌的几条指令被原样插入。若在 64 位机器上要编出 32 位代码,讲义给出两步:先 sudo apt-get install gcc-multilib 安装多架构支持,再 gcc -S -o assembly_in_C.s assembly_in_C.c -m32。注意第 2 讲这里用的是 gcc-multilib,而第 1 讲 32 位链接缺库时用的是 libc6-dev-i386——前者提供 -m32 所需的头文件与库集合,后者补 32 位 libc 开发包,两者场景不同别混。验证结果:val1=1、val2=2,eax 依次变 0、1、3,最终 val3=3。

易错:在指令串里只写一个 %,如 "movl $0,%eax"。单 % 会被当成操作数占位符解析,寄存器必须写 %%eax;另外输出约束写成 "=m" 表示内存,若写成 "=r" 则让编译器挑寄存器,语义不同。

重点

问题一:执行 call func 之后、进入 func 执行 pushl %ebp 之前,栈顶存放的是什么?请说明它由谁写入、又由谁在什么时候取走。
参考答案栈顶存放的是返回地址,即 call 指令之后那条指令的地址(讲义称地址 A)。它由 call 指令在执行时自动压入:call 先把当前 cs:eip 的值(指向 call 的下一条指令)保存到栈顶,再把 cs:eip 设为 func 的入口地址。取走它的是 func 函数尾声的 ret 指令——ret 从栈顶弹出这个值放回 cs:eip,程序于是回到 call 的下一句继续执行。中间的 pushl %ebp / movl %esp,%ebp 只是保存与重建基址,不改变返回地址的位置(它在 ebp+4 处)。
问题二:main 中执行 z = p2(x, y),反汇编为 pushl -8(%ebp)、pushl -4(%ebp)、call p2、add $0x8,%esp、movl %eax,-0x4(%ebp)。请解释为什么先压 -8(%ebp) 而不是 -4(%ebp),以及 add $0x8,%esp 的作用与执行者。
参考答案32 位 x86 的参数按从右往左的顺序压栈,所以先压第二个实参 y(存于 -8(%ebp))、再压第一个实参 x(存于 -4(%ebp))。这样压完后第一个参数 x 位于最低地址,恰好紧邻返回地址之上,被调用函数就能用固定偏移 0x8(%ebp) 取 x、0xc(%ebp) 取 y,不必知道实参总数。add $0x8,%esp 由调用者 main 在 call 返回后执行,用于回收刚才压入的两个 4 字节参数(共 8 字节),把 esp 恢复到压参前的位置;这是 cdecl 约定中「调用者清理参数」的体现。随后 movl %eax,-0x4(%ebp) 把 p2 通过 eax 带回的返回值存入变量 z。

章节测试

共 15 题

0
总分

📋 AI批改任务已生成

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

/exampass grade "<路径>"

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