RCU：Linux 内核的「无锁读」圣杯

在现代多核系统中，读多写少的场景无处不在——路由表、文件描述符表、模块列表、cgroup 配置等。传统的读写锁（rwlock）在读者路径上依然需要原子操作和缓存一致性流量，当读取频率远高于写入时，这会成为性能瓶颈。RCU（Read-Copy-Update）正是 Linux 内核为解决这一痛点而设计的同步机制：它实现了「读者零开销」——读者不需要任何原子操作、不需要写入共享内存，在快速的 RCU 读临界区内本质上是普通的 load/store 指令。

本文将从 RCU 的数学基础出发，深入剖析经典 RCU 与 SRCU 的实现原理，拆解 Grace Period 检测机制、内存序屏障的关键作用，并结合生产级实战案例展示如何正确使用和调优 RCU。

1. 为什么需要 RCU

考虑一个典型的读多写少场景：系统中维护一个全局链表，99.9% 的操作为遍历查找，0.1% 的操作为插入或删除节点。使用 rwlock 时，每次读操作需要执行 atomic_inc，这会在多核间触发缓存一致性协议（MESI）流量。在 128 核服务器上，即使所有核都在读同一份数据，rwlock 的缓存行 bouncing 也会导致可扩展性问题。

2. RCU 的代数基础：偏序与 Happens-Before

RCU 的正确性建立在一个核心不变式上：在上一次 Grace Period 开始之前开始的所有 RCU 读临界区，必须在该 Grace Period 结束之前完成。这个不变式可以用偏序关系严格表达：

• 设 E(v) 为事件 v 的结束时间，S(v) 为开始时间。逻辑顺序上的「rcu_read_lock 先于 rcu_read_unlock」构成一个偏序关系 ≺。
• 一个 Grace Period g 满足：对所有在 g 之前开始的读者 r，都有 E(r) < S(g')，其中 g' 是 g 紧接着的下一个 Grace Period。
• 这个条件保证了不会有读者仍持有在被删除对象的引用。

3. 核心 API 与使用范式

3.1 经典 RCU（Classic RCU / Tree RCU）

经典 RCU 的使用遵循「读侧临界区」+「写侧复制更新 + 延迟释放」的模式：

读者侧（Read-Side Critical Section）

// 读者路径：零开销读取
rcu_read_lock();           // 仅包含 preempt_disable() + 内存屏障
p = rcu_dereference(head); // 带屏障的指针读取（防止 CPU/编译器重排）
if (p) {
    do_something_with(p); // 在临界区内随意操作
}
rcu_read_unlock();         // preempt_enable() + 屏障

rcu_read_lock() 的实际实现极其轻量——它只做两件事：增加 preempt_count（禁止抢占）和执行一个编译器屏障（barrier()）。注意：经典 RCU 不允许在 RCU 读临界区内睡眠或调度，因为读者持有的是一个「逻辑锁」，若在此期间发生上下文切换，Grace Period 将会收到影响。

写者侧（Writer-Side Update & Reclaim）

// 写者路径：复制更新 + 延迟释放
new_node = kmalloc(sizeof(*new_node), GFP_KERNEL);
*new_node = *old_node;   // 复制原节点
new_node->field = new_val; // 修改副本
rcu_assign_pointer(head, new_node); // 原子发布新指针（带 release 语义）
synchronize_rcu();       // 等待所有现有读者完成（Grace Period）
kfree(old_node);         // 安全释放旧节点

synchronize_rcu() 是阻塞式的——它会让写者等待直到所有在调用前开始的 RCU 读临界区都已完成。在非阻塞场景下，可以使用异步版本 call_rcu()：

call_rcu(&old_node->rcu_head, my_callback);
// callback 会在 Grace Period 结束后被调用

3.2 SRCU（Sleepable RCU）

SRCU 是对经典 RCU 的扩展，允许在 RCU 读临界区内睡眠。它通过为每个 CPU 维护一个计数器来实现：

// SRCU 读者侧：允许睡眠
idx = srcu_read_lock(&my_srcu);
p = rcu_dereference(my_p);
do_sleeping_work(p); // 允许！
srcu_read_unlock(&my_srcu, idx);

SRCU 内部维护每 CPU 的计数器。srcu_read_lock() 原子地将对应 CPU 的计数器从偶数翻到奇数（进入读），srcu_read_unlock() 翻回来。写者通过 snapshot 每 CPU 的计数器来判断读者是否已退出——这种方法虽然允许睡眠，但由于需要扫描所有 CPU 的计数器，开销更大。

4. Grace Period 检测机制

RCU 最精妙的实现在于如何「悄无声息」地知道所有读者都已退出，而不需要在读者路径上做任何标记。

4.1 Quiescent State（静态状态）

在 Linux 内核中，一个 CPU 被处于 Quiescent State 有两种情况：

• CPU 正在用户态执行（不在内核 RCU 临界区）
• CPU 正在执行上下文切换（context_switch()）

4.2 Tree RCU：基于信号的检测协议

Tree RCU（Linux 默认的 RCU 实现）使用一棵多层的 rcu_node 树状结构来高效检测所有 CPU 是否都经历了 Quiescent State：

• 底层节点（Leaf rcu_node）：管理一组 CPU（通常 4-16 个），通过位图（mask）跟踪已报告的 Quiescent State。
• 中间节点：每个节点的 blk显着性 位图，只有当所有子节点都上报 QS 后才向上汇报。
• 根节点：当所有底层节点都确认 QS，Grace Period 结束。

这种分层的信号协议避免了全局原子操作，极大地提升了可扩展性。

4.3 状态机

Grace Period 的核心状态转移：

GP_IDLE → GP_WAIT [synchronize_rcu() 触发]
GP_WAIT → GP_DONE [所有 CPU 均报告 QS]
GP_DONE → CALLBACK_READY

内核启动一个 rcu_gp_kthread 内核线程来驱动这个状态机，它周期性地检查 QS 状态并在 Grace Period 结束时执行回调。

5. Preemptible RCU（可抢占 RCU）

在 CONFIG_PREEMPT=y 配置下，经典 RCU 读者侧的 preempt_disable() 会全局关闭抢占，导致延迟不确定。为此 Linux 引入了 Preemptible RCU（CONFIG_PREEMPT_RCU=y），允许读者被抢占。其实现更加复杂：

• 读者侧通过 rcu_read_lock() 标记自己在读临界区（current->rcu_read_lock_nesting++）。
• 抢占不会让 RCU 「遗忘」这个读者——调度器的 rcu_note_context_switch() 会将当前 CPU 处于 RCUC 读临界区的信息传播出去。
• 写者需要追踪「飞行中」的读者（rcu_tasks 系列机制）。

6. 内存序屏障的关键作用

RCU 正确性的一个关键但常被忽视的环节是内存屏障。考虑以下代码：

// 读者
rcu_read_lock();
p = rcu_dereference(gp);   // (A) 读指针
val = p->data;             // (B) 读数据
rcu_read_unlock();

// 写者
new = kmalloc(...);
new->data = 42;             // (C) 写数据
rcu_assign_pointer(gp, new); // (D) 发布新指针 - release 语义
synchronize_rcu();
kfree(old);

这里的顺序至关重要：

• rcu_assign_pointer() 使用 release 语义（smp_store_release()），保证 (C) 的写操作先于 (D) 对其他 CPU 可见。
• rcu_dereference() 使用 acquire 语义（smp_load_acquire() 或数据依赖屏障），保证看到新指针后一定能看到其初始化好的 data 字段。
• 如果编译器或 CPU 重排了 (A) 和 (B)，读者可能读到过期指针的旧数据。

7. 生产级实战案例

7.1 案例一：percpu_ref 与 RCU 实现高效引用计数

percpu_ref 是内核中使用 RCU 管理对象生命周期的典型例子（include/linux/percpu-refcount.h）。它维护一个 per-CPU 的局部计数，只有当全局计数下降到 0 时才触发销毁回调：

struct percpu_ref {
    atomic64_t      count;
    percpu_ref_func_t *release;
    struct rcu_head     rcu;
};

void percpu_ref_kill(struct percpu_ref *ref)
{
    // 设置标志，禁止新的引用获取
    // 等待所有 per-CPU 计数器收拢
    // 然后等待 RCU Grace Period - 确保无人持有旧引用
    percpu_ref_kill_and_confirm(ref, NULL);
}

这里 RCU 保证在 kill 之后，所有持有旧引用的读者都已经退出临界区，安全释放对象。

7.2 案例二：dst_entry 路由缓存与 RCU

IPv4/V6 路由缓存（dst_entry）使用 RCU 保护。读取路径绝对无锁——包转发中的 skb_dst() 直接使用 RCU 语义：

// 网络栈快速路径
dst = rcu_dereference(skb->_skb_refdst);
// 或者使用 skb_dst() 宏，它内部使用 rcu_dereference

// 在模块列表中使用 RCU 查询
mutex_lock(&module_mutex);
// ... 结构修改 ...
mutex_unlock(&module_mutex);
synchronize_rcu();

# 查看 RCU 统计
$ cat /sys/kernel/debug/rcu/rcu_preempt/rcudata
    0: 76 42395 234923 0 0 0 0 64 0 46 # cbl ... (callbacks, GP, QS counts)
    
# Expedited GP 统计
$ cat /sys/kernel/debug/rcu/rcu_preempt/rcuexp

# 查看当前 Grace Period 状态
$ cat /sys/kernel/debug/rcu/rcu_preempt/gp # 当前 GP 编号