芯灵思SinlinxA33开发板Linux内核原子操作(附实测代码)

小.易

• 原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何线程切换。
• 原子操作是不可分割的，在执行完毕之前不会被任何其它任务或事件中断。在单处理器系统（UniProcessor）中，能够在单条指令中完成的操作都可以认为是" 原子操作"，因为中断只能发生于指令之间。这也是某些CPU指令系统中引入了test_and_set、test_and_clear等指令用于临界资源互斥的原因。但是，在对称多处理器（Symmetric Multi-Processor）结构中就不同了，由于系统中有多个处理器在独立地运行，即使能在单条指令中完成的操作也有可能受到干扰。我们以decl （递减指令）为例，这是一个典型的"读－改－写"过程，涉及两次内存访问。设想在不同CPU运行的两个进程都在递减某个计数值，可能发生的情况是：
  

                               ⒈ CPU A(CPU A上所运行的进程，以下同）从内存单元把当前计数值⑵装载进它的寄存器中；
                               ⒉ CPU B从内存单元把当前计数值⑵装载进它的寄存器中。
                              ⒊ CPU A在它的寄存器中将计数值递减为1；
                              ⒋ CPU B在它的寄存器中将计数值递减为1；
                              ⒌ CPU A把修改后的计数值⑴写回内存单元。
                              ⒍ CPU B把修改后的计数值⑴写回内存单元。
我们看到，内存里的计数值应该是0，然而它却是1。如果该计数值是一个共享资源的引用计数，每个进程都在递减后把该值与0进行比较，从而确定是否需要释放该共享资源。这时，两个进程都去掉了对该共享资源的引用，但没有一个进程能够释放它--两个进程都推断出：计数值是1，共享资源仍然在被使用。
Linux原子操作大部分使用汇编语言实现，因为c语言并不能实现这样的操作。
原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中

原子操作相关API
atomic.h        这个文件中包含了和具体芯片架构相关的原子操作头文件arch\arm\include\asm\atomic.h。
ATOMIC_INIT(v);
初始化一个个原子变量，一般比较少用。
atomic_read(atomic_t * v);
读取原子变量中的值
atomic_set(atomic_t * v, int i);
设置原子变量值为i
void atomic_add(int i, atomic_t *v)
把原子变量值加上i
void atomic_sub(int i, atomic_t *v)
把原子变量值减去i
atomic_sub_and_test(i, v)
把原子变量v的值减去i，判断相减后的原子变量值是否为0，如果为0返回真
atomic_inc(v);
把原子变量v加上1
atomic_dec(v)
把原子变量v减去1
atomic_dec_and_test(v)
把原子变量v的值减去1，判断相减后的原子变量值是否为0，如果为0返回真
atomic_inc_and_test(v)
把原子变量v的值加1，判断相加后的原子变量值是否为0，如果为0返回真
atomic_add_negative(i,v)
把原子变量v的值加i，判断相加后的原子变量值是否为负数，如果为负数返回真
int atomic_add_return(int i, atomic_t *v)
把原子变量v的值加i，返回相加后原子变量的结果
int atomic_sub_return(int i, atomic_t *v)
把原子变量v的值减i，返回相减后原子变量的结果
atomic_inc_return(v)
把原子变量v的值加1后，返回结果
atomic_dec_return(v)
把原子变量v的值减1后返回结果

实验现象：当多个APP调用同一个驱动时，不会发生混乱，依次执行#  ./ledtest & ./ledtest&  ./ledtest &

未实现原子操作会都执行

驱动代码：

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/init.h>
   
5. #include <linux/delay.h>
   
6. #include <linux/uaccess.h>
   
7. #include <asm/irq.h>
   
8. #include <asm/io.h>
   
9. #include <asm/types.h>
   
10. #include <linux/of.h>
    
11. #include <linux/of_device.h>
    
12. #include <linux/of_platform.h>
    
13. #include <linux/atomic.h>
    
14. static int major;
    
15. static struct class *led_class;
    
16. volatile unsigned long *gpio_con = NULL;
    
17. volatile unsigned long *gpio_dat = NULL;
    
18. //定义原子变量  ,初始化值为1
    
19. atomic_t  atomic_v = ATOMIC_INIT(1);
    
20. static int led_open (struct inode *node, struct file *filp)
    
21. {
    
22.     // atomic_dec_and_test(v),判断减1结果是否0，为0返回真。
    
23.     if( !atomic_dec_and_test(&atomic_v) ){
    
24.           printk("done done done \n");
    
25.                 return -1;
    
26.         }
    
27. 
    
28.         /* PB7 - 0x01C20824 */
    
29.         if (gpio_con) {
    
30.                 printk("ioremap  0x%x\n", gpio_con);
    
31.         }
    
32.         else {
    
33.                 return -EINVAL;
    
34.         }
    
35.         printk(" open open open  \n");
    
36.         return 0;
    
37. }
    
38. 
    
39. static ssize_t led_write (struct file *filp, const char __user *buf, size_t size, loff_t *off)
    
40. {
    
41.         unsigned char val;        
    
42.         copy_from_user(&val, buf, 1);
    
43. 
    
44.         if (val)
    
45.         {
    
46.                 *gpio_dat |= (1<<7);
    
47.         }
    
48.         else
    
49.         {
    
50.                 *gpio_dat &= ~(1<<7);
    
51.         }
    
52.         printk(" write write write  \n");
    
53.         return 1;
    
54. }
    
55. 
    
56. static int led_release (struct inode *node, struct file *filp)
    
57. {
    
58.     //释放信号量
    
59.     atomic_set(&atomic_v,1);
    
60.     printk("iounmap(0x%x)\n", gpio_con);
    
61.     iounmap(gpio_con);
    
62.     printk(" release release release  \n");
    
63.     return 0;
    
64. }
    
65. 
    
66. 
    
67. static struct file_operations myled_oprs = {
    
68.     .owner = THIS_MODULE,
    
69.     .open  = led_open,
    
70.     .write = led_write,
    
71.     .release = led_release,
    
72. };
    
73. static int myled_init(void)
    
74. {
    
75.    major = register_chrdev(0, "myled", &myled_oprs);
    
76.    led_class = class_create(THIS_MODULE, "myled");
    
77.    device_create(led_class, NULL, MKDEV(major, 0), NULL, "ledzzzzzzzz");
    
78.    gpio_con = (volatile unsigned long *)ioremap(0x01C20824, 1);   //0x01C20824
    
79.    gpio_dat = gpio_con + 4;     //0x01C20834        
    
80.    *gpio_con &= ~(7<<28);
    
81.    *gpio_con |=  (1<<28);
    
82.    *gpio_dat &= ~(1<<7);
    
83.    return 0;
    
84. }
    
85. module_init(myled_init);
    
86. module_exit(led_release);
    
87. MODULE_LICENSE("GPL");
    
88. 
    

复制代码

APP代码:

1. #include <sys/stat.h>
   
2. #include <fcntl.h>
   
3. #include <stdio.h>
   
4. /* ledtest on
   
5. *  *   * ledtest off
   
6. *   *     */
   
7. int main(int argc, char **argv)
   
8. {
   
9.         int fd;
   
10.         unsigned char val = 1;
    
11. 
    
12.                 fd = open("/dev/ledzzzzzzzz", O_RDWR);
    
13.                 if (fd < 0)
    
14.                 {
    
15.                         printf("can't open!\n");
    
16.                 }
    
17.                 if (argc != 2)
    
18.                 {
    
19.                         printf("Usage :\n");
    
20.                         printf("%s <on|off>\n", argv[0]);
    
21.                         return 0;
    
22.                 }
    
23. 
    
24.                 if (strcmp(argv[1], "on") == 0)
    
25.                 {
    
26.                         val  = 1;
    
27.                 }
    
28.                 else
    
29.                 {
    
30.                         val = 0;
    
31.                 }
    
32.                 write(fd, &val, 1);
    
33. 
    
34.         return 0;
    
35. }

复制代码