Linux并发与竞争备忘
Linux 作为一个多任务操作系统,存在多个任务共同操作同一段内存或者设备的情况,多个任务甚至中断都能访问的资源叫做共享资源。驱动开发中要注意对共享资源的保护,就是要处理对共享资源的并发访问。
原子操作
用于变量或位操作,变为不能再进一步分割的操作。
原子整形操作API函数
Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作,在使用中用原子变量来代替整形变量,此结构体定义在 include/linux/types.h 文件中,定义如下:
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 v = ATOMIC_INIT(0); /* 定义并初始化原子变零 v=0 */
atomic_set(&v, 10); /* 设置 v=10*/
atomic_read(&v); /* 读取 v 的值,肯定是 10*/
atomic_inc(&v); /* v 的值加 1,v=11*/
struct gpioled_dev{
...
atomic_t lock; /* 原子变量*/
};
static int led_open(struct inode *inode, struct file *filp)
{
/* 通过判断原子变量的值来检查 LED 有没有被别的应用使用 */
if (!atomic_dec_and_test(&gpioled.lock)) {
atomic_inc(&gpioled.lock); /* 小于 0 的话就加 1,使其原子变量等于 0 */
return -EBUSY; /* LED 被使用,返回忙 */
}
filp->private_data = &gpioled; /* 设置私有数据 */
return 0;
}
static int led_release(struct inode *inode, struct file *filp)
{
struct gpioled_dev *dev = filp->private_data;
/* 关闭驱动文件的时候释放原子变量 */
atomic_inc(&dev->lock);
return 0;
}
static int __init led_init(void)
{
int ret = 0;
const char *str;
/* 1、初始化原子变量*/
gpioled.lock = (atomic_t)ATOMIC_INIT(0);
/* 2、原子变量初始值为 1 */
atomic_set(&gpioled.lock, 1);
/* 设置 LED 所使用的 GPIO */
/* 1、获取设备节点:gpioled */
gpioled.nd = of_find_node_by_path("/gpioled");
if(gpioled.nd == NULL) {
printk("gpioled node not find!\r\n");
return -EINVAL;
}
....
}
....
原子位操作 API 函数
原子位操作是直接对内存进行操作,API 函数如表 11.2.3.1 所示:
函数 | 描述 |
---|---|
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 位原来的值 |
自旋锁(适合线程与线程之间)
原子操作只能对整形变量或者位进行保护,但是,在实际的使用环境中怎么可能只有整形变量或位这么简单的临界区。举个最简单的例子,设备结构体变量就不是整型变量,我们对于结构体中成员变量的操作也要保证原子性,在线程 A 对结构体变量使用期间,应该禁止其他的线程来访问此结构体变量,这些工作原子操作都不能胜任,需要本节要讲的锁机制,在 Linux内核中就是自旋锁。
当一个线程要访问某个共享资源的时候首先要先获取相应的锁,锁只能被一个线程持有,只要此线程不释放持有的锁,那么其他的线程就不能获取此锁。对于自旋锁而言,如果自旋锁正在被线程 A 持有,线程 B 想要获取自旋锁,那么线程 B 就会处于忙循环-旋转-等待状态,线程 B 不会进入休眠状态或者说去做其他的处理,而是会等待锁可用。
在使用自旋锁之前,肯定要先定义一个自旋锁变量,定义方法如下所示:
spinlock_t lock; //定义自旋锁
自旋锁 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 |
代码节选示例:
.....省略.........
/* gpioled 设备结构体 */
struct gpioled_dev{
dev_t devid; /* 设备号*/
struct cdev cdev; /* cdev*/
struct class *class; /* 类*/
struct device *device; /* 设备*/
int major; /* 主设备号*/
int minor; /* 次设备号*/
struct device_node *nd; /* 设备节点*/
int led_gpio; /* led 所使用的 GPIO 编号*/
int dev_stats; /* 设备使用状态,0,设备未使用;>0,设备已经被使用 */
spinlock_t lock; /* 定义自旋锁变量 lock */
};
static struct gpioled_dev gpioled; /* led 设备 */
static int led_open(struct inode *inode, struct file *filp)
{
unsigned long flags;59
filp->private_data = &gpioled; /* 设置私有数据 */
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);/*驱动入口函数 led_init 中调用 spin_lock_init 函数初始化自旋锁*/
........
}
死锁:
-
被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数,否则的话会可能会导致死锁现象的发生。(自旋锁会自动禁止抢占,也就说当线程 A 得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态,那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行,线程 B 也想要获取锁,但是此时锁被 A 线程持有,而且内核抢占还被禁止了!线程 B 无法被调度出去,那么线程 A 就无法运行,锁也就无法释放)
-
中断使用自旋锁时候,在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断,对于多核 SOC 来说会有多个 CPU 核),否则可能导致锁死现象的发生(线程 A 先运行,并且获取到了 lock 这个锁,当线程 A 运行functionA 函数的时候中断发生了,中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁,但是这个锁被线程 A 占有着,中断就会一直自旋,等待锁有效。)
解决方法就是获取锁之前关闭本地中断,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) 将中断状态恢复到以前的状态,并且激活本地中断,
释放自旋锁代码示例:
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) /* 释放锁*/ }
信号量
Linux 内核提供了信号量机制,信号量常常用于控制对共享资源的访问。相比于自旋锁,信号量可以使线程进入休眠状态.
信号量的特点:
- 因为信号量可以使等待资源线程进入休眠状态,因此适用于那些占用资源比较久的场合。
- 因此信号量不能用于中断中,因为信号量会引起休眠,中断不能休眠。
- 如果共享资源的持有时间比较短,那就不适合使用信号量了,因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。
信号量 API 函数
Linux 内核使用 semaphore 结构体表示信号量,结构体内容如下所示:
struct semaphore {
raw_spinlock_t lock;
unsigned int count;
struct list_head wait_list;
};
函数 | 描述 |
---|---|
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); /* 释放信号量*/
/* gpioled 设备结构体 */
struct gpioled_dev{
.......
struct semaphore sem; /* 信号量 */
};
static struct gpioled_dev gpioled;
static int led_open(struct inode *inode, struct file *filp)
{
filp->private_data = &gpioled; /* 设置私有数据 */
/* 获取信号量 */
if(down_interruptible(&gpioled.sem)){
return -ERESTARTSYS;
}
# if 0
down(&gpioled.sem);
#endif
return 0;
}
.............
struct int led_release(struct inode *inode, struct file *filp)
{
struct gpioled_dev *dev = filp->private_data;
up(&dev->sem);
return 0;
}
static int __init led_init(void){
int ret = 0;
const char *str;
/* 初始化信号量 */
sema_init(&gpioled.sem, 1);
............
}
..........
互斥体
将信号量的值设置为 1 就可以使用信号量进行互斥访问了,虽然可以通过信号量实现互斥,但是 Linux 提供了一个比信号量更专业的机制来进行互斥,它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源,不能递归申请互斥体。在我们编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。
struct mutex {
atomic_long_t owner;
spinlock_t wait_lock;
};
使用 mutex 的时候要注意如下几点:
- mutex 可以导致休眠,因此不能在中断中使用 mutex,中断中只能使用自旋锁。
- 和信号量一样,mutex 保护的临界区可以调用引起阻塞的 API 函数。
- 因为一次只有一个线程可以持有 mutex,因此,必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁。
互斥体 API 函数
函数 | 描述 |
---|---|
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,解锁 |
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); /* 解锁*/
..........
/* gpioled 设备结构体 */
struct gpioled_dev{
dev_t devid; /* 设备号*/
struct cdev cdev; /* cdev*/
struct class *class; /* 类*/
struct device *device; /* 设备*/
int major; /* 主设备号*/
int minor; /* 次设备号*/
struct device_node *nd; /* 设备节点*/
int led_gpio; /* led 所使用的 GPIO 编号*/
struct mutex lock; /* 定义互斥体 lock*/
};
static struct gpioled_dev gpioled; /* led 设备 */
static int led_open(struct inode *inode, struct file *filp)
{
filp->private_data = &gpioled; /* 设置私有数据 */
/* 获取互斥体,可以被信号打断 */
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)
{
struct gpioled_dev *dev = filp->private_data;
/* 释放互斥锁 */
mutex_unlock(&dev->lock);
return 0;
}
static int __init led_init(void)
{
int ret = 0;
const char *str;
/* 初始化互斥体 */
mutex_init(&gpioled.lock);
......
}
如有侵权之处,敬请联系删除。