0725_驱动1 内核中并发和竟态解决方法

news2024/11/25 15:33:46

一、内核中并发和竟态相关概念

        一、什么时候产生竟态

        1.同一个驱动程序，同时被多个应用层程序进行访问

        2.访问同一个临界资源，驱动产生竟态

        二、竟态产生根本原因

1.在单核cpu中，如果内核支持抢占，就会产生竟态

2.在多核cpu中，核与核之间就会产生竟态

3.中断和进程之间也会产生竟态

4.中断和中断之间也会产生竟态（前提中断需要支持嵌套，A核GIC控制器不支持中断嵌套，M核NVIC控制器支持中断嵌套）

        三、解决竟态

1.顺序执行

2.互斥执行

 二、解决竟态方法

        一、中断屏蔽

        1.只针对单核cpu使用，顾名思义当中断到来时，将中断进行屏蔽

        2.但是中断屏蔽时间不能过长

        3.如果时间过长就会导致用户数据丢失，或者操作系统崩溃

        

        API接口：

        

local_irq_disable();//中断屏蔽
临界资源
local_irq_enable(); //中断开启

        二、自旋锁

工作原理：

        1.当一个进程获取到自旋锁之后，另一个进程也想获取自旋锁，此时后一个进程进入自旋状态（原地打转）

特点：

        1.自旋锁针对于多核cpu设计

        2.自旋锁需要消耗cpu资源，并且自旋状态处于运行状态

        3.自旋锁保护的临界资源比较小，在临界资源中不可以出现copy_to_user和copy_from_user使用

        4.自旋锁会产生死锁

        5.自旋锁上锁会关闭抢占

        6.自旋锁工作于中断上下文，也可以工作于进程上下文

API接口

- spinlock_t spinlock;   // 定义自旋锁
- void spin_lock_init(spinlock_t *lock);   //初始化锁
- void spin_lock(spinlock_t *lock);  //上锁
- void spin_unlock(spinlock_t *lock); //解锁

使用：

        1.当A进程获取自旋锁成功，B进程获取自旋锁失败，返回错误码，只有当A进程解锁之后，B进程获取自旋锁成功

代码：

demo.c

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

#define CNAME "myled"
struct cdev *cdev;
char kbuf[128] = {};
#if 0
unsigned int major = 500; //静态指定设备号
#else
unsigned int major = 0; //动态分配设备号
#endif
unsigned int count = 3;
unsigned int minor = 0; 
struct class* cls;
struct device* device;
spinlock_t spinlock;   // 定义自旋锁
int flag = 0;
int myled_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    spin_lock(&spinlock);  //上锁
    if(flag != 0)
    {
        spin_unlock(&spinlock);  //解锁
        return -EBUSY; //返回错误码
    }
    flag = 1;
    spin_unlock(&spinlock);  //解锁
    return 0;
}

ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //如果用户空间想读的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间读的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_to_user(ubuf,kbuf,size); //将内核空间的数据，写入到用户空间
    if(ret){
        printk("copy to user is error\n");
        return -EIO;
    }
    return size; 
}

ssize_t myled_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    
    //如果用户空间想写的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间写的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size); //将用户空间的数据，写入到内核空间
    if(ret){
        printk("copy from user is error\n");
        return -EIO;
    }
    printk("kernel kbuf=%s\n",kbuf);
    return size; 
}

int myled_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    spin_lock(&spinlock);  //上锁
    flag = 0;
    spin_unlock(&spinlock);  //解锁
    return 0; 
}

//操作方法结构体
const struct file_operations fops = {
    .open = myled_open,
    .read = myled_read,
    .write = myled_write,
    .release = myled_close,
};

//入口
static int __init demo_init(void)
{
    int ret;
    dev_t devno;
    int i  = 0;
    //分配对象
    cdev = cdev_alloc();
    if(cdev == NULL){
        printk("cdev alloc is error\n");
        ret = -EIO;
        goto ERR1;
    }
    //对象初始化
    cdev_init(cdev,&fops);

    if(major > 0)
    {
        //静态指定设备号
    ret = register_chrdev_region(MKDEV(major,minor), count, CNAME);
        if(ret){
            printk("register chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }
    }else{ //动态指定设备号
        ret = alloc_chrdev_region(&devno, 0, count,CNAME);
        if(ret){
            printk("alloc chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }    
        major = MAJOR(devno);//根据设备号，获取主设备号的值
        minor = MINOR(devno);//根据设备号，获取次设备号的值    
    }
        
    //对象注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);
    if(ret){
        printk("dev add is error\n");
        ret = -EIO;
        goto ERR3;
    }  

    //三盏灯，自动创建三个设备节点 /dev/myled0 /dev/myled1 /dev/myled2
    cls = class_create(THIS_MODULE, CNAME);  //向上层提交目录信息
    if(IS_ERR(cls))
    {
        printk("class create is error\n");
        ret = EIO;
        goto ERR4;
    }
    for(i=0;i<count;i++) //向上层提交设备节点信息
    {
        device = device_create(cls, NULL, MKDEV(major,i),NULL, "myled%d", i);
        if(IS_ERR(device))
        {
            printk("device create is error\n");
            ret = EIO;
            goto ERR5;
        }
    }
    spin_lock_init(&spinlock);   //初始化自旋锁锁
    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), count); //注销设备号
ERR2:
    kfree(cdev); //释放结构体指针
ERR1:
    return ret;
}

//出口
static void __exit demo_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); //注销设备号
    kfree(cdev); //释放结构体指针
}

module_init(demo_init); //指定入口地址

module_exit(demo_exit); //指定出口地址

MODULE_LICENSE("GPL");//许可证

        三、信号量

工作原理：

        1.当一个进程获取到信号量之后。另外一个进程也想获取信号量，此时后一个进程就会处于休眠状态

特点：

        1.信号量针对多核cpu设计

        2.信号量不消耗cpu资源

        3.信号量保护的临界资源比较大，在临界区可以出现延时，耗时，甚至休眠的操作

        4.在临界资源中可以出现copy_to_user和copy_from_user

        5.信号量不会产生死锁

        6.信号量上锁不会关闭抢占

        7.信号量工作于进程上下文

API接口：

- struct semaphore  sema; // 定义信号量
- void sema_init(struct semaphore *sem, int val);   //初始化信号量
- sem:定义信号量
- 写1：表示互斥执行
- 写0：表示同步执行
- void down(struct semaphore *sem);  //上锁
- void up(struct semaphore *sem); //解锁 
- int down_trylock(struct semaphore *sem); //尝试获取锁
- 尝试获取锁成功返回0
- 尝试获取锁失败返回1

使用：

        当A进程获取到信号量成功，B进程想要获取信号量，需要等待A进程解锁之后才能获取成功

编译代码：

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

#define CNAME "myled"
struct cdev *cdev;
char kbuf[128] = {};
#if 0
unsigned int major = 500; //静态指定设备号
#else
unsigned int major = 0; //动态分配设备号
#endif
unsigned int count = 3;
unsigned int minor = 0; 
struct class* cls;
struct device* device;
struct semaphore sema; // 定义信号量

int myled_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //成功返回0 失败返回1
    if((down_trylock(&sema)))
    {
        return -EBUSY; //返回错误码
    }
    return 0;
}

ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //如果用户空间想读的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间读的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_to_user(ubuf,kbuf,size); //将内核空间的数据，写入到用户空间
    if(ret){
        printk("copy to user is error\n");
        return -EIO;
    }
    return size; 
}

ssize_t myled_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    
    //如果用户空间想写的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间写的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size); //将用户空间的数据，写入到内核空间
    if(ret){
        printk("copy from user is error\n");
        return -EIO;
    }
    printk("kernel kbuf=%s\n",kbuf);
    return size; 
}

int myled_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    up(&sema);
    return 0; 
}

//操作方法结构体
const struct file_operations fops = {
    .open = myled_open,
    .read = myled_read,
    .write = myled_write,
    .release = myled_close,
};

//入口
static int __init demo_init(void)
{
    int ret;
    dev_t devno;
    int i  = 0;
    //分配对象
    cdev = cdev_alloc();
    if(cdev == NULL){
        printk("cdev alloc is error\n");
        ret = -EIO;
        goto ERR1;
    }
    //对象初始化
    cdev_init(cdev,&fops);

    if(major > 0)
    {
        //静态指定设备号
    ret = register_chrdev_region(MKDEV(major,minor), count, CNAME);
        if(ret){
            printk("register chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }
    }else{ //动态指定设备号
        ret = alloc_chrdev_region(&devno, 0, count,CNAME);
        if(ret){
            printk("alloc chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }    
        major = MAJOR(devno);//根据设备号，获取主设备号的值
        minor = MINOR(devno);//根据设备号，获取次设备号的值    
    }
        
    //对象注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);
    if(ret){
        printk("dev add is error\n");
        ret = -EIO;
        goto ERR3;
    }  

    //三盏灯，自动创建三个设备节点 /dev/myled0 /dev/myled1 /dev/myled2
    cls = class_create(THIS_MODULE, CNAME);  //向上层提交目录信息
    if(IS_ERR(cls))
    {
        printk("class create is error\n");
        ret = EIO;
        goto ERR4;
    }
    for(i=0;i<count;i++) //向上层提交设备节点信息
    {
        device = device_create(cls, NULL, MKDEV(major,i),NULL, "myled%d", i);
        if(IS_ERR(device))
        {
            printk("device create is error\n");
            ret = EIO;
            goto ERR5;
        }
    }
    sema_init(&sema, 1);   //初始化信号量
    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), count); //注销设备号
ERR2:
    kfree(cdev); //释放结构体指针
ERR1:
    return ret;
}

//出口
static void __exit demo_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); //注销设备号
    kfree(cdev); //释放结构体指针
}

module_init(demo_init); //指定入口地址

module_exit(demo_exit); //指定出口地址

MODULE_LICENSE("GPL");//许可证

        四、互斥体

工作原理：

        当一个进程获取到互斥体之后，另外一个进程也想要获取，后一个进程如果获取不到，会稍微一会进入休眠状态，所以对于保护临界资源比较小的时候，互斥体的效率高于信号量

特点：

        1.互斥体针对多核cpu设计

        2.互斥体不消耗cpu资源

        3.互斥体保护临界资源比较大，所以在临界区可以出现延时，耗时，甚至休眠

        4.在临界区可以使用copy_to_user和copy_from_user

        5.互斥体不会产生死锁

        6.互斥体不会关闭抢占

        7.互斥体工作于进程上下文

API接口：

- struct mutex mutex; // 定义互斥体
- mutex_init(&mutex);   //初始化互斥体
- void mutex_lock(struct mutex *lock);  //上锁
- void mutex_unlock(struct mutex *lock); //解锁 
- int mutex_trylock(struct mutex *lock);; //尝试获取互斥体
- 尝试获取锁成功返回1
- 尝试获取锁失败返回0

使用：

        当A进程获取到互斥锁成功后，B进程获取互斥锁，。只有等A进程解锁，B进程才能获取成功

编译代码：

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

#define CNAME "myled"
struct cdev *cdev;
char kbuf[128] = {};
#if 0
unsigned int major = 500; //静态指定设备号
#else
unsigned int major = 0; //动态分配设备号
#endif
unsigned int count = 3;
unsigned int minor = 0; 
struct class* cls;
struct device* device;
struct mutex mutex; // 定义互斥体

int myled_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //成功返回1 失败返回0
    if(!(mutex_trylock(&mutex)))
    {
        return -EBUSY; //返回错误码
    }
    return 0;
}

ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //如果用户空间想读的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间读的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_to_user(ubuf,kbuf,size); //将内核空间的数据，写入到用户空间
    if(ret){
        printk("copy to user is error\n");
        return -EIO;
    }
    return size; 
}

ssize_t myled_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    
    //如果用户空间想写的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间写的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size); //将用户空间的数据，写入到内核空间
    if(ret){
        printk("copy from user is error\n");
        return -EIO;
    }
    printk("kernel kbuf=%s\n",kbuf);
    return size; 
}

int myled_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    mutex_unlock(&mutex); //解锁 
    return 0; 
}

//操作方法结构体
const struct file_operations fops = {
    .open = myled_open,
    .read = myled_read,
    .write = myled_write,
    .release = myled_close,
};

//入口
static int __init demo_init(void)
{
    int ret;
    dev_t devno;
    int i  = 0;
    //分配对象
    cdev = cdev_alloc();
    if(cdev == NULL){
        printk("cdev alloc is error\n");
        ret = -EIO;
        goto ERR1;
    }
    //对象初始化
    cdev_init(cdev,&fops);

    if(major > 0)
    {
        //静态指定设备号
    ret = register_chrdev_region(MKDEV(major,minor), count, CNAME);
        if(ret){
            printk("register chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }
    }else{ //动态指定设备号
        ret = alloc_chrdev_region(&devno, 0, count,CNAME);
        if(ret){
            printk("alloc chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }    
        major = MAJOR(devno);//根据设备号，获取主设备号的值
        minor = MINOR(devno);//根据设备号，获取次设备号的值    
    }
        
    //对象注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);
    if(ret){
        printk("dev add is error\n");
        ret = -EIO;
        goto ERR3;
    }  

    //三盏灯，自动创建三个设备节点 /dev/myled0 /dev/myled1 /dev/myled2
    cls = class_create(THIS_MODULE, CNAME);  //向上层提交目录信息
    if(IS_ERR(cls))
    {
        printk("class create is error\n");
        ret = EIO;
        goto ERR4;
    }
    for(i=0;i<count;i++) //向上层提交设备节点信息
    {
        device = device_create(cls, NULL, MKDEV(major,i),NULL, "myled%d", i);
        if(IS_ERR(device))
        {
            printk("device create is error\n");
            ret = EIO;
            goto ERR5;
        }
    }
    mutex_init(&mutex);   //初始化互斥体
    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), count); //注销设备号
ERR2:
    kfree(cdev); //释放结构体指针
ERR1:
    return ret;
}

//出口
static void __exit demo_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); //注销设备号
    kfree(cdev); //释放结构体指针
}

module_init(demo_init); //指定入口地址

module_exit(demo_exit); //指定出口地址

MODULE_LICENSE("GPL");//许可证

        五、原子变量

工作原理：

        原子变量本身就是一个变量，没有自选或者休眠状态，获取到原子变量就成功，获取不到就失败，原子变量在内核中通过内联汇编实现，省区中间环节

定义原子变量：

typedef struct {
    int counter;
} atomic_t;

API接口：

- atomic_t atomic = ATOMIC_INIT(1); //定义并且初始化原子变量
- bool atomic_dec_and_test(atomic_t *v);  //上锁 -1
- 减1之后和0值进行比较，是否相等
- 减1之后和0值相等，返回1
- 减1之后和0值不相等，返回0
- void atomic_inc(atomic_t *v); //解锁 +1
========================================================
- atomic_t atomic = ATOMIC_INIT(-1); //定义并且初始化原子变量
- bool atomic_inc_and_test(atomic_t *v);  //上锁 +1
- 加1之后和0值进行比较，是否相等
- 加1之后和0值相等，返回1
- 加1之后和0值不相等，返回0
- void atomic_dec(atomic_t *v); //解锁 -1

编译代码：

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

#define CNAME "myled"
struct cdev *cdev;
char kbuf[128] = {};
#if 0
unsigned int major = 500; //静态指定设备号
#else
unsigned int major = 0; //动态分配设备号
#endif
unsigned int count = 3;
unsigned int minor = 0; 
struct class* cls;
struct device* device;
atomic_t atomic = ATOMIC_INIT(1); //定义并且初始化原子变量

int myled_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //成功返回1 失败返回0
    if(!(atomic_dec_and_test(&atomic))) //上锁 -1
    {
        atomic_inc(&atomic); //解锁 +1
        return -EBUSY; //返回错误码
    }
    return 0;
}

ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //如果用户空间想读的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间读的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_to_user(ubuf,kbuf,size); //将内核空间的数据，写入到用户空间
    if(ret){
        printk("copy to user is error\n");
        return -EIO;
    }
    return size; 
}

ssize_t myled_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    
    //如果用户空间想写的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间写的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size); //将用户空间的数据，写入到内核空间
    if(ret){
        printk("copy from user is error\n");
        return -EIO;
    }
    printk("kernel kbuf=%s\n",kbuf);
    return size; 
}

int myled_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    atomic_inc(&atomic); //解锁 +1
    return 0; 
}

//操作方法结构体
const struct file_operations fops = {
    .open = myled_open,
    .read = myled_read,
    .write = myled_write,
    .release = myled_close,
};

//入口
static int __init demo_init(void)
{
    int ret;
    dev_t devno;
    int i  = 0;
    //分配对象
    cdev = cdev_alloc();
    if(cdev == NULL){
        printk("cdev alloc is error\n");
        ret = -EIO;
        goto ERR1;
    }
    //对象初始化
    cdev_init(cdev,&fops);

    if(major > 0)
    {
        //静态指定设备号
    ret = register_chrdev_region(MKDEV(major,minor), count, CNAME);
        if(ret){
            printk("register chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }
    }else{ //动态指定设备号
        ret = alloc_chrdev_region(&devno, 0, count,CNAME);
        if(ret){
            printk("alloc chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }    
        major = MAJOR(devno);//根据设备号，获取主设备号的值
        minor = MINOR(devno);//根据设备号，获取次设备号的值    
    }
        
    //对象注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);
    if(ret){
        printk("dev add is error\n");
        ret = -EIO;
        goto ERR3;
    }  

    //三盏灯，自动创建三个设备节点 /dev/myled0 /dev/myled1 /dev/myled2
    cls = class_create(THIS_MODULE, CNAME);  //向上层提交目录信息
    if(IS_ERR(cls))
    {
        printk("class create is error\n");
        ret = EIO;
        goto ERR4;
    }
    for(i=0;i<count;i++) //向上层提交设备节点信息
    {
        device = device_create(cls, NULL, MKDEV(major,i),NULL, "myled%d", i);
        if(IS_ERR(device))
        {
            printk("device create is error\n");
            ret = EIO;
            goto ERR5;
        }
    }
    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), count); //注销设备号
ERR2:
    kfree(cdev); //释放结构体指针
ERR1:
    return ret;
}

//出口
static void __exit demo_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); //注销设备号
    kfree(cdev); //释放结构体指针
}

module_init(demo_init); //指定入口地址

module_exit(demo_exit); //指定出口地址

MODULE_LICENSE("GPL");//许可证

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1952884.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Internxt：适用于Linux开源安全云存储平台

Internxt：适用于Linux开源安全云存储平台

有无数的云存储平台为您的文件提供安全可靠的存储空间。可在 Linux 上安装的热门云存储应用程序包括Dropbox、Nextcloud和Google Drive&#xff0c;遗憾的是&#xff0c;后者迄今为止不提供 Linux 客户端。 其他自托管选项包括OwnCloud、Pydio Cells、Seafile、Resilio和Synct…
阅读更多...
【C++深度探索】AVL树与红黑树的原理与特性

【C++深度探索】AVL树与红黑树的原理与特性

&#x1f525; 个人主页&#xff1a;大耳朵土土垚 &#x1f525; 所属专栏&#xff1a;C从入门至进阶 这里将会不定期更新有关C/C的内容&#xff0c;欢迎大家点赞&#xff0c;收藏&#xff0c;评论&#x1f973;&#x1f973;&#x1f389;&#x1f389;&#x1f389; 前言 前…
阅读更多...
鱼哥好书分享活动第28期：看完这篇《终端安全运营》终端安全企业基石，为你的终端安全保驾护航！

鱼哥好书分享活动第28期：看完这篇《终端安全运营》终端安全企业基石，为你的终端安全保驾护航！

鱼哥好书分享活动第28期&#xff1a;看完这篇《终端安全运营》终端安全企业基石&#xff0c;为你的终端安全保驾护航&#xff01; 读者对象&#xff1a;主要内容&#xff1a;本书目录&#xff1a;了解更多&#xff1a;赠书抽奖规则: 在当前网络威胁日益复杂化的背景下&#xff…
阅读更多...
SGLang 大模型推理框架 qwen2部署使用案例；openai接口调用、requests调用

SGLang 大模型推理框架 qwen2部署使用案例；openai接口调用、requests调用

参考： https://github.com/sgl-project/sglang 纯python写，号称比vllm、tensorRT还快 暂时支持模型 安装 可以pip、源码、docker安装，这里用的pip 注意flashinfer安装最新版，不然会可能出错误ImportError: cannot import name ‘top_k_top_p_sampling_from_probs’ fr…
阅读更多...
FreeSWITCH 1.10.10 简单图形化界面27-Auto-Answer功能

FreeSWITCH 1.10.10 简单图形化界面27-Auto-Answer功能

FreeSWITCH 1.10.10 简单图形化界面27-Auto-Answer功能 1、前言2、测试环境3、呼叫测试 1、前言 在某些支持 Auto-Answer 消息头的 SIP 设备上&#xff0c;我们可以通过使用 FreeSWITCH 的 sip_auto_answer 变量来实现 SIP 设备的自动接听功能。即使 SIP 设备本身没有明确地启…
阅读更多...
【无为则无心SpringBoot】— 1.SpringBoot介绍

【无为则无心SpringBoot】— 1.SpringBoot介绍

1、什么是SpringBoot SpringBoot是Spring家族中的一个全新的框架&#xff0c;它用来简化Spring应用程序的创建和开发过程&#xff0c;也可以说SpringBoot能简化我们之前采用SpringMVCSpringMybatis框架进行开发的过程。 我们在使用Spring Boot时只需要配置相应的Spring Boot配置…
阅读更多...
开源数据结构存储系统Redis的内部数据结构详解（上）

开源数据结构存储系统Redis的内部数据结构详解（上）

目录 1、简单动态字符串 1.1、SDS的定义 1.2、SDS与C字符串的区别 2、链表 2.1、链表的定义 2.2、特性 3、字典 3.1、哈希表定义 3.2、哈希表节点定义 3.3、字典定义 3.4、Rehash 3.5、渐进式rehash 4、总结 C++软件异常排查从入门到精通系列教程（专栏文章列表，…
阅读更多...
ReentrantReadWriteLock详解

ReentrantReadWriteLock详解

目录 ReentrantReadWriteLock详解1、ReentrantReadWriteLock简介2、ReentrantReadWriteLock类继承结构和类属性3、ReentrantReadWriteLock的读写锁原理分析4、ReentrantReadWriteLock.WriteLock类的核心方法详解非公平写锁的获取非公平写锁的释放公平写锁的获取公平写锁的释放 …
阅读更多...
FPGA开发——独立仿真和联合仿真

FPGA开发——独立仿真和联合仿真

一、概述 我们在进行FPGA开发的过程之中&#xff0c;大部分情况下都是在进行仿真&#xff0c;从而验证代码实现结果的正确与否&#xff0c;这里我们引入了独立仿真和联合仿真进行一个简单介绍。 联合仿真&#xff1a;一般我们在进行仿真之前需要在相应的软件中建立相应的工程…
阅读更多...
C语言强化-3.单链表的新建、查找

C语言强化-3.单链表的新建、查找

与408的关联&#xff1a;1. 链表出了很多大题。 2. 任何数据结构&#xff0c;主要进行的操作就是增删改查。 头插法新建链表的实战 流程图 代码 #include <stdio.h> #include <stdlib.h>typedef int ElemType; typedef struct LNode{ElemType data;//数据域struc…
阅读更多...
Docker 搭建Elasticsearch详细步骤

Docker 搭建Elasticsearch详细步骤

本章教程使用Docker搭建Elasticsearch环境。 一、拉取镜像 docker pull docker.elastic.co/elasticsearch/elasticsearch:8.8.2二、运行容器 docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-n
阅读更多...
分布式锁的三种实现方式：Redis、基于数据库和Zookeeper

分布式锁的三种实现方式：Redis、基于数据库和Zookeeper

分布式锁的实现 操作共享资源&#xff1a;例如操作数据库中的唯一用户数据、订单系统、优惠券系统、积分系统等&#xff0c;这些系统需要修改用户数据&#xff0c;而多个系统可能同时修改同一份数据&#xff0c;这时就需要使用分布式锁来控制访问&#xff0c;防止数据不一致。…
阅读更多...
一步步教你学会如何安装VMare虚拟机（流程参考图）

一步步教你学会如何安装VMare虚拟机（流程参考图）

前言&#xff1a;一步步教你安装VMare虚拟机&#xff08;此版本为17.5。2版本&#xff09;。 1、安装 2、确认协议 3、选择位置存放 4、选择第二个 5、都不选。 6、都选提供便捷操作 7、点击许可证&#xff0c;将密钥输入&#xff08;可以在网络寻找自己版本的密钥&#xff…
阅读更多...
学好C++之——函数重载、缺省参数、内联函数

学好C++之——函数重载、缺省参数、内联函数

函数重载、缺省参数、内联函数都是C不同于C语言的知识点&#xff0c;简单轻松&#xff0c;这里就放到一篇来讲—— 目录 1.缺省参数 1.1什么是缺省参数&#xff1f; 1.2为什么需要缺省参数&#xff1f; 1.3缺省参数的使用规则 2.函数重载 参数类型不同&#xff1a; 参数个…
阅读更多...
错误代码0x80070035是什么情况？针对错误代码0x80070035的解决方法

错误代码0x80070035是什么情况？针对错误代码0x80070035的解决方法

错误代码 0x80070035 通常与网络连接和文件共享有关&#xff0c;表示“找不到网络路径”。这个问题可能由多种原因引起&#xff0c;包括网络设置不当、服务未启动、注册表配置错误等。今天这篇文章就和大家分享几种针对错误代码0x80070035的解决方法。 针对错误代码0x80070035问…
阅读更多...
Linux权限维持篇

Linux权限维持篇

目录 SSH后门 &#xff08;1&#xff09;软链接sshd &#xff08;2&#xff09;SSH Key 生成公私钥 创建个authorized_keys文件来保存公钥 通过修改文件时间来隐藏authorized_keys &#xff08;3&#xff09;SSH Keylogger&#xff08;记录日志&#xff09; Linux的PA…
阅读更多...
vue 给特定满足条件的表单数据添加背景颜色，组件的 row-class-name

vue 给特定满足条件的表单数据添加背景颜色，组件的 row-class-name

1、:row-class-name"tableRowClassName" 可为表格每行根据后面的函数绑定class名 <!-- 列表框 --><div class"tableList"><el-table :data"teamModelListTable" style"width: 100%"selection-change"handleSele…
阅读更多...
基于Python的哔哩哔哩国产动画排行数据分析系统

基于Python的哔哩哔哩国产动画排行数据分析系统

需要本项目的可以私信博主&#xff0c;提供完整的部署、讲解、文档、代码服务 随着经济社会的快速发展&#xff0c;中国影视产业迎来了蓬勃发展的契机&#xff0c;其中动漫产业发展尤为突出。中国拥有古老而又璀璨的文明&#xff0c;仅仅从中提取一部分就足以催生出大量精彩的…
阅读更多...
数字图像处理和机器视觉中的常用特殊矩阵及MATLAB实现详解

数字图像处理和机器视觉中的常用特殊矩阵及MATLAB实现详解

一、前言 Matlab的名称来源于“矩阵实验室&#xff08;Matrix Laboratory&#xff09;”&#xff0c;其对矩阵的操作具有先天性的优势&#xff08;特别是相对于C语言的数组来说&#xff09;。在数字图像处理和机器视觉实践中&#xff0c;为了提高编程效率&#xff0c;MATLAB 提…
阅读更多...
用Java手写jvm之实现查找class

用Java手写jvm之实现查找class

写在前面 完成类加载器加载class的三阶段&#xff0c;加载&#xff0c;解析&#xff0c;初始化中的加载&#x1f600;&#x1f600;&#x1f600; 源码 。 jvm想要运行class&#xff0c;是根据类全限定名称来从特定的位置基于类加载器来查找的&#xff0c;分别如下&#xff1a;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023