应用视角的操作系统

应用视角的操作系统 · 课堂笔记

本次课从应用程序视角审视操作系统。核心思路：操作系统的本质是一组 API，程序通过系统调用与内核交互。一切应用程序——无论多复杂——在操作系统眼中，都是同一种状态机。

核心观点：程序 = 状态机

硬件是状态机：寄存器 + 内存 + 指令驱动的状态迁移。

一个 C 程序，也是一个严格定义的状态机：

初始状态：程序入口（main 被调用前）→ 一个包含 main 栈帧的调用栈，全局变量已初始化。
每个栈帧：包含局部变量、参数，还有一个 PC（当前语句的位置）。
状态迁移：从栈顶帧的 PC 取出语句，执行之；PC 移到下一条。
函数调用：新建一个栈帧压入栈顶，新 PC 指向被调函数入口。
函数返回：弹出栈顶帧，恢复调用者 PC。

数学化的理解

状态 = 所有栈帧 + 全部变量 + 内存；迁移函数：S → S'。用离散数学的集合、函数可以完全精确描述。计算机世界没有魔法，全是数学。

为什么选 C 语言

离机器最近，又能写真实应用。C 被称为高级汇编：

任意复杂的表达式（x = y + z + w）可以改写为每行只做一件小事的形式：

t1 = y + z;      // 一条加法指令
t2 = t1 + w;
x  = t2;

分支、循环都可改写成“判断布尔变量 → 跳转”，与汇编跳转一一对应。
因此编译器可以原样翻译为汇编指令，编译器的正确性容易保证。
对比 C++/JavaScript：函数调用可能涉及虚函数表、类型系统等，映射到机器码需要的复杂推理，离机器太远。

可证明：任何 C 程序都能改写成 simple C（每行一步），然后精确对应到硬件指令。

非递归汉诺塔：检验是否真正理解函数调用

老师课堂调查：在考场中不允许用数学性质推导，直接写一个非递归的汉诺塔——几乎没人敢举手。

递归汉诺塔调用了两次自身（hanoi(n-1, A, C, B) 和 hanoi(n-1, B, A, C)）。调用顺序不能交换，这与数学函数（如 Fibonacci)的“无副作用性”根本不同。

非递归的意义：你必须精确理解函数调用栈的压栈和弹栈。用状态机的视角，模拟器会：

把每个栈帧记为 (PC, n, from, to, via, c1, c2, ...)。
当前栈顶的 PC 决定下一步动作：继续分解任务 / 返回累加步数。
递归调用 = 压新帧；返回 = 弹帧恢复。

C 语言是高级汇编。解释执行 C 程序的模拟器，就是一台精简的计算机。

编译器能做哪些优化

早期编译器“一条语句对应几条指令”，后来发现编译器可以改变程序行为。问题：边界在哪？

关键原则

可优化的

只要不改变程序的可观察输出（系统调用序列），任何只影响内部变量、不向外界输出的代码都可以优化为更短的形式。

死代码删除：x = 1+2+3 若 x 后续不使用，整句可删。
常量折叠：f1() 直接 return 25（2×3+19）。
重复赋值消除：x=1; x=1; 两次 store 合成一次。

不可优化的

所有对外部系统的调用，即 system call。因为外部函数的行为编译器并不知道。程序从“内部状态机”变作“影响外面世界”的时刻，必须严格保留。

编译器正确性的定义：在所有输入下，输出序列完全一致。

系统调用：唯一的门外通道

应用程序能执行的普通指令（add、mov、load/store）只能改变自己进程的寄存器和内存。想要影响外部世界必须借助系统调用指令。

架构	系统调用指令
x86-64	syscall
ARM64	svc #0
RISC-V	ecall

调用方式

x86-64：返回值放 rax，系统调用号放 rax，参数依次放 rdi, rsi, rdx, r10, r8, r9
ARM64：系统调用号放 x8，参数在 x0, x1, x2, x3, x4, x5

关键：执行 syscall 时，程序失去控制权，操作系统接管。OS 检查权限、执行操作（可能挂起进程、写入文件、销毁进程），然后返回。这个过程中程序内部可能发生任何改变，甚至再也不会回来（例如 exit）。

系统调用 = 与上帝签好契约的祈祷。你的程序把控制权完全交给操作系统，眼睛一闭，醒来一切已改变。

最小 Hello World：没有 C 库的支持

普通的 hello.c 编译出来有 70+ KB，链接了很多库代码。如果用纯汇编，直接调用两个系统调用就够了：

mov x0, #1          // fd: stdout

adr x1, msg         // 缓冲区

mov x2, #13         // 长度

mov x8, #64         // syscall: write

svc #0

mov x0, #0

mov x8, #93         // syscall: exit

svc #0

msg: .ascii "Hello World\n"

这条 svc 是进入 OS 的“最后一班车”：

把参数放到固定寄存器
触发软件中断 → 跳入内核
OS 执行完再返回（或永不返回）

用 gdb 单步跟踪时，可以看到 write 系统调用打印出 Hello World，然后再执行 exit 退出。这就是程序运行的全部真相。

众生平等：所有程序都是同一个东西

你在桌面上看到的 VS Code、浏览器、终端模拟器、OBS……本质上都和上面那个最小 Hello World 毫无区别：

都是可执行文件（ELF/二进制）；
都是被操作系统加载的进程；
同样通过 syscall 请求系统服务；
同样拥有自己的地址空间和调用栈。

不同之处只在于：复杂程序有大量库代码、运行时、UI 框架……但底层全是同一个模型。

软件栈分层

桌面应用（GTK/Qt → Wayland/X11）

系统服务 / 守护进程（udisksd, 蓝牙, cron）

核心工具（GNU Coreutils, shell）

C 标准库 / 运行时

操作系统内核（syscall 接口）

硬件

用 strace 验证一切

strace -f gcc hello.c 可以看到 gcc 创建子进程、调用汇编器、链接器、删除临时文件的全过程。一个最简单的程序就可能产生 2249 次系统调用。

在 AI 时代，不再需要手工 grep 过滤日志。直接问 AI："帮我分析 strace 的输出，解释 gcc 的调用流程"，它会自动提取进程树、系统调用序列、文件操作并画成图。

关键案例

文本编辑器（如 xedit）的主要系统调用是 poll/read/write，通过 Wayland 协议与窗口管理器通信；VS Code 本质完全一样，只是多了更多的 IPC 与文件操作。

一切皆文件、一切皆系统调用——操作系统就是这样看待世界。

计算机世界没有魔法，都是数学。你看到的每一个程序，不过是有一个虚拟 PC 的状态机。

📌 行动建议

回顾本课的例子，用 gdb 单步跟踪任意简单 C 程序，观察函数调用时栈帧的变化。
尝试把汉诺塔改写为非递归版本，在自己的机器上跑通。
使用 strace -f 跟踪一个图形程序（如 xedit、VS Code）启动时的系统调用序列，交给 AI 解读。
读一次老师的“最小 Hello World”汇编代码，理解系统调用的寄存器约定。

结尾总结

程序 = 状态机：PC + 栈帧 + 变量，执行语句就是状态迁移。

编译器只要保证系统调用序列不变，其它都可优化。

操作系统 = 一组 API：每条 API 通过系统调用指令触发，程序完全交出控制权。

所有应用程序——无论是最小汇编 hello world 还是 VS Code ——在操作系统面前完全一样，都是调用系统调用的普通进程。