从买s3c2440a的开发板差不多快一年了吧，从一开始当单片机玩 弄裸奔的程序，把各个功能调得差不多了。之后又开始弄ucosII了。中间停了一段时间，工作忙就放下了，最近又拿出来，接着玩玩，嘿嘿。
前段时间研究了一下uboot，蛮深奥的...
，然后把linux内核和yaffs2 移植上去了，然后就着手学习linux的设备驱动啦，哈哈。毕竟是学习嘛，要把准备工作都做好，在网上下了视频，然后又买了《linux设备驱动程序第三版》，京东上买的，京东送货还是蛮靠谱的，第二天就送到了，也就是周四晚上到的，新的东西嘛都要稀罕几天呢，再加上周六日，一口气儿看到了第六章，哈哈。之前是有些基础的，要不也不能看这么快啦，但是还是有很多地方不懂嘛，需要仔细琢磨的，静下心来，一步一个脚印，嘿嘿。
把学习过程中理解的记录一下，以便以后忘记了，也容易找到，回顾回顾
等待队列源码分析
说明： list_head，属于内核链表的内容，list_entry(ptr,type,member);这个的实现还是很经典的...
2 50struct __wait_queue_head {
3 51 spinlock_t lock;
4 52 struct list_head task_list;
5 53};
6 54typedef struct __wait_queue_head wait_queue_head_t;
可以看到，等待队列头结构中封装了list_head结构。这么做是可以想象到的，因为队列和栈本质上还是双联表。当我们适当限制双联表的某些操作 时，就可以实现这样的功能。另外，等待队列头结构中还有一个自旋锁结构的变量lock，它起到了对等待队列进行互斥操作的作用。
在等待队列结构中，除了使用list_head结构外，还有以下几个字段：
2 32struct __wait_queue {
3 33 unsigned int flags;
4 34#define WQ_FLAG_EXCLUSIVE 0x01
5 35 void *private;
6 36 wait_queue_func_t func;
7 37 struct list_head task_list;
8 38};
flag：指明该等待的进程是互斥还是非互斥，为0时非互斥，为1时互斥；
WQ_FLAG_EXCLUSIVE ：从变量可以看出，此宏代表进程是互斥的；
private：void型指针变量功能强大，你可以赋给它你需要的结构体指针。一般赋值为task_struct类型的指针，也就是说指向一个进程；
func：函数指针，指向该等待队列项的唤醒函数；
我们可以通过下述图来详细了解等待队列头和等待队列的结构关系：
1.定义及初始化
内核中使用init_waitqueue_head宏来初始化等待队列头。
2 82#define init_waitqueue_head(q) \
3 83 do { \
4 84 static struct lock_class_key __key; \
5 85 \
6 86 __init_waitqueue_head((q), &__key); \
7 87 } while (0)
我们可以看到这个宏使用了do-while型循环语句，里面包含两条语句。首先定义了一个变量__key，然后再调用init_waitqueue_head函数。
事实上，这个do-while循环语句只会执行一次。那么，为什么要选择使用这个循环语句？在定义宏的时候将上述语句嵌套在一个大括号里也可以啊！可能我们如下那样使用一个宏：
2 11 init_waitqueue_head(q);
3 12 else
4 13 do_somthing_else();
如果我们去除do-while，那么替换后会编译错误。因为宏末尾的分号使得else语句成为一个单独的句子。你也许会说，那我这样使 用：init_waitqueue_head(q)就可以避免这个错误了。这样是可以，但是对于那些初学者来说，很难避免他们要加上一个;。并且，在茫茫 代码中，孤零零的出现一个没有;的语句，未免显得有些奇怪。
言归正传，在init_waitqueue_head宏中调用的__init_waitqueue_head函数定义如下：
2 14{
3 15 spin_lock_init(&q->lock);
4 16 lockdep_set_class(&q->lock, key);
5 17 INIT_LIST_HEAD(&q->task_list);
6 18}
在这个函数中，首先利用自旋锁初始化函数初始化这个自旋锁；在上述等待队列头的定义中，我们可以看到task_list字段是一个list_head结构类型，因此我们使用INIT_LIST_HEAD对这个链表进行初始化。这些过程都是我们所熟悉的。
同时，我们也可以使用初始化宏DECLARE_WAIT_QUEUE_HEAD一步的进行定义和初始化。
2 71 .lock = __SPIN_LOCK_UNLOCKED(name.lock), \
3 72 .task_list = { &(name).task_list, &(name).task_list } }
4 73
5 74#define DECLARE_WAIT_QUEUE_HEAD(name) \
6 75 wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
上述代码对于有C基础的人理解起来并不困难。需要注意的是对task_list进行赋值后，这个结点的前后指针都会指向自己。
同样，对于等待队列，我们可以使用DECLARE_WAITQUEUE宏来定义并初始化一个等待队列项。
2 62#define __WAITQUEUE_INITIALIZER(name, tsk) { \
3 63 .private = tsk, \
4 64 .func = default_wake_function, \
5 65 .task_list = { NULL, NULL } }
6 66
7 67#define DECLARE_WAITQUEUE(name, tsk) \
8 68 wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
name要定义的等待队列项的名称；tsk是task_struct类型的指针变量，它指向这个等待队列项所对应的进程。
3.添加/移除等待队列
add_wait_queue添加函数将等待队列wait添加到以q为等待队列头的那个等待队列链表中。
2 23{
3 24 unsigned long flags;
4 25
5 26 wait->flags &= ~WQ_FLAG_EXCLUSIVE;
6 27 spin_lock_irqsave(&q->lock, flags);
7 28 __add_wait_queue(q, wait);
8 29 spin_unlock_irqrestore(&q->lock, flags);
9 30}
我们可以看到flags的结果必然是0，也就是说这个函数是将非互斥进程添加到等待队列当中。而且在调用具体的添加函数时候，使用关中断并保护现场的自旋锁方式使得添加操作每次只被一个进程访问。
具体的添加过程是将当前进程所对应的等待队列结点wait添加到等待队列头结点q之后。具体来说，就是将new->task_list结点添 加到以head->task_list为头指针的双链表当中。另外，通过add_wait_queue_exclusive函数可以将一个互斥进程 添加到等待队列当中。从添加过程可以发现，add_wait_queue函数会将非互斥进程添加到等待队列的前部。
2 123{
3 124 list_add(&new->task_list, &head->task_list);
4 125}
2 34{
3 35 unsigned long flags;
4 36
5 37 wait->flags |= WQ_FLAG_EXCLUSIVE;
6 38 spin_lock_irqsave(&q->lock, flags);
7 39 __add_wait_queue_tail(q, wait);
8 40 spin_unlock_irqrestore(&q->lock, flags);
9 41}
02 45{
03 46 unsigned long flags;
04 47
05 48 spin_lock_irqsave(&q->lock, flags);
06 49 __remove_wait_queue(q, wait);
07 50 spin_unlock_irqrestore(&q->lock, flags);
08 51}
09 150static inline void __remove_wait_queue(wait_queue_head_t *head,
10 151 wait_queue_t *old)
11 152{
12 153 list_del(&old->task_list);
13 154}
有了上述的基础，那么移除函数就简单了许多。
4.在等待队列上睡眠
如何实现进程的阻塞？大致过程就是将当前进程的状态设置成睡眠状态，然后将这个进程加入到等待队列即可。在linux内核中有一组函数接口来实现这个功能。
02 4314{
03 4315 sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
04 4316}
05 4317EXPORT_SYMBOL(interruptible_sleep_on);
06 4318
07 4319long __sched
08 4320interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
09 4321{
10 4322 return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
11 4323}
12 4324EXPORT_SYMBOL(interruptible_sleep_on_timeout);
13 4325
14 4326void __sched sleep_on(wait_queue_head_t *q)
15 4327{
16 4328 sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
17 4329}
18 4330EXPORT_SYMBOL(sleep_on);
19 4331
20 4332long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
21 4333{
22 4334 return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
23 4335}
24 4336EXPORT_SYMBOL(sleep_on_timeout);
02 4293sleep_on_common(wait_queue_head_t *q, int state, long timeout)
03 4294{
04 4295 unsigned long flags;
05 4296 wait_queue_t wait;
06 4297
07 4298 init_waitqueue_entry(&wait, current);
08 4299
09 4300 __set_current_state(state);
10 4301
11 4302 spin_lock_irqsave(&q->lock, flags);
12 4303 __add_wait_queue(q, &wait);
13 4304 spin_unlock(&q->lock);
14 4305 timeout = schedule_timeout(timeout);
15 4306 spin_lock_irq(&q->lock);
16 4307 __remove_wait_queue(q, &wait);
17 4308 spin_unlock_irqrestore(&q->lock, flags);
18 4309
19 4310 return timeout;
20 4311}
2 99{
3 100 q->flags = 0;
4 101 q->private = p;
5 102 q->func = default_wake_function;
6 103}
初始化完毕后，通过__set_current_state函数将当前进程的状态设置成state。接着，在自旋锁的保护下，将当前进程对应的等待 队列结点插入到等待队列链表当中。更重要的是，在schedule_timeout函数中不仅要设置进程的睡眠时间（以jiffies为单位的），还要使 用schedule函数进行重新调度。一旦使用了schedule函数后，也就意味这当前这个进程真正的睡眠了，那么接下来的代码会在它唤醒后执行。当该进程被唤醒后（资源可用时），会从等待队列中将自己对应的那个等待队列结点wait移除。
上述过程都是在自旋锁保护下进行的，并且在整个执行过程中不可被其他中断所打断。现在再回过头去看一开始的那四个睡眠函数接口，你就明白了它们各自的不同之处了。
5.唤醒函数
唤醒函数会唤醒以x为头结点的等待队列中的等待队列项所对应的进程。与睡眠函数类似，内核中也有一组函数可以对阻塞的进程进行唤醒。
2 171#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
3 172#define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
4
5 175#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
6 176#define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
7 177#define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
2 4000 int nr_exclusive, void *key)
3 4001{
4 4002 unsigned long flags;
5 4003
6 4004 spin_lock_irqsave(&q->lock, flags);
7 4005 __wake_up_common(q, mode, nr_exclusive, 0, key);
8 4006 spin_unlock_irqrestore(&q->lock, flags);
9 4007}
02 3976 int nr_exclusive, int wake_flags, void *key)
03 3977{
04 3978 wait_queue_t *curr, *next;
05 3979
06 3980 list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
07 3981 unsigned flags = curr->flags;
08 3982
09 3983 if (curr->func(curr, mode, wake_flags, key) &&
10 3984 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
11 3985 break;
12 3986 }
13 3987}
list_for_each_entry_safe函数将遍历整个等待队列中的链表，通过每次的逻辑判断来唤醒相应的进程。这个if语句初看起来有点麻烦，不过我们一点一点的将它拆解。
curr->func(curr, mode, sync, key)：即执行默认的唤醒函数，将指定的进程curr以mode方式唤醒。成功唤醒返回1；否则，返回0；
(flags & WQ_FLAG_EXCLUSIVE)：判断当前进程是否以互斥形式唤醒。是互斥形式则返回1；否则返回0；
!–nr_exclusive：nr_exclusive为需要唤醒的互斥进程的数量。
这三个部分是通过逻辑与连接起来的。根据逻辑与的运算规则，只有当第一部分为真时才会判断第二部分的值，依次再判断第三部分的值。
通过上述的等待队列的添加过程我们知道，等待队列中前面均是非互斥进程，后面才是互斥进程。因此，唤醒函数总先唤醒全部的非互斥进程。因为当 __wake_up_commom函数每一次去判断if语时，总会“不自觉”去执行默认的唤醒函数（除非唤醒失败，那么会退出遍历宏）；当全部的非互斥进 程被唤醒后，第二个判断条件也就成立了。因此__wake_up_commom函数会依次唤醒nr_exclusive个互斥进程；当 –nr_exclusive为0时（!–nr_exclusive也就为真），整个遍历过程也恰好结束，而此时if语句的三个判断条件才刚好满足（这段代码太强大了!!!）。
6.有条件的睡眠
与睡眠函数不同，条件睡眠是指当某些条件发生时，这个进程才会加入到等待队列当中。关于条件睡眠有下列的宏：
2 wait_event_timeout(wq, condition, timeout)
3 wait_event_interruptible(wq, condition)
4 wait_event_interruptible_timeout(wq, condition, timeout)
