---

前言

记录嵌入式驱动学习笔记

---

一、五种IO模型

当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程
序对应的线程挂起，直到设备资源可以获取为止。对于非阻塞 IO，应用程序对应的线程不会挂
起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。
1.阻塞式 IO
应用程序调用 read 函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。阻塞式 IO 如图

2.非阻塞式 IO
应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，这样一直往复循环，直到数据读取成功。非阻塞 IO 如图

3.多路复用
委托中介监控

4.信号驱动
让内核如果能操作时发信号，在信号处理函数中操作

5.异步IO
向内核注册操作请求，内核完成操作后发通知信号

二、阻塞与非阻塞

阻塞与非阻塞实现流程
应用层：
open时由O_NONBLOCK指示read、write时是否阻塞，open以后可以由fcntl函数来改变是否阻塞：

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

驱动层：通过等待队列

A.定义等待队列头
wait_queue_head_t rq; 读等待队列头
wait_queue_head_t wq; 写等待队列头
B.初始化队列头
init_waitqueue_head(wait_queue_head_t *pwq)
C.将任务丢到等待队列去 条件成立后正常唤醒 读和写的睡眠条件不同
wait_event_interruptible(wq,condition)
D.将符合条件唤醒条件的任务从等待队列头中唤醒
wake_up_interruptible(wait_queue_head_t *pwq)

1. 读、写用不同的等待队列头rq、wq
2. 无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)
3. 写入数据成功时唤醒rq，读出数据成功唤醒wq

	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) //唤醒深睡眠
/*

添加读写阻塞等待功能和非阻塞的字符设备驱动代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>
#include "mychar.h"
// 该程序思路 应用层先往内核mydev_buf内写 hello 然后再从内核里读出来
#define BUF_LEN 100
//主设备号
int major = 11;
//次设备号
int minor = 0;
//注册设备数量
int mychar_num = 1;
//设备名
char mycharname[] ="mychar";
//设备操作函数避免使用太多全局变量 将变量写入一个结构体
struct mychar_dev
{//创建cdev类型的对象 cdevinit函数要用到 包含在结构体mychar_dev相当于子类继承父类struct cdev mydev;//全局数组 字符设备产生的数据存放char mydev_buf[BUF_LEN];//数组下标从零开始int curlen;//阻塞队列队头 读等待 写等待wait_queue_head_t rq;wait_queue_head_t wq; 
}; 
//实例化一个 mychar_dev类型的对象
struct mychar_dev gmydev;
int mychar_open(struct inode *pnode, struct file *pfile) //打开设备
{//将设备结构体作为私有数据添加到设备文件中/*已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)*/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 xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：filp：指向open产生的struct file类型的对象，表示本次read对应的那次openpbuf：指向用户空间一块内存，用来保存读到的数据count：用户期望读取的字节数ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置返回值：本次成功读取的字节数，失败返回-1wait_event_interruptible(wq,condition)
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来wq:等待队列头condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）*/
ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
{struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;int ret = 0;//要读的数据大于数据的长度 修改要读数据的长度int size = 0;//改写读写函数变成支持非阻塞 curlen <= 0此时表示没数据可读if(pmydev->curlen <= 0){//通过该标志位判断是否为非阻塞if(pfile->f_flags & O_NONBLOCK){//非阻塞 直接返回错误printk("O_NONBLOCK No Data Read\n");return -1;}else{//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 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;}//将内核空间数据复制到用户空间 用户空间：puser 内核空间：mydev_bufret = copy_to_user(puser,pmydev->mydev_buf,size);if(ret){printk("copy_to_user failed\n");return -1;}//将剩下的数据移动到数组起始 即删除已读数据memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);pmydev->curlen -= size;//成功读走一段数据 就会空出一段空间可以写入数据wake_up_interruptible(&pmydev->wq);return size;
}
//写数据对于应用层来说 把数据写进驱动
/*
ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：filp：指向open产生的struct file类型的对象，表示本次write对应的那次openpbuf：指向用户空间一块内存，用来保存被写的数据count：用户期望写入的字节数ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置返回值：本次成功写入的字节数，失败返回-1
*/
ssize_t mychar_write(struct file *pfile, const char __user *puser, size_t count, loff_t *p_pos)
{int size = 0;int ret = 0;struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;//改写读写函数变成支持非阻塞 >= BUF_LEN此时表示数据已经写满不可再写if(pmydev->curlen >= BUF_LEN){if(pfile->f_flags & O_NONBLOCK){//非阻塞 直接返回错误printk("O_NONBLOCK Can not write data\n");return -1;}else{//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 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->mydev_buf + pmydev->curlen,puser,size);if(ret){printk("copy_from_user failed\n");return -1;}pmydev->curlen += size;//当应用层写入数据后 就有数据可读在此处唤醒读等待队列wake_up_interruptible(&pmydev->rq);return size;
}
//设备属性控制函数
long mychar_ioctl(struct file *pfile,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 *)pfile->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;
}
//内核驱动操作函数集合 cdevinit函数要用到
struct file_operations myops =
{.owner=THIS_MODULE,.open=mychar_open,.release=mychar_close,.read=mychar_read,.write=mychar_write,.unlocked_ioctl=mychar_ioctl,
};int __init mychar_init(void)
{//用来接收注册设备函数的返回值int ret = 0;//主设备号和次设备号合并dev_t devno = MKDEV(major,minor);/*1.申请设备号*///静态分配 手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号//ret = register_chrdev_region(devno,mychar_num,"mychar");ret = register_chrdev_region(devno,mychar_num,mycharname);//分配失败返回负数if(ret){//动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号//ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");ret = alloc_chrdev_region(&devno,minor,mychar_num,mycharname);if(ret){printk("get devno failed\n");return -1;}//如果是动态分配说明自己设置的设备号被占用了 系统会更换主设备号 重新获取一下主设备号major = MAJOR(devno);}/*2.将struct cdev对象添加到内核对应的数据结构里*///初始化cdev 给struct cdev对象指定操作函数集cdev_init(&gmydev.mydev,&myops);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);//注销字符设备驱动 入口参数：设备号 设备名称//unregister_chrdev(devno,"mychar");//将字符设备从内核移除cdev_del(&gmydev.mydev);unregister_chrdev_region(devno,mychar_num);
}
MODULE_LICENSE("GPL");
module_init(mychar_init);
module_exit(mychar_exit);

阻塞等待应用程序

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include "mychar.h"
int main(int argc,char *argv[])
{int fd = -1;char buf[8] = "";int ret = 0;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;}ret = read(fd,buf,8);if(ret < 0){printf("read data failed\n");}else{printf("buf=%s\n",buf);}close(fd);fd = -1;return 0;
}

非阻塞等待应用程序

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include "mychar.h"
int main(int argc,char *argv[])
{int fd = -1;char buf[8] = "";int ret = 0;if(argc < 2){printf("The argument is too few\n");return 1;}fd = open(argv[1],O_RDWR | O_NONBLOCK);if(fd < 0){printf("open %s failed\n",argv[1]);return 2;}ret = read(fd,buf,8);if(ret < 0){printf("read data failed\n");}else{printf("buf=%s\n",buf);}close(fd);fd = -1;return 0;
}

三、多路复用

如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、epoll 和 select 可以用于处理轮询，应用程序通过 select、epoll 或 poll 函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用 select、epoll 或 poll 函数的时候设备驱动程序中的 poll 函数就会执行，因此需要在设备驱动程序中编写 poll 函数。
应用层思路
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)){//写数据//....}}
}

当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序file_operations 操作集中的 poll 函数就会执行。所以驱动程序的编写者需要提供对应的 poll 函数，poll 函数原型如下所示：
驱动层思路
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;
}

支持多路复用驱动层代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/poll.h>
#include <linux/cdev.h>
#include "mychar.h"// 该程序思路 应用层先往内核mydev_buf内写 hello 然后再从内核里读出来
/*11.15增加多路复用代码
*/
#define BUF_LEN 100
//主设备号
int major = 11;
//次设备号
int minor = 0;
//注册设备数量
int mychar_num = 1;
//设备名
char mycharname[] ="mychar";
//设备操作函数避免使用太多全局变量 将变量写入一个结构体
struct mychar_dev
{//创建cdev类型的对象 cdevinit函数要用到 包含在结构体mychar_dev相当于子类继承父类struct cdev mydev;//全局数组 字符设备产生的数据存放char mydev_buf[BUF_LEN];//数组下标从零开始int curlen;//阻塞队列队头 读等待 写等待wait_queue_head_t rq;wait_queue_head_t wq; 
}; 
//实例化一个 mychar_dev类型的对象
struct mychar_dev gmydev;
int mychar_open(struct inode *pnode, struct file *pfile) //打开设备
{//将设备结构体作为私有数据添加到设备文件中/*已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)*/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 xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：filp：指向open产生的struct file类型的对象，表示本次read对应的那次openpbuf：指向用户空间一块内存，用来保存读到的数据count：用户期望读取的字节数ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置返回值：本次成功读取的字节数，失败返回-1wait_event_interruptible(wq,condition)
功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来wq:等待队列头condition：C语言表达式
返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）*/
ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
{struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;int ret = 0;//要读的数据大于数据的长度 修改要读数据的长度int size = 0;//改写读写函数变成支持非阻塞 curlen <= 0此时表示没数据可读if(pmydev->curlen <= 0){//通过该标志位判断是否为非阻塞if(pfile->f_flags & O_NONBLOCK){//非阻塞 直接返回错误printk("O_NONBLOCK No Data Read\n");return -1;}else{//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 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;}//将内核空间数据复制到用户空间 用户空间：puser 内核空间：mydev_bufret = copy_to_user(puser,pmydev->mydev_buf,size);if(ret){printk("copy_to_user failed\n");return -1;}//将剩下的数据移动到数组起始 即删除已读数据memcpy(pmydev->mydev_buf,pmydev->mydev_buf + size,pmydev->curlen - size);pmydev->curlen -= size;//成功读走一段数据 就会空出一段空间可以写入数据wake_up_interruptible(&pmydev->wq);return size;
}
//写数据对于应用层来说 把数据写进驱动
/*
ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos);  
完成功能：向设备写入数据
参数：filp：指向open产生的struct file类型的对象，表示本次write对应的那次openpbuf：指向用户空间一块内存，用来保存被写的数据count：用户期望写入的字节数ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置返回值：本次成功写入的字节数，失败返回-1
*/
ssize_t mychar_write(struct file *pfile, const char __user *puser, size_t count, loff_t *p_pos)
{int size = 0;int ret = 0;struct mychar_dev *pmydev = (struct mychar_dev *) pfile->private_data;//改写读写函数变成支持非阻塞 >= BUF_LEN此时表示数据已经写满不可再写if(pmydev->curlen >= BUF_LEN){if(pfile->f_flags & O_NONBLOCK){//非阻塞 直接返回错误printk("O_NONBLOCK Can not write data\n");return -1;}else{//阻塞 将任务丢到等待队列去 条件成立后正常唤醒返回0，信号唤醒返回非0 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->mydev_buf + pmydev->curlen,puser,size);if(ret){printk("copy_from_user failed\n");return -1;}pmydev->curlen += size;//当应用层写入数据后 就有数据可读在此处唤醒读等待队列wake_up_interruptible(&pmydev->rq);return size;
}
//设备属性控制函数
long mychar_ioctl(struct file *pfile,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 *)pfile->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;
}
/* 支持多路复用
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表
*/
unsigned int mychar_poll(struct file *pfile, poll_table *ptb)
{struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;unsigned int mask = 0;//1. 将所有等待队列头加入poll_table表中poll_wait(pfile,&pmydev->rq,ptb);poll_wait(pfile,&pmydev->wq,ptb);//2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;if(pmydev->curlen > 0){mask |= POLLIN | POLLRDNORM;}//3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;if(pmydev->curlen < BUF_LEN){mask |= POLLOUT | POLLWRNORM;}return mask;
}
//内核驱动操作函数集合 cdevinit函数要用到
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 __init mychar_init(void)
{//用来接收注册设备函数的返回值int ret = 0;//主设备号和次设备号合并dev_t devno = MKDEV(major,minor);/*1.申请设备号*///静态分配 手动分配设备号，先验证设备号是否被占用，如果没有则申请占用该设备号//ret = register_chrdev_region(devno,mychar_num,"mychar");ret = register_chrdev_region(devno,mychar_num,mycharname);//分配失败返回负数if(ret){//动态分配设备号，查询内核里未被占用的设备号，如果找到则占用该设备号//ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");ret = alloc_chrdev_region(&devno,minor,mychar_num,mycharname);if(ret){printk("get devno failed\n");return -1;}//如果是动态分配说明自己设置的设备号被占用了 系统会更换主设备号 重新获取一下主设备号major = MAJOR(devno);}/*2.将struct cdev对象添加到内核对应的数据结构里*///初始化cdev 给struct cdev对象指定操作函数集cdev_init(&gmydev.mydev,&myops);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);//注销字符设备驱动 入口参数：设备号 设备名称//unregister_chrdev(devno,"mychar");//将字符设备从内核移除cdev_del(&gmydev.mydev);unregister_chrdev_region(devno,mychar_num);
}
MODULE_LICENSE("GPL");
module_init(mychar_init);
module_exit(mychar_exit);

支持多路复用应用层代码

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>#include <stdio.h>#include "mychar.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;}
/***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，则无描述符可被操作的情况下阻塞指定长度的时间 
*/while(1){//功能：将集合清零 清除 readfdsFD_ZERO(&rfds);//功能：将fd 添加到集合中  将 fd 添加到 readfds 里面FD_SET(fd,&rfds);//监听的文件中没有数据可读一直阻塞 有数据可读时返回 //select将更新这个集合,把其中不可读的文件描述符去掉只保留符合条件的在这个集合里面ret = select(fd + 1,&rfds,NULL,NULL,NULL);//小于0表示出错 返回其他值，可以进行操作的文件描述符个数。if(ret < 0){//被信号唤醒的出错可以忽略继续执行if(errno == EINTR){continue;}else{printf("select error\n");break;}}//功能：判断fd 是否存在于集合中 条件成立代表有数据可读/*** fd_set rfds取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。* 则1字节长的fd_set最大可以对应8个fd。(1)执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。(2)若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)(3)若再加入fd＝2，fd=1,则set变为0001,0011(4)执行select(6,&set,0,0,0)阻塞等待(5)若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。*/if(FD_ISSET(fd,&rfds)){//读数据并打印read(fd,buf,8);printf("buf=%s\n",buf);}}close(fd);fd = -1;return 0;
}