lv14 多路复用及信号驱动 8

本文主要是介绍lv14 多路复用及信号驱动 8，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1 多路复用

描述符：

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

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

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

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

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

select

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
/*  功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。内核将没有准备就绪的文件描述符，从集合中清掉了。参数：  nfds           最大文件描述符数 ，加1readfds     读文件描述符集合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)){//写数据//....}}
}

1.2 驱动层：实现poll函数

驱动函数XXX_POLL，其实也是帮我进行监控的

我们需要告诉设备什么情况是数据可读，什么情况是有可写入数据

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表
*/

/*该函数与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;
}

1.3 驱动示例：

mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>#include "mychar.h"#define BUF_LEN 100#define MYCHAR_DEV_CNT 3int major = 11;
int minor = 0;
int mychar_num  = MYCHAR_DEV_CNT;//新建结构体类型
struct mychar_dev
{struct cdev mydev;char mydef_buf[BUF_LEN];  //相当于结构体的私有变量int curlen;          //相当于结构体的私有变量wait_queue_head_t rq; //等待读队列wait_queue_head_t wq; //等待写队列};struct mychar_dev gmydev;int mychar_open(struct inode *pnode, struct file *pfile)
{//利用private_data私有变量来指向全局变量结构体地址pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));printk("mychar_open is called\n");return 0;
}int mychar_close(struct inode *pnode, struct file *pfile)
{printk("mychar_close is called\n");return 0;
}ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{int ret = 0;int size = 0;//获取全家变量结构体地址struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;if(pmydev->curlen <= 0){if(filp->f_flags & O_NONBLOCK){//非阻塞printk("O_NONBLOCK No Data Read\n");return -1;}else{//阻塞ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);if(ret){printk("Wake up by signal\n");return -ERESTARTSYS;}}}if(count > pmydev->curlen){size = pmydev->curlen;}else{size = count;}//将内核空间中的数据复制到用户空间ret = copy_to_user(pbuf,pmydev->mydef_buf,size);if(ret){printk("copy_to_user failed\n");return -1;}//读完之后把后面的内容再拷贝过来，同时更新curlenmemcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);pmydev->curlen = pmydev->curlen - size;wake_up_interruptible(&pmydev->wq);return size;}ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{int size = 0;int ret  = 0;//获取全家变量结构体地址struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;if(pmydev->curlen >= BUF_LEN){if(filp->f_flags & O_NONBLOCK){printk("O_NONBLOCK Can not write data\n");return -1;}else{ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);if(ret){printk("wake up by signal\n");return -ERESTARTSYS;}}}if(count > BUF_LEN - pmydev->curlen){size = BUF_LEN - pmydev->curlen;}else{size = count;}//将用户空间中的数据复制到内核空间中ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);if(ret){printk("copy_from_user failed\n");return -1;}//更新curlenpmydev->curlen = pmydev->curlen + size;wake_up_interruptible(&pmydev->rq);return size;
}long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{int __user *pret = (int *)arg;int maxlen = BUF_LEN;int ret = 0;struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;switch(cmd){case MYCHAR_IOCTL_GET_MAXLEN:ret = copy_to_user(pret,&maxlen,sizeof(int));if(ret){printk("copy_to_user MAXLEN failed\n");return -1;}break;case MYCHAR_IOCTL_GET_CURLEN:ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));if(ret){printk("copy_to_user CURLEN failed\n");return -1;}break;default:printk("The cmd is unknow\n");return -1;}return 0;
}/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int mychar_poll(struct file *filp, poll_table *ptb)
{struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;unsigned int mask = 0;//将等待队列头添加至poll_table表中poll_wait(filp, &pmydev->rq,ptb);poll_wait(filp, &pmydev->wq,ptb);//mutex_lock(&pmydev->lock);if(pmydev->curlen > 0) //有数据可读{mask |= POLLIN | POLLRDNORM;}if(pmydev->curlen < BUF_LEN) //有空间可写{mask |= POLLOUT | POLLWRNORM;}//mutex_unlock(&pmydev->lock);return mask;}//结构体初始化:部分变量赋值初始化
struct file_operations myops = {.owner = THIS_MODULE,.open = mychar_open,.release = mychar_close,.read = mychar_read,.write = mychar_write,.unlocked_ioctl = mychar_ioctl,.poll = mychar_poll,
};int mychar_init(void)
{int ret = 0;dev_t devno = MKDEV(major, minor);/* 申请设备号 */ret = register_chrdev_region(devno, mychar_num, "mychar");if (ret) {ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");if (ret) {printk("get devno failed\n");return -1;}major = MAJOR(devno); // 容易遗漏，注意}/* 给struct cdev对象指定操作函数集 */cdev_init(&gmydev.mydev, &myops);/* 将 struct cdev对象添加到内核对应的数据结构里 */gmydev.mydev.owner = THIS_MODULE;cdev_add(&gmydev.mydev, devno, 1);//初始化队列init_waitqueue_head(&(gmydev.rq));init_waitqueue_head(&(gmydev.wq));return 0;
}void __exit mychar_exit(void)
{dev_t devno = MKDEV(major, minor);cdev_del(&gmydev.mydev);unregister_chrdev_region(devno, mychar_num);
}//表示支持GPL的开源协议
MODULE_LICENSE("GPL");module_init(mychar_init);
module_exit(mychar_exit);

主要实现以下部分功能:

编译报错，缺的头文件可以通过grep搜索

 grep poll_table /home/linux/Linux_4412/kernel/linux-3.14/include/ -r -n

mychar.h

#ifndef MY_CHAR_H
#define MY_CHAR_H#include <asm/ioctl.h>#define MY_CHAR_MAGIC 'k'#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)#endif

testmychar_select.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/select.h>
#include <errno.h>#include "mychar.h"
#include <stdio.h>int main(int argc,char *argv[])
{int fd = -1;char buf[8] = "";int ret = 0;fd_set rfds;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDWR);if(fd < 0){printf("open %s failed\n",argv[1]);return 2;}while(1){	//使用FD_ZERO宏初始化一个文件描述符集rfds，并使用FD_SET宏将文件描述符fd添加到rfds集合中。FD_ZERO(&rfds);FD_SET(fd,&rfds);//调用select函数对文件描述符进行监控，如果文件描述符可读，则返回一个大于0的数值，表示有文件描述符就绪；如果出错，则返回-1ret = select(fd + 1,&rfds,NULL,NULL,NULL);if(ret < 0){//如果select返回值小于0，并且错误码为EINTR，表示select被中断，可以继续循环等待；否则，打印错误信息并退出循环。if(errno == EINTR){continue;}else{printf("select error\n");break;}}//如果文件描述符fd在rfds集合中可读，调用read函数从fd中读取8字节的数据，并将其存储在缓冲区buf中if(FD_ISSET(fd,&rfds)){read(fd,buf,8);printf("buf=%s\n",buf);}}close(fd);fd = -1;return 0;
}

Makefile

ifeq ($(KERNELRELEASE),)ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesmodules_install:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_installclean:rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versionselse
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.oendif

命令lsmod | grep char用于列出当前加载的内核模块

命令cat /proc/devices | grep char用于查看系统中已注册的设备类型。

执行效果

2 信号驱动

2.1 应用层：信号注册+fcntl

signal(SIGIO, input_handler); //注册信号处理函数fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程，好由描述符获知PIDoflags = 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)
{//读写数据}

2.2 驱动层：实现fasync函数

实现模板

/*设备结构中添加如下成员*/
struct fasync_struct *pasync_obj;/*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/
static int hello_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync
{struct hello_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);   //POLL_IN代表读信号 POLL_OUT代表写信号/*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/SIGSTOPint 	读写信息POLLIN、POLLOUT
*/

2.3 驱动示例

mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>#include "mychar.h"#define BUF_LEN 100#define MYCHAR_DEV_CNT 3int major = 11;
int minor = 0;
int mychar_num  = MYCHAR_DEV_CNT;//新建结构体类型
struct mychar_dev
{struct cdev mydev;char mydef_buf[BUF_LEN];  //相当于结构体的私有变量int curlen;          //相当于结构体的私有变量wait_queue_head_t rq; //等待读队列wait_queue_head_t wq; //等待写队列struct fasync_struct *pasync_obj;  //实现异步通知机制的数据结构};struct mychar_dev gmydev;int mychar_open(struct inode *pnode, struct file *pfile)
{//利用private_data私有变量来指向全局变量结构体地址pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));printk("mychar_open is called\n");return 0;
}int mychar_close(struct inode *pnode, struct file *pfile)
{struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;printk("mychar_close is called\n");if(pmydev->pasync_obj != NULL){fasync_helper(-1,pfile,0,&pmydev->pasync_obj);  //则调用fasync_helper函数来取消异步通知}return 0;
}ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{int ret = 0;int size = 0;//获取全家变量结构体地址struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;if(pmydev->curlen <= 0){if(filp->f_flags & O_NONBLOCK){//非阻塞printk("O_NONBLOCK No Data Read\n");return -1;}else{//阻塞ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);if(ret){printk("Wake up by signal\n");return -ERESTARTSYS;}}}if(count > pmydev->curlen){size = pmydev->curlen;}else{size = count;}//将内核空间中的数据复制到用户空间ret = copy_to_user(pbuf,pmydev->mydef_buf,size);if(ret){printk("copy_to_user failed\n");return -1;}//读完之后把后面的内容再拷贝过来，同时更新curlenmemcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);pmydev->curlen = pmydev->curlen - size;wake_up_interruptible(&pmydev->wq);return size;}ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{int size = 0;int ret  = 0;//获取全家变量结构体地址struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;if(pmydev->curlen >= BUF_LEN){if(filp->f_flags & O_NONBLOCK){printk("O_NONBLOCK Can not write data\n");return -1;}else{ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);if(ret){printk("wake up by signal\n");return -ERESTARTSYS;}}}if(count > BUF_LEN - pmydev->curlen){size = BUF_LEN - pmydev->curlen;}else{size = count;}//将用户空间中的数据复制到内核空间中ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);if(ret){printk("copy_from_user failed\n");return -1;}//更新curlenpmydev->curlen = pmydev->curlen + size;wake_up_interruptible(&pmydev->rq);//数据写成功发送可读信号（同样读函数也可以实现）if(pmydev->pasync_obj != NULL){kill_fasync(&pmydev->pasync_obj,SIGIO,POLL_IN);}return size;
}long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{int __user *pret = (int *)arg;int maxlen = BUF_LEN;int ret = 0;struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;switch(cmd){case MYCHAR_IOCTL_GET_MAXLEN:ret = copy_to_user(pret,&maxlen,sizeof(int));if(ret){printk("copy_to_user MAXLEN failed\n");return -1;}break;case MYCHAR_IOCTL_GET_CURLEN:ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));if(ret){printk("copy_to_user CURLEN failed\n");return -1;}break;default:printk("The cmd is unknow\n");return -1;}return 0;
}/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int mychar_poll(struct file *filp, poll_table *ptb)
{struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;unsigned int mask = 0;//将等待队列头添加至poll_table表中poll_wait(filp, &pmydev->rq,ptb);poll_wait(filp, &pmydev->wq,ptb);if(pmydev->curlen > 0) //有数据可读{mask |= POLLIN | POLLRDNORM;}if(pmydev->curlen < BUF_LEN) //有空间可写{mask |= POLLOUT | POLLWRNORM;}return mask;}//使用pmydev->pasync_obj作为异步通知对象进行注册
int mychar_fasync(int fd,struct file *filp,int mode)
{struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;return fasync_helper(fd,filp,mode,&pmydev->pasync_obj);
}//结构体初始化:部分变量赋值初始化
struct file_operations myops = {.owner = THIS_MODULE,.open = mychar_open,.release = mychar_close,.read = mychar_read,.write = mychar_write,.unlocked_ioctl = mychar_ioctl,.poll = mychar_poll,.fasync = mychar_fasync,
};int mychar_init(void)
{int ret = 0;dev_t devno = MKDEV(major, minor);/* 申请设备号 */ret = register_chrdev_region(devno, mychar_num, "mychar");if (ret) {ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");if (ret) {printk("get devno failed\n");return -1;}major = MAJOR(devno); // 容易遗漏，注意}/* 给struct cdev对象指定操作函数集 */cdev_init(&gmydev.mydev, &myops);/* 将 struct cdev对象添加到内核对应的数据结构里 */gmydev.mydev.owner = THIS_MODULE;cdev_add(&gmydev.mydev, devno, 1);//初始化队列init_waitqueue_head(&(gmydev.rq));init_waitqueue_head(&(gmydev.wq));return 0;
}void __exit mychar_exit(void)
{dev_t devno = MKDEV(major, minor);cdev_del(&gmydev.mydev);unregister_chrdev_region(devno, mychar_num);}//表示支持GPL的开源协议
MODULE_LICENSE("GPL");module_init(mychar_init);
module_exit(mychar_exit);

mychar.c代码实现步骤

1 添加异步通知数据结构体

2 注册异步通知对象的模板函数

3 关闭释放异步通知处理对象

4 写函数中发送信号

mychar.h

#ifndef MY_CHAR_H
#define MY_CHAR_H#include <asm/ioctl.h>#define MY_CHAR_MAGIC 'k'#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)#endif

Makefile

ifeq ($(KERNELRELEASE),)ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)modules:$(MAKE) -C $(KERNELDIR) M=$(PWD) modulesmodules_install:$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_installclean:rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versionselse
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.oendif

testmychar_signal.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/select.h>
#include <errno.h>
#include <signal.h>#include "mychar.h"
#include <stdio.h>int fd = -1;void sigio_handler(int signo);int main(int argc,char *argv[])
{int flg = 0;if(argc < 2){printf("The argument is too few\n");return 1;}signal(SIGIO,sigio_handler);fd = open(argv[1],O_RDWR);if(fd < 0){printf("open %s failed\n",argv[1]);return 2;}//将文件描述符fd设置为异步通知模式，并将当前进程的PID设置为接收异步通知的进程fcntl(fd,F_SETOWN,getpid());  //数将当前进程的PID设置为fd的拥有者flg = fcntl(fd,F_GETFL);      //取fd的标志位flg |= FASYNC;                //然后使用按位或运算符将FASYNC标志位添加到标志中fcntl(fd,F_SETFL,flg);        //将flg（即带有FASYNC标志位的标志）设置为fd的标志位，从而使fd进入异步通知模式while(1){	}close(fd);fd = -1;return 0;
}void sigio_handler(int signo)
{char buf[8] = "";read(fd,buf,8);printf("buf=%s\n",buf);
}

编译后插入内核模块：