Linux 设备驱动 ====> 并发控制 --- 原子操作

时间:2021-06-26 23:36:14

原子操作

原子的操作指的就是在执行过程中不会被别的代码所中断的操作。

Linux中原子操作的方法有很多,有整型原子和位原子,他们在任何情况下操作都是原子的,这些原子操作的实现都是依赖CPU来实现的,因此这些函数都与CPU架构密切相关。


整型原子

我们arm架构的原子实现在kernel/arch/arm/include/asm/atomic.h

1. 设置源自变量的值

  1. static inline void atomic_set(atomic_t *v, int i);            //设置原子的值  
  2. atomic_t = ATOMIC_INIT(0);                                    //定义原子变量并且初始化为0  
Linux 设备驱动 ====> 并发控制 --- 原子操作

2. 获取原子变量的值

  1. #define atomic_read(v)  ((v)->counter)                         //返回原子变量的值  
Linux 设备驱动 ====> 并发控制 --- 原子操作

3. 原子变量加减,自增自减

  1. #define atomic_add(i, v)    (void) atomic_add_return(i, v)  
  2. #define atomic_inc(v)       (void) atomic_add_return(1, v)  
  3. #define atomic_sub(i, v)    (void) atomic_sub_return(i, v)  
  4. #define atomic_dec(v)       (void) atomic_sub_return(1, v)  
Linux 设备驱动 ====> 并发控制 --- 原子操作

4. 操作并测试

  1. int atomic_inc_and_test(atomic_t *v);  
  2. int atomic_dec_and_test(atomic_t *v);  
  3. int atomic_sub_and_test(int i, atomic_t *v);  
Linux 设备驱动 ====> 并发控制 --- 原子操作

上述操作对原子变量执行自增、自减和减操作后测试其是否为0,为-则返回true,否则返回false。

5. 操作并返回

  1. int atomic_add_return(int i,atomic_t *v);  
  2. <pre name="code" class="cpp">int atomic_sub_return(int i,atomic_t *v);</pre><pre name="code" class="cpp">int atomic_inc_return(atomic_t *v);</pre><pre name="code" class="cpp">int atomic_dec_return(atomic_t *v);</pre><p></p>  
  3. <pre></pre>  
  4. <br>  
  5. 返回新值。  
  6. <p></p>  
  7. <p><strong><span style="font-size:16px">位原子操作与整型雷同</span></strong></p>  
  8. <p><strong><span style="font-size:16px"><br>  
  9. </span></strong></p>  
  10. <p><span style="font-size:16px"><strong>举个例子---使用原子变量实现设备只能被一个进程打开。</strong></span></p>  
  11. <p>我们写一个小小的应用程序,打开之前我们的字符设备,然后sleep 10秒钟,然后再close,</p>  
  12. <p></p><pre name="code" class="cpp">#include <stdio.h>  
  13. #include <fcntl.h>  
  14. #include <unistd.h>  
  15.   
  16. int main()  
  17. {  
  18.     int fd;  
  19.     fd = open("/dev/globalmem",O_RDWR);  
  20.     if(fd == -1) {  
  21.         printf("open error!!\n");  
  22.         return -1;  
  23.     }  
  24.     sleep(10);  
  25.     printf("close fd!\n");  
  26.     close(fd);  
  27.     return 0;  
  28. }</pre><br>  
  29. 我们在这sleep的10秒内去cat /dev/globalmem<p></p>  
  30. <p></p><pre name="code" class="plain">root@jay-LJ:/dev# cat globalmem   
  31. Hello globalmem driver  
  32. </pre><br>  
  33. 还是可以cat出来的,如果有好多个进程都要读写我们的globalmem的话就会产生竞态,会导致读出来的数据有问题,所以这里我们让我们的驱动在同一时间只能由一个进程来访问。<p></p>  
  34. <p>修改驱动代码如下</p>  
  35. <p></p><pre name="code" class="cpp">static atomic_t globalmem_available = ATOMIC_INIT(1);   //define atomic valiable  
  36.   
  37. int globalmem_open(struct inode *inode, struct file *filp)  
  38. {  
  39.     if(!atomic_dec_and_test(&globalmem_available)) {  
  40.         printk(KERN_ERR "already open!\n");  
  41.         atomic_inc(&globalmem_available);  
  42.         return -EBUSY;  //already open  
  43.     }  
  44.     printk(KERN_INFO "globalmem open!\n");  
  45.     filp->private_data = globalmem_devp;   
  46.     return 0;  
  47. }  
  48.   
  49. int globalmem_release(struct inode *inode ,struct file *filp)  
  50. {  
  51.     printk(KERN_INFO "globalmem release!\n");  
  52.     atomic_inc(&globalmem_available);  
  53.     return 0;  
  54. }</pre><br>  
  55. 很简单,使用我们的atomic_dec_and_test来进行原子的测试并返回,然后检测返回值来查看该设备是否已经被打开,最后在close的时候再自加1.<p></p>  
  56. <p>我们重新编译驱动,然后加载,并跟之前一样来测试,发现在打开之后还没关闭的时候,我们去cat会发生错误,提示设备忙。</p>  
  57. <p></p><pre name="code" class="plain">root@jay-LJ:/dev# cat globalmem   
  58. cat: globalmem: Device or resource busy  
  59. root@jay-LJ:/dev#   
  60. </pre><p></p>  
  61. <p><br>  
  62. </p>  
  63. 原子的操作介绍到这里,结束。<br>  
  64. =================================================================  
  65. <p></p>  
  66. <p style="margin-top:0px; margin-bottom:0px; padding-top:0px; padding-bottom:0px; font-family:Arial; font-size:14px; line-height:26px; text-align:left">  
  67. mail & MSN :zhangjie201412@live.com</p>  
  68. <p style="margin-top:0px; margin-bottom:0px; padding-top:0px; padding-bottom:0px; font-family:Arial; font-size:14px; line-height:26px; text-align:left">  
  69. =========================================================</p>  
  70. <br>  
  71.      
Linux 设备驱动 ====> 并发控制 --- 原子操作
  1. int atomic_sub_return(int i,atomic_t *v);  
Linux 设备驱动 ====> 并发控制 --- 原子操作
  1. int atomic_inc_return(atomic_t *v);  
Linux 设备驱动 ====> 并发控制 --- 原子操作
  1. int atomic_dec_return(atomic_t *v);  
Linux 设备驱动 ====> 并发控制 --- 原子操作

 

返回新值。

位原子操作与整型雷同


举个例子---使用原子变量实现设备只能被一个进程打开。

我们写一个小小的应用程序,打开之前我们的字符设备,然后sleep 10秒钟,然后再close,

  1. #include <stdio.h>  
  2. #include <fcntl.h>  
  3. #include <unistd.h>  
  4.   
  5. int main()  
  6. {  
  7.     int fd;  
  8.     fd = open("/dev/globalmem",O_RDWR);  
  9.     if(fd == -1) {  
  10.         printf("open error!!\n");  
  11.         return -1;  
  12.     }  
  13.     sleep(10);  
  14.     printf("close fd!\n");  
  15.     close(fd);  
  16.     return 0;  
  17. }  
Linux 设备驱动 ====> 并发控制 --- 原子操作

我们在这sleep的10秒内去cat /dev/globalmem

  1. root@jay-LJ:/dev# cat globalmem   
  2. Hello globalmem driver  
Linux 设备驱动 ====> 并发控制 --- 原子操作

还是可以cat出来的,如果有好多个进程都要读写我们的globalmem的话就会产生竞态,会导致读出来的数据有问题,所以这里我们让我们的驱动在同一时间只能由一个进程来访问。

修改驱动代码如下

  1. static atomic_t globalmem_available = ATOMIC_INIT(1);   //define atomic valiable  
  2.   
  3. int globalmem_open(struct inode *inode, struct file *filp)  
  4. {  
  5.     if(!atomic_dec_and_test(&globalmem_available)) {  
  6.         printk(KERN_ERR "already open!\n");  
  7.         atomic_inc(&globalmem_available);  
  8.         return -EBUSY;  //already open  
  9.     }  
  10.     printk(KERN_INFO "globalmem open!\n");  
  11.     filp->private_data = globalmem_devp;   
  12.     return 0;  
  13. }  
  14.   
  15. int globalmem_release(struct inode *inode ,struct file *filp)  
  16. {  
  17.     printk(KERN_INFO "globalmem release!\n");  
  18.     atomic_inc(&globalmem_available);  
  19.     return 0;  
  20. }  
Linux 设备驱动 ====> 并发控制 --- 原子操作

很简单,使用我们的atomic_dec_and_test来进行原子的测试并返回,然后检测返回值来查看该设备是否已经被打开,最后在close的时候再自加1.

我们重新编译驱动,然后加载,并跟之前一样来测试,发现在打开之后还没关闭的时候,我们去cat会发生错误,提示设备忙。

  1. root@jay-LJ:/dev# cat globalmem   
  2. cat: globalmem: Device or resource busy  
  3. root@jay-LJ:/dev#   
Linux 设备驱动 ====> 并发控制 --- 原子操作


原子的操作介绍到这里,结束。
=================================================================

mail & MSN :zhangjie201412@live.com

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