【linux】驱动-12-并发与竞态

目录

• 前言
• 12. 并发&竞态
  • 12.1 并发&竞态概念
  • 12.2 竞态解决方法
  • 12.3 原子
  • 12.3.1 原子介绍
    • 12.3.2 原子操作步骤
    • 12.3.3 原子 API
  • 12.4 自旋锁
    • 12.4.1 自旋锁介绍
    • 12.4.2 自旋锁操作步骤
    • 12.4.3 自旋锁 API
    • 12.4.4 读写自旋锁
    • 12.4.5 顺序锁
  • 12.5 信号量
    • 12.5.1 信号量概念
    • 12.5.2 信号量操作
    • 12.5.3 信号量 API
  • 12.6 互斥体
    • 12.6.1 互斥体概念
    • 12.6.2 互斥体操作
    • 12.6.3 互斥体 API
  • 12.7 完成量
    • 12.7.1 完成量概念
    • 12.7.2 完成量操作
    • 12.7.3 完成量 API

---

前言

内核驱动的并发&竟态很容易理解，其解决方法也不能，看看例程就可以了。

对于API，看看内核源码和内核文档即可。

原文链接：https://www.cnblogs.com/lizhuming/p/14907262.html

12. 并发&竞态

本章内容为驱动基石之一。

驱动只提供功能，不提供策略。

12.1 并发&竞态概念

并发：

• 指多个单元同时、并行执行。
• 但是并发执行的单元对共享资源的访问容易产生竞态。
• 单核的并发可以参考 MCU RTOS 多任务原理。看似并行，实质串行。不过也存在竞态。

并发产生原因（大概）：

• 多线程并发访问。
• 抢占式并发访问。（linux2.6及高版本的内核为抢占式内核）
• 中断程序并发访问。
• 多核（SMP）核间并发访问。

竞态：

• 指并发的执行单元对共享资源的访问。
• 竞态产生的条件：
  • 存在共享资源。
  • 对共享资源进行竞争访问。

12.2 竞态解决方法

需要解决竞态是因为要保护数据。

确保每个时刻都只有一个执行单元访问共享资源。

竞态解决方法有：

• 原子操作。
• 自旋锁操作。
• 信号量操作。
• 互斥体操作。

12.3 原子

参考文档：

• Documentation\atomic_t.txt
• Documentation\atomic_bitops.txt

12.3.1 原子介绍

都知道，在 C 的世界里，a = 10; 这样一个简单的赋值，到了汇编的世界就不止一条语句啦。若此时多线程往变量 a 的地址赋值，就可能会产生数据错误。

原子操作就是不可分割操作。

注意：原子操作只能对 整型变量 和 位操作 具有保护功能。

12.3.2 原子操作步骤

原子操作：

• 定义原子变量&设置初始值。
• 设置原子变量的值。
• 获取原子变量的值。
• 原子变量的 加/减。
• 原子变量的 自加/自减。
• 原子变量的 加/减 及返回值。
• 原子变量测试函数。

12.3.3 原子 API

由于函数容易理解，所以就不像以前的笔记一样详细列出。

整型原子的操作需要个 atomic_t 结构体。

bit原子的操作只需要一个地址即可，是直接对内存操作。

atomic_t 32bit 整型原子变量结构体：

//atomic_t类型结构体
typedef struct
{
   int counter;
}atomic_t;

atomic64_t 64bit 整型原子变量结构体：

//atomic64_t 类型结构体
typedef struct
{
   long long  counter;
}atomic64_t;

整型原子 API 汇总：

API	描述
ATOMIC_INIT(int i)	定义原子变量时候的初始值
void atomic_set(atomic_t *v, int i)	向 v 写入 i
void atomic_read(atomic_t *v)	读取 v 的值
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_add_return(int i, atomic_t *v)	v 加 i ，返回 v 的结果
int atomic_sub_return(int i, atomic_t *v)	v 减 i ，返回 v 的结果
int atomic_inc_return(int i, atomic_t *v)	v 加 1 ，返回 v 的结果
int atomic_dec_return(int i, atomic_t *v)	v 减 1 ，返回 v 的结果
int atomic_sub_and_test(int i, atomic_t *v)	v 减 i 后是否为 0
int atomic_inc_and_test(atomic_t *v)	v 加 1 后是否为 0
int atomic_dec_and_test(atomic_t *v)	v 减 1 后是否为 0
int atomic_add_negative(int i, atomic_t *v)	v 加 i 后是否为 负数

更多 API（如atomic_dec_unless_positive()、atomic_inc_unless_negative()） 请参考内核源码和推荐的文档。

bit原子的操作不需要 atomic_t 结构体，它是直接对 内存 操作的。

bit 原子 API 汇总：

API	描述
void set_bit(int nr, void *p)	对地址 p 的第 nr 位置 1
void clear_bit(int nr, void *p)	对地址 p 的第 nr 位置 0
void change_bit(int nr, void *p)	对地址 p 的第 nr 位翻转
int test_bit(int nr, void *p)	返回地址 p 的第 nr 位的值
void test_and_set_bit(int nr, void *p)	对地址 p 的第 nr 位置 1，并返回原来的 nr 位值
void test_and_clear_bit(int nr, void *p)	对地址 p 的第 nr 位置 0，并返回原来的 nr 位值
void test_and_change_bit(int nr, void *p)	对地址 p 的第 nr 位翻转，并返回原来的 nr 位值

12.4 自旋锁

12.4.1 自旋锁介绍

原子操作只能对整型变量或者bit进行保护。而自旋锁能对一个单元进行保护，是给代码段添加一把锁。

自旋锁是实现互斥访问的常用手段。

获取自旋锁后再运行代码才能被保护起来。

自旋锁特点：

• 当使用自旋锁获取锁失败时（即需要访问的代码段被锁住了），线程不休眠，做死循环检测锁状态，直至自旋锁被释放。
• 简单，不休眠，可在中断中使用。
• 使用不当会导致死锁。如：
  • 递归获取锁：第一次获取锁成功，在自旋锁保护的代码段内进行获取锁，那便永远等不到解锁，导致死锁。

自旋锁缺点：

• 死循环检测，占用系统资源。
• 递归获取锁后会导致死锁。
• 同一线程不能连续两次获取自旋锁，必须一获取一释放。
• 自旋锁在锁定期间不能调用引起进程调度的函数，否则可能导致系统崩溃。

12.4.2 自旋锁操作步骤

自旋锁操作：

• 定义自旋锁。
• 初始化自旋锁。
• 获取自旋锁。
• 释放自旋锁。

自旋锁使用注意事项：

• 锁的持有时间要短。因为自旋锁是不会休眠的，以免其它线程获取锁等待太久，降低系统性能。
• 自旋锁保护的临界区内不能调用引起线程休眠的 API 函数，否则可能引起死锁。
• 不能递归获取自旋锁，否则会导致死锁。
• 按多核思想编程。提高系统可移植性。

12.4.3 自旋锁 API

spinlock_t 结构体：

typedef struct
{
   struct lock_impl internal_lock;
}spinlock_t;

自旋锁 API 汇总：

API	描述
DEFINE_SPINLOCK(spinlock_t lock)	定义、初始化一个自选变量
void spin_lock_init(spinlock_t *lock)	初始化一个自旋锁
void spin_lock(spinlock_t *lock)	加锁，即是获取一个自旋锁
int spin_trylock(spinlock_t *lock)	尝试获取自旋锁，不等待，成功返回 true，失败返回 false
void spin_unlock(spinlock_t *lock)	释放自旋锁
int spin_is_locked(spinlock_t *lock)	检查指定自旋锁是否已经被获取。若没有，则返回非0；否则返回 0
void spin_lock_irq(spinlock_t *lock)	获取自旋锁并关中断（防止中断打断）
void spin_unlock_irq(spinlock_t *lock)	释放自旋锁并开中断
spin_lock_irqsave(lock, flags)	获取自旋锁，并保存中断状态到flags。锁返回时，之前开的中断，之后也是开的；之前关，之后也是关
spin_unlock_irqrestore(lock, flags)	释放自旋锁，并恢复中断状态，即是把 flags 值赋值给中断状态寄存器。

12.4.4 读写自旋锁

普通的自旋锁是一刀切的，不管访问者对临界区的操作是读还是写。

但是实际上，很多共享资源都允许多个执行单元同时读，这是不影响数据的。

所以，读写自旋锁 允许 读并发，但是不允许 写并发，且不允许读写同时出现。

即有允许以下情景：

• 多读。
• 一写。

读写自旋锁 结构体：

typedef struct
{
   arch_rwlock_t raw_lock;
}rwlock_t;

读写自旋锁 API：

• 定义&初始化：

API	描述
DEFINE_RWLOCK(rwlock_t lock)	定义、初始化一个自选变量
void rwlock_init(rwlock_t *lock)	初始化一个自旋锁

• 读锁 API：

API	描述
void read_lock(rwlock_t *lock)	加锁，即是获取一个读自旋锁
void read_unlock(rwlock_t *lock)	释放读自旋锁
void read_lock_irq(rwlock_t *lock)	禁止本地中断，且加锁，即是获取一个读自旋锁
void read_unlock_irq(rwlock_t *lock)	打开本地中断，释放读自旋锁
void read_lock_irqsave(rwlock_t *lock, unsigned long flags)	保存本地中断状态，禁止本地中断，且加锁，即是获取一个读自旋锁
void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)	回复本地中断状态，且激活本地中断，释放读自旋锁
void read_lock_bh(rwlock_t *lock)	关闭下半部，加锁，即是获取一个读自旋锁
void read_unlock_bh(rwlock_t *lock)	打开下半部，释放读自旋锁

• 写锁：
  • 把前面读锁的前缀 read_ 改为 write_，即可。

12.4.5 顺序锁

顺序锁 是 读写锁 的一个优化。

读写锁 不允许读和写同时出现。有以下前景：

• 多读。
• 一写。

顺序锁 允许读和写同时出现，但是只能出现一个写。有以下前景：

• 多读。
• 一写。
• 多读一写。

顺序自旋锁 结构体：

typedef struct
{
   struct seqcount seqcount;
   spinlock_t lock;
}seqlock_t;

顺序自旋锁 API：

• 定义&初始化：

API	描述
DEFINE_SEQLOCK(seqlock_t sl)	定义、初始化一个自选变量
void seqlock_init(seqlock_t *sl)	初始化一个自旋锁

• 读锁 API：
  • 需要注意的是，写操作的顺序锁，会对顺序号加1-2。若 read_seqretry() 检测到顺序号不一致，则请重新读去数据。

API	描述
unsigned read_seqbegin(const seqlock_t *sl)	加锁，并返回获取到的顺序锁的顺序号
unsigned read_seqretry(const seqlock_t *sl)	读结束后调用该函数。用于检查在读的过程中是否有对资源进行写操作，若有，则返回1，建议重新读去数据。

• 写锁 API：

API	描述
void write_seqlock(seqlock_t *sl)	加锁，即是获取一个读自旋锁
void write_sequnlock(seqlock_t *sl)	释放读自旋锁
void write_seqlock_irq(seqlock_t *sl)	禁止本地中断，且加锁，即是获取一个读自旋锁
void write_sequnlock_irq(seqlock_t *sl)	打开本地中断，释放读自旋锁
void write_seqlock_irqsave(seqlock_t *sl, unsigned long flags)	保存本地中断状态，禁止本地中断，且加锁，即是获取一个读自旋锁
void write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)	回复本地中断状态，且激活本地中断，释放读自旋锁
void write_seqlock_bh(seqlock_t *sl)	关闭下半部，加锁，即是获取一个读自旋锁
void write_sequnlock_bh(seqlock_t *sl)	打开下半部，释放读自旋锁

12.5 信号量

12.5.1 信号量概念

学过 RTOS 的都知道信号量了。可以看做一个全局计数器。

信号量常用于同步和互斥。

信号量的获取失败后，线程可引入休眠，当信号量可用时，系统会通知其退出休眠。

12.5.2 信号量操作

信号量操作：

• 定义信号量。
• 初始化信号量。
• 尝试获取信号量。
• 获取信号量。
• 释放信号量。

信号量使用注意事项：

• 适用于占用资源较长时间的情景。因为信号量可以引起休眠，占用系统资源少。若占用资源时间少的，建议使用 自旋锁 ，因为不用切换线程，系统开销小。
• 不能用于中断。同样是因为信号量可以引起休眠。不过可以使用 down_interruptible() 函数。
• 保护的临界区内可调用引起阻塞的 API。

12.5.3 信号量 API

semaphore 结构体：

struct semaphore
{
    raw_spinlock_t    lock;
    unsigned int      count;
    struct list_head  wait_list;
};

API	描述
DEFINE_SEMAPHORE(name)	定义一个信号量，并置为 1
void sema_init(struct semaphore *sem, int val)	初始化信号量，并置为 val
void down(struct semaphore *sem)	获取信号量。因为信号量会导致休眠，且不能被信号打断，因此不能在中断中使用该函数
int down_trylock(struct semaphore *sem)	尝试获取信号量，不休眠。成功返回 0，失败返回 非0
void down_interruptible(struct semaphore *sem)	获取信号量。就算导致休眠后，也能被信号打断，因此该函数可以在中断中使用
void up(struct semaphore *sem)	释放信号量

12.6 互斥体

12.6.1 互斥体概念

互斥体 的占用其实和 信号量量值为 1 的效果是一样的。

但是互斥体的执行效率更高，毕竟，专业的API做专业的事嘛。

12.6.2 互斥体操作

互斥体执行操作：

• 定义互斥体。
• 初始化互斥体。
• 尝试获取互斥体。
• 获取互斥体。
• 释放互斥体。

互斥体使用注意事项：

• 不能在中断中使用。因为 mutex 会导致休眠。除非使用函数 int mutex_lock_interruptible。
• 必须由 mutex 持有者释放。因为一次只有一条线程持有。
• 保护的临界区内可调用引起阻塞的 API。

12.6.3 互斥体 API

API	描述
DEFINE_MUTEX(name)	定义并初始化一个 mutex 变量
void mutex_init(mutex *lock)	初始化 mutex
void mutex_lock(struct mutex *lock)	加锁，获取 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
void mutex_lock_interruptible(struct mutex *lock)	加锁，获取 mutex。获取失败进入休眠后，依然能被信号打断。支持在中断中使用。

12.7 完成量

12.7.1 完成量概念

完成量（completion）。

完成量用于一个执行单元等待另一个执行单元。

12.7.2 完成量操作

完成量操作：

• 定义完成量。
• 初始化完成量。
• 等待完成量。
• 唤醒完成量。

12.7.3 完成量 API

完成量结构体：

struct completion {
	unsigned int done;
	wait_queue_head_t wait;
};

API	描述
void complete(struct completion *x)	唤醒一个等待完成量 x 的线程
void complete_all(struct completion *x)	唤醒所有等待完成量 x 的线程
void wait_for_completion(struct completion *x)	等待一个完成量 x
unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout)	限时等待一个完成量 x
void init_completion(struct completion *c)	初始化一个完成量
void reinit_completion(struct completion *c)	重新初始化一个完成量