一、工作原理
1.当一个app应用程序，如果像读取多个硬件中的数据，监听多个文件描述符，这时就要引入io多路服用机制
2.使用select/poll/epoll监听多个文件描述符
3.如果所有硬件数据（文件描述）没有准备好，进程进入休眠状态
4.如果有一个或者多个硬件数据（文件描述符）准备好。唤醒休眠进程
5.当进程被唤醒之后，在内核空间，读取到准备好的文件描述符
6.从准备好的文件描述符集合中，读取准备好的文件描述符
7.从文件描述符中读取数据
二、io模型
应用层：
fd1 = open("/dev/myled0",O_RDWR); // 打开设备文件/dev/myled0
fd2 = open("/dev/input/mouse0",O_RDWR); // 打开设备文件/dev/input/mouse0
fd_set rfds;
FD_ZERO(&rfds); //清空读表集合
FD_SET(fd1, &rfds); //将fd1放入读表集合中
FD_SET(fd2, &rfds); //将fd2放入读表集合中
select(fd2+1, &rfds, NULL,
NULL, NULL) //监听设备文件
{
if(FD_ISSET(fd1, &rfds)) //判断fd1文件描述符数据是否准备完成
{
read(fd1,buf,sizeof(buf)); //从fd1中读取数据
printf("buf = %s\n",buf);
}
if(FD_ISSET(fd2, &rfds)) //判断fd2文件描述符数据是否准备完成
{
read(fd2,buf,sizeof(buf)); //从fd2中读取数据
printf("buf = %s\n",buf);
}
}
------------------------------------------------------------------------
内核层：应用层select/poll/epoll对应底层poll函数
linux@ubuntu:~/linux-5.10.61$ grep ".poll = " * -nR
drivers/char/tpm/tpm-dev.c:66: .poll = tpm_common_poll,
drivers/char/tpm/tpm_vtpm_proxy.c:249: .poll = vtpm_proxy_fops_poll,
drivers/char/tpm/tpmrm-dev.c:53: .poll = tpm_common_poll,
drivers/char/hpet.c:716: .poll = hpet_poll,
追踪：ctrl + ] 返回上一层：cttl + t
__poll_t myled_poll(struct file *file, struct poll_table_struct *wait)
{
//1.定义mask返回值
//2.调用poll_wait函数
//3.判断数据是否可读
//4.返回mask
}
------------------------------------------------------------------------
硬件层：
/dev/myled0 /dev/input/mouse0
三、编写代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/poll.h>
#define CNAME "myled"
struct cdev *cdev;
char kbuf[128] = {};
#if 0
unsigned int major = 500; //静态指定设备号
#else
unsigned int major = 0; //动态分配设备号
#endif
unsigned int count = 3;
unsigned int minor = 0;
struct class* cls;
struct device* device;
wait_queue_head_t wq; //定义等待队列头
int condition = 0;
int myled_open(struct inode *inode, struct file *file)
{
printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
return 0;
}
ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
int ret;
printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
if(file->f_flags & O_NONBLOCK) //以非阻塞方式打开
{
printk("O_NONBLOCK\n");
return -EIO;
}
else //以阻塞方式打开
{
ret = wait_event_interruptible(wq,condition); //让进程进入可中断等待态
if(ret)
{
printk("signal\n");
return -EIO;
}
}
//如果用户空间想读的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间读的大小
if(size > sizeof(kbuf)) size = sizeof(kbuf);
ret = copy_to_user(ubuf,kbuf,size); //将内核空间的数据，写入到用户空间
if(ret){
printk("copy to user is error\n");
return -EIO;
}
condition = 0; //！！！！condition一直都为真，一直数据都可以读！！！！！！！！
return size;
}
ssize_t myled_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
int ret;
printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
//如果用户空间想写的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间写的大小
if(size > sizeof(kbuf)) size = sizeof(kbuf);
ret = copy_from_user(kbuf,ubuf,size); //将用户空间的数据，写入到内核空间
if(ret){
printk("copy from user is error\n");
return -EIO;
}
condition = 1; //表示数据准备好
wake_up_interruptible(&wq);//唤醒可中断等待态
return size;
}
int myled_close(struct inode *inode, struct file *file)
{
printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
return 0;
}
__poll_t myled_poll(struct file *file, struct poll_table_struct *wait)
{
//定义mask返回值
__poll_t mask = 0;
//调用poll_wait函数
poll_wait(file,&wq,wait);
//判断数据是否可以读
if(condition)
{
mask |= POLL_IN; //表示数据可读
}
//返回mask值
return mask;
}
//操作方法结构体
const struct file_operations fops = {
.open = myled_open,
.read = myled_read,
.write = myled_write,
.poll = myled_poll,
.release = myled_close,
};
//入口
static int __init demo_init(void)
{
int ret;
dev_t devno;
int i = 0;
//分配对象
cdev = cdev_alloc();
if(cdev == NULL){
printk("cdev alloc is error\n");
ret = -EIO;
goto ERR1;
}
//对象初始化
cdev_init(cdev,&fops);
if(major > 0)
{
//静态指定设备号
ret = register_chrdev_region(MKDEV(major,minor), count, CNAME);
if(ret){
printk("register chrdev region is error\n");
ret = -EIO;
goto ERR2;
}
}else{ //动态指定设备号
ret = alloc_chrdev_region(&devno, 0, count,CNAME);
if(ret){
printk("alloc chrdev region is error\n");
ret = -EIO;
goto ERR2;
}
major = MAJOR(devno);//根据设备号，获取主设备号的值
minor = MINOR(devno);//根据设备号，获取次设备号的值
}
//对象注册
ret = cdev_add(cdev,MKDEV(major,minor),count);
if(ret){
printk("dev add is error\n");
ret = -EIO;
goto ERR3;
}
//三盏灯，自动创建三个设备节点 /dev/myled0 /dev/myled1 /dev/myled2
cls = class_create(THIS_MODULE, CNAME); //向上层提交目录信息
if(IS_ERR(cls))
{
printk("class create is error\n");
ret = EIO;
goto ERR4;
}
for(i=0;i<count;i++) //向上层提交设备节点信息
{
device = device_create(cls, NULL, MKDEV(major,i),NULL, "myled%d", i);
if(IS_ERR(device))
{
printk("device create is error\n");
ret = EIO;
goto ERR5;
}
}
init_waitqueue_head(&wq); //初始化等待队列头
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 demo_exit(void)
{
int i = 0;
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(demo_init); //指定入口地址
module_exit(demo_exit); //指定出口地址
MODULE_LICENSE("GPL");//许可证四、io多路复用内部工作原理
4.1对应关系
应用层select函数调用底层所有的poll函数
在内核层调用poll_wait函数，当数据没有准备好的时候，poll_wait函数是否完成休眠：
poll_wait函数没有完成休眠如果休眠所有逻辑就不对了
在虚拟文件系统层完成休眠
4.2虚拟文件系统层工作原理
标签：__,file,多路复用,0726,ret,描述符,io,poll,struct From： https://blog.csdn.net/slander_1120/article/details/1407398831.将用户空间文件描述符集合，拷贝到内核空间
2.校验文件描述符最大值
3.遍历文件描述符
a.fd==》fd_array[fd]==>struct file *==>file_operations==>poll
b.mask = poll_wait(file,wait)
1.如果mask的返回值为0，表示数据没有准备好
2.如果mask返回值为1，表示数据准备好，如果数据可读，返回POLL_IN
c.如果所有的mask返回值都为0，表示所有的硬件数据都没有准备好，进程进入休眠状态
d.当所有的硬件数据准备好，mask的返回值为1，表示硬件的数据准备好，唤醒休眠的进程
e.当进程唤醒之后，再次遍历文件描述符集合，找到mask返回值部位0，表示数据准备好
f.将准备好的文件描述符，拷贝到准备好的文件描述符集合中
g.将准备好的文件描述符集合，拷贝到用户空间