位原子操作

一、理论：

1.并发
并发的概念是：多个执行单元同时、并行被执行。
Linux系统是多任务的，很多任务会同时执行。
假如有三个执行单元ABC，共享了内存资源。
执行单元A对Buffer写1000个“a”；
执行单元B对Buffer写1000个“b”；
执行单元C从buffer中读取数据。
如果按照A写→C读→B写→C读，当然没有问题。
但是如果A写→B写→C读，执行单元C就出问题了。
当然比这个复杂更多，更加混乱的并发操作存在设备驱动中，
只要有多个进程对共享资源的同时访问，就可能出现竞态。
2.竞态
以下三种情况会导致竞态。
对称多处理的多个CPU
单CPU内进程和抢占它的进程
中断和进程
3.竞态的解决方法
解决竞态的途径是“保证对共享资源的互斥访问”
也就是一个执行单元在访问共享资源的时候，其它的执行单元被禁止访问。
访问共享资源的代码区称为临界区，临界区需要使用互斥机制来保护。

4.Linux操作系统中提供实现互斥的方法：
原子操作、自旋锁、信号量、互斥体等。
我们后续的视频介绍原子操作，自旋锁，互斥体

二、函数

1.直接列出内核中提供的宏定义
宏定义：test_bit 返回位原子值
宏定义：set_bit 设置位

宏定义：clear_bit 清除位

1.  //将addr的第nr(nr为0-31)位置值置为1;  
2.         //nr大于31时，把高27的值做为当前地址的偏移，低5位的值为要置为1的位数  
3. extern __inline__ int set_bit(int nr,int * addr)  
4. {      
5. int mask, retval;         
6. addr += nr >> 5;                 //nr大于31时，把高27的值做为当前地址的偏移，      
7. mask = 1 << (nr & 0x1f);         //获取31范围内的值，并把1向左偏移该位数      
8. *addr |= mask;       sti();                           //开所有中断      
9. cli();                           //关所有中断      
10. retval = (mask & *addr) != 0;    //位置置1      
11. //nr大于31时，把高27的值做为当前地址的偏移，低5位的值为要置为0的位数；  
12. return retval;                   //返回置数值  
13. }     
14.        
16.          //将addr的第nr(nr为0-31)位置值置为0;  
17. extern __inline__ int clear_bit(int nr, int * addr)  
18. retval = (mask & *addr) != 0;      
19. {      
20. int mask, retval;         
21. addr += nr >> 5;      
22. mask = 1 << (nr & 0x1f);      
23. cli();      
24. *addr &= ~mask;      
25. extern __inline__ int test_bit(int nr, int * addr)  
26. sti();      
27. return retval;  
28. }     
31. //判断addr的第nr(nr为0-31)位置的值是否为1;  
32. //nr大于31时，把高27的值做为当前地址的偏移，低5位的值为要判断的位数；  
33.         extern __inline__ int test_bit(int nr, int * addr)  
34. {      
35. int mask;         
36. addr += nr >> 5;      
37. mask = 1 << (nr & 0x1f);      
38. return ((mask & *addr) != 0);  
39. }

三、实例

1、驱动程序

1. #include <linux/init.h>
2. #include <linux/module.h>
4. /*驱动注册的头文件，包含驱动的结构体和注册和卸载的函数*/
5. #include <linux/platform_device.h>
6. /*注册杂项设备头文件*/
7. #include <linux/miscdevice.h>
8. /*注册设备节点的文件结构体*/
9. #include <linux/fs.h>
10. //原子操作的函数头文件
11. #include <asm/atomic.h>
12. #include <asm/types.h>
14. #define DRIVER_NAME "atomic_bit"
15. #define DEVICE_NAME "atomic_bit"
16. MODULE_LICENSE("Dual BSD/GPL");
17. MODULE_AUTHOR("TOPEET");
19. //定义原子变量,并初始化为0
20. //static atomic_t value_atomic = ATOMIC_INIT(0);
23. unsigned long int value_bit = 0;
25. static int atomic_bit_open(struct inode *inode, struct file *file){
26. printk(KERN_EMERG "atomic_bit open in!\n");
28. /*if(atomic_read(&value_atomic)){
29. return -EBUSY;
30. }*/
32. //atomic_inc(&value_atomic);
33. if(test_bit(0,&value_bit)!=0){
34. return -EBUSY;
35. }
37. set_bit(0,&value_bit);
39. printk(KERN_EMERG "atomic_bit open success!\n");
40. return 0;
41. }
43. static int atomic_bit_release(struct inode *inode, struct file *file){
44. printk(KERN_EMERG "atomic_bit release\n");
46. clear_bit(0,&value_bit);
47. //atomic_dec(&value_atomic);
49. return 0;
50. }
52. static struct file_operations atomic_bit_ops = {
53. .owner = THIS_MODULE,
54. .open = atomic_bit_open,
55. .release = atomic_bit_release,
56. };
59. static struct miscdevice atomic_bit_dev = {
60. .minor = MISC_DYNAMIC_MINOR,
61. .name = DEVICE_NAME,
62. .fops = &atomic_bit_ops,
63. };
66. static int atomic_bit_probe(struct platform_device *pdv){
68. printk(KERN_EMERG "\tinitialized\n");
69. misc_register(&atomic_bit_dev);
71. return 0;
72. }
74. static int atomic_bit_remove(struct platform_device *pdv){
76. printk(KERN_EMERG "\tremove\n");
77. misc_deregister(&atomic_bit_dev);
78. return 0;
79. }
81. struct platform_driver atomic_bit_driver = {
82. .probe = atomic_bit_probe,
83. .remove = atomic_bit_remove,
84. .driver = {
85. .name = DRIVER_NAME,
86. .owner = THIS_MODULE,
87. }
88. };
91. static int atomic_bit_init(void)
92. {
93. int DriverState;
95. printk(KERN_EMERG "HELLO WORLD enter!\n");
96. DriverState = platform_driver_register(&atomic_bit_driver);
98. printk(KERN_EMERG "\tDriverState is %d\n",DriverState);
99. return 0;
100. }
103. static void atomic_bit_exit(void)
104. {
105. printk(KERN_EMERG "HELLO WORLD exit!\n");
107. platform_driver_unregister(&atomic_bit_driver);
108. }
110. module_init(atomic_bit_init);
111. module_exit(atomic_bit_exit);

2、测试程序

1. #include <stdio.h>
3. #include <sys/types.h>
4. #include <sys/stat.h>
5. #include <fcntl.h>
6. #include <unistd.h>
7. #include <sys/ioctl.h>
8. #include <errno.h>
10. int main(int argc,char **argv){
11. char *atomic_bit = "/dev/atomic_bit";
12. int fd1;
14. if((fd1 = open(atomic_bit,O_RDWR|O_NDELAY))==0){
15. printf("%s open %s success\n",argv[0],atomic_bit);
16. }
17. else{
18. perror(argv[0]);
19. }
21. while(1);
22. close(fd1);
23. }
24. #include <stdio.h>
26. #include <sys/types.h>
27. #include <sys/stat.h>
28. #include <fcntl.h>
29. #include <unistd.h>
30. #include <sys/ioctl.h>
31. #include <errno.h>
33. int main(int argc,char **argv){
34. char *atomic_bit = "/dev/atomic_bit";
35. int fd1;
37. if((fd1 = open(atomic_bit,O_RDWR|O_NDELAY))==0){
38. printf("%s open %s success!\n",argv[0],atomic_bit);
39. }
40. else{
41. perror(argv[0]);
42. }
44. while(1);
45. close(fd1);
46. }