Linux设备驱动中的并发控制

1.1 中断屏蔽
DMB
数据存储器隔离。DMB 指令保证： 仅当所有在它前面的存储器访问操作
都执行完毕后，才提交(commit)在它后面的存储器访问操作。
DSB
数据同步隔离。比 DMB 严格： 仅当所有在它前面的存储器访问操作
都执行完毕后，才执行在它后面的指令（亦即任何指令都要等待存储器访 问操作——译者注）
ISB
指令同步隔离。最严格：它会清洗流水线，以保证所有它前面的指令都执
行完毕之后，才执行它后面的指令。

linux内核的自旋锁、互斥体等互斥逻辑，需要用到上述指令：在请求获得锁时候，调用屏障指令；在解锁时候，也需要调用屏障指令；

基于内存屏障指令的互斥逻辑：

LOCKED      EQU 1
UNLOCKED    EQU 0
lock_mutex
    ;互斥量是否锁定?
    LDREX r1, [r0]      ;检查是否锁定
    CMP r1, #LOCKED ;和"locked"比较
    WFEEQ               ;互斥量已经锁定, 进入休眠
    BEQ lock_mutex      ;被唤醒, 重新检查互斥量是否锁定
    ;尝试锁定互斥量
    MOV r1, #LOCKED
    STREX r2, r1, [r0]  ;尝试锁定
    CMP r2, #0x0 ;检查STR指令是否完成
    BNE lock_mutex      ;如果失败重试
    DMB                 ;进入被保护的资源前需要隔离, 保证互斥量已经被更新
    BX lr

unlock_mutex
    DMB                 ;保证资源的访问已经结束
    MOV r1, #UNLOCKED ;向锁定域写"unlocked"
    STR r1, [r0]

    DSB                 ;保证在CPU唤醒前完成互斥量状态更新
    SEV                 ;像其他CPU发送事件, 唤醒任何等待事件的CPU
    BX lr

1.2 原子操作：
原子操作可以保证对一个整型数据的修改是排他性的。Linux内核提供了一些了函数来实现内核中的原子操作，分为两类，分别针对位和整型变量进行原子操作

1.3 自旋锁：
自旋锁（Spin Lock）是一种典型的对界资源进行互斥访问的手段，其名称来源自它的工作方式；
最简单的方法把它当做一个变量看待，该变量把一个临界区标记为“我当前在运行，请稍等一会”或者标记为“我当前不在运行，可以被使用”
相关操作有以下四种：

1.定义自旋转
spinlock_t lock;
2.初始化自旋锁
spin_lock_init(lock) 该宏用于动态初始化自旋锁； 3.获得自旋锁 spin_lock(lock) 该宏用于获得自旋锁lock，如果能够立即获得锁，它就马上返回，否则，它将在那里自旋，知道该自旋锁的保持者释放； spin_trylock(lock) 该宏用于获得自旋锁lock，如果能够立即获得锁，它获得锁并返回true，否则立即返回false，实际上不再“在原地打转” 4.释放自旋锁 spin_unlock(lock) 该宏释放自旋锁lock，它与spin_trylock或spin_lock配对使用 

自旋锁使用例子：

spinlock_t lock

spin_lock_init(&lock);

spin_lock(&lock);

.../*临界区*/

spin_unlock(&lock);

自旋锁主要针对 SMP 或单 CPU 但内核可抢占的情况，对于单 CPU 和内核不支持抢占的系统，自旋锁退化为空操作。在单CPU内核可抢占的系统中，自旋锁持有期间内核的抢占将被禁止。
由于内核可抢占的单 CPU 系统的行为实际很类似于 SMP系统，因此，在这样的单 CPU 系统中使用自旋锁仍十分必要。
尽管用了自旋锁可以保证临界区不受别的 CPU 和本 CPU 内的抢占进程打扰，但是得到锁的代码路径在执行临界区的时候还可能受到中断和底半部（BH）的影响。
为了防止这种影响，就需要用到自旋锁的衍生。spin_lock()/spin_unlock()是自旋锁机制的基础，
它们和关中断 local_irq_ disable()/开中断 local_irq_enable()、关底半部local_bh_disable()/开底半部 local_bh_enable()、关中断并保存状态字 local_irq_save()/开中断并恢复状态 local_irq_restore()结合就形成了整套自旋锁机制，关系如下所示：

spin_lock_irq() = spin_lock() + local_irq_disable() spin_unlock_irq() = spin_unlock() + local_irq_enable() spin_lock_irqsave() = spin_unlock() + local_irq_save() spin_unlock_irqrestore() = spin_unlock() + local_irq_restore() spin_lock_bh() = spin_lock() + local_bh_disable() spin_unlock_bh() = spin_unlock() + local_bh_enable()

spin_lock_irq()、spin_lock_irqsave()、spin_lock_bh()类似函数会为自旋锁的使用系好“安全带”以避免突如其来的中断驶入对系统造成的伤害。

驱动工程师应谨慎使用自旋锁，而且在使用中还要特别注意如下几个问题。
（1）自旋锁实际上是忙等锁，当锁不可用时，CPU一直循环执行“测试并设置”该锁直到可用而取得该锁，CPU在等待自旋锁时不做任何有用的工作，仅仅是等待。因此，只有在占用锁的时间极短的情况下，使用自旋锁才是合理的。当临界区很大，或有共享设备的时候，需要较长时间占用锁，使用自旋锁会降低系统的性能。
（2）自旋锁可能导致系统死锁，引发这个问题最常见的情况是递归使用一个自旋锁，即如果一个已经拥有某个自旋锁的CPU想第二次获得这个自旋锁，则该CPU将死锁。
（3）自旋锁锁定期间不能调用可能引起进程调度的函数，如果进程获得自旋锁之后再阻塞，如调用copy_from_user()、copy_to_user()、kmalloc()和msleep()等函数，则可能导致内核的崩溃。

1.4 信号量
信号量（semaphore）是用于保护临界区的一种常用方法，它的使用方式和自旋锁类似。与自旋锁相同，只有得到信号量的进程才能执行临界区代码，但是，与自旋锁不同的是，当获取不到信号量时，进程不会原地打转而是进入休眠等待状态。
1.4.1 Linux中与信号量相关的操作主要有：

1.定义信号量
      下面代码定义名称为sem的信号量：struct semaphore sem；
2.初始化信号量
      void sema_init(struct semaphore *sem, int val);

该函数初始化信号量，并设置信号量sem的值为val。尽管信号量可以被初始化为大于1的值，从而成为一个计数信号量，但是它通常不被这样使用。

#define init_MUTEX(sem)        sema_init(sem, 1)
      该宏用于初始化一个用于互斥的信号量，它把信号量sem的值设置为1。
#define init_MUTEX_LOCKED(sem)        sema_init(sem, 0)
      该宏也用于初始化一个信号量，但他把信号量sem的值设置为0.
      下面两个宏是定义并初始化信号量的“快捷方式”：
          DECLARE_MUTEX(name)
          DECLARE_MUTEX_LOCKED(name)
      前者定义一个名为name的信号量并初始化为1，后者定义一个名为name的信号量并初始化为0。

1.4.2.获得信号量

void down(struct semaphore *sem);
       该函数用于获得信号量sem，它会导致休眠，因此不能在中断上下文使用。
int down_interruptible(struct semaphore *sem);
       该函数功能与down类似，不同之处为，因为down()而进入睡眠状态的进程不能被信号打断，但因为down_interruptible()而进入睡眠状态的进程能被信号打断，信号会导致该函数返回，这时候的返回值非0.
int down_trylock(struct semphore *sem);
       该函数尝试获得信号量sem，如果能够立刻获得，它就获得该信号量并返回0，否则，返回非0值。它不会导致调用者睡眠，可以在中断上下文使用。
        在使用down_interruptible()获取信号量时，对返回值一般会进行检查，如果非0，通常立即返回-ERESTARTSYS。

1.4.3.释放信号量
void up(struct semphore *sem);
该函数释放信号量sem，唤醒等待者。

1.4.4 信号量用于同步
如果信号量被初始化为0，则它可以用于同步，同步意味着一个执行单元的继续执行需等待另一执行单元完成某事，保证执行的先后顺序。

1.4.5 完成量用于同步
完成量（completion），它用于一个执行单元等待另一个执行单元执行完成某事。
Linux中与completion相关的操作主要有以下4种：

1.定义完成量
        下列代码定义名为my_completion的完成量：
        struct completion my_completion;
2.初始化completion
        下列代码初始化my_completion这个完成量：
        init_completion(&my_completion);
        对my_completion的定义和初始化可以通过如下快捷方式下实现： 
        DECLARE_COMPLETION(my_completion);
3.等待完成量
         下列函数用于等待一个completion被唤醒：
         void wait_for_completion(struct completion *c);
4.唤醒完成量
         下面两个函数用于唤醒完成量：
         void completion(struct completion *c);
         void complete_all(struct completion *c);
         前者只唤醒一个等待的执行单元，后者释放所有等待同一完成量的执行单元。

1.4.4 读写信号量
读写信号量与信号量的关系与读写自旋锁和自旋锁的关系类似，读写信号量可能引起进程阻塞，但它允许N个读执行单元同时访问共享资源，而最多只能有一个写执行单元。
因此，读写信号量是一种相对放宽条件的粒度稍大于信号量的互斥机制。
读写信号量涉及的操作包括以下5种：

1.定义和初始化读写信号量
        struct rw_semaphore my_rws;        /*定义读写信号量*/
        void init_rwsem(struct rw_semaphore *sem);        
        /*初始化读写信号量*/
2.读信号量获取
        void down_read(struct rw_semaphore *sem);
        int down_read_trylock(struct rw_semaphore *sem);
3.读信号量释放
        void up_read(struct rw_semaphore *sem);
4.写信号量获取
        void down_write(struct rw_semaphore *sem);
        int down_write_trylock(struct rw_semaphore *sem);
5.写信号量释放
        void up_write(struct rw_semaphore *sem);

1.5 互斥体
尽管信号量已经可以实现互斥的功能，而且包含DECLARE_MUTEX()、init_MUTEX()等定义信号量的宏或函数，
下面代码定义名为my_mutex的互斥体并初始化它：

    struct mutex my_mutex;
    mutex_init(&my_mutex);

下面的两个函数用于获取互斥体：

void inline __sched mutex_lock(struct mutex *lock);
int __sched mutex_lock_interruptible(struct mutex *lock);
int __sched mutex_trylock(struct mutex *lock);

mutex_lock()与mutex_lock_interruptible()的区别和down()与down_trylock()的区别完全一致，前者引起的睡眠不能被信号打断，而后者可以。
mutex_trylock()用于尝试获得mutex，获取不到mutex时不会引起进程睡眠。
下列函数用于释放互斥体：
void __sched mutex_unlock(struct mutex *lock);