<acronym id="xonnx"></acronym>
      <td id="xonnx"></td>
    1. <pre id="xonnx"></pre>

      1. 專注電子技術學習與研究
        當前位置:單片機教程網 >> MCU設計實例 >> 瀏覽文章

        Linux學習-等待隊列

        作者:公平   來源:本站原創   點擊數:  更新時間:2014年03月14日   【字體:

        由于學習linux驅動編程,學習到了堵塞型IO讀寫,等待隊列的操作比較的有意思,拿來分析分析,其中的一些代碼還是蠻有意思的,感受到了linux的美,體會到了藝術家和一般程序員的差別。
        我就簡要的分析分析等待隊列的一些問題,就相當于自己的總結吧。邊學驅動,邊學內核,還是蠻有意思的。
        1、等待隊列的定義,包括兩個,等待隊列頭,節點。

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

         /*關于等待隊列的操作主要是初始化操作*/
        #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);
        }

        從上面的定義可知,實質上等待隊列頭很簡單,只要就是一個鏈表頭,而等待隊列的節點主要包含了一個函數指針和對應的參數,以及鏈表。
        我們在驅動過程中主要使用的函數主要包括wait_event(),wait_event_interruptible(),wait_event_killable(),以及喚醒過程中的wait_up(),wait_up_interruptible().
        基本的流程就是:

            #define wait_event(wq, condition)                     \
            do {                                    \
                if (condition)
            /*添加滿足,則直接跳出*/                             \
                    break; 
                /*負責進入等待隊列*/                          \
                __wait_event(wq, condition);                    \
            } while (0)

        #define __wait_event(wq, condition) \
        do { \
        /*定義新的等待隊列節點*/
               DEFINE_WAIT(__wait); \
        \
        for (;;) {/*一個循環的過程,可能導致堵塞*/
                        /*將添加的節點添加到隊列中,并改變進程的運行狀態*/ \
        prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \
        if (condition)/*如果條件合適了,就跳出當前的循環,也就是等待條件獲得*/ \
        break; \
        /*當前進程放棄CPU,進行調度其他的進程,這時的進程進入睡眠狀態
                          也就是說在schedule中函數就不在繼續執行,只有調用wake_up函數喚
                          醒當前的進程,才會退出schedule函數,然后繼續執行下面的函數,也就是繼續循環
                          真正的退出循環,只有當條件滿足時,如果條件不滿足,調用wake_up函數
                          仍然不會滿足條件,只會再次調度,再次失去CPU,
                          根據上面的分析可知,只有上面的條件滿足了,并調用
                          wake_up函數才能跳出當前的for循環。
                         */
        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;
                /*改變狀態*/
        wait->flags &= ~WQ_FLAG_EXCLUSIVE;
        spin_lock_irqsave(&q->lock, flags);
                /*如果鏈表是空,則將當前的這個節點添加進來,這樣能避免wait被反復的添加,造成大量的浪費*/
        if (list_empty(&wait->task_list))
        __add_wait_queue(q, wait);
        /*修改當前進程的狀態*/
        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)
        {
                /*就是將鏈表添加進來而已*/
        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;
               /*修改當前進程的狀態為TASK_RUNNING,因此可以被執行*/
        __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
        *    CPU's that we haven't 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).
        */
                /*刪除鏈表,實質上就是釋放*/
        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;
        }
        根據上面的各個函數,宏定義可知,在wait_event函數中完成了大部分的事情,其中包括等待隊列節點的定義,添加,當前進程運行狀態的改變,等待條件的滿足,跳出等待,函數介紹之前需要完成的任務是修改當前進程的狀態為TASK_RUNNING,刪除鏈表,釋放一些空間。
        其他的函數wait_event_interruptible以及wait_event_killable具有相似的操作,只是對前期修改進程狀態存在差別。wait_event_interruptible則不一定只能在條件滿足時喚醒,也可以被信號喚醒,而wait_event則在條件滿足時被喚醒。

        關閉窗口

        相關文章

        欧美性色欧美精品视频,99热这里只有精品mp4,日韩高清亚洲日韩精品一区二区,2020国自产拍精品高潮