内核中并发和竞态 自旋锁 示例

作用

争锁，未得到的进程处于循环询问状态（运行态），不断判断是否可以获取到锁。

很多时候我们并不能采用其他的锁，比如读写锁、互斥锁、信号量等。一方面这些锁会发生上下文切换，他的时间是不可预期的，对于一些简单的、极短的临界区完全是一种性能损耗；

另一方面在中断上下文是不允许睡眠的，除了自旋锁以外的其他任何形式的锁都有可能导致睡眠或者进程切换，这是违背了中断的设计初衷，会发生不可预知的错误。

特点

1.忙等过程消耗cpu

2.保护的临界区要尽可能短，不能有延时（休眠、拷贝等）操作

（原因：如果自旋锁锁住以后进入睡眠，而此时又不能进行处理器抢占，内核的调取器无法调取其他进程获得该 CPU，从而导致该 CPU 被挂起，同时该进程也无法自唤醒且一直持有该自旋锁，进一步会导致其他使用该自旋锁的位置出现死锁）

3.会死锁

4.上锁前会关闭抢占但不关闭中断

（原因：当一个 CPU 获取到一把自旋锁之后，开始执行临界区代码，此时假设他的时间片运转完毕，进程调度会主动触发调度将其调走，执行另一个线程/进程，结果恰巧了这个线程/进程也需要用到该自旋锁，而上一个线程/进程还在停留在临界区内未释放锁，导致本进程无法获取到锁而形成死锁，所以自旋锁为了规避此类情形的出现从而直接禁止对已经开始运行的临界区设置抢占标志）

初始化自旋锁，将自旋锁设置为1，表示有一个资源可用

void spin_lock_init(spinlock_t *lock)

lock：定义的自旋锁

返回值：无

获取锁（性能损耗从小到大）

普通自旋锁，在进程上下文或者工作队列中使用

void spin_lock(spinlock_t *lock)

获取锁前关闭中断底半部（软中断、Taskset 以及 Timer 等抢占能力）

void spin_lock_bh(spinlock_t *lock)

获取锁前关闭中断，在中断处理函数中使用

void spin_lock_irq(spinlock_t *lock)

获得锁前保存当前中断状态，再关闭中断，嵌套中使用，最安全，性能损耗最大的方式

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags)

lock：定义的自旋锁

flags：保存当前中断状态的容器

返回值：无

解锁

解锁（置为1）

void spin_unlock(spinlock_t *lock)

解锁（置为1），开启底半部的执行

void spin_unlock_bh(spinlock_t *lock)

解锁（置为1），开中断

void spin_unlock_irq(spinlock_t *lock)

解锁（置为1），开中断，将flags值存入状态寄存器，即恢复上锁之前的中断状态

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)

lock：定义的自旋锁

flags：保存当前中断状态的容器

返回值：无

示例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/spinlock.h>

struct cdev *cdev;
int major = 0;
int minor = 0;
struct class *cls;
struct device *dev;
//1.定义自旋锁(加个flag)
spinlock_t lock;
int flag = 0;

char kbuf[128]={0};

int mycdev_open(struct inode *inode, struct file *file){
    //3.获取锁
    spin_lock(&lock);
    //对flag加锁是保证在整个open、read、write、close过程中只有一个进程在调用，
    //如果没有加锁，可能会出现两个进程同时进入的情况
    //加了锁，只有一个进程能进入，另一个进程获取到锁后也会因为flag而进入if解开锁
    if(0 != flag){ 
        spin_unlock(&lock);
        return -EBUSY;
    }
    flag = 1;
    spin_unlock(&lock);
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t mycdev_read(struct file *file,char __user *ubuf,size_t size,loff_t *offs){
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //校验大小
    if(size > sizeof(kbuf)){
        size = sizeof(kbuf);
    }
    //数据传输
    ret = copy_to_user(ubuf,kbuf,size);
    if(ret){
        printk("copy_to_user errpr");
        return -EIO;
    }
    return size;
}

ssize_t mycdev_write(struct file *file,const char __user *ubuf,size_t size,loff_t *offs){
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //校验大小
    if(size > sizeof(kbuf)){
        size = sizeof(kbuf);
    }
    //数据传输
    ret = copy_from_user(kbuf,ubuf,size);
    if(ret){
        printk("copy_from_user error\n");
        return -EIO;
    }
    return size;
}

int mycdev_close(struct inode *inode, struct file *file){
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //4.获取锁
    //这里加锁是为了防止离开的进程和进入的进程产生对flag赋值的竞争（其实不加也行）
    spin_lock(&lock);
    flag = 0;
    spin_unlock(&lock);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void){
    
    int ret;
    dev_t cdevnum;
    int i;
    //1.cdev初始化(动态)
    cdev =cdev_alloc();
    if(NULL == cdev){
        printk("cdev_alloc error\n");
        ret = -ENOMEM;//记录系统最后一次错误代码(int型)
        goto ERR1;
    } 
    cdev->ops = &fops;
    cdev->owner = THIS_MODULE;

    //2.申请设备号
    if(major > 0){ //主设备号固定，用静态申请
        ret = register_chrdev_region(MKDEV(major, minor),3,"mycdev");
        if(ret){
            printk("register_chrdev_region error\n");
            goto ERR2;
        }
    }else if(major == 0){ //主设备号无所谓，用动态申请
        ret = alloc_chrdev_region(&cdevnum,minor,3,"mycdev");
        if(ret){
            printk("alloc_chrdev_region error\n");
            goto ERR2;
        }
        major = MAJOR(cdevnum);
        minor = MINOR(cdevnum);
    }

    //3. 注册cdev
    ret = cdev_add(cdev,MKDEV(major,minor),3);
    if(ret){
        printk("cdev_add error\n");
        goto ERR3;
    }

    //4.创建设备节点
    cls = class_create(THIS_MODULE,"mycdev");
    if(IS_ERR(cls)){
        printk("class_creat error");
        goto ERR4;
    }
    for(i=0;i<3;i++){
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
        if(IS_ERR(dev)){
            printk("device_creat error\n");
            goto ERR5;
        }
    }

    //2.初始化锁
    spin_lock_init(&lock);
    
    return 0;

ERR5:
    for(--i;i>=0;i--){
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major,minor),3);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}
static void __exit mycdev_exit(void){
    int i = 0;
    for(i=0;i<3;i++){
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major,minor),3);
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");