ExamPass Assistant
github.com/WUBING2023/ExamPass-Assistant

第5讲

第5讲 系统调用与嵌入式汇编

5.1 系统调用要点回顾页1页2

Hook:上一讲讲了那么多机制,如果只能带走六句话,应该是哪六句?

本讲回顾六条主线:用户态与内核态、中断、x86 VS ARM、系统调用(特殊的中断,中断号是多少)、通过 API 封装好、调用的过程、x86 和 ARM 触发系统调用的指令、系统调用的参数传递方式。

Why:这一讲要动手写嵌入式汇编,而汇编里每一个寄存器、每一条指令都必须有依据。回顾的作用是把上一讲的结论变成「写代码时可以直接落笔的清单」——不知道用哪个寄存器传号、用哪条指令陷入,就写不出一行可运行的代码。

What:回顾清单可归为四组:① 状态模型——用户态与内核态的权限划分;② 机制模型——中断(含 x86 与 ARM 的差异),以及「系统调用是一种特殊的中断」这一定位;③ 封装模型——系统调用通过 API 封装好,中断号是 0x80;④ 执行模型——调用的过程、x86 和 ARM 触发系统调用的指令、系统调用的参数传递方式。

How:把这四组当作写代码前的自检表:要陷入内核,先问触发指令是哪条(x86 用 int $0x80 或 syscall,ARM64 用 svc);要说明调谁,先问系统调用号放哪个寄存器(32/64 位 x86 都用 EAX/RAX);要传参,先问参数按什么顺序进寄存器(32 位 EBX/ECX/EDX/ESI/EDI/EBP,64 位 RDI/RSI/RDX/RCX/R8/R9);要取返回值,先问值从哪个寄存器读回(EAX/RAX)。这四问就是后面 5.4、5.5 两段汇编的全部设计依据。

易错:回顾里「中断号是?」这一问的答案是 0x80(即 128),不是 0x0d。0x0d 是 time 的系统调用号,两者一个是「走哪条门」,一个是「找哪个人」。

了解

5.2 库函数 API 触发系统调用案例页3页3

Hook:一段只用 time、localtime、printf 三个标准函数的十几行程序,凭什么能作为整个汇编实验的对照基准?

用库函数 API 写一个取时间并格式化输出的程序:time_t tt 存秒数,struct tm *t 存分解后的时间,printf 按 年/月/日 时:分:秒 输出,其中年份要加 1900。这就是后面用嵌入式汇编手工复现的目标。

Why:这是「不碰汇编也能完成同一件事」的版本。先跑通它,才能确认环境、头文件、输出格式都正确;再用嵌入式汇编替换掉 time 那一行,两版输出一致,就证明手写的汇编确实触发了同一个系统调用。

What:程序结构:int main() 中声明 time_t tt 与 struct tm *t;调用 tt = time(NULL) 取得秒数;调用 t = localtime(&tt) 把秒数分解为本地时区的结构体;最后 printf 输出 t->tm_year + 1900、t->tm_mon、t->tm_mday、t->tm_hour、t->tm_min、t->tm_sec。

How:按三步走:① 取原始值:time(NULL) 的参数为 NULL 表示不额外回写,返回值即自 1970-01-01 00:00:00 UTC 起的秒数;② 做分解:localtime 把 time_t 拆到 struct tm,并按本地时区表示;③ 做格式化:tm_year 是相对 1900 的偏移量,所以必须加 1900 才是真实年份,其余字段按 月、日、时、分、秒 直接打印。

int main(){
    time_t tt;
    struct tm *t;
    tt = time(NULL);
    t = localtime(&tt);
    printf("time: %d/%d/%d  %d:%d:%d\n",
        t->tm_year + 1900, t->tm_mon,
        t->tm_mday, t->tm_hour,
        t->tm_min, t->tm_sec);
    return 0; }
易错:tm_year 直接打印会得到「126」这类数字,因为它记录的是距 1900 年的偏移;漏掉 +1900 是最常见的输出错误。

重点

5.3 嵌入式汇编语法与常用限定符页4页5页6页7页8页9页4

Hook:C 代码里嵌一段汇编,编译器怎么知道哪些变量该进 EAX、哪些变量写回内存、哪些寄存器会被你改坏?答案全在冒号后面的那几个字母里。

嵌入式汇编的限定符用来约束操作数的落位与读写属性:通用寄存器类(a/b/c/d/s/D/q/r/A)决定变量进哪个寄存器,内存类(m/o/v/p/g/x)决定按内存变量处理,立即数类(i/J/N/I/n)约束立即数范围,还有 =(只写)、+(读写)、f/t/u/G(浮点)以及 %(可与下一个操作数交换)。

Why:汇编模板里只写 %0、%1、%2 这样的占位符,真正的寄存器分配交给编译器。限定符就是程序员与编译器之间的契约:写「a」表示「请把这个变量放进 EAX」,写「=m」表示「结果只写回内存」,写「r」表示「随便挑一个通用寄存器」。契约写错,编译器就会生成与你意图不符的代码。

What:分四类记:通用寄存器——「a」入 EAX、「b」入 EBX、「c」入 ECX、「d」入 EDX、「s」入 ESI、「D」入 EDI、「q」入 EAX\EBX\ECX\EDX 之一、「r」入 EAX\EBX\ECX\EDX\ESI\EDI 之一、「A」把 EAX 和 EDX 合成一个 64 位寄存器。内存或寄存器——「m」内存变量、「o」寻址方式为偏移量类型的内存变量、「v」寻址方式非偏移量类型的内存变量、「.」寻址方式为自动增量、「p」合法内存地址(指针)、「g」入通用寄存器之一或作为内存变量、「x」任何类型。立即数——「i」0~31 之间(32 位移位指令)、「J」0~63 之间(64 位移位指令)、「N」0~255 之间(out 指令)、「I」立即数、「n」立即数(用在不支持字以外立即数的系统上)。操作数类型与浮点——「=」只写(输出操作数)、「+」读写(输入输出操作数)、「f」浮点数、「t」第一个浮点寄存器、「u」第二个浮点寄存器、「G」标准 80387 浮点常数、「%」该操作数可以和下一个操作数交换位置。

How:用示例代码把语法结构钉住:__asm__ __volatile__( 指令模板 : 输出部分 : 输入部分 : 破坏描述部分 )。示例中指令模板依次是 movl $0,%%eax(EAX 置 0)、movl %%eax,%1(%1 指 temp,temp=0)、movl %2,%%eax(%2 指 input,eax=1)、movl %%eax,%0(%0 指 output,output=1);输出部分是 "=m"(output)、"=m"(temp),"=m" 表示只输出到内存;输入部分是 "r"(input),"r" 表示把变量放进 EAX\EBX\ECX\EDX\ESI\EDI 之一;破坏描述部分是 "eax",表示 EAX 寄存器会被改动。注意汇编模板里寄存器要写两个百分号 %%eax,而 %0/%1/%2 是操作数占位符。

易错:把 %0、%1 当成寄存器编号。它们是「第 0 个、第 1 个操作数」的占位符,具体落到内存还是寄存器,由后面的限定符决定;寄存器本身在模板里必须写成 %%eax。

必考

5.4 嵌入式汇编触发 time 系统调用页10页10

Hook:不用 time() 函数,只写四行汇编,能不能拿到和 time(NULL) 一模一样的时间戳?

四步模板:EAX 清 0 --> EAX 装入系统调用号 0xd(13)--> int $0x80 触发系统调用 --> 从 EAX 读回返回值存入 tt。这段汇编等价于 tt = time(NULL)。

Why:这是把上一讲的抽象机制第一次落成可执行代码。四行分别对应「准备参数」「指明调谁」「陷入内核」「取回结果」四个动作,缺一不可。理解了这四行,双参数的 rename 只是多搬两个寄存器而已。

What:代码骨架与逐行含义:mov $0, %%eax 是 EAX 寄存器清 0(time 的参数为 NULL);mov $0xd, %%eax 是使用 EAX 传递系统调用号 13(0xd);int $0x80 触发系统调用;mov %%eax, %0 是通过 EAX 返回系统调用值。输出部分为 "=m"(tt),即 tt 是只读的内存变量(只写回内存)。

How:完整写法与后续处理:

int main(void){
    time_t tt;              /* int 型数值 */
    struct tm *t;
    asm volatile(
        "mov $0, %%eax \n\t"
        "mov $0xd, %%eax \n\t"
        "int    $0x80 \n\t"
        "mov %%eax, %0 \n\t"
        : "=m"(tt));
    t = localtime(&tt);
    printf("time:%d:%d: %d:%d: %d:%d\n", t->tm_year + 1900,
        t->tm_mon, t->tm_mday, t->tm_hour,
        t->tm_min, t->tm_sec);
    return 0;}

注意第一行 mov $0,%%eax 紧接着就被第二行覆盖,它的作用是显式表达「time 的参数为 NULL」,与 C 版 time(NULL) 一一对应。取回结果后仍需 localtime 做时区分解,输出格式与 5.2 的 C 版保持一致,便于对照验证。

易错:把「=m」写成「=a」或反过来——本段刻意用 "=m"(tt) 让结果只写回内存。另外不要漏掉 int $0x80,少了它 EAX 里只是数字 13,什么都不会发生。

必考

5.5 嵌入式汇编触发 rename 双参数系统调用页11页12页13页11

Hook:time 没有参数,所以只要一个 EAX。现在要重命名文件,两个字符串指针往哪儿放?

rename 的系统调用号为 38(0x26),内核处理函数 sys_rename,原型为 asmlinkage long sys_rename(const char __user *oldname, const char __user *newname)。双参数版本:oldname 放 EBX、newname 放 ECX、0x26 放 EAX,int $0x80 触发,返回值从 EAX 取回,0 表示成功。

Why:这是「参数传递规则」从条文变成代码的检验点。32 位 x86 下参数按顺序赋给 EBX、ECX、EDX、ESI、EDI、EBP,所以第 1 个参数进 EBX、第 2 个进 ECX——顺序错一位,内核就会把新文件名当成旧文件名去打开,必然失败。

What:需求是写一段嵌入式汇编,把 hello.c 重新命名为 newhello.c,返回值为 0 表示修改成功。C 版对照:ret = rename(oldname, newname),ret 为 0 打印 Renamed successfully.,否则打印 Unable to rename the file.。汇编版关键三行:movl %2, %%ecx(newname 进 ECX)、movl %1, %%ebx(oldname 进 EBX)、movl $0x26, %%eax(系统调用号 38 进 EAX),最后 int $0x80。

How:完整代码与限定符对应关系:

int main(void){
    int ret;
    char *oldname = "hello.c";
    char *newname = "newhello.c";
    asm volatile(
        "movl %2, %%ecx\n\t"
        "movl %1, %%ebx\n\t"
        "movl $0x26, %%eax\n\t"
        "int $0x80"
        : "=a"(ret) : "b"(oldname) : "c"(newname));
    if( ret == 0)
        printf("Renamed successfully.\n");
    else
        printf("Unable to rename the file.\n");
    return 0;}

读法:输出部分 "=a"(ret) 表示返回值只写进 EAX 并绑定到 ret;输入部分 "b"(oldname) 与 "c"(newname) 表示 oldname 进 EBX、newname 进 ECX,于是模板里 %1 对应 oldname、%2 对应 newname(%0 是输出操作数 ret)。注意模板中先把 %2 搬进 ecx、再把 %1 搬进 ebx,是因为 "b"/"c" 限定符只保证变量在对应寄存器中,显式搬运让意图更清晰。

易错:幻灯片留了一道思考题——把第 9 行的「=a」换成「=m」会发生什么?"=m" 表示结果只写回内存,而系统调用的返回值是通过 EAX 带回的,编译器不再把 EAX 与 ret 绑定,ret 就拿不到真实返回值(可能读到未初始化或旧值)。解决办法是保留 "=a" 绑定 EAX,或在 int $0x80 之后显式把 %%eax 搬到一个 "=m" 的输出操作数上。

必考

5.6 libc 提供的 syscall() 函数页14页14

Hook:如果某个系统调用太新,连 libc 都还没来得及为它写封装函数,你就只能干等吗?

当 libc 没有对某个系统调用做封装时,开发人员无法通过 API 方式触发它;解决办法是使用 libc 提供的 syscall()。原型为 extern long int syscall(long int sysno, ...),sysno 是系统调用号,「...」是系统调用的参数。以 rename 为例:ret = syscall(SYS_rename, oldname, newname)。

Why:嵌入式汇编虽能解决问题,但可读性差、可移植性差。syscall() 提供了一个「通用封装」:不用记寄存器、不用写 int $0x80,只要把系统调用号和参数按顺序传进去,剩下的搬寄存器与陷入内核由 libc 完成。它是「专用 API 缺失」时的兜底方案。

What:核心信息三点:① 触发条件——libc 没有为某系统调用提供封装;② 函数原型——extern long int syscall(long int sysno, ...) __THROW,其中 sysno 是系统调用号,「...」是系统调用的参数;③ 调用范例——ret = syscall(SYS_rename, oldname, newname),用宏 SYS_rename 代替手写 38。

How:与 5.5 的汇编版对照记忆:syscall() 的第一个实参 SYS_rename 就等价于汇编里的 movl $0x26,%%eax;第二、三个实参 oldname、newname 等价于 movl 进 ebx、ecx;函数返回值等价于从 EAX 读回 ret。也就是说 syscall() 把「传号 + 传参 + 触发 + 取返回值」四步全部收进了库函数内部,你在 C 层面只看到一次普通函数调用。三个版本(专用 API、syscall()、嵌入式汇编)实现同一功能,可靠性依次下降、可控性依次上升。

易错:syscall() 的返回值类型是 long int,不是 int;另外第一个参数必须是系统调用号(可用 SYS_xxx 宏),不要把函数名当字符串传进去。

重点

5.7 系统调用三层机制 xyz-system_call-sys_xyz页15页16页15

Hook:从你写下 time() 到内核里 sys_time 真正执行,中间到底经过了几层?这三层各自负责什么、又各自属于谁?

系统调用的三层机制是 xyz() --> system_call --> sys_xyz():xyz() 是封装了一个系统调用的 API 函数,system_call 是中断向量 0x80 的中断服务程序入口,sys_xyz() 是系统调用处理函数。

Why:这三层把前面所有零散知识串成一条完整链路——第一层属用户态(库函数),第二层是跨越态的关口(中断入口),第三层属内核态(真正的服务实现)。记住这条链,就能回答「系统调用到底发生在哪一刻」「哪一层负责保存现场」这类问题。

What:本章小结共五条:① 内核态、用户态、中断;② 系统调用是一种特殊的中断;③ 三层机制——xyz() --> system_call --> sys_xyz();④ 系统调用的触发方式;⑤ 系统调用的参数传递方式。其中第 3 条是骨架,第 4、5 条是填充骨架的两块血肉。

How:把 5.4/5.5 的代码映射到三层:以 rename 为例——xyz() 就是 libc 里的 rename() 或你手写的 syscall(SYS_rename,...) 那一层;system_call 是 int $0x80 进入的中断服务程序入口(对应 entry_INT80_32,内部再调 do_int80_syscall_32);sys_xyz() 是 sys_rename(),它按系统调用号 38 从系统调用表 ia32_sys_call_table 中取出并执行。三层各自的可替换性也不同:第一层可以换成嵌入式汇编,第二层的入口地址由内核初始化时告诉 CPU,第三层只能在改内核时变动。

易错:把 system_call 当成「一个函数调用」。它是中断向量 0x80 对应的中断服务程序入口,是用户态与内核态的分界线;而 sys_xyz() 才是真正干活的内核函数。

必考

问题一:请写出用嵌入式汇编在 32 位 x86 Linux 上触发 rename 系统调用的关键指令序列,并说明每条指令与 C 语句 ret = rename(oldname, newname) 的对应关系。
参考答案关键序列为:movl %2,%%ecx(把 newname 放进 ECX,即第 2 个参数);movl %1,%%ebx(把 oldname 放进 EBX,即第 1 个参数);movl $0x26,%%eax(把系统调用号 38 放进 EAX);int $0x80(触发系统调用)。约束部分写作 : "=a"(ret) : "b"(oldname) : "c"(newname),即返回值只写进 EAX 并绑定到 ret,oldname 绑定 EBX、newname 绑定 ECX。对应关系:C 的函数名 rename 对应系统调用号 0x26 与内核函数 sys_rename;两个实参按 32 位规则依次进 EBX、ECX;C 的返回值 ret 就是 EAX 中带回的值,为 0 表示修改成功。若把 "=a" 改成 "=m",返回值不再与 EAX 绑定,ret 取不到真实结果,需在 int $0x80 之后显式把 %%eax 搬到 "=m" 的输出操作数。
问题二:系统调用的三层机制是什么?请指出每一层分别属于用户态还是内核态,并用 rename 举例说明。
参考答案三层机制为 xyz() --> system_call --> sys_xyz()。xyz() 是封装了一个系统调用的 API 函数,运行在用户态,例如 libc 的 rename() 或 syscall(SYS_rename, oldname, newname);system_call 是中断向量 0x80 的中断服务程序入口,是用户态与内核态的分界关口,由 int $0x80 触发进入(对应 entry_INT80_32,内部调用 do_int80_syscall_32),负责保存现场、按系统调用号分派;sys_xyz() 是系统调用处理函数,运行在内核态,例如 sys_rename(),由系统调用表 ia32_sys_call_table 按 38 号取出执行,完成后恢复现场并由 iret 返回用户态。

章节测试

共 11 题

0
总分

📋 AI批改任务已生成

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

/exampass grade "<路径>"

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