【嵌入式Linux驱动开发】十六、Linux中的阻塞IO与非阻塞IO
有志不在年高，罗成少年统兵马。
得道何须深山，老君立地晓阴阳
文章目录
- 一、阻塞和非阻塞IO
- 1.1 等待队列 - 阻塞IO
- 1.2 轮询 - 非阻塞IO
- 1.2.1 非阻塞访问 - select函数
- 1.2.1 非阻塞访问 - poll函数
- 1.2.1 非阻塞访问 - epoll函数
- 1.3 Linux 驱动下的 poll 操作函数
- 二、阻塞IO实验
- 三、非阻塞IO实验
一、阻塞和非阻塞IO
阻塞和非阻塞 IO 是 Linux 驱动开发里面很常见的两种设备访问模式。需要强调的是，这里的 IO 指的是 Input/Output，也就是输入/输出，是应用程序对驱动设备的输入/输出操作。应用程序对设备驱动进行操作的时候，如果不能获取到设备资源时，阻塞IO和非阻塞IO动作是不同的，具体动作如下所示：
- 阻塞式 IO 就会将应用程序对应的线程挂起，直到设备资源可以获取为止
- 阻塞方式读IO：
open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开 */ - 阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态，这样可以将CPU 资源让出来。
- 阻塞方式读IO：
- 非阻塞 IO，应用程序对应的线程不会挂起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。
- 非阻塞方式读IO：
open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打开 */
- 非阻塞方式读IO：
1.1 等待队列 - 阻塞IO
阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态，这样可以将CPU 资源让出来。但是，当设备文件可以操作的时候就必须唤醒进程，一般在中断函数里面完成唤醒工作。Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作。
- 等待队列头
如果我们要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体 wait_queue_head_t 定义。定义好等待队列头以后需要初始化， 使用 init_waitqueue_head 函数初始化等待队列头。
当然了，也可以使用宏
DECLARE_WAIT_QUEUE_HEAD来一次性完成等待队列头的定义的初始化。
- 等待队列项
等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，当设备不可用的时候就要将这些进程对应的等待队列项添加到等待队列里面。使用结构体 wait_queue_t 定义等待队列项，然后使用 init_waitqueue_head 函数初始化等待队列头
使用宏
DECLARE_WAITQUEUE(name, tsk)定义并初始化一个等待队列项。
其中，name 就是等待队列项的名字， tsk 表示这个等待队列项属于哪个任务(进程)，，一般设置为current ， 在 Linux 内 核 中 current 相 当 于 一 个 全 局 变 量 ， 表 示 当 前 进 程 。 因 此 宏DECLARE_WAITQUEUE 就是给当前正在运行的进程创建并初始化了一个等待队列项。
- 将队列项添加/移除等待队列头
当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。当设备可以访问以后再将进程对应的等待队列项从等待队列头中移除即可，等待队列项添加/移除 API 函数如下：
//q: 等待队列项要加入的等待队列头，wait：要加入的等待队列项。
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
- 等待唤醒
当设备可以使用的时候就要唤醒进入休眠态的进程，唤醒可以使用如下两个函数，这两个函数会将这个等待队列头中的所有进程都唤醒。wake_up 函数可以唤醒处于 TASK_INTERRUPTIBLE 和TASK_UNINTERRUPTIBLE 状态的进程，而 wake_up_interruptible 函数只能唤醒处于TASK_INTERRUPTIBLE 状态的进程。
//参数 q 就是要唤醒的等待队列头
void wake_up(wait_queue_head_t *q)
void wake_up_interruptible(wait_queue_head_t *q)
- 等待事件
除了等待唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒等待队列中的进程。
| 函数 | 描述 |
|---|---|
| wait_event(wq, condition) | 等待以 wq 为等待队列头的等待队列被唤醒，前提是 condition 条件必须满足(为真)，否则一直阻塞 。 此 函 数 会 将 进 程 设 置 为TASK_UNINTERRUPTIBLE 状态 |
| wait_event_timeout(wq, condition, timeout) | 功能和 wait_event 类似，但是此函数可以添加超时时间，以 jiffies 为单位。此函数有返回值，如果返回 0 的话表示超时时间到，而且 condition为假。为 1 的话表示 condition 为真，也就是条件满足了。 |
| wait_event_interruptible(wq, condition) | 与 wait_event 函数类似，但是此函数将进程设置为 TASK_INTERRUPTIBLE，就是可以被信号打断。 |
| wait_event_interruptible_timeout(wq,condition, timeout) | 与 wait_event_timeout 函数类似，此函数也将进程设置为 TASK_INTERRUPTIBLE，可以被信号打断。 |
1.2 轮询 - 非阻塞IO
如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、 epoll 和 select 可以用于处理轮询，应用程序通过 select、 epoll 或 poll 函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用 select、 epoll 或 poll 函数的时候设备驱动程序中的 poll 函数就会执行，因此**需要在设备驱动程序中编写 poll 函数。**我们先来看一下应用程序中使用的 select、 poll 和 epoll 这三个函数。
1.2.1 非阻塞访问 - select函数
函数原型：
int select(int nfds,
fd_set *readfds,
fd_set *writefds,
fd_set *exceptfds,
struct timeval *timeout)
nfds
- 要操作的文件描述符个数。
readfds、 writefds 和 exceptfds
- 这三个指针指向描述符集合（ fd_set 类型）
- fd_set 类型变量的每一个位都代表了一个文件描述符。 【下面有介绍如何添加描述到描述符集fd_set中】
- readfds - 监视指定描述符集的读变化(是否可读)。
- 若可读select返回大于0的值；若不可读根据timeout参数判断是否超时；若设置readfds为NULL则表示不关系是否可读。
- writefds - 监视指定描述符集的写变化(是否可写)。
- exceptfds - 监视指定描述符集的异常。
timeout
- 超时时间，当我们调用 select 函数等待某些文件描述符可以设置超时时间，超时时间使用结构体 timeval 表示。
- 当 timeout 为 NULL 的时候就表示无限期的等待。
- 结构体定义如下所示：
struct timeval {
long tv_sec; /* 秒 */
long tv_usec; /* 微妙 */
};
select返回值
- 0，表示超时，但是没有任何文件描述符可以进行操作；
- -1，表示发生错误；
- 其他值，表示可以进行操作的文件描述符个数。
fd_set
- 若要从一个设备文件中读取数据，那么就可以定义一个 fd_set 变量，这个变量要传递给参数 readfds。当我们定义好一个 fd_set 变量以后可以使用如下所示几个宏进行操作：
void FD_ZERO(fd_set *set)
void FD_SET(int fd, fd_set *set)
void FD_CLR(int fd, fd_set *set)
int FD_ISSET(int fd, fd_set *set)
- FD_ZERO 用于将 fd_set 变量的所有位都清零，文件描述符集清空
- FD_SET 用于将 fd_set 变量的某个位置 1，也就是向 fd_set 添加一个文件描述符，参数 fd 就是要加入的文件描述符
- FD_CLR 用户将 fd_set变量的某个位清零，也就是将一个文件描述符从 fd_set 中删除，参数 fd 就是要删除的文件描述符
- FD_ISSET 用于测试 fd_set 的某个位是否置 1，也就是判断某个文件是否可以进行操作，参数 fd 就是要判断的文件描述符
select 函数读非阻塞访问示例
void main(void)
{
int ret, fd; /* 要监视的文件描述符 */
fd_set readfds; /* 读操作文件描述符集 */
struct timeval timeout; /* 超时结构体 */
fd = open("dev_xxx", O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */
FD_ZERO(&readfds); /* 清除 readfds */
FD_SET(fd, &readfds); /* 将 fd 添加到 readfds 里面 */
/* 构造超时时间 */
timeout.tv_sec = 0;
timeout.tv_usec = 500000; /* 500ms */
ret = select(fd + 1, &readfds, NULL, NULL, &timeout);//1个文件描述符，只检测读变化
switch (ret) {
case 0: /* 超时 */
printf("timeout!\r\n");
break;
case -1: /* 错误 */
printf("error!\r\n");
break;
default: /* 可以读取数据 */
if(FD_ISSET(fd, &readfds)) { /* 判断是否为 fd 文件描述符 */
/* 使用 read 函数读取数据 */
}
break;
}
}
1.2.1 非阻塞访问 - poll函数
在单个线程中， select 函数能够监视的文件描述符数量有最大的限制，一般为 1024，可以修改内核将监视的文件描述符数量改大，但是这样会降低效率！这个时候就可以使用 poll 函数，poll 函数本质上和 select 没有太大的差别，但是 poll 函数没有最大文件描述符限制， Linux 应用程序中 poll 函数原型如下所示：
int poll(struct pollfd *fds,
nfds_t nfds,
int timeout)
fds
- 要监视的文件描述符集合以及要监视的事件，类型是一个pollfd类型的结构体数组
- pollfd 结构体如下所示，参数说明如下
- fd 是要监视的文件描述符，如果 fd 无效的话那么 events 监视事件也就无效，并且 revents返回 0。
- events 是要监视的事件，可监视的事件类型如下表。
- revents 是返回的事件，由 Linux 内核设置具体的返回事件
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 请求的事件 */
short revents; /* 返回的事件 */
};
| 事件类型 | 描述 |
|---|---|
| POLLIN | 有数据可以读取。 |
| POLLPRI | 有紧急的数据需要读取。 |
| POLLOUT | 可以写数据。 |
| POLLERR | 指定的文件描述符发生错误。 |
| POLLHUP | 指定的文件描述符挂起。 |
| POLLNVAL | 无效的请求。 |
| POLLRDNORM | 等同于 POLLIN |
nfds
- poll 函数要监视的文件描述符数量。
timeout
- 超时时间，单位为 ms。
poll返回值
- 0，表示超时发生
- -1，表示发生错误，并且设置 errno 为错误类型。
- 其他值，表示revents 域中不为 0 的 pollfd 结构体个数
poll 函数读非阻塞访问示例
void main(void)
{
int ret;
int fd; /* 要监视的文件描述符 */
struct pollfd fds;
fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */
/* 构造结构体 */
fds.fd = fd;
fds.events = POLLIN; /* 监视数据是否可以读取 */
ret = poll(&fds, 1, 500); /* 轮询文件是否可操作，超时 500ms */
if (ret) { /* 数据有效 */
......
/* 读取数据 */
......
} else if (ret == 0) { /* 超时 */
......
} else if (ret < 0) { /* 错误 */
......
}
}
1.2.1 非阻塞访问 - epoll函数
传统的 selcet 和 poll 函数都会随着所监听的 fd 数量的增加，出现效率低下的问题，而且poll 函数每次必须遍历所有的描述符来检查就绪的描述符，这个过程很浪费时间。为此， epoll因运而生， epoll 就是为处理大并发而准备的，一般常常在网络编程中使用 epoll 函数。
使用流程：epoll_create -> epoll_ctl -> epoll_wait
应用程序需要先使用 epoll_create 函数创建一个 epoll 句柄， epoll_create 函数原型如下：
int epoll_create(int size)
size
- 从 Linux2.6.8 开始此参数已经没有意义了，随便填写一个大于 0 的值就可以。
- 返回值： epoll 句柄，如果为-1 的话表示创建失败。
poll 句柄创建成功以后使用 epoll_ctl 函数向其中添加要监视的文件描述符以及监视的事件， epoll_ctl 函数原型如下所示：
int epoll_ctl(int epfd,
int op,
int fd,
struct epoll_event *event)
epfd
- 要操作的 epoll 句柄，也就是使用 epoll_create 函数创建的 epoll 句柄。
op
- 表示要对epoll 句柄(epfd)进行的操作，可以设置的参数如下表所示。
| 参数 | 含义 |
|---|---|
| EPOLL_CTL_ADD | 向 epfd 添加文件参数 fd 表示的描述符。 |
| EPOLL_CTL_MOD | 修改参数 fd 的 event 事件。 |
| EPOLL_CTL_DEL | 从 epfd 中删除 fd 描述符。 |
fd
- 要监视的文件描述符。
event
- 要监视的事件类型，为 epoll_event 结构体类型指针， epoll_event 结构体类型如下所示。
- 结构体 epoll_event 的 events 成员变量表示要监视的事件，可选的事件如下表所示，这些事件可以进行“或”操作，也就是说可以设置监视多个事件。
struct epoll_event {
uint32_t events; /* epoll 事件 */
epoll_data_t data; /* 用户数据 */
};
| 参数 | 含义 |
|---|---|
| EPOLLIN | 有数据可以读取。 |
| EPOLLOUT | 可以写数据。 |
| EPOLLPRI | 有紧急的数据需要读取。 |
| EPOLLERR | 指定的文件描述符发生错误。 |
| EPOLLHUP | 指定的文件描述符挂起。 |
| EPOLLET | 设置 epoll 为边沿触发，默认触发模式为水平触发。 |
| EPOLLONESHOT | 一次性的监视，当监视完成以后还需要再次监视某个 fd，那么就需要将fd 重新添加到 epoll 里面。 |
epoll返回值
- 0，成功
- -1，失败，并且设置 errno 的值为相应的错误码。
一切都设置好以后应用程序就可以通过 epoll_wait 函数来等待事件的发生，类似 select 函数。 epoll_wait 函数原型如下所示：
int epoll_wait(int epfd,
struct epoll_event *events,
int maxevents,
int timeout)
epfd
- 要等待的 epoll。
events
- 指向 epoll_event 结构体的数组，当有事件发生的时候 Linux 内核会填写 events，调用者可以根据 events判断发生了哪些事件。
maxevents
- events 数组大小，必须大于 0。
timeout
- 超时时间，单位为 ms。
返回值
- 0，超时
- -1，错误
- 其他值，准备就绪的文件描述符数量。
epoll 更多的是用在大规模的并发服务器上，因为在这种场合下 select 和 poll 并不适合。当设计到的文件描述符(fd)比较少的时候就适合用 selcet 和 poll，初学先了解select和poll函数即可！
1.3 Linux 驱动下的 poll 操作函数
当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序file_operations 操作集中的 poll 函数就会执行。所以驱动程序的编写者需要提供对应的 poll 函数。poll 函数原型如下所示：
unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)
filp
- 要打开的设备文件(文件描述符)。
wait
- 结构体 poll_table_struct 类型指针， 由应用程序传递进来的。一般将此参数传递给poll_wait 函数。
返回值
- 向应用程序返回设备或者资源状态，可以返回的资源状态如下表。
| 参数 | 描述符 |
|---|---|
| POLLIN | 有数据可以读取。 |
| POLLPRI | 有紧急的数据需要读取。 |
| POLLOUT | 可以写数据。 |
| POLLERR | 指定的文件描述符发生错误。 |
| POLLHUP | 指定的文件描述符挂起。 |
| POLLNVAL | 无效的请求。 |
| POLLRDNORM | 等同于 POLLIN，普通数据可读 |
二、阻塞IO实验
在上一节第一个按键实验中，我们直接在应用程序中通过 read 函数不断的读取按键状态，当按键有效的时候就打印出按键值。这种方法有个缺点，那就是 imx6uirqApp 这个测试应用程序拥有高达99.6% CPU 占用率。
原因就在于我们是直接在 while 循环中通过 read 函数读取按键值，因此 imx6uirqApp 这个软件会一直运行，一直读取按键值， CPU 使用率肯定就会很高。最好的方法就是在没有有效的按键事件发生的时候，imx6uirqApp 这个应用程序应该处于休眠状态，当有按键事件发生以后 imx6uirqApp 这个应用程序才运行，打印出按键值，这样就会降低 CPU 使用率，本小节我们就使用阻塞 IO 来实现此功能。
驱动程序
#include 应用程序
同第一次按键
需要说明的
1、几个函数
__set_current_state 函数
- 设置当前进程的状态为 TASK_INTERRUPTIBLE，也就是可以被信号打断
schedule 函数
- 进行一次任务切换，当前进程就会进入到休眠态
signal_pending 函数
- 判断一下进程是不是由信号唤醒的
2、使用等待队列实现阻塞访问重点注意两点：
- ①、将任务或者进程加入到等待队列头。
- ②、在合适的点唤醒等待队列，一般都是中断处理函数里面。
三、非阻塞IO实验
驱动程序
#include 应用程序
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "linux/ioctl.h"
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : noblockApp.c
作者 : 左忠凯
版本 : V1.0
描述 : 非阻塞访问测试APP
其他 : 无
使用方法 ：./blockApp /dev/blockio 打开测试App
论坛 : www.openedv.com
日志 : 初版V1.0 2019/9/8 左忠凯创建
***************************************************************/
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd;
int ret = 0;
char *filename;
struct pollfd fds;
fd_set readfds;
struct timeval timeout;
unsigned char data;
if (argc != 2) {
printf("Error Usage!\r\n");
return -1;
}
filename = argv[1];
fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞访问 */
if (fd < 0) {
printf("Can't open file %s\r\n", filename);
return -1;
}
#if 0
/* 构造结构体 */
fds.fd = fd;
fds.events = POLLIN;
while (1) {
ret = poll(&fds, 1, 500);
if (ret) { /* 数据有效 */
ret = read(fd, &data, sizeof(data));
if(ret < 0) {
/* 读取错误 */
} else {
if(data)
printf("key value = %d \r\n", data);
}
} else if (ret == 0) { /* 超时 */
/* 用户自定义超时处理 */
} else if (ret < 0) { /* 错误 */
/* 用户自定义错误处理 */
}
}
#endif
while (1) {
FD_ZERO(&readfds);
FD_SET(fd, &readfds);
/* 构造超时时间 */
timeout.tv_sec = 0;
timeout.tv_usec = 500000; /* 500ms */
ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
switch (ret) {
case 0: /* 超时 */
/* 用户自定义超时处理 */
break;
case -1: /* 错误 */
/* 用户自定义错误处理 */
break;
default: /* 可以读取数据 */
if(FD_ISSET(fd, &readfds)) {
ret = read(fd, &data, sizeof(data));
if (ret < 0) {
/* 读取错误 */
} else {
if (data)
printf("key value=%d\r\n", data);
}
}
break;
}
}
close(fd);
return ret;
}
需要说明的：
- 第 52~73 行，这段代码使用 poll 函数来实现非阻塞访问，在 while 循环中使用 poll 函数不断的轮询，检查驱动程序是否有数据可以读取，如果可以读取的话就调用 read 函数读取按键数据。
- 第 75~101 行，这段代码使用 select 函数来实现非阻塞访问