本文主要内容如下:

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 为例:

  1. 读 EFI 系统分区里的 grubx64.efi
  2. 解析 grub.cfg,决定启动哪个内核
  3. 把 vmlinuz(bzImage:头部 setup 代码 + 压缩的内核)和 initrd.img 读进内存
  4. 填好 boot_params:e820 内存图、ACPI RSDP 指针、命令行、initrd 地址
  5. 调 ExitBootServices()——从这一刻起固件的服务全部失效,只能靠内核自己
  6. 跳转到内核入口

关键认知: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 sring 0
start_kernel 到 PID 10.3–1 sring 0,内核
systemd 到登录界面1–5 sring 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 statusstate、exit_state、flags图5 的状态
file descriptorsfiles(指向 files_struct)打开的文件/socket/管道
executables, libraries, heapmm(指向 mm_struct)地址空间
threads: user stack线程各自的用户栈(在 mm 里)函数调用
threads: kernel stackstack(16KB 内核栈)系统调用/中断时用
threads: priorityprio、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 = 新栈

要点:

  1. PID 不变。exec 前后是同一个进程,只是“人格”换了。这也是为什么 shell 能 exec ls 把自己变成 ls。
  2. FD 默认保留,除非设了 FD_CLOEXEC。这就是“重定向”的实现基础:shell 先 dup2 改 fd 0/1/2,再 exec,新程序继承。
  3. 信号处理函数被重置为默认(原 handler 的代码地址在新镜像里可能已经不存在了),被忽略的信号保持忽略。
  4. argv/envp 是内核拷贝到新栈的,所以 exec 之后修改原数组不影响子进程。
  5. 失败时返回 -1(比如文件不存在、无执行权限、格式错误),成功则永不返回。
  6. 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在哪里排队谁能把它弄走
readyTASK_RUNNING 且不在 CPU 上每 CPU 的 runqueue(红黑树)调度器
runningTASK_RUNNING 且在 CPU 上不在队列时间片耗尽/被抢占/自己阻塞
waitingTASK_INTERRUPTIBLE / TASK_UNINTERRUPTIBLE等待队列(wait_queue_head)wake_up()(通常由中断调用)
killedEXIT_ZOMBIE → EXIT_DEAD无父进程 wait

为什么 ready 和 running 在内核里是同一个值? 因为“是否在 CPU 上”是瞬时的,用 on_cpu 和 runqueue 成员关系表示就够了;教材拆成两个状态是为了讲清楚抢占这件事。

为什么 waiting 不能直接到 running? 三个理由:

  1. 公平:醒来时可能有更高优先级在等,必须重新比较
  2. 负载均衡:可能该把它放到别的核
  3. 抢占安全:中断上下文里不能直接切到用户进程(中断还没退完)

所以 wake_up() 只做“入队 + 必要时设重调度标志”,真正的切换发生在中断/系统调用返回前的 schedule()。

抢占点:preempt_schedule、返回用户态、cond_resched()、自旋锁释放。内核配置 CONFIG_PREEMPT 决定内核态能否被抢占(影响延迟,桌面发行版通常开 PREEMPT_DYNAMIC/PREEMPT_RT 相关选项)。

第三部分 线程:共享地址空间的执行流

3.1 本质区别(深入版)

维度进程线程内核里差在哪
地址空间独立 mm_struct共享同一个 mmCLONE_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 寄存器~几十 nsswitch_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 并发的收益与代价

收益(三个层次):

  1. 并行加速:4 线程编码 4 个片段,接近 4×(Amdahl 定律限制在串行部分)
  2. 延迟隐藏:聊天进程 99% 时间在等网络,阻塞式单线程会让 UI 冻结
  3. 结构清晰: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 开销适用
轮询 pollingCPU 反复读状态寄存器空转 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)的铁律:

  1. 不能睡眠(不能 kmalloc(GFP_KERNEL)、不能拿 mutex、不能访问用户内存)
  2. 要极短(微秒级),因为同核中断被屏蔽(或至少同优先级)
  3. 只做:读状态、应答设备、清中断标志、把数据搬进队列、调度下半部

为什么要拆? 因为中断处理期间:

  • 同核其他中断被延迟 → 中断延迟
  • 长时间关中断会导致丢中断、时钟漂移、网络丢包
  • 内核有 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
返回iretsysret

共同点:都是特权级切换(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 要解决的四个问题

  1. 隔离:进程 A 不能读写进程 B 的内存
  2. 超发:虚拟空间总和可以大于物理内存
  3. 碎片:不需要大块连续物理内存
  4. 共享与懒加载:同一份 libc 只存一份;不用到的页不分配

一个机制解决四个问题:给每个进程一套页表,MMU 在每次访存时翻译。

5.2 MMU 是翻译官

CPU 发出 0x12345(虚拟地址)
        │
        ▼
   ┌─────────┐   查页表(TLB 命中则跳过)
   │   MMU   │ ──────────────────────┐
   └─────────┘                       │
        │ 翻译结果                   │
        ▼                            ▼
   0x83145(物理地址)          页表在内存里
        │
        ▼
       RAM

MMU 是 CPU 内部的硬件,不是软件。它做三件事:

  1. 把虚拟地址拆成 页号 + 偏移
  2. 查页表(或 TLB)拿到物理页框号
  3. 检查权限位(读/写/执行/用户态),不合法就发 #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 dTLB64 项~1 周期(与 L1 cache 并行)
L2 STLB1536 项~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

这解释了两个现象:

  1. 进程切换贵,因为 TLB 冷启动
  2. 大页对数据库/虚拟化性能提升巨大,因为 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需要读磁盘/swapSSD ~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 editorCPU 密集、可并行4 核占满、缓存带宽调度器、多线程、大页分片并行、绑核、避免伪共享、SIMD
chatIO 密集(网络)唤醒延迟中断、等待队列、epoll提高优先级、epoll 而非阻塞读、减少拷贝
music周期性强实时中断/调度延迟RT 调度、关中断时长SCHED_FIFO + 足够 buffer、线程化中断
database随机 IO + 内存缺页、fsync、page cache页表、脏页回写、COW加大 buffer pool、NVMe、批量提交、O_DIRECT

四个可观测现象及其解释:

  1. 导出时开会卡:5 个进程抢 4 个核,CFS 给每个进程分时间片,响应延迟从 µs 级涨到 ms 级。不是 CPU 变慢,是排队。
  2. 内存吃紧时导出突然变慢,CPU 占用反而不高:major fault 让进程频繁进 waiting 等磁盘(图5 + 图7)。vmstat 里 si/so 上升、us 下降就是信号。
  3. 数据库备份瞬间完成:fork() 的 COW,子进程零拷贝拿到快照,只有被改的页才复制。
  4. 上下文切换是隐形税:perf sched 能看到每秒几万次切换,每次 1–5µs 外加缓存污染。线程不是越多越好。

一条经验公式:

程序性能 = 有效计算 ÷(计算 + 内存停顿 + IO 等待 + 调度开销) 操作系统负责后三项,而它们往往占大头。


第七部分 常见误解澄清

误解真相
fork 会复制内存只复制页表,物理页 COW 共享,写入才复制
exec 会创建新进程只替换地址空间,PID 不变
线程比进程快创建/切换快,但共享内存要加锁,可能更慢
虚拟内存 = swap虚拟内存是地址翻译机制;swap 只是它的一种后备存储
内存越大程序越快超过工作集后,缺页和 TLB 才是瓶颈;NUMA 还会引入远端访问
中断处理越短越好所以都丢给 workqueueworkqueue 有调度延迟;高频短任务用 softirq 更合适
kill -9 一定能杀死D 状态(不可中断睡眠)等 IO 的进程杀不掉
多线程一定比多进程好隔离性、崩溃影响、调试难度都要权衡
CPU 占用 100% 就是性能瓶颈可能是在自旋等锁,或者在软中断里收包
页表越大越慢多级页表让稀疏地址空间开销很小,慢的是 TLB miss
Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐