linux的IO 多路复用（高级字符设备三）

最新推荐文章于 2024-06-13 20:44:24 发布

温人之周.

最新推荐文章于 2024-06-13 20:44:24 发布

阅读量128

点赞数

分类专栏： RK3568 linux驱动开发笔记（迅为）文章标签： linux

本文链接：https://blog.csdn.net/xxxx123041/article/details/134033565

版权

RK3568 linux驱动开发笔记（迅为）专栏收录该内容

22 篇文章 6 订阅

订阅专栏

一、linux的IO 多路复用介绍

IO 多路复用是一种同步的 IO 模型。IO 多路复用可以实现一个进程监视多个文件描述符。一旦某个文件描述符准备就绪，就通知应用程序进行相应的读写操作。没有文件描述符就绪时就会阻塞应用程序，从而释放出 CPU 资源。
在应用层 Linux 提供了三种实现 IO 多路复用的模型，分别是select、poll 和epoll。poll 函数和select 函数都可以监听多个文件描述符，通过轮询来获取已经准备好的文件描述符。但是epoll 函数将主动轮询变成了被动通知，当事件发生时被动接收通知。在单个线程中，select 函数最大可以监视1024 个文件描述符，而 poll 函数和 select 函数并没有什么区别，只是 poll 函数没有最大文件描述符的限制。

1.1、应用层的poll 函数

在 Linux 应用程序中poll 函数如下所示：

int poll(struct pollfd *fds, nfds_t nfds,int timeout);

第一个参数 fds: 要监视的文件描述符集合以及要监视的事件，为一个数组，数组元素都是结构体 pollfd 类型，pollfd 结构体如下所示：

struct pollfd 
{
	int fd; //被监视的文件描述符
	short events; //等待的事件
	short revents; //实际发生的事件
}；

在 pollfd 结构体中，第一个成员 fd 是被监视的文件描述符。第二个成员events 是要监视的事件，可监视的事件类型如下所示：

POLLIN 有数据可以读取
POLLPRI 有紧急的数据需要读取
POLLOUT 可以写数据
POLLERR 指定的文件描述符发生错误
POLLHUP 指定的文件描述符挂起
POLLNVAL 无效的请求
POLLRDNORM 等同于 POLLIN

第三个成员是返回事件，由 Linux 内核设置具体的返回事件。
第二个参数 nfds: poll 函数要监视的文件描述符数量
第三个参数 timeout:指定等待的时间，单位是 ms。无论I/O 是否准备好，时间到POLL就会返回。如果 timepoll 大于 0 等待指定的时间，如果 timeout 等于0，立即返回。如果timeout等于-1，事件发生以后才返回。

1.2、驱动层的poll 函数

当应用程序使用 select 或者 poll 函数对驱动程序进行非阻塞访问时，驱动程序中file_operations 操作集的 poll 函数会执行。所以需要完善驱动中的poll 函数。驱动中的poll 函数原型如下所示：

unsigned int (*poll)(struct file *filp,struct poll_table_struct *wait);

函数参数：
filp:要打开的文件描述符
wait: 结构体 poll_table_struct 类型指针，此参数是由应用程序中传递的。一般此参数要传递给 poll_wait 函数。
返回值：
向应用程序返回资源状态，可以返回的资源状态如下：
POLLIN 有数据可以读取
POLLPRI 有紧急的数据需要读取
POLLOUT 可以写数据
POLLERR 指定的文件描述符发生错误
POLLHUP 指定的文件描述符挂起
POLLNVAL 无效的请求
POLLRDNORM 等同于 POLLIN，普通数据可读。
函数功能：
这个函数要进行下面两项工作。首先，对可能引起设备文件状态变化的等待队列调用poll_wait(),将对应的等待队列头添加到 poll_table.然后返回表示是否能对设备进行无阻塞读写访问的掩码。
驱动程序的 poll 函数中调用 poll_wait 函数，注意！poll_wait 函数是不会引起阻塞的。poll_wait 函数原型如下所示：

void poll_wait(struct file *filp,wait_queue_head_t *queue,poll_table *wait);

参数 queue 是要添加到 poll_table 中的等待队列头，参数wait 是poll_table，也就是file_operations 中 poll 函数的 wait 参数。

二、代码示例

2.1、应用层程序

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <poll.h>

int main(int argc, char *argv[])  
{
    int fd;//要监视的文件描述符
    char buf1[32] = {0};   
    char buf2[32] = {0};
    struct pollfd  fds[1];
    int ret;
    fd = open("/dev/test", O_RDWR);  //打开/dev/test设备，阻塞式访问
    if (fd < 0)
    {
        perror("open error \n");
        return fd;
    }
    fds[0] .fd =fd;
    fds[0].events = POLLIN;
    printf("read before \n");
    while (1)
    {
        ret = poll(fds,1,3000);
        if(!ret)
        {
            printf("time out !!\n");
        }else if(fds[0].revents == POLLIN)
        {
            read(fd,buf1,sizeof(buf1));  //从/dev/test文件读取数据
            printf("buf is %s \n",buf1);
            sleep(1);
        }
    }
    printf("read after\n");
    close(fd);     //关闭文件
    return 0;
}

2.2、驱动层程序

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include  <linux/wait.h>
#include <linux/poll.h>

struct device_test{
   
    dev_t dev_num;  //设备号
     int major ;  //主设备号
    int minor ;  //次设备号
    struct cdev cdev_test; // cdev
    struct class *class;   //类
    struct device *device; //设备
    char kbuf[32];
    int  flag;  //标志位
};


struct  device_test dev1;  

DECLARE_WAIT_QUEUE_HEAD(read_wq); //定义并初始化等待队列头

/*打开设备函数*/
static int cdev_test_open(struct inode *inode, struct file *file)
{
    file->private_data=&dev1;//设置私有数据
   
    return 0;
}

/*向设备写入数据函数*/
static ssize_t cdev_test_write(struct file *file, const char __user *buf, size_t size, loff_t *off)
{
     struct device_test *test_dev=(struct device_test *)file->private_data;

    if (copy_from_user(test_dev->kbuf, buf, size) != 0) // copy_from_user:用户空间向内核空间传数据
    {
        printk("copy_from_user error\r\n");
        return -1;
    }
    test_dev->flag=1;
    wake_up_interruptible(&read_wq);

    return 0;
}

/**从设备读取数据*/
static ssize_t cdev_test_read(struct file *file, char __user *buf, size_t size, loff_t *off)
{
    
    struct device_test *test_dev=(struct device_test *)file->private_data;
    if(file->f_flags & O_NONBLOCK ){
        if (test_dev->flag !=1)
        return -EAGAIN;
    }
    wait_event_interruptible(read_wq,test_dev->flag);

    if (copy_to_user(buf, test_dev->kbuf, strlen( test_dev->kbuf)) != 0) // copy_to_user:内核空间向用户空间传数据
    {
        printk("copy_to_user error\r\n");
        return -1;
    }

    return 0;
}

static int cdev_test_release(struct inode *inode, struct file *file)
{
    
    return 0;
}

static  __poll_t  cdev_test_poll(struct file *file, struct poll_table_struct *p){
     struct device_test *test_dev=(struct device_test *)file->private_data;  //设置私有数据
     __poll_t mask=0;    
     poll_wait(file,&read_wq,p);     //应用阻塞

     if (test_dev->flag == 1)    
     {
         mask |= POLLIN;
     }
     return mask;
     
}

/*设备操作函数*/
struct file_operations cdev_test_fops = {
    .owner = THIS_MODULE, //将owner字段指向本模块，可以避免在模块的操作正在被使用时卸载该模块
    .open = cdev_test_open, //将open字段指向chrdev_open(...)函数
    .read = cdev_test_read, //将open字段指向chrdev_read(...)函数
    .write = cdev_test_write, //将open字段指向chrdev_write(...)函数
    .release = cdev_test_release, //将open字段指向chrdev_release(...)函数
    .poll = cdev_test_poll,  //将poll字段指向chrdev_poll(...)函数
};

static int __init chr_fops_init(void) //驱动入口函数
{
    /*注册字符设备驱动*/
    int ret;
    /*1 创建设备号*/
    ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "alloc_name"); //动态分配设备号
    if (ret < 0)
    {
       goto err_chrdev;
    }
    printk("alloc_chrdev_region is ok\n");

    dev1.major = MAJOR(dev1.dev_num); //获取主设备号
   dev1.minor = MINOR(dev1.dev_num); //获取次设备号

    printk("major is %d \r\n", dev1.major); //打印主设备号
    printk("minor is %d \r\n", dev1.minor); //打印次设备号
     /*2 初始化cdev*/
    dev1.cdev_test.owner = THIS_MODULE;
    cdev_init(&dev1.cdev_test, &cdev_test_fops);

    /*3 添加一个cdev,完成字符设备注册到内核*/
   ret =  cdev_add(&dev1.cdev_test, dev1.dev_num, 1);
    if(ret<0)
    {
        goto  err_chr_add;
    }
    /*4 创建类*/
  dev1. class = class_create(THIS_MODULE, "test");
    if(IS_ERR(dev1.class))
    {
        ret=PTR_ERR(dev1.class);
        goto err_class_create;
    }
    /*5  创建设备*/
  dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "test");
    if(IS_ERR(dev1.device))
    {
        ret=PTR_ERR(dev1.device);
        goto err_device_create;
    }

return 0;

 err_device_create:
        class_destroy(dev1.class);                 //删除类

err_class_create:
       cdev_del(&dev1.cdev_test);                 //删除cdev

err_chr_add:
        unregister_chrdev_region(dev1.dev_num, 1); //注销设备号

err_chrdev:
        return ret;
}
static void __exit chr_fops_exit(void) //驱动出口函数
{
    /*注销字符设备*/
    unregister_chrdev_region(dev1.dev_num, 1); //注销设备号
    cdev_del(&dev1.cdev_test);                 //删除cdev
    device_destroy(dev1.class, dev1.dev_num);       //删除设备
    class_destroy(dev1.class);                 //删除类
}
module_init(chr_fops_init);
module_exit(chr_fops_exit);

2.3、linux的IO 多路复用使用API要点

应用层

struct pollfd  fds[1];
fds[0] .fd =fd;
fds[0].events = POLLIN;
ret = poll(fds,1,3000);

驱动层

static  __poll_t  cdev_test_poll(struct file *file, struct poll_table_struct *p)
{
     struct device_test *test_dev=(struct device_test *)file->private_data;  //设置私有数据
     __poll_t mask=0;    
     poll_wait(file,&read_wq,p);     //应用阻塞

     if (test_dev->flag == 1)    
     {
         mask |= POLLIN;
     }
     return mask;
     
}