【Linux】内核驱动篇四--IO模型

---

---

一、五种IO模型------读写外设数据的方式

1. 阻塞: 不能操作就睡觉
   
2. 非阻塞：不能操作就返回错误
   
3. 多路复用：委托中介监控
   
4. 信号驱动：让内核如果能操作时发信号，在信号处理函数中操作
   
5. 异步IO：向内核注册操作请求，内核完成操作后发通知信号
   

---

二、阻塞与非阻塞

应用层：

1. open函数的条件O_NONBLOCK指示read、write时是否阻塞
2. open以后可以由fcntl函数来改变是否阻塞：

flags = fcntl(fd,F_GETFL,0);
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags);

驱动层：通过等待队列

wait_queue_head_t //等待队列头数据类型

init_waitqueue_head(wait_queue_head_t *pwq) //初始化等待队列头
    
wait_event_interruptible(wq,condition)   浅度等待，信号可以唤醒
/*
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来
    wq:等待队列头
    condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）
*/
        
wait_event(wq,condition) //深度睡眠

wake_up_interruptible(wait_queue_head_t *pwq)  //浅度唤醒
        
wake_up(wait_queue_head_t *pwq)  //深度唤醒
    
    
/*
注：
1. 读、写用不同的等待队列头rq、wq
2. 无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)
3. 写入数据成功时唤醒rq，读出数据成功唤醒wq
*/

---

三、多路复用

描述符：

1. 文件描述符：设备文件、管道文件
2. socket描述符

3.1 应用层：三套接口select、poll、epoll

select：位运算实现 监控的描述符数量有限（32位机1024,64位机2048） 效率差

poll：链表实现，监控的描述符数量不限 效率差

epoll：效率最高，监控的描述符数量不限

三者使用驱动设备都会调用驱动代码内的poll函数

select使用模型:

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
/*	功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。
		内核将没有准备就绪的文件描述符，从集合中清掉了。
	参数：  nfds			最大文件描述符数 ，加1
			readfds		读文件描述符集合
			writefds		写文件描述符集合
			exceptfds		其他异常的文件描述符集合
			timeout		超时时间（NULL）
	返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1 
		   当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间 
*/
void FD_CLR(int fd, fd_set *set);
//功能：将fd 从集合中清除掉

int  FD_ISSET(int fd, fd_set *set);
//功能：判断fd 是否存在于集合中
 
void FD_SET(int fd, fd_set *set);
//功能：将fd 添加到集合中

void FD_ZERO(fd_set *set);
//功能：将集合清零

//使用模型:

while(1)
{
    /*得到最大的描述符maxfd*/
    /*FD_ZERO清空描述符集合*/
	/*将被监控描述符加到相应集合rfds里  FD_SET*/
    /*设置超时*/
    ret = select(maxfd+1,&rfds,&wfds,NULL,NULL);
    if(ret < 0)
    {
        if(errno == EINTR)//错误时信号引起的
        {
        	continue;   
        }
        else
        {
            break;
        }
    }
    else if(ret == 0)
    {//超时
        //.....
    }
    else
    { //> 0 ret为可被操作的描述符个数
        if(FD_ISSET(fd1,&rfds))
        {//读数据
            //....
        }
        if(FD_ISSET(fd2,&rfds))
        {//读数据
            //....
        }
        ///.....
        if(FD_ISSET(fd1,&wfds))
        {//写数据
            //....
        }
    }
}
   

3.2 驱动层：实现poll函数

poll_waith函数：

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
/*
  功能：将等待队列头添加至poll_table表中
  参数：
  struct file :设备文件
  Wait_queue_head_t :等待队列头
  Poll_table :poll_table表
*/

poll函数制造与使用模板：

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int xxx_poll(struct file *filp, poll_table *wait) //函数名初始化给struct file_operations的成员.poll
{
    unsigned int mask = 0;
    /*
    	1. 将所有等待队列头加入poll_table表中
    	2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
    	3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
    */
    return mask;
}

---

四、信号驱动

4.1 应用层：信号注册+fcntl

使用模板：

signal(SIGIO, input_handler); //注册信号处理函数

fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程，好由描述符获知PID

oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, oflags | FASYNC);//将该设备的IO模式设置成信号驱动模式

void input_handler(int signum)//应用自己实现的信号处理函数，在此函数中完成读写
{
    //读数据
}

//应用模板
int main()
{
	int fd = open("/dev/xxxx",O_RDONLY);

	fcntl(fd, F_SETOWN, getpid());

	oflags = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, oflags | FASYNC);

	signal(SIGIO,xxxx_handler);

	//......
}
    
void xxxx_handle(int signo)
{//读写数据
    
}

4.2 驱动层：实现fasync函数

制造与使用模板：

/*设备结构中添加如下成员*/
struct fasync_struct *pasync_obj;

/*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/
static int xxx_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync
{
	struct xxx_device *dev = filp->private_data; 
	return fasync_helper(fd, filp, mode, &dev->pasync_obj);
}

/*写函数中有数据可读时向应用层发信号*/
if(dev->pasync_obj)
       kill_fasync(&dev->pasync_obj, SIGIO, POLL_IN);
       
/*release函数中释放异步通知结构对象*/
if(dev->pasync_obj) 
	fasync_helper(-1, filp, 0, &dev->pasync_obj);

int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **pp);
/*
	功能：产生或释放异步通知结构对象
	参数：
	返回值：成功为>=0,失败负数
*/

void kill_fasync(struct fasync_struct **, int, int);
/*	
	功能：发信号
	参数：
		struct fasync_struct ** 指向保存异步通知结构地址的指针
		int 	信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP
		int 	读写信息POLLIN、POLLOUT
*/

---

实用例子：

/*************************************************************************
  > File Name: mytest1.c
  > Author: xiuchengzhen
  > CSDN: xiuchengzhen.blog.csdn.net
  > Created Time: Tue 10 May 2022 07:29:52 PM PDT
 ************************************************************************/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <asm/uaccess.h>

#include "mytest.h"

#define BUFSIZE 100 //模拟内核空间大小
int major = 11;   //主设备号
int minor = 0;    //次设备号
int dev_num = 1;  //设备数量

struct pdev 
{
	struct cdev mydev;     //设备结构体
	char dev_buf[BUFSIZE]; //模拟内核空间
	int buf_seek;          //内核空间储存值

	wait_queue_head_t dr;  //等待读队列
	wait_queue_head_t dw;  //等待写队列

	struct fasync_struct *pasync_obj;   //驱动信号对象
};

struct pdev pmydev;

int mydev_open(struct inode *pnode, struct file *pfile)	//打开设备
{
	pfile->private_data = (void *)(container_of(pnode->i_cdev,struct pdev,mydev)); //获取设备结构体地址

	return 0;
}

int mydev_release(struct inode *pnode, struct file *pfile)	//关闭设备
{
	struct pdev *gmydev = (struct pdev *)pfile->private_data;
	
	if(gmydev->pasync_obj != NULL) 
		fasync_helper(-1, pfile, 0, &gmydev->pasync_obj);
	return 0;
}

ssize_t mydev_read(struct file *pfile, char __user *user_buf, size_t user_size, loff_t *seek)	//读设备
{
	int size;   //读取的数据量
	int ret; 
	struct pdev *gmydev = (struct pdev *)pfile->private_data;

	printk("%s\n",__FUNCTION__);
	
	if(gmydev->buf_seek <= 0)
	{
		if(pfile->f_flags & O_NONBLOCK)  //判断是否为阻塞模式
		{
			printk("no data read!\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(gmydev->dr,gmydev->buf_seek>0);  //将信号加入等待队列
			if(ret)   //判断是否为信号唤醒
			{
				printk("sigal wake!\n");
				return -ERESTARTSYS;
			}
		}
	}

	
	printk("----------2-----------\n");
	if(user_size > gmydev->buf_seek)  //量定读取多少
	{
		size = gmydev->buf_seek;
	}
	else
	{
		size = user_size;
	}

	printk("----------3-----------\n");
	ret = copy_to_user(user_buf, gmydev->dev_buf, size);  //读取数据
	if(ret)
	{
		printk("copy_to_user1 fail!");
		return -1;
	}

	printk("----------4-----------\n");
	memcpy(gmydev->dev_buf, gmydev->dev_buf+size, gmydev->buf_seek-size);

	gmydev->buf_seek -= size;
	
	printk("----------5-----------\n");
	wake_up_interruptible(&gmydev->dw);   //唤醒写等待

	printk("----------6-----------\n");
	return size;
}

ssize_t mydev_write(struct file *pfile, const char __user *user_buf, size_t user_size, loff_t *seek)    //写设备
{
	int size;
	int ret;
	struct pdev *gmydev = (struct pdev *)pfile->private_data;

	
	if(gmydev->buf_seek >= BUFSIZE)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{
			printk("buf full!\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(gmydev->dw,gmydev->buf_seek < BUFSIZE);  //加入写等待队列
			if(ret)    //判断是否为信号唤醒
			{
				printk("sigal wake!\n");  
				return -ERESTARTSYS;
			}
		}
	}

	
	if(user_size > BUFSIZE-gmydev->buf_seek)     //量定写入多少
	{
		size = BUFSIZE-gmydev->buf_seek;
	}
	else
	{
		size = user_size;
	}

	ret = copy_from_user(gmydev->dev_buf+gmydev->buf_seek, user_buf, size); //写入数据
	if(ret)
	{
		printk("copy_from_user fail!\n");
		return -1;
	}

	gmydev->buf_seek += size;

	wake_up_interruptible(&gmydev->dr);  //唤醒等待读

	if(gmydev->pasync_obj != NULL)
		kill_fasync(&gmydev->pasync_obj, SIGIO, POLL_IN);  //向app发送读信号

	return size;
}

long mydev_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
	int __user *pret = (int *)arg;
	int maxlen = BUFSIZE;
	int ret;
	struct pdev *gmydev = (struct pdev *)pfile->private_data;

	switch(cmd)
	{
		case MYDEV_IOCTL_GET_MUTEX:
			ret = copy_to_user(pret, &maxlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user1 fail!\n");
				return -1;
			}
			break;
		case MYDEV_IOCTL_GET_SEEK:
			ret = copy_to_user(pret, &gmydev->buf_seek, sizeof(int));
			if(ret)
			{
				printk("copy_to_user2 fail!\n");
				return -1;
			}	
			break;
		default: 
			printk("cmd error!\n");
			return -1;
	}
	return 0;
}

unsigned int mydev_poll(struct file *pfile, poll_table *wait)
{
	struct pdev *gmydev = (struct pdev *)pfile->private_data;
	unsigned int mask = 0;

	poll_wait(pfile, &gmydev->dr, wait);   //将读等待与写等待加入表内
	poll_wait(pfile, &gmydev->dw, wait);

	if(gmydev->buf_seek > 0)   //判断是否可读
	{
		mask |= POLLIN | POLLRDNORM;
	}

	if(gmydev->buf_seek < BUFSIZE)   //判读是否可写
	{
		mask |= POLLOUT | POLLWRNORM;
	}

	return mask;
}

static int mydev_fasync(int fd, struct file *pfile, int mode) 
{
	struct pdev *gmydev = (struct pdev *)pfile->private_data;

	return fasync_helper(fd, pfile, mode, &gmydev->pasync_obj);  
}

struct file_operations fops ={
	.open = mydev_open,
	.release = mydev_release,
	.read = mydev_read,
	.write = mydev_write,
	.unlocked_ioctl = mydev_ioctl,
	.poll = mydev_poll,
	.fasync = mydev_fasync,
};

int __init mytest1_init(void)
{
	dev_t devno = MKDEV(major, minor);
	int ret = -1;

	/* 申请设备号 */
	if((ret = register_chrdev_region(devno, dev_num, "mytest1")) < 0)
	{
		ret = alloc_chrdev_region(&devno, minor, dev_num, "mytest1");
		if(ret < 0)
		{
			printk("alloc_chrdev_region fail!\n");
			return -1;
		}
		major = MAJOR(devno);
	}

	/* 设备初始化 */
	fops.owner = THIS_MODULE;
	cdev_init(&pmydev.mydev, &fops);
	pmydev.mydev.owner = THIS_MODULE;

	/* 设备添加 */
	cdev_add(&pmydev.mydev, devno, dev_num);

	/* 等待队列初始化 */
	init_waitqueue_head(&pmydev.dr); //初始化读等待队列头
	init_waitqueue_head(&pmydev.dw); //初始化写等待队列头

	return 0;
}

void __exit mytest1_exit(void)
{
	dev_t devno = MKDEV(major, minor);

	/* 注销设备 */
	cdev_del(&pmydev.mydev);

	/* 注销设备号 */
	unregister_chrdev_region(devno, dev_num);
}

MODULE_LICENSE("GPL");
module_init(mytest1_init);
module_exit(mytest1_exit);

---

到这里就结束啦！