＜Linux开发＞驱动开发 -之-资源的并发与竞争处理

news2024/12/23 4:31:08

＜Linux开发＞驱动开发 -之-资源的并发与竞争处理

交叉编译环境搭建：
＜Linux开发＞ linux开发工具-之-交叉编译环境搭建

uboot移植可参考以下：
＜Linux开发＞ -之-系统移植 uboot移植过程详细记录（第一部分）
＜Linux开发＞ -之-系统移植 uboot移植过程详细记录（第二部分）
＜Linux开发＞ -之-系统移植 uboot移植过程详细记录（第三部分）(uboot移植完结)

Linux内核及设备树移植可参考以下：
＜Linux开发＞系统移植 -之- linux内核移植过程详细记录（第一部分）
＜Linux开发＞系统移植 -之- linux内核移植过程详细记录（第二部分完结）

Linux文件系统构建移植参考以下：
＜Linux开发＞系统移植 -之- linux构建BusyBox根文件系统及移植过程详细记录
＜Linux开发＞系统移植 -之-使用buildroot构建BusyBox根文件系统

Linux驱动开发参考以下：
＜Linux开发＞驱动开发 -之-pinctrl子系统
＜Linux开发＞驱动开发 -之-gpio子系统
＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的LED驱动
＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动

一 前言

对应资源的并发与竞争处理,主要涉及原子操作、自旋锁、信号量和互斥体这四个。不同进程同时访问同一个资源就会存在并发问题； 比如不同进程同时控制LED或beep。本文不过多解释四种处理并发的原理，读者可以自行查阅相关资料。这里只讲使用。那么我们接下来一个一个使用看看。

二 信号量

本次实现对beep的这个资源，来进行并发的处理，通过信号量的方式；
基于＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动，设备树无需改动，主要是修改驱动程序；

2.1 修改beep驱动

修改beep驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    struct semaphore sem;   /* 信号量 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    if (down_interruptible(&beep.sem)) {
        return -ERESTARTSYS;
    }

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    struct beep_dev *dev = filp->private_data;
    up(&dev->sem);  /* 释放信号量，信号量值加 1 */
    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    sema_init(&beep.sem, 1);


    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

2.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

2.3 编写测试asme信号量的app

编写测试app如下：

#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "stdio.h"

/*************************************************************** 
 * Copyright © onefu Co., Ltd. 2019-2023. All rights reserved. 
 * 文件名 : beep_water_app.c 
 * 作者 : water 
 * 版本 : V1.0 
 * 描述 : beep 驱测试APP。 
 * 其他 : 使用方法：./beep_water_app /dev/beep <1>|<2>
 *                argv[2] 0:关闭beep
 *                argv[2] 1:打开beep
 * 日志 : 初版V1.0 2023/05/28 water创建 
 * ***************************************************************/ 

#define BEEPOFF 0
#define BEEPON  1

/* 
* @description : main主程序 
* @param - argc : argv数组元素个数 
* @param - argv : 具体参数 
* @return : 0 成功;其他 失败 
*/ 
int main(int argc, char *argv[])
{
    int fd, retvalue;               //fd: 文件描述符 用以对文件操作    retvalue:存放函数操作后的返回值
    char *filename;                 //filename：文件名，有主函数参数传入赋值
    unsigned char databuf[1];       //定义的buf，用来读写数据用 
    int cnt = 0;

    if(argc != 3){                  //判断主函数传入的函数的参数的个数
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];              //获取第1个参数，存放的是文件的路径（即要操作的设备文件路径）
    
    fd = open(filename,O_RDWR);                         /*打开驱动文件*/
    if(fd < 0){
        printf("Can't open file %s\r\n",filename);      /*打开失败，输出提示*/
        return -1;
    }

    databuf[0] = atoi(argv[2]);                         /* 要执行的操作：打开或关闭 */

    retvalue = write(fd, databuf, sizeof(databuf));     /*向设备驱动写入数据*/
    if(retvalue < 0){
        printf("BEEP Control Failed!\r\n",filename);     /*写入错误输出提示*/
        close(fd);
        return -1;
    }

    /* 模拟占用 50S LED */
    while(1) {
        sleep(1);
        cnt++;
        printf("beep App running times:%d\r\n", cnt);
        if(cnt >= 10) break;
    }
    printf("App running finished!");
    
    retvalue = close(fd);                               /*关闭文件*/
    if(retvalue < 0){
        printf("Can't close file %s\r\n",filename);     /*关闭错误输出提示*/
        return -1;
    }

    return 0;
}
//编译指令： arm-linux-gnueabihf-gcc  beep_water_app.c  -o  beep_water_app

2.4 测试asme信号量的app编译

编译命令：

 arm-linux-gnueabihf-gcc  sema_beep_app.c  -o  sema_beep_app

在这里插入图片描述

2.5 运行验证

将编译的sema_beep_app执行文件放到设备的/root/water_soft/beep目录下；

cp sema_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

在这里插入图片描述
运行命令：

./sema_beep_app  /dev/beep 1&
 ./sema_beep_app  /dev/beep 0&

在这里插入图片描述
同时运行两个，第1个开启BEEP 10s,第2个关闭beep。
由现象可观测到，关闭命令 需要等待开启的命令运行完才会运行。所以可以知道，在操作Beep资源时，只有等待前面一个进程操作释放后，后一个进程才能操作beep资源。

三 互斥体

3.1 编译驱动

更改＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// #include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    // struct semaphore sem;   /* 信号量 */
    struct mutex lock;          /* 互斥体 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    // if (down_interruptible(&beep.sem)) {
    //     return -ERESTARTSYS;
    // }

    /* 获取互斥体,可以被信号打断 */
    if (mutex_lock_interruptible(&beep.lock)) {
        return -ERESTARTSYS;
    }

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    struct beep_dev *dev = filp->private_data;

    /* 释放信号量，信号量值加 1 */
    // up(&dev->sem);  

    /* 释放互斥锁 */
    mutex_unlock(&dev->lock);
    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    // sema_init(&beep.sem, 1);

    /* 初始化互斥体 */
    mutex_init(&beep.lock);

    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

3.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

3.3 编写测试互斥体信号的app

编写测试app与2.3小结一样，重命名为mutex_beep_app.c，然后编译，并将执行文件放到根文件系统中。

arm-linux-gnueabihf-gcc  mutex_beep_app.c  -o  mutex_beep_app
cp mutex_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

3.4 运行验证

运行命令：

 ./mutex_beep_app  /dev/beep  1&
 ./mutex_beep_app  /dev/beep  0&

在这里插入图片描述
实际现象与第二节内容一致，都是先运行完开启进程后，延时10s后才会执行第二个进程的关闭操作。

四 原子操作

4.1 编译驱动

更改＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// #include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    // struct semaphore sem;   /* 信号量 */
    // struct mutex lock;          /* 互斥体 */
    atomic_t lock; /* 原子变量 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{

    /* 通过判断原子变量的值来检查 beep 有没有被别的应用使用 */
    if (!atomic_dec_and_test(&beep.lock)) {
        atomic_inc(&beep.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
        return -EBUSY; /* beep 被使用，返回忙 */
    }

    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    // if (down_interruptible(&beep.sem)) {
    //     return -ERESTARTSYS;
    // }

    /* 获取互斥体,可以被信号打断 */
    // if (mutex_lock_interruptible(&beep.lock)) {
    //     return -ERESTARTSYS;
    // }

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    struct beep_dev *dev = filp->private_data;

    /* 释放信号量，信号量值加 1 */
    // up(&dev->sem);  

    /* 释放互斥锁 */
    // mutex_unlock(&dev->lock);

    /* 关闭驱动文件的时候释放原子变量 */
    atomic_inc(&dev->lock);

    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    // sema_init(&beep.sem, 1);

    /* 初始化互斥体 */
    // mutex_init(&beep.lock);

    /* 初始化原子变量 */
    atomic_set(&beep.lock, 1); /* 原子变量初始值为 1 */

    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

4.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

4.3 编写测试原子操作的app

编写测试app与2.3小结一样，重命名为atomic_beep_app.c，然后编译，并将执行文件放到根文件系统中。

arm-linux-gnueabihf-gcc  atomic_beep_app.c  -o  atomic_beep_app
 cp atomic_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

4.4 运行验证

运行命令：

 ./atomic_beep_app /dev/beep  1&
 ./atomic_beep_app /dev/beep  0&

在这里插入图片描述

实际现象是第2个进程使用beep时会报错，除非是第1个进程已经使用完beep释放了。

五 自旋锁

5.1 编译驱动

更改＜Linux开发＞驱动开发 -之-基于pinctrl/gpio子系统的beep驱动驱动后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : beep.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 beep蜂鸣器。
其他 : 无
日志 : 初版 V1.0 2023/05/28 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
// #include <linux/semaphore.h>

#define BEEP_CNT 1              /* 设备号个数 */
#define BEEP_NAME "beep"        /* 名字 */
#define BEEPOFF 0                /* 关beep */
#define BEEPON 1                 /* 开beeo */

/* beep 设备结构体 */
struct beep_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int beep_gpio;          /* beep 所使用的 GPIO 编号 */
    // struct semaphore sem;   /* 信号量 */
    // struct mutex lock;          /* 互斥体 */
    // atomic_t lock; /* 原子变量 */
    int dev_stats;          /* 设备状态，0，设备未使用;>0,设备已经被使用 */
    spinlock_t lock;        /* 自旋锁 */

};
 
struct beep_dev beep; /* beep 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int beep_open(struct inode *inode, struct file *filp)
{
    unsigned long flags;

    /* 通过判断原子变量的值来检查 beep 有没有被别的应用使用 */
    // if (!atomic_dec_and_test(&beep.lock)) {
    //     atomic_inc(&beep.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
    //     return -EBUSY; /* beep 被使用，返回忙 */
    // }

    filp->private_data = &beep; /* 设置私有数据 */
    /* 获取信号量,进入休眠状态的进程可以被信号打断 */
    // if (down_interruptible(&beep.sem)) {
    //     return -ERESTARTSYS;
    // }

    /* 获取互斥体,可以被信号打断 */
    // if (mutex_lock_interruptible(&beep.lock)) {
    //     return -ERESTARTSYS;
    // }

    spin_lock_irqsave(&beep.lock, flags); /* 上锁 */
    if (beep.dev_stats) { /* 如果设备被使用了 */
        spin_unlock_irqrestore(&beep.lock, flags); /* 解锁 */
        return -EBUSY;
    }
    beep.dev_stats++; /* 如果设备没有打开，那么就标记已经打开了 */
    spin_unlock_irqrestore(&beep.lock, flags);/* 解锁 */

    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t beep_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t beep_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char beepstat;
    struct beep_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    beepstat = databuf[0]; /* 获取状态值 */

    if(beepstat == BEEPON) { 
        gpio_set_value(dev->beep_gpio, 0); /* 打开 beep */
    } else if(beepstat == BEEPOFF) {
        gpio_set_value(dev->beep_gpio, 1); /* 关闭 beep */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int beep_release(struct inode *inode, struct file *filp)
{
    unsigned long flags;
    
    struct beep_dev *dev = filp->private_data;

    /* 释放信号量，信号量值加 1 */
    // up(&dev->sem);  

    /* 释放互斥锁 */
    // mutex_unlock(&dev->lock);

    /* 关闭驱动文件的时候释放原子变量 */
    // atomic_inc(&dev->lock);

    /* 关闭驱动文件的时候将 dev_stats 减 1 */
    spin_lock_irqsave(&dev->lock, flags); /* 上锁 */
    if (dev->dev_stats) {
        dev->dev_stats--;
    }
    spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */

    return 0;
}

/* 设备操作函数 */
static struct file_operations beep_fops = {
    .owner = THIS_MODULE,
    .open = beep_open,
    .read = beep_read,
    .write = beep_write,
    .release = beep_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_beep_init(void)
{
    int ret = 0;

    /* 初始化信号量 */
    // sema_init(&beep.sem, 1);

    /* 初始化互斥体 */
    // mutex_init(&beep.lock);

    /* 初始化原子变量 */
    // atomic_set(&beep.lock, 1); /* 原子变量初始值为 1 */

    /* 初始化自旋锁 */
    spin_lock_init(&beep.lock);

    /* 设置 beep 所使用的 GPIO */
    /* 1、获取设备节点： beep */
    beep.nd = of_find_node_by_path("/beep");
    if(beep.nd == NULL) {
        printk("beep node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("beep node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    beep.beep_gpio = of_get_named_gpio(beep.nd, "beep-gpio", 0);
    if(beep.beep_gpio < 0) {
        printk("can't get beep-gpio");
        return -EINVAL;
    }
    printk("beep num = %d\r\n", beep.beep_gpio);

    /* 3、设置 GPIO5_IO01 为输出，并且输出高电平，默认关闭 beep */
    ret = gpio_direction_output(beep.beep_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (beep.major) { /* 定义了设备号 */
        beep.devid = MKDEV(beep.major, 0);
        register_chrdev_region(beep.devid, BEEP_CNT,
                                    BEEP_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&beep.devid, 0, BEEP_CNT, 
                                    BEEP_NAME); /* 申请设备号 */
        beep.major = MAJOR(beep.devid); /* 获取分配号的主设备号 */
        beep.minor = MINOR(beep.devid); /* 获取分配号的次设备号 */
    }
    printk("beep major=%d,minor=%d\r\n",beep.major,
                                    beep.minor); 

    /* 2、初始化 cdev */
    beep.cdev.owner = THIS_MODULE;
    cdev_init(&beep.cdev, &beep_fops);

    /* 3、添加一个 cdev */
    cdev_add(&beep.cdev, beep.devid, BEEP_CNT);

    /* 4、创建类 */
    beep.class = class_create(THIS_MODULE, BEEP_NAME);
    if (IS_ERR(beep.class)) {
    return PTR_ERR(beep.class);
    }

    /* 5、创建设备 */
    beep.device = device_create(beep.class, NULL,
                            beep.devid, NULL, BEEP_NAME);
    if (IS_ERR(beep.device)) {
        return PTR_ERR(beep.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_beep_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&beep.cdev); /* 删除 cdev */
    unregister_chrdev_region(beep.devid, BEEP_CNT); /* 注销 */

    device_destroy(beep.class, beep.devid);
    class_destroy(beep.class);
}

module_init(water_beep_init);
module_exit(water_beep_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

5.2 编译驱动

笔者使用集成kernel一起编译的，所以修改完后，直接整个kernel编译即可，读者也可以模块编译然后挂载。使用新编译的Kernel内核启动；

5.3 编写测试自旋锁的app

编写测试app与2.3小结一样，重命名为spinlock_beep_app.c，然后编译，并将执行文件放到根文件系统中。

arm-linux-gnueabihf-gcc  spinlock_beep_app.c  -o  spinlock_beep_app
cp spinlock_beep_app ../../nfs/buildrootfs/root/water_soft/beep/

5.4 运行验证

运行命令：

 ./spinlock_beep_app  /dev/beep  1&
 ./spinlock_beep_app  /dev/beep  0&

在这里插入图片描述
实际现象是第2个进程使用beep时会报错，除非是第1个进程已经使用完beep释放了。

六 LED互斥资源

针对资源的互斥访问问题，在经过前面4个测试案例，后续开发kernel实际使用，beep驱动使用自旋锁，而led驱动使用原子变量方式。
led驱动更改后如下：

/***************************************************************
Copyright © OneFu Co., Ltd. 2018-2023. All rights reserved.
文件名 : gpioled.c
作者 : water
版本 : V1.0
描述 : 采用 pinctrl 和 gpio 子系统驱动 LED 灯。
其他 : 无
日志 : 初版 V1.0 2023/05/24 water创建
***************************************************************/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPIOLED_CNT 1           /* 设备号个数 */
#define GPIOLED_NAME "gpioled"  /* 名字 */
#define LEDOFF 0                /* 关灯 */
#define LEDON 1                 /* 开灯 */

/* gpioled 设备结构体 */
struct gpioled_dev{
    dev_t devid;            /* 设备号 */
    struct cdev cdev;       /* cdev */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    struct device_node *nd; /* 设备节点 */
    int led_gpio;           /* led 所使用的 GPIO 编号 */
    atomic_t lock; /* 原子变量 */
};
 
struct gpioled_dev gpioled; /* led 设备 */

/*
* @description : 打开设备
* @param – inode : 传递给驱动的 inode
* @param – filp : 设备文件，file 结构体有个叫做 private_data 的成员变量
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int led_open(struct inode *inode, struct file *filp)
{
    /* 通过判断原子变量的值来检查 LED 有没有被别的应用使用 */
    if (!atomic_dec_and_test(&gpioled.lock)) {
        atomic_inc(&gpioled.lock);/* 小于 0 的话就加 1,使其原子变量等于 0 */
        return -EBUSY; /* LED 被使用，返回忙 */
    }

    filp->private_data = &gpioled; /* 设置私有数据 */
    return 0;
}

/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t led_read(struct file *filp, char __user *buf,
                        size_t cnt, loff_t *offt)
{
    return 0;
}
 
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t led_write(struct file *filp, const char __user *buf,
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;
    struct gpioled_dev *dev = filp->private_data;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0) {
        printk("kernel write failed!\r\n");
        return -EFAULT;
    }

    ledstat = databuf[0]; /* 获取状态值 */

    if(ledstat == LEDON) { 
        gpio_set_value(dev->led_gpio, 0); /* 打开 LED 灯 */
    } else if(ledstat == LEDOFF) {
        gpio_set_value(dev->led_gpio, 1); /* 关闭 LED 灯 */
    }
    return 0;
}

/*
* @description : 关闭/释放设备
* @param – filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int led_release(struct inode *inode, struct file *filp)
{
    struct gpioled_dev *dev = filp->private_data;

    /* 关闭驱动文件的时候释放原子变量 */
    atomic_inc(&dev->lock);
    return 0;
}

/* 设备操作函数 */
static struct file_operations gpioled_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .read = led_read,
    .write = led_write,
    .release = led_release,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init water_led_init(void)
{
    int ret = 0;

    /* 初始化原子变量 */
    atomic_set(&gpioled.lock, 1); /* 原子变量初始值为 1 */

    /* 设置 LED 所使用的 GPIO */
    /* 1、获取设备节点：gpioled */
    gpioled.nd = of_find_node_by_path("/gpioled");
    if(gpioled.nd == NULL) {
        printk("gpioled node cant not found!\r\n");
        return -EINVAL;
    } else {
        printk("gpioled node has been found!\r\n");
    }

    /* 2、 获取设备树中的 gpio 属性，得到 LED 所使用的 LED 编号 */
    gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
    if(gpioled.led_gpio < 0) {
        printk("can't get led-gpio");
        return -EINVAL;
    }
    printk("led-gpio num = %d\r\n", gpioled.led_gpio);

    /* 3、设置 GPIO1_IO03 为输出，并且输出高电平，默认关闭 LED 灯 */
    ret = gpio_direction_output(gpioled.led_gpio, 1);
    if(ret < 0) {
        printk("can't set gpio!\r\n");
    }

    /* 注册字符设备驱动 */
    /* 1、创建设备号 */
    if (gpioled.major) { /* 定义了设备号 */
        gpioled.devid = MKDEV(gpioled.major, 0);
        register_chrdev_region(gpioled.devid, GPIOLED_CNT,
                                    GPIOLED_NAME);
    } else { /* 没有定义设备号 */
        alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, 
                                    GPIOLED_NAME); /* 申请设备号 */
        gpioled.major = MAJOR(gpioled.devid); /* 获取分配号的主设备号 */
        gpioled.minor = MINOR(gpioled.devid); /* 获取分配号的次设备号 */
    }
    printk("gpioled major=%d,minor=%d\r\n",gpioled.major,
                                    gpioled.minor); 

    /* 2、初始化 cdev */
    gpioled.cdev.owner = THIS_MODULE;
    cdev_init(&gpioled.cdev, &gpioled_fops);

    /* 3、添加一个 cdev */
    cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);

    /* 4、创建类 */
    gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
    if (IS_ERR(gpioled.class)) {
    return PTR_ERR(gpioled.class);
    }

    /* 5、创建设备 */
    gpioled.device = device_create(gpioled.class, NULL,
                            gpioled.devid, NULL, GPIOLED_NAME);
    if (IS_ERR(gpioled.device)) {
        return PTR_ERR(gpioled.device);
    }
    return 0;
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit water_led_exit(void)
{
    /* 注销字符设备驱动 */
    cdev_del(&gpioled.cdev); /* 删除 cdev */
    unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销 */

    device_destroy(gpioled.class, gpioled.devid);
    class_destroy(gpioled.class);
}

module_init(water_led_init);
module_exit(water_led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("water");

七 总结

学会如何让资源访问变得更加和，需要加入上述所说的一些方法，来让互斥访问变得合理和有效。 后续也将根据上述方法继续开发后面的驱动程序。

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

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

相关文章

K8s之Pod生命周期、启动停止钩子详解

K8s之Pod生命周期、启动停止钩子详解

文章目录 一、Pod生命周期流程二、初始化容器-initContainers三、主容器操作-containers1、启动钩子-lifecycle.postStart2、停止钩子-lifecycle.preStop 一、Pod生命周期流程 Pod生命周期整个过程 如下图&#xff1a; 1、在启动任何容器之前&#xff0c;前创建 pause 容器&am…
阅读更多...
网络通信IO模型上

网络通信IO模型上

计算机组成 计算机由软件和硬件组成&#xff0c;软件包括CPU、内存等&#xff0c;硬件包括主板&#xff0c;磁盘&#xff0c;IO设备&#xff08;网卡、鼠标、键盘等&#xff09;、电源按钮。 内核程序加载过程 当接通电源的时候1、BIOS就会把它的一段代码放入了内存当中&#…
阅读更多...
ORB SLAM3 构建Frame

ORB SLAM3 构建Frame

1.构造Frame 为了构建一帧Frame&#xff0c;主要的步骤如下&#xff1a; 提取ORB特征点(ExtractORB)对提取的特征点进行矫正(cv::undistortPoints)计算去畸变后的图像边界(ComputeImageBounds)将特征点分配到网格中(AssignFeaturesToGrid) A.提取ORB特征点 首先需要对当前帧…
阅读更多...
某程序员哀叹：月薪四五万，却每天极度焦虑痛苦，已有生理性不适，又不敢裸辞，该怎么办？

某程序员哀叹：月薪四五万，却每天极度焦虑痛苦，已有生理性不适，又不敢裸辞，该怎么办？

高薪能买来快乐吗&#xff1f; 来看看这位程序员的哀叹&#xff1a; 实在是扛不住了&#xff0c;每天都在极度焦虑和痛苦中度过&#xff0c;早上起来要挣扎着做心理建设去上班&#xff0c;已经产生生理性的头晕恶心食欲不振。有工作本身的原因&#xff0c;更多是自己心态的问…
阅读更多...
如何在CSDN获得铁粉

如何在CSDN获得铁粉

文章目录 前言关于铁粉方法总结 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 铁粉512位即可参加此活动 完成一篇如何获得铁粉&#xff0c;或者相关的文章且质量分达到80分以上即可 关于铁粉 简单地说&#xff0c;就是在过去 N 个月内&#xff0c;一…
阅读更多...
vscode配置flutter开发环境，不需要安装第三方安卓模拟器

vscode配置flutter开发环境，不需要安装第三方安卓模拟器

1.获取Flutter SDK 点击下方的安装包&#xff0c;获取 stable 发行通道的 Flutter SDK 最新版本&#xff1a;Flutter SDK 将压缩包解压&#xff0c;然后把其中的 flutter 目录整个放在你想放置 Flutter SDK 的路径中**&#xff08;注意不要出现中文目录&#xff09;** 配置Wi…
阅读更多...
Spring Boot配置文件（5/27）

Spring Boot配置文件（5/27）

1.Spring Boot 配置文件的分类和作用 整个项目所有重要的数据都是在配置文件中配置的 1.数据库连接信息&#xff08;包含用户名和密码的设置&#xff09; 2.项目的启动窗口&#xff1b; 3.第三方系统调用密匙等信息 4.用于发现和定位问题的普通日志和异常日志等等 大体上可以分…
阅读更多...
基于FPGA的Bayer转RGB算法实现

基于FPGA的Bayer转RGB算法实现

1 概述 Bayer转RGB在图像处理中被称为去马赛克&#xff08;Demosaic&#xff09;&#xff0c;是机器视觉ISP流程中的一个基础且重要的算法&#xff0c;主要完成彩色图像传感器原始的Bayer格式图像到RGB格式图像的转换。 关于Bayer图像的相关概念和知识&#xff0c;本文不作介绍…
阅读更多...
jquery data和data-属性不一致问题

jquery data和data-属性不一致问题

延申val和value属性同样不一致 <script src"https://code.jquery.com/jquery-3.7.0.min.js"></script> <input type"text" value"F119-PW110" data-tag"F119" id"txtEngine" name"Engine" placeh…
阅读更多...
第十六届全国大学生信息安全竞赛创新实践能力赛（CISCN）

第十六届全国大学生信息安全竞赛创新实践能力赛（CISCN）

目录 Misc 1、被加密的生产流量 Crypto 2、Sign_in_passwd Web 3、unzip 4、dumpit Re 5、babyRE Pwn 6、funcanary Misc 1、被加密的生产流量 下载附件解压后是一段流量&#xff0c;使用wireshark打开 最开始做的时候找错了方向&#xff0c;追踪到了另一个东西 …
阅读更多...
阿里云服务器配置怎么选择合适？CPU内存带宽配置

阿里云服务器配置怎么选择合适？CPU内存带宽配置

阿里云服务器配置如何选择&#xff1f;个人用户选择通用算力型u1云服务器或轻量应用服务器&#xff0c;2核2G、2核4G配置即可&#xff0c;企业公司用户可以选择独享型ECS计算型c7、通用型g7等&#xff0c;4核8G、8核16G、4核32G等配置&#xff0c;阿里云百科来详细说下不同用户…
阅读更多...
实验二十一、积分运算电路的输出波形分析

实验二十一、积分运算电路的输出波形分析

一、题目 利用 Multisim 分析图1所示两个积分运算电路的输出波形&#xff0c;输入电压为 200 Hz、幅值为 1 V 的方波信号。 图 1 图1\,\, 图1 二、仿真电路 在 Multism 中搭建图1所示的两个电路&#xff0c;如图2所示。为了防止电路中的直流增益过大&#xff0c;故在电容上…
阅读更多...
node.js与内置模块

node.js与内置模块

一、目标 能够知道什么是Node.js能够知道Node.js可以做什么能够说出Node.js中的JavaScript的组成部分能够使用fs模块读写操作文件能够使用path模块处理路径能够使用http模块写一个基本的web服务器 二、目录 初始Node.jsfs文件系统模块path路径模块http模块 1.初始Node.js …
阅读更多...
[Nacos] Nacos Server处理订阅请求 (九)

[Nacos] Nacos Server处理订阅请求 (九)

文章目录 1.InstanceController#list()2.InstanceController#doSrvIpxt()3.总结 1.InstanceController#list() Nacos Server处理订阅请求 主要还是从请求中获取参数, 比如namespceId、serviceName、agent(指定提交请求的客户端是哪种类型)、clusters、clusterIP、udpPort(后续…
阅读更多...
2023全国酒店数据

2023全国酒店数据

数据内容字段结构 hotel_id int(11) NOT NULL, name varchar(100) DEFAULT NULL, name_en varchar(100) DEFAULT NULL, short_name varchar(100) DEFAULT NULL, province varchar(20) DEFAULT NULL, city_id int(11) DEFAULT NULL, city varchar(20…
阅读更多...
R语言实践——使用rWCVP在WCVP中匹配名称

R语言实践——使用rWCVP在WCVP中匹配名称

使用rWCVP在WCVP中匹配名称 加载库工作流1. 示例数据&#xff1a;IUCN红色名录2. 将匹配的名称解析为接受名2.1 模糊匹配2.2 多项匹配2.3 将评估与接受的名称相关联 3. 可视化匹配过程4. 得到最终数据集 加载库 世界维管植物名录提供了所有已知维管植物物种的全球共识观点&…
阅读更多...
LabView中条件结构的使用方法1

LabView中条件结构的使用方法1

LabView中的条件结构包含一个或多个子程序框图&#xff0c;即分支&#xff0c;当满足某个条件时&#xff0c;相应的分支会被执行。也就是说&#xff0c;在条件结构执行时&#xff0c;仅有一个分支被执行。当程序存在两种或多种可能性时&#xff0c;可以使用条件结构。 1 创建条…
阅读更多...
攻防世界安卓逆向练习

攻防世界安卓逆向练习

一.easy-so jadx分析程序逻辑 可以看到关键在于cyberpeace.CheckString()函数 双击跟进之后可以发现是native层函数 ida查看so文件 程序逻辑: 将字符串保存到新的空间buffer中第一个判断是将buffer的前16个字符和后16个字符进行交换第二个判断是将buffer的2个相邻的字符互换位…
阅读更多...
算法|10.从暴力递归到动态规划3

算法|10.从暴力递归到动态规划3

算法|10.从暴力递归到动态规划3 1.纸牌游戏 题意&#xff1a;给定一个整型数组arr&#xff08;都是正数&#xff09;&#xff0c;代表数值不同的纸牌排成一条线。玩家A和玩家B依次拿走每张纸牌&#xff0c;规定玩家A先拿&#xff0c;玩家B后拿。但是每个玩家每次只能拿走最左…
阅读更多...
(10) 朴素贝叶斯

(10) 朴素贝叶斯

文章目录 1 概述2 不同分布下的贝叶斯2.1 高斯朴素贝叶斯GaussianNB2.1.1 认识高斯朴素贝叶斯2.1.2 探索贝叶斯&#xff1a;高斯朴素贝叶斯擅长的数据集2.1.3 探索贝叶斯&#xff1a;高斯朴素贝叶斯的拟合效果与运算速度 2.2 概率类模型的评估指标2.2.1 布里尔分数Brier Score2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023