介绍这几个函数，不得不先介绍等待队列wait_queue_head_t
等待队列用于使得进程等待某一特定事件的发生，无需频繁的轮询，进程在等待周期中睡眠，当时间发生后由内核自动唤醒。
等待队列
（一）数据结构
等待队列结构如下，因为每个等待队列都可以再中断时被修改，因此，在操作等待队列之前必须获得一个自旋锁。
struct __wait_queue_head { spinlock_t lock; struct list_head task_list; }; typedef struct__wait_queue_head wait_queue_head_t; 等待队列是通过task_list双链表来实现，其数据成员是以下数据结构： typedef struct__wait_queue wait_queue_t; struct __wait_queue { unsigned int flags; #defineWQ_FLAG_EXCLUSIVE 0x01 /* 表示等待进程想要被独占地唤醒 */ void *private; /* 指向等待进程的task_struct实例 */ wait_queue_func_t func; /* 用于唤醒等待进程 */ struct list_head task_list; /* 用于链表元素，将wait_queue_t链接到wait_queue_head_t */ }; 其图如下：
等待队列如何使用哪？分两步:
1. 为了使得等待进程在一个等待队列中睡眠，需要调用函数wait_event()函数。进程进入睡眠，将控制权释放给调度器。
2. 在内核中另一处，调用wake_up()函数唤醒等待队列中的睡眠进程。
注：使用wait_event()函数使得进程睡眠；而在内核另一处有一个对应的wake_up()函数被调用。 （二）初始化等待队列元素
有两种方法初始化队列：
1. 动态初始化init_waitqueue_entry()
static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p) { q->flags = 0; q->private = p; q->func = default_wake_function; } 2. 静态初始化DEFINE_WAIT() #define DEFINE_WAIT_FUNC(name, function) \ wait_queue_t name = { \ .private = current, \ .func = function, \ .task_list = LIST_HEAD_INIT((name).task_list), \ } #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)其中函数autoremove_wake_function()是用来唤醒进程的，该函数不经调用default_wake_function()，还将所属等待队列成员从等待队列删除。
（三）进程睡眠
1. 通过add_wait_queue()函数将一个进程添加到等待队列，首先获得队列的自旋锁，然后调用__add_wait_queue()实现将新的等待进程添加等待队列（添加到等待队列的头部），然后解锁；代码如下：
static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new) { list_add(&new->task_list, &head->task_list); }另一个函数add_wait_queue_exclusive()的含义与add_wait_queue()函数类似，但是将等待进程添加到等待队列的尾部，并设置WQ_EXCLUSIXE标志。
使得进程在等待队列上睡眠的另一种方法是：prepare_to_wait()，除了有add_wait_queue()函数的参数外，还要设置进程的状态。
另一个函数prepare_to_wait_exclusive()语义类似。
通常情况下，add_wait_queue()函数不会直接使用,因为add_wait_queue()函数不与具体的逻辑相管理，单纯的一个等待队列的模型是没有意义的，因此通常使用的是wait_event()函数：
/** * wait_event - sleep until a condition gets true * @wq: the waitqueue to wait on * @condition: a C expression for the event to wait for * * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the * @condition evaluates to true. The @condition is checked each time * the waitqueue @wq is woken up. * * wake_up() has to be called after changing any variable that could * change the result of the wait condition. */ #define wait_event(wq, condition) \ do { \ if (condition) \ break; \ __wait_event(wq, condition); \ } while (0) 函数__wait_event() #define __wait_event(wq, condition) \ do { \ DEFINE_WAIT(__wait); \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ if (condition) \ break; \ schedule(); \ } \ finish_wait(&wq, &__wait); \ } while (0)其中wq是等待进程需要加入的等待队列，而condition是通过与所等待时间有关的一个C表达式形式给出。表示，条件满足时，可以立即停止处理。
主要工作由__wait_event()来完成：
(1) 调用DEFINE_WAIT宏创建等待队列成员；
(2) 使用一个无线循环，在循环体内，
(a) 调用prepare_to_wait()使得进程在等待队列上等待,并将进程状态置为不可中断TASK_UNINTERRUPTIBLE；
(b) 当进程被唤醒时，检查指定的条件condition是否满足，如果满足则跳出循环，否则将控制权交给调度器，然后进程继续睡眠。
(3) 调用函数finish_wait()将进程状态设置为TASK_RUNNING，并从等待队列的链表中移除对应的成员。
其他与wait_event类似的函数：
1. wait_event_interrupable()函数 ，使得进程处于可中断(TASK_INTERRUPTIBLE)状态，从而睡眠进程可以通过接收信号被唤醒；
2. wait_event_timeout()函数，等待满足指定的条件，但是如果等待时间超过指定的超时限制则停止睡眠，可以防止进程永远睡眠；
3. wait_event_interruptible_timeout() 使得进程睡眠，不但可以通过接收信号被唤醒，也具有超时限制。
（四）进程唤醒
内核中虽然定义了很多唤醒等待队列中进程的函数，但是最终调用的都是__wake_up()
#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) #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, 1)而__wake_up()函数在加锁之后调用的是__wake_up_common()
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, int wake_flags, void *key) { wait_queue_t *curr, *next; list_for_each_entry_safe(curr, next, &q->task_list, task_list) { unsigned flags = curr->flags; if (curr->func(curr, mode, wake_flags, key) && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive) break; } }其中：q是等待队列，mode指定进程的状态，用于控制唤醒进程的条件，nr_exclusive表示将要唤醒的设置了WQ_FLAG_EXCLUSIVE标志的进程的数目。
然后扫描链表，调用func(注册的进程唤醒函数，默认为default_wake_function)唤醒每一个进程，直至队列为空，或者没有更多的进程被唤醒，或者被唤醒的的独占进程数目已经达到规定数目。
简单的demo：
点击(此处)折叠或打开
/*a simple wait_queue demo *task_1,task_2 added into the wait_queue, if condition is 0. *task_3 change condition to 1, and task_1 task_2 will be wake up */#include <linux/kernel.h>#include <linux/init.h>#include <linux/module.h>#include <linux/sched.h>#include <linux/kthread.h>#include <linux/delay.h>MODULE_LICENSE("GPL");MODULE_AUTHOR("cengku@gmail.com");static int condition;static struct task_struct *task_1;static struct task_struct *task_2;static struct task_struct *task_3;DECLARE_WAIT_QUEUE_HEAD(wq);static int thread_func_1(void *data){ int i = 0; while (i++ < 100) { wait_event(wq, condition == 1); msleep(1000); printk(">>>>>this task 1\n"); } return 0;}static int thread_func_2(void *data){ int i = 0; while (i++ < 100) { wait_event(wq, condition == 1); msleep(1000); printk(">>>>>this task 2\n"); } return 0;}static int thread_func_3(void *data){ int i = 0; while (i++ < 10) { condition = 0; msleep(2000); printk(">>>>>this task 3\n"); condition = 1; wake_up(&wq); msleep(2000); } return 0;}static int __init mod_init(void){ printk("=====mod set up===\n"); condition = 0; task_1 = kthread_run(thread_func_1, NULL, "thread%d", 1); if (IS_ERR(task_1)) printk("**********create thread 1 failed\n"); else printk("======success create thread 1\n"); task_2 = kthread_run(thread_func_2, NULL, "thread%d", 2); if (IS_ERR(task_2)) printk("**********create thread 2 failed\n"); else printk("======success create thread 2\n"); task_3 = kthread_run(thread_func_3, NULL, "thread%d", 3); if (IS_ERR(task_3)) printk("**********create thread 3 failed\n"); else printk("======success create thread 3\n"); return 0;}static void __exit mod_exit(void){ int ret; if (!IS_ERR(task_1)) { ret = kthread_stop(task_1); if (ret > 0) printk("<<<<<<<<<thread 1 has run %ds\n", ret); } if (!IS_ERR(task_2)) { ret = kthread_stop(task_2); if (ret > 0) printk("<<<<<<<<<thread 2 has run %ds\n", ret); } if (!IS_ERR(task_3)) { ret = kthread_stop(task_3); if (ret > 0) printk("<<<<<<<<<thread 3 has run %ds\n", ret); }}module_init(mod_init);module_exit(mod_exit); Makefile:点击(此处)折叠或打开
KERNEL_DIR:=/lib/modules/`uname -r`/buildPWD:=`pwd`obj-m:= wq_mod.odefault: make -C $(KERNEL_DIR) M=$(PWD) modulesclean: make -C $(KERNEL_DIR) M=$(PWD) clean <script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"2","bdMiniList":false,"bdPic":"","bdStyle":"0","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script> 阅读(372) | 评论(1) | 转发(0) | 0上一篇：printf实现
下一篇：深入理解linux内核list_head的实现
相关热门文章 linux 常见服务端口xmanager 2.0 for linux配置【ROOTFS搭建】busybox的httpd...openwrt中luci学习笔记Linux里如何查找文件内容... 给主人留下些什么吧！~~183450931672016-07-26 18:56:48
等待队列用于使得进程等待某一特定事件的发生，无需频繁的轮询，进程在等待周期中睡眠，当时间发生后由内核自动唤醒。时间应改为事件
回复 | 举报 评论热议