int down_interruptible(struct semaphore *sem)
            {
            unsigned long flags;
            int result = 0;
             
            spin_lock_irqsave(&sem->lock, flags);  //獲取自旋鎖，關(guān)閉中斷，將狀態(tài)寄存器值存放在flags
            /*如果信號(hào)量計(jì)數(shù)器值大于0，說明有多個(gè)空閑資源可訪問，可以成功獲取信號(hào)量了*/
            if (likely(sem->count > 0))    //likely表示成功獲取的概率大，通知編譯器進(jìn)行分支預(yù)測(cè)優(yōu)化
            sem->count--;
            else
            result = __down_interruptible(sem);    //進(jìn)入睡眠等待
            spin_unlock_irqrestore(&sem->lock, flags);
             
            return result;
            }
             
            static noinline int __sched __down_interruptible(struct semaphore *sem)
            {
            return __down_common(sem, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
            }

static inline int __sched __down_common(struct semaphore *sem, long state,
            long timeout)
            {
            struct task_struct *task = current;
            struct semaphore_waiter waiter;
             
            list_add_tail(&waiter.list, &sem->wait_list);   //加入到等待隊(duì)列
            waiter.task = task;
            waiter.up = 0;
             
            for (;;) {
            if (state == TASK_INTERRUPTIBLE && signal_pending(task))
            goto interrupted;
            if (state == TASK_KILLABLE && fatal_signal_pending(task))
            goto interrupted;
            if (timeout <= 0)
            goto timed_out;
            __set_task_state(task, state);
            spin_unlock_irq(&sem->lock);
            timeout = schedule_timeout(timeout);     //調(diào)度
            spin_lock_irq(&sem->lock);
            if (waiter.up)
            return 0;
            }
             
            timed_out:
            list_del(&waiter.list);
            return -ETIME;
             
            interrupted:
            list_del(&waiter.list);
            return -EINTR;
            }

互斥鎖

信號(hào)量的初始值表示可以有多少個(gè)任務(wù)可同時(shí)訪問的共享資源，如果初始值為1，表示只有1個(gè)任務(wù)可以訪問，信號(hào)量變成互斥鎖（Mutex）。可見互斥鎖是信號(hào)量的特例。

互斥鎖（mutex）是在原子操作API的基礎(chǔ)上實(shí)現(xiàn)的信號(hào)量行為?；コ怄i不能進(jìn)行遞歸鎖定或解鎖，能用于交互上下文，同一時(shí)間只能有一個(gè)任務(wù)持有互斥鎖。

互斥鎖功能上基本上與信號(hào)量一樣，互斥鎖占用空間比信號(hào)量小，運(yùn)行效率比信號(hào)量高?；コ怄i的API函數(shù)功能說明如表1。

互斥鎖用結(jié)構(gòu)mutex描述，它含有信號(hào)量計(jì)數(shù)和等待隊(duì)列成員，信號(hào)量的值為1或0或負(fù)數(shù)。其列出如下（在include/linux/mutex.h中）：

struct mutex {
            /* 1：表示解鎖，0：表示鎖住，負(fù)數(shù)：表示鎖住，可能有等待者*/
            atomic_t		count;
            spinlock_t		wait_lock;  /*操作等待隊(duì)列的自旋鎖*/
            struct list_head	wait_list;   /*等待隊(duì)列*/
            /*省略了用于調(diào)試的結(jié)構(gòu)成員*/
            };

struct rw_semaphore {
            /*讀/寫信號(hào)量定義：
            * - 如果activity為0，那么沒有激活的讀者或?qū)懻摺?            * - 如果activity為+ve，那么將有ve個(gè)激活的讀者。
            * - 如果activity為-1，那么將有1個(gè)激活的寫者。 */
            __s32			activity;   /*信號(hào)量值*/
            spinlock_t		wait_lock;   /*用于鎖等待隊(duì)列wait_list*/
            struct list_head	wait_list;    /*如果非空，表示有進(jìn)程等待該信號(hào)量*/
            #ifdef CONFIG_DEBUG_LOCK_ALLOC  /*用于鎖調(diào)試*/
            struct lockdep_map dep_map;
            #endif
            };

void __sched down_read(struct rw_semaphore *sem)
            {
            might_sleep();     /*用于調(diào)試自旋鎖睡眠*/
            rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_); /*確認(rèn)獲得鎖，用于調(diào)試*/
            /*跟蹤鎖狀態(tài)信息（如：鎖深度），用于調(diào)試*/
            LOCK_CONTENDED(sem, __down_read_trylock, __down_read);
            }

void __sched __down_read(struct rw_semaphore *sem)
            {
            struct rwsem_waiter waiter;
            struct task_struct *tsk;
             
            spin_lock_irq(&sem->wait_lock);
            /*如果有0或多個(gè)讀者，并且等待隊(duì)列為空，就可以獲取sem*/
            if (sem->activity >= 0 && list_empty(&sem->wait_list)) {
            /* 獲得sem */
            sem->activity++;  /*讀者計(jì)數(shù)加1*/
            spin_unlock_irq(&sem->wait_lock);
            goto out;
            }
             
            /*運(yùn)行到這里，說明不能獲取sem，將當(dāng)前進(jìn)程加入等待隊(duì)列進(jìn)行等待*/
            tsk = current;
            set_task_state(tsk, TASK_UNINTERRUPTIBLE);
             
            /* 建立等待隊(duì)列成員*/
            waiter.task = tsk;
            waiter.flags = RWSEM_WAITING_FOR_READ;  /*表示等待讀操作*/
            get_task_struct(tsk);   /*進(jìn)程使用計(jì)數(shù)加1*/
             
            list_add_tail(&waiter.list, &sem->wait_list);  /*將等待成員加到等待隊(duì)列尾*/
             
            /* 不再需要訪問等待隊(duì)列，因此，這里解鎖*/
            spin_unlock_irq(&sem->wait_lock);
             
            /* 讀者等待獲取sem */
            for (;;) {
            if (!waiter.task)
            break;
            schedule();
            set_task_state(tsk, TASK_UNINTERRUPTIBLE);
            }
            /*運(yùn)行這里，退出等待，說明可以獲取sem了*/
            tsk->state = TASK_RUNNING;
            out:
            ;
            }

void up_read(struct rw_semaphore *sem)
            {
            rwsem_release(&sem->dep_map, 1, _RET_IP_);  /*獲取解鎖信息，用于調(diào)試*/
             
            __up_read(sem);
            }

void __up_read(struct rw_semaphore *sem)
            {
            unsigned long flags;
             
            spin_lock_irqsave(&sem->wait_lock, flags);
            /*如果所有讀者完成讀操作，并且有寫者等待，那么喚醒一個(gè)寫者*/
            if (--sem->activity == 0 && !list_empty(&sem->wait_list))
            sem = __rwsem_wake_one_writer(sem);
             
            spin_unlock_irqrestore(&sem->wait_lock, flags);
            }
             
            /*喚醒一個(gè)寫者*/
            static inline struct rw_semaphore *
            __rwsem_wake_one_writer(struct rw_semaphore *sem)
            {
            struct rwsem_waiter *waiter;
            struct task_struct *tsk;
             
            sem->activity = -1;  /*表示有一個(gè)寫者正在寫操作*/
             
            /*獲取一個(gè)等待者*/
            waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
            list_del(&waiter->list);  /*將該等待者從等待隊(duì)列刪除*/
             
            tsk = waiter->task;
            smp_mb();   /*加內(nèi)存屏障，確保完成上面的指針引用操作*/
            waiter->task = NULL;
            wake_up_process(tsk);  /*喚醒進(jìn)程*/
            put_task_struct(tsk);    /*進(jìn)程上下文使用計(jì)數(shù)減1*/
            return sem;
            }

void __sched down_write(struct rw_semaphore *sem)
            {
            might_sleep();
            rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);
             
            LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
            }
             
            void __sched __down_write(struct rw_semaphore *sem)
            {
            __down_write_nested(sem, 0);
            }

void __sched __down_write_nested(struct rw_semaphore *sem, int subclass)
            {
            struct rwsem_waiter waiter;
            struct task_struct *tsk;
             
            spin_lock_irq(&sem->wait_lock);
            /*如果沒有讀者，并且等待隊(duì)列為空（說明沒有寫者）時(shí)，寫者才能獲取寫者鎖*/
            if (sem->activity == 0 && list_empty(&sem->wait_list)) {
            /* 獲取寫者鎖*/
            sem->activity = -1;
            spin_unlock_irq(&sem->wait_lock);
            goto out;
            }
             
            /*運(yùn)行到這里，說明有讀者或?qū)懻咴诓僮?，需要等?/
            tsk = current;
            set_task_state(tsk, TASK_UNINTERRUPTIBLE);
             
            /* 建立等待隊(duì)列成員*/
            waiter.task = tsk;
            waiter.flags = RWSEM_WAITING_FOR_WRITE; /*標(biāo)識(shí)為等待寫操作*/
            get_task_struct(tsk);    /*進(jìn)程上下文使用計(jì)數(shù)加1*/
             
            list_add_tail(&waiter.list, &sem->wait_list);  /*加到等待隊(duì)列尾*/
            spin_unlock_irq(&sem->wait_lock);
             
            /* 進(jìn)行等待*/
            for (;;) {
            if (!waiter.task)
            break;
            schedule();
            set_task_state(tsk, TASK_UNINTERRUPTIBLE);
            }
            /*被喚醒*/
            tsk->state = TASK_RUNNING;
            out:
            ;
            }

void up_write(struct rw_semaphore *sem)
            {
            rwsem_release(&sem->dep_map, 1, _RET_IP_);
             
            __up_write(sem);
            }
             
            void __up_write(struct rw_semaphore *sem)
            {
            unsigned long flags;
             
            spin_lock_irqsave(&sem->wait_lock, flags);
             
            sem->activity = 0;  /*表示有0個(gè)讀者*/
            if (!list_empty(&sem->wait_list))
            sem = __rwsem_do_wake(sem, 1); /*喚醒等待者*/
             
            spin_unlock_irqrestore(&sem->wait_lock, flags);
            }