操作系统(一)进程、线程、虚拟内存和IO中断的全流程
本文主要内容如下:
1、操作系统如何管理硬件资源?从开机到运行程序的全流程
2、进程与线程的本质区别,以及为什么需要并发
3、IO中断机制详解:CPU如何高效响应外
4、虚拟内存的魔法:让每个程序都以为自己独占内存
5、结合实例理解操作系统对系统性能的关键影响
第一部分 开机:从加电到第一个进程

1.1 上电后的第一条指令
x86-64 CPU 复位后处于实模式(16 位),CS:IP 被强制设为 F000:FFF0,线性地址 0xFFFFFFF0——主板把固件 ROM 映射到那里。此时:
- 没有页表,没有保护级,没有中断处理程序
- 只有 1MB 可寻址空间(后来靠 A20 线扩展到 4GB)
- 内存控制器还没训练完,DDR 时序都没配
固件(UEFI/BIOS) 接手后做四件事:
| 动作 | 细节 | 为什么和 OS 有关 |
|---|---|---|
| POST 自检 | CPU、内存、PCIe 枚举 | 内存容量通过 e820/ UEFI Memory Map 交给内核 |
| 内存训练 | DDR 时序校准 | 决定可用物理地址范围 |
| 建立 ACPI 表 | MADT(每核 LAPIC ID)、SRAT(NUMA)、FADT | 内核靠 MADT 知道有几个核 |
| 提供启动服务 | Block IO、文件系统、变量读写 | bootloader 靠它读磁盘 |
UEFI 本身是一个小型 OS(DXE 驱动模型、事件、协议),它跑在 ring 0。Secure Boot 在这一步验证 bootloader 的签名。
1.2 bootloader:把内核“搬”进内存
以 GRUB 为例:
- 读 EFI 系统分区里的
grubx64.efi - 解析
grub.cfg,决定启动哪个内核 - 把
vmlinuz(bzImage:头部 setup 代码 + 压缩的内核)和initrd.img读进内存 - 填好
boot_params:e820 内存图、ACPI RSDP 指针、命令行、initrd 地址 - 调
ExitBootServices()——从这一刻起固件的服务全部失效,只能靠内核自己 - 跳转到内核入口
关键认知:bootloader 不“启动操作系统”,它只是把内核镜像放到内存并交出 CPU。之后的一切都是内核自己搭建的。
1.3 内核自举:进入长模式
vmlinuz 的执行是两段式的:
第一段(16/32 位 setup 代码):校验 CPU、计算解压后的位置、把压缩内核解压到高地址、跳过去。
第二段(startup_64)——这里发生了三件决定命运的事:
# arch/x86/kernel/head_64.S 的核心动作(简化)
mov %cr4, %rax
or $X86_CR4_PAE, %rax # 开启物理地址扩展
mov %rax, %cr4
mov $MSR_EFER, %ecx
or $EFER_LME, %eax # 开启长模式(Long Mode Enable)
wrmsr
mov $early_top_pgt, %rax # 装上临时页表
mov %rax, %cr3
mov %cr0, %rax
or $X86_CR0_PG, %rax # 开启分页 → 长模式正式生效
mov %rax, %cr0
到这一步:分页已开、内核已映射、但还没有内存分配器、没有中断、没有进程。CPU 在 start_kernel() 里继续。
1.4 start_kernel():操作系统的“宪法时刻”
init/main.c 里的调用顺序,就是操作系统的建造顺序(记住这个顺序,比背概念有用):
start_kernel()
├─ setup_arch() 解析 e820/ACPI/MADT,确定 CPU 数量、NUMA 节点、内存区
├─ trap_init() 建立 IDT(256 个门),装异常处理
├─ mm_init() 建 buddy 分配器、slab/slub、vmalloc、页表缓存
├─ sched_init() 建每 CPU 运行队列、初始化调度类(stop/dl/rt/cfs/idle)
├─ rcu_init() 建 RCU 机制(无锁读的基础设施)
├─ init_IRQ() 建 IOAPIC 路由、中断描述符
├─ time_init() 选 clocksource、注册时钟中断、启动 tick
├─ console_init() 打开串口/VGA 输出(之后才看得到内核日志)
└─ rest_init()
├─ kernel_thread(kernel_init) → PID 1
├─ kernel_thread(kthreadd) → PID 2(所有内核线程之父)
└─ cpu_startup_entry() → 变成 idle 进程,进入 idle 循环
注意:PID 0(swapper/idle)就是 start_kernel 这个执行流本身,它是唯一没有通过 fork 产生的“进程”。
随后 SMP 启动:内核向每个 AP(Application Processor)发 INIT-SIPI-SIPI,各核从 secondary_startup_64 进入,各自建栈、初始化 LAPIC、加入调度。4 个 core 是这样陆续到达的(图1 的四方格)。
1.5 根文件系统与 initramfs
内核要执行 /sbin/init,但“/”在哪?两种路径:
- 有 initramfs:内核把
initrd.img(cpio 归档)解压进 rootfs(ramfs/tmpfs),执行里面的/init脚本。脚本加载磁盘/文件系统驱动(如nvme、ext4、dm-crypt),挂载真实根,然后switch_root切换根并 exec 真正的 init。这是为了把“读懂磁盘”所需的最小驱动集合提前准备好。 - 无 initramfs:内核直接用
root=/dev/nvme0n1p2挂载,要求存储和文件系统驱动都编译进内核。
1.6 PID 1 与用户态的诞生
kernel_init 最后调用 run_init_process("/sbin/init"),内部是 kernel_execve——这是系统里第一次 execve。从此:
- PID 1 是所有用户态进程的祖先
- 所有孤儿进程会被 reparent 给它(或最近的 subreaper)
systemd读取 unit、构建依赖事务、并行启动服务、用 cgroup v2 给每个服务划资源、socket activation 按需拉起守护进程- 最后启动
getty/显示管理器 → 会话 → shell 或桌面合成器

1.7 双击图标后的完整链路
合成器收到点击
→ fork() 复制 task_struct、FD 表、COW 地址空间 [图3]
→ execve("/usr/bin/editor") 丢弃旧 mm,映射新 ELF 的 text/data/heap/stack
→ 动态链接器 ld.so 加载 libc/Qt/ffmpeg(mmap 共享库)
→ main() 里创建窗口:向 Wayland/X11 socket 发请求(写一个 fd) [图3 的 file descriptors]
→ 读字体/图标/素材:page cache 未命中 → 发起磁盘 IO → TASK_INTERRUPTIBLE [图5 waiting]
→ 磁盘 DMA 完成 → 中断 → 唤醒 → 回 ready → 调度上某个 core [图1 的 core]
→ mmap 显存 → 逐页缺页 → 内核填页表 → 第一帧画出来
从点击到出画面,几乎每个环节都在用后面要讲的知识点。 这也是为什么这张图把 CPU/RAM/DISK 和进程盒子画在一起——进程的一切行为都是这三者之间的数据搬运。
1.8 开机时间线(量级感)
| 阶段 | 典型耗时 | 运行在 |
|---|---|---|
| 固件 POST + 设备枚举 | 1–10 s(服务器更久) | ring 0,固件 |
| bootloader + 内核解压 | 0.2–1 s | ring 0 |
start_kernel 到 PID 1 | 0.3–1 s | ring 0,内核 |
| systemd 到登录界面 | 1–5 s | ring 3 |
| 应用启动(fork+exec) | 1–1000 ms | 混合 |
观测工具:systemd-analyze blame、dmesg -t、ftrace 的 bootgraph。
第二部分 进程:一台虚拟计算机
2.1 抽象的三件套
图4 第一行 “Abstraction of a simple computer” 是整章的总纲。进程给程序提供的是一台假电脑:
| 真实硬件 | 进程看到的虚拟硬件 | 由谁虚拟化 |
|---|---|---|
| CPU 核心 + 寄存器 | 线程(PC/SP/寄存器上下文) | 调度器 + 上下文切换 |
| 物理内存 | 从 0 开始的连续地址空间 | MMU + 页表 |
| 磁盘、网卡、终端 | 文件描述符(read/write/ioctl) | VFS + 驱动 |
| 时钟、信号 | 定时器、信号 | 内核 |
程序因此可以假设“我独占一台机器”,不需要知道自己被调度、被换出、内存被压缩。这是操作系统最重要的谎言,也是它能同时跑几百个进程的原因。
2.2 task_struct:

把所有字段画成三个盒子,Linux 里它们全在一个结构体里(数 KB):
| 图 里的字段 | 内核字段 | 作用 |
|---|---|---|
PID, PPID, UID, time... | pid、tgid、real_parent、cred、utime/stime | 身份、权限、记账 |
process status | state、exit_state、flags | 图5 的状态 |
file descriptors | files(指向 files_struct) | 打开的文件/socket/管道 |
executables, libraries, heap | mm(指向 mm_struct) | 地址空间 |
threads: user stack | 线程各自的用户栈(在 mm 里) | 函数调用 |
threads: kernel stack | stack(16KB 内核栈) | 系统调用/中断时用 |
threads: priority | prio、static_prio、se.vruntime、rt_priority | 调度 |
| (未画) | thread.cpu_context(sp/pc/callee-saved 寄存器) | 上下文切换的保存点 |
| (未画) | signal、sighand | 信号处理 |
| (未画) | nsproxy、cgroups | 命名空间、资源控制 |
“进程”和“线程”在内核里是同一个结构体,区别只在共享了哪些指针。这一点想通,进程/线程的区别就全通了。
2.3 地址空间布局(图3 右侧)
如图是单个进程的虚拟地址空间。0x0 / 0x100 / 0x200 是教学刻度(真实系统不是这样),但方向是对的:

高地址 0x7fff_ffff_ffff ┌────────────────────┐
│ argv/envp/auxv │ ← 内核在 exec 时写好的
│ program stack ↓ │ ← 向下增长,每线程一份
│ ......guard...... │ ← 保护页,碰到就 SIGSEGV
│ mmap 区(共享库) │ ← libc/Qt/ffmpeg 映射在这
│ ......gap......... │
│ heap ↑ │ ← brk 向上增长,进程内共享
├────────────────────┤
│ .bss(未初始化) │
│ .data(已初始化) │
低地址 0x0000_0000_0040_0000 │ .text(代码,r-x)│ ← ELF 段,可共享
└────────────────────┘
-
constants, data, etc对应.rodata/.data/.bss,program text对应.text - 向下箭头 = 栈增长,向上箭头 = 堆增长,中间的空隙不是浪费,是隔离带
- 每个进程都有这样一套,但物理页完全不同——这就是 MMU 要干的事
补充一个图里没画但极重要的区域:内核空间(x86-64 高 half,0xffff8000_00000000 以上)映射在每个进程页表里,但用户态无权访问(PTE 的 U/S 位为 0)。系统调用时不需要换页表就能进内核,这是性能关键。
2.4 fork() 的内核路径
// 用户态看到的样子
pid_t pid = fork();
if (pid == 0) { /* 子进程 */ }
else if (pid > 0) { /* 父进程,pid 是子进程号 */ }
sys_fork → kernel_clone → copy_process()
├─ dup_task_struct() 复制 task_struct,分配新内核栈,把 pt_regs 放在栈顶
├─ copy_creds() 引用计数 +1(或按需复制)
├─ sched_fork() 设调度实体,子进程初始 vruntime 略大(防止 fork 炸弹霸屏)
├─ copy_files() fd 表引用计数 +1(不是复制文件!)
├─ copy_fs() cwd/umask 共享
├─ copy_sighand()/copy_signal() 信号处理表复制或共享
├─ copy_mm() → dup_mm() → copy_page_range() ★ 关键
├─ alloc_pid() 分配新 PID
└─ wake_up_new_task() 子进程进入 ready 队列
copy_page_range() 是 fork 性能的全部秘密:它不复制物理页,只复制页表,并把父子双方的 PTE 都改成只读(清除 RW 位)。父子共享同一批物理页。
当任何一方写入时:
写只读页 → #PF 缺页异常(错误码 W=1, P=1)
→ do_wp_page() → wp_page_copy()
→ 分配新物理页,拷贝内容,改自己的 PTE 指向新页并恢复可写
这就是 COW(Copy-On-Write)。收益:
fork后立刻exec的场景(shell 跑命令)几乎零拷贝- 数据库
fork做快照备份,只有被改的页才复制 - 缺点:
copy_page_range是 O(页表项数)。一个占 10GB 的进程 fork 一次要复制几百万个 PTE,耗时可达毫秒级。所以高并发服务器用posix_spawn(vfork 语义,不复制页表)或线程池。
一个经典误解:fork 之后父子“变量互不影响”不是靠拷贝,而是靠 COW 延迟拷贝。如果子进程只读不写,物理内存一页都没复制。
fork 返回两次的机制:子进程的返回值是 copy_process 里把 pt_regs->ax 置 0;父进程正常返回子 PID。两者从同一条用户态指令继续,但内核栈和返回值不同。
2.5 execve():换掉灵魂,不换身份
do_execveat_common
→ alloc_bprm / open_exec(打开可执行文件)
→ bprm_execve
→ exec_binprm → search_binary_handler
→ load_elf_binary(ELF 格式)
├─ flush_old_exec() 断开旧 mm(exec_mmap(NULL)),旧地址空间被丢弃
├─ setup_new_exec() 重置信号处理、清 TLS
├─ elf_map() 循环 把 PT_LOAD 段 mmap 进新地址空间(代码只读、数据私有 COW)
├─ set_brk() 设定堆起点
├─ setup_arg_pages() 在新栈顶压入 argc/argv/envp/auxv/AT_RANDOM
└─ start_thread() 设 rip = ELF 入口、rsp = 新栈
要点:
- PID 不变。exec 前后是同一个进程,只是“人格”换了。这也是为什么 shell 能
exec ls把自己变成 ls。 - FD 默认保留,除非设了
FD_CLOEXEC。这就是“重定向”的实现基础:shell 先dup2改 fd 0/1/2,再 exec,新程序继承。 - 信号处理函数被重置为默认(原 handler 的代码地址在新镜像里可能已经不存在了),被忽略的信号保持忽略。
argv/envp是内核拷贝到新栈的,所以 exec 之后修改原数组不影响子进程。- 失败时返回 -1(比如文件不存在、无执行权限、格式错误),成功则永不返回。
- ASLR 在这里生效:栈顶、mmap 基址、PIE 基址、brk 都加随机偏移。
2.6 退出、僵尸与孤儿
exit_group() → do_exit()
├─ 设 PF_EXITING
├─ exit_mm() 释放 mm(若没有别的线程共享),切到 active_mm(内核线程借用上一个进程的页表)
├─ exit_files()/exit_fs()/exit_sem()
├─ exit_notify() 把子进程 reparent 给 subreaper 或 PID 1;给父进程发 SIGCHLD
├─ state = EXIT_ZOMBIE
└─ schedule() ★ 永不返回
之后父进程 wait4() → release_task() 才真正释放 task_struct 和内核栈。
为什么要有僵尸态? 因为退出码必须交付给父进程,而父进程可能还没 wait。这期间进程已死,但 PID 和 PCB 还在——ps 里显示 <defunct>。如果父进程一直不 wait,僵尸会堆积(PID 泄漏)。父进程先死则孤儿被 PID 1 收养并自动回收。
信号与死亡:SIGKILL 和 SIGSTOP 不可捕获/阻塞。SIGKILL 不会立刻杀死进程——它只是设置 TIF_SIGPENDING,进程在下一次返回用户态或从可中断睡眠中被唤醒时才死。所以卡在不可中断睡眠(D 状态,等磁盘)的进程连 kill -9 都杀不掉,只能等 IO 超时。
2.7 状态机:把四个圈翻译成内核字段

| 状态 | Linux state | 在哪里排队 | 谁能把它弄走 |
|---|---|---|---|
| ready | TASK_RUNNING 且不在 CPU 上 | 每 CPU 的 runqueue(红黑树) | 调度器 |
| running | TASK_RUNNING 且在 CPU 上 | 不在队列 | 时间片耗尽/被抢占/自己阻塞 |
| waiting | TASK_INTERRUPTIBLE / TASK_UNINTERRUPTIBLE | 等待队列(wait_queue_head) | wake_up()(通常由中断调用) |
| killed | EXIT_ZOMBIE → EXIT_DEAD | 无 | 父进程 wait |
为什么 ready 和 running 在内核里是同一个值? 因为“是否在 CPU 上”是瞬时的,用 on_cpu 和 runqueue 成员关系表示就够了;教材拆成两个状态是为了讲清楚抢占这件事。
为什么 waiting 不能直接到 running? 三个理由:
- 公平:醒来时可能有更高优先级在等,必须重新比较
- 负载均衡:可能该把它放到别的核
- 抢占安全:中断上下文里不能直接切到用户进程(中断还没退完)
所以 wake_up() 只做“入队 + 必要时设重调度标志”,真正的切换发生在中断/系统调用返回前的 schedule()。
抢占点:preempt_schedule、返回用户态、cond_resched()、自旋锁释放。内核配置 CONFIG_PREEMPT 决定内核态能否被抢占(影响延迟,桌面发行版通常开 PREEMPT_DYNAMIC/PREEMPT_RT 相关选项)。
第三部分 线程:共享地址空间的执行流
3.1 本质区别(深入版)
| 维度 | 进程 | 线程 | 内核里差在哪 |
|---|---|---|---|
| 地址空间 | 独立 mm_struct | 共享同一个 mm | CLONE_VM |
| 页表 | 独立 CR3 | 同一个 CR3 | 无切换成本 |
| 文件描述符 | 独立 files_struct | 共享 | CLONE_FILES |
| 信号处理 | 独立 sighand | 共享 handler 表 | CLONE_SIGHAND |
| 信号屏蔽/待处理 | 独立 | 独立(CLONE_THREAD 下按线程) | — |
| 栈 | 主线程栈 + 各线程栈 | 各线程独立用户栈 | CLONE_SETTLS 设 TLS |
| 内核栈 | 每线程一份 16KB | 同左 | 必须独立 |
| 调度 | 每进程一个实体 | 每线程一个调度实体 | task_struct 级别 |
| 切换成本 | 换页表 + TLB | 只换栈和寄存器 | 差一个数量级 |
| 崩溃影响 | 只死自己 | 全进程死 | 共享地址空间 |
Linux 的实现哲学:没有“线程”这个类型,只有 task_struct,共享程度由 clone() 的 flag 组合决定。pthread_create 最终就是:
clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
CLONE_THREAD | CLONE_SYSVSEM | CLONE_SETTLS |
CLONE_PARENT_SETTID | CLONE_CHILD_CLEARTID, ...)
CLONE_THREAD 让新任务的 tgid 等于组长的 pid,于是 /proc/<pid>/task/ 下能看到所有线程。getpid() 返回 tgid(线程组 ID),gettid() 才返回自己的 tid——这是很多 bug 的来源。
3.2 上下文切换到底贵在哪
一次进程切换的完整开销:
| 开销项 | 量级 | 说明 |
|---|---|---|
| 保存/恢复 callee-saved 寄存器 | ~几十 ns | switch_to 汇编,rbx/rbp/r12-r15 + sp |
| 切换内核栈 | ~ns | 改 sp 即可 |
| FPU/SIMD 状态 | 0 或 ~µs | 惰性保存(TIF_NEED_FPU_LOAD),不用就不存 |
| 换 CR3 + TLB 失效 | 几百 ns ~ µs | 进程切换才有;PCID 可避免全刷 |
| 缓存污染 | 几 µs | 新进程的工作集不在 L1/L2,全部 miss |
| 分支预测器状态 | 间接 | Spectre 缓解后更明显 |
| 调度器开销 | ~几百 ns | 红黑树摘除/插入、负载均衡 |
实测典型值:1–5 µs(lmbench -W 或 perf sched)。线程切换因为没有 CR3/TLB 开销,通常只有进程切换的 1/3 左右。
所以:
- 每秒切 10 万次 → 吃掉 10%–50% CPU
- 高并发服务器用 epoll + 线程池,而不是“一连接一线程”
- 实时系统要减少切换(缓冲、批处理)
3.3 调度器:4 个 core 怎么分给 5 个进程


图1 画了 4 个 core,图2 里有 5 个进程盒子。内核的做法:
CFS(完全公平调度,6.6 之后是 EEVDF):
- 每个任务有
vruntime(虚拟运行时间),每 CPU 一棵红黑树按它排序 - 每次选
vruntime最小的跑 - 优先级通过权重影响 vruntime 增长速度:nice 0 权重 1024,nice -20 权重 88761(约 87 倍),nice 19 权重 15
- 目标延迟
sched_latency默认 6ms,最小粒度 0.75ms:任务多时每个时间片被压缩,但不低于最小粒度 - 新任务/唤醒任务的
vruntime会被“补偿”(不低于min_vruntime - 某阈值),避免饿死也避免霸屏 - EEVDF 改用“虚拟截止时间 = 应得时间 + 请求时间”排序,对延迟敏感任务更友好
实时调度:SCHED_FIFO/SCHED_RR,优先级 1–99,永远压过普通任务。默认有 RT throttling(每 1s 最多跑 950ms),防止一个死循环的 RT 线程锁死整机——图里的 music 进程就该用这个。
多核层面:每核一个 runqueue,load_balance 定期迁移任务;sched_setaffinity 绑核;cgroup v2 的 cpu.weight 和 cpu.max 做分组配额。
为什么图1 的四个 core 能跑五个进程而不崩? 时间片轮转 + 抢占。代价是每个进程的响应延迟变长——这就是“导出视频时开会卡”的根本原因,不是 CPU 不够快,是排队。
3.4 并发的收益与代价
收益(三个层次):
- 并行加速:4 线程编码 4 个片段,接近 4×(Amdahl 定律限制在串行部分)
- 延迟隐藏:聊天进程 99% 时间在等网络,阻塞式单线程会让 UI 冻结
- 结构清晰:UI 线程 + 工作线程 + IO 线程是最自然的分解
代价:
// 竞态:counter++ 是 读-改-写 三步
// 两个线程各执行 100 万次,结果常常小于 200 万
counter++;
// 伪共享:两个无关变量落在同一 64B 缓存行
struct { int a; int b; } shared; // 核 A 写 a,核 B 写 b,缓存行来回弹
// 修法:alignas(64) 或各自填充
- 锁:mutex(睡眠锁,可长期持有)、spinlock(忙等,临界区极短)、读写锁、RCU
- 死锁四条件:互斥、持有并等待、不可剥夺、循环等待
- 优先级反转:低优先级持锁 → 高优先级等锁 → 中优先级抢 CPU。解法是优先级继承(PI mutex)
- futex:Linux 的 mutex 在无竞争时完全在用户态完成(一条原子指令),有竞争才进内核睡眠——这是 pthread 性能的关键
第四部分 中断与 IO:CPU 如何不被外设拖死
4.1 问题的本质
CPU 一条指令 ~0.3ns,一次磁盘寻道 ~5ms——差 7 个数量级。如果 CPU 轮询等磁盘,99.999% 的算力浪费。
三种协作模型:
| 模型 | 机制 | CPU 开销 | 适用 |
|---|---|---|---|
| 轮询 polling | CPU 反复读状态寄存器 | 空转 100% | 极低延迟、可预测(如 DPDK、NVMe 轮询模式) |
| 中断 | 设备完成后主动通知 | 空闲时 0,每次有固定开销 | 通用 |
| DMA + 中断 | 设备直接读写内存,完成才中断 | 几乎为 0 | 大块传输的标配 |
4.2 硬件路径:从设备到 CPU
键盘/网卡/磁盘控制器
│ ① 拉高 IRQ 线(传统) 或 写 MSI 消息到 LAPIC 地址(PCIe)
▼
IOAPIC(或 MSI 直达 LAPIC)
│ ② 按路由表选择目标 CPU 核 + 中断向量号
▼
目标 CPU 的 LAPIC
│ ③ 在当前指令边界采样,压栈 CS/EIP/EFLAGS,查 IDT
▼
IDT[vector] → 入口 stub → common_interrupt → do_IRQ()
细节:
- IDT 256 项:0–31 是异常(#PF、#GP、#DB…),32–255 是外部中断和系统调用
- MSI/MSI-X:PCIe 设备直接写一个内存地址(LAPIC 的 MSI 窗口),不需要共享 IRQ 线,天然支持每队列绑不同核——现代网卡/ NVMe 都这么干
- 中断亲和性:
/proc/irq/<n>/smp_affinity决定哪个核处理,多队列网卡按流哈希分散 - NMI:不可屏蔽中断,用于看门狗、性能计数器、紧急事件
- SMI:固件接管,OS 完全看不见(也是延迟抖动来源)
4.3 软件路径:上半部与下半部
// 典型的中断处理流程(简化)
do_IRQ(regs)
→ irq_enter() 标记进入中断上下文
→ generic_handle_domain_irq() 找到 irq_desc,遍历 action 链
→ action->handler() ★ 上半部:你的驱动 ISR
→ irq_exit() 退出中断上下文
→ invoke_softirq() 执行挂起的软中断(或唤醒 ksoftirqd)
上半部(hardirq)的铁律:
- 不能睡眠(不能
kmalloc(GFP_KERNEL)、不能拿 mutex、不能访问用户内存) - 要极短(微秒级),因为同核中断被屏蔽(或至少同优先级)
- 只做:读状态、应答设备、清中断标志、把数据搬进队列、调度下半部
为什么要拆? 因为中断处理期间:
- 同核其他中断被延迟 → 中断延迟
- 长时间关中断会导致丢中断、时钟漂移、网络丢包
- 内核有 soft lockup 检测器,硬中断里死循环会报警甚至 panic
下半部三种机制:
| 机制 | 上下文 | 能否睡眠 | 并发性 | 典型用途 |
|---|---|---|---|---|
| softirq | 软中断上下文 | 否 | 同类型可在多核并行 | 网络收包(NET_RX)、块层、定时器、RCU |
| tasklet | 软中断之上 | 否 | 同一 tasklet 串行 | 老驱动、简单延后工作 |
| workqueue | 内核线程 | 能 | 可配并发 | 需要睡眠的收尾、文件系统、驱动初始化 |
| threaded IRQ | 专用内核线程 | 能 | 按需 | 现代驱动的首选(request_threaded_irq) |
softirq 只有 10 个固定类型(HI、TIMER、NET_TX、NET_RX、BLOCK、TASKLET、SCHED、HRTIMER、RCU),所以不能随便加;workqueue 可以动态创建。
ksoftirqd:软中断负载过高时,从 irq_exit 里转交给每核的 ksoftirqd/N 内核线程,避免用户进程被无限延迟——这是“软中断不能饿死用户态”的保护。
4.4 DMA:让 CPU 完全不搬数据
无 DMA: 磁盘 → CPU 读端口 → CPU 写内存(每字节都过 CPU)
有 DMA: 磁盘控制器 ──直接写──> 内存,完成后发一个中断
细节:
- 驱动准备描述符环(descriptor ring):每项含内存地址、长度、方向
- 设备按环取描述符,总线主控(bus master)直接读写内存
- scatter-gather:一次传输多个不连续缓冲区,避免大块连续内存
- IOMMU:给设备做地址翻译 + 隔离,防止设备 DMA 到任意物理内存(安全 + 支持 >4GB 地址)
- coherent vs streaming 映射:前者保证 CPU/设备看到一致数据(慢),后者需要显式
dma_sync_*(快) - bounce buffer:设备只能访问低 4GB 时,内核用中间缓冲区中转
这就是为什么 read() 一个大文件时 CPU 占用很低——搬运是设备干的,CPU 只在开始时下命令、结束时处理中断。
4.5 时钟中断:调度器的心跳
- 每个核有 LAPIC timer,可编程为单次或周期
- 内核用 hrtimer(红黑树,纳秒精度)管理定时器
jiffies/HZ是粗粒度节拍(通常 250 或 1000)- NO_HZ / tickless:空闲核关闭周期 tick,省电;有定时任务时用单次触发
- 时钟中断负责:时间片记账、触发抢占、更新墙钟、喂 RCU、统计

图中的 running → ready 这条箭头,绝大多数情况就是时钟中断里设置的 TIF_NEED_RESCHED 造成的。
4.6 系统调用不是中断(但很像)
传统 int 0x80 | 现代 syscall | |
|---|---|---|
| 指令 | 软中断 | 专用指令(AMD 引入,Intel 跟进) |
| 入口 | IDT 第 0x80 项 | MSR_LSTAR 寄存器指向的入口 |
| 开销 | 高(查 IDT、权限检查) | 低(~100–300ns) |
| 参数 | ebx/ecx/edx… | rdi/rsi/rdx/r10/r8/r9,号在 rax |
| 返回 | iret | sysret |
共同点:都是特权级切换(ring 3 → ring 0),都要保存现场、切换栈、检查参数(copy_from_user)、返回时可能触发调度。KPTI(Meltdown 缓解)让每次系统调用多一次页表切换,成本大约翻倍——这就是为什么现代内核大量使用 vDSO(把 gettimeofday 之类做成用户态可直接读的共享页,不陷内核)。
4.7 观测与调优
cat /proc/interrupts # 每个 IRQ 在每个核上的计数,看是否集中在一个核
cat /proc/softirqs # 软中断分布
perf top -e irq:softirq_entry
ftrace: irqsoff # 关中断最长的时间段
cyclictest -t1 -p99 # 实时延迟测量
ethtool -l eth0 # 网卡队列数
调优方向:中断亲和性分散、RPS/RFS(软件收包分发)、NAPI 预算、中断合并(ethtool -c)、把耗时 ISR 改成线程化中断。
第五部分 虚拟内存:图6 和图7 的完整故事
5.1 要解决的四个问题
- 隔离:进程 A 不能读写进程 B 的内存
- 超发:虚拟空间总和可以大于物理内存
- 碎片:不需要大块连续物理内存
- 共享与懒加载:同一份 libc 只存一份;不用到的页不分配
一个机制解决四个问题:给每个进程一套页表,MMU 在每次访存时翻译。
5.2 MMU 是翻译官

CPU 发出 0x12345(虚拟地址)
│
▼
┌─────────┐ 查页表(TLB 命中则跳过)
│ MMU │ ──────────────────────┐
└─────────┘ │
│ 翻译结果 │
▼ ▼
0x83145(物理地址) 页表在内存里
│
▼
RAM
MMU 是 CPU 内部的硬件,不是软件。它做三件事:
- 把虚拟地址拆成
页号 + 偏移 - 查页表(或 TLB)拿到物理页框号
- 检查权限位(读/写/执行/用户态),不合法就发 #PF 异常
每个进程有自己的页表,切换进程时写 CR3 就换了整套映射。同一个虚拟地址在不同进程里指向不同物理页——这就是隔离的物理基础。
5.3 页表结构与地址翻译(含完整算例)

图7中的教学设定:页大小 0x100(256 字节,8 位偏移)。真实 x86-64 是 4KB(12 位偏移),但算法完全一样。
第一步:拆分地址
虚拟地址 0x2C8 = 二进制 0010 1100 1000
页号 = 0x2C8 >> 8 = 0x2
偏移 = 0x2C8 & 0xFF = 0xC8
第二步:查页表第 2 项(图里绿色高亮那行)
索引 标志位 物理页框
0 1 1 -
1 0 1 -
2 1 1 9 ← 命中!present=1,location=9
3 0 1 -
...
第三步:拼物理地址
物理地址 = 页框号 × 页大小 + 偏移
= 9 × 0x100 + 0xC8
= 0x9C8
图里绿色箭头从 Page Map 第 2 行指向 Physical Memory 的第 9 格,就是这个意思。
那两列标志位是什么? 图里标 D / R,不同教材字母不同,但作用固定:
| 位 | 含义 | 谁设置 | 用途 |
|---|---|---|---|
| present / valid | 页在不在物理内存 | 内核 | 0 则访问触发缺页 |
| dirty (D) | 有没有被写过 | 硬件自动置位 | 换出前必须写回磁盘,否则丢数据 |
| referenced (R) | 最近有没有被访问 | 硬件自动置位 | 给页面回收算法做“二次机会”判断 |
| location | 物理页框号 | 内核 | 翻译结果 |
| (真实 PTE 还有) | 读写/执行/用户/全局/NX | 内核 | 权限与安全 |
为什么要有 D 和 R? 因为页表不只是“地图”,还是记账本。物理内存有限,必须挑页换出:
- 用 R 位近似 LRU(clock 算法:扫一圈,R=1 的清零放过,R=0 的淘汰)
- 用 D 位决定淘汰时要不要先写磁盘(干净页直接丢弃,脏页必须回写)
这两个位由 MMU 硬件自动维护,操作系统只读——这是软硬件协作的经典设计。
5.4 真实 x86-64:四级页表
48 位虚拟地址拆成 5 段:
47 39 38 30 29 21 20 12 11 0
┌──────────┬─────────┬─────────┬─────────┬───────────┐
│ PML4 idx │ PDPT idx│ PD idx │ PT idx │ offset │
│ 9 bits │ 9 bits │ 9 bits │ 9 bits │ 12 bits │
└──────────┴─────────┴─────────┴─────────┴───────────┘
│ │ │ │
CR3 → PML4 → PDPT → PD → PT → 物理页
每级表 512 项 × 8 字节 = 4KB,正好一页。
为什么不用单级页表? 48 位地址空间有 2^36 个页,单级表要 512GB——每个进程都建一张,内存瞬间爆炸。多级表让未使用的区域不建表:一个只用了几 MB 的进程,页表开销只有几十 KB。
代价是一次翻译最多 4 次内存访问(每级一次)。所以需要 TLB。
算例(真实地址):0x00007f3a2c4d5e6f
offset = 0xe6f
PT idx = (addr >> 12) & 0x1ff
PD idx = (addr >> 21) & 0x1ff
PDPT idx = (addr >> 30) & 0x1ff
PML4 idx = (addr >> 39) & 0x1ff
5.5 TLB:地址翻译的缓存
| 层级 | 典型容量 | 命中延迟 |
|---|---|---|
| L1 dTLB | 64 项 | ~1 周期(与 L1 cache 并行) |
| L2 STLB | 1536 项 | ~7 周期 |
| 页表遍历(命中 cache) | — | ~20–50 周期 |
| 页表遍历(全 miss) | — | ~100+ 周期(4 次内存访问) |
关键机制:
- PCID(Process Context ID):CR3 里带 12 位进程 ID,切换进程时不必全刷 TLB,只换 ID。这让进程切换便宜了很多
- 大页:2MB 页(PDE.PS)跳过一级,1GB 页(PDPTE.PS)跳过两级;TLB 覆盖范围放大 512/262144 倍。THP(透明大页)自动合并
- TLB shootdown:改了一个被多核共享的映射,必须发 IPI 让其他核失效对应 TLB 项——这是
munmap大区域慢的原因之一 - ASID/PCID 用尽:会触发 flush
这解释了两个现象:
- 进程切换贵,因为 TLB 冷启动
- 大页对数据库/虚拟化性能提升巨大,因为 TLB 覆盖范围
5.6 缺页异常:虚拟内存的“兜底”
访问虚拟地址
→ MMU 查 PTE:present = 0
→ 触发 #PF,CPU 把出错地址写入 CR2,错误码入栈
→ 内核 do_page_fault() → handle_mm_fault()
├─ 匿名页首次写:分配零页 → 填 PTE(minor fault)
├─ COW 写:分配新页 + 拷贝(minor fault)
├─ 文件页:从 page cache 找;没有则读磁盘(major fault)
├─ 栈增长:扩展 VMA
├─ swap:从交换区读回
└─ 非法访问:发 SIGSEGV
→ 返回用户态,重新执行那条指令(这次成功)
错误码位(x86):P(0=不存在,1=权限不足)、W/R(写还是读)、U/S(用户态还是内核态)、RSVD、I/D(取指)。内核靠它区分“缺页”和“越权”。
minor vs major:
| 类型 | 触发 | 延迟 |
|---|---|---|
| minor fault | 页在内存但没映射(COW、零页、page cache 命中) | ~0.5–2 µs |
| major fault | 需要读磁盘/swap | SSD ~100µs,HDD ~5–10ms |
这就把虚拟内存和图5 的 waiting 状态连起来了:major fault 时进程进入 TASK_UNINTERRUPTIBLE,等磁盘 DMA 完成的中断把它唤醒。内存不足时程序“变慢”不是 CPU 降频,是缺页率飙升、大量时间在等磁盘,这叫 thrashing(抖动)。
5.7 页面回收与 swap
物理内存不够时的完整链条:
空闲页低于 low watermark
→ 唤醒 kswapd(每 NUMA 节点一个)
→ 扫描 LRU 链表:inactive anon / active anon / inactive file / active file
→ 用 PTE 的 R 位做二次机会,把“冷页”降到 inactive
→ 淘汰:
干净文件页 → 直接丢弃(还能从磁盘再读)
脏文件页 → 回写后丢弃
匿名页 → 写入 swap(需 D 位判断是否已回写)
→ 如果回收速度跟不上分配速度 → 直接回收(分配者自己扫,卡顿)
→ 还不够 → OOM killer 按 oom_score 杀进程
相关旋钮:vm.swappiness、vm.min_free_kbytes、vm.dirty_ratio、vm.overcommit_memory、zswap/zram。
5.8 mmap、COW、page cache:三个高频场景
① mmap 文件 = 把文件当数组
int fd = open("video.mp4", O_RDONLY);
void *p = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
// 之后 p[i] 就是文件第 i 字节,缺页时内核从磁盘读入 page cache
MAP_SHARED:修改写回文件,多进程可见MAP_PRIVATE:COW,修改不落盘MAP_ANONYMOUS:malloc 大块内存的底层实现(glibc 超过 128KB 走 mmap)- 好处:零拷贝(不用 read 到用户缓冲区)、按需加载、多进程共享同一份 page cache
② page cache = 磁盘的缓存层
所有文件读写都经过它。read() 命中 cache 是纯内存拷贝(~GB/s),未命中才触发磁盘 IO。write() 默认只写 cache(不是落盘),由 writeback 线程按 dirty_ratio 周期回写;fsync() 强制落盘——数据库的 WAL 就靠它保证持久性。
③ COW = fork 的零拷贝魔法(见 2.4)
第六部分 把知识合起来:那台 4 核机器的性能故事
场景:视频导出 + 聊天 + 听歌 + 数据库(对应图2 的五个盒子)。
| 进程 | 负载类型 | 主要瓶颈 | 起作用的 OS 机制 | 优化手段 |
|---|---|---|---|---|
| video editor | CPU 密集、可并行 | 4 核占满、缓存带宽 | 调度器、多线程、大页 | 分片并行、绑核、避免伪共享、SIMD |
| chat | IO 密集(网络) | 唤醒延迟 | 中断、等待队列、epoll | 提高优先级、epoll 而非阻塞读、减少拷贝 |
| music | 周期性强实时 | 中断/调度延迟 | RT 调度、关中断时长 | SCHED_FIFO + 足够 buffer、线程化中断 |
| database | 随机 IO + 内存 | 缺页、fsync、page cache | 页表、脏页回写、COW | 加大 buffer pool、NVMe、批量提交、O_DIRECT |
四个可观测现象及其解释:
- 导出时开会卡:5 个进程抢 4 个核,CFS 给每个进程分时间片,响应延迟从 µs 级涨到 ms 级。不是 CPU 变慢,是排队。
- 内存吃紧时导出突然变慢,CPU 占用反而不高:major fault 让进程频繁进 waiting 等磁盘(图5 + 图7)。
vmstat里si/so上升、us下降就是信号。 - 数据库备份瞬间完成:
fork()的 COW,子进程零拷贝拿到快照,只有被改的页才复制。 - 上下文切换是隐形税:
perf sched能看到每秒几万次切换,每次 1–5µs 外加缓存污染。线程不是越多越好。
一条经验公式:
程序性能 = 有效计算 ÷(计算 + 内存停顿 + IO 等待 + 调度开销) 操作系统负责后三项,而它们往往占大头。
第七部分 常见误解澄清
| 误解 | 真相 |
|---|---|
| fork 会复制内存 | 只复制页表,物理页 COW 共享,写入才复制 |
| exec 会创建新进程 | 只替换地址空间,PID 不变 |
| 线程比进程快 | 创建/切换快,但共享内存要加锁,可能更慢 |
| 虚拟内存 = swap | 虚拟内存是地址翻译机制;swap 只是它的一种后备存储 |
| 内存越大程序越快 | 超过工作集后,缺页和 TLB 才是瓶颈;NUMA 还会引入远端访问 |
| 中断处理越短越好所以都丢给 workqueue | workqueue 有调度延迟;高频短任务用 softirq 更合适 |
kill -9 一定能杀死 | D 状态(不可中断睡眠)等 IO 的进程杀不掉 |
| 多线程一定比多进程好 | 隔离性、崩溃影响、调试难度都要权衡 |
| CPU 占用 100% 就是性能瓶颈 | 可能是在自旋等锁,或者在软中断里收包 |
| 页表越大越慢 | 多级页表让稀疏地址空间开销很小,慢的是 TLB miss |
openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构
更多推荐



所有评论(0)