一文搞懂 ， Linux内核—— 同步管理（下）

上面讲的自旋锁，信号量和互斥锁的实现，都是使用了原子 *** 作指令。由于原子 *** 作会 lock，当线程在多个 CPU 上争抢进入临界区的时候，都会 *** 作那个在多个 CPU 之间共享的数据 lock。CPU 0 *** 作了 lock，为了数据的一致性，CPU 0 的 *** 作会导致其他 CPU 的 L1 中的 lock 变成 invalid，在随后的来自其他 CPU 对 lock 的访问会导致 L1 cache miss（更准确的说是communication cache miss），必须从下一个 level 的 cache 中获取。

这就会使缓存一致性变得很糟，导致性能下降。所以内核提供一种新的同步方式：RCU（读-复制-更新）。

RCU 解决了什么

RCU 是读写锁的高性能版本，它的核心理念是读者访问的同时，写者可以更新访问对象的副本，但写者需要等待所有读者完成访问之后，才能删除老对象。读者没有任何同步开销，而写者的同步开销则取决于使用的写者间同步机制。

RCU 适用于需要频繁的读取数据，而相应修改数据并不多的情景，例如在文件系统中，经常需要查找定位目录，而对目录的修改相对来说并不多，这就是 RCU 发挥作用的最佳场景。

RCU 例子

RCU 常用的接口如下图所示：

为了更好的理解，在剖析 RCU 之前先看一个例子：

#include<linux/kernel.h>#include<linux/module.h>#include<linux/init.h>#include<linux/slab.h>#include<linux/spinlock.h>#include<linux/rcupdate.h>#include<linux/kthread.h>#include<linux/delay.h>structfoo{intastructrcu_headrcu}staticstructfoo*g_ptrstaticintmyrcu_reader_thread1(void*data)//读者线程1{structfoo*p1=NULLwhile(1){if(kthread_should_stop())breakmsleep(20)rcu_read_lock()mdelay(200)p1=rcu_dereference(g_ptr)if(p1)printk("%s: read a=%d\n",__func__,p1->a)rcu_read_unlock()}return0}staticintmyrcu_reader_thread2(void*data)//读者线程2{structfoo*p2=NULLwhile(1){if(kthread_should_stop())breakmsleep(30)rcu_read_lock()mdelay(100)p2=rcu_dereference(g_ptr)if(p2)printk("%s: read a=%d\n",__func__,p2->a)rcu_read_unlock()}return0}staticvoidmyrcu_del(structrcu_head*rh)//回收处理 *** 作{structfoo*p=container_of(rh,structfoo,rcu)printk("%s: a=%d\n",__func__,p->a)kfree(p)}staticintmyrcu_writer_thread(void*p)//写者线程{structfoo*oldstructfoo*new_ptrintvalue=(unsignedlong)pwhile(1){if(kthread_should_stop())breakmsleep(250)new_ptr=kmalloc(sizeof(structfoo),GFP_KERNEL)old=g_ptr*new_ptr=*oldnew_ptr->a=valuercu_assign_pointer(g_ptr,new_ptr)call_rcu(&old->rcu,myrcu_del)printk("%s: write to new %d\n",__func__,value)value++}return0}staticstructtask_struct*reader_thread1staticstructtask_struct*reader_thread2staticstructtask_struct*writer_threadstaticint__initmy_test_init(void){intvalue=5printk("figo: my module init\n")g_ptr=kzalloc(sizeof(structfoo),GFP_KERNEL)reader_thread1=kthread_run(myrcu_reader_thread1,NULL,"rcu_reader1")reader_thread2=kthread_run(myrcu_reader_thread2,NULL,"rcu_reader2")writer_thread=kthread_run(myrcu_writer_thread,(void*)(unsignedlong)value,"rcu_writer")return0}staticvoid__exitmy_test_exit(void){printk("goodbye\n")kthread_stop(reader_thread1)kthread_stop(reader_thread2)kthread_stop(writer_thread)if(g_ptr)kfree(g_ptr)}MODULE_LICENSE("GPL")module_init(my_test_init)module_exit(my_test_exit)

执行结果是：

myrcu_reader_thread2:reada=0myrcu_reader_thread1:reada=0myrcu_reader_thread2:reada=0myrcu_writer_thread:writetonew5myrcu_reader_thread2:reada=5myrcu_reader_thread1:reada=5myrcu_del:a=0

RCU 原理

可以用下面一张图来总结，当写线程 myrcu_writer_thread 写完后，会更新到另外两个读线程 myrcu_reader_thread1 和 myrcu_reader_thread2。读线程像是订阅者，一旦写线程对临界区有更新，写线程就像发布者一样通知到订阅者那里，如下图所示。

写者在拷贝副本修改后进行 update 时，首先把旧的临界资源数据移除（Removal）；然后把旧的数据进行回收（Reclamation）。结合 API 实现就是，首先使用 rcu_assign_pointer 来移除旧的指针指向，指向更新后的临界资源；然后使用 synchronize_rcu 或 call_rcu 来启动 Reclaimer，对旧的临界资源进行回收（其中 synchronize_rcu 表示同步等待回收，call_rcu 表示异步回收）。

为了确保没有读者正在访问要回收的临界资源，Reclaimer 需要等待所有的读者退出临界区，这个等待的时间叫做宽限期（Grace Period）。

Grace Period

中间的黄色部分代表的就是 Grace Period，中文叫做宽限期，从 Removal 到 Reclamation，中间就隔了一个宽限期，只有当宽限期结束后，才会触发回收的工作。宽限期的结束代表着 Reader 都已经退出了临界区，因此回收工作也就是安全的 *** 作了。

宽限期是否结束，与 CPU 的执行状态检测有关，也就是检测静止状态 Quiescent Status。

Quiescent Status

Quiescent Status，用于描述 CPU 的执行状态。当某个 CPU 正在访问 RCU 保护的临界区时，认为是活动的状态，而当它离开了临界区后，则认为它是静止的状态。当所有的 CPU 都至少经历过一次 Quiescent Status 后，宽限期将结束并触发回收工作。

因为 rcu_read_lock 和 rcu_read_unlock 分别是关闭抢占和打开抢占，如下所示：

staticinlinevoid__rcu_read_lock(void){preempt_disable()}

staticinlinevoid__rcu_read_unlock(void){preempt_enable()}

所以发生抢占，就说明不在 rcu_read_lock 和 rcu_read_unlock 之间，即已经完成访问或者还未开始访问。

Linux 同步方式的总结

资料免费领

学习直通车

Linux 内核设计的理念主要有这几个点：

MutiTask，多任务

SMP，对称多处理

ELF，可执行文件链接格式

Monolithic Kernel，宏内核

MutiTask

MutiTask 的意思是多任务，代表着 Linux 是一个多任务的 *** 作系统。多任务意味着可以有多个任务同时执行，这里的「同时」可以是并发或并行：

对于单核 CPU 时，可以让每个任务执行一小段时间，时间到就切换另外一个任务，从宏观角度看，一段时间内执行了多个任务，这被称为并发。

对于多核 CPU 时，多个任务可以同时被不同核心的 CPU 同时执行，这被称为并行。

SMP

SMP 的意思是对称多处理，代表着每个 CPU 的地位是相等的，对资源的使用权限也是相同的，多个 CPU 共享同一个内存，每个 CPU 都可以访问完整的内存和硬件资源。

这个特点决定了 Linux *** 作系统不会有某个 CPU 单独服务应用程序或内核程序，而是每个程序都可以被分配到任意一个 CPU 上被执行。

ELF

ELF 的意思是可执行文件链接格式，它是 Linux *** 作系统中可执行文件的存储格式

ELF 文件格式

ELF 把文件分成了一个个分段，每一个段都有自己的作用，具体每个段的作用这里就不详细说明了，感兴趣的同学可以去看《程序员的自我修养——链接、装载和库》这本书。

另外，ELF 文件有两种索引，Program header table 中记录了「运行时」所需的段，而 Section header table 记录了二进制文件中各个「段的首地址」。

那 ELF 文件怎么生成的呢？

我们编写的代码，首先通过「编译器」编译成汇编代码，接着通过「汇编器」变成目标代码，也就是目标文件，最后通过「链接器」把多个目标文件以及调用的各种函数库链接起来，形成一个可执行文件，也就是 ELF 文件。

那 ELF 文件是怎么被执行的呢？

执行 ELF 文件的时候，会通过「装载器」把 ELF 文件装载到内存里，CPU 读取内存中宏内核的特征是系统内核的所有模块，比如进程调度、内存管理、文件系统、设备驱动等，都运行在内核态。

不过，Linux 也实现了动态加载内核模块的功能，例如大部分设备驱动是以可加载模块的形式存在的，与内核其他模块解藕，让驱动开发和驱动加载更为方便、灵活。

---