首先是为什么要有 原子操作

网上的截图：

不能从C语言来看，要从汇编来看

但是实际的情况有可能是这样。

A进程没有得到想要的结果。

然后是 原子操作的 底层实现

最终会是这段代码，当然只是一个 加一的操作。

static inline void atomic_add(int i, atomic_t *v)                      
{                                                                      
        unsigned long tmp;                                             
        int result;                                                    
                                                                       
        prefetchw(&v->counter);                                        
        __asm__ __volatile__("@ atomic_add "\n"                  @@后是注释            
"1:     ldrex   %0, [%3]\n"                                             
"       add     %0, %0, %4\n"                                  
"       strex   %1, %0, [%3]\n"                                        
"       teq     %1, #0\n"                                              
"       bne     1b"                                                    
        : "=&r" (result), "=&r" (tmp), "+Qo" (v->counter)         @输出部分       
        : "r" (&v->counter), "Ir" (i)                             @输入部分   
        : "cc");                                                  @破坏描述部分               
}  

这里需要知道两个命令。

ldrex，strex

这个例子很好。

也就是说， 汇编上，只有， strex 才是真正的原子，ldrex 就是先到先得了。因为这只是读，但是写就不一样了。

我的疑问： 如果进程没有获得原子变量怎么办，是休眠还是返回，还是空转。

然后是一个 关于 atomic 使用的例子。

#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>

#define OK   (0)
#define ERROR  (-1)

/* 原子变量 */
static atomic_t canopen = ATOMIC_INIT(1);

int hello_open(struct inode *p, struct file *f)
{
    /*自减1并判断是否位0 */
    if(!atomic_dec_and_test(&canopen)){
        /* 恢复原始值 */
        atomic_inc(&canopen);
        printk("device busy,hello_open failed");
        return ERROR;
    }
    printk("hello_open\n");
    return 0;
}

ssize_t hello_write(struct file *f, const char __user *u, size_t s, loff_t *l)
{
    printk("hello_write\n");
    return 0;
}

ssize_t hello_read(struct file *f, char __user *u, size_t s, loff_t *l)
{
    printk("hello_read\n");
    return 0;
}

int hello_close(struct inode *inode, struct file *file)
{
    /* 恢复原始值 */
// 这里问什么要 增加以下呢？ 因为 if(!atomic_dec_and_test(&canopen)) 在判断的时候也是执行的。
    atomic_inc(&canopen);
    return 0;
}

struct file_operations hello_fops = {
    .owner   =   THIS_MODULE,
    .open    =   hello_open,
    .read    =   hello_read,
    .write   =   hello_write,
    .release =   hello_close,
};

dev_t devid;                      // 起始设备编号
struct cdev hello_cdev;          // 保存操作结构体的字符设备 
struct class *hello_cls;

int hello_init(void)
{
    
    /* 动态分配字符设备: (major,0) */
    if(OK == alloc_chrdev_region(&devid, 0, 1,"hello")){   // ls /proc/devices看到的名字
        printk("register_chrdev_region ok\n");
    }else {
        printk("register_chrdev_region error\n");
        return ERROR;
    }
    
     cdev_init(&hello_cdev, &hello_fops);
     cdev_add(&hello_cdev, devid, 1);


    /* 创建类,它会在sys目录下创建/sys/class/hello这个类  */
     hello_cls = class_create(THIS_MODULE, "hello");
     if(IS_ERR(hello_cls)){
         printk("can't create class\n");
         return ERROR;
     }
    /* 在/sys/class/hello下创建hellos设备，然后mdev通过这个自动创建/dev/hello这个设备节点 */
     device_create(hello_cls, NULL, devid, NULL, "hello"); 

     return 0;
}

void __exit hello_exit(void)
{
    printk("hello driver exit\n");
    /* 注销类、以及类设备 /sys/class/hello会被移除*/
    device_destroy(hello_cls, devid);
    class_destroy(hello_cls);

    cdev_del(&hello_cdev);
    unregister_chrdev_region(devid, 1);
    return;
}


module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

需要注意的地方：  原子操作 是没有 阻塞与非阻塞的概念的。就是一个 if 判断，原子变量的值， 如果值 不符合要求 就直接 返回 了。

我的疑问： 我们知道 open 是以 阻塞方式打开的，也就是 说应用的阻塞的关键字没有起到作用吗？