Linux内核的sleep/wakeup机制非常重要，几乎贯穿了所有的内核子系统，值得注意的是，这里的sleep/wakeup依然采用了OO的思想，并没有限制睡眠的entry一定要是一个task，而是将睡眠的entry做了一层抽象，即：

struct __wait_queue {
    unsigned int flags;
    // 至于这个private到底是什么，内核并不限制，它可以是task，也可以是别的。
    void *private;
    wait_queue_func_t func;
    struct list_head task_list; //挂在链表__wait_queue_head
};
typedef struct __wait_queue wait_queue_t;

以上的这个entry，最终要睡眠在下面的数据结构实例化的一个链表上：

struct __wait_queue_head {
    spinlock_t lock;
    struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;

被等待的事件会提供链表wait_queue_head_t，等待事件的进程会初始化wait_queue_t，然后插入被等待事件的链表wait_queue_head_t后开始睡眠等待。
当事件发生后，会遍历链表wait_queue_head_t上的wait_queue_t，执行其func函数default_wake_function将等待进程唤醒。

entry初始化

//调用此函数的一般是需要将调用进程睡眠等待事件发生
//事件发生时调用default_wake_function来唤醒调用进程

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;
}

//调用此函数的一般不会是打算唤醒进程，而是事件发生时，调用func来做其他事情，比如epoll_ctl添加监听目标

static inline void
init_waitqueue_func_entry(wait_queue_t *q, wait_queue_func_t func)
{
    q->flags    = 0;
    q->private  = NULL;
    q->func     = func;
}

将entry添加到等待队列

有四个版本的添加函数用来将wait_queue_t添加到链表wait_queue_head_t
a. 直接添加到队列头部

static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
{
    list_add(&new->task_list, &head->task_list);
}

b. 设置exclusive标志，并添加到队列头部 //epoll_wait使用此函数

/*
 * Used for wake-one threads:
 */
static inline void
__add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
{
    wait->flags |= WQ_FLAG_EXCLUSIVE;
    __add_wait_queue(q, wait);
}

c. 直接添加到队列尾部

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

d. 设置exclusive标志，并添加到队列尾部 //accept使用此函数

static inline void
__add_wait_queue_tail_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
{
    wait->flags |= WQ_FLAG_EXCLUSIVE;
    __add_wait_queue_tail(q, wait);
}

删除entry

//将old entry从链表中删除

static inline void
__remove_wait_queue(wait_queue_head_t *head, wait_queue_t *old)
{
    list_del(&old->task_list);
}

唤醒任务

//将wait_queue_head_t 上的任务唤醒

void __wake_up(wait_queue_head_t *q, unsigned int mode,
            int nr_exclusive, void *key)
{
    unsigned long flags;

    spin_lock_irqsave(&q->lock, flags);
    __wake_up_common(q, mode, nr_exclusive, 0, key);
    spin_unlock_irqrestore(&q->lock, flags);
}
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;
        //调用__pollwake或者default_wake_function将进程唤醒
        //如果设置了WQ_FLAG_EXCLUSIVE，则只唤醒nr_exclusive个任务
        if (curr->func(curr, mode, wake_flags, key) &&
                (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
            break;
    }
}