Hook:你写下的每一个 printf、每一行 fopen,最后到底是谁在替你跟硬件说话?为什么程序员几乎从不直接「命令」硬盘和网卡?
Why:做系统开发时经常需要与系统调用打交道,但直接使用系统调用的门槛较高——要自己准备寄存器、自己触发中断。于是标准库把这些细节包起来,程序员调用一个普通函数就完成了对内核的请求。要真正理解系统调用,还需要先补一些背景知识,也就是后面几节的权限划分与地址空间。
What:本节确立三层关系:应用程序 --> 库函数 API --> 系统调用。库函数是「封装层」,系统调用是「真正的请求入口」。用户写的是库函数名,真正被内核执行的是系统调用。
How:记住这条链路的三个角色:① 应用程序只管调 API,不关心寄存器;② 库函数负责把参数搬到约定的寄存器、并放入系统调用号,然后执行触发指令;③ 内核根据系统调用号查表,找到对应的内核处理函数并执行。第 5 讲还会把这条链展开成 xyz() --> system_call --> sys_xyz() 的三层机制。
易错:不要把「库函数」和「系统调用」当成一回事。库函数是用户态代码,系统调用是内核提供的服务;一个库函数可能封装一个系统调用,也可能完全不涉及系统调用(纯计算)。
必考
Hook:如果任何一个写得糟糕的小程序都能随手执行特权指令、随意改别人的内存,你的电脑还能开机超过五分钟吗?
Why:如果没有权限级别划分,不同程序员写的应用程序都能使用特权指令,而应用质量参差不齐,质量差的程序很容易导致整个系统崩溃;还有些程序会非法访问其他进程甚至内核的资源,直接产生系统安全问题。
What:现代 CPU 一般有几种不同的指令执行权限级别。内核态:执行权限级别高,代码可以执行特权指令,包括访问任意内存,所有指令都能执行。用户态:代码属低权限级别,能够操作的地址范围受到限制,只能访问特定范围的内存。
How:系统调用是操作系统发展过程中为保证系统稳定性和安全性而出现的重要机制:它让普通程序员写的用户态代码很难导致整个系统崩溃;而内核代码由更专业的程序员编写、有规范的测试,相对更稳定、健壮性更好。所以「把危险动作收进内核、只留一个受控入口给用户态」就是整个设计的核心思路。
易错:权限划分的目的不只是「防止恶意」,更是「防止失误」。幻灯片强调的是质量参差的程序引发崩溃,这是稳定性问题,不是纯安全问题。
必考
Hook:课本图上画着四个同心圆环,可真实的 Linux 只用到了其中两个——另外两个环去哪了?
Why:理解硬件到底提供了几级权限,才能明白操作系统的「用户态/内核态」是硬件能力的子集而非全部。这也是为什么同一套「两级」模型能横跨 x86 与 ARM 两种完全不同的架构。
What:X86 架构下 CPU 有 4 种指令执行权限,分别是 0、1、2、3,数值越小,权限越高。按 Intel 的设想:操作系统内核在 Ring0,驱动程序运行在 Ring1 和 Ring2,应用程序运行在 Ring3。ARM64 架构中指令执行权限级别被称为异常级别(Exception Level,EL),同样分 4 级:普通用户程序处于 EL0(最低),Supervisor 处于 EL1,Hypervisor 处于 EL2,Secure monitor 处于 EL3。
How:落到实际实现:主流操作系统如 Linux、Windows 都没有采用 Intel 提出的 4 级划分。Linux 在 X86 平台下只用 0 和 3 两级,分别对应内核态和用户态;在 ARM64 环境中只用 EL0 作用户态、EL1 作内核态。也就是说,硬件给了 4 个档位,操作系统只挂 2 档。
易错:ARM64 的编号方向和 x86 相反——EL0 权限最低、EL3 最高;而 x86 是 Ring0 最高。别把「0」一律当成最高权限。
必考
Hook:不用看任何标志位,只看一个寄存器里的数值,就能判断当前 CPU 处在用户态还是内核态——这个寄存器是哪个?
Why:权限划分在硬件上是「级别」,在软件上必须有一个可判定的表现。地址范围就是那个可判定的表现:同一段代码,IP 落在哪片区域,就说明它正跑在哪个态。这也是后面理解「用户态栈」和「内核态栈」是两个不同栈的基础。
What:32 位 Linux 系统上每个进程有 4GB 的地址空间(逻辑地址)。内核态下这 4GB 全都可以访问;用户态只能访问 0x00000000~0xbfffffff,即 0xc0000000 以上的部分只能在内核态下访问。64 位 Linux 系统上一般使用 48 位地址总线,每个进程有 256TB 的进程地址空间;内核态下 256TB 全可访问,用户态只能访问 0x000000000000~0x7ffffffff000。
How:按「先看位数、再算边界」两步记:① 32 位:总空间 4GB = 0x00000000~0xffffffff,分界线 0xc0000000,用户态占低端 3GB,内核态占高端 1GB;② 64 位:48 位地址总线意味着 2^48 = 256TB,用户态占低半区到 0x7ffffffff000,高端留给内核。做题时先确认架构位数,再套对应边界值。
易错:64 位进程的地址空间不是 2^64,而是 2^48 = 256TB——因为一般只使用 48 位地址总线。把 256TB 写成 16EB 是最常见的失分点。
必考
Hook:C 语言里 &x 取到的那个值,是内存条上真实的门牌号吗?如果不是,它凭什么能最终落到正确的物理单元上?
Why:三层地址的存在是为了让「每个进程都以为自己独占内存」成为可能,同时把隔离做在硬件里。理解这三层,才能解释为什么用户态只能访问特定范围——限制正是加在地址转换这一环上。
What:逻辑地址(logical address):机器语言指令中用来指定一个操作数或一条指令的地址;每一个逻辑地址都由该地址所属的段和段内偏移量组成,偏移量指明从段开始处到实际地址之间的距离。例如 C 语言的取指针操作(&),这个值是逻辑地址,它是相对于当前进程数据段的地址,不是物理地址;逻辑地址由两个 16 位的地址分量构成,一个为段基值,另一个为偏移量。线性地址(linear address):也称虚拟地址,是一个 32 位无符号整数,可表示高达 4GB 的地址,是逻辑地址和物理地址之间的中间层;在分段部件中逻辑地址是段内偏移地址,加上基地址就得到线性地址。物理地址就是实际物理内存的地址。
How:串起转换链:逻辑地址(段:偏移)--> 加段基址 --> 线性地址(虚拟地址)--> 经 MMU 内存页转换 --> 物理地址。逻辑地址和线性地址在 32 位和 64 位上目前都是虚拟地址,需要依次经过分段、分页映射,最后才转换成物理地址;这个映射计算过程一般由 CPU 内部的 MMU 负责。
易错:不要以为线性地址就是物理地址。线性地址仍是虚拟地址,必须再过一层分页(MMU 页表)才变成物理地址;漏掉分页这一步就答错了。
重点
Hook:系统调用既不是函数调用也不是硬件中断,它凭什么能让 CPU 心甘情愿地从用户态掉进内核态?
Why:要理解「怎么进去」,先要理解「中断这套机制本来是怎么分类的」。只有把系统调用定位到分类树的正确叶子上,才能解释它为什么是「主动」的、为什么返回地址指向下一条指令。
What:x86 分类树:中断(Interrupt)= 外部中断 + 内部中断;内部中断又称异常(Exception);异常 = 故障(fault)+ 陷阱(trap)。ARM64 的划分不同:中断被称为异常(Exception),进一步分为同步异常和异步异常,异步异常又分为普通优先级外部中断请求 IRQ、高优先级外部中断请求 FIQ 和系统错误 System Error。同步异常由程序本身的操作引发(系统调用、页面错误、段错误等),特点是精确——异常发生时指令流会立即进入异常处理流程;异步异常是与程序控制流程无关的意外事件或错误,通常由硬件或操作系统触发,常见有硬件中断、系统调用错误、信号处理、内存错误等。
How:同步与异步的区别可归纳为三点:① 同步异常由程序内部错误引发且能通过异常处理机制捕获处理;异步异常由外部因素触发,无法通过常规异常处理机制捕获。② 同步异常通常由程序员在代码中显式引发;异步异常由计算机系统或操作系统自动触发。③ 异步异常的发生可能不可预测,且在不同系统上表现可能不同。触发路径有两条:用户态进程执行时硬件中断信号到来,进入内核态执行对应中断处理程序;或者用户态程序执行过程中调用了一个系统调用,陷入内核态,这就叫陷阱(trap)。
易错:ARM64 里「异常」是总称(包含 IRQ/FIQ),而 x86 里「异常」只是内部中断的别名。同一个中文词在两套架构里层级不同,答题要说明架构。
必考
Hook:用户态跑到一半被拽进内核,回来时凭什么还能接着往下跑、变量一个都没乱?
Why:切换意味着「两套栈、两套状态」。不保存现场就回不去,不恢复现场就会带着内核的状态跑用户代码——所以保存与恢复是系统调用能成立的前提。
What:系统调用通过特定的软件中断向内核发出服务请求。触发指令:X86 架构下 int $0x80 指令或 syscall 指令触发系统调用;ARM64 架构下 svc 指令触发系统调用。返回指令:X86 是 iret 或 sysret,ARM64 是异常返回指令 eret。
How:按时间顺序走一遍:① 中断发生时,CPU 第一时间保存关键上下文(栈顶指针寄存器、标志寄存器、指令指针寄存器);② 一般系统调用会在堆栈上保存一些寄存器的值——保存中断发生时当前执行程序的栈顶地址、当时的状态字、当时指令指针寄存器的值;③ 同时把当前进程内核态的栈顶地址、内核态的状态字放入 CPU 对应寄存器,指令指针寄存器的值指向中断处理程序入口(对系统调用即系统调用处理入口);④ 进入处理程序后首先保存现场,把其他寄存器的值也入栈存入内核堆栈;⑤ 处理结束前恢复现场——在 3.18.6 的 X86-32 位内核中由 restore_all 和 INTERRUPT_RETURN(iret)实现,把入栈的寄存器依次出栈恢复到 ESP、EBP、EIP 等;⑥ 最后 iret 的动作与中断发生时 CPU 做的动作正好相反:之前保存栈顶指针寄存器、标志寄存器、指令指针寄存器,这里就是恢复它们。期间可能发生进程调度,若未调度或已从调度返回且工作处理完毕,就准备中断返回。
易错:int 不是 C/C++ 里的整型 int,而是中断(interrupt)的缩写——int $0x80 读作「中断 0x80」,不是「整数 0x80」。
必考
Hook:如果每个程序都自己写驱动去操作网卡,你的电脑上装十个浏览器就要写十份硬件代码——这显然不现实。系统调用解决的正是这件事。
Why:这三条不是口号,而是对前面所有机制的回报:因为有了内核态代管硬件,用户态才不必碰特权指令(第一条);因为用户态碰不到硬件,坏程序才炸不掉系统(第二条);因为接口代替了硬件细节,同一份程序才能跨机器跑(第三条)。
What:逐条对应:① 把用户从底层的硬件编程中解放出来——操作系统为我们管理硬件,用户态进程不用直接与硬件设备打交道;② 极大地提高系统的安全性——如果用户态进程直接与硬件设备打交道会产生安全隐患,可能引起系统崩溃;③ 使用户程序具有可移植性——用户程序与具体硬件已经解耦合并用接口代替,不会有紧密关系,便于在不同系统间移植。
How:答题模板化记忆:「解放 + 安全 + 可移植」。若要展开,每条都补一句因果:解放是因为内核代管硬件;安全是因为特权指令被关在 Ring0/EL1;可移植是因为接口层把硬件差异吃掉了。注意第 3 条的措辞是「可移植性」,落点在「便于在不同系统间移植」。
易错:这三点常被答成「提高效率」「方便调试」。幻灯片里没有效率这一条——系统调用本身反而有切换开销。按原文三点作答。
重点
Hook:内核里有 200 多个系统调用,你只说了一句 time(),内核凭什么知道你要的是哪一个?
Why:系统调用要从用户态切到内核态,而这两种执行模式下使用的是不同的堆栈——进程的用户态堆栈和进程的内核态堆栈。压栈传参依赖「同一个栈」,跨态就不成立了,所以只能改用寄存器。另外压栈方式需要读写内存,函数调用速度较慢,寄存器传参也更快。
What:Linux 内核中大约定义了 200 多个系统调用。32 位 x86:除 EAX 传系统调用号外,参数按顺序赋给 EBX、ECX、EDX、ESI、EDI、EBP,参数个数不能超过 6 个;超过 6 个时,把某一个寄存器作为指针指向内存,通过内存传递更多参数。每个参数长度不能超过寄存器长度,32 位下寄存器最大 32 位。64 位 x86:普通函数调用和系统调用都通过寄存器传参,RDI、RSI、RDX、RCX、R8、R9 这 6 个寄存器依次对应第 1 到第 6 个参数。
How:做题按三步:① 看位数定寄存器组——32 位用 E 系列(EBX/ECX/EDX/ESI/EDI/EBP),64 位用 R 系列(RDI/RSI/RDX/RCX/R8/R9);② 系统调用号固定放 EAX/RAX,不占参数位;③ 参数超过 6 个就用一个寄存器当指针指向内存结构体。注意 64 位普通函数调用也改成了寄存器传参,因为压栈要读写内存、速度较慢。
易错:64 位传参的第 4 个寄存器是 RCX 而不是 R8,且不含 RBP——顺序是 RDI、RSI、RDX、RCX、R8、R9。把 32 位的 EBX/ECX 顺序直接套到 64 位会全错。
必考
Hook:课本说 time() 最终会触发系统调用,可源代码里一个 int 指令都看不见。怎么证明它真的陷进去了?
Why:库函数封装把系统调用藏起来了,要看见它只能往二进制里看。反汇编是「验证封装」的标准手段——这也是本讲从「会用」走向「看懂」的关键一步。
What:C 库函数原型:time_t time(time_t *seconds) 返回自 1970-01-01 00:00:00(UTC 国际时区)起经过的时间,以秒为单位;如果 seconds 不为空,则返回值也存储在变量 seconds 中。struct tm *localtime(const time_t *timer) 使用 timer 的值来填充 struct tm 结构体,timer 的值被分解到 struct tm 结构体中,并用本地时区表示。
How:实操四步:① 写范例程序:声明 time_t tt 与 struct tm *t,tt = time(NULL),t = localtime(&tt),再 printf 输出 tm_year+1900、tm_mon、tm_mday、tm_hour、tm_min、tm_sec;② gcc -o time time.c -static 静态编译;③ objdump -S time > time64.S 生成带源码的反汇编;④ 在反汇编里找 int $0x80 或 syscall,并读 EAX 里装入的立即数。结论:32 位系统 time 系统调用号为 0xd(13),64 位为 0xc9(201);查 arch/x86/entry/syscalls/syscall_32.tbl 可知 13 号对应内核处理函数 sys_time,查 syscall_64.tbl 可知 201 号对应 __x64_sys_time。
易错:同一个 time 服务在 32 位和 64 位下系统调用号完全不同(13 vs 201),且 64 位的处理函数名带 __x64_ 前缀。跨位数对比时必须分别查表。
重点
Hook:同一条「进内核」的路,Intel 和 AMD 各修了一条高速通道,最后又合并成一条——这三代指令到底在优化什么?
Why:传统 int $0x80 每次都要走中断描述符表、GDT/LDT 找段描述符,链路长;MSR 方式把入口地址直接放在 CPU 内部寄存器里,切换更快。x86-64 又引入 SWAPGS,用类似快照的方式快速保存与恢复寄存器,进一步加速。
What:三条关键事实:① int $0x80 是产生中断向量为 128 的编程异常(trap),按中断向量依次存放入口;② sysenter 是 Intel 处理器引入的快速系统调用指令,因 Intel 系列 CPU 专用、AMD 的 CPU 并不支持,故不再详述;③ syscall 与 sysenter 都借助 CPU 内部的 MSR 寄存器存放系统调用处理入口,查找更快。
How:分两个阶段理解:初始化阶段——把系统调用处理入口地址告诉 CPU:int $0x80 和其他中断一样按中断向量依次存放,sysenter/syscall 则写进 MSR。执行阶段——int $0x80 由 CPU 压栈关键寄存器,内核保存现场,内核函数处理完恢复现场,最后 iret 出栈;sysenter/syscall 用 MSR 快速把 EIP/RIP 切到入口,但本质上仍是中断处理思路:压栈关键寄存器、保存现场、恢复现场、系统调用返回;x86-64 的 SWAPGS 类似快照,把保存/恢复现场用的 CPU 寄存器也通过 CPU 内部存储器快速保存和恢复。再看内核侧:syscall_32.tbl 与 syscall_64.tbl 分别定义 32 位与 x86-64 的系统调用内核处理函数,最终通过脚本转换按系统调用号依次存入 ia32_sys_call_table 和 sys_call_table 数组;入口 entry_INT80_32 和 entry_SYSCALL_64 分别调用 do_int80_syscall_32 和 do_syscall_64(代码在 arch/x86/entry/common.c)来执行对应内核函数。
易错:sysenter/sysret 不是「另一种完全不同的机制」,它仍属于中断处理思路,只是入口查找更快;而且它是 Intel 专用,AMD 不支持——这正是后来被 syscall/sysret 取代的原因之一。
重点
共 13 题
答案已下载为 JSON 文件(通常在下载文件夹)。将以下命令发送给 Claude Code EPA skill,AI 会自动批改并生成报告:
将 <路径> 替换为刚下载的 JSON 文件的完整路径。