Linux等待队列机制

一.概念

1.linux内核等待队列机制

1.1.概念

明确：等待分为忙等待和休眠等待

"等待":期望某个事件发生

“事件”：比如按键有操作，串口有数据，网络有数据；

明确：阻塞一般是指休眠等待

明确：进程的状态

1.进程的准备就绪状态
TASK_READY;

2.进程的运行状态
TASK_RUNNING;

3.进程的休眠状态

不可中断的休眠：TASK_UNINTERRUPTIBLE

可中断的休眠：TASK_INTERRUPTIBLE

4.注意：进程的切换，调度都是利用内核的调度器来实现的，调度器管理的对象是进程；

明确：休眠只能用于进程

进程休眠的方法：
1.在用户层调用sleep函数

2.在内核层调用msleep/ssleep/schedule/schedule_timeout
说明：以上休眠的方法的缺点在于一旦事件到来，进程无法及时被唤醒(除非发信号)，那么造成事件无法得到及时的处理；

问：事件一旦到来，如何及时唤醒休眠的进程呢？

问：一个进程如果发现设备不可用，进程将进入休眠等待，一旦设备可用，如何及时唤醒休眠的进程呢？

答：利用linux内核的等待队列机制；

二.等待队列机制

2.等待队列机制
特点：

1.等待队列机制本质目的就是实现进程在内核空间进行休眠操作；当然休眠的原因是等待某个事件到来！

2.一旦事件到来，驱动能够主动唤醒休眠的进程，当然也可以通过信号来唤醒；

3.信号量机制就是靠等待队列机制来实现的！

使用等待队列机制实现进程休眠的步骤：

1.等待队列 = 等待 + 队列

模型：

进程调度器->老鹰(内核实现)

等待队列头->鸡妈妈(驱动实现)

要休眠的进程->小鸡(驱动实现)

2.相关的数据结构

linux内核描述等待队列头的数据类型：
wait_queue_head_t

linux内核描述装载休眠进程的容器的数据类型：
wait_queue_t
切记：此数据类型描述的装载进程的容器

linux内核描述进程(线程)的数据类型：
struct task_struct {

volatile long state;//进程的状态

pid_t pid;//进程的进程号

char comm[TASK_COMM_LEN];//进程的名称

...

};//内核会为每一个进程创建一个对应的对象

linux内核描述"当前进程"的内核全局指针变量: current
"当前进程"：只是当时获取CPU资源，正在运行中中的进程，

而此时内核全局指针变量current就指向当前这个进程的struct task_struct对象；

3.使用等待队列实现进程在内核休眠的编程步骤：

3.1.定义初始化等待队列头(造鸡妈妈)
wait_queue_head_t wq;

init_waitqueue_head(&wq);

3.2.定义初始化装载休眠进程的容器(造小鸡)
wait_queue_t wait;

init_waitqueue_entry(&wait, current);

说明：把当前要休眠的进程添加到容器wait中

3.3.将当前要休眠的进程添加到休眠队列中去
add_wait_queue(&wq, &wait);

3.4.设置当前要休眠进程的休眠状态
set_current_state(TASK_INTERRUPTIBLE);

//设置为可中断休眠状态

或者
set_current_state(TASK_UNINTERRUPTIBLE);

//设置为不可中断的休眠状态
注意：此时当前进程还没有进入休眠状态，还没有释放CPU资源；

3.5.当前进程进入真正的休眠状态(释放CPU资源)
schedule();
注意：此时程序就运行到此停止不前，等待某个事件的到来！
注意：

1.此休眠函数和休眠状态(可中断的),休眠进程被唤醒的方法有两种：

第一种通过信号来唤醒

第二种通过事件到来，驱动主动唤醒

2.此休眠函数和休眠状态(不可中断的),休眠进程被唤醒的方法有一种：

第一种通过事件到来，驱动主动唤醒
总结：调用此函数，静静等待信号或者驱动主动来唤醒；

3.6.一旦休眠进程被唤醒，记得要将休眠进程从休眠队列中移除，在移除前设置当前进程的状态为运行态：
set_current_state(TASK_RUNNING);
remove_wait_queue(&wq, &wait);

3.7.判断唤醒的原因：
if (signal_pending(current)) {

printk("由于接受到了信号引起的唤醒!\n")

return -ERESTARTSYS;

} else {

printk("事件到来，驱动主动唤醒！\n");

接下来开始处理事件

}

3.8.事件到来，驱动主动唤醒的方法：
wake_up(&wq); //唤醒休眠队列中所有的休眠进程；

或者

wake_up_interruptible(&wq);//唤醒休眠队列中所有睡眠类型为可中断的休眠进程

案例：写进程唤醒读进程

实验步骤：

1.insmod led_drv.ko

2../led_test r & //启动读进程

3../led_test w //启动写进程 ，主动唤醒

4../led_test r & //启动读进程

5.kill 读进程的PID //接受信号唤醒

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/sched.h>

//定义等待队列头
static wait_queue_head_t wq;

static ssize_t led_read(struct file *file,
char __user *buf,
size_t count,
loff_t *ppos)
{
//让读进程进入休眠状态，等待写进程来唤醒
//1.定义初始化装载休眠进程的容器
//说明：只要进程调用read，那么就给这个进程单独分配一个容器
wait_queue_t wait;
init_waitqueue_entry(&wait, current);

//2.将当前进程添加到休眠队列中
add_wait_queue(&wq, &wait);

//3.设置当前进程的休眠状态为可中断
set_current_state(TASK_INTERRUPTIBLE);

//4.让当前进程进入休眠状态
printk("%s:读进程[%s][%d]将进入休眠状态!\n",
__func__, current->comm, current->pid);
schedule();//此时等待被唤醒：写进程唤醒或者接收到了信号

//5.一旦被唤醒，设置当前进程的状态为运行
set_current_state(TASK_RUNNING);

//6.将当前进程从休眠队列中移除
remove_wait_queue(&wq, &wait);

//7.判断唤醒的原因
if (signal_pending(current)) {
printk("%s:读进程[%s][%d]是由于接收到了信号引起的唤醒!\n",
__func__, current->comm, current->pid);
return -ERESTARTSYS;
} else {
printk("%s:读进程[%s][%d]是由于写进程唤醒!\n",
__func__, current->comm, current->pid);
}
return count;
}

static ssize_t led_write(struct file *file,
char __user *buf,
size_t count,
loff_t *ppos)
{
//唤醒休眠的读进程
printk("%s:写进程[%s][%d]将会唤醒读进程!\n",
__func__, current->comm, current->pid);
wake_up_interruptible(&wq);
return count;
}

//定义初始化操作接口
static struct file_operations led_fops = {
.owner = THIS_MODULE,
.read = led_read,
.write = led_write
};

//定义初始化混杂设备对象
static struct miscdevice led_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "myled",
.fops = &led_fops
};

static int led_init(void)
{
//注册
misc_register(&led_misc);
//初始化等待队列头
init_waitqueue_head(&wq);
return 0;
}

static void led_exit(void)
{
//卸载
misc_deregister(&led_misc);
}
module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
int fd;
int data;

if (argc != 2) {
printf("Usage:%s <r|w>\n", argv[0]);
return -1;
}

fd = open("/dev/myled", O_RDWR);
if (fd < 0)
return -1;

if (!strcmp(argv[1], "r")) {
//启动一个读进程
read(fd, &data, 4);
} else {
//启动一个写进程
write(fd, "hello", 5);
}

close(fd);
return 0;
}

三.等待队列机制编程方法2

 3.linux内核等待队列编程方法2：
明确：等待队列机制是实现进程在内核空间进行休眠操作；

驱动要做的步骤：

1.定义初始化等待队列头
wait_queue_head_t wq;

init_waitqueue_head(&wq);

2.调用以下方法实现进程的休眠
wait_event(wq,condition);

说明：

参数：

wq：等待队列头

condition:

condition如果为假，表示事件没有满足，进程需要进行休眠；

condition如果为真，表示事件满足，进程不进行休眠，立即返回

1.内核会帮你定义初始化一个装载当前进程的容器

2.内核也会帮你将当前进程添加到wq的休眠队列中

3.内核也会帮你设置进程的休眠状态，此休眠状态为不可中断；

4.内核也会帮你进入真正的休眠；

5.内核也会帮你判断唤醒的原因；

6.内核也会帮你移除

或者
wait_event_interruptible(wq,condition);

说明：

参数：

wq：等待队列头

condition:

condition如果为假，表示事件没有满足，进程需要进行休眠；

condition如果为真，表示事件满足，进程不进行休眠，立即返回

1.内核会帮你定义初始化一个装载当前进程的容器

2.内核也会帮你将当前进程添加到wq的休眠队列中

3.内核也会帮你设置进程的休眠状态，此休眠状态 为可中断；

4.内核也会帮你进入真正的休眠；

5.内核也会帮你判断唤醒的原因；

6.内核也会帮你移除

编程框架：

//刚开始condition为假

wait_event_interruptible(wq, condition);

将condition再次设置为假，为了下一次休眠

...

//在别处，发现事件满足，唤醒

condition设置为真；

wake_up_interruptible(&wq);

案例：尝试阅读wait_event_interruptible内核实现

案例：编写一个真实有用的按键驱动！