Linux内核原语（六）——读-写自旋锁（rwlock）

 

 

Linux内核原语（六）——读-写自旋锁（rwlock）

小狼@http://blog.csdn.net/xiaolangyangyang

 

---

上一章聊到了内核的自旋锁 spinlock 相关的内容，试想这样一种场景：一个内核链表元素，很多进程（或者线程）都会对其进行读写，但是使用 spinlock 的话，多个读之间无法并发，只能被 spin，为了提高系统的整体性能，内核定义了一种锁：

1. 允许多个处理器进程（或者线程或者中断上下文）并发的进行读操作（SMP 上），这样是安全的，并且提高了 SMP 系统的性能。

2. 在写的时候，保证临界区的完全互斥

所以，当某种内核数据结构被分为：读-写，或者生产-消费，这种类型的时候，类似这种 读-写自旋锁就起到了作用。对读者是共享的，对写者完全互斥。

读/写自旋锁是在保护SMP体系下的共享数据结构而引入的，它的引入是为了增加内核的并发能力。只要内核控制路径没有对数据结构进行修改，读/写自旋锁就允许多个内核控制路径同时读同一数据结构。如果一个内核控制路径想对这个结构进行写操作，那么它必须首先获取读/写锁的写锁，写锁授权独占访问这个资源。这样设计的目的，即允许对数据结构并发读可以提高系统性能。

 

加锁的逻辑：

（1）假设临界区内没有任何的thread，这时候任何read thread或者write thread可以进入，但是只能是其一。

（2）假设临界区内有一个read thread，这时候新来的read thread可以任意进入，但是write thread不可以进入

（3）假设临界区内有一个write thread，这时候任何的read thread或者write thread都不可以进入

（4）假设临界区内有一个或者多个read thread，write thread当然不可以进入临界区，但是该write thread也无法阻止后续read thread的进入，他要一直等到临界区一个read thread也没有的时候，才可以进入。

解锁的逻辑：

（1）在write thread离开临界区的时候，由于write thread是排他的，因此临界区有且只有一个write thread，这时候，如果write thread执行unlock操作，释放掉锁，那些处于spin的各个thread（read或者write）可以竞争上岗。

（2）在read thread离开临界区的时候，需要根据情况来决定是否让其他处于spin的write thread们参与竞争。如果临界区仍然有read thread，那么write thread还是需要spin（注意：这时候read thread可以进入临界区，听起来也是不公平的）直到所有的read thread释放锁（离开临界区），这时候write thread们可以参与到临界区的竞争中，如果获取到锁，那么该write thread可以进入。

 

读-写自旋锁的使用

与 spinlock 的使用方式几乎一致，读-写自旋锁初始化方式也分为两种：

动态的：

rwlock_t rw_lock;
rwlock_init (&rw_lock);

静态的：

DEFINE_RWLOCK(rwlock);

初始化完成后就可以使用读-写自旋锁了，内核提供了一组 APIs 来操作读写自旋锁，最简单的比如：

读临界区：

rwlock_t rw_lock;
rwlock_init (&rw_lock);

read_lock(rw_lock);
------------- 读临界区 -------------
read_unlock(rw_lock);

写临界区：

​​​​​​​rwlock_t rw_lock;
rwlock_init (&rw_lock);

write_lock(rw_lock);
------------- 写临界区 -------------
write_unlock(rw_lock);

注意：读锁和写锁会位于完全分开的代码中，若是：

read_lock(lock);
write_lock(lock);

这样会导致死锁，因为读写锁的本质还是自旋锁。写锁不断的等待读锁的释放，导致死锁。如果读-写不能清晰的分开的话，使用一般的自旋锁，就别使用读写锁了。

注意：由于读写自旋锁的这种特性（允许多个读者），使得即便是递归的获取同一个读锁也是允许的。更比如，在中断服务程序中，如果确定对数据只有读操作的话（没有写操作），那么甚至可以使用 read_lock 而不是 read_lock_irqsave，但是对于写来说，还是需要调用 write_lock_irqsave 来保证不被中断打断，否则如果在中断中去获取了锁，就会导致死锁。

 

读-写锁内核 APIs

与 spinlock 一样，Read/Write spinlock 有如下的 APIs：

接口API描述	Read/Write Spinlock API
定义rw spin lock并初始化	DEFINE_RWLOCK
动态初始化rw spin lock	rwlock_init
获取指定的rw spin lock	read_lock write_lock
获取指定的rw spin lock同时disable本CPU中断	read_lock_irq write_lock_irq
保存本CPU当前的irq状态，disable本CPU中断并获取指定的rw spin lock	read_lock_irqsave write_lock_irqsave
获取指定的rw spin lock同时disable本CPU的bottom half	read_lock_bh write_lock_bh
释放指定的spin lock	read_unlock write_unlock
释放指定的rw spin lock同时enable本CPU中断	read_unlock_irq write_unlock_irq
释放指定的rw spin lock同时恢复本CPU的中断状态	read_unlock_irqrestore write_unlock_irqrestore
获取指定的rw spin lock同时enable本CPU的bottom half	read_unlock_bh write_unlock_bh
尝试去获取rw spin lock，如果失败，不会spin，而是返回非零值	read_trylock write_trylock

 

读-写锁内核实现

说明：使用读写内核锁需要包含的头文件和 spinlock 一样，只需要包含：include/linux/spinlock.h 就可以了

这里仅看 和体系架构相关的部分，在 ARM 体系架构上：

arch_rwlock_t 的定义：

typedef struct {
    u32 lock;
} arch_rwlock_t;

看看 arch_write_lock 的实现：

static inline void arch_write_lock(arch_rwlock_t *rw)
{
       unsigned long tmp;

       prefetchw(&rw->lock);------------------------(0)
       __asm__ __volatile__(
"1:  ldrex     %0, [%1]\n"--------------------------(1)
"      teq  %0, #0\n"--------------------------------(2)
       WFE("ne")------------------------------------(3)
"      strexeq %0, %2, [%1]\n"----------------------(4)
"      teq  %0, #0\n"--------------------------------(5)
"      bne       1b"--------------------------------------(6)
       : "=&r" (tmp)
       : "r" (&rw->lock), "r" (0x80000000)
       : "cc");

       smp_mb();------------------------------------(7)
}

（0） ： 先通知 hw 进行preloading cache 

（1）：  标记独占，获取 rw->lock 的值并保存在 tmp 中

​​​​​​​（2） ： 判断 tmp 是否等于 0

（3） ： 如果 tmp 不等于0，那么说明有read 或者write的thread持有锁，那么还是静静的等待吧。其他thread会在unlock的时候Send Event来唤醒该CPU的

（4） ： 如果 tmp 等于0，将 0x80000000 这个值赋给 rw->lock

（5） ： 是否 str 成功，如果有其他 thread 在上面的过程插入进来就会失败

（6） ： 如果不成功，那么需要重新来过跳转到标号为 1 的地方，即开始的地方，否则持有锁，进入临界区

（7） ： 内存屏障，保证执行顺序

 

arch_write_unlock 的实现：

static inline void arch_write_unlock(arch_rwlock_t *rw)
{
    smp_mb(); ---------------------------（0）

    __asm__ __volatile__(
    "str    %1, [%0]\n" -----------------（1）
    :
    : "r" (&rw->lock), "r" (0)
    : "cc");

    dsb_sev(); --------------------------（2）
}

（0） ： 内存屏障

（1） ： rw->lock 赋值为 0 

（2） ：唤醒处于 WFE 的 thread

 

arch_read_lock 的实现：

static inline void arch_read_lock(arch_rwlock_t *rw)
{
       unsigned long tmp, tmp2;

       prefetchw(&rw->lock);
       __asm__ __volatile__(
"1:  ldrex     %0, [%2]\n" ----------- （0）
"      adds     %0, %0, #1\n" --------- （1）
"      strexpl  %1, %0, [%2]\n" ------- （2）
       WFE("mi") --------------------- （3）
"      rsbpls   %0, %1, #0\n" --------- （4）
"      bmi 1b" ----------------------- （5）
       : "=&r" (tmp), "=&r" (tmp2)
       : "r" (&rw->lock)
       : "cc");

       smp_mb();
}

（0） ： 标记独占，获取 rw->lock 的值并保存在 tmp 中

（1） ： tmp = tmp + 1 

（2） ： 如果 tmp 结果非负值，那么就执行该指令，将 tmp 值存入rw->lock

（3） ： 如果 tmp 是负值，说明有 write thread，那么就进入 wait for event 状态

（4） ： 判断strexpl指令是否成功执行

（5） ： 如果不成功，那么需要重新来过，否则持有锁，进入临界区

 

arch_read_unlock 的实现：

static inline void arch_read_unlock(arch_rwlock_t *rw)
{
       unsigned long tmp, tmp2;

       smp_mb();

       prefetchw(&rw->lock);
       __asm__ __volatile__(
"1:  ldrex     %0, [%2]\n" -----------（0）
"      sub %0, %0, #1\n" -------------（1）
"      strex      %1, %0, [%2]\n" -------（2）
"      teq  %1, #0\n" -----------------（3）
"      bne       1b" -----------------------（4）
       : "=&r" (tmp), "=&r" (tmp2)
       : "r" (&rw->lock)
       : "cc");

       if (tmp == 0)
              dsb_sev(); ----------------（5）
}

（0） ： 标记独占，获取 rw->lock 的值并保存在 tmp 中

（1） ： read 退出临界区，所以，tmp = tmp + 1 

（2） ： 将tmp值存入 rw->lock 中

（3） ：是否str成功，如果有其他thread在上面的过程插入进来就会失败

（4） ： 如果不成功，那么需要重新来过，否则离开临界区

（5） ： 如果read thread已经等于0，说明是最后一个离开临界区的 Reader，那么调用 sev 去唤醒 WF E的 CPU Core（配合 Writer 线程）

 

所以看起来，读-写锁使用了一个 32bits 的数来存储当前的状态，最高位代表着是否有写线程占用了锁，而低 31 位代表可以同时并发的读的数量，看起来现在至少是绰绰有余了。

 

小结

读-写锁自旋锁本质上还是属于自旋锁。只不过允许了并发的读操作，对于写和写，写和读之间，都需要互斥自旋等待。

注意读-写锁自旋锁的使用，避免死锁。

​​​​​​​合理运用内核提供的 APIs （诸如：write_lock_irqsave 等）。