4 内核

内核在做什么

内核是唯一运行在内核态的代码。它的职责:

  1. 管理资源:进程、内存、设备、文件系统
  2. 提供抽象:把硬件包装成系统调用接口
  3. 维持秩序:调度、隔离、保护、错误处理

内核与应用程序的根本区别:内核可以直接碰硬件、可以执行特权指令、可以看到所有内存。代价是它必须绝对正确——内核崩了,整台机器就崩了。

内核的入口:三种打断

内核不是"一直在跑"的程序,它是在被请求时才运行的代码。三种进入方式:

方式触发源同步性典型
系统调用应用主动同步read、write、fork
异常程序出错同步缺页、除零、非法访问
中断硬件设备异步时钟、网卡、磁盘、键盘

中断是异步的——它和当前正在执行的指令无关,随时可能到来。这一条性质决定了内核编程的很多复杂性。

中断

中断的流程

1. 设备把中断请求(IRQ)发给中断控制器(APIC / GIC)
2. 中断控制器裁决优先级,通知 CPU
3. CPU 在执行完当前指令后:
   a. 保存现场(PC、flags、部分寄存器)到内核栈
   b. 切到内核态
   c. 关中断(或屏蔽同级中断)
   d. 根据中断号查 IDT(中断描述符表),跳到对应 ISR
4. ISR(中断服务例程)执行:
   a. 保存其余寄存器
   b. **应答设备**(告诉它"收到了",否则会重复中断)
   c. 处理(通常是把数据从设备缓冲区拷出来)
   d. 恢复寄存器
5. iret / eret 返回,恢复到被打断的地方

关键点:中断处理必须快。因为中断是异步的,处理太久会:

  • 延迟其他中断(可能丢中断)
  • 让系统响应变差

上半部与下半部(Top Half / Bottom Half)

Linux 的解法:把中断处理拆成两段。

上半部(Top Half / 硬中断):
  - 立即执行,**关中断**
  - 只做最紧急的事:应答设备、把数据拷到内存、调度下半部
  - 必须极快(微秒级)

下半部(Bottom Half / 软中断):
  - 稍后执行,**开中断**
  - 做耗时的处理:协议栈处理、数据拷贝、唤醒进程
  - 可以被新的中断打断

下半部的三种机制:

机制特点能否睡眠
softirq静态定义,可并发跑在多核不能
tasklet基于 softirq,同类型串行不能
workqueue在内核线程上下文执行能

这是"中断上下文不能睡眠"的根源:中断上下文不属于任何进程,没有可以调度的实体,一旦睡眠就再也回不来(内核直接 panic)。

中断屏蔽

local_irq_disable();      // 关本地 CPU 中断
// 临界区(访问和 ISR 共享的数据)
local_irq_enable();

只在极短的临界区使用。长时间关中断会导致中断丢失、系统卡死。

关中断只能屏蔽本地 CPU。多核下要真正互斥还需要锁。

系统调用的实现

完整路径

用户态:
  write(1, buf, 5);
    ↓ glibc 封装
  把系统调用号放入 rax,参数放入 rdi/rsi/rdx...
  执行 syscall 指令
    ↓
CPU:
  切到内核态(CPL 3 → 0)
  切换到内核栈
  保存用户态 RIP、RSP、flags
  根据 rax 里的系统调用号,查 sys_call_table,跳转
    ↓
内核态:
  sys_write(fd, buf, count)
    ↓
  检查参数:fd 有效?buf 指针属于用户空间且可读?
  用 copy_from_user() 安全拷贝(**不能直接解引用用户指针**)
  执行实际的写操作(VFS → 具体文件系统 → 设备驱动)
  返回
    ↓
sysret / iret:
  恢复用户态寄存器,切回用户态,跳回 syscall 之后那条指令

为什么不能直接解引用用户指针

// 错误示范
int sys_foo(char __user *ptr) {
    return *ptr;   // 危险!ptr 可能是 0、可能是内核地址、可能是未映射地址
}

// 正确做法
int sys_foo(char __user *ptr) {
    char c;
    if (copy_from_user(&c, ptr, 1))   // 失败返回非零
        return -EFAULT;
    return c;
}

copy_from_user 内部会:

  • 检查地址是否在用户空间范围内
  • 临时修改异常处理表,万一真的缺页就返回错误而不是崩溃

这是内核安全的第一道防线。

系统调用的开销

一次系统调用约 1000~3000 个 CPU 周期(约 0.5~1 微秒)。来源:

  1. 模式切换本身(特权级切换、栈切换)
  2. 保存/恢复寄存器
  3. TLB 和 Cache 污染(内核地址空间和用户空间不同)
  4. 参数检查

优化手段:

技术做法
vDSO把部分不需要特权的操作(如 gettimeofday)映射到用户空间,直接调用,无需陷入
io_uring用共享环形队列批量提交 I/O 请求,大幅减少系统调用次数
批量系统调用一次调用处理多个请求
epoll一次等待多个 fd,替代大量 select/poll

现代高性能服务器(如 Nginx、数据库)的核心优化之一就是减少系统调用次数。

内核同步

内核代码是并发的,来源包括:

  • 多个 CPU 同时执行内核代码
  • 中断打断正在执行的内核代码
  • 内核抢占(一个进程在内核态被另一个抢占)

所以任何共享数据都需要保护。

自旋锁(Spinlock)

spin_lock(&lock);
// 临界区(必须很短,且不能睡眠)
spin_unlock(&lock);

忙等:拿不到锁就一直循环检查。

适用场景:

  • ✓ 临界区极短(几十条指令)
  • ✓ 中断上下文(不能睡眠)
  • ✗ 临界区长(浪费 CPU)
  • ✗ 单核非抢占内核(没意义,直接关中断更快)

危险:持有自旋锁时睡眠 → 别人等这把锁会死循环 → 死锁。所以自旋锁保护的临界区绝对不能调用可能睡眠的函数(kmalloc 带 GFP_KERNEL、copy_from_user、mutex…)。

信号量 / 互斥锁(Mutex)

mutex_lock(&lock);
// 临界区(可以很长,可以睡眠)
mutex_unlock(&lock);

拿不到锁就把自己挂起,让出 CPU。

  • ✓ 临界区长
  • ✓ 进程上下文
  • ✗ 中断上下文(不能睡眠)

读写锁(rwlock / rwsem)

多个读者可并行,写者独占。适合读多写少的数据结构(如内核的路由表、模块列表)。

seqlock 是另一种:读者不加锁,靠一个序列号检测"读期间有没有被写",如果被写了就重读。适合写极少、读极多、读要极快的场景(如 jiffies/时间)。

RCU(Read-Copy-Update)

读者完全无开销(不加锁、不原子操作)。

原理:

  • 读者:直接读,标记自己处于"读侧临界区"
  • 写者:复制一份,改副本,然后原子地把指针指向新版;等所有旧读者都退出后,释放旧版本
写者:
  1. 分配新对象,复制旧内容
  2. 修改新对象
  3. 原子替换指针(rcu_assign_pointer)
  4. synchronize_rcu()  ← 等待所有正在进行的读者结束
  5. 释放旧对象

适用:读极多写极少,且能容忍读者看到"稍旧的数据"。Linux 内核里大量使用(路由表、进程列表、模块列表)。

死锁预防

内核里的死锁比用户态更难调试(会导致整机卡死)。规则:

  1. 固定加锁顺序(最重要)
  2. 持有锁时不调用外部代码(尤其回调函数)
  3. 锁的层次(lockdep):Linux 有 CONFIG_LOCKDEP 运行时检测潜在的锁顺序问题
  4. 中断上下文要用 spin_lock_irqsave(既加锁又关中断),防止 ISR 也来抢同一把锁造成死锁
// 如果数据也会被 ISR 访问,必须用这个版本
unsigned long flags;
spin_lock_irqsave(&lock, flags);
// 临界区
spin_unlock_irqrestore(&lock, flags);

如果只用 spin_lock,ISR 抢同一把锁时会死锁(持有锁的进程等不到 ISR 返回)。

内核内存分配

内核不能用 malloc(那是 C 库的,基于 brk/mmap 系统调用,属于用户态)。

Buddy(伙伴)分配器

按 2 的幂大小的块管理物理页(1, 2, 4, 8, ... 1024 页)。

要 3 页 → 分配 4 页(内部碎片)
释放时,若相邻的"伙伴"也空闲,合并成更大的块

解决外部碎片(因为总能合并)。但仍有内部碎片。

Slab / Slub 分配器

Buddy 只能按页分配,内核里到处都是几十到几百字节的小对象(task_struct、inode、sk_buff…)。

Slab:为每种常用对象维护一个对象缓存,从 buddy 拿几页,切成等大小的对象,维护空闲链表。

struct kmem_cache *cache = kmem_cache_create("my_obj", sizeof(struct my_obj), 0, 0, NULL);
struct my_obj *p = kmem_cache_alloc(cache, GFP_KERNEL);
kmem_cache_free(cache, p);

好处:

  • 快(O(1) 分配释放)
  • 无内部碎片(对象大小精确匹配)
  • 缓存/着色优化(利用对象在 cache line 里的布局)

/proc/slabinfo 能看到内核里各种对象的缓存使用情况,是排查内核内存泄漏的好工具。

vmalloc vs kmalloc

kmallocvmalloc
物理连续是否
虚拟连续是是
大小限制通常 ≤ 128 KB(受碎片影响)可以很大
速度快(直接偏移)慢(要建页表)
用途设备 DMA、小对象大块、非 DMA

DMA 必须物理连续(老设备只认连续物理地址,除非有 IOMMU)。

GFP 标志

kmalloc(size, GFP_KERNEL);   // 可以睡眠等待内存
kmalloc(size, GFP_ATOMIC);   // 不能睡眠,中断上下文用
kmalloc(size, GFP_DMA);      // 从 DMA 区分配

在中断上下文或持有自旋锁时,必须用 GFP_ATOMIC。

内核线程

内核也有自己的"进程"——内核线程,只在内核态运行,没有用户地址空间。

ps aux | grep '\['   # 方括号括起来的就是内核线程
# [kthreadd]  [ksoftirqd/0]  [kworker/0:1]  [migration/0]  [rcu_sched]

常见内核线程:

名字作用
kthreadd内核线程的父进程(PID 2)
ksoftirqd/N每 CPU 一个,处理软中断
kworker/N:xworkqueue 的工作线程
migration/N负载均衡,迁移进程
kswapd内存回收(换页守护进程)
writeback把脏页写回磁盘
jbd2/sda1-8ext4 的日志线程

设备驱动

驱动是内核里直接和硬件对话的部分。

应用程序  →  系统调用  →  VFS/子系统  →  设备驱动  →  硬件

驱动的三大交互方式:

方式机制例子
轮询(Polling)CPU 不断读状态寄存器简单但浪费 CPU
中断(Interrupt)设备就绪后通知 CPU最常用
DMA设备直接和内存传数据,完成后中断通知网卡、磁盘(不用 CPU 搬运)

DMA 为什么重要:没有 DMA,传 1 MB 数据要 CPU 执行 1M 次 load/store。有了 DMA,CPU 只需设置好地址和长度,设备自己搬,搬完中断一下。

内核启动流程

1. 上电,CPU 从固定地址执行 BIOS/UEFI
2. BIOS/UEFI:
   - 自检(POST)
   - 枚举硬件
   - 找到启动设备
   - 加载 bootloader(GRUB)
3. Bootloader:
   - 加载内核镜像到内存
   - 加载 initramfs(初始内存盘,包含启动时需要的驱动)
   - 跳到内核入口
4. 内核(汇编阶段):
   - 设置页表,开启分页
   - 切换到 64 位长模式(x86-64)
   - 设置栈
5. 内核(C 阶段):
   - 解析 ACPI / 设备树
   - 初始化内存管理(buddy、slab)
   - 初始化中断(IDT)
   - 初始化调度器
   - 探测并初始化设备驱动
   - 挂载根文件系统
6. 启动第一个用户态进程 init(PID 1,现代是 systemd)
7. init 启动各种服务、登录界面

initramfs 的作用:内核要挂载根文件系统,但读根文件系统需要磁盘驱动和文件系统驱动——鸡生蛋问题。解法是先把一个小的内存文件系统(含必要驱动)挂载起来,再切换。

内核调试

dmesg                       # 内核日志(printk 的输出)
cat /proc/kmsg              # 实时内核日志
uname -a                    # 内核版本
cat /proc/interrupts        # 中断统计(每 CPU 每 IRQ)
cat /proc/softirqs          # 软中断统计

# 崩溃分析
# Oops: 内核检测到异常但能继续,会打印调用栈
# Panic: 无法继续,直接停机
# 内核转储(kdump/kexec)保留崩溃现场供事后分析

# 动态追踪
perf probe                  # 动态插入探测点
ftrace                      # 内核函数追踪
bpftrace / BCC              # eBPF,安全地在内核里跑自定义代码

eBPF 是现代内核可观测性的革命:可以安全地在内核里执行自定义程序(有验证器保证不会死循环/越界),无需重新编译内核、无需加载模块。用于网络、安全、性能分析。

常见坑

  • 在中断上下文调用会睡眠的函数 → 内核 panic。kmalloc(GFP_KERNEL)、mutex_lock、copy_from_user 都不能在硬中断里用
  • 持有自旋锁时睡眠 → 死锁
  • 忘记 spin_lock_irqsave → ISR 抢同一把锁导致死锁
  • 在内核里直接解引用用户指针 → 安全漏洞(可被用来读内核内存)
  • 驱动里的竞态 → 极难复现的随机 bug,通常要靠 lockdep 和代码审查发现
  • printk 太多 → 内核日志刷屏,反而丢失关键信息,还可能拖慢系统
  • 内核栈很小(通常 8KB 或 16KB,不能增长)→ 递归太深或大数组放栈上会栈溢出直接崩