linux 驱动中并发与竞争

前言

Linux 系统是个多任务操作系统，会存在多个任务同时访问同一片内存区域，这些任务可能会相互覆盖这段内存中的数据，造成内存数据混乱。针对这个问题必须要做处理，严重的话可能会导致系统崩溃。现在的 Linux 系统并发产生的原因很复杂，总结一下有下面几个主要原因：

1. 多线程并发访问，Linux是多线程系统，所以存在多线程的访问是最基本的原因。
2. 抢占式发访问，从linux2.6内核版本开始支持抢占式访问，也就是调度程序可以再任意时刻抢占正在运行的线程，从而运行其他的线程。
3. 中断程序并发访问。
4. SMP(多核)核间并发访问，现在ARM架构多核CPU存在核间并发访问。

保护的是什么？
保护的是数据，一般是全局变量，设备结构体等。

保护策略，原子操作、自旋锁、信号量、互斥体

1、原子操作

原子操作就是指不能再进一步分割的操作，一般原子操作用于变量或者位操作。Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量。

适用环境：
一般适用于变量或者位操作
如：a=1 给a赋值1 ，在汇编阶段需要好几个操作才能完成赋值工作，在这个阶段中（多核、多线程、三级流水线）容易发生修改。

1)整形操作 API 函数

原子整型操作 API

typedef struct {
	int counter;
}atomic_t;

函数	含义
ATOMIC_INIT(int i)	定义原子变量的时候对其初始化
int atomic_read(atomic_t *v)	读取 v 的值，并且返回
void atomic_set(atomic_t *v, int i)	向 v 写入 i 值。
void atomic_add(int i, atomic_t *v)	给 v 加上 i 值。
void atomic_sub(int i, atomic_t *v)	从 v 减去 i 值。
void atomic_inc(atomic_t *v)	给 v 加 1，也就是自增。
void atomic_dec(atomic_t *v)	从 v 减 1，也就是自减
int atomic_dec_return(atomic_t *v)	从 v 减 1，并且返回 v 的值。
int atomic_inc_return(atomic_t *v)	给 v 加 1，并且返回 v 的值。
int atomic_sub_and_test(int i, atomic_t *v)	从 v 减 i，如果结果为 0 就返回真，否则返回假
int atomic_dec_and_test(atomic_t *v)	从 v 减 1，如果结果为 0 就返回真，否则返回假
int atomic_inc_and_test(atomic_t *v)	给 v 加 1，如果结果为 0 就返回真，否则返回假
int atomic_add_negative(int i, atomic_t *v)	给 v 加 i，如果结果为负就返回真，否则返回假

atomic_t b = ATOMIC_INIT(0) //定义原子变量 b 并赋初值为 0

2)位操作API

函数	含义
void set_bit(int nr, void *p)	将 p 地址的第 nr 位置 1
void clear_bit(int nr,void *p)	将 p 地址的第 nr 位清零
void change_bit(int nr, void *p)	将 p 地址的第 nr 位进行翻转
int test_bit(int nr, void *p)	获取 p 地址的第 nr 位的值
int test_and_set_bit(int nr, void *p)	将 p 地址的第 nr 位置 1，并且返回 nr 位原来的值
int test_and_clear_bit(int nr, void *p)	将 p 地址的第 nr 位清零，并且返回 nr 位原来的值
int test_and_change_bit(int nr, void *p)	将 p 地址的第 nr 位翻转，并且返回 nr 位原来的值

1.1 原子操作实战范例

struct gpioled_dev{
	dev_t devid;	
	atomic_t lock;			/* 原子变量 */
};

static int led_open(struct inode *inode, struct file *filp)
{
	if (!atomic_dec_and_test(&gpioled.lock)) {
		atomic_inc(&gpioled.lock);	/* 小于0的话就加1,使其原子变量等于0 */
		return -EBUSY;				/* LED被使用，返回忙 */
	}

	return 0;
}

static int __init led_init(void)
{
	int ret = 0;
	atomic_set(&gpioled.lock, 1);	/* 原子变量初始值为1 */
}

static int led_release(struct inode *inode, struct file *filp)
{
	/* 关闭驱动文件的时候释放原子变量 */
	atomic_inc(&dev->lock);
	return 0;
}

程序解析：
1）led_init 驱动入口函数会将 lock 的值设置为 1
2）open 函数打开驱动设备的时候先申请 lock，如果申请成功的话就表示LED灯还没有被其他的应用使用，如果申请失败就表示LED灯正在被其他的应用程序使用。

每次打开驱动设备的时先使用 atomic_dec_and_test 函数将 lock 减 1，如果 atomic_dec_and_test函数返回值为真就表示 lock 当前值为 0，说明设备可以使用。
如果 atomic_dec_and_test 函数返回值为假，就表示 lock 当前值为负数，那就是其他设备正在使用 LED。其他设备正在使用 LED 灯，只能退出了。
在退出之前调用函数 atomic_inc 将 lock 加 1，因为此时 lock 的值被减成了负数，必须要对其加 1，将 lock 的值变为 0

2、自旋锁

概念：当一个线程要访问某个共享资源的时候首先要先获取相应的锁， 锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。

与原子区别：原子操作适用于整形或者位操作，但是实际使用中不是简单的整形，可能会有结构体等数据结构。

适用环境：
适用于短时期的轻量级加锁，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。

缺点：那就等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。

死锁发生：

1）睡眠情况下：
A线程在拥有锁的情况下进行了睡眠，A线程会放弃CPU使用权，B线程开始运行，因为B也想获取或，因为A已经获取了锁并且睡眠了，线程B无法调度出去，死锁发生；

2）阻塞情况下：
A线程正在使用锁，这时中断进来。
首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断API，否则死锁。

函数	含义
DEFINE_SPINLOCK(spinlock_t lock)	定义并初始化一个自选变量。
int spin_lock_init(spinlock_t *lock)	初始化自旋锁
void spin_lock(spinlock_t *lock)	获取指定的自旋锁，也叫做加锁
void spin_unlock(spinlock_t *lock)	释放指定的自旋锁
int spin_trylock(spinlock_t *lock) 尝	试获取指定的自旋锁，如果没有获取到就返回 0
int spin_is_locked(spinlock_t *lock)	检查指定的自旋锁是否被获取，如果没有被获取就返回非 0，否则返回 0

获取锁之前关闭本地中断， Linux 内核提供了相应的 API 函数

函数	含义
void spin_lock_irq(spinlock_t *lock)	禁止本地中断，并获取自旋锁。
void spin_unlock_irq(spinlock_t *lock)	激活本地中断，并释放自旋锁。
void spin_lock_irqsave(spinlock_t *lock,unsigned long flags)	保存中断状态，禁止本地中断，并获取自旋锁。
void spin_unlock_irqrestore(spinlock_t*lock, unsigned long flags)	将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁

建议使用 spin_lock_irqsave/ spin_unlock_irqrestore，因为这一组函数会保存中断状态，在释放锁的时候会恢复中断状态。

使用模板

DEFINE_SPINLOCK(lock) /* 定义并初始化一个锁 */

/* 线程 A */
 void functionA (){
		unsigned long flags; /* 中断状态 */
		spin_lock_irqsave(&lock, flags) /* 获取锁 */
		/* 临界区 */
		spin_unlock_irqrestore(&lock, flags) /* 释放锁 */
}

/* 中断服务函数 */
void irq() {
	spin_lock(&lock) /* 获取锁 */
	/* 临界区 */
	spin_unlock(&lock) /* 释放锁 */
}

下半部(BH)也会竞争共享资源,使用的API

函数	含义
void spin_lock_bh(spinlock_t *lock)	关闭下半部，并获取自旋锁
void spin_unlock_bh(spinlock_t *lock)	打开下半部，并释放自旋锁

2.2、自旋锁实战范例

struct gpioled_dev{
	int dev_stats;			/* 设备使用状态，0，设备未使用;>0,设备已经被使用 */
	spinlock_t lock;		/* 自旋锁 */
};

static int led_open(struct inode *inode, struct file *filp)
{
	unsigned long flags;

	spin_lock_irqsave(&gpioled.lock, flags);	/* 上锁 */
	if (gpioled.dev_stats) {					/* 如果设备被使用了 */
		spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
		return -EBUSY;
	}
	gpioled.dev_stats++;	/* 如果设备没有打开，那么就标记已经打开了 */
	spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */

	return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
	unsigned long flags;
	struct gpioled_dev *dev = filp->private_data;

	/* 关闭驱动文件的时候将dev_stats减1 */
	spin_lock_irqsave(&dev->lock, flags);	/* 上锁 */
	if (dev->dev_stats) {
		dev->dev_stats--;
	}
	spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */

	return 0;
}

static int __init led_init(void)
{
	/*  初始化自旋锁 */
	spin_lock_init(&gpioled.lock);
	...
	
}

程序解析：
1）自旋锁的工作就是保护dev_stats 变量， 真正实现对设备互斥访问的是 dev_stats。
2）如果设备没有被使用的话将 dev_stats 加 1，表示设备要被使用了，然后调用 spin_unlock_irqrestore 函数释放锁；
3）在 release 函数中将 dev_stats 减 1，表示设备被释放了，可以被其他的应用程序使用。

3、信号量

相比于自旋锁，信号量可以使线程进入休眠状态，使用信号量会提高处理器的使用效率，毕竟不用一直等待。信号量的开销要比自旋锁大，因为信号量使线程进入休眠状态以后会切换线程，切换线程就会有开销。

适用环境：

1. 因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合
2. 因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
3. 如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。

函数	含义
DEFINE_SEAMPHORE(name)	定义一个信号量，并且设置信号量的值为 1。
void sema_init(struct semaphore *sem, int val)	初始化信号量 sem，设置信号量值为 val。
void down(struct semaphore *sem)	获取信号量，因为会导致休眠，因此不能在中断中使用。
int down_trylock(struct semaphore *sem)	尝试获取信号量，如果能获取到信号量就获取，并且返回 0。如果不能就返回非 0，并且不会进入休眠。
int down_interruptible(struct semaphore *sem)	获取信号量，和 down 类似，只是使用 down 进入休眠状态的线程不能被信号打断。而使用此函数进入休眠以后是可以被信号打断的。
void up(struct semaphore *sem)	释放信号量

使用模板

struct semaphore sem; /* 定义信号量 */
sema_init(&sem, 1)； /* 初始化信号量 */
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

3.3、信号量实战范例

//头文件
#include <linux/semaphore.h>

//设备结构体
struct gpioled_dev{
	dev_t devid;		
	struct semaphore sem;	/* 信号量 */
};

static int led_open(struct inode *inode, struct file *filp)
{
	/* 获取信号量 */
	if (down_interruptible(&gpioled.sem)) { /* 获取信号量,进入休眠状态的进程可以被信号打断 */
		return -ERESTARTSYS;
	}
#if 0
	down(&gpioled.sem);		/* 不能被信号打断 */
#endif

	return 0;
}
static int led_release(struct inode *inode, struct file *filp)
{
	up(&dev->sem);		/* 释放信号量，信号量值加1 */
	return 0;
}
static int __init led_init(void)
{
	/* 初始化信号量 */
	sema_init(&gpioled.sem, 1);
	
}

程序解析：
1）open函数中，可以使用 down 函数，也可以使用 down_interruptible函数。如果信号量值大于等于 1 就表示可用，那么应用程序就会开始使用 LED 灯。如果信号量值为 0 就表示应用程序不能使用 LED 灯，此时应用程序就会进入到休眠状态。等到信号量值大于 1 的时候应用程序就会唤醒，申请信号量，获取 LED 灯使用权。
2）在 release 函数中调用 up 函数释放信号量，这样其他因为没有得到信号量而进入休眠状态的应用程序就会唤醒，获取信号量。

如果A进程使用驱动，则会获取信号量 sem，获取成功以后 sem 的值减 1 变为 0；
如果这时有B进程也使用此驱动，申请信号量无效(值为 0)，进入休眠状态；
A使用完，释放信号量，sem变为1，此时休眠的B进程可以使用此驱动了。

4、互斥体

互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex

适用环境：
1、mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
2、和信号量一样， mutex 保护的临界区可以调用引起阻塞的 API 函数。
3、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁

函数	含义
DEFINE_MUTEX(name)	定义并初始化一个 mutex 变量。
void mutex_init(mutex *lock)	初始化 mutex。
void mutex_lock(struct mutex *lock)	获取 mutex，也就是给 mutex 上锁。如果获取不到就进休眠。
void mutex_unlock(struct mutex *lock)	释放 mutex，也就给 mutex 解锁。
int mutex_trylock(struct mutex *lock)	尝试获取 mutex，如果成功就返回 1，如果失败就返回 0。
int mutex_is_locked(struct mutex *lock)	判断 mutex 是否被获取，如果是的话就返回1，否则返回 0。
int mutex_lock_interruptible(struct mutex *lock)	使用此函数获取信号量失败进入休眠以后可以被信号打断

使用模板

struct mutex lock; /* 定义一个互斥体 */
mutex_init(&lock); /* 初始化互斥体 */

mutex_lock(&lock); /* 上锁 */
/* 临界区 */
mutex_unlock(&lock); /* 解锁 *

4.4 互斥体实战范例

struct gpioled_dev{
	dev_t devid;		
	struct mutex lock;		/* 互斥体 */
};

static int led_open(struct inode *inode, struct file *filp)
{
	/* 获取互斥体,可以被信号打断 */
	if (mutex_lock_interruptible(&gpioled.lock)) {
		return -ERESTARTSYS;
	}
#if 0
	mutex_lock(&gpioled.lock);	/* 不能被信号打断 */
#endif
	return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
	/* 释放互斥锁 */
	mutex_unlock(&dev->lock);
	return 0;
}
static int __init led_init(void)
{
	/* 初始化互斥体 */
	mutex_init(&gpioled.lock);
}

程序解析：
1）在 open 函数中调用 mutex_lock_interruptible 或者 mutex_lock 获取 mutex，成功的话就表示可以使用 LED 灯，失败的话就会进入休眠状态，和信号量一样；
2）在 release 函数中调用 mutex_unlock 函数释放 mutex，这样其他应用程序就可以获取 mutex