Linux设备驱动程序笔记(4)

第四章 并发和竞态

• 并发及其管理

 大部分竞态可通过使用内核的并发控制原语，并应用几个基本的原理来避免。第一个规则是，只要可能，就应该避免资源的共享，这种思想的明显应用就是避免使用全局变量。但硬件资源本质上就是共享的，软件资源经常需要对其他执行线程可用。全局变量并不是共享数据的唯一途径，只要我们的代码将一个指针传递给了内核的其他部分，一个新的共享就可能建立。在单个执行线程之外共享硬件或软件资源的任何时候，因为另外一个线程可能产生对该资源的不一致观察，因此必须显示地管理对该资源的访问。访问管理的常见技术是“锁定”或“互斥”——确保一次只有一个执行线程可操作共享资源。

• 信号量和互斥体

   临界区：在任意给定的时刻，代码只能被一个线程执行。并不是所有的机制都是一样的，因此内核为不同的需求提供了不同的原语。

   进程休眠：当一个Linux进程到达某个时间点，此时它不能进行任何处理时，它将进入休眠状态，这将把处理器让给其他执行线程直到将来它能够继续完成自己的处理为止。我们可以使用一种锁定机制，当进程在等待临界区的访问时，此机制可让进程进入休眠状态。重要的是，我们将执行另外一个操作，该操作也可能会休眠，因此休眠可能在任何时刻发生。为了让我们的临界区正确工作，我们选择使用的锁定原语必须在其他拥有这个锁并休眠的情况下工作。

   信号量是一个众所周知的概念，一个信号量本质上是一个整数，它和一对函数联合使用，这一对函数通常称为P和V。希望进入临界区的进程将在相关信号量上调用P；如果信号量的值大于0，则该值会减小1，而进程继续。相反，如果信号量的值为0(或更小)，进程必须等待直到其他人释放该信号量。对信号量的解锁通过调用V完成；该函数增加信号量的值，并在必要时唤醒等待的进程。当信号量用于互斥时，信号量的值该初始化为1。

1. Linux信号量的实现

   要使用信号量，内核代码必须包含<asm/semaphore.h>。相关的类型是struct semaphore。

   a. 信号量的声明和初始化：直接创建信号量void sema_init(struct semaphore *sem, int val),其中val是信号量的初始值

   DECLART_MUTEX(name);

   DECLARE_MUTEX_LOCKED(name)；

   第一个宏初始化信号量name的初始值为1，第二个宏初始值为0.如果互斥体在运行时被初始化，使用下面的函数之一：

   void init_MUTEX(struct semaphore *sem)

   void init_MUTEX_LOCKED(struct semaphore *sem);

   b. 在Linux世界中，P函数被称为down，或者该名字的其他变种。
   

   void down(struct semaphore *sem);----减小信号量的值，并在必要时一直等待。

   int down_interruptible(struct semaphore *sem);----完成与down相同的工作，但操作是可以中断的。

   int down_trylock(struct semaphore *sem);----永远不会休眠，如果信号量在调用时不可获得，会立即返回非零值。

   当一个线程成功调用上述down的某个版本后，就称该线程“拥有”了该信号量，这样，该线程就被赋予访问由该信号量包含的临界区的权利。当互斥操作完成后，必须返回该信号量。Linux等价于V的函数是up：void up(struct semaphore *sem);任何拿到信号量的线程都必须通过一次对up调用而释放该信号量。

   在出现错误的情况下，经常需要特别小心；如果在拥有一个信号量时发生错误，必须在将错误状态返回给调用者之前释放该信号量。

• 互斥体

“互斥体（mutex）”这个称谓所指的是任何可以睡眠的强制互斥锁，比如使用计数是1的信号量。但在最新的Linux内核中，“互斥体（mutex）”这个称谓现在也用于一种实现互斥的特定睡眠锁。也就是说，互斥体是一种互斥信号。

mutex在内核中对应的数据结构是mutex，其行为和使用计数为1的信号量类似，但操作接口更简单，实现也更高效，而且使用限制更强。使用互斥体需包含<linux/mutex.h>。

1、定义及初始化互斥体

静态定义互斥体（声明+初始化宏）

DEFINE_MUTEX(mutexname);

运行时动态初始化互斥体

mutex_init(&mutex);

2、获取互斥体

void mutex_lock(struct mutex *lock);

int mutex_lock_interruptible(struct mutex *lock);

int mutex_trylock(struct mutex *lock);

上述函数的操作行为和信号量的down有类似之处，try函数永不睡眠。

3、释放互斥体

1 void mutex_unlock(struct mutex *lock);

4、mutex的使用

struct mutex my_mutex; // 定义mutex

mutex_init(&my_mutex); // 初始化mutex

mutex_lock(&my_mutex); // 获取mutex

/* 临界区 */

mutex_unlock(&my_mutex); // 释放mutex

mutex的使用方法和信号量用于互斥的场合完全一样。

• 读取者/写入者信号量

   信号量对所有的调用者互斥，而不管每个线程到底想做什么。

   允许多个并发的读取者是可能的，Linux内核为这种情形提供了一种特殊的信号量类型，称为“rwsem”（或者reader/write semaphore，读取者/写入者信号量）。使用rwsem的代码必须包含<linux/rwsem.h>，rwsem相关的数据类型是struct rw_semaphore。

1、初始化rwsem

init_rwsem(struct rw_semaphore *sem);

2、只读访问，可用接口

void down_read(struct rw_semaphore *sem);

int down_read_trylock(struct rw_semaphore *sem);

void up_read(struct rw_semaphore *sem);

3、针对写入者的接口

void down_write(struct rw_semaphore *sem);

int down_write_trylock(struct rw_semaphore *sem);

void up_write(struct rw_semaphore *sem);

/* downgrade write lock to read lock */

void downgrade_write(struct rw_semaphore *sem);

在结束修改之后，可以调用downgrade_write，来允许其他读取者的访问。

   一个rwsem可允许一个写入者或无限多个读取者拥有该信号量。写入者具有更高优先级，其有可能导致读取者“饿死”。最好在很少需要写访问且写入者只会短期拥有信号量的时候使用rwsem。

• completion

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

 Linux内核提供了一种更好的同步机制，即完成量（completion），完成量允许一个线程告诉另一个线程某个工作已经完成，其声明在<linux/completion.h>中。

1、创建和初始化completion

DECLARE_COMPLETION(my_completion); // 定义+初始化

动态创建和初始化完成量

struct completion my_completion;

void init_completion(&my_completion);

2、等待完成量

void wait_for_completion(struct completion *);

执行一个非中断的等待，如果调用了wait_for_completion且没有人会完成该任务，则会产生一个不可杀的进程。

3、唤醒完成量

void complete(struct completion *); //唤醒一个等待进程

void complete_all(struct completion *); // 唤醒所有等待进程

一个completion通常是个单次（one-shot）设备，它只会被使用一次，然后被丢弃。如果没有使用completion_all，则我们可以重复使用一个completion结构，但是，如果使用了completion_all，则必须在重复使用该结构体前重新初始化它。下面这个宏用来快速执行重新初始化：

INIT_COMPLETION(struct completion c)；

• 自旋锁

  自旋锁（spinlock）可在不能睡眠的代码中使用，比如中断例程。

   一个自旋锁是一个互斥设备，它只有两个值：“锁定”和“解锁”。它通常实现为某个整数值中的单个位。希望获得某特定锁的代码测试相关的位。如果锁可用，则“锁定”位被设置，而代码继续进入临界区。相反，如果锁被其他人获得，则代码进入忙循环并重复检查这个锁，直到该锁可用为止，这个循环就是自旋锁的“自旋”部分。“测试并设置”的操作必须以原子的方式完成。

  适用于自旋锁的核心规则是：

  1、任何拥有自旋锁的代码都必须是原子的。它不能休眠，事实上，它不能因为任何原因放弃处理器，除了服务中断以外（某些情况下也不能放弃CPU，如果在中断服务例程中，也需要该自旋锁，则会发生“死锁”，因此，在拥有自旋锁时会禁止本地CPU的中断）。任何时候，只要内核代码拥有自旋锁，在相关处理器上的抢占就会被禁止。当我们编写在自旋锁下执行的代码时，必须注意每一个所调用的函数，他们不能休眠。

  2、自旋锁必须在可能的最短时间内拥有。拥有自旋锁的时间越长，其他处理器不得不自旋的时间就越长，而它不得不自旋的可能性就越大。

自旋锁API

要使用自旋锁原语，需要包含头文件<linux/spinlock.h>。

spinlock_t my_lock = SPIN_LOCK_UNLOCKED;/* 编译时初始化spinlock*/

void spin_lock_init(spinlock_t lock);/ 运行时初始化spinlock*/

/* 所有spinlock等待本质上是不可中断的，一旦调用spin_lock，在获得锁之前一直处于自旋状态*/

void spin_lock(spinlock_t lock);/ 获得spinlock*/

void spin_lock_irqsave(spinlock_t lock, unsigned long flags);/ 获得spinlock，禁止本地cpu中断，保存中断标志于flags*/

void spin_lock_irq(spinlock_t lock);/ 获得spinlock,禁止本地cpu中断*/

void spin_lock_bh(spinlock_t lock)/ 获得spinlock,禁止软件中断，保持硬件中断打开*/

/* 以下是对应的锁释放函数*/

void spin_unlock(spinlock_t *lock);

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);

void spin_unlock_irq(spinlock_t *lock);

void spin_unlock_bh(spinlock_t *lock);

/* 以下非阻塞自旋锁函数，成功获得，返回非零值；否则返回零*/

int spin_trylock(spinlock_t *lock);

int spin_trylock_bh(spinlock_t *lock);

/新内核的<linux/spinlock.h>包含了更多函数/

   在Linux使用读-写自旋锁时，这种锁机制照顾读比写要多一点。当读锁被持有时，写操作为了互斥访问只能等待，但是读者可以继续成功占有锁。而自旋等待的写者在所有读者释放锁之前是无法获得锁的。所以，大量读者必然使挂起的写者处于饥饿状态。

   如果加锁时间不长且代码不会睡眠（比如中断处理程序），利用自旋锁是最佳选择。如果加锁时间可能很长或者代码在持有锁时有可能睡眠，那么最好使用信号量来完成加锁功能。

• 免锁算法

  经常用于免锁的生产者/消费者任务的数据结构之一是循环缓冲区（circular buffer）。循环缓冲区的使用在设备驱动程序中相当普遍。特别是网络适配器，经常使用循环冲区和处理器交换数据。在Linux内核中，有一个通用的循环缓冲区实现，有关其使用可参阅<linux/kfifo.h>。

• 原子变量

   有时，共享的资源可能恰好是一个简单的整数，完整的锁机制对一个简单的整数来讲显得有些浪费。针对这种情况，内核提供了一种原子的整数类型，称为atomic_t，定义在<ams/atomic.h>中。

   一个atomic_t变量在所有内核支持的架构上保存了一个int值。但是，由于某些处理器上这种数据类型的工作方式有些限制，因此不能使用完整的整数范围，也就是说，在atomic_t变量中不能记录大于24位的整数。原子操作速度非常快，因为只要可能，它们就会被编译成单个机器指令。

原子变量操作函数：

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

atomic_t v = ATOMIC_INIT(0); /编译时使用宏定义 ATOMIC_INIT 初始化原子值./

int atomic_read(atomic_t *v); /返回 v 的当前值./

void atomic_add(int i, atomic_t *v);/由 v 指向的原子变量加 i. 返回值是 void/

void atomic_sub(int i, atomic_t *v); /*从 v 减去 i./

void atomic_inc(atomic_t *v);

void atomic_dec(atomic_t *v); /递增或递减一个原子变量./

int atomic_inc_and_test(atomic_t *v);

int atomic_dec_and_test(atomic_t *v);

int atomic_sub_and_test(int i, atomic_t *v);

/进行一个特定的操作并且测试结果; 如果, 在操作后, 原子值是 0, 那么返回值是真; 否则, 它是假. 注意没有 atomic_add_and_test./

int atomic_add_negative(int i, atomic_t *v);

/加整数变量 i 到 v. 如果结果是负值返回值是真, 否则为假./

int atomic_add_return(int i, atomic_t *v);

int atomic_sub_return(int i, atomic_t *v);

int atomic_inc_return(atomic_t *v);

int atomic_dec_return(atomic_t *v);

/像 atomic_add 和其类似函数, 除了它们返回原子变量的新值给调用者./

   atomic_t类型数据必须只能通过上面的函数来访问。如果将原子变量传递给了需要整型参数的函数，则会遇到编译错误。只有原子变量的数目是原子的，atomic_t变量才能正常工作，需要多个atomic_t变量的操作，仍然需要某种类型的锁。

• 原子位操作

  为了实现位操作，内核提供了一组可原子地修改和测试单个位的函数。

原子位操作非常快，只要底层硬件允许，这种操作就可以使用单个机器指令来执行，并且不需要禁止中断。这些函数依赖于具体的架构，因此在<asm/bitops.h>中声明。即使是在SMP计算机上，这些函数也可确保为原子的，因此，能提供跨处理器的一致性。

   这些函数使用的数据类型也是依赖于具体架构的。nr参数（用来描述要操作的位）通常被定义为int，但在少数架构上被定义为unsigned long。要修改的地址通常是指向unsigned long指针，但在某些架构上却使用void *来代替。

可用的位操作如下：

void set_bit(nr, void *addr); /设置第 nr 位在 addr 指向的数据项中。/

void clear_bit(nr, void *addr); /清除指定位在 addr 处的无符号长型数据./

void change_bit(nr, void *addr);/翻转nr位./

int test_bit(nr, void *addr); /这个函数是唯一一个不需要是原子的位操作; 它简单地返回这个位的当前值./

/以下原子操作如同前面列出的, 除了它们还返回这个位以前的值./

int test_and_set_bit(nr, void *addr);

int test_and_clear_bit(nr, void *addr);

int test_and_change_bit(nr, void *addr);

• seqlock

  2.6内核包含了一对新机制打算来提供快速地，无锁地存取一个共享资源。seqlock要保护的资源小，简单，并且常常被存取，并且很少写存取但是必须要快。seqlock 通常不能用在保护包含指针的数据结构。seqlock 定义在<linux/seqlock.h> 。

/两种初始化方法/

seqlock_t lock1 = SEQLOCK_UNLOCKED;

seqlock_t lock2;

seqlock_init(&lock2);

    这个类型的锁常常用在保护某种简单计算,读存取通过在进入临界区入口获取一个(无符号的)整数序列来工作。在退出时, 那个序列值与当前值比较; 如果不匹配, 读存取必须重试。读者代码形式:

unsigned int seq;

do {

 seq = read_seqbegin(&the_lock);

 /* Do what you need to do */

} while read_seqretry(&the_lock, seq);

如果你的 seqlock可能从一个中断处理里存取,你应当使用IRQ安全的版本来代替:

unsigned int read_seqbegin_irqsave(seqlock_t *lock, unsigned long flags);

int read_seqretry_irqrestore(seqlock_t *lock, unsigned int seq, unsigned long flags);

   写者必须获取一个排他锁来进入由一个seqlock保护的临界区，写锁由一个自旋锁实现，调用:

void write_seqlock(seqlock_t *lock);

void write_sequnlock(seqlock_t *lock);

   因为自旋锁用来控制写存取, 所有通常的变体都可用:

void write_seqlock_irqsave(seqlock_t *lock, unsigned long flags);

void write_seqlock_irq(seqlock_t *lock);

void write_seqlock_bh(seqlock_t *lock);

void write_sequnlock_irqrestore(seqlock_t *lock, unsigned long flags);

void write_sequnlock_irq(seqlock_t *lock);

void write_sequnlock_bh(seqlock_t *lock);

   还有一个write_tryseqlock在它能够获得锁时返回非零。

• 读取-复制-更新

  读取-拷贝-更新(RCU) 是一个高级的互斥方法, 在合适的情况下能够有高效率。它在驱动中的使用很少。使用RCU的代码须包含<linux/rcupdate.h>。