并发与竞争

什么是并发？

1. 并发指的是多个执行单元同时被执行。
2. 并发的执行单元对共享资源（硬件资源和软件上的全局变量等）的访问就容易导致竞态。
3. 即使最简单的设备驱动程序也要考虑并发与竞态并作出相应处理。
   例：
   if (copy_from_user(dev->mem+p, buf, count))
   ret = -EFAULT;
   goto out;

假设有 2 个进程试图写入同一个设备的相同偏移，就会造成数据混乱。

导致并发的可能原因

1 对称多处理器的多个CPU
多个CPU可访问共同的外设和存储器
2 单CPU内进程与抢占它的进程
内核支持抢占调度，进程被更高优先级的进程打断。2进程都访问共同资源。
3 中断与进程之间
中断处理程序访问进制正在访问的资源。

处理并发的常用技术

处理并发的常用技术是加锁或者互斥，即确保在任何时间只有一个执行线程可以操作一个共享资源。
linux设备驱动可采用的互斥途径有：中断屏蔽、原子操作、自旋锁和信号量。
其中最常用的是信号量。

中断屏蔽

1 避免中断与进程之间的并发
2 避免内核抢占进程之间的并发（进程调度也依赖中断）

中断屏蔽的使用方法：

Local_irq_disable()
…
Critical section
…
Local_irq_enable()


Local_irq_save(flags) //保存了目前CPU的中断位信息
…
Critical section
…
Local_irq_restore(flags)

原子操作（sbh_p138）

在执行过程中不会被中断的操作。有2种：
1 整形原子操作
2 位原子操作

原子操作一

确保操作过程不被打断，即原子性

#include <asm/atomic.h> 
atomic_t v = ATOMIC_INIT(0);//定义原子变量V的值为0 
void atomic_set(atomic_t *v, int i); 

int atomic_read(atomic_t *v); 

void atomic_add(int i, atomic_t *v);

void atomic_sub(int i, atomic_t *v); 

void atomic_inc(atomic_t *v); 

void atomic_dec(atomic_t *v); 

int atomic_inc_and_test(atomic_t *v); //自加后并测试结果是否为0

int atomic_dec_and_test(atomic_t *v);

int atomic_sub_and_test(int i, atomic_t *v); 

int atomic_add_negative(int i, atomic_t *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);

自旋锁（sbh_p139）

自旋锁最多只能被一个可执行线程持有。自旋锁不会引起调用者睡眠，如果一个执行线程试图获得一个已经被持有的自旋锁，那么线程就会一直进行忙循环，一直等待下去，在那里看是否该自旋锁的保持者已经释放了锁，“自旋”就是这个意思。

Spinlock_t lock;
spin_lock_init(&lock) 
//该宏用于初始化自旋锁lock ，自旋锁在使用前必须先初始化。

spin_lock(&lock) 　
//获取自旋锁lock，如果成功，立即获得锁，并马上返回，否则它将一直自旋在那里，直到该自旋锁的保持者释放。

spin_trylock(&lock) 　　
//试图获取自旋锁lock，如果能立即获得锁，并返回真，否则立即返回假。它不会一直等待被释放。

spin_unlock(&lock) 　　
//释放自旋锁lock，它与spin_trylock或spin_lock配对使用。

自旋锁注意点

1 自旋锁是忙等锁，只有在占用锁的时间极短的情况下使用才合理。
2 递归使用自旋锁则会死锁。
3 能保证不被别的CPU或者本CPU的其他进程打搅，但可能受中断或者底半部的影响。

自旋锁的衍生

读写自旋锁（sbh_p142）

只能一个进程写，但可以多个进程读，且读和写不能同时进行。拥有锁时不能休眠
These locks allow any number of readers into a critical section simultaneously, but writers must have exclusive access

读写锁初始化

rwlock_t lock = RW_LOCK_UNLOCKED；//静态初始化 


rwlock_t lock；
rwlock_init(rwlock_t *lock); //动态初始化
The two ways of initializing reader/writer locks.

读锁定

void read_lock(rwlock_t *lock); 

void read_lock_irqsave(rwlock_t *lock, unsigned long flags); 

void read_lock_irq(rwlock_t *lock); 

void read_lock_bh(rwlock_t *lock); 

void read_unlock(rwlock_t *lock);
 
void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags); 

void read_unlock_irq(rwlock_t *lock); 

void read_unlock_bh(rwlock_t *lock); 

写锁定

void write_lock(rwlock_t *lock); 

void write_lock_irqsave(rwlock_t *lock, unsigned long flags); 

void write_lock_irq(rwlock_t *lock); 

void write_lock_bh(rwlock_t *lock); 

int write_trylock(rwlock_t *lock); 

void write_unlock(rwlock_t *lock); 

void write_unlock_irqrestore(rwlock_t *lock, unsigned long flags); 

void write_unlock_irq(rwlock_t *lock); 

void write_unlock_bh(rwlock_t *lock); 

信号量(sbh_p148)

Linux内核的信号量在概念和原理上与用户态的信号量是一样的，但是它不能在内核之外使用，它是一种睡眠锁。如果有一个任务想要获得已经被占用的信号量时，信号量会将这个进程放入一个等待队列，然后让其睡眠。当持有信号量的进程将信号释放后，处于等待队列中的任务将被唤醒，并让其获得信号量。
信号量在创建时需要设置一个初始值，表示允许有几个任务可以同时访问该信号量保护的共享资源，初始值为1就变成互斥锁（Mutex），即同时只能有一个任务可以访问信号量保护的共享资源。
当任务访问完被信号量保护的共享资源后，必须释放信号量，释放信号量通过把信号量的值加1实现，如果信号量的值为非正数，表明有任务等待当前信号量
信号量的实现也是与体系结构相关的，定义在<asm/semaphore.h>中，struct semaphore类型用来表示信号量。

1. 定义信号量
struct semaphore sem;

2. 初始化信号量
void sema_init (struct semaphore *sem, int val);
该函用于数初始化设置信号量的初值，它设置信号量sem的值为val。 

3. 获取信号量
void down(struct semaphore * sem)
获取信号量sem，可能会导致睡眠，因此不能在中断上下文使用该函数。该函数将把sem的值减1，如果信号量sem的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。
int down_interruptible(struct semaphore * sem)
该函数功能与down类似，不同之处为，down不会被信号（signal）打断，但down_interruptible能被信号打断，因此该函数有返回值来区分是正常返回还是被信号中断，如果返回0，表示获得信号量正常返回，如果被信号打断，返回-EINTR。

4. 释放信号量
void up(struct semaphore * sem);
该函数释放信号量sem，即把sem的值加1，如果sem的值为非正数，表明有任务等待该信号量，因此唤醒这些等待者。

定义与初始化的工作可由如下宏一步完成：

DECLARE_MUTEX(name)
定义一个信号量name，并初始化它的值为1。

DECLARE_MUTEX_LOCKED(name)
定义一个信号量name，但把它的初始值设置为0，即锁在创建时就处在已锁状态。

信号量一般用于互斥与同步

Example:3globalmeme_sem（互斥）
Example:3globalmeme_semetongbu（同步）

完成量也用于同步（sbh_p150）

用于一个执行单元等待另一个执行单元执行完某事。用法和信号量一样。

#include <linux/completion.h> 

struct completion c;

init_completion(struct completion *c); 

INIT_COMPLETION(struct completion c);

void wait_for_completion(struct completion *c); 
Wait for a completion event to be signalled.
c->done--

void complete(struct completion *c);
Send  a completion event signal.
c->done++;

信号量PK自旋锁

信号量最多可以允许多个持有者，而自旋锁在任何时候只能允许一个持有者。当然也有信号量叫互斥信号量(只能一个持有者),允许有多个持有者的信号量叫计数信号量。

信号量适合于保持时间较长的情况；而自旋锁适合于保持时间非常短的情况，在实际应用中自旋锁控制的代码只有几行，而持有自旋锁的时间也一般不会超过两次上下文切换的时间，因为线程一旦要进行切换，就至少花费切出切入两次，自旋锁的占用时间如果远远长于两次上下文切换，我们就应该选择信号量。

读写信号量

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

互斥体