2022-12-29 驱动-IO多路复用

IO多路复用的原理：
1>select和poll原理：将文件描述符添加到集合中，监测是否有准备就绪的文件描述符，将未准备就绪的文件描述符剔除集合，准备就绪的文件描述符实现相关操作

2>对于epoll函数原理：创建树的根节点，将文件描述符添加到根节点为epfd的二叉树中，若有准备好的文件描述符，将其摘下放入集合中，实现相关的操作

select为例：在用户层创建一个集合存放要监测的文件描述符，然后通过调用select()函数等待事件发生。若事件发生，读取用户空间的数据。
在内核和用户层之间有一个虚拟文件系统层，当用户层调用select函数后，虚拟文件系统层会调用sys_select()函数，在该函数中实现的功能：
(1)在内核申请一块内存，用来保存用户表，通过copy_from_user将用户表从用户空间拷贝到这块内存
(2)从表中获取文件描述符fd->fd_arry[fd]->struct file->f_op指针->poll()函数
mask=poll(),接收poll()的返回值，对返回值进行判断
mask为0，数据没有准备好；mask不等于0为POLLIN/POLLOUT
(3)如果fd_set表的所有文件描述符对应的poll()返回值都为0,的话，进程进入可中断的休眠状态
(4)在虚拟文件系统层收到一个或多个硬件的唤醒条件后，再次遍历文件描述符，找到准备好的文件描述符，拷贝到用户空间
内核层：poll函数提交等待队列头，被唤醒就返回POLLIN

//mycdev.c
#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/uaccess.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/device.h>
#include<linux/poll.h>

//定义字符设备驱动结构体对象指针
struct cdev* cdev;
char kbuf[128]={0};
dev_t devno;//设备号
unsigned int minor=0;//次设备号
int count=3;//设备数量
struct class* cls;//指向设备目录的指针
struct device* dev;//指向设备节点的指针
#if 1
unsigned int major=0;//进行动态申请设备号
#else
unsigned int major=500;//进行静态指定设备号
#endif

//定义等待对列头
wait_queue_head_t wq_head;
unsigned int condition=0;

int mycdev_open(struct inode *inode,struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file,char __user *ubuf,size_t size,loff_t *off)
{
	int ret;
	//先判断size的大小是否大于内核kbuf的大小，如果比kbuf大，把size的数据修改为kbuf的大小
	if(size>sizeof(kbuf))
		size=sizeof(kbuf);
	//将kbuf的数据拷贝给用户空间
	ret=copy_to_user(ubuf,kbuf,size);
	if(ret)
	{
		printk("copy_to_user failed\n");
		return -EIO;
	}
	condition=0;
	return 0;
}
ssize_t mycdev_write(struct file *file,const char __user *ubuf,size_t size,loff_t *off)
{
    int ret;// 定义变量接收函数返回值
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //先判断size的大小是否大于内核kbuf的大小，如果比kbuf大，把size的数据修改为kbuf的大小
    if(size>sizeof(kbuf))
        size=sizeof(kbuf);
    //从用户空间拷贝数据到内核
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("copy_from_user failed\n");
        return -EIO;
    }
	//唤醒进程1
	condition=1;
	wake_up_interruptible(&wq_head);
    return 0;
}
__poll_t mycdev_poll(struct file* file,struct poll_table_struct* wait)
{
	__poll_t mask=0;
	//向上提交等待队列头
	poll_wait(file,&wq_head,wait);
	if(condition)
	{
		mask|=POLLIN;
	}
	return mask;
}
 int mycdev_close(struct inode *inode,struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
//定义操作方法结构体
struct file_operations fops =
{
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
	.poll=mycdev_poll,
};

 static int __init mycdev_init(void)
{
	int ret,i;
	//给字符设备驱动对象申请空间
	cdev=cdev_alloc();
	if(cdev==NULL)
	{
		printk("给字符设备驱动对象申请空间失败\n");
		ret=-ENOMEM;
		goto ERR1;
	}
	printk("给字符设备驱动对象申请空间成功\n");
	//对象的初始化
	cdev_init(cdev,&fops);
	//申请设备号
	if(major==0)//动态申请
	{
		ret=alloc_chrdev_region(&devno,minor,count,"mycdev");
		if(ret)
		{
			printk("动态指定设备号失败\n");
			goto ERR2;
		}
		//获取主设备号的次设备号
		major=MAJOR(devno);//获取主设备号
		minor=MINOR(devno);//获取次设备号
	}
	else if(major>0)
	{
		ret=register_chrdev_region(MKDEV(major,minor),count,"mycdev");
		if(ret)
		{
			printk("静态指定设备号失败\n");
			goto ERR2;
		}
	}
	printk("设备号申请成功\n");
	//将字符设备驱动注册进内核
	ret=cdev_add(cdev,MKDEV(major,minor),count);
	if(ret)
	{
		printk("字符设备驱动注册失败\n");
		goto ERR3;
	}
	//自动创建设备节点
	//向上提交目录
	cls=class_create(THIS_MODULE,"mycdev");
	if(IS_ERR(cls))
	{
		printk("向上提交目录失败\n");
		ret=PTR_ERR(cls);
		goto ERR4;
	}
	printk("向上提交目录成功\n");
	//向上提交设备节点
	for(i=0;i<count;i++)
	{
		dev=device_create(cls,NULL,MKDEV(major,i),NULL,"mycdev%d",i);
		if(IS_ERR(dev))
		{
			printk("向上提交节点信息失败\n");
			ret=PTR_ERR(dev);
			goto ERR5;
		}
	}
	printk("向上提交节点信息成功\n");

	//初始化等待队列头
	init_waitqueue_head(&wq_head);
	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 mycdev_exit(void)
{
	//销毁设备节点
	int i;
	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(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

//select-test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/time.h>
int main(int argc, const char *argv[])
{
	char buf[128]={0};
	int ret;
	int fd1=open("/dev/mycdev0",O_RDWR);
	if(fd1<0)
	{
		printf("open err\n");
		exit(-1);
	}
	int fd2=open("/dev/input/mouse0",O_RDWR);
	if(fd2<0)
	{
		printf("open err\n");
		exit(-1);
	}
	fd_set rfds;
	while(1)
	{
		//清空集合
		FD_ZERO(&rfds);
		//将文件描述符添加到集合
		FD_SET(fd1,&rfds);
		FD_SET(fd2,&rfds);
		//等待事件
		ret=select(fd2+1,&rfds,NULL,NULL,NULL);
		if(ret<0)
		{
			printf("select err\n");
		}
		if(FD_ISSET(fd1,&rfds))
		{
			read(fd1,buf,sizeof(buf));
			printf("mycdev:%s\n",buf);
		}
		if(FD_ISSET(fd2,&rfds))
		{
			read(fd2,buf,sizeof(buf));
			printf("mouse:%s\n",buf);
		}

	}
	return 0;
}

//1.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, const char *argv[])
{
	char buf[128]="hello";
	int fd=open("/dev/mycdev0",O_RDWR);
	if(fd<0)
	{
		printf("open err\n");
		exit(-1);
	}
	write(fd,buf,sizeof(buf));
	close(fd);
	return 0;
}

//epoll-test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/epoll.h>
int main(int argc, const char *argv[])
{
	char buf[128]={0};
	int ret,epfd,i;
	struct epoll_event event;
	struct epoll_event events[10];
	int fd1=open("/dev/mycdev0",O_RDWR);
	if(fd1<0)
	{
		printf("open err\n");
		exit(-1);
	}
	int fd2=open("/dev/input/mouse0",O_RDWR);
	if(fd2<0)
	{
		printf("open err\n");
		exit(-1);
	}
	//创建epoll
	epfd=epoll_create(10);
	if(epfd<0)
	{
		printf("epoll_create err\n");
		exit(-1);
	}
	//将文件描述符挂到epfd为根节点的树上
	event.events=EPOLLIN;
	event.data.fd=fd1;
	if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd1,&event)<0)
	{
		printf("epoll_ctl err\n");
		exit(-1);
	}
	event.events=EPOLLIN;
	event.data.fd=fd2;
	if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd2,&event)<0)
	{
		printf("epoll_ctl err\n");
		exit(-1);
	}
	while(1)
	{
		ret=epoll_wait(epfd,events,10,-1);
		if(ret<0)
		{
			printf("epoll_wait err\n");
			exit(-1);
		}
		for(i=0;i<ret;i++)
		{
			if(events[i].events&EPOLLIN)
			{
				read(events[i].data.fd,buf,sizeof(buf));
				printf("buf:%s\n",buf);
			}
		}
	}
	close(fd1);
	close(fd2);
	close(epfd);
	return 0;
}

 结果：