图解｜RCU原理

Linux 内核设计了多种锁机制，比如 读写锁、自旋锁 和 信号量 等。为什么要设计这么多锁机制呢？这是因为不同的锁机制适用于不同的场景，比如 读写锁 适用于读多写少的场景；而 信号量 适用于进程长时间占用锁，并且允许上下文切换的场景。

本文主要介绍一种 Linux 内核中性能非常高的锁机制：RCU锁机制。

RCU 是 Read Copy Update 的缩写，中文意思是 读取、复制、更新。RCU锁机制 就是通过读取、复制和更新这三个操作来实现锁功能。在介绍 RCU锁 之前，我们先来看看下面的实例。

struct foo {
    int  a;
    char b;
    long c;
 };

struct foo *gbl_foo;

void foo_read(void)
{
    foo *fp = gbl_foo;
    if (fp != NULL)
        do_something(fp->a, fp->b, fp->c);
}

void foo_update(foo *new_fp)
{
    foo *old_fp = gbl_foo;
    gbl_foo = new_fp;
    free(old_fp);
}

假如有线程 A 和线程 B 同时执行 foo_read()，而另线程 C 执行 foo_update()，那么会出现以下几种情况：

1. 线程 A 和线程 B 同时读取到旧的 gbl_foo 的指针。
2. 线程 A 和线程 B 同时读取到新的 gbl_foo 的指针。
3. 线程 A 和线程 B 有一个读取到新的 gbl_foo 的指针，另外一个读取到旧的 gbl_foo 的指针。

如果线程 A 或线程 B 在读取旧的 gbl_foo 数据还没完成时，线程 C 释放了旧的 gbl_foo 指针，那么将会导致程序奔溃。

也就是说，在不加锁的情况下，对公共数据的访问是危险的。当然，我们可以使用 读写锁、信号量 或者 自旋锁 来对公共数据进行保护。但这些锁都有各自的弊端，比如：

• 读写锁：对于写操作较多的场景，性能会非常差。
• 信号量：上锁失败的进程将会切换上下文，从而导致系统的性能下降。
• 自旋锁：获得锁的 CPU 将会阻塞其他 CPU 的允许，从而导致系统的并行能力下降。

那么有没有一种锁机制，对系统的性能影响不大的呢？所以，Linux 内核黑客们就创造出 RCU锁。

RCU锁原理

如果能够保证所有使用某个公共数据的线程不再使用它，那么就可以安全删除此公共数据。

1. 宽限期

在上面的例子中，如果能够保证线程 A 和线程 B 不再使用旧数据，那么线程 C 就能安全删除旧数据。

如下图所示（旧数据对应对象A，新数据对应对象B）：

从上图的时间线可以看出，线程 A 和线程 B 从 glb_foo 指针获取的都是对象 A 的引用。

提示：因为 glb_foo 指针在时间点 B 才被替换成对象 B，而线程 A 和线程 B 都是在时间点 B 前获取 glb_foo 指针指向的对象，所以它们获取到的都是对象 A 的引用。

而在 安全点 后，线程 A 和线程 B 便不再使用旧数据（对象A）。所以此时，线程 C 便可以安全释放旧数据（对象A）。

线程 A 和线程 B 使用旧数据的这段期间，被称为 宽限期。如下图所示：

所以，RCU锁 的核心思想就是怎么确定 宽限期。因为确定宽限期后，就可以随心所欲地释放旧数据。

2. 宽限期确认

RCU锁 的原理虽然比较简单，但是实现却有点小复杂，主要是因为 宽限期 的确定比较麻烦。

为了能够确认 宽限期，使用 RCU 锁时有以下限制：

• 使用 RCU 锁前，必须禁止内核抢占。
• 在 RCU 锁保护的临界区中，不能使用可能触发调度的函数（如不能调用 alloc_pages 函数）。

由于在 RCU 临界区是禁止调度的，所以如果 CPU 发生了调度，就可以确定当前线程已经退出了临界区（也就是说当前线程不再引用旧对象）。如果所有的 CPU 都至少发生过一次调度，那么也就说明没有任何线程引用旧对象，此时就可以安全释放旧对象了。

所以，RCU 锁的核心原理是：在释放旧对象前，必须等待所有 CPU 核心至少调度一次。如下代码所示：

void foo_update(struct foo *new_fp)
{
    // 1. 将 gbl_foo 指向新对象
    spin_lock(&foo_mutex);
    foo *old_fp = gbl_foo;
    gbl_foo = new_fp;
    spin_unlock(&foo_mutex);

    // 2. 等待所有 CPU 核心至少调度一次
    synchronize_kernel();

    // 3. 释放旧对象
    free(old_fp);
}

foo_update() 函数释放旧对象的步骤如下：

1. 使用新对象替换旧对象，在替换前必须使用自旋锁进行保护，避免多个 CPU 同时修改 gbl_foo 指针的值。
2. 等待所有 CPU 核心至少调度一次。
3. 由于所有 CPU 核心都至少调度过一次，那么可以确认现在没有线程引用旧对象，所以可以安全释放旧对象。

3. RCU临界区

通过前面的分析可知，在 RCU 临界区中是不能发生调度的。要保证临界区不发生调度，首先要确保在临界区中不能调用可能触发调度的函数，如：alloc_pages()。这点需要 RCU 使用者自己保证。

另外一点要保证的是，内核不能发生抢占，这点可以通过调用 preempt_disable() 函数实现。内核定义了一个名为 rcu_read_lock() 的宏，如下所示：

#define rcu_read_lock()  preempt_disable()

可以看出， rcu_read_lock() 宏其实就是 preempt_disable() 函数的别名。所以，使用 RCU 锁时，可以使用 rcu_read_lock() 宏对临界区进行保护。

当退出临界区时，需要调用 rcu_read_unlock() 把内核抢占打开。rcu_read_unlock() 的定义如下：

#define rcu_read_unlock() preempt_enable()

可以看出，rcu_read_unlock() 宏就是 preempt_enable() 的别名。

所以，当我们使用 RCU 锁对临界区进行保护时，必须将需要保护的代码放置在 rcu_read_lock() 和 rcu_read_unlock() 之间，如下所示：

void foo_read(void)
{
    // 1. 保护临界区
    rcu_read_lock();
  
    foo *fp = gbl_foo;
    if (fp != NULL)
        do_something(fp->a, fp->b, fp->c);
  
    // 2. 退出临界区
    rcu_read_unlock();
}