【摘要】本文分析了内核的同步及互斥的几种机制：原子运算符（atomic operator）、自旋锁Spinlock、等待队列Waitqueue、事件Event、completion、信号量Semaphore及其优化版互斥锁，详细分析了其实现流程。Event及Semaphore本质上都是基于Waitqueue和自旋锁实现的。本文还探讨了每种机制最适合应用到哪些地方，以及如何构建安全高效的内核及驱动代码。
互斥锁，自旋锁，信号量，完成量等锁基本上都是按照先后顺序唤配休眠的进程.
但在某些场合，想唤醒满足特定条件的特定休眠进程时就无法做到. 在linux内核里可用等待队列来实现这种需求。
当进程要获取某些资源(例如从网卡读取数据)的时候，但资源并没有准备好(例如网卡还没接收到数据)，这时候内核必须切换到其他进程运行，直到资源准备好再唤醒进程。
waitqueue (等待队列) 就是内核用于管理等待资源的进程，当某个进程获取的资源没有准备好的时候，可以通过调用 add_wait_queue() 函数把进程添加到 waitqueue 中，然后切换到其他进程继续执行。当资源准备好，由资源提供方通过调用 wake_up() 函数来唤醒等待的进程。
第五十二章Linux阻塞和非阻塞IO实验
阻塞和非阻塞IO是Linux驱动开发里面很常见的两种设备访问模式，在编写驱动的时候一定要考虑到阻塞和非阻塞。本章我们就来学习一下阻塞和非阻塞IO，以及如何在驱动程序中处理阻塞与非阻塞，如何在驱动程序使用等待队列和poll机制。
52.1 阻塞和非阻塞IO
52.1.1 阻塞和非阻塞简介
这里的“IO”并不是我们学习STM32或者其他单片机的时候所说的“GPIO”(也就是引脚)。这里的IO指的是Input/Output，也就是输入/输出，是应用程序对驱动设备的输入/输出操作。当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式IO就会将应用程序对应的线程挂起，直到设备资源可以才做为止。对于非阻塞IO，应用程序对应的线程不会挂起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。阻塞式IO如图52.1.1.1所示：
图52.1.1.1 阻塞IO访问示意图。
图52.1.1.1中应用程序调用read函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。非阻塞IO如图52.1.2所示：
图52.1.1.2 非阻塞IO访问示意图
从图52.1.1.2可以看出，应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，这样一直往复循环，直到数据读取成功。
应用程序可以使用如下所示示例代码来实现阻塞访问：
示例代码52.1.1.1 应用程序阻塞读取数据
1int fd;
2int data =0;
3
4 fd =open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开 */
5 ret =read(fd,&data,sizeof(data)); /* 读取数据 */
从示例代码52.1.1.1可以看出，对于设备驱动文件的默认读取方式就是阻塞式的，所以我们前面所有的例程测试APP都是采用阻塞IO。
如果应用程序要采用非阻塞的方式来访问驱动设备文件，可以使用如下所示代码：
示例代码52.1.1.2 应用程序非阻塞读取数据
1int fd;
2int data =0;
3
4 fd =open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打开 */
5 ret =read(fd,&data,sizeof(data)); /* 读取数据 */
第4行使用open函数打开“/dev/xxx_dev”设备文件的时候添加了参数“O_NONBLOCK”，表示以非阻塞方式打开设备，这样从设备中读取数据的时候就是非阻塞方式的了。
52.1.2 等待队列
1、等待队列头
阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态，这样可以将CPU资源让出来。但是，当设备文件可以操作的时候就必须唤醒进程，一般在中断函数里面完成唤醒工作。Linux内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，如果我们要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t表示，wait_queue_head_t结构体定义在文件include/linux/wait.h中，结构体内容如下所示：
示例代码52.1.2.1 wait_queue_head_t结构体
39struct __wait_queue_head {
40 spinlock_t lock;
41struct list_head task_list;
42};
43typedefstruct __wait_queue_head wait_queue_head_t;
定义好等待队列头以后需要初始化，使数init_waitqueue_head函数初始化等待队列头，函数原型如下：
void init_waitqueue_head(wait_queue_head_t *q)
参数q就是要初始化的等待队列头。
也可以使用宏DECLARE_WAIT_QUEUE_HEAD来一次性完成等待队列头的定义的初始化。
2、等待队列项
等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，当设备不可用的时候就要将这些进程对应的等待队列项添加到等待队列里面。结构体wait_queue_t表示等待队列项，结构体内容如下：
示例代码52.1.2.2 wait_queue_t 结构体
struct __wait_queue {
unsignedint flags;
void *private;
wait_queue_func_t func;
struct list_head task_list;
};
typedefstruct __wait_queue wait_queue_t;
使用宏DECLARE_WAITQUEUE定义并初始化一个等待队列项，宏的内容如下：
DECLARE_WAITQUEUE(name, tsk)
name就是等待队列项的名字，tsk表示这个等待队列项属于哪个任务(进程)，一般设置为current，在Linux内核中current相当于一个全局变量，表示当前进程。因此宏DECLARE_WAITQUEUE就是给当前正在运行的进程创建并初始化了一个等待队列项。
3、将队列项添加/移除等待队列头
当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，只有添加到等待队列头中以后进程才能进入休眠态。当设备可以访问以后再将进程对应的等待队列项从等待队列头中移除即可，等待队列项添加API函数如下：
void add_wait_queue(wait_queue_head_t *q,
wait_queue_t *wait)
函数参数和返回值含义如下：
q：等待队列项要加入的等待队列头。
wait：要加入的等待队列项。
返回值：无。
等待队列项移除API函数如下：
void remove_wait_queue(wait_queue_head_t *q,
wait_queue_t *wait)
函数参数和返回值含义如下：
q：要删除的等待队列项所处的等待队列头。
wait：要删除的等待队列项。
返回值：无。
4、等待唤醒
当设备可以使用的时候就要唤醒进入休眠态的进程，唤醒可以使用如下两个函数：
void wake_up(wait_queue_head_t *q)
void wake_up_interruptible(wait_queue_head_t *q)
参数q就是要唤醒的等待队列头，这两个函数会将这个等待队列头中的所有进程都唤醒。wake_up函数可以唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE状态的进程，而wake_up_interruptible函数只能唤醒处于TASK_INTERRUPTIBLE状态的进程。
5、等待事件
除了主动唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒等待队列中的进程，和等待事件有关的API函数如表52.1.2.1所示：
52.1.3 轮询
如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、epoll和select可以用于处理轮询，应用程序通过select、epoll或poll函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用select、epoll或poll函数的时候设备驱动程序中的poll函数就会执行，因此需要在设备驱动程序中编写poll函数。我们先来看一下应用程序中使用的select、poll和epoll这三个函数。
1、select函数
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类型变量的每一个位都代表了一个文件描述符。readfds用于监视指定描述符集的读变化，也就是监视这些文件是否可以读取，只要这些集合里面有一个文件可以读取那么seclect就会返回一个大于0的值表示文件可以读取。如果没有文件可以读取，那么就会根据timeout参数来判断是否超时。可以将readfs设置为NULL，表示不关心任何文件的读变化。writefds和readfs类似，只是writefs用于监视这些文件是否可以进行写操作。exceptfds用于监视这些文件的异常。
比如我们现在要从一个设备文件中读取数据，那么就可以定义一个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就是要判断的文件描述符。
timeout:超时时间，当我们调用select函数等待某些文件描述符可以设置超时时间，超时时间使用结构体timeval表示，结构体定义如下所示：
struct timeval {
long tv_sec; /* 秒 */
long tv_usec; /* 微妙 */
};
当timeout为NULL的时候就表示无限期的等待。
返回值：0，表示的话就表示超时发生，但是没有任何文件描述符可以进行操作；-1，发生错误；其他值，可以进行操作的文件描述符个数。
使用select函数对某个设备驱动文件进行读非阻塞访问的操作示例如下所示：
示例代码52.1.3.1 select函数非阻塞读访问示例
1void main(void)
2{
3 int ret, fd;/* 要监视的文件描述符 */
4 fd_set readfds;/* 读操作文件描述符集 */
5 struct timeval timeout;/* 超时结构体 */
6
7 fd =open("dev_xxx", O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */
8
9 FD_ZERO(&readfds);/* 清除readfds */
10 FD_SET(fd,&readfds);/* 将fd添加到readfds里面 */
11
12 /* 构造超时时间 */
13 timeout.tv_sec =0;
14 timeout.tv_usec =500000;/* 500ms */
15
16 ret =select(fd +1,&readfds,NULL,NULL,&timeout);
17 switch(ret){
18 case0:/* 超时 */
19 printf("timeout!\r\n");
20 break;
21 case-1:/* 错误 */
22 printf("error!\r\n");
23 break;
24 default:/* 可以读取数据 */
25 if(FD_ISSET(fd,&readfds)){/* 判断是否为fd文件描述符 */
26 /* 使用read函数读取数据 */
27 }
28 break;
29 }
30}
2、poll函数
在单个线程中，select函数能够监视的文件描述符数量有最大的限制，一般为1024，可以修改内核将监视的文件描述符数量改大，但是这样会降低效率！这个时候就可以使用poll函数，poll函数本质上和select没有太大的差别，但是poll函数没有最大文件描述符限制，Linux应用程序中poll函数原型如下所示：
int poll(struct pollfd *fds,
nfds_t nfds,
int timeout)
函数参数和返回值含义如下：
fds：要监视的文件描述符集合以及要监视的事件,为一个数组，数组元素都是结构体pollfd类型的，pollfd结构体如下所示：
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 请求的事件 */
short revents; /* 返回的事件 */
};
fd是要监视的文件描述符，如果fd无效的话那么events监视事件也就无效，并且revents返回0。events是要监视的事件，可监视的事件类型如下所示：
POLLIN 有数据可以读取。
POLLPRI 有紧急的数据需要读取。
POLLOUT 可以写数据。
POLLERR 指定的文件描述符发生错误。
POLLHUP 指定的文件描述符挂起。
POLLNVAL 无效的请求。
POLLRDNORM 等同于POLLIN
revents是返回参数，也就是返回的事件，有Linux内核设置具体的返回事件。
nfds：poll函数要监视的文件描述符数量。
timeout：超时时间，单位为ms。
返回值：返回revents域中不为0的pollfd结构体个数，也就是发生事件或错误的文件描述符数量；0，超时；-1，发生错误，并且设置errno为错误类型。
使用poll函数对某个设备驱动文件进行读非阻塞访问的操作示例如下所示：
示例代码52.1.3.2 poll函数读非阻塞访问示例
1void main(void)
2{
3 int ret;
4 int fd;/* 要监视的文件描述符 */
5 struct pollfd fds;
6
7 fd =open(filename, O_RDWR | O_NONBLOCK);/* 非阻塞式访问 */
8
9 /* 构造结构体 */
10 fds.fd =fd;
11 fds.events =POLLIN;/* 监视数据是否可以读取 */
12
13 ret =poll(&fds,1,500); /* 轮询文件是否可操作，超时500ms */
14 if(ret){/* 数据有效 */
15 ......
16 /* 读取数据 */
17 ......
18 }elseif(ret ==0){/* 超时 */
19 ......
20 }elseif(ret <0){/* 错误 */
21 ......
22 }
23}
3、epoll函数
传统的selcet和poll函数都会随着所监听的fd数量的增加，出现效率低下的问题，而且poll函数每次必须遍历所有的描述符来检查就绪的描述符，这个过程很浪费时间。为此，epoll因运而生，epoll就是为处理大并发而准备的，一般常常在网络编程中使用epoll函数。应用程序需要先使用epoll_create函数创建一个epoll句柄，epoll_create函数原型如下：
int epoll_create(int size)
函数参数和返回值含义如下：
size：从Linux2.6.8开始此参数已经没有意义了，随便填写一个大于0的值就可以。
返回值：epoll句柄，如果为-1的话表示创建失败。
epoll句柄创建成功以后使用epoll_ctl函数向其中添加要监视的文件描述符以及监视的事件，epoll_ctl函数原型如下所示：
int epoll_ctl(int epfd,
int op,
int fd,
struct epoll_event *event)
函数参数和返回值含义如下：
epfd：要操作的epoll句柄，也就是使用epoll_create函数创建的epoll句柄。
op：表示要对epfd(epoll句柄)进行的操作，可以设置为：
EPOLL_CTL_ADD 向epfd添加文件参数fd表示的描述符。
EPOLL_CTL_MOD 修改参数fd的event事件。
EPOLL_CTL_DEL 从epfd中删除fd描述符。
fd：要监视的文件描述符。
event：要监视的事件类型，为epoll_event结构体类型指针，epoll_event结构体类型如下所示：
struct epoll_event {
uint32_t events; /* epoll事件 */
epoll_data_t data; /* 用户数据 */
};
结构体epoll_event的events成员变量表示要监视的事件，可选的事件如下所示：
EPOLLIN 有数据可以读取。
EPOLLOUT 可以写数据。
EPOLLPRI 有紧急的数据需要读取。
EPOLLERR 指定的文件描述符发生错误。
EPOLLHUP 指定的文件描述符挂起。
EPOLLET 设置epoll为边沿触发，默认触发模式为水平触发。
EPOLLONESHOT 一次性的监视，当监视完成以后还需要再次监视某个fd，那么就需要将fd重新添加到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，本章我们就使用sellect和poll这两个函数。
52.1.4 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，普通数据可读
我们需要在驱动程序的poll函数中调用poll_wait函数，poll_wait函数不会引起阻塞，只是将应用程序添加到poll_table中，poll_wait函数原型如下：
void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
参数wait_address是要添加到poll_table中的等待队列头，参数p就是poll_table，就是file_operations中poll函数的wait参数。
52.2 阻塞IO实验
在上一章Linux中断实验中，我们直接在应用程序中通过read函数不断的读取按键状态，当按键有效的时候就打印出按键值。这种方法有个缺点，那就是imx6uirqApp这个测试应用程序拥有很高的CPU占用率，大家可以在开发板中加载上一章的驱动程序模块imx6uirq.ko，然后以后台运行模式打开imx6uirqApp这个测试软件，命令如下：
./imx6uirqApp /dev/imx6uirq &
测试驱动是否正常工作，如果驱动工作正常的话输入“top”命令查看imx6uirqApp这个应用程序的CPU使用率，结果如图52.2.1所示：
图52.2.1 CPU使用率
从图52.2.1可以看出，imx6uirqApp这个应用程序的CPU使用率竟然高达99.6%，这仅仅是一个读取按键值的应用程序，这么高的CPU使用率显然是有问题的！原因就在于我们是直接在while循环中通过read函数读取按键值，因此imx6uirqApp这个软件会一直运行，一直读取按键值，CPU使用率肯定就会很高。最好的方法就是在没有有效的按键事件发生的时候，imx6uirqApp这个应用程序应该处于休眠状态，当有按键事件发生以后imx6uirqApp这个应用程序才运行，打印出按键值，这样就会降低CPU使用率，本小节我们就使用阻塞IO来实现此功能。
52.2.1 硬件原理图分析
本章实验硬件原理图参考15.2小节即可。
52.2.2 实验程序编写
1、驱动程序编写
本实验对应的例程路径为：开发板光盘->2、Linux驱动例程->14_blockio。
本章实验我们在上一章的“13_irq”实验的基础上完成，主要是对其添加阻塞访问相关的代码。新建名为“14_blockio”的文件夹，然后在14_blockio文件夹里面创建vscode工程，工作区命名为“blockio”。将“13_irq”实验中的imx6uirq.c复制到14_blockio文件夹中，并重命名为blockio.c。接下来我们就修改blockio.c这个文件，在其中添加阻塞相关的代码，完成以后的blockio.c内容如下所示(因为是在上一章实验的imx6uirq.c文件的基础上修改的，因为了减少篇幅，下面的代码有省略)：
示例代码52.2.2.1 blockio.c文件代码(有省略)
1 #include <linux/types.h>
2 #include <linux/kernel.h>
......
18 #include <asm/mach/map.h>
19 #include <asm/uaccess.h>
20 #include <asm/io.h>
21/***************************************************************
22 Copyright ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
23文件名 : block.c
24作者 : 左忠凯
25版本 : V1.0
26描述 : 阻塞IO访问
27其他 : 无
28论坛 : www.openedv.com
29日志 : 初版V1.0 2019/7/26 左忠凯创建
30 ***************************************************************/
31 #define IMX6UIRQ_CNT 1 /* 设备号个数 */
32 #define IMX6UIRQ_NAME "blockio" /* 名字 */
33 #define KEY0VALUE 0X01 /* KEY0按键值 */
34 #define INVAKEY 0XFF /* 无效的按键值 */
35 #define KEY_NUM 1 /* 按键数量 */
36
37/* 中断IO描述结构体 */
38struct irq_keydesc {
39int gpio;/* gpio */
40int irqnum;/* 中断号 */
41unsignedchar value;/* 按键对应的键值 */
42char name[10];/* 名字 */
43 irqreturn_t (*handler)(int,void*);/* 中断服务函数 */
44};
45
46/* imx6uirq设备结构体 */
47struct imx6uirq_dev{
48 dev_t devid;/* 设备号 */
49struct cdev cdev;/* cdev */
50struct class *class;/* 类 */
51struct device *device;/* 设备 */
52int major;/* 主设备号 */
53int minor;/* 次设备号 */
54struct device_node *nd;/* 设备节点 */
55 atomic_t keyvalue;/* 有效的按键键值 */
56 atomic_t releasekey;/* 标记是否完成一次完成的按键 */
57struct timer_list timer; /* 定义一个定时器*/
58struct irq_keydesc irqkeydesc[KEY_NUM];/* 按键init述数组 */
59unsignedchar curkeynum;/* 当前init按键号 */
60
61 wait_queue_head_t r_wait; /* 读等待队列头 */
62};
63
64struct imx6uirq_dev imx6uirq;/* irq设备 */
65
66/* @description : 中断服务函数，开启定时器
67 * 定时器用于按键消抖。
68 * @param - irq : 中断号
69 * @param - dev_id : 设备结构。
70 * @return : 中断执行结果
71 */
72static irqreturn_t key0_handler(int irq,void*dev_id)
73{
74struct imx6uirq_dev *dev =(struct imx6uirq_dev*)dev_id;
75
76 dev->curkeynum =0;
77 dev->timer.data =(volatilelong)dev_id;
78 mod_timer(&dev->timer,jiffies + msecs_to_jiffies(10));
79returnIRQ_RETVAL(IRQ_HANDLED);
80}
81
82/* @description : 定时器服务函数，用于按键消抖，定时器到了以后
83 * 再次读取按键值，如果按键还是处于按下状态就表示按键有效。
84 * @param - arg : 设备结构变量
85 * @return : 无
86 */
87void timer_function(unsignedlong arg)
88{
89unsignedchar value;
90unsignedchar num;
91struct irq_keydesc *keydesc;
92struct imx6uirq_dev *dev =(struct imx6uirq_dev *)arg;
93
94 num =dev->curkeynum;
95 keydesc =&dev->irqkeydesc[num];
96
97 value =gpio_get_value(keydesc->gpio); /* 读取IO值 */
98if(value ==0){/* 按下按键 */
99 atomic_set(&dev->keyvalue,keydesc->value);
100}
101else{/* 按键松开 */
102 atomic_set(&dev->keyvalue,0x80|keydesc->value);
103 atomic_set(&dev->releasekey,1);
104}
105
106/* 唤醒进程 */
107if(atomic_read(&dev->releasekey)){/* 完成一次按键过程 */
108/* wake_up(&dev->r_wait); */
109 wake_up_interruptible(&dev->r_wait);
110}
111}
112
113/*
114 * @description : 按键IO初始化
115 * @param : 无
116 * @return : 无
117 */
118staticint keyio_init(void)
119{
120unsignedchar i =0;
121char name[10];
122int ret =0;
......
163/* 创建定时器 */
164 init_timer(&imx6uirq.timer);
165 imx6uirq.timer.function =timer_function;
166
167/* 初始化等待队列头 */
168 init_waitqueue_head(&imx6uirq.r_wait);
169return0;
170}
171
172/*
173 * @description : 打开设备
174 * @param – inode : 传递给驱动的inode
175 * @param - filp : 设备文件，file结构体有个叫做private_data的成员变量
176 * 一般在open的时候将private_data指向设备结构体。
177 * @return : 0 成功;其他失败
178 */
179staticint imx6uirq_open(struct inode *inode,struct file *filp)
180{
181 filp->private_data =&imx6uirq;/* 设置私有数据 */
182return0;
183}
184
185/*
186 * @description : 从设备读取数据
187 * @param - filp : 要打开的设备文件(文件描述符)
188 * @param - buf : 返回给用户空间的数据缓冲区
189 * @param - cnt : 要读取的数据长度
190 * @param - offt : 相对于文件首地址的偏移
191 * @return : 读取的字节数，如果为负值，表示读取失败
192 */
193static ssize_t imx6uirq_read(struct file *filp,char __user *buf,
size_t cnt,loff_t *offt)
194{
195int ret =0;
196unsignedchar keyvalue =0;
197unsignedchar releasekey =0;
198struct imx6uirq_dev *dev =(struct imx6uirq_dev *)
filp->private_data;
199
200 #if0
201/* 加入等待队列，等待被唤醒,也就是有按键按下 */
202 ret = wait_event_interruptible(dev->r_wait,
atomic_read(&dev->releasekey));
203if(ret){
204goto wait_error;
205}
206 #endif
207
208 DECLARE_WAITQUEUE(wait, current);/* 定义一个等待队列 */
209if(atomic_read(&dev->releasekey)==0){ /* 没有按键按下 */
210 add_wait_queue(&dev->r_wait,&wait); /*添加到等待队列头 */
211 __set_current_state(TASK_INTERRUPTIBLE);/* 设置任务状态 */
212 schedule(); /* 进行一次任务切换 */
213if(signal_pending(current)){ /* 判断是否为信号引起的唤醒 */
214 ret =-ERESTARTSYS;
215goto wait_error;
216}
217}
218 remove_wait_queue(&dev->r_wait,&wait);/* 唤醒以后将等待队列移除 */
219
220 keyvalue =atomic_read(&dev->keyvalue);
221 releasekey =atomic_read(&dev->releasekey);
......
234return0;
235
236 wait_error:
237 set_current_state(TASK_RUNNING); /* 设置任务为运行态 */
238 remove_wait_queue(&dev->r_wait,&wait); /* 将等待队列移除 */
239returnret;
240
241 data_error:
242return-EINVAL;
243}
244
245/* 设备操作函数 */
246staticstruct file_operations imx6uirq_fops ={
247.owner =THIS_MODULE,
248.open =imx6uirq_open,
249.read =imx6uirq_read,
250};
251
252/*
253 * @description : 驱动入口函数
254 * @param : 无
255 * @return : 无
256 */
257staticint __init imx6uirq_init(void)
258{
259/* 1、构建设备号 */
260if(imx6uirq.major){
261 imx6uirq.devid =MKDEV(imx6uirq.major,0);
262 register_chrdev_region(imx6uirq.devid,IMX6UIRQ_CNT,
IMX6UIRQ_NAME);
263}else{
264 alloc_chrdev_region(&imx6uirq.devid,0,IMX6UIRQ_CNT,
IMX6UIRQ_NAME);
265 imx6uirq.major =MAJOR(imx6uirq.devid);
266 imx6uirq.minor =MINOR(imx6uirq.devid);
267}
......
284
285/* 5、始化按键 */
286 atomic_set(&imx6uirq.keyvalue,INVAKEY);
287 atomic_set(&imx6uirq.releasekey,0);
288 keyio_init();
289return0;
290}
291
292/*
293 * @description : 驱动出口函数
294 * @param : 无
295 * @return : 无
296 */
297staticvoid __exit imx6uirq_exit(void)
298{
299unsigned i =0;
300/* 删除定时器 */
301 del_timer_sync(&imx6uirq.timer);/* 删除定时器 */
......
310 class_destroy(imx6uirq.class);
311}
312
313 module_init(imx6uirq_init);
314 module_exit(imx6uirq_exit);
315 MODULE_LICENSE("GPL");
第32行，修改设备文件名字为“blockio”，当驱动程序加载成功以后就会在根文件系统中出现一个名为“/dev/blockio”的文件。
第61行，在设备结构体中添加一个等待队列头r_wait，因为在Linux驱动中处理阻塞IO需要用到等待队列。
第107~110行，定时器中断处理函数执行，表示有按键按下，先在107行判断一下是否是一次有效的按键，如果是的话就通过wake_up或者wake_up_interruptible函数来唤醒等待队列r_wait。
第168行，调用init_waitqueue_head函数初始化等待队列头r_wait。
第200~206行，采用等待事件来处理read的阻塞访问，wait_event_interruptible函数等待releasekey有效，也就是有按键按下。如果按键没有按下的话进程就会进入休眠状态，因为采用了wait_event_interruptible函数，因此进入休眠态的进程可以被信号打断。
第208~218行，首先使用 DECLARE_WAITQUEUE宏定义一个等待队列，如果没有按键按下的话就使用add_wait_queue函数将当前任务的等待队列添加到等待队列头r_wait中。随后调用__set_current_state函数设置当前进程的状态为TASK_INTERRUPTIBLE，也就是可以被信号打断。接下来调用schedule函数进行一次任务切换，当前进程就会进入到休眠态。如果有按键按下，那么进入休眠态的进程就会唤醒，然后接着从休眠点开始运行。在这里也就是从第213行开始运行，首先通过signal_pending函数判断一下进程是不是由信号唤醒的，如果是由信号唤醒的话就直接返回-ERESTARTSYS这个错误码。如果不是由信号唤醒的(也就是被按键唤醒的)那么就在218行调用remove_wait_queue函数将进程从等待队列中删除。
使用等待队列实现阻塞访问重点注意两点：
①、将任务或者进程加入到等待队列头，
②、在合适的点唤醒等待队列，一般都是中断处理函数里面。
2、编写测试APP
本节实验的测试APP直接使用第51.3.3小节所编写的imx6uirqApp.c，将imx6uirqApp.c复制到本节实验文件夹下，并且重命名为blockioApp.c，不需要修改任何内容。
52.2.3 运行测试
1、编译驱动程序和测试APP
①、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为blockio.o，Makefile内容如下所示：
示例代码52.2.3.1 Makefile文件
1 KERNELDIR:=/home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
......
4 obj-m := blockio.o
......
11 clean:
12$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第4行，设置obj-m变量的值为blockio.o。
输入如下命令编译出驱动模块文件：
make-j32
编译成功以后就会生成一个名为“blockio.ko”的驱动模块文件。
②、编译测试APP
输入如下命令编译测试noblockioApp.c这个测试程序：
arm-linux-gnueabihf-gcc blockioApp.c -o blockioApp
编译成功以后就会生成blcokioApp这个应用程序。
2、运行测试
将上一小节编译出来blockio.ko和blockioApp这两个文件拷贝到rootfs/lib/modules/4.1.15目录中，重启开发板，进入到目录lib/modules/4.1.15中，输入如下命令加载blockio.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe blockio.ko //加载驱动
驱动加载成功以后使用如下命令打开blockioApp这个测试APP，并且以后台模式运行：
./blockioApp /dev/blockio &
按下开发板上的KEY0按键，结果如图52.2.3.1所示：
图52.2.3.1 测试APP运行测试
当按下KEY0按键以后blockioApp这个测试APP就会打印出按键值。输入“top”命令，查看blockioAPP这个应用APP的CPU使用率，如图52.2.3.2所示：
图52.2.3.2 应用程序CPU使用率
从图52.2.3.2可以看出，当我们在按键驱动程序里面加入阻塞访问以后，blockioApp这个应用程序的CPU使用率从图52.2.1中的99.6%降低到了0.0%。大家注意，这里的0.0%并不是说blockioApp这个应用程序不使用CPU了，只是因为使用率太小了，CPU使用率可能为0.00001%，但是图52.2.3.2只能显示出小数点后一位，因此就显示成了0.0%。
我们可以使用“kill”命令关闭后台运行的应用程序，比如我们关闭掉blockioApp这个后台运行的应用程序。首先输出“Ctrl+C”关闭top命令界面，进入到命令行模式。然后使用“ps”命令查看一下blockioApp这个应用程序的PID，如图52.2.3.3所示：
图52.2.3.3 当前系统所有进程的ID
从图图52.2.3.3可以看出，blockioApp这个应用程序的PID为149，使用“kill-9PID”即可“杀死”指定PID的进程，比如我们现在要“杀死”PID为149的blockioApp应用程序，可是使用如下命令：
kill-9 149
输入上述命令以后终端显示如图52.2.3.4所示：
图52.2.3.4 kill命令输出结果
从图52.2.3.4可以看出，“./blockioApp /dev/blockio”这个应用程序已经被“杀掉”了，在此输入“ps”命令查看当前系统运行的进程，会发现blockioApp已经不见了。这个就是使用kill命令“杀掉”指定进程的方法。
52.3 非阻塞IO实验
52.3.1 硬件原理图分析
本章实验硬件原理图参考15.2小节即可。
52.3.2 实验程序编写
1、驱动程序编写
本实验对应的例程路径为：开发板光盘->2、Linux驱动例程->15_noblockio。
本章实验我们在52.2小节中的“14_blockio”实验的基础上完成，上一小节实验我们已经在驱动中添加了阻塞IO的代码，本小节我们继续完善驱动，加入非阻塞IO驱动代码。新建名为“15_noblockio”的文件夹，然后在15_noblockio文件夹里面创建vscode工程，工作区命名为“noblockio”。将“14_blockio”实验中的blockio.c复制到15_noblockio文件夹中，并重命名为noblockio.c。接下来我们就修改noblockio.c这个文件，在其中添加非阻塞相关的代码，完成以后的noblockio.c内容如下所示(因为是在上一小节实验的blockio.c文件的基础上修改的，因为了减少篇幅，下面的代码有省略)：
示例代码52.3.3.1 noblockio.c文件(有省略)
1 #include <linux/types.h>
2 #include <linux/kernel.h>
......
18 #include <linux/wait.h>
19 #include <linux/poll.h>
20 #include <asm/mach/map.h>
21 #include <asm/uaccess.h>
22 #include <asm/io.h>
23/***************************************************************
24 Copyright ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
25文件名 : noblock.c
26 作者 : 左忠凯
27版本 : V1.0
28描述 : 非阻塞IO访问
29其他 : 无
30论坛 : www.openedv.com
31日志 : 初版V1.0 2019/7/26 左忠凯创建
32 ***************************************************************/
31 #define IMX6UIRQ_CNT 1 /* 设备号个数 */
32 #define IMX6UIRQ_NAME "noblockio" /* 名字 */
......
187/*
188 * @description : 从设备读取数据
189 * @param - filp : 要打开的设备文件(文件描述符)
190 * @param - buf : 返回给用户空间的数据缓冲区
191 * @param - cnt : 要读取的数据长度
192 * @param - offt : 相对于文件首地址的偏移
193 * @return : 读取的字节数，如果为负值，表示读取失败
194 */
195static ssize_t imx6uirq_read(struct file *filp,char __user *buf,
size_t cnt,loff_t *offt)
196{
197int ret =0;
198unsignedchar keyvalue =0;
199unsignedchar releasekey =0;
200struct imx6uirq_dev *dev =(struct imx6uirq_dev *)
filp->private_data;
201
202if(filp->f_flags & O_NONBLOCK){ /* 非阻塞访问 */
203if(atomic_read(&dev->releasekey)==0) /* 没有按键按下*/
204return-EAGAIN;
205}else{/* 阻塞访问 */
206/* 加入等待队列，等待被唤醒,也就是有按键按下 */
207 ret =wait_event_interruptible(dev->r_wait,
atomic_read(&dev->releasekey));
208if(ret){
209gotowait_error;
210}
211}
......
229 wait_error:
230returnret;
231 data_error:
232return-EINVAL;
233}
234
235/*
236 * @description : poll函数，用于处理非阻塞访问
237 * @param - filp : 要打开的设备文件(文件描述符)
238 * @param - wait : 等待列表(poll_table)
239 * @return : 设备或者资源状态，
240 */
241unsignedint imx6uirq_poll(struct file *filp,
struct poll_table_struct *wait)
242{
243unsignedint mask =0;
244struct imx6uirq_dev *dev =(struct imx6uirq_dev *)
filp->private_data;
245
246 poll_wait(filp,&dev->r_wait, wait);
247
248if(atomic_read(&dev->releasekey)){ /* 按键按下 */
249 mask = POLLIN | POLLRDNORM; /* 返回PLLIN */
250}
251return mask;
252}
253
254/* 设备操作函数 */
255staticstruct file_operations imx6uirq_fops ={
256.owner =THIS_MODULE,
257.open =imx6uirq_open,
258.read =imx6uirq_read,
259.poll = imx6uirq_poll,
260};
261
262/*
263 * @description : 驱动入口函数
264 * @param : 无
265 * @return : 无
266 */
267staticint __init imx6uirq_init(void)
268{
......
298 keyio_init();
299return0;
300}
301
302/*
303 * @description : 驱动出口函数
304 * @param : 无
305 * @return : 无
306 */
307staticvoid __exit imx6uirq_exit(void)
308{
309unsigned i =0;
310/* 删除定时器 */
311 del_timer_sync(&imx6uirq.timer);/* 删除定时器 */
......
320 class_destroy(imx6uirq.class);
321}
322
323 module_init(imx6uirq_init);
324 module_exit(imx6uirq_exit);
325 MODULE_LICENSE("GPL");
第32行，修改设备文件名字为“noblockio”，当驱动程序加载成功以后就会在根文件系统中出现一个名为“/dev/noblockio”的文件。
第202~204行，判断是否为非阻塞式读取访问，如果是的话就判断按键是否有效，也就是判断一下有没有按键按下，如果没有的话就返回-EAGAIN。
第241~252行，imx6uirq_poll函数就是file_operations驱动操作集中的poll函数，当应用程序调用select或者poll函数的时候imx6uirq_poll函数就会执行。第246行调用poll_wait函数将等待队列头添加到poll_table中，第248~250行判断按键是否有效，如果按键有效的话就向应用程序返回POLLIN这个事件，表示有数据可以读取。
第259行，设置file_operations的poll成员变量为imx6uirq_poll。
2、编写测试APP
新建名为noblockioApp.c测试APP文件，然后在其中输入如下所示内容：
示例代码52.3.3.2 noblockioApp.c文件代码
1 #include "stdio.h"
2 #include "unistd.h"
3 #include "sys/types.h"
4 #include "sys/stat.h"
5 #include "fcntl.h"
6 #include "stdlib.h"
7 #include "string.h"
8 #include "poll.h"
9 #include "sys/select.h"
10 #include "sys/time.h"
11 #include "linux/ioctl.h"
12/***************************************************************
13 Copyright ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
14文件名 : noblockApp.c
15作者 : 左忠凯
16版本 : V1.0
17描述 : 非阻塞访问测试APP
18其他 : 无
19使用方法 ：./blockApp /dev/blockio 打开测试App
20论坛 : www.openedv.com
21日志 : 初版V1.0 2019/9/8 左忠凯创建
22 ***************************************************************/
23
24/*
25 * @description : main主程序
26 * @param - argc : argv数组元素个数
27 * @param - argv : 具体参数
28 * @return : 0 成功;其他失败
29 */
30int main(int argc,char*argv[])
31{
32int fd;
33int ret =0;
34char*filename;
35struct pollfd fds;
36 fd_set readfds;
37struct timeval timeout;
38unsignedchar data;
39
40if(argc !=2){
41 printf("Error Usage!\r\n");
42return-1;
43}
44
45 filename =argv[1];
46 fd =open(filename, O_RDWR | O_NONBLOCK);/* 非阻塞访问 */
47if(fd <0){
48 printf("Can't open file %s\r\n",filename);
49return-1;
50}
51
52 #if0
53/* 构造结构体 */
54 fds.fd =fd;
55 fds.events =POLLIN;
56
57while(1){
58 ret =poll(&fds,1,500);
59if(ret){/* 数据有效 */
60 ret =read(fd,&data,sizeof(data));
61if(ret <0){
62/* 读取错误 */
63}else{
64if(data)
65 printf("key value = %d \r\n",data);
66}
67}elseif(ret ==0){/* 超时 */
68/* 用户自定义超时处理 */
69}elseif(ret <0){/* 错误 */
70/* 用户自定义错误处理 */
71}
72}
73 #endif
74
75while(1){
76 FD_ZERO(&readfds);
77 FD_SET(fd,&readfds);
78/* 构造超时时间 */
79 timeout.tv_sec =0;
80 timeout.tv_usec =500000;/* 500ms */
81 ret =select(fd +1,&readfds,NULL,NULL,&timeout);
82switch(ret){
83case0:/* 超时 */
84/* 用户自定义超时处理 */
85break;
86case-1:/* 错误 */
87/* 用户自定义错误处理 */
88break;
89default:/* 可以读取数据 */
90if(FD_ISSET(fd,&readfds)){
91 ret =read(fd,&data,sizeof(data));
92if(ret <0){
93/* 读取错误 */
94}else{
95if(data)
96 printf("key value=%d\r\n",data);
97}
98}
99break;
100}
101}
102
103 close(fd);
104returnret;
105}
第52~73行，这段代码使用poll函数来实现非阻塞访问，在while循环中使用poll函数不断的轮询，检查驱动程序是否有数据可以读取，如果可以读取的话就调用read函数读取按键数据。
第75~101行，这段代码使用select函数来实现非阻塞访问。
52.3.3运行测试
1、编译驱动程序和测试APP
①、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为noblockio.o，Makefile内容如下所示：
示例代码52.3.3.1 Makefile文件
1 KERNELDIR:=/home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
......
4 obj-m := noblockio.o
......
11 clean:
12$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第4行，设置obj-m变量的值为noblockio.o。
输入如下命令编译出驱动模块文件：
make-j32
编译成功以后就会生成一个名为“noblockio.ko”的驱动模块文件。
②、编译测试APP
输入如下命令编译测试noblockioApp.c这个测试程序：
arm-linux-gnueabihf-gcc noblockioApp.c -o noblockioApp
编译成功以后就会生成noblcokioApp这个应用程序。
2、运行测试
将上一小节编译出来noblockio.ko和noblockioApp这两个文件拷贝到rootfs/lib/modules/4.1.15目录中，重启开发板，进入到目录lib/modules/4.1.15中，输入如下命令加载blockio.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe noblockio.ko //加载驱动
驱动加载成功以后使用如下命令打开noblockioApp这个测试APP，并且以后台模式运行：
./noblockioApp /dev/noblockio &
按下开发板上的KEY0按键，结果如图52.3.3.1所示：
图52.3.3.1 测试APP运行测试
当按下KEY0按键以后noblockioApp这个测试APP就会打印出按键值。输入“top”命令，查看noblockioAPP这个应用APP的CPU使用率，如图52.3.3.2所示：
图52.3.3.2 应用程序CPU使用率
从图52.3.3.2可以看出，采用非阻塞方式读处理以后，noblockioApp的CPU占用率也低至0.0%，和图52.2.3.2中的blockioApp一样，这里的0.0%并不是说noblockioApp这个应用程序不使用CPU了，只是因为使用率太小了，而图中只能显示出小数点后一位，因此就显示成了0.0%。
如果要“杀掉”处于后台运行模式的noblockioApp这个应用程序，可以参考52.2.3小节讲解的方法。
等待队列（waitqueue）实现机制
源码基于：Linux5.10
0. 前言
等待队列（waitqueue） 这个机制在Linux 内核中使用的频率很高，与进程调度机制紧密相关联，可以用来同步对系统资源的访问、异步事件通知、跨进程通信等。网上关于等待队列使用的优秀文章也很多，之所以笔者也写一篇，一是想更新下最新代码中的使用，二是融入些自己的拙见，方便自己回头查看，也希望能有助于后来读者。
1. 原理
引用网上一个专家的一句话：
A "wait queue" in the Linux kernel is a data structure to manage threads that are waiting for some condition to become true;
笔者个人觉得还是这句话概括的挺好。等待队列就是一个数据结构，该数据结构用来管理那些正在等待某个condition 变成true 的进程。
等待队列用 wait_queue_head_t 这个数据结构串联、管理所有正在等待的进程，每一次等待都会创建一个 wait_queue_entry_t，用该数据结构来更细致管理每个进程：
- private：存放每个正在等待的进程 task_struct 的结构体指针；
- flags：用以指定该进程处于什么等待属性；
- func：当该进程被唤醒时，执行一个特殊的回调函数；
本文将结合该图，细致剖析：
- 等待队列的创建过程；
- 每个进程的等待过程；
- 等待队列中每个等待的唤醒过程；
1. waitqueue的基本概念
1.1 waitqueue 的数据结构
include/linux/wait.h
struct wait_queue_entry {
unsigned int flags; //该entry的属性
void *private; //该entry与进程绑定，存放该进程的task_struct指针
wait_queue_func_t func; //回调函数，当等待队列被唤醒时的回调函数
struct list_head entry;
};
struct wait_queue_head {
spinlock_t lock; //等待队列的自旋锁，用以同步整个等待队列
struct list_head head; //等待队列的头，用以串联整个等待队列
};
typedef struct wait_queue_head wait_queue_head_t;
typedef struct wait_queue_entry wait_queue_entry_t;
下面来看下等待队列 entry 的flags：
include/linux/wait.h
#define WQ_FLAG_EXCLUSIVE 0x01
#define WQ_FLAG_WOKEN 0x02
#define WQ_FLAG_BOOKMARK 0x04
#define WQ_FLAG_CUSTOM 0x08
#define WQ_FLAG_DONE 0x10下面来看下等待队列 entry 的回调函数：
typedef int (*wait_queue_func_t)(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key);
int default_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key);
第一行，指定等待队列回调函数的函数指针类型 wait_queue_func_t；
第二行，指定系统默认的唤醒回调函数 default_wake_function()；
1.2 等待队列的创建和初始化
include/linux/wait.h
#define init_waitqueue_head(wq_head) \
do { \
static struct lock_class_key __key; \
\
__init_waitqueue_head((wq_head), #wq_head, &__key); \
} while (0)
kernel/sched/wait.c
void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *key)
{
spin_lock_init(&wq_head->lock);
lockdep_set_class_and_name(&wq_head->lock, key, name);
INIT_LIST_HEAD(&wq_head->head);
}
EXPORT_SYMBOL(__init_waitqueue_head);
等待队列的名称为：传入 init_waitqueue_head() 的变量名 (字符串化)；
另外，也可以使用宏 DECLARE_WAIT_QUEUE_HEAD() 进行创建和初始化：
include/linux/wait.h
#define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \
.lock = __SPIN_LOCK_UNLOCKED(name.lock), \
.head = { &(name).head, &(name).head } }
#define DECLARE_WAIT_QUEUE_HEAD(name) \
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
1.3 等待队列 entry 的创建和初始化
1.3.1 使用DECLARE_WAITQUEUE()创建
include/linux/wait.h
#define __WAITQUEUE_INITIALIZER(name, tsk) { \
.private = tsk, \
.func = default_wake_function, \
.entry = { NULL, NULL } }
#define DECLARE_WAITQUEUE(name, tsk) \
struct wait_queue_entry name = __WAITQUEUE_INITIALIZER(name, tsk)
注意，此种创建的进程是传入的 tsk，另外，唤醒时的回调函数是default_wake_function()
1.3.2 使用DEFINE_WAIT() 创建
include/linux/wait.h
#define DEFINE_WAIT_FUNC(name, function) \
struct wait_queue_entry name = { \
.private = current, \
.func = function, \
.entry = LIST_HEAD_INIT((name).entry), \
}
#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
注意，此种创建的进程是当前进程，另外，唤醒时的回调函数是autoremove_wake_function()
1.3.3 使用init_wait() 初始化
include/linux/wait.h
#define init_wait(wait) \
do { \
(wait)->private = current; \
(wait)->func = autoremove_wake_function; \
INIT_LIST_HEAD(&(wait)->entry); \
(wait)->flags = 0; \
} while (0)
也可以init_wait() 对定义好的 wait_queue_entry_t 指针 进行初始化。
该entry 绑定的是当前进程，另外，唤醒时的回调函数是autoremove_wake_function()
1.3.4 在___wait_event()时使用init_wait_entry() 初始化
kernel/sched/wait.c
void init_wait_entry(struct wait_queue_entry *wq_entry, int flags)
{
wq_entry->flags = flags;
wq_entry->private = current;
wq_entry->func = autoremove_wake_function;
INIT_LIST_HEAD(&wq_entry->entry);
}
EXPORT_SYMBOL(init_wait_entry);
与 init_wait() 区别是多了一个 flags 参数。
详细的可以查看下文的 __wait_event() 函数和wake_up() 函数。
1.4 添加和移除等待队列
1.4.1 添加到等待队列
include/linux/wait.h
static inline void __add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
{
list_add(&wq_entry->entry, &wq_head->head);
}
static inline void
__add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
{
wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
__add_wait_queue(wq_head, wq_entry);
}
前插到等待队列中，__add_wait_queue_exclusive() 将要插入的entry 指定为 EXCLUSIVE 属性。
include/linux/wait.h
static inline void __add_wait_queue_entry_tail(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
{
list_add_tail(&wq_entry->entry, &wq_head->head);
}
static inline void
__add_wait_queue_entry_tail_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
{
wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
__add_wait_queue_entry_tail(wq_head, wq_entry);
}后插到等待队列中，__add_wait_queue_entry_tail_exclusive() 将要插入的entry 指定为 EXCLUSIVE 属性。
注意：
对于使用 ___wait_event() 创建的 entry，如果是 EXCLUSIVE 属性，该entry 会被插入到等待队列的尾部，其他属性的entry 将选择前插。
1.4.2 等待队列的移除
include/linux/wait.h
static inline void
__remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
{
list_del(&wq_entry->entry);
}
直接就是调用 list_del() 将指定的 entry 从等待队列中移除。
2. wait event
在上一节中已经讲述了等待队列的基本概念，包括wait_queue_head 和 wait_queue_entry 的创建和初始化。
在初始化结束，会在某个进程中指定一个等待事件，用以阻塞等待唤醒，当 condition 成立时退出此次等待事件。
等待事件的接口有很多，我们接下来分批来看。
2.1 UNINTERRUPTIBLE 等待事件
2.1.1 __wait_event()
#define __wait_event(wq_head, condition) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
schedule())
2.1.2 __io_wait_event()
#define __io_wait_event(wq_head, condition) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
io_schedule())
2.1.3 __wait_event_timeout()
#define __wait_event_timeout(wq_head, condition, timeout) \
___wait_event(wq_head, ___wait_cond_timeout(condition), \
TASK_UNINTERRUPTIBLE, 0, timeout, \
__ret = schedule_timeout(__ret))
2.1.4 __wait_event_exclusive_cmd()
#define __wait_event_exclusive_cmd(wq_head, condition, cmd1, cmd2) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 1, 0, \
cmd1; schedule(); cmd2)
2.1.5 __wait_event_cmd()
#define __wait_event_cmd(wq_head, condition, cmd1, cmd2) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
cmd1; schedule(); cmd2)
2.1.6 __wait_event_lock_irq()
#define __wait_event_lock_irq(wq_head, condition, lock, cmd) \
(void)___wait_event(wq_head, condition, TASK_UNINTERRUPTIBLE, 0, 0, \
spin_unlock_irq(&lock); \
cmd; \
schedule(); \
spin_lock_irq(&lock))
注意：
除了 __ion_wait_event() 这个等待事件使用的是 io_schedule()，其他等待事件都是使用 schedule() 函数使得当前进程让出调度，进入休眠状态。
2.2 INTERRUPTIBLE 等待事件
2.2.1 __wait_event_freezable()
#define __wait_event_freezable(wq_head, condition) \
___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \
freezable_schedule())
2.2.2 __wait_event_freezable_timeout()
#define __wait_event_freezable_timeout(wq_head, condition, timeout) \
___wait_event(wq_head, ___wait_cond_timeout(condition), \
TASK_INTERRUPTIBLE, 0, timeout, \
__ret = freezable_schedule_timeout(__ret))
2.2.3 __wait_event_freezable_exclusive()
#define __wait_event_freezable_exclusive(wq, condition) \
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0, \
freezable_schedule())
2.2.4 __wait_event_interruptible()
#define __wait_event_interruptible(wq_head, condition) \
___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \
schedule())
2.2.5 __wait_event_interruptible_timeout()
#define __wait_event_interruptible_timeout(wq_head, condition, timeout) \
___wait_event(wq_head, ___wait_cond_timeout(condition), \
TASK_INTERRUPTIBLE, 0, timeout, \
__ret = schedule_timeout(__ret))
2.2.6 __wait_event_interruptible_exclusive()
#define __wait_event_interruptible_exclusive(wq, condition) \
___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0, \
schedule())
2.2.7 __wait_event_interruptible_lock_irq()
#define __wait_event_interruptible_lock_irq(wq_head, condition, lock, cmd) \
___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0, \
spin_unlock_irq(&lock); \
cmd; \
schedule(); \
spin_lock_irq(&lock))
2.3 KILLABLE 等待事件
2.3.1 __wait_event_killable()
#define __wait_event_killable(wq, condition) \
___wait_event(wq, condition, TASK_KILLABLE, 0, 0, schedule())
2.3.2 __wait_event_killable_exclusive()
#define __wait_event_killable_exclusive(wq, condition) \
___wait_event(wq, condition, TASK_KILLABLE, 1, 0, \
schedule())
2.3.3 __wait_event_killable_timeout()
#define __wait_event_killable_timeout(wq_head, condition, timeout) \
___wait_event(wq_head, ___wait_cond_timeout(condition), \
TASK_KILLABLE, 0, timeout, \
__ret = schedule_timeout(__ret))
2.4 IDLE 等待事件
2.4.1 wait_event_idle()
#define wait_event_idle(wq_head, condition) \
do { \
might_sleep(); \
if (!(condition)) \
___wait_event(wq_head, condition, TASK_IDLE, 0, 0, schedule()); \
} while (0)
2.4.2 wait_event_idle_exclusive()
#define wait_event_idle_exclusive(wq_head, condition) \
do { \
might_sleep(); \
if (!(condition)) \
___wait_event(wq_head, condition, TASK_IDLE, 1, 0, schedule()); \
} while (0)
2.4.3 __wait_event_idle_timeout()
#define __wait_event_idle_timeout(wq_head, condition, timeout) \
___wait_event(wq_head, ___wait_cond_timeout(condition), \
TASK_IDLE, 0, timeout, \
__ret = schedule_timeout(__ret))
2.4.4 __wait_event_idle_exclusive_timeout()
#define __wait_event_idle_exclusive_timeout(wq_head, condition, timeout) \
___wait_event(wq_head, ___wait_cond_timeout(condition), \
TASK_IDLE, 1, timeout, \
__ret = schedule_timeout(__ret))
2.5 ___wait_event()
对于不同状态的等待事件上面已经列举了，最终调用的都是 ___wait_event()，注意函数名是三个下划线：
include/linux/wait.h
#define ___wait_event(wq_head, condition, state, exclusive, ret, cmd) \
({ \
__label__ __out; \
struct wait_queue_entry __wq_entry; \
long __ret = ret; /* explicit shadow */ \
\
init_wait_entry(&__wq_entry, exclusive ? WQ_FLAG_EXCLUSIVE : 0); \
for (;;) { \
long __int = prepare_to_wait_event(&wq_head, &__wq_entry, state);\
\
if (condition) \
break; \
\
if (___wait_is_interruptible(state) && __int) { \
__ret = __int; \
goto __out; \
} \
\
cmd; \
} \
finish_wait(&wq_head, &__wq_entry); \
__out: __ret; \
})参数：
wq_head：wait_queue_head_t 变量，为什么不使用指针呢？
condition：退出等待的条件，只有为true 时才能退出等待 (__wait_event 函数是个死循环)；
state：用以等待的 task 状态；
exclusive：标记是否是独占等待；
ret：一般用于有 timeout时，会将其临时存放在 __ret 中，在cmd 中作为参数带入；
cmd：一般是 schedule() 函数或者 schedule_timeout() 函数；
注意其中的 condition 参数，当等待事件中存在 timeout 时，该参数一般会是 ___wait_cond_timeout(condition)：
#define ___wait_cond_timeout(condition) \
({ \
bool __cond = (condition); \
if (__cond && !__ret) \
__ret = 1; \
__cond || !__ret; \
})
即，当condition 为true 或者是 timeout 到时了，___wait_event() 的condition 才为 true。
另外，___wait_event() 是个死循环，只有当condition 为true，或者当前进程收到 SIGKILL 信号时，才会退出该死循环。
2.5.1 init_wait_entry()
struct wait_queue_entry __wq_entry;
init_wait_entry(&__wq_entry, exclusive ? WQ_FLAG_EXCLUSIVE : 0);
当调用 ___wait_event() 时，会创建一个 wait_queue_entry 变量，并调用 init_wait_entry() 对其进行初始化，其中第二个参数 flags 根据 ___wait_event() 的入参 exclusive 决定；
2.5.2 prepare_to_wait_event()
kernel/sched/wait.c
long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
{
unsigned long flags;
long ret = 0;
spin_lock_irqsave(&wq_head->lock, flags);
if (signal_pending_state(state, current)) {
/*
* Exclusive waiter must not fail if it was selected by wakeup,
* it should "consume" the condition we were waiting for.
*
* The caller will recheck the condition and return success if
* we were already woken up, we can not miss the event because
* wakeup locks/unlocks the same wq_head->lock.
*
* But we need to ensure that set-condition + wakeup after that
* can't see us, it should wake up another exclusive waiter if
* we fail.
*/
list_del_init(&wq_entry->entry);
ret = -ERESTARTSYS;
} else {
if (list_empty(&wq_entry->entry)) {
if (wq_entry->flags & WQ_FLAG_EXCLUSIVE)
__add_wait_queue_entry_tail(wq_head, wq_entry);
else
__add_wait_queue(wq_head, wq_entry);
}
set_current_state(state);
}
spin_unlock_irqrestore(&wq_head->lock, flags);
return ret;
}
EXPORT_SYMBOL(prepare_to_wait_event);每次在等待事件进入shedule 之前，会调用 signal_pending_state() 确定进程是否立即返回 RUNNING 状态：
如果不允许信号处理，返回0，表示不需要返回；
如果允许信号处理，但该进程中没有信号等待处理，也表示不需要返回；
除此，如果是 TASK_INTERRUPTIBLE 或当前进程可以处理信号且收到了 SIGKILL，则需要立即返回RUNNING 状态；
include/linux/sched/signal.h
static inline int signal_pending_state(long state, struct task_struct *p)
{
//是否允许信号处理，不允许返回0
if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
return 0;
//当允许信号处理时，确定当前进程是否有信号挂起，如果没有返回0
if (!signal_pending(p))
return 0;
return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
}
回到 prepare_to_wait_event() 函数，如果 signal_pending_state() 需要进程立即返回 RUNNING 状态，则认为此次等待事件无效，立即退出此次等待。
如果不需要返回 RUNNING，则会将此次的等待队列 entry 添加到等待队列中。不过需要注意的是，对于 exclusive 属性的entry，会将其添加到等待队列的尾部，其他属性的 entry 添加到等待队列的头部。
prepare_to_wait_event() 函数的最后会调用 set_current_state() 将进程状态标记上。
2.5.3 执行 cmd
cmd 是 ___wait_event() 的最后一个参数，可能是：
schedule()
io_schedule()
schedule_timeout()
freezable_schedule()
freezable_schedule_timeout()
cmd1; schedule(); cmd2
详细可以查看 include/linux/wait.h 文件中调用 ___wait_event() 的地方。
2.5.4 finish_wait()
当退出等待事件需要退出时，在 ___wait_event() 的最后会调用 finish_wait() 函数：
kernel/sched/wait.c
void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
{
unsigned long flags;
__set_current_state(TASK_RUNNING);
/*
* We can check for list emptiness outside the lock
* IFF:
* - we use the "careful" check that verifies both
* the next and prev pointers, so that there cannot
* be any half-pending updates in progress on other
* CPU's that we haven't seen yet (and that might
* still change the stack area.
* and
* - all other users take the lock (ie we can only
* have _one_ other CPU that looks at or modifies
* the list).
*/
if (!list_empty_careful(&wq_entry->entry)) {
spin_lock_irqsave(&wq_head->lock, flags);
list_del_init(&wq_entry->entry);
spin_unlock_irqrestore(&wq_head->lock, flags);
}
}
EXPORT_SYMBOL(finish_wait);
主要做了两件事情：
将进程状态改成 RUNNING；
确定该 entry是否还在等待队列中，如果还在队列中，将其从等待队列中移除；
2.6 总结
等待队列的wait event 有很多种，按照进程将要进入的状态分为：
INTERRUPTIBLE 等待事件；
UNINTERRUPTIBLE 等待事件；
KILLABLE 等待事件；
IDLE 等待事件；
所有等待事件最终会调用 ___wait_event() 函数；
首先会创建一个 entry，并调用 init_wait_entry() 进行初始化；
进入死循环，直到condition 为true 或进程允许信号中断并收到了 SIGKILL 信号；
___wait_event() 中会调用最后一个参数 cmd，通常是利用 schedule() 交出调度后进入休眠；
当被唤醒后会确定当前进程状态或condition，进而判断是否退出死循环；
当___wait_event() 中退出死循环后，会调用 finish_wait() 将进程状态改为 RUNNING，并将此次的 entry 从等待队列中删除；
3. wake up
3.1 wake_up TASK_NORMAL
include/linux/wait.h
#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
#define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
#define wake_up_locked(x) __wake_up_locked((x), TASK_NORMAL, 1)
#define wake_up_all_locked(x) __wake_up_locked((x), TASK_NORMAL, 0)
有三点注意：
wake_up 不携带interruptible 的接口，指的是唤醒 TASK_NORMAL 状态的进程，而TASK_NORMAL 表示的是 (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)；
wake_up 最终调用的有两个接口：__wake_up() 和 __wake_up_locked()，区别在于 __wake_up_locked() 的调用是已经在等待队列的自旋锁中了，不需要再加锁，最终实现都需要调用 __wake_up_common() 函数；
wake_up 中有个nr 的参数，用以决定唤醒几个等待的 exclusive entry；
3.2 wake_up INTERRUNPTIBLE
include/linux/wait.h
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
#define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
#define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
#define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE)
3.3 __wake_up()
kernel/sched/wait.c
void __wake_up(struct wait_queue_head *wq_head, unsigned int mode,
int nr_exclusive, void *key)
{
__wake_up_common_lock(wq_head, mode, nr_exclusive, 0, key);
}
EXPORT_SYMBOL(__wake_up);
static void __wake_up_common_lock(struct wait_queue_head *wq_head, unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
unsigned long flags;
wait_queue_entry_t bookmark;
bookmark.flags = 0;
bookmark.private = NULL;
bookmark.func = NULL;
INIT_LIST_HEAD(&bookmark.entry);
do {
spin_lock_irqsave(&wq_head->lock, flags);
nr_exclusive = __wake_up_common(wq_head, mode, nr_exclusive,
wake_flags, key, &bookmark);
spin_unlock_irqrestore(&wq_head->lock, flags);
} while (bookmark.flags & WQ_FLAG_BOOKMARK);
}
函数流程比较清晰：
定义了一个 bootmark，用以串联还需要再处理的 entry；
调用 __wake_up_common() 进行实际的唤醒操作；
注意：
这里引入了一个 bookmark，是为了 __wake_up_common() 进去后唤醒的 entry 过多而导致自旋锁持有时间太长。当唤醒的 entry 超过 WAITQUEUE_WALK_BREAK_CNT (默认64) 时，将后面的 entry 放到bookmark 尾部并退出 __wake_up_common() 函数。通过这种机制，实现了进程分批次唤醒，避免了等待队列中自旋锁被持有时间过长
下面单独来看下 __wake_up_common() 的处理：
3.4 __wake_up_common()
kernel/sched/wait.c
static int __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
int nr_exclusive, int wake_flags, void *key,
wait_queue_entry_t *bookmark)
{
wait_queue_entry_t *curr, *next;
int cnt = 0;
// 判断自旋锁已经被持有
lockdep_assert_held(&wq_head->lock);
//如果是再处理的entry，找到第一个entry，并初重新初始化bootmark
if (bookmark && (bookmark->flags & WQ_FLAG_BOOKMARK)) {
curr = list_next_entry(bookmark, entry);
list_del(&bookmark->entry);
bookmark->flags = 0;
} else //如果bookmark中没有entry，则获取等待队列的第一个entry
curr = list_first_entry(&wq_head->head, wait_queue_entry_t, entry);
//确定等待队列是否为空
if (&curr->entry == &wq_head->head)
return nr_exclusive;
//从第一个entry，即curr 开始依次处理等待队列的entry
list_for_each_entry_safe_from(curr, next, &wq_head->head, entry) {
unsigned flags = curr->flags;
int ret;
//跳过等待队列上标记 WQ_FLAG_BOOKMARK的entry，目前系统中没有主动标记的entry
if (flags & WQ_FLAG_BOOKMARK)
continue;
/**
* 调用等待队列entry绑定的唤醒回调函数
* 具体唤醒什么样的进程，是INTERRUPTIBLE / UNINTERRUPTIBLE，需要根据mode 决定，
* 如果需要唤醒的进程mode与当前进程的状态state 不符合，则返回0，
* 详细查看 try_to_wake_up()函数；
*/
ret = curr->func(curr, mode, wake_flags, key);
if (ret < 0)
break;
//如果成功唤醒，且当前entry标记了WQ_FLAG_EXCLUSIVE，则nr_exclusive计数要减1
// 当nr_exclusive 个entry都唤醒了，就不再接着去唤醒了，退出此次wake_up
if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
/**
* 之所以引入临时的bootmark，就为了性能考虑
* 当连续唤醒的entry 超过了WAITQUEUE_WALK_BREAK_CNT(系统默认为64)时，
* 会将剩下的entry移入到bootmark之后，返回到上一级函数
* 通过这种机制，实现了进程分批次唤醒，避免了等待队列中自旋锁被持有时间过长
*/
if (bookmark && (++cnt > WAITQUEUE_WALK_BREAK_CNT) &&
(&next->entry != &wq_head->head)) {
bookmark->flags = WQ_FLAG_BOOKMARK;
list_add_tail(&bookmark->entry, &next->entry);
break;
}
}
return nr_exclusive;
}
参数：
wq_head：等待队列的头；
mode：唤醒进程的状态，TASK_NORMAL 或 TASK_INTERRUPTIBLE；
nr_exclusive：指定需要唤醒的 exclusive entry 数量；
wake_flags：只有在 __wake_up_sync_key() 函数调用时会传入 WF_SYNC，其他默认都为 0；
bootmark：用以标记再处理的 entry；
3.5 总结
wake up 的接口比较多，注意 __wake_up() 和 __wake_up_locked() 的区别在于后者已经处于等待队列的自旋锁中。另外 __wake_up_common_lock() 函数中多了 bookmark机制，实现进程的分批次唤醒。
wake up 最终都是通过唤醒回调函数达到唤醒等待队列的目的，系统默认的回调函数最终都是通过 try_to_wake_up() 来实现。
下面单独来分析唤醒回调函数。
4. 唤醒回调函数
上面 wake_up() 函数中没轮询一个 entry 时，都会调用该entry 的唤醒回调函数。
在 entry 上文第 1.3 节中提到系统默认有两种方式：
default_wake_function
autoremove_wake_function
唯一区别在于 autoremove_wake_function() 函数在调用 default_wake_function() 之后会将该 entry 从等待队列中移除，如下：
4.1 autoremove_wake_function()
kernel/sched/wait.c
int autoremove_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key)
{
int ret = default_wake_function(wq_entry, mode, sync, key);
if (ret)
list_del_init_careful(&wq_entry->entry);
return ret;
}
EXPORT_SYMBOL(autoremove_wake_function);
5. 另外一种休眠1
上文第 2、3、4节 基本上剖析的是系统 ___wait_event() 和 wake_up() 方式的休眠和唤醒。
而在第 1.3 节中我们还看到了其他中等待队列 entry 的创建和初始化方式，例如：
include/linux/wait.h
#define DEFINE_WAIT_FUNC(name, function) \
struct wait_queue_entry name = { \
.private = current, \
.func = function, \
.entry = LIST_HEAD_INIT((name).entry), \
}
#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
这种有模块自己定义的 entry，如何使用呢？
系统提供了另外一个函数 prepare_to_wait() 和 prepare_to_wait_exclusive()。
5.1 prepare_to_wait()
kernel/sched/wait.c
void
prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
{
unsigned long flags;
wq_entry->flags &= ~WQ_FLAG_EXCLUSIVE;
spin_lock_irqsave(&wq_head->lock, flags);
if (list_empty(&wq_entry->entry))
__add_wait_queue(wq_head, wq_entry);
set_current_state(state);
spin_unlock_irqrestore(&wq_head->lock, flags);
}
EXPORT_SYMBOL(prepare_to_wait);
将该 entry 添加到等待队列的头部，并调用 set_current_state() 将当前进程状态置上。
5.2 prepare_to_wait_exclusive()
kernel/sched/wait.c
bool
prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
{
unsigned long flags;
bool was_empty = false;
wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
spin_lock_irqsave(&wq_head->lock, flags);
if (list_empty(&wq_entry->entry)) {
was_empty = list_empty(&wq_head->head);
__add_wait_queue_entry_tail(wq_head, wq_entry);
}
set_current_state(state);
spin_unlock_irqrestore(&wq_head->lock, flags);
return was_empty;
}
EXPORT_SYMBOL(prepare_to_wait_exclusive);
与 prepare_to_wait() 不同的是，这里指定的 entry 是 WQ_FLAG_EXCLUSIVE，并且该entry 是添加到等待队列尾部。
5.3 示例
了解完 DEFINE_WAIT()、prepare_to_wait() 之后，模块上可以使用如下示例进行管理：
net/atm/svc.c
static void svc_disconnect(struct atm_vcc *vcc)
{
DEFINE_WAIT(wait);
...
if (test_bit(ATM_VF_REGIS, &vcc->flags)) {
sigd_enq(vcc, as_close, NULL, NULL, NULL);
for (;;) {
prepare_to_wait(sk_sleep(sk), &wait, TASK_UNINTERRUPTIBLE);
if (test_bit(ATM_VF_RELEASED, &vcc->flags) || !sigd)
break;
schedule();
}
finish_wait(sk_sleep(sk), &wait);
}
...
6. 另外一种休眠2
DECLARE_WAIT_QUEUE_HEAD(queue);
DECLARE_WAITQUEUE(wait, current);
for (;;) {
add_wait_queue(&queue, &wait);
set_current_state(TASK_INTERRUPTIBLE);
if (condition)
break;
schedule();
remove_wait_queue(&queue, &wait);
if (signal_pending(current))
return -ERESTARTSYS;
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&queue, &wait);
这种方式是手动调用等待队列的add、remove 接口。
7. 总结
至此，等待队列基本剖析完成。其实，根本上就是通过一个数据接口 wait_queue_head_t 串联很多 wait_queue_entry_t，主要在这些 entry 的创建或初始化上，因为此时会指定flags、func 以及对应进程的 private 变量。
在不同的进程中会调用 ___wait_event() 可以自动创建等待队列 entry；
也可以通过 DEFINE_WAIT()、DECLARE_WAITQUEUE() 等方式手动创建等待队列entry；
不同的实现方式对应着不同的唤醒方式：
___wait_event() 中必须要指定 condition，只有在condition 为true或者进程挂起信号并收到信号，才能退出等待，进程才能进入之后的 RUNNING 状态；
通过 DEFINE_WAIT() 等方式，可以配合使用prepare_to_wait()，进而由模块自己组织代码，控制schedule 的时机和唤醒后的条件处理；
当然，也可以不适用等待队列，也能达到休眠、唤醒的目的。都是根据不同的实际需求，进而选择合适的方式。
另外，wait event 的state 有下面几种方式：
TASK_UNINTERRUPTIBLE，表示该等待事件只能调用 wake_up 唤醒；
TASK_INTERRUPTIBLE，表示该等待事件可以使用wake_up 唤醒，也可以使用信号唤醒；
TASK_KILLABLE，表示该等待事件只能由 SIGKILL 唤醒或wake_up 唤醒；
TASK_IDLE，表示等待事件只能由wake_up唤醒；
当然，这些state 还组合了 timeout 机制，详细可以查看 schedule_timeout() 处理。
最后，附上等待队列的完整流程图：
文章知识点与官方知识档案匹配，可进一步学习相关知识
————————————————
本文为博主原创文章，未经博主允许不得转载！
原文链接：https://blog.csdn.net/shift_wwx/article/details/134994589
扫一扫
649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
