linux内核锁机制-不可睡眠锁之RCU

最新推荐文章于 2023-08-23 14:37:32 发布
最新推荐文章于 2023-08-23 14:37:32 发布
阅读量1.3k 收藏
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cajan2/article/details/21344803
版权

RCU

 Read-Copy-Update

linux内核RCU的演变


 下面是一个使用rcu做读写的演示


#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/rcupdate.h>


#include "tmain.h"
MODULE_DESCRIPTION("The module is only used for test");
MODULE_VERSION("1.0.0");
MODULE_AUTHOR("David Zhang");
MODULE_LICENSE("GPL");


#define MAX_KTHREAD  10
static unsigned long reader_bitmap;
static void set_reader_number(int reader)
{
  WARN_ON((MAX_KTHREAD-reader) != 1);


  reader_bitmap=0;
  while(reader){
    reader_bitmap |= (1 << --reader);
  }
}
/*
unsigned int testpar= 0;
module_param(testpar, uint, S_IRUGO | S_IWUSR);
//static DEFINE_SPINLOCK(threads_lock);
static spinlock_t threads_lock;


static void threads_lock_init(void)
{
    //spin_lock_init
  spin_lock_init(&threads_lock);
}


*/


struct our_data{
  int count1;
  int count2;
};


static struct our_data my_data;

//to tell reader this pointer is protected by rcu
//linux kernel will check staticly when you use rcu_dereference, and source code is friendly to reader 
static struct our_data __rcu *pmy_data=&my_data;


static void reader_do(void)
{
   struct our_data *data;
   rcu_read_lock();
   data = rcu_dereference(pmy_data);
   printk("read count1 %d, count2 %d.\n",data->count1,data->count2);
   rcu_read_unlock();
}


static void writer_do(void)
{
  struct our_data *data, *tmp=pmy_data;
  data = kmalloc(sizeof(*data),GFP_KERNEL);
  if(!data)
    return;
  //Read + Copy. */
  memcpy(data,pmy_data,sizeof(*data));
  data->count1++;
  data->count2 +=10;
  
  rcu_assign_pointer(pmy_data,data);
  if(tmp != &my_data)
  {
    synchronize_rcu();
    kfree(tmp);
    printk("write completed!");


  }
  //Update


}

static struct task_struct *threads[MAX_KTHREAD];


static int thread_do(void *data)
{
long i=(long)data;
int isReader=reader_bitmap & (1 << i);
printk("run ...%ld %s \n",i,isReader?"reader":"writer");
while(!kthread_should_stop())
{
 if(isReader)
   reader_do();
   else
   writer_do();
 msleep(10);
}
return 0;
}


static void show_my_data(void)
{
   printk("my_data,count1:%d,count2:%d\n",pmy_data->count1,pmy_data->count2);
   
}


static int create_threads(void)
{
int i;
for(i=0;i<MAX_KTHREAD;i++){
struct task_struct *thread;
thread=kthread_run(thread_do,(void *)(long)i,"thread-%d",i);
if(IS_ERR(thread))
 return -1;
threads[i]=thread;


}
return 0;
}


static void cleanup_threads(void)
{
int i;
for(i=0;i<MAX_KTHREAD;i++)
{
 if(threads[i]){
   kthread_stop(threads[i]);
 }
}
}


static __init int minit(void)
{
// printk("testpar= %#x.\n",testpar);
printk("call %s.\n",__FUNCTION__);
// other_function();
set_reader_number(9);
if(create_threads())
{
 cleanup_threads();
 return -1;
}
return 0;
}


static __exit void mexit(void)
{
printk("call %s.\n",__FUNCTION__);
show_my_data();
}


module_init(minit)
module_exit(mexit)


//

sudo dmesg -c

sudo rmmod rcumain

sudo dmesg -c

sudo insmod rcumain.ko

sudo dmesg -c

[21685.846012] read count1 736, count2 7360.
[21685.846026] read count1 736, count2 7360.
[21685.846048] read count1 736, count2 7360.
[21685.849910] read count1 736, count2 7360.
[21685.849920] read count1 736, count2 7360.
[21685.857896] read count1 736, count2 7360.
[21685.857917] read count1 737, count2 7370.
[21685.861919] read count1 737, count2 7370.
[21685.861930] read count1 737, count2 7370.
[21685.861934] read count1 737, count2 7370.
[21685.861942] read count1 737, count2 7370.
[21685.861950] read count1 737, count2 7370.
[21685.865947] read count1 737, count2 7370.
[21685.865951] read count1 737, count2 7370.
[21685.873999] read count1 737, count2 7370.
[21685.874012] read count1 737, count2 7370.
[21685.878018] read count1 737, count2 7370.
[21685.878042] write completed!
[21685.878042] read count1 737, count2 7370.
[21685.878052] read count1 737, count2 7370.
[21685.878058] read count1 737, count2 7370.
[21685.878071] read count1 737, count2 7370.
[21685.881994] read count1 737, count2 7370.
[21685.882041] read count1 737, count2 7370.
[21685.889995] read count1 737, count2 7370.
[21685.890014] read count1 737, count2 7370.
[21685.894022] read count1 737, count2 7370.
[21685.894030] read count1 737, count2 7370.
[21685.894034] read count1 737, count2 7370.
[21685.894047] read count1 737, count2 7370.
[21685.894071] read count1 738, count2 7380.
[21685.898010] read count1 738, count2 7380.
[21685.898032] read count1 738, count2 7380.
[21685.906007] read count1 738, count2 7380.
[21685.906039] read count1 738, count2 7380.
[21685.910028] read count1 738, count2 7380.
[21685.910033] read count1 738, count2 7380.
[21685.910054] read count1 738, count2 7380.
[21685.910059] read count1 738, count2 7380.
[21685.910087] read count1 738, count2 7380.
[21685.913979] write completed!
[21685.913980] read count1 738, count2 7380.
[21685.913992] read count1 738, count2 7380.
[21685.922028] read count1 738, count2 7380.
[21685.922039] read count1 738, count2 7380.
[21685.926040] read count1 738, count2 7380.
[21685.926056] read count1 738, count2 7380.
[21685.926060] read count1 738, count2 7380.
[21685.926069] read count1 738, count2 7380.
[21685.926081] read count1 739, count2 7390.
[21685.929972] read count1 739, count2 7390.
[21685.929983] read count1 739, count2 7390.
[21685.938034] read count1 739, count2 7390.
[21685.938050] read count1 739, count2 7390.
[21685.942048] read count1 739, count2 7390.
[21685.942056] read count1 739, count2 7390.
[21685.942070] read count1 739, count2 7390.
[21685.942095] read count1 739, count2 7390.
[21685.942106] write completed!
[21685.942107] read count1 739, count2 7390.
[21685.946061] read count1 739, count2 7390.
[21685.946067] read count1 739, count2 7390.
[21685.954022] read count1 739, count2 7390.
[21685.954039] read count1 739, count2 7390.
[21685.958001] read count1 739, count2 7390.
[21685.958010] read count1 739, count2 7390.
[21685.958038] read count1 739, count2 7390.
[21685.958055] read count1 739, count2 7390.
[21685.962051] read count1 739, count2 7390.
[21685.962071] read count1 739, count2 7390.
[21685.962083] read count1 739, count2 7390.
[21685.970068] read count1 740, count2 7400.
[21685.970106] read count1 740, count2 7400.
[21685.974073] read count1 740, count2 7400.
[21685.974108] read count1 740, count2 7400.
[21685.974140] read count1 740, count2 7400.
[21685.974156] read count1 740, count2 7400.
[21685.978060] read count1 740, count2 7400.
[21685.978081] read count1 740, count2 7400.
[21685.978084] read count1 740, count2 7400.
[21685.986083] read count1 740, count2 7400.
[21685.986091] read count1 740, count2 7400.
[21685.989117] write completed!
[21685.990030] read count1 740, count2 7400.
[21685.990039] read count1 740, count2 7400.
[21685.990046] read count1 740, count2 7400.
[21685.990056] read count1 740, count2 7400.
[21685.994081] read count1 740, count2 7400.
[21685.994088] read count1 740, count2 7400.
[21685.994104] read count1 740, count2 7400.
[21686.002038] read count1 740, count2 7400.
[21686.002045] read count1 740, count2 7400.
[21686.006030] read count1 741, count2 7410.
[21686.006050] read count1 741, count2 7410.
[21686.006059] read count1 741, count2 7410.
[21686.006070] read count1 741, count2 7410.
[21686.010040] read count1 741, count2 7410.
[21686.010074] read count1 741, count2 7410.
[21686.010084] read count1 741, count2 7410.
[21686.014687] write completed!
[21686.018046] read count1 741, count2 7410.
[21686.018053] read count1 741, count2 7410.
[21686.022043] read count1 741, count2 7410.
[21686.022059] read count1 741, count2 7410.
[21686.022061] read count1 741, count2 7410.
[21686.022073] read count1 741, count2 7410.
[21686.026037] read count1 741, count2 7410.
[21686.026048] read count1 741, count2 7410.
[21686.026075] read count1 741, count2 7410.

=============

call_rcu vs. synchronize_rcu



static void rcu_free(struct rcu_head *head)
{
   struct our_data *data;
   data =container_of(head,struct our_data,rhead);
   printk("rcu_free is called!");
   kfree(data);
}
static void writer_do(void)
{
  struct our_data *data, *tmp=pmy_data;
  data = kmalloc(sizeof(*data),GFP_KERNEL);
  if(!data)
    return;
  //Read + Copy. */
  memcpy(data,pmy_data,sizeof(*data));
  data->count1++;
  data->count2 +=10;
  
  rcu_assign_pointer(pmy_data,data);
  if(tmp != &my_data)
  {
    call_rcu(&tmp->rhead,rcu_free);
  }
  //Update


}

[  140.690494] read count1 49, count2 490.
[  140.690505] read count1 49, count2 490.
[  140.690526] read count1 50, count2 500.
[  140.706419] rcu_free is called!
[  140.706462] read count1 50, count2 500.
[  140.706466] read count1 50, count2 500.
[  140.706471] read count1 50, count2 500.
[  140.706484] read count1 50, count2 500.
[  140.706488] read count1 50, count2 500.
[  140.706497] read count1 50, count2 500.
[  140.706510] read count1 50, count2 500.
[  140.706511] read count1 50, count2 500.
[  140.706515] read count1 50, count2 500.
[  140.722388] rcu_free is called!
[  140.722439] read count1 51, count2 510.
[  140.722444] read count1 51, count2 510.
[  140.722447] read count1 51, count2 510.
[  140.722452] read count1 51, count2 510.
[  140.722465] read count1 51, count2 510.
[  140.722473] read count1 51, count2 510.
[  140.722480] read count1 51, count2 510.
[  140.722487] read count1 52, count2 520.
[  140.722508] read count1 52, count2 520.
[  140.738443] rcu_free is called!
[  140.738478] rcu_free is called!read count1 52, count2 520.
[  140.738495] read count1 52, count2 520.
[  140.738521] read count1 52, count2 520.
[  140.738525] read count1 52, count2 520.
[  140.738529] read count1 52, count2 520.
[  140.738536] read count1 52, count2 520.
[  140.738542] read count1 52, count2 520.
[  140.738557] read count1 52, count2 520.
[  140.738560] read count1 52, count2 520.
[  140.754488] read count1 53, count2 530.
[  140.754494] read count1 53, count2 530.
[  140.754513] read count1 53, count2 530.
[  140.754528] read count1 53, count2 530.
[  140.754546] read count1 53, count2 530.
[  140.754558] read count1 53, count2 530.
[  140.754562] read count1 53, count2 530.
[  140.754587] read count1 54, count2 540.
[  140.754590] read count1 54, count2 540.
[  140.770496] rcu_free is called!
[  140.770497] read count1 54, count2 540.
[  140.770510] read count1 54, count2 540.
[  140.770518] read count1 54, count2 540.
[  140.770523] read count1 54, count2 540.
[  140.770529] read count1 54, count2 540.
[  140.770539] read count1 54, count2 540.
[  140.770543] read count1 54, count2 540.
[  140.770556] read count1 54, count2 540.
[  140.770589] read count1 54, count2 540.
[  140.786502] rcu_free is called!
[  140.786503] read count1 55, count2 550.
[  140.786543] read count1 55, count2 550.
[  140.786547] read count1 55, count2 550.
[  140.786557] read count1 55, count2 550.
[  140.786563] read count1 55, count2 550.
[  140.786569] read count1 55, count2 550.
[  140.786574] read count1 55, count2 550.
[  140.786618] read count1 56, count2 560.
[  140.786644] read count1 56, count2 560.
[  140.802465] read count1 56, count2 560.
[  140.802491] rcu_free is called!
[  140.802523] read count1 56, count2 560.
[  140.802526] read count1 56, count2 560.
[  140.802529] read count1 56, count2 560.
[  140.802538] read count1 56, count2 560.
[  140.802544] read count1 56, count2 560.
[  140.802560] read count1 56, count2 560.
[  140.802563] read count1 56, count2 560.
[  140.802573] read count1 56, count2 560.
[  140.818512] rcu_free is called!
[  140.818512] read count1 57, count2 570.

cajan2
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 内核RCU机制分析
02-26
本文章主要分为3个章节来介绍linux 内核中RCU 机制。首先分析RCU机制的原理及发布-订阅机制，原理部分介绍都配有图形方便理解其原理机制。在理解了rcu原理机制基础上文章会详细介绍linux 内核中RCU 的核心API的用法及注意事项，方便读者快速准确的使用这些API来保护并发资源。最后会给出linux 内核使用RCU的示例。该文章是一篇很好的理解使用linux RCU机制的文章。
内核的rcu锁移植到就应用层的实现
01-29
内核的rcu锁移植到就应用层的实现
进程不能睡眠的情况
angle_birds的专栏
12-14 573
进程不能睡眠的情况： 1、进程已经持有一个自旋锁、seqlock、rcu锁 2、在进程中关闭了中断 3、除非能确保，在某处，能够找到这个进程，并且可以唤醒此进程；否则，不应进入睡眠。 使用等待队列 写数据时，如果无空间可写，则应进入睡眠，但应检查执行睡眠代码时，是否有空间可写，避免发生“先唤醒，后睡眠”，即将要执行睡眠代码时，读操作释放了空间，释放空间后会
RCU到底是什么？为什么快？为什么可以读写并行？
遇见你是我最美丽的意外
10-16 5990
文章目录RCU经典文献RCU锁特点介绍RCU中常见问题1. 有没有使用引用计数2. RCU既然没有使用引用计数，那又是确定是否存在读者引用之？3. RCU 读端和写端同时操作，不会触发段错误吗？4. RCU 与资源回收 RCU经典文献 What is RCU, Fundamentally? What is RCU? Part 2: Usage RCU part 3: the RCU API linux kernel RCU作者的主页介绍 这几个连接简直就是一个宝藏，里面的干活很多很多！！！
真香！终于知道怎么解决c++死锁了
adlatereturn的博客
10-18 1857
死锁 在写c/c++的过程中遇到死锁常常会让我们手无足错，因为死锁往往不像其他类型的错误一样会在终端直接打印报错，因此难以被发现并需要大量精力去排错。是时候思考，该如何防范或者避免死锁。 死锁场景1 在类里面或者全局无意识的使用过多的锁，并在函数中调用这些锁的时候未注意到锁的次序。如一个线程执行函数fun1时锁的顺序是Ａ－>B－>Ｃ，另一个线程执行fun2时锁的顺序是Ｃ－>B－>Ａ ,除非能保证fun1，fun2不会同时执行，否则及其容易发生死锁。 解决途径1 如果使用
为什么拥有自旋锁的代码段不能睡眠？
liaojunwu的博客
09-21 1227
参考博文: 宋宝华： 是谁关闭了Linux抢占，而抢占又关闭了谁？ Linux中的preempt_count - 知乎 [宏]preempt_disable - DoOrDie - 博客园 LInux中ThreadInfo中的preempt_count字段 - jack.chen - 博客园 Linux进程内核栈与thread_info结构详解--Linux进程的管理与调度（九）_OSKernelLAB(gatieme)-CSDN博客_thread_info linux - Why can't
【C++ 多线程：读写锁的实现及使用样例】
最新发布
Sugar_wolf的博客
08-23 728
【C++ 多线程（五）：读写锁的实现及使用样例】
为什么使用spinlock的时候不能睡眠
sabolasi
12-10 240
跟踪一下spin_lock(&amp;mr_lock)的实现 #define spin_lock(lock) _spin_lock(lock) #define _spin_lock(lock) __LOCK(lock) #define __LOCK(lock) / do { preempt_disable(); __acquire(lock); (void)(lock); } whil...
C语言提供的线程/进程间同步（锁）机制
海棠花的博客
12-31 5952
##C语言提供的线程间同步（锁）机制 /usr/include/pthread.h中提供 1、互斥体 （Mutex） 描述：互斥体是比信号量更为简单是睡眠锁。 使用范围：最为常用 /* Initialize a mutex. */ extern int pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) __THROW __nonnull...
C++新特性33_死锁产生的原因及避免（线程在等待一个永远都不能成功的条件成立，从而进入到陷入休眠，永远不能被唤醒的状态；通过调整锁的使用顺序解决死锁问题）
分享学习成长历程，Winter is coming！
03-07 646
上篇：C++新特性32_C++中mutex与lock_guard的使用（采用上篇类似方法封装至C++的标准库中）讲了在C++标准库中实现线程锁的方法，本篇主要介绍在使用多线程的过程中常遇到的死锁问题。 1. 死锁及产生原因 线程（程序）在等待一个永远都不能成功的条件成立，从而进入到陷入休眠，永远不能被唤醒的状态。 举例1：两个线程互相等待 原理：线程A获取锁1，只有锁2被线程B释放才可以获取锁2，线程B获取锁2，只有锁1被线程A释放才可以获取锁1，双方不断的在等待对方释放锁，但一直等不到对方释放。 线程A：
Linux内核RCU机制详解
01-09
　RCU（Read-Copy Update）是数据同步的一种方式，在当前的Linux内核中发挥着重要的作用。RCU主要针对的数据对象是链表，目的是提高遍历读取数据的效率，为了达到目的使用RCU机制读取数据的时候不对链表进行耗时的...
Linux内核的同步机制
11-10
在主流的Linux内核中包含了几乎所有现代的操作系统具有的同步机制，这些同步机制包括：原子操作、信号量（semaphore）、读写信号量（rw_semaphore）、spinlock、BKL(Big Kernel Lock)、rwlock、brlock（只包含在2.4...
rcu_example:linux内核的rcu示例。 标签
04-30
rcu_example linux内核的rcu示例。 标记：rcu，列表rcu，linux内核rcu，内核rcu，读取副本更新，rcu示例 作者 金本公园
flask实例项目发布到centos-nginx+uWSGI+flask
cajan2的专栏
05-25 3902
flask实例项目发布到centos-nginx+uWSGI+flask     flask做的微博microblog发布到centos服务器，反向代理使用nginx， wsgi采用uWSGI。         nginx采用源码编译安装 第一步.nginx安装和配置        参考http://www.nginx.cn/install centos平台编译环境使用如下
ubuntu蓝牙bluez
cajan2的专栏
05-14 3043
Ubuntu和BlueZ BLE 1. Ubuntu12.04查看BlueZ版本： ＃dpkg --status bluez | grep '^Version:' Version: 4.98-2ubuntu7 http://www.ioncannon.net/linux/1570/bluetooth-4-0-le-on-raspberry-pi-with-bluez-5-x/ 2
linux内核编程-可睡眠锁之SRCU
cajan2的专栏
05-12 2684
linux内核编程-可睡眠锁之SRCU DEFINE_SRCU DEFINE_SRCU_STATIC static修饰的定义只能在该c文件中使用，用于保护命名空间。 如果一个函数里面使用了static，这是相当与一个全局变量，但是他的有效范围只能在该函数内，其他地方不能使用。 /*  * define and init a srcu struct at build ti
linux内核锁机制实例代码-不可睡眠锁之自旋锁之二
cajan2的专栏
05-12 1335
spinlock.h DEFINE_SPINLOCK 在kernel里面找到一个使用他的例子 获取锁 static inline void spin_lock(spinlock_t *lock) { raw_spin_lock(&lock->rlock); } static DEFINE_SPINLOCK(threads_lock); struct our_d
linux内核锁机制实例代码-不可睡眠锁之自旋锁之一
cajan2的专栏
05-12 1303
锁机制 不可睡眠锁   自旋锁示例代码 kthread.h   kthread_run() #define kthread_create(threadfn, data, namefmt, arg...) \ kthread_create_on_node(threadfn, data, -1, namefmt, ##arg) struct task_struct *
详细介绍Linux内核的rcu stall的机制
07-17
Linux内核中的RCU（Read-Copy-Update）机制是一种用于实现高效并发访问共享数据的技术。在RCU机制中，读操作不会被阻塞，而写操作则通过延迟更新来避免对读操作的影响。然而，当某些情况下读操作被长时间阻塞时，就...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值