书籍 / 计算机是怎么工作的
第 15 章

操作系统是个大管家

操作系统是个大管家

想象一家五星级酒店。前台、餐厅、客房服务、保安——每个部门各司其职，但背后有个总经理统筹全局：安排资源、协调冲突、保证每位客人的体验互不干扰。操作系统就是这个总经理，而运行在它上面的每个程序，就是入住的客人。

你打开浏览器、播放音乐、下载文件——这三件事同时发生时，是谁在决定谁能用多少 CPU？谁能访问哪块内存？谁能向哪个磁盘写数据？答案是操作系统。它是所有软件和硬件之间的调停者，是让混乱变成秩序的那层"魔法"。

Level 1：建立直觉

操作系统的三大职责

第一：资源管理

你的电脑有一个 CPU（或多个核心）、16GB 内存、一块 SSD。同时运行着几十个程序。操作系统负责把这些资源公平（或按优先级）分配给每个程序，让大家都能得到服务。

第二：抽象硬件

你写 Python 代码时，只需要 open('file.txt')，不需要知道文件存在哪个磁盘扇区、用什么总线协议传输。操作系统把复杂的硬件差异藏起来，提供统一的接口。

第三：保护隔离

一个崩溃的程序不能毁掉整个系统。操作系统确保每个程序在自己的"沙盒"里运行，相互不干扰。

内核：操作系统的核心

操作系统分为两层：

用户空间（User Space）
  ├── 浏览器
  ├── 播放器
  ├── Word
  └── ...

─────────────────── 系统调用接口 ───────────────────

内核空间（Kernel Space）
  ├── 进程管理
  ├── 内存管理
  ├── 文件系统
  ├── 设备驱动
  └── 网络协议栈

内核运行在特权模式（Ring 0），可以直接访问硬件。用户程序运行在非特权模式（Ring 3），想要访问硬件必须通过**系统调用（syscall）**请求内核代劳。

有意思的是：你每天用的那些"软件功能"，大部分都是幻觉——是操作系统在精心维护的幻觉。你的程序"以为"自己独占 CPU、独占内存，实际上操作系统一直在偷偷切换和分时共享。

系统调用：跨越边界的请求

当 Python 执行 print("hello") 时，底层发生了什么？

Python print()
  → C 库 printf()
    → C 库 write()
      → syscall write（系统调用 nr=1）
        → 内核 sys_write()
          → 设备驱动
            → 终端输出

每次系统调用都要从用户模式切换到内核模式，完成后再切换回来。这个"特权级切换"大约需要 100-300 纳秒——不算慢，但频繁调用会累积开销。

Linux 目前有约 350 个系统调用。常用的几个：

read(fd, buf, count)   // 读文件
write(fd, buf, count)  // 写文件
open(path, flags)      // 打开文件
fork()                 // 创建进程
exec(path, args)       // 执行程序
exit(status)           // 退出进程
mmap(...)              // 内存映射
socket(...)            // 创建网络连接

操作系统的启动过程

计算机开机时发生什么？

1. 上电 → CPU 从固定地址（0xFFFF_FFF0）开始执行
2. BIOS/UEFI 运行：检测硬件、初始化内存
3. 引导程序（Bootloader）：从磁盘加载内核
4. 内核初始化：设置内存、中断、驱动
5. 启动第一个进程（Linux: init/systemd，PID=1）
6. PID 1 启动所有服务和 shell
7. 用户登录，一切就绪

整个过程在现代 SSD 机器上约 10-20 秒。有意思的是，步骤 1 的地址 0xFFFF_FFF0 是 x86 的历史遗留：1978 年的 8086 处理器就用这个入口地址，40 年后的 CPU 依然保持兼容。

Level 2：原理剖析

内核架构：宏内核 vs 微内核

宏内核（Monolithic Kernel）：所有核心功能（文件系统、驱动、网络）都在同一个内核地址空间里运行。

微内核（Microkernel）：内核只保留最基本的功能（进程管理、IPC、基本内存管理），其他服务跑在用户空间。

宏内核结构：
┌─────────────────────────────┐
│  文件系统 │ 驱动 │ 网络  │ 进程 │  ← 全在内核空间，Ring 0
└─────────────────────────────┘

微内核结构：
┌─────────────────────────────┐
│  文件服务 │ 驱动服务 │ 网络服务 │  ← 用户空间，Ring 3
└──────────────────────────────┘
         ↓ 消息传递（IPC）
┌─────────────────────────────┐
│  IPC │ 基本内存 │ 线程调度    │  ← 极简内核，Ring 0
└─────────────────────────────┘

Linux 选择了宏内核，但加了可加载内核模块（LKM）——驱动可以动态加载/卸载，不用重启内核。你装了一个新打印机，modprobe 一下，驱动就加载进去了。

有意思的是，这个争论很有名：1991 年 Linus Torvalds 和 Andrew Tanenbaum（Minix 作者）在新闻组上就"宏内核 vs 微内核"激烈辩论，Tanenbaum 认为宏内核是"过时的设计"。结果嘛，Linux 成了全球最广泛使用的操作系统，Minix 则主要用于学术教学——不过有意思的是，Intel ME（管理引擎）芯片里跑的就是 Minix，所以 Minix 其实是出货量最大的操作系统……

混合内核（Hybrid Kernel）：Windows NT 和 macOS XNU 其实是混合架构——部分服务运行在内核态（为了性能），部分在用户态（为了稳定性）。

中断：硬件向软件说话的语言

CPU 如果要不断"轮询"每个设备"你有数据吗？"会浪费大量时间。更聪明的方式是中断：设备有事才主动"拍一下"CPU 的肩膀。

中断类型：
├── 硬件中断（IRQ）
│   ├── 时钟中断（每1ms）：触发调度器
│   ├── 键盘中断：按键了
│   ├── 网卡中断：收到数据包
│   └── 磁盘中断：I/O 完成
├── 软件中断（syscall）
│   └── 用户程序主动请求内核服务
└── 异常（Exception）
    ├── 除零错误（SIGFPE）
    ├── 页面缺失（Page Fault）
    └── 非法指令（SIGILL）

中断处理流程：

1. 设备触发中断信号（IRQ 线）
2. CPU 完成当前指令，保存寄存器状态到栈
3. 从中断描述符表（IDT）找到对应处理函数
4. 跳转到中断处理程序（ISR）
5. 处理完成，恢复寄存器，IRET 指令返回

现代系统每秒发生成千上万次中断。Linux 的时钟中断默认每秒 1000 次（CONFIG_HZ=1000），每次都触发调度器检查是否需要切换进程。

中断延迟是实时系统的关键指标。工业控制系统要求中断响应时间 < 1 微秒；普通 Linux 内核的中断延迟可能高达几毫秒（因为中断可能被暂时屏蔽）。这就是为什么需要 PREEMPT_RT 补丁——将 Linux 改造成实时内核。

设备驱动：内核与硬件的翻译官

Linux 内核代码约 3000 万行，其中驱动占了 60% 以上。这是因为世界上有数以万计的不同硬件，每种都需要独立的驱动程序。

驱动的结构通常是：

// 一个简化的字符设备驱动
struct file_operations mydev_fops = {
    .open    = mydev_open,
    .release = mydev_release,
    .read    = mydev_read,
    .write   = mydev_write,
    .ioctl   = mydev_ioctl,
};

// 用户程序调用 read(fd, buf, len)
// → 内核找到对应的 file_operations
// → 调用 mydev_read()
// → 驱动与硬件通信（读寄存器/DMA）
// → 数据返回给用户

**DMA（Direct Memory Access）**是驱动性能的关键：不让 CPU 亲自搬运数据，而是让 DMA 控制器直接在设备和内存之间传输，CPU 只需发一条命令，DMA 完成后发中断通知。

文件系统接口的统一性

有意思的是，Linux 里一切皆文件：

/dev/sda    → 磁盘设备
/dev/tty    → 终端
/proc/cpuinfo → CPU 信息（虚拟文件，读取时动态生成）
/sys/class/net/eth0 → 网卡配置
/dev/random → 随机数生成器

这个设计来自 Unix 哲学：用统一的文件接口屏蔽一切差异。你可以用 cat /proc/meminfo 查看内存状态，也可以用 echo 1 > /proc/sys/net/ipv4/ip_forward 开启 IP 转发——都是文件操作。

VFS（Virtual File System）层是这一切的基础：

应用程序 open()/read()/write()
          ↓
    VFS 统一接口层
    ↙        ↘
ext4       tmpfs      btrfs     ...
（磁盘）   （内存）   （磁盘）

Level 3 · 规范怎么定义的（资深）

操作系统接口的标准化

操作系统的用户空间接口由 POSIX（Portable Operating System Interface，IEEE Std 1003.1）标准定义。POSIX 涵盖了文件操作（open/read/write/close）、进程管理（fork/exec/wait）、信号处理（signal/sigaction）、线程（pthread_*）、IPC（管道、消息队列、共享内存、信号量）等核心 API。Linux、macOS、FreeBSD 和大多数 Unix 系统都不同程度地遵循 POSIX——这就是为什么一段用 POSIX API 编写的 C 程序可以在这些系统间移植。

系统调用的编号和参数约定由各操作系统独立定义。Linux 的系统调用表在内核源码的 arch/x86/entry/syscalls/syscall_64.tbl 中维护，目前约有 450 个系统调用。x86-64 Linux 使用 SYSCALL 指令进入内核态，系统调用号通过 RAX 传递，参数通过 RDI/RSI/RDX/R10/R8/R9 传递（注意 R10 代替了用户态 ABI 的 RCX，因为 SYSCALL 指令会覆盖 RCX）。

内核架构方面，宏内核（Monolithic Kernel）与微内核（Microkernel）的争论在 1992 年 Linus Torvalds 与 Andrew Tanenbaum 的著名邮件论战中达到高潮。微内核的理论基础来自 Jochen Liedtke 的 L4 系列微内核（1995 年），其 IPC 性能证明了微内核的开销可以降到最低。今天，L4 的后继者 seL4 是世界上第一个经过形式化验证的操作系统内核——其功能正确性和安全属性已被数学证明。

Level 4 · 边界与陷阱（所有人）

陷阱 1：系统调用的开销比你想象的大

一次系统调用需要：保存用户态寄存器→切换到内核栈→执行内核代码→切换回用户栈→恢复寄存器。在 Spectre 补丁（KPTI/Kernel Page Table Isolation）之前，这个过程约 100-200ns；打上补丁后，因为需要额外切换页表（刷新 TLB），延迟增加到 300-800ns。对于像 getpid() 这样简单的系统调用，内核逻辑本身只需几纳秒，99% 的时间花在了进出内核的上下文切换上。这就是为什么 Linux 引入了 vDSO（virtual Dynamic Shared Object）——将 gettimeofday() 等频繁调用的只读数据映射到用户空间，完全避免进入内核。

陷阱 2：驱动 bug 是内核崩溃的头号原因

Linux 内核代码中，约 70% 是设备驱动程序。驱动运行在内核态，拥有最高权限——一个驱动 bug（如空指针解引用、缓冲区溢出）就会导致整个系统崩溃（Kernel Panic）。这就是微内核支持者的核心论点：如果驱动运行在用户态，一个驱动崩溃只会影响那一个驱动进程，而不是整个系统。Windows 的蓝屏（BSOD）绝大多数也是由第三方驱动引起的。Linux 内核的 tainted 标志会记录是否加载了非 GPL 驱动模块，以帮助开发者判断崩溃是否由第三方驱动导致。

陷阱 3：中断风暴可以打垮整个系统

当硬件设备以极高频率产生中断（如网卡在 10Gbps 流量下每秒产生数百万个中断），CPU 可能将大部分时间花在中断处理上，无暇执行用户态程序——这就是"中断风暴"（Interrupt Storm）。Linux 的 NAPI（New API）网络栈通过在高负载时从中断模式切换到轮询模式（polling）来缓解这一问题：不再等硬件通知，而是 CPU 主动去检查。类似地，irqbalance 守护进程会将中断分散到多个 CPU 核心上。如果你的服务器在高网络负载下出现 CPU 使用率 100% 但 %user 几乎为 0（全部是 %softirq），很可能遇到了中断风暴。

本章评分
4.8  / 5  (18 评分)

💬 留言讨论