3.3 rcu_dereference() 的实现

rcu_dereference() 确保：在读取指针所指向的数据之前，指针本身的加载已经完成。

// include/linux/rcupdate.h 中的简化定义
#define rcu_dereference(p) \
    ({ \
        typeof(*p) *_________p1 = READ_ONCE(p); \
        smp_check_load_pointer(p); \
        (&(p), _________p1); \
    })

在大多数架构上，READ_ONCE() 仅提供编译器屏障，确保变量不被编译器优化为寄存器缓存。在 DEC Alpha 等极端弱序架构上，它会生成真正的内存屏障指令（mb）。

四、内核中 RCU 的典型使用模式

4.1 链表安全遍历

RCU 最常见的用途是保护链表的并发读取。内核提供了专门的 RCU 链表遍历宏：

// 单向链表遍历
struct my_node *pos;
list_for_each_entry_rcu(pos, &my_list, list) {
    if (pos->key == target_key)
        return pos;  // 安全返回，调用者需持有 RCU 读锁
}
return NULL;

// 哈希链表（hlist）遍历
struct my_hash *hpos;
hlist_for_each_entry_rcu(hpos, &hash_bucket[i], hlist) {
    if (hpos->id == search_id)
        return hpos;
}

4.2 kfree_rcu()——延迟释放模式

RCU 最优雅的设计之一是 kfree_rcu()。它允许在更新后立即释放旧数据结构所占的内存，而无需显式调用 synchronize_rcu()：

// 旧方式：使用 synchronize_rcu，可能阻塞很久
old_config = global_config;
global_config = new_config;
synchronize_rcu();  // 必须等待所有读者完成
kfree(old_config);

// 新方式：kfree_rcu 在宽限期结束后自动释放
old_config = rcu_protect_pointer(global_config);
rcu_assign_pointer(global_config, new_config);
kfree_rcu(old_config, rcu_head);  // 非阻塞，延迟释放

使用 kfree_rcu() 时，结构体中必须包含一个 struct rcu_head 成员，或者通过第二个参数指定偏移量。

4.3 Per-CPU 变量与 RCU 的配合

Per-CPU 变量天然适合 RCU 保护的模式——每个 CPU 拥有独立的副本，更新时可以通过 RCU 发布新的 per-CPU 指针：

DEFINE_PER_CPU(struct stats *, cpu_stats);

void update_stats(struct stats *new_stats) {
    int cpu;
    struct stats *old_stats;
    
    for_each_possible_cpu(cpu) {
        old_stats = per_cpu(cpu_stats, cpu);
        per_cpu(cpu_stats, cpu) = per_cpu_alloc(new_stats, cpu);
        call_rcu(&old_stats->rcu, free_stats);
    }
}

4.4 RCU 保护的指针数组

RCU 广泛用于保护大型指针数组，如网络路由 FIB 表：

// net/ipv4/fib_trie.c
struct fib_table {
    struct rcu_head rcu;
    ...
    struct key_vector *kv;
};

// 原子替换整个路由表
void fib_table_replace(struct fib_table *new_tb) {
    struct fib_table *old_tb = rtnl_dereference(net->ipv4.fib_main);
    rcu_assign_pointer(net->ipv4.fib_main, new_tb);
    call_rcu(&old_tb->rcu, fib_table_destroy_rcu);
}

五、宽限期实现与内核 RCU 子系统

5.1 Classic RCU vs Preemptible RCU

Linux 内核实现了多种 RCU 变体：

对于需要支持抢占的内核配置（CONFIG_PREEMPT=y），默认使用 Preemptible RCU。

5.2 Tree RCU——大规模系统的扩展方案

在拥有数百个 CPU 的大型系统上，管理宽限期成为了挑战。Tree RCU（CONFIG_TREE_RCU）采用树形层次结构来减少宽限期同步的开销：

• 每个 CPU 位于树的叶子节点
• 内部节点（struct rcu_node）在其所有子节点都报告静止状态后才报告
• 根节点确认后，宽限期正式结束

这种设计将宽限期检测的通信复杂度从 O(N) 降低到 O(log N)，使 RCU 能够扩展到 4096+ CPU 的系统。

5.3 RCU 回调机制

当宽限期完成时，RCU 子系统通过软中断（RCU_SOFTIRQ）触发注册的回调函数。call_rcu() 注册的回调按照 FIFO 顺序执行：

// call_rcu 的典型用法
void my_rcu_free(struct rcu_head *head) {
    struct my_data *ptr = container_of(head, struct my_data, rcu);
    kfree(ptr);
}

// 注册回调
call_rcu(&old_ptr->rcu, my_rcu_free);

对于大量 call_rcu() 调用导致的延迟问题，Linux 5.x 引入了 call_rcu_hurry() 加速机制，以及基于 rcutree 的优先回调处理。

六、性能基准对比

6.1 RCU vs rwlock vs seqlock vs percpu

以下是在 128 核 Intel Xeon 系统上进行的典型读取性能测试（单位：百万次操作/秒）：

* 写入延迟包括 synchronize_rcu() 等待宽限期的成本
** 若使用 call_rcu() 异步释放，写入成本大幅降低

6.2 微基准测试代码

// 测量 RCU 读取延迟的循环
ktime_get();
for (i = 0; i < ITERATIONS; i++) {
    rcu_read_lock();
    p = rcu_dereference(shared_ptr);
    tmp = p->counter;  // 访问共享数据
    rcu_read_unlock();
}
elapsed = ktime_get() - start;

// 测量 rwlock 读取延迟的循环
ktime_get();
for (i = 0; i < ITERATIONS; i++) {
    read_lock(&rwlock);
    tmp = shared_ptr->counter;
    read_unlock(&rwlock);
}
elapsed = ktime_get() - start;

6.3 NUMA 敏感场景分析

在 NUMA 架构中，RCU 的优势更加明显。跨 NUMA 节点的缓存一致性流量远高于节点内，RCU 的零开销读取消除了跨节点流量，而 rwlock_t 的原子操作会在每次获取读锁时触发 MESI 协议状态转换。

七、RCU 在生产环境中的最佳实践

7.1 必须遵守的规则

1. 读取侧临界区不可阻塞：禁止在 rcu_read_lock() 和 rcu_read_unlock() 之间调用可能睡眠的函数（kmalloc(GFP_KERNEL)、互斥锁、copy_to_user() 等）
2. 指针赋值使用 rcu_assign_pointer()：确保写入侧的Store-Release语义
3. 指针读取使用 rcu_dereference()：确保读取侧不发生重排序
4. RCU 保护的数据必须通过 RCU 方式释放：使用 kfree_rcu() 或 call_rcu()，禁止直接 kfree()

7.2 常见的陷阱与反模式

// 反模式 1：在 RCU 临界区内睡眠
rcu_read_lock();
p = rcu_dereference(dev->data);
mutex_lock(&p->lock);  // 危险！如果 p->lock 需要等待，将导致 RCU stall
rcu_read_unlock();

// 反模式 2：直接修改 RCU 保护的数据
rcu_read_lock();
p = rcu_dereference(head);
p->value++;  // 错误！可能与其他写入者产生竞争
rcu_read_unlock();

// 反模式 3：未使用 RCU 安全方式释放
old_p = global_ptr;
global_ptr = new_p;
kfree(old_p);  // 错误！可能有读者仍在使用 old_p

// 正确做法
old_p = rcu_protect_pointer(global_ptr);
rcu_assign_pointer(global_ptr, new_p);
kfree_rcu(old_p, rcu);

7.3 调试工具：RCU Stall 检测

内核提供了 RCU stall 检测机制。当某个 CPU 在 RCU 临界区内停留过长时间，系统将打印警告信息：

rcu_sched detected stalls on CPUs/tasks:
0-...: (12499 ticks this GP) idle=xxxx/0/0x0 softirq=xxx/xxx
#0  xxx kworker/0:1 ...
  xxx+0xa8/0x100

调试 RCU stall 的关键步骤：

1. 查看 dmesg 中的 RCU stall 详细信息
2. 确认哪个 CPU 长时间未经历静止状态
3. 使用 rcu_nocbs 将回调卸载到单独线程，减少延迟
4. 使用 CONFIG_RCU_EQS_DEBUG 帮助检测异常

八、RCU 在现代 Linux 内核中的应用案例

8.1 VFS 路径查找（nameidata）

Linux 4.x 之后，VFS 路径查找的核心数据结构（struct nameidata）和 dentry 缓存使用 RCU 保护，使得 open()、stat() 等系统调用的路径解析部分实现了真正的无锁并行：

// fs/namei.c 中的 RCU 路径查找
static struct dentry *lookup_fast(struct nameidata *nd, ...) {
    struct dentry *dentry;
    
    rcu_read_lock();
    dentry = __d_lookup_rcu(...);
    if (dentry) {
        // 使用 RCU 安全方式访问 dentry
        if (dentry->d_seq != seq) {
            rcu_read_unlock();
            return NULL;  // 序列号不匹配，重试
        }
        ...
    }
    rcu_read_unlock();
}

8.2 网络协议栈——FIB 路由表

IPv4 路由查找使用 RCU 保护的路由表。当管理员添加/删除路由时，内核原子替换路由表，旧表延迟释放：

// net/ipv4/fib_frontend.c
void fib_add_ifaddr(...) {
    // 创建新 fib_table
    ...
    // RCU 方式发布新表
    rcu_assign_pointer(net->ipv4.fib_main, new_tb);
    // 异步释放旧表
    call_rcu(&old_tb->rcu, fib_table_destroy_call_rcu);
}

8.3 进程调度器——task_group 保护

CFS 调度器使用 RCU 保护 task_group 结构体的层级结构，允许在读取调度信息时无需持有锁：

// kernel/sched/core.c
struct task_group *sched_create_group(struct task_group *parent) {
    struct task_group *tg;
    tg = kzalloc(sizeof(*tg), GFP_KERNEL);
    // 初始化 cfs_rq、rt_rq 等
    return tg;
}
// 通过 RCU 方式发布：tg->rcu 嵌入在结构中

九、RCU 在最新内核中的演进（5.x~6.x）

9.1 任务型 RCU（Tasks RCU）

为了支持更复杂的同步场景，内核引入了 Tasks RCU。它不仅等待 CPU 的静止状态，还等待特定任务完成对 RCU 临界区的访问。

9.2 SRCU（Sleepable RCU）

SRCU 允许在 RCU 临界区内合法睡眠，是 Classic RCU 和 Preemptible RCU 的补充：

int srcu_read_lock(struct srcu_struct *ssp) __acquires(ssp)
void srcu_read_unlock(struct srcu_struct *ssp, int idx) __releases(ssp)
void synchronize_srcu(struct srcu_struct *ssp)

// 使用示例
static DEFINE_SRCU(my_srcu);
int idx = srcu_read_lock(&my_srcu);
sleeping_function();  // 合法睡眠
srcu_read_unlock(&my_srcu, idx);

9.3 Polled Grace Period

Linux 6.x 引入了轮询式宽限期 API（get_state_synchronize_rcu()、start_poll_synchronize_rcu()），允许在不阻塞的情况下检查宽限期是否完成，适用于不能睡眠的上下文：

// 非阻塞宽限期等待
unsigned long cookie = start_poll_synchronize_rcu();
// ... 执行其他工作 ...
if (poll_state_synchronize_rcu(cookie))
    kfree(old_data);  // 宽限期已完成，安全释放

十、总结

RCU 作为 Linux 内核中最重要的同步原语之一，通过独特的"读取零开销 + 延迟释放"设计，为高并发读取场景提供了极致的性能优势：

• 性能：在 128 核系统上，RCU 读取带宽可达 rwlock 的 138 倍
• 扩展性：读取端不受核心数增加的影响，理论上具备线性扩展能力
• 适用范围广：从链表、哈希表到路由表、VFS 路径查找，RCU 已渗透到内核各个子系统
• 持续演进：从 Classic RCU 到 Tree RCU，再到 SRCU 和 Polled GP，RCU 子系统持续发展

掌握 RCU 不仅是理解 Linux 内核同步机制的关键，也是编写高性能并发系统代码的必备技能。当你的系统面临高频读取、低频写入的并发场景时，RCU 往往是最优解。

参考资料

1. Paul E. McKenney, What is RCU, Fundamentally?, Linux Journal, 2012
2. Linux Kernel Documentation: Documentation/RCU/
3. Paul E. McKenney, Is Parallel Programming Hard, And, If So, What Can You Do About It?
4. Understanding the Linux Kernel, 3rd edition - 并发与同步章节