• linux设备驱动第五篇：驱动中的并发与竟态

    综述

    在上一篇介绍了linux驱动的调试方法，这一篇介绍一下在驱动编程中会遇到的并发和竟态以及如何处理并发和竞争。

    首先什么是并发与竟态呢？并发(concurrency)指的是多个执行单元同时、并行被执行。而并发的执行单元对共享资源(硬件资源和软件上的全局、静态变量)的访问则容易导致竞态(race conditions)。可能导致并发和竟态的情况有：

    • SMP（Symmetric Multi-Processing），对称多处理结构。SMP是一种紧耦合、共享存储的系统模型，它的特点是多个CPU使用共同的系统总线，因此可访问共同的外设和存储器。 
    • 中断。中断可 打断正在执行的进程，若中断处理程序访问进程正在访问的资源，则竞态也会发生。中断也可能被新的更高优先级的中断打断，因此，多个中断之间也可能引起并发而导致竞态。
    • 内核进程的抢占。linux是可抢占的，所以一个内核进程可能被另一个高优先级的内核进程抢占。如果两个进程共同访问共享资源，就会出现竟态。

    以上三种情况只有SMP是真正意义上的并行，而其他都是宏观上的并行，微观上的串行。但其都会引发对临界共享区的竞争问题。而解决竞态问题的途径是保证对共享资源的互斥访问，即一个执行单元在访问共享资源的时候，其他的执行单元被禁止访问。那么linux内核中如何做到对对共享资源的互斥访问呢？在linux驱动编程中，常用的解决并发与竟态的手段有信号量与互斥锁，Completions 机制，自旋锁（spin lock），以及一些其他的不使用锁的实现方式。下面一一介绍。

    信号量与互斥锁

    信号量其实就是一个整型值，其核心是一个想进入临界区的进程将在相关信号量上调用 P; 如果信号量的值大于零, 这个值递减 1 并且进程继续. 相反,，如果信号量的值是 0 ( 或更小 ), 进程必须等待直到别人释放信号量. 解锁一个信号量通过调用 V 完成； 这个函数递增信号量的值,，并且， 如果需要, 唤醒等待的进程。而当信号量的初始值为1的时候，就变成了互斥锁。
    信号量的典型使用形式：
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. //声明信号量  
    2. struct semaphore sem;  
    3.   
    4. //初始化信号量  
    5. void sema_init(struct semaphore *sem, int val)  
    6.     //常用下面两种形式  
    7. #define init_MUTEX(sem) sema_init(sem, 1)  
    8. #define init_MUTEX_LOCKED(sem) sema_init(sem, 0)  
    9.     //以下是初始化信号量的快捷方式，最常用的  
    10. DECLARE_MUTEX(name)    //初始化name的信号量为1  
    11. DECLARE_MUTEX_LOCKED(name) //初始化信号量为0  
    12.   
    13. //常用操作  
    14. DECLARE_MUTEX(mount_sem);  
    15. down(&mount_sem); //获取信号量  
    16. ...  
    17. critical section    //临界区  
    18. ...  
    19. up(&mount_sem);    //释放信号量  
    //声明信号量
struct semaphore sem;

//初始化信号量
void sema_init(struct semaphore *sem, int val)
    //常用下面两种形式
#define init_MUTEX(sem) sema_init(sem, 1)
#define init_MUTEX_LOCKED(sem) sema_init(sem, 0)
    //以下是初始化信号量的快捷方式，最常用的
DECLARE_MUTEX(name)    //初始化name的信号量为1
DECLARE_MUTEX_LOCKED(name) //初始化信号量为0

//常用操作
DECLARE_MUTEX(mount_sem);
down(&mount_sem); //获取信号量
...
critical section    //临界区
...
up(&mount_sem);    //释放信号量
    常用的down操作还有
     
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. // 类似down(),因为down()而进入休眠的进程不能被信号打断，而因为down_interruptible()而进入休眠的进程能被信号打断，   
    2. // 信号也会导致该函数返回，此时返回值非0  
    3. int down_interruptible(struct semaphore *sem);  
    4. // 尝试获得信号量sem，若立即获得，它就获得该信号量并返回0，否则，返回非0.它不会导致调用者睡眠，可在中断上下文使用  
    5. int down_trylock(struct semaphore *sem);  
    // 类似down(),因为down()而进入休眠的进程不能被信号打断，而因为down_interruptible()而进入休眠的进程能被信号打断， 
// 信号也会导致该函数返回，此时返回值非0
int down_interruptible(struct semaphore *sem);
// 尝试获得信号量sem，若立即获得，它就获得该信号量并返回0，否则，返回非0.它不会导致调用者睡眠，可在中断上下文使用
int down_trylock(struct semaphore *sem);

    Completions 机制

    完成量(completion)提供了一种比信号量更好的同步机制，它用于一个执行单元等待另一个执行单元执行完某事。
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. </pre></div><div><pre name="code" class="cpp">// 定义完成量  
    2. struct completion my_completion;  
    3.    
    4. // 初始化completion  
    5. init_completion(&my_completion);  
    6.    
    7. // 定义和初始化快捷方式：  
    8. DECLEAR_COMPLETION(my_completion);  
    9.    
    10. // 等待一个completion被唤醒  
    11. void wait_for_completion(struct completion *c);  
    12.    
    13. // 唤醒完成量  
    14. void cmplete(struct completion *c);  
    15. void cmplete_all(struct completion *c);  
    </pre></div><div><pre name="code" class="cpp">// 定义完成量
struct completion my_completion;
 
// 初始化completion
init_completion(&my_completion);
 
// 定义和初始化快捷方式：
DECLEAR_COMPLETION(my_completion);
 
// 等待一个completion被唤醒
void wait_for_completion(struct completion *c);
 
// 唤醒完成量
void cmplete(struct completion *c);
void cmplete_all(struct completion *c);

    自旋锁

    若一个进程要访问临界资源，测试锁空闲，则进程获得这个锁并继续执行；若测试结果表明锁扔被占用，进程将在一个小的循环内重复“测试并设置”操作，进行所谓的“自旋”，等待自旋锁持有者释放这个锁。自旋锁与互斥锁类似，但是互斥锁不能用在可能睡眠的代码中，而自旋锁可以用在可睡眠的代码中，典型的应用是可以用在中断处理函数中。自旋锁的相关操作：
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. // 定义自旋锁   
    2. spinlock_t spin;   
    3.    
    4. // 初始化自旋锁  
    5. spin_lock_init(lock);  
    6.    
    7. // 获得自旋锁：若能立即获得锁，它获得锁并返回，否则，自旋，直到该锁持有者释放  
    8. spin_lock(lock);   
    9.    
    10. // 尝试获得自旋锁：若能立即获得锁，它获得并返回真，否则立即返回假，不再自旋  
    11. spin_trylock(lock);   
    12.    
    13. // 释放自旋锁: 与spin_lock(lock)和spin_trylock(lock)配对使用  
    14. spin_unlock(lock);   
    15.    
    16.   自旋锁的使用：  
    17. // 定义一个自旋锁  
    18. spinlock_t lock;  
    19. spin_lock_init(&lock);  
    20.    
    21. spin_lock(&lock);  // 获取自旋锁，保护临界区  
    22. ...  // 临界区  
    23. spin_unlock();  // 解锁  
    // 定义自旋锁 
spinlock_t spin; 
 
// 初始化自旋锁
spin_lock_init(lock);
 
// 获得自旋锁：若能立即获得锁，它获得锁并返回，否则，自旋，直到该锁持有者释放
spin_lock(lock); 
 
// 尝试获得自旋锁：若能立即获得锁，它获得并返回真，否则立即返回假，不再自旋
spin_trylock(lock); 
 
// 释放自旋锁: 与spin_lock(lock)和spin_trylock(lock)配对使用
spin_unlock(lock); 
 
  自旋锁的使用：
// 定义一个自旋锁
spinlock_t lock;
spin_lock_init(&lock);
 
spin_lock(&lock);  // 获取自旋锁，保护临界区
...  // 临界区
spin_unlock();  // 解锁
    自旋锁持有期间内核的抢占将被禁止。自旋锁可以保证临界区不受别的CPU和本CPU内的抢占进程打扰，但是得到锁的代码路径在执行临界区的时候还可能受到中断和底半部(BH)的影响。为防止这种影响，需要用到自旋锁的衍生：
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. spin_lock_irq() = spin_lock() + local_irq_disable()  
    2. spin_unlock_irq() = spin_unlock() + local_irq_enable()  
    3. spin_lock_irqsave() = spin_lock() + local_irq_save()  
    4. spin_unlock_irqrestore() = spin_unlock() + local_irq_restore()  
    5. spin_lock_bh() = spin_lock() + local_bh_disable()  
    6. spin_unlock_bh() = spin_unlock() + local_bh_enable()  
    spin_lock_irq() = spin_lock() + local_irq_disable()
spin_unlock_irq() = spin_unlock() + local_irq_enable()
spin_lock_irqsave() = spin_lock() + local_irq_save()
spin_unlock_irqrestore() = spin_unlock() + local_irq_restore()
spin_lock_bh() = spin_lock() + local_bh_disable()
spin_unlock_bh() = spin_unlock() + local_bh_enable()

    其他的一些选择

    以上是linux驱动编程中经常用到的锁机制，下面讲一些内核中其他的一些实现。

    不加锁算法

    有时, 你可以重新打造你的算法来完全避免加锁的需要.。许多读者/写者情况 -- 如果只有一个写者 -- 常常能够在这个方式下工作.。如果写者小心使数据结构，由读者所见的，是一直一致的,，有可能创建一个不加锁的数据结构。在linux内核中就有一个通用的无锁的环形缓冲实现，具体内容参考<linux/kfifo.h>。

    原子变量与位操作

    原子操作指的是在执行过程中不会被别的代码路径所中断的操作。原子变量与位操作都是原子操作。以下是其相关操作介绍。
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. // 设置原子变量的值  
    2. void atomic_set(atomic_t *v, int i);  // 设置原子变量的值为i  
    3. atomic_t v = ATOMIC_INIT(0);  // 定义原子变量v，并初始化为0  
    4.    
    5. // 获取原子变量的值  
    6. atomic_read(atomic_t *v);  // 返回原子变量的值  
    7.    
    8. // 原子变量加/减  
    9. void atomic_add(int i, atomic_t *v);  // 原子变量加i  
    10. void atomic_sub(int i, atomic_t *v);  // 原子变量减i  
    11.    
    12. // 原子变量自增/自减  
    13. void atomic_inc(atomic_t *v);  // 原子变量增加1  
    14. void atomic_dec(atomic_t *v);  // 原子变量减少1  
    15.    
    16. // 操作并测试：对原子变量进行自增、自减和减操作后(没有加)测试其是否为0，为0则返回true，否则返回false  
    17. int atomic_inc_and_test(atomic_t *v);  
    18. int atomic_dec_and_test(atomic_t *v);  
    19. int atomic_sub_and_test(int i, atomic_t *v);  
    20.    
    21. // 操作并返回： 对原子变量进行加/减和自增/自减操作，并返回新的值  
    22. int atomic_add_return(int i, atomic_t *v);  
    23. int atomic_sub_return(int i, atomic_t *v);  
    24. int atomic_inc_return(atomic_t *v);  
    25. int atomic_dec_return(atomic_t *v);  
    26.   位原子操作：  
    27. // 设置位  
    28. void set_bit(nr, void *addr);  // 设置addr地址的第nr位，即将位写1  
    29.    
    30. // 清除位  
    31. void clear_bit(nr, void *addr);  // 清除addr地址的第nr位，即将位写0  
    32.    
    33. // 改变位  
    34. void change_bit(nr, void *addr);  // 对addr地址的第nr位取反  
    35.    
    36. // 测试位  
    37. test_bit(nr, void *addr); // 返回addr地址的第nr位  
    38.    
    39. // 测试并操作：等同于执行test_bit(nr, void *addr)后再执行xxx_bit(nr, void *addr)  
    40. int test_and_set_bit(nr, void *addr);  
    41. int test_and_clear_bit(nr, void *addr);  
    42. int test_and_change_bit(nr, void *addr);  
    // 设置原子变量的值
void atomic_set(atomic_t *v, int i);  // 设置原子变量的值为i
atomic_t v = ATOMIC_INIT(0);  // 定义原子变量v，并初始化为0
 
// 获取原子变量的值
atomic_read(atomic_t *v);  // 返回原子变量的值
 
// 原子变量加/减
void atomic_add(int i, atomic_t *v);  // 原子变量加i
void atomic_sub(int i, atomic_t *v);  // 原子变量减i
 
// 原子变量自增/自减
void atomic_inc(atomic_t *v);  // 原子变量增加1
void atomic_dec(atomic_t *v);  // 原子变量减少1
 
// 操作并测试：对原子变量进行自增、自减和减操作后(没有加)测试其是否为0，为0则返回true，否则返回false
int atomic_inc_and_test(atomic_t *v);
int atomic_dec_and_test(atomic_t *v);
int atomic_sub_and_test(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);
  位原子操作：
// 设置位
void set_bit(nr, void *addr);  // 设置addr地址的第nr位，即将位写1
 
// 清除位
void clear_bit(nr, void *addr);  // 清除addr地址的第nr位，即将位写0
 
// 改变位
void change_bit(nr, void *addr);  // 对addr地址的第nr位取反
 
// 测试位
test_bit(nr, void *addr); // 返回addr地址的第nr位
 
// 测试并操作：等同于执行test_bit(nr, void *addr)后再执行xxx_bit(nr, void *addr)
int test_and_set_bit(nr, void *addr);
int test_and_clear_bit(nr, void *addr);
int test_and_change_bit(nr, void *addr);

    seqlock（顺序锁）

     
    使用seqlock锁，读执行单元不会被写执行单元阻塞，即读执行单元可以在写执行单元对被seqlock锁保护的共享资源进行写操作时仍然可以继续读，而不必等待写执行单元完成写操作，写执行单元也不需要等待所有读执行单元完成读操作才去进行写操作。写执行单元之间仍是互斥的。若读操作期间，发生了写操作，必须重新读取数据。seqlock锁必须要求被保护的共享资源不含有指针。
    [cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. // 获得顺序锁  
    2. void write_seqlock(seqlock_t *sl);  
    3. int write_tryseqlock(seqlock_t *sl);  
    4. write_seqlock_irqsave(lock, flags)  
    5. write_seqlock_irq(lock)  
    6. write_seqlock_bh()  
    7.    
    8. // 释放顺序锁  
    9. void write_sequnlock(seqlock_t *sl);  
    10. write_sequnlock_irqrestore(lock, flags)  
    11. write_sequnlock_irq(lock)  
    12. write_sequnlock_bh()  
    13.    
    14. // 写执行单元使用顺序锁的模式如下：  
    15. write_seqlock(&seqlock_a);  
    16. ...  // 写操作代码块  
    17. write_sequnlock(&seqlock_a);  
    18.   读执行单元操作：  
    19. // 读开始：返回顺序锁sl当前顺序号  
    20. unsigned read_seqbegin(const seqlock_t *sl);  
    21. read_seqbegin_irqsave(lock, flags)  
    22.    
    23. // 重读：读执行单元在访问完被顺序锁sl保护的共享资源后需要调用该函数来检查，在读访问期间是否有写操作。若有写操作，重读  
    24. int read_seqretry(const seqlock_t *sl, unsigned iv);  
    25. read_seqretry_irqrestore(lock, iv, flags)  
    26.    
    27. // 读执行单元使用顺序锁的模式如下：  
    28. do{  
    29.     seqnum = read_seqbegin(&seqlock_a);  
    30.     // 读操作代码块   
    31.     ...  
    32. }while(read_seqretry(&seqlock_a, seqnum));  
    // 获得顺序锁
void write_seqlock(seqlock_t *sl);
int write_tryseqlock(seqlock_t *sl);
write_seqlock_irqsave(lock, flags)
write_seqlock_irq(lock)
write_seqlock_bh()
 
// 释放顺序锁
void write_sequnlock(seqlock_t *sl);
write_sequnlock_irqrestore(lock, flags)
write_sequnlock_irq(lock)
write_sequnlock_bh()
 
// 写执行单元使用顺序锁的模式如下：
write_seqlock(&seqlock_a);
...  // 写操作代码块
write_sequnlock(&seqlock_a);
  读执行单元操作：
// 读开始：返回顺序锁sl当前顺序号
unsigned read_seqbegin(const seqlock_t *sl);
read_seqbegin_irqsave(lock, flags)
 
// 重读：读执行单元在访问完被顺序锁sl保护的共享资源后需要调用该函数来检查，在读访问期间是否有写操作。若有写操作，重读
int read_seqretry(const seqlock_t *sl, unsigned iv);
read_seqretry_irqrestore(lock, iv, flags)
 
// 读执行单元使用顺序锁的模式如下：
do{
    seqnum = read_seqbegin(&seqlock_a);
    // 读操作代码块 
    ...
}while(read_seqretry(&seqlock_a, seqnum));

    读取-拷贝-更新（RCU）

     
    读取-拷贝-更新(RCU) 是一个高级的互斥方法，在合适的时候可以取得非常高的效率。RCU可以看作读写锁的高性能版本，相比读写锁，RCU的优点在于既允许多个读执行单元同时访问被保护的数据，又允许多个读执行单元和多个写执行单元同时访问被保护的数据。但是RCU不能替代读写锁，因为如果写比较多时，对读执行单元的性能提高不能弥补写执行单元导致的损失。由于平时应用较少，所以不做多说。

    小结

    以上就是linux驱动编程中涉及的并发与竞态的内容，下面做一个简单的小结。
     
    现在的处理器基本上都是SMP类型的，而且在新的内核版本中，基本上都支持抢占式的操作，在linux中很多程序都是可重入的，要保护这些数据，就得使用不同的锁机制。而锁机制的基本操作过程其实大同小异的，声明变量，上锁，执行临界区代码，然后再解锁。不同点在于，可以重入的限制不同，有的可以无限制重入，有的只允许异种操作重入，而有的是不允许重入操作的，有的可以在可睡眠代码中使用，有的不可以在可睡眠代码中使用。而在考虑不同的锁机制的使用时，也要考虑CPU处理的效率问题，对于不同的代码长度，不同的代码执行时间，选择一个好的锁对CPU的良好使用有很大的影响，否则将造成浪费。 
     
    之前在linux设备驱动第三篇：写一个简单的字符设备驱动中介绍了简单的字符设备驱动，下一篇将介绍一些字符设备驱动中得高级操作。

    第一时间获得博客更新提醒，以及更多技术信息分享，欢迎关注个人微信公众平台:程序员互动联盟(coder_online)，扫一扫下方二维码或搜索微信号coder_online即可关注,阅读android，chrome等多种热门技术文章。
  • 相关阅读:
    .net core下直接执行SQL语句并生成DataTable
    asp.net core获取HttpContext相关操作
    连接Oracle的几种方式
    数据库（表）的逻辑备份与恢复
    Oracle函数
    Oracle 11g ORA-12514:TNS:监听程序当前无法识别连接描述符中请求的服务
    未在本地计算机上注册"MSDAORA.1"提供程序
    如果在安装32位oracle 客户端组件时的情况下以64位模式运行,将出现问题
    Oracle Client安装与基本配置
    事务
  • 原文地址：https://www.cnblogs.com/qiugc846717529/p/4418202.html
Copyright © 2020-2023  润新知