wait_queue_head_t my_queue;

init_waitqueue_head(&my_queue);  //会将自旋锁初始化为未锁，等待队列初始化为空的双向循环链表。

//宏名用于定义并初始化，相当于"快捷方式"

DECLARE_WAIT_QUEUE_HEAD (my_queue);  

/*定义并初始化一个名为name的等待队列 ,注意此处是定义一个wait_queue_t类型的变量name，并将其private与设置为tsk*/

DECLARE_WAITQUEUE(name,tsk);

struct __wait_queue {

 unsigned int flags;

#define WQ_FLAG_EXCLUSIVE   0x01

 void *private;                       /* 通常指向当前任务控制块 */

 wait_queue_func_t func;

 struct list_head task_list;              /* 挂入wait_queue_head的挂载点 */

};

typedef struct __wait_queue wait_queue_t;

//设置等待的进程为非互斥进程，并将其添加进等待队列头(q)的队头中。

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

{

    unsigned long flags;

    wait->flags &= ~WQ_FLAG_EXCLUSIVE;

    spin_lock_irqsave(&q->lock, flags);

    __add_wait_queue(q, wait);

    spin_unlock_irqrestore(&q->lock, flags);

}

EXPORT_SYMBOL(add_wait_queue);

//下面函数也和add_wait_queue()函数功能基本一样，只不过它是将等待的进程(wait)设置为互斥进程。

void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)

{

    unsigned long flags;

    wait->flags |= WQ_FLAG_EXCLUSIVE;

    spin_lock_irqsave(&q->lock, flags);

    __add_wait_queue_tail(q, wait);

    spin_unlock_irqrestore(&q->lock, flags);

    }

    EXPORT_SYMBOL(add_wait_queue_exclusive);

//在等待的资源或事件满足时，进程被唤醒，使用该函数被从等待头中删除。
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

{

     unsigned long flags;

     spin_lock_irqsave(&q->lock, flags);

     __remove_wait_queue(q, wait);

     spin_unlock_irqrestore(&q->lock, flags);

}

EXPORT_SYMBOL(remove_wait_queue);

#define wait_event(wq, condition)

do {

        if (condition)

         break;

        __wait_event(wq, condition);

} while (0)

/**
* 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.
*/

wait_event(queue,condition);等待以queue为等待队列头等待队列被唤醒，condition必须满足，否则阻塞 

/**
* wait_event_interruptible - 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_INTERRUPTIBLE) until the
* @condition evaluates to true or a signal is received.
* 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.
*
* The function will return -ERESTARTSYS if it was interrupted by a
* signal and 0 if @condition evaluated to true.
*/

wait_event_interruptible(queue,condition);可被信号打断  

/**
* wait_event_timeout - sleep until a condition gets true or a timeout elapses
* @wq: the waitqueue to wait on
* @condition: a C expression for the event to wait for
* @timeout: timeout, in jiffies
*
* 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.
*
* The function returns 0 if the @timeout elapsed, or the remaining
* jiffies (at least 1) if the @condition evaluated to %true before
* the @timeout elapsed.
*/

wait_event_timeout(queue,condition,timeout);阻塞等待的超时时间，时间到了，不论condition是否满足，都要返回  

/**
* wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
* @wq: the waitqueue to wait on
* @condition: a C expression for the event to wait for
* @timeout: timeout, in jiffies
*
* The process is put to sleep (TASK_INTERRUPTIBLE) until the
* @condition evaluates to true or a signal is received.
* 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.
*
* Returns:
* 0 if the @timeout elapsed, -%ERESTARTSYS if it was interrupted by
* a signal, or the remaining jiffies (at least 1) if the @condition
* evaluated to %true before the @timeout elapsed.
*/

wait_event_interruptible_timeout(queue,condition,timeout) 

注意timeout的时间单位为jiffies。返回值timeout与不带timeout的也略有不同。

/*

 __wake_up - wake up threads blocked on a waitqueue.

 @q: the waitqueue

 @mode: which threads

 @nr_exclusive: how many wake-one or wake-many threads to wake up

 @key: is directly passed to the wakeup function

*/

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

}

    EXPORT_SYMBOL(__wake_up);

//唤醒等待队列.可唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERUPTIBLE状态的进程,和wait_event/wait_event_timeout成对使用

#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)

//和wake_up()唯一的区别是它只能唤醒TASK_INTERRUPTIBLE状态的进程.,与wait_event_interruptible

wait_event_interruptible_timeout

wait_event_interruptible_exclusive成对使用

#define wake_up_all(x)          __wake_up(x, TASK_NORMAL, 0, 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)

//这些也基本都和wake_up/wake_up_interruptible一样

void __sched sleep_on(wait_queue_head_t *q)

{

  sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);

}

static long __sched

sleep_on_common(wait_queue_head_t *q, int state, long timeout)

{

        unsigned long flags;

        wait_queue_t wait;

        init_waitqueue_entry(&wait, current);

        __set_current_state(state);

        spin_lock_irqsave(&q->lock, flags);

        __add_wait_queue(q, &wait);

        spin_unlock(&q->lock);

        timeout = schedule_timeout(timeout);

        spin_lock_irq(&q->lock);

        __remove_wait_queue(q, &wait);

        spin_unlock_irqrestore(&q->lock, flags);

        return timeout;

}

long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)

{

       return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);

}

EXPORT_SYMBOL(sleep_on_timeout);

 void __sched interruptible_sleep_on(wait_queue_head_t *q)

{

        sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);

}

EXPORT_SYMBOL(interruptible_sleep_on);

long __sched

interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)

{

    return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);

}

EXPORT_SYMBOL(interruptible_sleep_on_timeout);