内核中并发和竞态 信号量 示例

作用

信号量的本质就是一个描述临界资源有效个数的计数器，先申请信号量（未获得的休眠），然后访问临界资源，最后释放信号量

特点

1.保护的临界区可以很大，允许有延迟（休眠、拷贝等）的操作

2.不会死锁

3.不关闭抢占

初始化信号量

void sema_init(struct semaphore *sem, int val)

sem：定义的信号量

val：信号量的初值，1 = 互斥，0 = 同步

返回值：无

申请信号量

休眠不可被打断

void down(struct semaphore *sem)

休眠可被信号打断，信号打断 = -EINTR

int down_interruptible(struct semaphore *sem)

休眠时可被kill

int down_killable(struct semaphore *sem)

申请信号量，不论成功与否都立即返回，失败 = 1

int down_trylock(struct semaphore *sem)

在jiffies个时钟节拍内休眠等待信号量，成功= 0，超时 = -ETIME

int down_timeout(struct semaphore *sem, long jiffies)

sem：定义的信号量

jiffies：在jiffies个时钟节拍内获取信号量，一个时钟节拍为4ms

返回值：成功 = 0，失败 = !0

释放信号量，唤醒休眠进程

void up(struct semaphore *sem)

sem：定义的信号量

返回值：无

示例

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

#define CNAME "mycdev"
struct cdev cdev;
int major = 0;
int minor = 0;
const int count = 3;
struct class *cls;
struct device *dev;
char kbuf[128] = {0};

//一.定义信号量
struct semaphore lock;

int mycdev_open(struct inode *inode, struct file *file){
    //三.获取信号量
    //注意返回值
    if(down_interruptible(&lock)){
        return -ERESTARTSYS;
    }
    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 = 0;
    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 error\n");
        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__);
    //四.释放信号量
    up(&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 = 0;
    dev_t devno = 0;
    int i = 0;

    //1.初始化cdev
    cdev_init(&cdev,&fops);
    cdev.owner = THIS_MODULE;

    //2.申请设备号
    if(major > 0){
        ret = register_chrdev_region(MKDEV(major,minor),count,CNAME);
        if(ret){
            printk("register_chrdev_region error\n");
            goto ERR1;
        }
    }else if(major == 0){
        ret = alloc_chrdev_region(&devno,minor,count,CNAME);
        if(ret){
            printk("alloc_chrdev_region error\n");
            goto ERR1;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
    }

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

    //4.创建设备节点
    cls = class_create(THIS_MODULE,CNAME);
    if(IS_ERR(cls)){
        printk("class_creat error\n");
        goto ERR3;
    }
    for(i = 0; i < count; i++){
        dev = device_create(cls, NULL, MKDEV(major,i), NULL, "mycdev%d",i);
        if(IS_ERR(dev)){
            printk("device_creat error\n");
            goto ERR4;
        }
    }
    
    //二.初始化信号量(1=互斥 0=同步)
    sema_init(&lock,1);

    return 0;

ERR4:
    for(--i; i >= 0; i--){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
ERR3:
    cdev_del(&cdev);
ERR2:
    unregister_chrdev_region(MKDEV(major,minor),count);
ERR1:
    return ret;
}

static void __exit mycdev_exit(void){
    int i = 0;
    for(i = 0; i < count; i++){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
    cdev_del(&cdev);
    unregister_chrdev_region(MKDEV(major, minor), count);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");