嵌入式学习之Linux驱动 原子操作理论讲解

什么是原子操作？

原子操作的应用

原子整形变量的描述

原子整形操作API函数（32位）

原子整形操作API函数（64位）

原子操作举例

11打错了，是2

#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/device.h>  

#include <linux/atomic.h>  
#include <asm/atomic.h>  


struct device_test {
    dev_t dev_num;
    int major;
    int minor;
    int flag;

    struct cdev cdev_test;
    struct class *class;
    struct device *device;
    char lbuf[32];
};

struct device_test dev1;
static atomic64_t v=ATOMIC_INIT(1);         //初始化为1


static int cdev_test_open(struct inode *inode, struct file *file) {

//此函数做了两件事：

// 将 v 的值减 1；

// 判断结果是否为 0，如果是返回 true（非 0 表示失败）。
if(!atomic64_dec_and_test(&v)){         //尝试减少为0，检查是否为最后一个
    atomic64_inc(&v);
    return -EBUSY;
}   
    file->private_data = container_of(inode->i_cdev, struct device_test, cdev_test);
    printk("This is cdev_test_open\n");
    return 0;
}

static ssize_t cdev_test_read(struct file *file, char __user *buf, size_t size, loff_t *off) {
    struct device_test *test_dev = (struct device_test *)file->private_data;

    if (copy_to_user(buf, test_dev->lbuf, strlen(test_dev->lbuf)) != 0) {
        printk("copy_to_user error\n");
        return -EFAULT;
    }

    return strlen(test_dev->lbuf);
}

static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off) {
    struct device_test *test_dev = (struct device_test *)file->private_data;

    if (size >= sizeof(test_dev->lbuf)) {
        printk("write size too large\n");
        return -EINVAL;
    }

    if (copy_from_user(test_dev->lbuf, buf, size) != 0) {
        printk("copy_from_user error\n");
        return -EFAULT;
    }

    test_dev->lbuf[size] = '\0'; 
    printk("test_dev->lbuf is %s\n", test_dev->lbuf);

    return size;
}

static int cdev_test_release(struct inode *inode, struct file *file) {

    atomic64_inc(&v);
    return 0;
}

static struct file_operations cdev_test_ops = {
    .owner = THIS_MODULE,
    .open = cdev_test_open,
    .read = cdev_test_read,
    .write = cdev_test_write,
    .release = cdev_test_release,
};

static int __init modulecdev_init(void) {
    int ret;

    ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "WLD");
    if (ret < 0) {
        printk("alloc_chrdev_region failed\n");
        goto err_chrdev;
    }

    dev1.major = MAJOR(dev1.dev_num);
    dev1.minor = MINOR(dev1.dev_num);
    printk("register_chrdev_region is ok\n");
    printk("major is %d\n", dev1.major);
    printk("minor is %d\n", dev1.minor);

    cdev_init(&dev1.cdev_test, &cdev_test_ops);
    dev1.cdev_test.owner = THIS_MODULE;

    ret = cdev_add(&dev1.cdev_test, dev1.dev_num, 1);
    if (ret < 0) {
        printk("cdev_add failed\n");
        goto err_chr_add;
    }

    dev1.class = class_create(THIS_MODULE, "test");
    if (IS_ERR(dev1.class)) {
        ret = PTR_ERR(dev1.class);
        printk("class_create failed\n");
        goto err_class_create;
    }

    dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "test1");
    if (IS_ERR(dev1.device)) {
        ret = PTR_ERR(dev1.device);
        printk("device_create failed\n");
        goto err_device_create;
    }

    return 0;

err_device_create:
    class_destroy(dev1.class);
err_class_create:
    cdev_del(&dev1.cdev_test);
err_chr_add:
    unregister_chrdev_region(dev1.dev_num, 1);
err_chrdev:
    return ret;
}

static void __exit modulecdev_exit(void) {
    device_destroy(dev1.class, dev1.dev_num);
    class_destroy(dev1.class);
    cdev_del(&dev1.cdev_test);
    unregister_chrdev_region(dev1.dev_num, 1);

    printk("bye bye\n");
}

module_init(modulecdev_init);
module_exit(modulecdev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("FASHI");
MODULE_VERSION("V1.0");