首页 > 系统相关 >linux驱动开发-内核并发 poll 和 lock

linux驱动开发-内核并发 poll 和 lock

时间:2024-09-17 18:24:39浏览次数:12  
标签:include lock 写入 char 线程 linux static poll 设备

内核并发poll 加 lock

执行流程
用户空间进程调用write将数据写入设备:

执行char_write,更新event_triggered并唤醒等待的进程。

有进程因此等待:

正在执行的char_read会检查event_triggered,如果为0,执行等待。

数据可用时:

事件被触发(event_triggered被设为1),之前因等待而被挂起的进程重启,继续执行char_read。
#include <linux/module.h>         // 包含模块相关的头文件,定义模块宏和操作
#include <linux/kernel.h>         // 包含内核相关的头文件,提供基本的内核函数
#include <linux/init.h>           // 包含模块初始化和卸载相关的头文件
#include <linux/fs.h>             // 包含文件系统相关的头文件,定义字符设备操作函数
#include <linux/cdev.h>           // 包含字符设备相关的头文件
#include <linux/poll.h>           // 包含poll相关的头文件
#include <linux/wait.h>           // 包含等待队列相关的头文件
#include <linux/sched.h>          // 包含调度相关的头文件
#include <linux/uaccess.h>        // 包含用户空间和内核空间数据访问相关的头文件

#define DEVICE_NAME "epoll_example"              // 定义设备名称
#define CLASS_NAME "epoll_example_class"         // 定义设备类别名称
// 假设我们存储了写入的数据
static char kbuf[256]; // 用于保持写入的数据
static size_t data_size = 0; // 数据大小

// 定义设备的主设备号
static int major_number;
// 定义设备类
static struct class* char_class = NULL;
// 定义设备
static struct device* char_device = NULL;
// 定义字符设备结构体
static struct cdev cdev;

// 定义读取时的等待队列头
static wait_queue_head_t read_wait;
// 标志变量,表示是否发生事件
static int event_triggered = 0;

static DEFINE_SPINLOCK(event_lock); // 定义一个自旋锁


// 设备打开函数
static int char_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device opened: PID=%d, INODE=%lx\n", current->pid, (unsigned long)inode->i_ino); // 打印设备打开信息和当前进程的PID
    return 0; // 返回成功
}

// 设备关闭函数
static int char_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device closed: PID=%d, INODE=%lx\n", current->pid, (unsigned long)inode->i_ino); // 打印设备关闭信息和当前进程的PID
    return 0; // 返回成功
}

// 更新char_write
static ssize_t char_write(struct file *file, const char __user *buf, size_t len, loff_t *offset) {
    if (len > sizeof(kbuf) - 1) {
        return -EINVAL; // 返回无效参数错误
    }

    if (copy_from_user(kbuf, buf, len)) {
        return -EFAULT; // 返回错误,如果数据复制失败
    }
    
    kbuf[len] = '\0'; // 确保字符串以空字符结束
    data_size = len;  // 记录数据大小
    
    spin_lock(&event_lock); // 加锁
    event_triggered = 1; // 设置事件标志
    spin_unlock(&event_lock); // 解锁
    
    wake_up_interruptible(&read_wait); // 唤醒等待的读取操作
    return len; // 返回写入的字节数
}


// 更新char_read
static ssize_t char_read(struct file *file, char __user *buf, size_t len, loff_t *offset) {
    // 检查数据是否被触发
    if (!event_triggered) {
        wait_event_interruptible(read_wait, event_triggered != 0); // 等待事件触发
    }

    // 将数据写入用户空间
    if (copy_to_user(buf, kbuf, data_size)) {
        return -EFAULT; // 返回错误,如果数据复制失败
    }

    spin_lock(&event_lock); // 加锁
    event_triggered = 0; // 重置标志
    spin_unlock(&event_lock); // 解锁
    printk(KERN_INFO "读取数据完成\n");

    return data_size; // 返回读取的字节数
}

// 设备轮询函数
static unsigned int char_poll(struct file *file, poll_table *wait) {
    unsigned int mask = 0;

    // 将当前进程加入到等待队列中
    poll_wait(file, &read_wait, wait);
    printk(KERN_INFO "记录当前进程加入到等待队列中\n"); // 记录轮询状态

    // 如果事件触发,设置相应的标志
    if (event_triggered) {
        mask |= POLLIN | POLLRDNORM; // 设置POLLIN和POLLRDNORM标志
        printk(KERN_INFO "记录事件已触发: %u\n", mask); // 记录事件已触发
    }

    return mask; // 返回轮询状态
}

// 文件操作结构体
static struct file_operations fops = {
    .owner = THIS_MODULE,           // 模块的所有者
    .open = char_open,              // 设备打开操作
    .release = char_release,        // 设备关闭操作
    .write = char_write,            // 添加写操作
    .read = char_read,              // 设备读取操作
    .poll = char_poll,              // 设备轮询操作
};

// 模块初始化函数
static int __init char_init(void) {
    // 动态注册字符设备,并获取主设备号
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_number < 0) {
        printk(KERN_ALERT "Failed to register a major number\n"); // 打印错误信息
        return major_number; // 返回错误码
    }
    printk(KERN_INFO "记录成功注册的主设备号: %d\n", major_number); // 记录成功注册的信息

    // 创建设备类
    char_class = class_create( CLASS_NAME);
    if (IS_ERR(char_class)) {
        unregister_chrdev(major_number, DEVICE_NAME); // 卸载字符设备
        printk(KERN_ALERT "Failed to register device class\n"); // 打印错误信息
        return PTR_ERR(char_class); // 返回错误码
    }
    printk(KERN_INFO "设备类注册成功\n"); // 记录设备类注册成功

    // 创建设备节点
    char_device = device_create(char_class, NULL, MKDEV(major_number, 0), NULL, DEVICE_NAME);
    if (IS_ERR(char_device)) {
        class_destroy(char_class); // 销毁设备类
        unregister_chrdev(major_number, DEVICE_NAME); // 卸载字符设备
        printk(KERN_ALERT "Failed to create the device\n"); // 打印错误信息
        return PTR_ERR(char_device); // 返回错误码
    }
    printk(KERN_INFO "设备节点创建成功\n"); // 记录设备节点创建成功

    // 初始化字符设备
    cdev_init(&cdev, &fops);
    cdev_add(&cdev, MKDEV(major_number, 0), 1); // 向内核注册字符设备

    init_waitqueue_head(&read_wait); // 初始化等待队列头
    printk(KERN_INFO "驱动初始化成功\n"); // 打印初始化成功信息
    return 0; // 返回成功
}

// 模块退出函数
static void __exit char_exit(void) {
    cdev_del(&cdev); // 删除字符设备
    device_destroy(char_class, MKDEV(major_number, 0)); // 销毁设备节点
    class_unregister(char_class); // 注销设备类
    class_destroy(char_class); // 销毁设备类
    unregister_chrdev(major_number, DEVICE_NAME); // 卸载字符设备
    printk(KERN_INFO "驱动卸载成功\n"); // 打印卸载成功信息
}

// 模块初始化和退出注册
module_init(char_init); // 注册初始化函数
module_exit(char_exit); // 注册退出函数

MODULE_LICENSE("GPL"); // 指定模块许可证
MODULE_AUTHOR("gopher"); // 指定模块作者
MODULE_DESCRIPTION("A simple character device driver with epoll support"); // 模块描述
MODULE_VERSION("1.0"); // 模块版本

测试

测试程序说明

线程创建:
程序创建了多个线程(NUM_THREADS),每个线程负责向设备写入数据。

写入操作:
每个线程会循环执行写入操作(NUM_WRITES次),每次写入一条消息到设备。

延迟模拟:
在每次写入后,线程会休眠一小段时间(usleep(1000)),以模拟实际应用中的延迟。

线程同步:
主线程会等待所有子线程完成后再结束程序。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>

#define DEVICE_PATH "/dev/epoll_example" // 设备路径
#define NUM_THREADS 10 // 定义线程数量
#define NUM_WRITES 100 // 每个线程写入的次数

// 线程函数,向设备写数据
void *write_to_device(void *threadid) {
    long tid = (long)threadid; // 获取线程ID
    int fd = open(DEVICE_PATH, O_WRONLY); // 打开字符设备
    if (fd == -1) {
        perror("打开设备失败"); // 打印打开设备失败的信息
        pthread_exit(NULL); // 退出线程
    }

    char message[256]; // 用于存储写入信息的缓冲区
    for (int i = 0; i < NUM_WRITES; i++) {
        // 格式化写入消息
        snprintf(message, sizeof(message), "线程 %ld: 写入 %d\n", tid, i);
        ssize_t bytes_written = write(fd, message, strlen(message)); // 向设备写数据
        if (bytes_written < 0) {
            perror("写入设备失败"); // 打印写入设备失败的信息
        } else {
            printf("线程 %ld 写入: %s", tid, message); // 输出已写入的消息
        }
        usleep(1000); // 模拟一些延迟
    }

    close(fd); // 关闭设备
    pthread_exit(NULL); // 退出线程
}

int main() {
    pthread_t threads[NUM_THREADS]; // 创建线程数组
    int rc; // 返回结果变量
    long t; // 线程计数器

    // 创建多个线程
    for (t = 0; t < NUM_THREADS; t++) {
        printf("正在创建线程 %ld\n", t); // 输出创建线程的消息
        rc = pthread_create(&threads[t], NULL, write_to_device, (void *)t); // 创建线程
        if (rc) {
            printf("错误: pthread_create() 返回代码是 %d\n", rc); // 输出错误信息
            exit(-1); // 退出程序
        }
    }

    // 等待所有线程完成
    for (t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL); // 等待线程结束
    }

    printf("所有线程已完成。\n"); // 输出所有线程完成的信息
    return 0; // 返回 0 表示成功
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>

#define DEVICE_PATH "/dev/epoll_example" // 设备路径
#define NUM_THREADS 100   // 定义线程数量
#define NUM_WRITES 1000   // 每个线程写入的次数

void *write_to_device(void *threadid) {
    long tid = (long)threadid;
    int fd = open(DEVICE_PATH, O_WRONLY);
    if (fd == -1) {
        perror("Failed to open device");
        pthread_exit(NULL);
    }

    char message[256];
    for (int i = 0; i < NUM_WRITES; i++) {
        snprintf(message, sizeof(message), "线程 %ld: 写入 %d\n", tid, i + 1);
        write(fd, message, strlen(message)); // 写入设备
    }

    close(fd);
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS]; // 创建线程数组
    int rc;
    struct timeval start, end;

    gettimeofday(&start, NULL); // 记录开始时间

    // 创建多个线程
    for (long t = 0; t < NUM_THREADS; t++) {
        rc = pthread_create(&threads[t], NULL, write_to_device, (void *)t);
        if (rc) {
            printf("Error: pthread_create() return code is %d\n", rc);
            exit(-1);
        }
    }

    // 等待所有线程完成
    for (int t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL);
    }

    gettimeofday(&end, NULL); // 记录结束时间
    long seconds = end.tv_sec - start.tv_sec; // 计算耗时
    long microseconds = end.tv_usec - start.tv_usec;
    long elapsed = seconds * 1000000 + microseconds; // 总耗时微秒

    printf("所有线程已完成。总耗时: %ld 微秒\n", elapsed);
    return 0;
}

标签:include,lock,写入,char,线程,linux,static,poll,设备
From: https://blog.csdn.net/gopher9511/article/details/142317112

相关文章

  • linux驱动开发-内核异步通知
    驱动/内核异步通知在Linux驱动程序中,异步通知机制允许内核模块在特定事件发生时主动通知用户空间进程。这样的设计通常用于管理输入输出操作,确保用户程序可以及时获得数据或状态变化而无需频繁查询设备状态。在Linux驱动中,常见的异步通知机制主要有以下几种:信号(Sign......
  • linux用户管理基本命令
    目录禁止非root用户连接配置文件/etc/group/etc/gshadow/etc/passwd/etc/shadow用户组管理groupaddgroupmodgroupdel用户管理useraddusermoduserdelpasswd主要组和附属组gpasswdnewgrpsuidgroups禁止非root用户连接在etc目录下创建nologin的空文件即可touch/etc/nologin配置......
  • 【Linux 20】线程控制
    文章目录......
  • Linux基础命令
    一、嵌入式、Linux背景嵌入式:硬件与软件相结合定制、为硬件设计相关代码来进行操作,代码测试,烧进板子,通过语音、图像、按钮等操作方式来调用。操作系统种类:DosWindowsUnixMacChmod osAndroid->华为、小米、中兴等等iOS介绍一下Linux:结构:一棵倒置的树/bin   ......
  • Linux系统与服务构建运维
    使用ext4文件系统格式化逻辑卷mylv。命令如下:一、Linux操作系统安装1.学习目标(1)了解服务器操作系统安装。(2)了解CentOS系统的安装。2.节点规划IP主机名节点192.168.200.10localhostLinux服务器节点3.基础准备使用本地PC环境的VMWareWorkstation软件进行实......
  • Linux实用操作
    文章目录Linux实用操作各种实用小技巧软件安装systemctl软链接日期和时区日期时区ntpIP和主机名ip地址主机名配置VMware固定IP进程ps命令kill命令端口nmap命令netstat命令网络请求和下载ping命令wget命令curl命令主机状态监控top命令df命令iostat命令sar命令环境变......
  • Centos7完美平替,Almalinux系统(低配版)安装oracle
            目前Centos7官网已停止维护,其官方下载源不能使用,在经过网上各类教程的洗礼之后,我放弃了给它更换国内的下载源(换完了也不行(小声bb))。于是我想到了是否可以找一个可以兼容Centos7的平替系统,即Almalinux。    本文主要介绍在低配版Almalinux8.9系统(如云服......
  • QEMU on Linux hosts(By frp)
    Invocation—QEMUdocumentationHosts/Linux-QEMU关键字:QEMU、Tips:由于是使用反向代理frp 内网穿透在无图形界面的Ubuntu24.04LTS主机,通过ssh安装QEMU,频繁出现掉线问题,所以使用Screenapt-getinstallscreenroot@atc:~#screen-vScreenversion4.09.01(GNU)20-Au......
  • 【Linux进程】Linux Shell编程实战:构建简易脚本示例与技巧详解
    ......
  • 初学Linux笔记
    对linux系统中目录的解释:/bin:bin是Binary的缩写,这个目录存放着最经常使用的命令。/boot:这里存放的是启动Linux时使用的一些核心文件,包括一些连接文件以及镜像文件。/dev:dev是Device(设备)的缩写,存放的是Linux的外部设备,在Linux中访问设备的方式和访问文件的方式是相同的。/e......