在linux内核中进程的状态主要有几种状态：
1.运行态：即进程正在CPU上进行运行，它此刻正在占有CPU；
2.就绪态：即进程除了CPU之外，已经具备了运行的所有条件，在就绪队列中等待调度器(schedule)的调度；
3.阻塞态：即进程除了缺少CPU外，还缺少其他条件，在等待队列中等待所需要的条件；
介绍linux内核中的等待队列的组织结构以及各种对等待队列的操作：
等待队列由两部分构成：等待队列头 + 等待队列中的等待项；
等待队列头的结构：
struct __wait_queue_head
{
spinlock_t lock; // 自选锁，用于保护等待队列，防止并发访问
struct list_head task_list;//用于构建等待队列
}
typedef struct __wait_queue_head wait_queue_head_t;
等待队列中的等待项：
struct __wait_queue
{
unsigned int flags;
void *private;
wait_queue_func_t func;
struct list_head task_list;
}
每个字段的介绍：
flags : 用于判断当等待条件满足时，是唤醒等待队列中的等待该条件的所有
等待进程，还是只唤醒一个；
flags 的最后一位为 1 时表示每次只唤醒一个等待队列中的进程；
flags 的最后一位为 0 时表示每次唤醒等待该条件的所有进程；
#define WQ_FLAG_EXCLUSIVE 0x01
private: 用于存放 struct task_struct 的地址；
wait_queue_func_t :等待队列中的进程被唤醒的方式；
typedef int (*wait_queue_func_t)(wait_queue_t *wait,unsigned mode,
int flags, void *key)
等待的队列的结构图：
对等待队列的各种操作：
1.等待队列头的静态初始化：
#define __WAIT_QUEUE_INITIALIZER(name) { \
.lock = __SPIN_LOCK_UNLOCK(name.lock),// lock = 1; \
.task_list = {&(name).task_list, &(name).task_list} }
#define DECLARE WAIT_QUEUE_HEAD(name) \
wait_queue_head_t name = __WAIT_QUEUE_INITIALIZER(name)
所以可以直接通过 ： DECLARE_WAIT_QUEUE_HEAD(name) 来完成一个等待队列头的定义以及初始化操作；
2. 等待队列头的动态初始化操作：
void __init_waitqueue_head(wait_queue_head_t *p, struct lock_class_key *key)
{
spin_lock_init(&p->lock); // 初始化spinlock_t lock lock = 1;
INIT_LIST_HEAD(&p->task_list);// 初始化链表头;
}
#define init_waitqueue_head(name) \
do { \
static struct lock_class_key __key; \
__init_wait_queue_head((name), &__key);\
} while(0)
所以如果使用 init_waitqueue_head()的用法为：
wait_queue_head_t name;
init_waitqueue_head(&name);
DECLARE_WAIT_QUEUE_HEAD() 与 init_waitqueue_head()的区别：
1.DECLARE_WAIT_QUEUE_HEAD完全时用宏定义实现的，因此程序在编译的时候就完成了变量的定义与初始化。而 init_waitqueue_head()本质上来说是对 __init_waitqueue_head()的一次封装。虽然使用了宏定义，其仍然是一个函数，它对变量的初始化是在程序运行的时候进行的；
3.对等待队列中的等待项进行静态定义与初始化：
#define __WAITQUEUE_INITIALIZER(name, task) { \
.private = task, \
.func = default_wake_function, \
.task_list = {NULL,NULL} }
#define DECLARE_WAITQUEUE(name,task) \
wait_queue_t name = __WAITQUQUE_INITIALIZER(name, task)
相当与：
wait_queue_t entry;
struct task_struct task;
entry = {
.private = &task,
.func = default_wake_function,
.taks_list = {NULL, NULL}
}
4.动态初始化等待队列中的数据项：
static inline void init_waitqueue_entry(wait_queue_t *p, struct task_struct *task)
{
p->flags = 0;
p->private = task;
p->func = default_wake_function;
}
用法：wait_queue_t wait;
struct task_struct task;
init_waitqueue_entry(&wait, &task);
5.使用自定义的函数作为等待队列中的进程唤醒做处理：
static inline void init_waitqueue_func_entry(wait_queue_t *wait,
wait_queue_func_t func)
{
p->flags = 0;
p->private = NULL;
p->func = func;
}
6.判断一个等待队列是否可用：
static inline int waitqueue_active(wait_queue_head_t *p)
{
return ！list_empty(&p->task_list);
}
waitqueue_active()本质上实在判断一个等待队列是否为空。
如果为空的话，等待队列不可用返回 0；
如果不为空，等待队列可用返回 1；
7.向等待队列中添加一个数据项：
static inline void __add_wait_queue(wait_queue_head_t *head,
wait_queue_t *new)
{
list_add(&new->task_list, &head->task_list);
}
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned int flags ;
wait->flags &= ~WQ_FLAG_EXCLUSIVE; // define WQ_FLAG_EXCLUSIVE 0x01
spin_lock_irqsave(&q->lock, flags);
__add_wait_queue(q, wait);
spin_unlock_irqstore(&q->lock, flags);
}
所以 add_wait_queue()是__add_wait_queue()的封装，并且加入了一些保护等待队列防止并发访问的措施， 所以在向等待队列中添加元素时使用 add_wait_queue()会更安全；
8.向等待队列中添加一个每次只能唤醒一个数据项：
static inline void __add_wait_queue_tail(wait_queue_head_t *head,
wait_queue_t *new)
{
list_add_tail(&new->task_list, &head->task_list);
}
void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned int flags ;
wait->flags |= WQ_FLAG_EXCLUSIVE;
spin_lock_irqsave(&q->lock, flags);
__add_wait_queue_tail(q,wait);
spin_unlock_irqstore(&q->lock, flags);
}
可以看出 add_wait_queue(wait_queue_head_t *head, wait_queue_t *wait)
每次向等待队列的头后面添加一个非互斥唤醒的等待项；
add_wait_queue_exclusive(wait_queue_head_t *head, wait_queue_t *wait)
每次向等待队列的尾部添加一个互斥唤醒的等待项；
9.将一个等待项从等待队列中删除：
static inline void __remove_wait_queue(wait_queue_head_t *head,
wait_queue_t *wait)
{
list_del(&wait->task_list);
}
void remove_wait_queue(wait_queue_head_t *head, wait_queue_t *wait)
{
unsigned int flags;
spin_lock_irqsave(&head->lock, flags);
__remove_wait_queue(head,wait);
spin_unlock_irqstore(&head->lock, flags);
}
小总结： add_wait_queue(); EXPORT_SYMBOL(add_wait_queue);
add_wait_queue_exclusive(); EXPORT_SYMBOL(add_wait_queue_exclusive);
remove_wait_queue(); EXPORT_SYMBOL(remove_wait_queue);
这三个对等待队列的操作是内核提过的函数，
内核中的等待队列中的进程是需要在一定条件下给唤醒的，然后加入到就绪队列中的。以及正在运行的进程如何将其加入到等待队列之中的。
内核也提供了一些函数，帮助我们将进程正在运行的进程阻塞，让后将其加入到等待队列中。以及在等待队列中唤醒唤醒阻塞进程。
阻塞正在运行的进程，然后将其加入到等待队列中的函数：
1. void prepare_to_wait(wait_queue_head_t *head, wait_queue_t *wait, int state)
state :表示进程的状态
取值 TASK_RUNNING, TASK_INTERRUPTIBLE, TASK_UNINTERRUPTIBLE
void prepare_to_wait(wait_queue_head_t *head, wait_queue_t *wait, int state)
{
unsigned int flags;
wait->flags &= ~WQ_FLAG_EXCLUSIVE; // 非互斥唤醒进程；
spin_lock_irqsave(&head->lock, flags);
if( list_empty(&wait->task_list) ) // 如果为空，说明其之前并不在等待对列中
__add_wait_queue(head, wait); // 将wait entry 加入到等待队列之中
set_current_state(state); // 使用 set_current_state()改变进程的运行状态
spin_unlock_irqstore(&head->lock, flags);
}
EXPORT_SYMBOL(prepare_to_wait);
void prepare_to_wait_exclusive(wait_queue_head_t *head,
wait_queue_head *wait, int state)
{
unsigned int flags;
wait->flags |= WQ_FLAG_EXCLUSIVE; // 互斥唤醒进程；
spin_lock_irqsave(&head->lock, flags);
if( list_empty(&wait->task_list) )
__add_wait_queue_tail(head, wait); //添加对尾
set_current_state(state);
spin_unlock_irqstore(&head->lock, flags);
}
EXPORT_SYMBOL(prepare_to_wait_exclusive);
从阻塞队列中删除一个等待进程的函数：
void finish_wait(wait_queue_head_t *head, wait_queue_t *wait)
{
unsigned int flags;
__set_current_state(TASK_RUNNING); //将当前的进程状态改为运行态；
if( !list_empty_careful(&wait->task_list) ) // 确定进程在等待队列之中
{
spin_lock_irqsave(&head->lock, flags);
list_del_init(&wait->task_list);
spin_unlock_irqstore(&head->lock, flags);
}
}
EXPORT_SYMBOL(finish_wait);