8、Linux设备驱动的并发控制

一、并发与竞争

    并发是指多个 多个执行单元同时执行，而这对对共享的资源，比如硬件的资源、软件的全局变量、静态变量 的访问，很容易导致竞态，

1.1、中断屏蔽

    在单核的  CPU 里，避免竞态的一个简单有效的方法是，在进入临界区之前，就屏蔽系统的中断。也就是说，在进入临界区之前，中断被关闭，使得中断与进程之间的并发不会发生，而且，因为进程的调度器是依赖于中断来实现的，没有了中断，进程就不能被切换，保证了进程之间的并发不会发生。

方法：

local_irq_disable()

XXXXX 临界区的代码

local_irq_enable()

    虽然  local_irq_disable() 和 local_irq_enable() 可以关闭本 CPU 的中断，但是在 多核的  CPU里面，并不能解决问题，因为 它们只能禁止和使能本 CPU 的中断，并不能解决多 CPU 引发的竞争，所以在多个的里面，一般是将关闭中断的方法与 自旋锁 结合使用。

    如果指向禁止中断的底部，在应该使用 locak_bh_disable() ，使能的是， local_bh_enable();

1.2、原子操作

原子操作，可以保证对一个整型数据的修改的排他性，也就是说，原子操作是对一个数据进行操作，操作的过程，是不会被线程的调度机制给打断，也就是说，一旦开始，是绝对不会睡眠和阻塞的，直到操作结束。对于整形数的操作，分别是对整型数和位进行原子的操作。

1.2.1、整型原子的操作

（1）设置原子变量的值

void atomic_set(atomic_t *v,int i);     // 设置原子变量的值为 i

atomic_t v = ATOMIC_INIT(0)  ;    // 定义原子变量 V，并初始化为 0

（2）获取原子变量的值

atomic_read(atomic_t *v)    // 返回值就是原子变量的值

（3）原子的操作

void atomic_add(int i, atomic_t *v)    // i + v

void atomic_sub(int i,atomic_t *v ) // v – i

（4）操作并测试

int atomic_inc_an_test(atomic_t *v)   // 自加1，测试是否为0，使得话返回 true

int atomic_dec_and_test(atomic_t *v)  // 自减 1，测试是否为 0，使得话，返回 true

（5）操作与返回

int atomic_add_reture(int i, atomic_t *v);   // V + i，返回新的值

int  atomic _sub_return(int i, atomic_t *v)  // v – i ,返回新的值

int atomic_inc_return(atomic_t *v)   // V + 1

int atomic_dec_return(atomic_t *v) // V – 1

1.2.2、位原子的操作

（1）设置为

void set_bit(nr,void * addr)   // 设置地址 addr 的 第 nr 位 为 1

（2）清除位

void clear_bit(nr, void *addr)   // 设置地址 addr 的 第 nr 位 为 0

(3)改变位

void change_bit（nr, void *addr） // 设置地址 addr 的 第 nr 位 反转

(4)检测位

test_bit(nr, void *addr);   // 返回 addr 第  nr 位的  值

（5）测试与操作为

int test_and_set_bit(nr, void *addr);

    先进行测试，之后在进行位的设置。

1.2.3、原子操作的特性

    原子操作的特性，就对原子数的操作的时候，绝对不会被线程的调度器进行打断，也就说，这个时间段，是没进程的上下文之间的切换，进一步说，就是绝对不会出现睡眠和阻塞。

1.3、自旋锁

    自旋锁 spin  lock，是另外一种对临界资源进行互斥访问的手段，它的实现也是借助了 原子操作实现的。自旋锁的机制是，进程对资源的访问之前，需要对特性的内存进行读取，当读取到值，也就是获得到锁的时候，就有权限进入下一步的操作；而其他的进程没有获得到锁的时候，就就如原地的等待，然后再次进行读取，这个等待、读取的过程，我们称之为自旋。

1.3.1、自旋的 API

（1）锁的定义

spinlock_t lock;

（2）锁的初始化

spin_lock_init(lock)    // 完成初始化

（3）获得锁

spin_lock(lock)

    尝试去获得锁，如果获得，就马上返回，没有获得的话，就进入自旋的状态，Linux 也提供非阻塞的方式：

spin_trylock(lock)

    获得锁的时候，返回 true，没有获得的时候，就返回 false

(4)释放锁

spin_unlock(lock)

1.3.2、一般执行方式

spinlock_t lock;

spin_init_lock(lock);

spin_lock(lock);

XXXX 临界区代码

spin_unlock(lock);

1.3.3、自旋锁与中断

    在单 CPU 和内核可被抢占的系统中，自旋锁在获得锁的期间，内核的抢占就是被禁止的，因此，这个时候，是可以完全保证获得锁器件的临界区操作代码，不收到其他进程的打扰；但是在 多核的 CPU 中，其中的一个 CPU 获得了自旋锁，但是，只是在该 CPU 上的抢占调度被禁止了，其他核心的CPU 是并没有被禁止抢占调度的，所以为了保证在多核的情况，临界区不受到本 CPU 和其他的  CPU 抢占进程的打扰。

    因为自旋锁的底层是借助原子操作实现的，保证了获得锁的器件的操作是不会被被本 CPU 和其他 CPU 的进程调度所影响，而且，自旋锁关闭了抢占系统，但是这些特性并不能保证在得到锁的的时候，执行临界区代码的时候，不受到中断和底部（BH）的影响，也就是这个时候，本 CPU 的中断发生的时候，还是会反过来影响临界区的代码，所以一般是假如关闭中断的操作，这个时候就借助了锁的衍生机制

spin_lock_irq = spin_lock() + local_irq_disable()    // 获得锁的同时，关闭中断

spin_inlock_irq = spin_unlock() + local_irq_enable   // 释放锁的同时，打开中断

spin_lock_irqsave = spin_lock() + locak_irq_save()  // 获得锁的同时，关闭中断，且保存中断的状态

spin_lock_irqrestore() = spin_unlock() + locak_irq_restore()   // 释放锁的同时，将中断状态进行回复

spin_lock_bh() = spin_lock() + local_bh_disable() ;  // 获得锁的同时，关闭底部中断

spin_unlock_bh() = spin_unlock() + local_bh_enable  // 释放锁，且恢复底部中断

    当在自旋锁内部加了中断的时候，CPU0 获得了自旋锁，进入了原子的操而CPU 1 在 CPU0 还没有释放锁的时候，CPU1 就只等原地等待（浪费

了 CPU）；而且，中断的话，就避免受到  本 CPU 的影响，保证了内核并发的可能。

1.3.4、自旋锁注意事项

（1）因为在获得了自旋锁之后，CPU 就开始了原子的操作，其他的CPU 就会原地一直自旋，等待的过程，并不是睡眠，所以浪费了 N 多的资源，所以，一般上，进程拥有锁的时间都是非常的短的，这样才是比较的划算；如果临界区的代码非常大的话，其他的 CPU 就一直原地等待，浪费了资源，导致了系统性能的降低。

（2）进程在拥有一个锁的期间，不能再尝试去获取本锁，否则导致死锁。

（3）在获得自旋锁的器件，绝对不能出现进程调度的情况，也就是，绝对不能出现进程的睡眠和进程的阻塞，不能出现 copy_tousr或者copy_from_usr，kmalloc、msleep等函数，因为自旋锁实现就是通过原子操作实现的，原子操作的特性，就是一旦开始执行，绝对不会出现进程的调度，否则会导致内核的崩溃。

1.4、信号量

    信号量，是非常常用的一种同步互斥的手段，类似于灯，当等的个数不为零的时候，进程获取资源的时候，就将灯拿走一个；当释放资源的时候，就将灯放回去；当灯为零的时候，这个时候，进程将被挂起，进入睡眠的状态，直到被唤醒。

1.4.1、API

（1）定义信号量

struct semaphore sem；

（2）初始化信号量

void sema_init(struct semaphore * sem, int val)

    初始化信号量的值为 val

（3）获得信号量

int down(struct semaphore  * sem)

    获得信号量，和获得锁差不多，当没有得到信号量的时候，就进入睡眠的状态，也就是说，不能在中断里面被使用，因为中断全部被关闭了，进程的调度器是依赖中断实现的，没有了中断，当睡眠的进程，拥有没有进程调度器去唤醒进程，导致程序用死停在那里。内核也提供了可以被打断的接口

int down_interruptible(struct semaphore  *sem)

    回去尝试去获取信号量，没有获得的时候，进入睡眠，但是可以被打断，，

int dowun_trylock(struct semaphore  *sem)

   即使在没有活动信号量的情况下，也不会导致睡眠，而是立即返回，所以可以在中断的上下文进行使用

（4）释放信号量

void up(struct semaphore *sem)

当信号量初始化为 1 的时候，实现的就是互斥锁的功能

1.5、互斥锁

   互斥锁的使用方法，和信号量的几乎一模一样 ，只是接口名字不一样而已。

（1）定义互斥锁

struct mutex mymutex;

（2）初始化互斥锁

mutex_init( struct mutex *mymutex)

（3）获得互斥锁

void mutex_lock( struct mutex mymutex;)

   当然也有，void mutex_lock_interruptible( struct mutex mymutex;) 和 void mutex_trylock( struct mutex mymutex;)

（4）释放互斥锁

void mutex_unlock(struct mutex mymutex)

1.5.1、自旋锁和互斥锁的选择

   （1） 自旋锁在没有获得锁的时候，就只能是原地的等地，因此开销就是其他进程获得锁执行的时间；而互斥锁的话，在没有获得锁，就会睡眠当前的进程，锁带来的开销，是进程切换带来的开销。

    （2）互斥锁的过程，会带来进程的睡眠 ，因此，互斥锁是绝对不能出现在中断的上下文；自旋锁则不然，非常适合与中断一起配合使用；自旋锁保护的临界区，绝对不能出现进程的阻塞以及睡眠。