Linux學(xué)習(xí)-等待隊列

我就簡要的分析分析等待隊列的一些問題，就相當(dāng)于自己的總結(jié)吧。邊學(xué)驅(qū)動，邊學(xué)內(nèi)核，還是蠻有意思的。

1、等待隊列的定義，包括兩個，等待隊列頭，節(jié)點(diǎn)。

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;

#define WQ_FLAG_EXCLUSIVE 0x01

void *private;

wait_queue_func_t func;

struct list_head task_list;

};

/*關(guān)于等待隊列的操作主要是初始化操作*/

#define DECLARE_WAIT_QUEUE_HEAD(name)

wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

/*就是初始化兩個元素*/

#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {

.lock = __SPIN_LOCK_UNLOCKED(name.lock),

.task_list = { &(name).task_list, &(name).task_list } }

#define init_waitqueue_head(q)

do {

static struct lock_class_key __key;

__init_waitqueue_head((q), &__key);

} while (0)

void __init_waitqueue_head(wait_queue_head_t *q, struct lock_class_key *key)

{

spin_lock_init(&q->lock);

lockdep_set_class(&q->lock, key);

INIT_LIST_HEAD(&q->task_list);

}

從上面的定義可知，實(shí)質(zhì)上等待隊列頭很簡單，只要就是一個鏈表頭，而等待隊列的節(jié)點(diǎn)主要包含了一個函數(shù)指針和對應(yīng)的參數(shù)，以及鏈表。

我們在驅(qū)動過程中主要使用的函數(shù)主要包括wait_event(),wait_event_interruptible()，wait_event_killable(),以及喚醒過程中的wait_up(),wait_up_interruptible().

基本的流程就是:

#define wait_event(wq, condition)

do {

if (condition)

/*添加滿足，則直接跳出*/

break;

/*負(fù)責(zé)進(jìn)入等待隊列*/

__wait_event(wq, condition);

} while (0)

#define __wait_event(wq, condition)

do {

/*定義新的等待隊列節(jié)點(diǎn)*/

DEFINE_WAIT(__wait);

for (;;) {/*一個循環(huán)的過程，可能導(dǎo)致堵塞*/

/*將添加的節(jié)點(diǎn)添加到隊列中，并改變進(jìn)程的運(yùn)行狀態(tài)*/

prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);

if (condition)/*如果條件合適了，就跳出當(dāng)前的循環(huán)，也就是等待條件獲得*/

break;

/*當(dāng)前進(jìn)程放棄CPU，進(jìn)行調(diào)度其他的進(jìn)程，這時的進(jìn)程進(jìn)入睡眠狀態(tài)

也就是說在schedule中函數(shù)就不在繼續(xù)執(zhí)行，只有調(diào)用wake_up函數(shù)喚

醒當(dāng)前的進(jìn)程，才會退出schedule函數(shù)，然后繼續(xù)執(zhí)行下面的函數(shù)，也就是繼續(xù)循環(huán)

真正的退出循環(huán)，只有當(dāng)條件滿足時，如果條件不滿足，調(diào)用wake_up函數(shù)

仍然不會滿足條件，只會再次調(diào)度，再次失去CPU，

根據(jù)上面的分析可知，只有上面的條件滿足了，并調(diào)用

wake_up函數(shù)才能跳出當(dāng)前的for循環(huán)。

*/

schedule();

}

/*完成等待*/

finish_wait(&wq, &__wait);

} while (0)

#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)

#define DEFINE_WAIT_FUNC(name, function)

wait_queue_t name = {

.private = current,

.func = function,

.task_list = LIST_HEAD_INIT((name).task_list),

}

void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)

{

unsigned long flags;

/*改變狀態(tài)*/

wait->flags &= ~WQ_FLAG_EXCLUSIVE;

spin_lock_irqsave(&q->lock, flags);

/*如果鏈表是空，則將當(dāng)前的這個節(jié)點(diǎn)添加進(jìn)來，這樣能避免wait被反復(fù)的添加，造成大量的浪費(fèi)*/

if (list_empty(&wait->task_list))

__add_wait_queue(q, wait);

/*修改當(dāng)前進(jìn)程的狀態(tài)*/

set_current_state(state);

spin_unlock_irqrestore(&q->lock, flags);

}

#define set_current_state(state_value)

set_mb(current->state, (state_value))

static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)

{

/*就是將鏈表添加進(jìn)來而已*/

list_add(&new->task_list, &head->task_list);

}

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

}

void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)

{

unsigned long flags;

/*修改當(dāng)前進(jìn)程的狀態(tài)為TASK_RUNNING,因此可以被執(zhí)行*/

__set_current_state(TASK_RUNNING);

/*

* We can check for list emptiness outside the lock

* IFF:

* - we use the "careful" check that verifies both

* the next and prev pointers, so that there cannot

* be any half-pending updates in progress on other

* CPUs that we havent seen yet (and that might

* still change the stack area.

* and

* - all other users take the lock (ie we can only

* have _one_ other CPU that looks at or modifies

* the list).

*/

/*刪除鏈表，實(shí)質(zhì)上就是釋放*/

if (!list_empty_careful(&wait->task_list)) {

spin_lock_irqsave(&q->lock, flags);

list_del_init(&wait->task_list);

spin_unlock_irqrestore(&q->lock, flags);

}

}

asmlinkage void __sched schedule(void)

{

struct task_struct *prev, *next;

unsigned long *switch_count;

struct rq *rq;

int cpu;

need_resched:

preempt_disable();

cpu = smp_processor_id();

rq = cpu_rq(cpu);

rcu_note_context_switch(cpu);

prev = rq->curr;

release_kernel_lock(prev);

need_resched_nonpreemptible:

schedule_debug(prev);

if (sched_feat(HRTICK))

hrtick_clear(rq);

raw_spin_lock_irq(&rq->lock);

switch_count = &prev->nivcsw;

if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {

if (unlikely(signal_pending_state(prev->state, prev))) {

prev->state = TASK_RUNNING;

} else {

/*

* If a worker is going to sleep, notify and

* ask workqueue whether it wants to wake up a

* task to maintain concurrency. If so, wake

* up the task.

*/

if (prev->flags & PF_WQ_WORKER) {

struct task_struct *to_wakeup;

to_wakeup = wq_worker_sleeping(prev, cpu);

if (to_wakeup)

try_to_wake_up_local(to_wakeup);

}

deactivate_task(rq, prev, DEQUEUE_SLEEP);

}

switch_count = &prev->nvcsw;

}

pre_schedule(rq, prev);

if (unlikely(!rq->nr_running))

idle_balance(cpu, rq);

put_prev_task(rq, prev);

next = pick_next_task(rq);

clear_tsk_need_resched(prev);

rq->skip_clock_update = 0;

if (likely(prev != next)) {

sched_info_switch(prev, next);

perf_event_task_sched_out(prev, next);

rq->nr_switches++;

rq->curr = next;

++*switch_count;

context_switch(rq, prev, next); /* unlocks the rq */

/*

* The context switch have flipped the stack from under us

* and restored the local variables which were saved when

* this task called schedule() in the past. prev == current

* is still correct, but it can be moved to another cpu/rq.

*/

cpu = smp_processor_id();

rq = cpu_rq(cpu);

} else

raw_spin_unlock_irq(&rq->lock);

post_schedule(rq);

if (unlikely(reacquire_kernel_lock(prev)))

goto need_resched_nonpreemptible;

preempt_enable_no_resched();

if (need_resched())

goto need_resched;

}

根據(jù)上面的各個函數(shù),宏定義可知，在wait_event函數(shù)中完成了大部分的事情，其中包括等待隊列節(jié)點(diǎn)的定義，添加，當(dāng)前進(jìn)程運(yùn)行狀態(tài)的改變，等待條件的滿足，跳出等待，函數(shù)介紹之前需要完成的任務(wù)是修改當(dāng)前進(jìn)程的狀態(tài)為TASK_RUNNING，刪除鏈表，釋放一些空間。

其他的函數(shù)wait_event_interruptible以及wait_event_killable具有相似的操作，只是對前期修改進(jìn)程狀態(tài)存在差別。wait_event_interruptible則不一定只能在條件滿足時喚醒，也可以被信號喚醒，而wait_event則在條件滿足時被喚醒。