Linux驱动开发原子操作自旋锁信号量互斥体

Posted 2022-12-08 XXX_UUU_XXX

Linux系统是多任务操作系统，存在多个任务同时访问同一片内存区域的情况，多个任务可能会相互覆盖掉内存中的数据，造成内存数据混乱。

Linux系统并发主要原因

• 多线程并发访问
• 抢占式并发访问
• 中断程序并发访问
• 多核间并发访问

通常需要对全局变量、设备结构体这些共享资源进行保护，局部变量不需要保护，其他类型数据视情况而定。

原子操作

原子操作是不能再进一步分割的操作，只能用于整型变量或位操作。

Linux内核提供两组原子操作API函数，一组是对整型变量进行操作，另一组是对位进行操作。

整型操作API函数

Linux内核定义atomic_t结构体对整型数据进行原子操作。64位定义atomic64_t结构体，atomic_t其他相关API函数替换为atomic64_t即可。

在驱动入口函数xxx_init中atomic_set初始化，在xxx_open函数中atomic_read判断原子变量的值，并atomic_dec减一，在xxx_release函数中atomic_inc加一。或使用!atomic_dec_and_test判断。

定义atomic_t变量

atomic_t a;

定义atomic_t变量并使用宏ATOMIC_INIT赋初值0

atomic_t a = ATOMIC_INIT(0);

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，如果结果为负就返回真，否则返回假

位操作API函数

不使用atomic_t结构体，直接对内存进行操作

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持有时，线程B要获得自旋锁，线程B会处于自旋等待状态，不会进入休眠或去进行其他操作。

等待自旋锁的线程会一直处于自旋的状态，会浪费处理器时间，降低系统性能，所以自旋锁持有时间不能太长，适用于短时间轻量级加锁。

自旋锁不能直接判断，需要定义全局变量dev_status（0可用，大于1不可用）标记某个驱动是否被使用。在驱动入口函数xxx_init中spin_lock_init初始化，自旋锁持有时间不能太长，所以不能在open申请和release释放，在xxx_open函数中spin_lock加锁，加锁代码后面为代码保护区判断全局变量dev_status为0可用，然后加1，执行完毕后spin_unlock解锁，在xxx_release函数中spin_lock加锁，加锁代码后面为代码保护区判断全局变量dev_status减1，执行完毕后spin_unlock解锁。推荐使用 spin_lock_irqsave 和 spin_unlock_irqrestore。

Linux内核定义spinlock_t结构体表示自旋锁。

使用自旋锁之前，定义自旋锁变量。

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。

适用支持抢占的单CPU下线程间访问或多核间访问，自旋锁会自动禁止抢占，被自旋锁保护的临界区不能调用引起睡眠和阻塞的函数，否则会发生死锁现象。 

自旋锁中断API函数

中断里面可以使用自旋锁，中断在获得锁之前要先禁止本地中断（本CPU中断），否则会发生死锁现象。

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 ，这两个函数加锁会保存中断状态，释放锁会恢复中断状态。 

自旋锁中断下半部API函数

void spin_lock_bh(spinlock_t *lock);   // 关闭下半部，并获取自旋锁。
void spin_unlock_bh(spinlock_t *lock); // 打开下半部，并释放自旋锁。

自旋锁注意事项

1. 自旋锁持有时间不能太长，否则会降低系统性能。
2. 自旋锁保护的临界区内不能调用任何可能导致线程休眠或阻塞的API函数，否则会导致死锁。
3. 不能递归申请自旋锁，否则会导致死锁。
4. 考虑驱动的可移植性，按照多核SOC编写驱动程序。

信号量

信号量可以使线程进入休眠状态，提高处理器使用效率，但是信号量的开销大，信号量使线程进入休眠状态后会切换线程，切换线程会有开销。

在驱动入口函数xxx_init中sema_init初始化，在xxx_open函数中down或down_interruptible加锁，在xxx_release函数中up加锁。

Linux内核定义semaphore结构体表示信号量。定义信号量。

struct semaphore sem;

信号量API函数

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);     // 释放信号量

信号量注意事项

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

计数型信号量

通过信号量访问资源的线程数，初始化时将信号量值设置大于1，这个信号量就是计数型信号量。因为计数型信号量允许多个线程同时访问共享资源，所以不能用于互斥访问。

二值信号量

通过信号量访问资源的线程数，初始化时将信号量值设置不能大于1，这个信号量就是二值型信号量。可以互斥访问。

互斥体

互斥访问就是一次只能有一个线程访问共享资源，不能递归申请互斥体。将信号量值设置为1就可以互斥访问，但是Linux提供一个更专业的互斥体机制表示互斥。

在驱动入口函数xxx_init中mutex_init初始化，在xxx_open函数中mutex_lock或加锁，在xxx_release函数中mutex_unlock加锁。

Linux内核定义mutex结构体表示互斥体。定义一个互斥体。

struct mutex lock;

互斥体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，也就给 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); //使用此函数获取信号量失败进入休眠以后可以被信号打断。

互斥体注意事项

1. 互斥体会导致休眠，所以不能在中断中使用互斥体。中断中只能使用自旋锁。
2. 互斥体保护的临界区可以调用引起阻塞的API函数。
3. 互斥体由互斥锁的持有者进行释放。
4. 互斥体不能递归上锁和解锁。

驱动开发大部分都是互斥体