linux 内核队列,linux内核中的等待队列的基本操作

在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);