嵌入式驱动初级-阻塞与非阻塞
2024-05-18 02:30:52
文章目录
- 前言
- 一、五种IO模型
- 二、阻塞与非阻塞
- 三、多路复用
- 四、信号驱动
前言
记录嵌入式驱动学习笔记
一、五种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)
- 读、写用不同的等待队列头rq、wq
- 无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)
- 写入数据成功时唤醒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;
}四、信号驱动
Linux 应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备，通过阻塞方式访问的话应用程序会处于休眠态，等待驱动设备可以使用，非阻塞方式的话会通过 poll 函数来不断的轮询，查看驱动设备文件是否可以使用。这两种方式都需要应用程序主动的去查询设备的使用情况，如果能提供一种类似中断的机制，当驱动程序可以访问的时候主动告诉应用程序那就最好了。
“信号”为此应运而生，信号类似于我们硬件上使用的“中断”，只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟，驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了，应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。
应用层思路：信号注册+fcntl
A.使用 signal 函数来设置指定信号的处理函数
sighandler_t signal(int signum, sighandler_t handler)
B.将本应用程序的进程号告诉内核
fcntl(fd, F_SETOWN, getpid())
C.将该设备的IO模式设置成信号驱动模式
oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, oflags | FASYNC);
D.应用自己实现的信号处理函数，在此函数中完成读写
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)
{//读写数据}
驱动层思路
/*设备结构中添加如下成员*/
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);/*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
*/
信号驱动代码
#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增加多路复用代码11.16增加信号驱动代码
*/
#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; //异步相关结构体 struct fasync_struct *pasync_obj;
};
//实例化一个 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) //关闭设备
{//释放异步通知结构对象struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;if(pmydev->pasync_obj != NULL)fasync_helper(-1,pfile,0,&pmydev->pasync_obj);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);/*** 当设备可以访问的时候，驱动程序需要向应用程序发出信号，相当于产生“中断”。kill_fasync函数负责发送指定的信号，kill_fasync 函数原型如下所示：void kill_fasync(struct fasync_struct **fp, int sig, int band)函数参数和返回值含义如下：fp：要操作的 fasync_struct。sig：要发送的信号。band：可读时设置为 POLL_IN，可写时设置为 POLL_OUT。返回值：无*///当对象被创建之后才可以执行以下语句if(pmydev->pasync_obj != NULL){kill_fasync(&pmydev->pasync_obj,SIGIO,POLL_IN);}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;
}
/**支持信号驱动* int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
fasync_helper 函数的前三个参数就是 fasync 函数的那三个参数，第四个参数就是要初始化
的 fasync_struct 结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变
fasync 标记的时候，驱动程序 file_operations 操作集中的 fasync 函数就会执行。功能：产生或释放异步通知结构对象
*/
int mychar_fasync(int fd,struct file *pfile,int mode)
{struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;return fasync_helper(fd,pfile,mode,&pmydev->pasync_obj);
}
//内核驱动操作函数集合 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,//支持信号驱动.fasync = mychar_fasync,
};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 <signal.h>#include <stdio.h>#include "mychar.h"
//把描述符变为全局变量 可以方便信号服务函数使同一个文件描述符
int fd = -1;
//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;}//2.将本应用程序的进程号告诉内核fcntl(fd,F_SETOWN,getpid());//3.开启异步通知flg = fcntl(fd,F_GETFL);flg |= FASYNC;fcntl(fd,F_SETFL,flg);//死循环一直阻塞 等待信号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);
}
嵌入式驱动初级-阻塞与非阻塞相关推荐
- 嵌入式Linux 阻塞和非阻塞 IO 驱动设备访问模式
阻塞和非阻塞 IO 是 Linux 驱动开发里面很常见的两种设备访问模式, 在编写驱动的时候一定要考虑到阻塞和非阻塞. 阻塞与非阻塞简介 阻塞操作是指在执行设备操作时, 若不能获得资源, 则挂起进程直 ...
- Verilog初级教程（15）Verilog中的阻塞与非阻塞语句
文章目录 前言 正文 阻塞赋值 非阻塞赋值 往期回顾 参考资料以及推荐关注 前言 本文通过仿真的方式,形象的说明阻塞赋值以及非阻塞赋值的区别,希望和其他教程相辅相成,共同辅助理解. 正文 阻塞赋值 阻 ...
- linux设备驱动学习（四）——阻塞与非阻塞I/O
1.阻塞与非阻塞I/O介绍 阻塞和非阻塞I/O是设备访问的两种不同模式.阻塞操作是指在执行设备操作时,若不能获得资源,则挂起进程直到满足可操作的条件后再进行操作.被挂起的进程进入睡眠状态,被从调度器的 ...
- Linux 设备驱动中的 I/O模型（一）—— 阻塞和非阻塞I/O
在前面学习网络编程时,曾经学过I/O模型 Linux 系统应用编程--网络编程(I/O模型),下面学习一下I/O模型在设备驱动中的应用. 回顾一下在Unix/Linux下共有五种I/O模型,分别是: ...
- linux 设备驱动阻塞,深入浅出:Linux设备驱动中的阻塞和非阻塞I/O
今天写的是Linux设备驱动中的阻塞和非阻塞I/0,何谓阻塞与非阻塞I/O?简单来说就是对I/O操作的两种不同的方式,驱动程序可以灵活的支持用户空间对设备的这两种访问方式. 一.基本概念: 阻塞操作 ...
- linux驱动开发 - 10_阻塞和非阻塞 IO
文章目录 1 阻塞和非阻塞 IO 1.1 阻塞和非阻塞简介 1.2 等待队列 1.等待队列头 2.等待队列项 3.将队列项添加/移除等待队列头 4.等待唤醒 5.等待事件 1.3 Linux驱动下的p ...
- Linux驱动开发6 阻塞与非阻塞
阻塞和非阻塞 IO 是 Linux 驱动开发里面很常见的两种设备访问模式,在编写驱动的时候 一定要考虑到阻塞和非阻塞.本章我们就来学习一下阻塞和非阻塞 IO ,以及如何在驱动程序中 处理阻塞与非阻塞, ...
- linux驱动阻塞和非阻塞
文章目录 一.阻塞与非阻塞理解 二.阻塞在内核实现--等待队列 三.非阻塞在内核实现--轮询 1.select 2. poll 函数 3. epoll 函数 一.阻塞与非阻塞理解 1.阻塞 如果不能获 ...
- linux write引起进程挂起,Linux设备驱动中的阻塞与非阻塞总结
Linux设备驱动中的阻塞与非阻塞总结 阻塞操作是指,在执行设备操作时,若不能获得资源,则进程挂起直到满足可操作的条件再进行操作. 非阻塞操作的进程在不能进行设备操作时,并不挂起.被挂起的进程进入sl ...
最新文章
- Spring多数据源配置和使用
- 制备pdms膜的方法_四川大学杨伟团队JMCC：实现柔性压阻式压力传感器的规模化制备...
- 3月25日 JavaScript
- UGUI_UGUI组件属性
- （旧）走遍美国——（三、文化3）
- linux文件目录的操作
- VMware中CentOS设置静态IP
- HTML示例08---CSS3概述
- 集合与数组，集合与集合之间的转换
- 五款交友APP对比评测，哪款交友app好用？
- CME ERROR错误代码列表
- CDN缓存原理和介绍
- chrome扩展设置代理
- 2048游戏制作html,一个自制的2048小游戏(一)
- Java 基础语法知识 - 万丈高楼平地起
- Android 项目必备（二十九）--＞App 在线升级与更新
- 揭秘支撑百度搜索、Feed、小程序三大业务的MVVM框架设计思想，San 核心人员倾力打造...
- windows防火墙规则添加
- ESP8266作为arduino D1 wifi模块应用时引脚序号说明(与UNO对比异同）2.5.0版本开发板库
- 2018 数学建模 国赛（高教杯）-智能RGV的动态调度策略