驱动-并发与竞争_内核驱动并发是如何实现的-CSDN博客

本文链接：https://blog.csdn.net/ItJavawfc/article/details/147296493

并发与竞争
这么多年接触下来，操作系统下不同的编程语言都有对应的并发、并行、线程、进程、同步、异步一说。这些核心本质其实是操作系>统的机制。
那么不同开发语言下面对应的形态不一样而已，表现形式不一样，但是基本概念、实现原理都是基于操作系统的。
在上学课本上面操作系统学科里面应该是第一次接触进程、线程、这些基本理论的。这里我们在驱动层面理解实验

文章目录

基本概念
参考资料
驱动程序实验源码
驱动程序步骤

基本概念

个人理解：
进程：程序的一次执行
线程：操作系统最小的操作单位
并发：将 CPU 资源合理地分配给多个任务，当一个任务执行 I/O 操作时， CPU 可以转而执行其它的任务，等到 I/O 操作完成以后，或者新的任务遇到 I/O 操作时，CPU 再回到原来的任务继续执行。我们理解为CPU 切片。
并行：多核 CPU 的每个核心都可以独立地执行一个任务，而且多个核心之间不会相互干扰。在不同核心上执行的多个任务，是真正地同时运行，这种状态就叫做并行

因为现在都是多核、多任务的，就在一定情况下一定存在资源访问情景。多任务、多线程、多进程下的场景下，共享资源、竞争资源会出各种问题，如何友好的来实现按需资源分配就是开发者需要了解、熟悉、掌握的技能了。

特别是高并发场景下

参考资料

在字符设备这块内容，所有知识点都是串联起来的，这里用到了字符设备相关内容，如果对字符设备不熟悉的，建议参考下之前资料。
驱动-申请字符设备号
 驱动-注册字符设备
 驱动-创建设备节点
 驱动-字符设备驱动框架
 驱动-杂项设备
 驱动-内核空间和用户空间数据交换
 驱动-文件私有数据

驱动程序实验源码

编写并发与竞争的驱动代码，首先完善字符设备驱动框架，然后通过
copy_from_user(…)函数接收用户空间传递到内核空间的数据并进行判断，如果接收到的字符串
数据为“topeet”会在睡眠 4 秒钟后打印接收到的数据，如果接收到的字符串数据为“itop”会在睡
眠 2 秒钟后打印接收到的数据

测试源码 example.c

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

static int open_test(struct inode *inode, struct file *file)
{
    printk("\n this is open_test \n");
    return 0;
};

static ssize_t read_test(struct file *file, char __user *ubuf, size_t len, loff_t *off)
{
    int ret;
    char kbuf[10] = "topeet"; // 定义char类型字符串变量kbuf
    printk("\nthis is read_test \n");
    ret = copy_to_user(ubuf, kbuf, strlen(kbuf)); // 使用copy_to_user接收用户空间传递的数据
    if (ret != 0)
    {
        printk("copy_to_user is error \n");
    }
    printk("copy_to_user is ok \n");
    return 0;
}
static char kbuf[10] = {0}; // 定义char类型字符串全局变量kbuf
static ssize_t write_test(struct file *file, const char __user *ubuf, size_t len, loff_t *off)
{
    int ret;
    ret = copy_from_user(kbuf, ubuf, len); // 使用copy_from_user接收用户空间传递的数据
    if (ret != 0)
    {
        printk("copy_from_user is error\n");
    }
    if (strcmp(kbuf, "topeet") == 0)
    { // 如果传递的kbuf是topeet就睡眠四秒钟
        printk("get topeet  - sleep 4   start   \n");
        ssleep(4);
        printk("get topeet  - sleep 4   end   \n");
    }
    else if (strcmp(kbuf, "itop") == 0)
    { // 如果传递的kbuf是itop就睡眠两秒钟
        printk("get itop  - sleep 2  start   \n");
        ssleep(2);
        printk("get itop  - sleep 2  end   \n");
    }
    printk("copy_from_user buf is %s \n", kbuf);
    return 0;
}
static int release_test(struct inode *inode, struct file *file)
{
    // printk("\nthis is release_test \n");
    return 0;
}

struct chrdev_test
{
    dev_t dev_num;            // 定义dev_t类型变量来表示设备号
    int major, minor;         // 定义int 类型的主设备号和次设备号
    struct cdev cdev_test;    // 定义字符设备
    struct class *class_test; // 定义结构体变量class 类
};

struct chrdev_test dev1; // 创建chardev_test类型结构体变量

static struct file_operations fops_test = {
    .owner = THIS_MODULE,    // 将owner字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
    .open = open_test,       // 将open字段指向chrdev_open(...)函数
    .read = read_test,       // 将open字段指向chrdev_read(...)函数
    .write = write_test,     // 将open字段指向chrdev_write(...)函数
    .release = release_test, // 将open字段指向chrdev_release(...)函数
}; // 定义file_operations结构体类型的变量cdev_test_ops

static int __init chrdev_fops_init(void) // 驱动入口函数
{

    if (alloc_chrdev_region(&dev1.dev_num, 0, 1, "chrdev_name") < 0)
    {
        printk("alloc_chrdev_region is error\n");
    }
    printk("alloc_chrdev_region is ok\n");
    dev1.major = MAJOR(dev1.dev_num); // 通过MAJOR()函数进行主设备号获取
    dev1.minor = MINOR(dev1.dev_num); // 通过MINOR()函数进行次设备号获取
    printk("major is %d\n", dev1.major);
    printk("minor is %d\n", dev1.minor);

    ////使用cdev_init()函数初始化cdev_test结构体，并链接到cdev_test_ops结构体
    cdev_init(&dev1.cdev_test, &fops_test);
    dev1.cdev_test.owner = THIS_MODULE; // 将owner字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块

    cdev_add(&dev1.cdev_test, dev1.dev_num, 1);
    printk("cdev_add is ok\n");
    dev1.class_test = class_create(THIS_MODULE, "class_test");               // 使用class_create进行类的创建，类名称为class_test
    device_create(dev1.class_test, NULL, dev1.dev_num, NULL, "device_test"); // 使用device_create进行设备的创建，设备名称为device_test

    return 0;
}
static void __exit chrdev_fops_exit(void) // 驱动出口函数
{
    cdev_del(&dev1.cdev_test);                     // 使用cdev_del()函数进行字符设备的删除
    unregister_chrdev_region(dev1.dev_num, 1);     // 释放字符驱动设备号
    device_destroy(dev1.class_test, dev1.dev_num); // 删除创建的设备
    class_destroy(dev1.class_test);                // 删除创建的类
    printk("module exit \n");
}
module_init(chrdev_fops_init);    // 注册入口函数
module_exit(chrdev_fops_exit);    // 注册出口函数
MODULE_LICENSE("GPL v2");         // 同意GPL开源协议
MODULE_AUTHOR("wang fang chen "); // 作者信息

这里所有的知识点都是之前字符操作相关的内容，暂不讨论，这里测试的核心关联代码是测试程序写入数据，copy 用户到内核数据里面去然后打印内核数据，如下：

static ssize_t write_test(struct file *file, const char __user *ubuf, size_t len, loff_t *off)
{
    int ret;
    ret = copy_from_user(kbuf, ubuf, len); // 使用copy_from_user接收用户空间传递的数据
    if (ret != 0)
    {
        printk("copy_from_user is error\n");
    }
    if (strcmp(kbuf, "topeet") == 0)
    { // 如果传递的kbuf是topeet就睡眠四秒钟
        printk("get topeet  - sleep 4   start   \n");
        ssleep(4);
        printk("get topeet  - sleep 4   end   \n");
    }
    else if (strcmp(kbuf, "itop") == 0)
    { // 如果传递的kbuf是itop就睡眠两秒钟
        printk("get itop  - sleep 2  start   \n");
        ssleep(2);
        printk("get itop  - sleep 2  end   \n");
    }
    printk("copy_from_user buf is %s \n", kbuf);
    return 0;
}

编译配置文件 Makefile

#!/bin/bash
export ARCH=arm64
export CROSS_COMPILE=aarch64-linux-gnu-
obj-m += example.o
KDIR :=/home/wfc123/Linux/rk356x_linux/kernel
PWD ?= $(shell pwd)
all:
	make -C $(KDIR) M=$(PWD) modules

clean:
	make -C $(KDIR) M=$(PWD) clean

测试程序 app.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
     
int main(int argc,char *argv[])
{
    int fd;//定义int类型的文件描述符
    char str1[10]={0};//定义读取缓冲区str1
    fd=open(argv[1],O_RDWR,0666);//调用open函数，打开输入的第一个参数文件，权限为可读可写
    //fd=open("/dev/device_test",O_RDWR,0666);//调用open函数，打开输入的第一个参数文件，权限为可读可写
    if(fd<0){
        printf("open is error\n");
        return -1;
    }
    printf("open is ok\n");
    if(strcmp(argv[2],"topeet")==0){
     write(fd,"topeet",sizeof(str1)); 
    }else if(strcmp(argv[2],"itop")==0)
    {
             write(fd,"itop",sizeof(str1)); 
    }
    

    close(fd);//调用close函数，对取消文件描述符到文件的映射
    return 0;
}

驱动程序步骤

加载驱动 insmod

结果如下，这里其实都是以前的字符设备管理的驱动实验。如下说明驱动设备创建成功了。
在这里插入图片描述

ls /dev/device_test 查看字符驱动设备生成的节点

[root@topeet:/mnt/sdcard]# ls /dev/device_test
/dev/device_test
[root@topeet:/mnt/sdcard]#

测试程序 ./app 测试验证

这里两个测试脚本命令一起执行，如下：

./app /dev/device_test topeet &
./app /dev/device_test itop &

测试得到结果如下：
在这里插入图片描述

分析：

./app 执行两个命令，传参不同的，两个测试命令一同执行
打印的 copy from user buf is itop 都是 itop ，并不符合传入参数先传递的是 tpeet 再传递的itop. 理论上应该打印的就是 tpeet 和 itop. 的。 strcmp 判断内核数据正常的，但是这里其实问题出在驱动程序代码中几乎同时执行的 copy_from_user 方法，将用户数据传递到内核。导致内核数据异常了。这里程序简要说明了异常现象，后续需要解决这个问题的。

直接原因是第二个 app 应用程序运行之后对共享资源进行了修改，两个 app 应用
程序就产生了竞争关系，会在之后的章节中使用不同的方法对上述驱动程序进行改进，从而避
免竞争的产生。