linux设备驱动中的并发控制

首先，让我们来回顾一下在简单的linux字符设备驱动中，我们是通过file_operation的连接实现了应用程序访问内核的接口，在各个注册的函数接口中，我们并没有考虑一些比较复杂的情况，比如：当一个进程在打开文件进行修改时候，而另一个进程也在打开修改，同时可能有一个进程正在阅读，这时候就会发生竞争了。因此linux中必须提供了一种针对多个进程共享资源的控制。

废话少说：直接提出解决的方法。。。。。

1、中断屏蔽

　　CPU一般具有开启中断和屏蔽中断的功能，该功能可以保证正在执行的内核执行路径不会被中断处理程序所抢占，，防止竞态条件的发生。

　　使用方法:

　　local_irq_disable();/*屏蔽中断*/

　　critical section......;/*临界区*/

　　local_irq_enable();/*开启中断*/

　　由于linux的异步I/O、进程调度等很多操作要依赖于中断，中断对于内核的运行非常重要，在屏蔽中断期间所有的中断都无法得到处理，因此长时间屏蔽中断时非常危险的。单独使用屏蔽中断不是值得推荐的一种避免竞态的方法，他适合与自旋锁同时使用。

 

原子操作

 

原子操作指的是在执行过程中不会被别的代码路径所中断的操作。

Linux内核提供了一系列函数来实现内核中的原子操作，这些函数又分为两类，分别针对位和整型变量进行原子操作。

 

整型原子操作

 

1. 设置值 void atomic_set(atomic_t *v,int i); Atomic_t v = ATOMIC_INT(0);

2. 获取值 atomic_read(atomic_t *v);

3. 加减 void atomic_add(int i,atomic_t *v); void atomic_sub(int i,atomic_t *v);

4. 自增自减 void atomic_inc(atomic_t *v); void atomic_dec(atomic_t *v);

5. 操作测试 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，为0返回true，否则返回false。

6. 操作返回int atomic_inc_and_return(atomic_t *v); int atomic_dec_and_return(atomic_t *v); int atomic_sub_and_return(int i, atomic_t *v); int atomic_add_and_return(int i, atomic_t *v);

操作后返回新值。

 

位原子操作

 

1. 设置位 void set_bit(nr,void *addr); 设置addr地址的第nr位，即将位写1。

2. 清除位 void clear_bit(nr,void *addr); 将位写为0。

3. 改变位 void change_bit(nr,void *addr); 将位进行反置。

4. 测试位test_bit(nr,void *addr); 返回第nr位。

5. 测试操作int test_and_set_bit(nr,void *addr); int test_and_clear_bit(nr,void *addr); int test_and_change_bit(nr,void *addr);

先返回，后操作。

 

例子：使用原子变量使设备只能被一个进程打开

 

static atomic_t xxx_available =ATOMIC_INIT(1);

 

xxx_open

{

if(!atomic_dec_and_test(&xxx_available))

{

atomic_inc(&xxx_available);

return - EBUSY;

}

}

 

xxx_release

{

atomic_inc(&xxx_available);

}

 

 

自旋锁

 

自旋锁的使用

自旋锁是一种对临界资源进行互斥访问的典型手段。

 

操作：1. 定义 spinlock_t lock;

2. 初始化 spin_lock_init(&lock);

3 获得 spin_lock(&lock); 自旋等待 spin_trylock(&lock); 非阻塞，立即返回。

4. 释放 spin_unlock(&lock);

 

注意：自旋锁实际是忙等锁；自旋锁可能导致系统死锁。

 

读写自旋锁

 

读写自旋锁可允许读的并发。

 

操作：1. 定义初始化 rwlock_t my_rwlock = RW_LOCK_UNLOCKED;

rwlock_t my_rwlock;

rwlock_init(&my_rwlock);

2. 读锁定 void read_lock(rw_lock_t *lock);

3. 读解锁 void read_unlock(rw_lock_t *lock);

4. 写锁定 void write_lock(rw_lock_t *lock);

void write_trylock(rw_lock_t *lock);

5. 写解锁 void write_unlock(rw_lock_t *lock);

 

 

顺序锁

顺序锁中读或写单元都不会被对方阻塞，但是写写仍然互斥。

顺序锁有一个限制，它必须要求被保护的共享资源不含有指针，因为写单元可能使得指针失效。

操作：1. 获得锁void write_seqlock(seqlock_t *sl);

void write_tryseqlock(seqlock_t *sl);

2. 释放锁void write_sequnlock(seqlock_t *sl);

读完后需要进行检查在读期间是否有写操作，如果有则需要重新进行读操作。

 

读-拷贝-更新

对于被RCU保护的共享数据结构，读执行单元不需要获得任何锁就可以访问它，不需要锁也使得使用更容易，因为死锁问题就不需要考虑。

使用RCU写执行单元在访问它前需首先复制一个副本，然后对副本进行修改，最后使用一个回调机制在适当的时机把指向原来数据的指针重新指向新的被修改的数据，这个时机就是所有引用该数据的CPU都退出对共享数据的操作的时候。

 

操作：1. 读锁定 rcu_read_lock() rcu_read_lock_bh()

2. 读解锁 rcu_read_unlock() rcu_read_unlock_bh()

3. 同步RCU synchronize_rcu()

4 挂接回调 void fastcall call_rcu(struct rcu_head *head, void (*func)(struct_rcu_head *rcu) );

RCU还增加了链表操作函数的RCU版本。

2.6中 RCU得到普遍使用。

 

信号量

 

信号量的使用

与自旋锁不同的是，当获取不到信号量时，进程不会原地打转而是进入休眠等待状态。

 

操作：

 

1. 定义 struct semaphore sem;

2. 初始化 void sema_init(struct semaphore *sem, int val);

void init_MUTEX(struct semaphore *sem); //信号量sem的值设置为1

void init_MUTEX_LOCKED(struct semaphore *sem); //信号量sem的值设置为0

DECLARE_MUTEX(name) //name的信号量初始化为1

DECLARE_MUTEX_LOCKED(name) //name的信号量初始化为0

3.获取 void down(struct semaphore *sem); //休眠

int down_interruptible(struct semaphore *sem);

Int down_trylock(struct semaphore *sem); //不会休眠 可在中断上下文使用

4. 释放 void up(struct semaphore *sem);

 

信号量用于同步

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

 

完成量用于同步

 

Linux提供了一种比信号量更好的同步机制，即完成量(completion)。

 

操作：1. 定义 struct completion my_completion;

2. 初始化 init_completion(&my_completion);

DECLARE_COMPLETION(my_completion);

3. 等待 void wait_for_completion(struct completion *c);

4. 唤醒void complete(struct completion *c);

void complete_all(struct completion *c);

 

自旋锁vs信号量

 

严格意义上说，信号量和自旋锁属于不同层次的互斥手段，前者的实现依赖于后者。

 

信号量是进程级的，用于多个进程之间对资源的互斥，所以适用于进程占用资源时间比较长的时候，而自旋锁不能在临界区长时间停留。

信号量所保护的临界区可包含可能引起阻塞的代码，而自旋锁则绝对要避免用来保护包含这样代码的临界区。因为阻塞意味着要进行进程间的切换，如果进程被切换出去后，另一个进程企图获取本自旋锁，死锁就会发生。

如果被保护的共享资源需要在中断或软中断情况下使用，则只能选择自旋锁。如果一定要使用信号量，则只能通过down_trylock()进行，以避免阻塞。

 

读写信号量

 

它可允许N个读执行单元同时访问共享资源，而最多只能有一个写执行单元。

 

操作：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);

3. 写信号量释放void up_write(struct rw_semaphore *sem);

 

 

互斥体

 

操作：1. 定义初始化 struct mutex my_mutex;

Mutex_init (&my_mutex);

2. 获取 void fastcall mutex_lock(struct mutex *lock);

int fastcall mutex_lock_interruptible(struct mutex *lock);

int fastcall mutex_trylock (struct mutex *lock);

3.释放void fastcall mutex_unlock(struct mutex *lock);