你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

STM32MP1嵌入式Linux驱动开发指南V1.7——Linux并发与竞争

[复制链接]
STMCU小助手 发布时间:2022-9-26 21:12
Linux并发与竞争" z1 L8 x8 \- k, F* y& k+ X
Linux是一个多任务操作系统,肯定会存在多个任务共同操作同一段内存或者设备的情况,多个任务甚至中断都能访问的资源叫做共享资源,就和共享单车一样。在驱动开发中要注意对共享资源的保护,也就是要处理对共享资源的并发访问。比如共享单车,大家按照谁扫谁骑走的原则来共用这个单车,如果没有这个并发访问共享单车的原则存在,只怕到时候为了一辆单车要打起来了。在Linux驱动编写过程中对于并发控制的管理非常重要,本章我们就来学习一下如何在Linux驱动中处理并发。
* `- A6 e5 t  ?
) U7 ?6 R# p/ n27.1 并发与竞争+ s  N. f% \/ v$ ~/ f( K1 Y7 {
1、并发与竞争简介# Y3 W9 t4 J0 x8 Y7 ?! A  j
并发就是多个“用户”同时访问同一个共享资源,比如你们公司有一台打印机,你们公司的所有人都可以使用。现在小李和小王要同时使用这一台打印机,都要打印一份文件。小李要打印的文件内容如下:
8 Q  Z1 Y+ h2 e4 ^# r示例代码27.1.1 小李要打印的内容
( B+ |5 F- [, {/ X8 r9 N) a4 T& H我叫小李
: W& h6 z* n, l  ^电话:123456
# ?4 ~1 u9 b( L0 G工号:16, z) G# [! }1 F6 W8 z, F5 O
小王要打印的内容如下:, a5 m) A: i+ \6 x* r3 g
示例代码27.1.2 小王要打印的内容9 w. L. z' k- B
我叫小王
- \% `) J* N4 ^6 ]" Y电话:678910: y: j# w" c0 w9 q
工号:206 L3 D3 `1 z8 ]" H' a. K: [
这两份文档肯定是各自打印出来的,不能相互影响。当两个人同时打印的时候,如果打印机不做处理,可能会出现小李的文档打印了一行,然后开始打印小王的文档,这样打印出来的文档就错乱了,可能会出现如下的错误文档内容:
/ E" F  ?3 Y  ]+ K0 n4 J/ ~1 [7 b' P示例代码27.1.3 小王打印出来的错误文档
: l6 o, [2 p- _6 t& {) C' e我叫小王/ Q' M0 k  [0 k0 y8 t1 w
电话:123456% y0 d8 X) P( B
工号:201 M/ ~  |  V9 `: q, v
可以看出,小王打印出来的文档中电话号码错误了,变成小李的了,这是绝对不允许的。如果有多人同时向打印机发送了多份文档,打印机必须保证一次只能打印一份文档,只有打印完成以后才能打印其他的文档。) C! x- O4 w9 b6 ~0 l5 H4 |
Linux系统是个多任务操作系统,会存在多个任务同时访问同一片内存区域,这些任务可能会相互覆盖这段内存中的数据,造成内存数据混乱。针对这个问题必须要做处理,严重的话可能会导致系统崩溃。现在的Linux系统并发产生的原因很复杂,总结一下有下面几个主要原因:
' V' u$ q/ y8 s& G6 V: U. ]1 \①、多线程并发访问,Linux是多任务(线程)的系统,所以多线程访问是最基本的原因。. k9 q. F# ]9 s" w4 O' M2 j; k
②、抢占式并发访问,从2.6版本内核开始,Linux内核支持抢占,也就是说调度程序可以在任意时刻抢占正在运行的线程,从而运行其他的线程。+ O" e3 H  G, }# P8 J3 R
③、中断程序并发访问,这个无需多说,学过STM32的同学应该知道,硬件中断的权利可是很大的。
* |' _5 J; C6 U( }④、SMP(多核)核间并发访问,现在ARM架构的多核SOC很常见,多核CPU存在核间并发访问。2 I. K# _6 F% B
并发访问带来的问题就是竞争,学过FreeRTOS或UCOS这类RTOS的同学应该知道临界区这个概念,所谓的临界区就是共享数据段,对于临界区必须保证一次只有一个线程访问,也就是要保证临界区是原子访问的,注意这里的“原子”不是正点原子的“原子”。我们都知道,原子是化学反应不可再分的基本微粒,这里的原子访问就表示这一个访问是一个步骤,不能再进行拆分。如果多个线程同时操作临界区就表示存在竞争,我们在编写驱动的时候一定要注意避免并发和防止竞争访问。很多Linux驱动初学者往往不注意这一点,在驱动程序中埋下了隐患,这类问题往往又很不容易查找,导致驱动调试难度加大、费时费力。所以我们一般在编写驱动的时候就要考虑到并发与竞争,而不是驱动都编写完了然后再处理并发与竞争。" m% t. t. ~, {& q6 [+ Y
2、保护内容是什么
6 x- F" x, N4 Z6 M. G9 B* [' f% n前面一直说要防止并发访问共享资源,换句话说就是要保护共享资源,防止进行并发访问。那么问题来了,什么是共享资源?现实生活中的公共电话、共享单车这些是共享资源,我们都很容易理解,那么在程序中什么是共享资源?也就是保护的内容是什么?我们保护的不是代码,而是数据!某个线程的局部变量不需要保护,我们要保护的是多个线程都会访问的共享数据。一个整形的全局变量a是数据,一份要打印的文档也是数据,虽然我们知道了要对共享数据进行保护,那么怎么判断哪些共享数据要保护呢?找到要保护的数据才是重点,而这个也是难点,因为驱动程序各不相同,那么数据也千变万化,一般像全局变量,设备结构体这些肯定是要保护的,至于其他的数据就要根据实际的驱动程序而定了。
( b" r) B" V. c( M; l. c当我们发现驱动程序中存在并发和竞争的时候一定要处理掉,接下来我们依次来学习一下Linux内核提供的几种并发和竞争的处理方法。$ |8 N8 x; F6 k/ |9 J: b1 W
27.2 原子操作2 M4 B3 s7 H0 E8 J+ y
27.2.1 原子操作简介
: Y+ I* [4 A* g( j" K0 g" Y首先看一下原子操作,原子操作就是指不能再进一步分割的操作,一般原子操作用于变量或者位操作。假如现在要对无符号整形变量a赋值,值为3,对于C语言来讲很简单,直接就是:; T* T, b/ m# X' d: w- T2 ]
a = 3
' Y/ j2 B0 b% s但是C语言要先编译为成汇编指令,ARM架构不支持直接对寄存器(内存)进行读写操作,要借助寄存器R0、R1等来完成赋值操作。假设变量a的地址为0X3000000,“a=3”这一行C语言可能会被编译为如下所示的汇编代码:
' t: f: F0 G; E8 |  i" q8 [0 M- \6 d
! U+ _$ G5 @$ L6 M" C. i" U
  1. 示例代码27.2.1.1 汇编示例代码
    - }% B8 B$ q7 z* f, C
  2. 1 ldr r0, =0X30000000           /* 变量a地址                         */8 [$ Y( G7 U, {" U# M
  3. 2 ldr r1, = 3                  /* 要写入的值                         */
    : S3 N0 G  i; E, Z5 b
  4. 3 str r1, [r0]                  /* 将3写入到a变量中         */
复制代码
6 u' T6 A# m' }7 Z& i* N& D7 a
示例代码27.2.1.1只是一个简单的举例说明,实际的结果要比示例代码复杂的多。从上述代码可以看出,C语言里面简简单单的一句“a=3”,编译成汇编文件以后变成了3句,那么程序在执行的时候肯定是按照示例代码27.2.1.1中的汇编语句一条一条的执行。假设现在线程A要向a变量写入10这个值,而线程B也要向a变量写入20这个值,我们理想中的执行顺序如图27.2.1.1所示:4 T, s: u. J& r9 o, C7 |

5 O- G" B# X( U" B" ~5 K 090ec6203da14d7384a1b3273451c361.png ' Q6 h2 U" n$ p- {5 B

- i4 O7 ^7 b- X8 }$ x  p( q# ?& S图27.2.1.1 理想的执行流程  B. \, x* w* M& s1 n" [( |6 ?  F
按照图27.2.1.1所示的流程,确实可以实现线程A将a变量设置为10,线程B将a变量设置为20。但是实际上的执行流程可能如图27.2.1.2所示:
. x3 p1 [# ]: `
; p3 L% l: S1 Z! j0 ` d77665dac35b4bbc931c8c87266246e5.png
7 y  s1 }/ L# _7 G1 ]2 F: U9 `/ X/ r0 a& k" M" H7 o  `; {5 U7 ~
图27.2.1.2 可能的执行流程+ ], E# S1 k! H' ?$ \, b' G
按照图27.2.1.2所示的流程,线程A最终将变量a设置为了20,而并不是要求的10!线程B没有问题。这就是一个最简单的设置变量值的并发与竞争的例子,要解决这个问题就要保证示例代码27.2.1.1中的三行汇编指令作为一个整体运行,也就是作为一个原子存在。Linux内核提供了一组原子操作API函数来完成此功能,Linux内核提供了两组原子操作API函数,一组是对整形变量进行操作的,一组是对位进行操作的,我们接下来看一下这些API函数。6 H9 B5 d  C& C3 B- Q( n! J
27.2.2 原子整形操作API函数0 y7 P, l# Q4 R
Linux内核定义了叫做atomic_t的结构体来完成整形数据的原子操作,在使用中用原子变量来代替整形变量,此结构体定义在include/linux/types.h文件中,定义如下:% Y' F' r) h& B$ ^$ {$ m" r7 f

8 m4 X8 g- T% o0 j8 [8 A
  1. 示例代码27.2.2.1 atomic_t结构体
    ) t, t! {6 m3 z
  2. 171 typedef struct {, n4 Z7 M7 D8 u& k# l+ E2 ?
  3. 172     int counter;: B4 [; y0 n6 m4 F: b( l
  4. 173 } atomic_t;
复制代码

( U: |+ E* o1 D* ~如果要使用原子操作API函数,首先要先定义一个atomic_t的变量,如下所示:; D; q( A# r  r% }) a

& [0 @* `, Y/ }8 {atomic_t a; //定义a
" u4 Q. [# e8 z也可以在定义原子变量的时候给原子变量赋初值,如下所示:4 S. o7 _6 ?% D
atomic_t b = ATOMIC_INIT(0); //定义原子变量b并赋初值为0
4 ]: L% {2 A- f) g) D& m. ]# m+ e可以通过宏ATOMIC_INIT向原子变量赋初值。2 V. p5 ~+ ^2 q' b0 `
原子变量有了,接下来就是对原子变量进行操作,比如读、写、增加、减少等等,Linux内核提供了大量的原子操作API函数,如表27.2.2.1所示:
/ ^) U5 F7 b. o+ Q- i. s; k
; ~. d# O7 p# H/ ^7 K 059b99004748476f9847ba81b1ff5a4f.png   U8 Z* G' K# c% z* _% Z) ~0 |4 p( o

2 P. X4 ^9 i  ^6 a& A# t表27.2.2.1 原子整形操作API函数表
/ B4 j0 e" R- Z如果使用64位的SOC的话,就要用到64位的原子变量,Linux内核也定义了64位原子结构体,如下所示:& |8 g. a) G4 y* g- c5 _5 A+ ?
4 Y8 {: l5 H$ D' h8 O
  1. 示例代码27.2.2.2 atomic64_t结构体
    9 v) t1 w, q$ `( t
  2. 176 typedef struct {9 w% d6 e" z2 y/ M% @9 w2 d  c
  3. 177     s64 counter;
    5 j$ e% _1 X& ^8 G. I
  4. 178 } atomic64_t;
复制代码
& h! V9 _3 v0 u, n8 b7 q2 _
可以看出,counter变为了s64类型,s64本质是long long类型,相应的也提供了64位原子变量的操作API函数,这里我们就不详细讲解了,和表27.2.1.1中的API函数有用法一样,只是将“atomic_”前缀换为“atomic64_”,将int换为long long。如果使用的是64位的SOC,那么就要使用64位的原子操作函数。Cortex-A7是32位的架构,所以本书中只使用表27.2.2.1中的32位原子操作函数。原子变量和相应的API函数使用起来很简单,参考如下示例:
! Y8 b5 ~% }* a. h" U8 K7 E7 o( k& ]/ J# l+ [; J5 E
  1. 示例代码27.2.2.2 原子变量和API函数使用
    & L, [( C; i4 {5 X) L
  2. atomic_t v = ATOMIC_INIT(0);            /* 定义并初始化原子变零v=0         */
    ) l  Q3 N3 @3 n: a* r
  3. ( @/ N" D! t9 l; C* O
  4. atomic_set(&v, 10);                             /* 设置v=10                                 */% a2 X2 z, y9 t! `9 {
  5. atomic_read(&v);                                    /* 读取v的值,肯定是10         */' @/ [3 T5 q7 A. Z5 F, L2 B* o* R
  6. atomic_inc(&v);                                     /* v的值加1,v=11                         */
复制代码

+ b& H" S- ?# ?# \/ {* ?7 r27.2.3 原子位操作API函数4 t& V; I: c/ V
位操作也是很常用的操作,Linux内核也提供了一系列的原子位操作API函数,只不过原子位操作不像原子整形变量那样有个atomic_t的数据结构,原子位操作是直接对内存进行操作,API函数如表27.2.3.1所示:
' _9 `" c6 y: |0 W( X& M. l- ^! F0 }函数 描述7 w0 k6 e6 D2 ~# ~4 C4 j
5 y; d# F/ ~# |: f. R
bdac59f297cb4bb5a952dccf36d1c287.png
+ S8 }) Z3 `1 ^$ s
; u0 }8 N. [6 X/ j2 R* x3 T表27.2.3.1 原子位操作函数表
3 F& n+ p8 A: M+ }3 w2 {
: t0 H# M6 H& E- w: j" ?% J27.3 自旋锁
' ]0 W+ J- s' `7 |3 h7 h27.3.1 自旋锁简介1 \+ @: j( P9 |% r! b: w
原子操作只能对整形变量或者位进行保护,但是,在实际的使用环境中怎么可能只有整形变量或位这么简单的临界区。举个最简单的例子,设备结构体变量就不是整型变量,我们对于结构体中成员变量的操作也要保证原子性,在线程A对结构体变量使用期间,应该禁止其他的线程来访问此结构体变量,这些工作原子操作都不能胜任,需要本节要讲的锁机制,在Linux内核中就是自旋锁。0 G5 y$ P. R- a% C
当一个线程要访问某个共享资源的时候首先要先获取相应的锁,锁只能被一个线程持有,只要此线程不释放持有的锁,那么其他的线程就不能获取此锁。对于自旋锁而言,如果自旋锁正在被线程A持有,线程B想要获取自旋锁,那么线程B就会处于忙循环-旋转-等待状态,线程B不会进入休眠状态或者说去做其他的处理,而是会一直傻傻的在那里“转圈圈”的等待锁可用。比如现在有个公用电话亭,一次肯定只能进去一个人打电话,现在电话亭里面有人正在打电话,相当于获得了自旋锁。此时你到了电话亭门口,因为里面有人,所以你不能进去打电话,相当于没有获取自旋锁,这个时候你肯定是站在原地等待,你可能因为无聊的等待而转圈圈消遣时光,反正就是哪里也不能去,要一直等到里面的人打完电话出来。终于,里面的人打完电话出来了,相当于释放了自旋锁,这个时候你就可以使用电话亭打电话了,相当于获取到了自旋锁。
% o* |; R- X$ u自旋锁的“自旋”也就是“原地打转”的意思,“原地打转”的目的是为了等待自旋锁可以用,可以访问共享资源。把自旋锁比作一个变量a,变量a=1的时候表示共享资源可用,当a=0的时候表示共享资源不可用。现在线程A要访问共享资源,发现a=0(自旋锁被其他线程持有),那么线程A就会不断的查询a的值,直到a=1。从这里我们可以看到自旋锁的一个缺点:那就等待自旋锁的线程会一直处于自旋状态,这样会浪费处理器时间,降低系统性能,所以自旋锁的持有时间不能太长。自旋锁适用于短时期的轻量级加锁,如果遇到需要长时间持有锁的场景那就需要换其他的方法了,这个我们后面会讲解。5 {  {5 K# X. `- b4 K
Linux内核使用结构体spinlock_t表示自旋锁,结构体定义如下所示:" Y6 b- @) G% y
# X3 c2 j8 b0 P' o9 ^7 N
  1. 示例代码27.3.1.1 spinlock_t结构体
    . [; ?/ s+ S) U( S& Q; ?" Z% b# _
  2. 61 typedef struct spinlock {* T7 ~+ ^$ f! u" L% F
  3. 62          union {
    ( ~( |9 w7 y, G  ~: P
  4. 63                      struct raw_spinlock rlock;
    ' D2 A6 G- F+ k
  5. 64
      K$ x3 x7 B, W0 N7 C) _
  6. 65 #ifdef CONFIG_DEBUG_LOCK_ALLOC
    5 q6 ?& s3 }6 K/ L% T3 a' c8 t; {* H6 F
  7. 66 # define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
    & u! c/ P. O7 X2 [
  8. 67              struct {9 w2 }" v8 w. ]/ m1 U
  9. 68                          u8 __padding[LOCK_PADSIZE];
    0 V- b5 a) h3 p2 K5 l3 ~
  10. 69                          struct lockdep_map dep_map;# {' ~' Y" b) O
  11. 70              };1 ~8 T5 ]# [$ \1 `$ r1 u; F% Q
  12. 71 #endif
    $ G$ ~& L, y' P. M. j, X1 s
  13. 72          };' c  O0 K, o3 [. o; t/ |
  14. 73 } spinlock_t;
复制代码
* Q( x& F& O- K- }, E
在使用自旋锁之前,肯定要先定义一个自旋锁变量,定义方法如下所示:
1 E3 r1 k0 S/ A( h: d6 v, X5 X" K
) f: x9 t* I' [# ~$ l) hspinlock_t lock; //定义自旋锁2 f- `1 O! u9 Y: Q
定义好自旋锁变量以后就可以使用相应的API函数来操作自旋锁。* P% g) n' q4 O( l2 t& u4 ^
27.3.2 自旋锁API函数
. Z8 l. j+ s9 I' Z) h6 N6 d最基本的自旋锁API函数如表27.3.2.1所示:1 f; [8 L* F9 L4 W
函数 描述
0 p* e! R, `8 h# m0 d5 wDEFINE_SPINLOCK(spinlock_t lock) 定义并初始化一个自选变量。8 f! t' X% _# r! {
int spin_lock_init(spinlock_t *lock) 初始化自旋锁。
" Y5 }& Q# M! g: W; Q, t0 Qvoid spin_lock(spinlock_t *lock) 获取指定的自旋锁,也叫做加锁。" {/ }( x1 N$ V: |: U5 V# ~3 u- u, R
void spin_unlock(spinlock_t *lock) 释放指定的自旋锁。
4 {1 E3 X1 S& dint spin_trylock(spinlock_t *lock) 尝试获取指定的自旋锁,如果没有获取到就返回02 ^: l& t$ {, k4 l/ T) i4 @
int spin_is_locked(spinlock_t *lock) 检查指定的自旋锁是否被获取,如果没有被获取就返回非0,否则返回0。$ s3 I- t7 Y; P$ p# O# m
表27.3.2.1自旋锁基本API函数表0 E- s$ k2 i6 ]+ j% I0 x  u
表27.3.2.1中的自旋锁API函数适用于SMP或支持抢占的单CPU下线程之间的并发访问,也就是用于线程与线程之间,被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API函数,否则的话会可能会导致死锁现象的发生。自旋锁会自动禁止抢占,也就说当线程A得到锁以后会暂时禁止内核抢占。如果线程A在持有锁期间进入了休眠状态,那么线程A会自动放弃CPU使用权。线程B开始运行,线程B也想要获取锁,但是此时锁被A线程持有,而且内核抢占还被禁止了!线程B无法被调度出去,那么线程A就无法运行,锁也就无法释放,好了,死锁发生了!
) D$ T; q4 C2 ^  }9 }# _$ |1 X: u表27.3.2.1中的API函数用于线程之间的并发访问,如果此时中断也要插一脚,中断也想访问共享资源,那该怎么办呢?首先可以肯定的是,中断里面可以使用自旋锁,但是在中断里面使用自旋锁的时候,在获取锁之前一定要先禁止本地中断(也就是本CPU中断,对于多核SOC来说会有多个CPU核),否则可能导致锁死现象的发生,如图27.3.2.1所示:$ U# v0 c/ G7 h. W; D$ P

) I2 q& n- f; u* q+ V 4f1f47f298ac4b48a2f007aeafa4edb8.png
9 S  |# A. D9 \7 u8 j: c, Q+ M) c( U& ~# d3 M! n; w
图27.3.2.1 中断打断线程
9 t  V& g* u  L% I: i7 s, b在图27.3.2.1中,线程A先运行,并且获取到了lock这个锁,当线程A运行functionA函数的时候中断发生了,中断抢走了CPU使用权。右边的中断服务函数也要获取lock这个锁,但是这个锁被线程A占有着,中断就会一直自旋,等待锁有效。但是在中断服务函数执行完之前,线程A是不可能执行的,线程A说“你先放手”,中断说“你先放手”,场面就这么僵持着,死锁发生!+ V$ Q. \8 Z9 y& z8 |: x
最好的解决方法就是获取锁之前关闭本地中断,Linux内核提供了相应的API函数,如表27.3.2.2所示:4 c/ M+ M4 b8 A9 R( F- G4 \; F
函数 描述0 Y9 A5 {; x+ u
void spin_lock_irq(spinlock_t *lock) 禁止本地中断,并获取自旋锁。  V' ]2 n8 G( N3 g/ e. x8 a4 e
void spin_unlock_irq(spinlock_t *lock) 激活本地中断,并释放自旋锁。" N, G  u2 U3 E0 R6 l# b7 @! H  u
void spin_lock_irqsave(spinlock_t *lock, unsigned long flags) 保存中断状态,禁止本地中断,并获取自旋锁。
3 o8 l4 A+ ]3 Z# tvoid spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags) 将中断状态恢复到以前的状态,并且激活本地中断,释放自旋锁。
* t. e0 s& E, p3 N  K表27.3.2.2 线程与中断并发访问处理API函数
3 P& W% c& }4 N使用spin_lock_irq/spin_unlock_irq的时候需要用户能够确定加锁之前的中断状态,但实际上内核很庞大,运行也是“千变万化”,我们是很难确定某个时刻的中断状态,因此不推荐使用spin_lock_irq/spin_unlock_irq。建议使用spin_lock_irqsave/ spin_unlock_irqrestore,因为这一组函数会保存中断状态,在释放锁的时候会恢复中断状态。一般在线程中使用spin_lock_irqsave/ spin_unlock_irqrestore,在中断中使用spin_lock/spin_unlock,示例代码如下所示:
1 M  S6 C( D9 G4 M. \
: d$ `6 Q, C$ B, k3 a6 e! D
  1. 示例代码27.3.2.1 自旋锁使用示例
    & B/ t) x7 t$ p3 H
  2. 1  DEFINE_SPINLOCK(lock)                                                 /* 定义并初始化一个锁         */
    ; d) p0 K$ B+ G7 L- k: A: L+ s3 H: S
  3. 2  : N) @, @# r0 {' E
  4. 3  /* 线程A */2 l: X) C1 n1 h4 m! f
  5. 4  void functionA (){8 P. c# [& p- q- F
  6. 5           unsigned long flags;                                            /* 中断状态                                 */
    ( J- P1 W' Q8 E1 g
  7. 6           spin_lock_irqsave(&lock, flags)                 /* 获取锁                                 */) V! l( j( `, i+ f$ E
  8. 7           /* 临界区 */
    : o1 e0 K9 C4 E6 h$ ~
  9. 8           spin_unlock_irqrestore(&lock, flags)        /* 释放锁                                 */
    ( P. \; \2 e4 [/ b) b3 j
  10. 9  }1 X2 X1 p3 R5 u" P9 z
  11. 10
    ; ~, G0 F& G' J& |
  12. 11 /* 中断服务函数 */, a8 y+ j; e: r  [* S$ [
  13. 12 void irq() {5 J! O/ M1 i) x/ q0 @
  14. 13          spin_lock(&lock)                                                    /* 获取锁                                 */
    0 y$ G0 c/ l  A6 g
  15. 14          /* 临界区 */
    : W, u# O. M- t* n9 g
  16. 15          spin_unlock(&lock)                                                 /* 释放锁                                 */  |4 _- I- b  p* Y: N5 I
  17. 16 }
复制代码

- P) v$ y& Y% q3 q: W) S下半部(BH)也会竞争共享资源,有些资料也会将下半部叫做底半部。关于下半部后面的章节会讲解,如果要在下半部里面使用自旋锁,可以使用表27.3.2.3中的API函数:
( F# E; a4 G" [3 `7 h" s# i
; ^/ \# E* \+ x4 C0 J( u6 I 1d1f23bfdbb842fabf000c0a3bd95063.png
9 W) P9 ?& f9 ?4 `/ Q
5 _. V2 B$ T  m% g, P" r0 l+ N表27.3.2.3 下半部竞争处理函数% E3 r3 p+ ^) X- {/ W& D: y
27.3.3 其他类型的锁* a$ G. g' y' R9 w9 W- l
在自旋锁的基础上还衍生出了其他特定场合使用的锁,这些锁在驱动中其实用的不多,更多的是在Linux内核中使用,本节我们简单来了解一下这些衍生出来的锁。$ F1 G9 y) G6 n! P' y9 j% D
1、读写自旋锁
1 b, K5 i8 ]1 a4 \. ]1 ?现在有个学生信息表,此表存放着学生的年龄、家庭住址、班级等信息,此表可以随时被修改和读取。此表肯定是数据,那么必须要对其进行保护,如果我们现在使用自旋锁对其进行保护。每次只能一个读操作或者写操作,但是,实际上此表是可以并发读取的。只需要保证在修改此表的时候没人读取,或者在其他人读取此表的时候没有人修改此表就行了。也就是此表的读和写不能同时进行,但是可以多人并发的读取此表。像这样,当某个数据结构符合读/写或生产者/消费者模型的时候就可以使用读写自旋锁。- f/ Q" d2 L8 m2 H! G4 f, l
读写自旋锁为读和写操作提供了不同的锁,一次只能允许一个写操作,也就是只能一个线程持有写锁,而且不能进行读操作。但是当没有写操作的时候允许一个或多个线程持有读锁,可以进行并发的读操作。Linux内核使用rwlock_t结构体表示读写锁,结构体定义如下(删除了条件编译):) c  [3 X, M8 G5 T! D$ F) B% u1 _
  h8 Q/ e# E! p7 Y/ {7 c
  1. 示例代码27.3.3.1 rwlock_t结构体
    7 W% y% Y* d1 n' ~) F8 M- j
  2. typedef struct {& y9 Z$ }2 `" {; L8 Q' @
  3.     arch_rwlock_t raw_lock;$ b" {" U7 Y' _0 o
  4. } rwlock_t;
复制代码
  v1 y, L1 s  b4 N. O9 M- w3 G; a
读写锁操作API函数分为两部分,一个是给读使用的,一个是给写使用的,这些API函数如表27.3.3.1所示:
: }! j- |$ v. G3 Y3 v
. U) j* G9 A7 ?9 F( a7 D9 F 01263145e6534f9c9762fc068bba9a45.png
+ q% r& X2 X- f5 d( L' a/ z0 K% m5 F0 ^1 L6 B, h4 y
表27.3.3.1 读写锁API函数
' ]( [6 Q" }% E1 y, I) ~2 ~3 F2、顺序锁
0 l/ k/ l" Y8 a; S" C顺序锁在读写锁的基础上衍生而来的,使用读写锁的时候读操作和写操作不能同时进行。使用顺序锁的话可以允许在写的时候进行读操作,也就是实现同时读写,但是不允许同时进行并发的写操作。虽然顺序锁的读和写操作可以同时进行,但是如果在读的过程中发生了写操作,最好重新进行读取,保证数据完整性。顺序锁保护的资源不能是指针,因为如果在写操作的时候可能会导致指针无效,而这个时候恰巧有读操作访问指针的话就可能导致意外发生,比如读取野指针导致系统崩溃。Linux内核使用seqlock_t结构体表示顺序锁,结构体定义如下:) K6 s% f$ s8 i: U& d
0 Z- U3 B) R  }+ i' Q/ u: l
  1. 示例代码27.3.3.2 seqlock_t结构体% N& i4 H0 Z& U! J% N
  2. 404 typedef struct {2 o; D$ N: {* M1 M% x, s
  3. 405    struct seqcount seqcount;
    # y# I  |7 S; H" Q
  4. 406    spinlock_t lock;
    . y8 p+ E8 H4 U/ \
  5. 407 } seqlock_t;
复制代码
6 _$ M, N3 d' c, F
关于顺序锁的API函数如表27.3.3.2所示:/ i' v8 }! d( u; D

6 t: w: W8 x& H* t" _, i6 M函数 描述
% q5 h6 D# u9 h  E/ C0 tDEFINE_SEQLOCK(seqlock_t sl) 定义并初始化顺序锁
5 P% M0 S: @- i2 o$ Gvoid seqlock_ini seqlock_t *sl) 初始化顺序锁。6 K2 z# u" j8 a0 W
顺序锁写操作
0 y6 c$ Y0 \8 U/ ^) C# _/ Wvoid write_seqlock(seqlock_t *sl) 获取写顺序锁。8 d0 S& o. z& ?. X4 [- \# b3 _8 S
void write_sequnlock(seqlock_t *sl) 释放写顺序锁。0 d, x/ U7 Z) ]! N9 o* {7 n  Z# v% T
void write_seqlock_irq(seqlock_t *sl) 禁止本地中断,并且获取写顺序锁
3 q+ U( T# C; }void write_sequnlock_irq(seqlock_t *sl) 打开本地中断,并且释放写顺序锁。
+ ?) Z5 M4 a6 Xvoid write_seqlock_irqsave(seqlock_t *sl,
3 }2 z6 L0 j& _& runsigned long flags) 保存中断状态,禁止本地中断,并获取写顺序锁。
" k8 h* V" m) Z# k/ Lvoid write_sequnlock_irqrestore(seqlock_t *sl,7 {2 i! W+ }- |
unsigned long flags) 将中断状态恢复到以前的状态,并且激活本地中断,释放写顺序锁。
& o" C# o$ l0 r2 Lvoid write_seqlock_bh(seqlock_t *sl) 关闭下半部,并获取写读锁。
/ Q# x9 K8 ~" E& rvoid write_sequnlock_bh(seqlock_t *sl) 打开下半部,并释放写读锁。
/ k' X7 `8 l5 x- A, G顺序锁读操作
6 v7 w- B7 d' \( ?unsigned read_seqbegin(const seqlock_t *sl) 读单元访问共享资源的时候调用此函数,此函数会返回顺序锁的顺序号。. y% H: L2 Q( i* @
unsigned read_seqretry(const seqlock_t *sl,) S# U4 d) \; q7 V. V  r& ?5 \7 L
unsigned start) 读结束以后调用此函数检查在读的过程中有没有对资源进行写操作,如果有的话就要重读4 l# [; ]$ H: i3 C; B+ d5 B
表27.3.3.2 顺序锁API函数表, L" G& a1 c; R: z+ `# Y; z
27.3.4 自旋锁使用注意事项
1 W/ x6 E& F! Q' W+ a综合前面关于自旋锁的信息,我们需要在使用自旋锁的时候要注意一下几点:
2 [3 m( q5 M+ u, e, r①、因为在等待自旋锁的时候处于“自旋”状态,因此锁的持有时间不能太长,一定要短,否则的话会降低系统性能。如果临界区比较大,运行时间比较长的话要选择其他的并发处理方式,比如稍后要讲的信号量和互斥体。3 u, c8 W8 ^$ O- Z; z7 z: ^$ g. k
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的API函数,否则的话可能导致死锁。9 @. s; T( t. C3 }; R
③、不能递归申请自旋锁,因为一旦通过递归的方式申请一个你正在持有的锁,那么你就必须“自旋”,等待锁被释放,然而你正处于“自旋”状态,根本没法释放锁。结果就是自己把自己锁死了!+ E- A* q- K: @* e3 n; M
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性,因此不管你用的是单核的还是多核的SOC,都将其当做多核SOC来编写驱动程序。8 n7 D: c9 ?- L  K& j5 Q
& F3 ?% M. p% N: n; p; O
27.4 信号量
! i& j, a; H* M5 N: e- O9 H" v5 k6 Q27.4.1 信号量简介# U" I8 P/ J4 H" n  j! }" y% f7 p
大家如果有学习过FreeRTOS或者UCOS的话就应该对信号量很熟悉,因为信号量是同步的一种方式。Linux内核也提供了信号量机制,信号量常常用于控制对共享资源的访问。举一个很常见的例子,某个停车场有100个停车位,这100个停车位大家都可以用,对于大家来说这100个停车位就是共享资源。假设现在这个停车场正常运行,你要把车停到这个这个停车场肯定要先看一下现在停了多少车了?还有没有停车位?当前停车数量就是一个信号量,具体的停车数量就是这个信号量值,当这个值到100的时候说明停车场满了。停车场满的时你可以等一会看看有没有其他的车开出停车场,当有车开出停车场的时候停车数量就会减一,也就是说信号量减一,此时你就可以把车停进去了,你把车停进去以后停车数量就会加一,也就是信号量加一。这就是一个典型的使用信号量进行共享资源管理的案例,在这个案例中使用的就是计数型信号量。
9 O" V9 O+ n: x. @相比于自旋锁,信号量可以使线程进入休眠状态,比如A与B、C合租了一套房子,这个房子只有一个厕所,一次只能一个人使用。某一天早上A去上厕所了,过了一会B也想用厕所,因为A在厕所里面,所以B只能等到A用来了才能进去。B要么就一直在厕所门口等着,等A出来,这个时候就相当于自旋锁。B也可以告诉A,让A出来以后通知他一下,然后B继续回房间睡觉,这个时候相当于信号量。可以看出,使用信号量会提高处理器的使用效率,毕竟不用一直傻乎乎的在那里“自旋”等待。但是,信号量的开销要比自旋锁大,因为信号量使线程进入休眠状态以后会切换线程,切换线程就会有开销。总结一下信号量的特点:* J! K9 U1 Q! ?; z* N
①、因为信号量可以使等待资源线程进入休眠状态,因此适用于那些占用资源比较久的场合。8 L3 q5 i+ D+ `' s. w' T8 K" n: s/ p
②、因此信号量不能用于中断中,因为信号量会引起休眠,中断不能休眠。: {) S' E$ d2 B  ^. O% W, [4 g
③、如果共享资源的持有时间比较短,那就不适合使用信号量了,因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。3 m2 G$ s) t! m! G$ Z
信号量有一个信号量值,相当于一个房子有10把钥匙,这10把钥匙就相当于信号量值为10。因此,可以通过信号量来控制访问共享资源的访问数量,如果要想进房间,那就要先获取一把钥匙,信号量值减1,直到10把钥匙都被拿走,信号量值为0,这个时候就不允许任何人进入房间了,因为没钥匙了。如果有人从房间出来,那他要归还他所持有的那把钥匙,信号量值加1,此时有1把钥匙了,那么可以允许进去一个人。相当于通过信号量控制访问资源的线程数,在初始化的时候将信号量值设置的大于1,那么这个信号量就是计数型信号量,计数型信号量不能用于互斥访问,因为它允许多个线程同时访问共享资源。如果要互斥的访问共享资源那么信号量的值就不能大于1,此时的信号量就是一个二值信号量。4 L( D, k0 o2 y/ q! x: e! k
27.4.2 信号量API函数+ G  g* t9 v  M  X4 F
Linux内核使用semaphore结构体表示信号量,结构体内容如下所示:
3 T1 n7 F. m; d+ E2 o  x; _  H
7 \, d: H1 b! W9 q! m( f& @9 y6 U
  1. 示例代码27.4.2.1 semaphore结构体+ E4 C* t# I3 U4 O7 S% q9 s% B% q3 K0 ^- c
  2. 15 struct semaphore {" l; x% A0 T8 }% i9 V
  3. 16    raw_spinlock_t      lock;& K6 Y  l% s. }$ R
  4. 17    unsigned int        count;
    ; |- k& u1 M+ b5 M& N3 p, `. \
  5. 18    struct list_head    wait_list;
    # D8 S& p" b4 a2 R- n& A. e5 m
  6. 19 };
复制代码

# f5 b4 X" O8 I+ l要想使用信号量就得先定义,然后初始化信号量。有关信号量的API函数如表27.4.2.1所示:
7 ]2 T+ c4 p. `! _1 O
1 g) h( p8 y, @- Q1 U函数 描述, Q: z: v& F1 ?$ O3 a
DEFINE_SEAMPHORE(name) 定义一个信号量,并且设置信号量的值为1。
8 _) u& _# h+ ^2 m$ b# r# xvoid sema_init(struct semaphore *sem, int val) 初始化信号量sem,设置信号量值为val。
% a0 M$ Y7 v, v8 ?/ q" \void down(struct semaphore *sem) 获取信号量,因为会导致休眠,因此不能在中断中使用。
4 J  o+ J' G5 ~int down_trylock(struct semaphore *sem); 尝试获取信号量,如果能获取到信号量就获取,并且返回0。如果不能就返回非0,并且不会进入休眠。  K8 Z8 v8 r7 E% ^4 M' e! V
int down_interruptible(struct semaphore *sem) 获取信号量,和down类似,只是使用down进入休眠状态的线程不能被信号打断。而使用此函数进入休眠以后是可以被信号打断的。
# |6 R; N8 z0 ?* w+ s# N6 Ivoid up(struct semaphore *sem) 释放信号量/ r1 h- E# c/ p3 w  z% d% J0 G
表27.4.2.1 信号量API函数# e1 W; {: r  L2 X
信号量的使用如下所示:
$ E8 \6 k- r' ]; q+ K
, ^7 I* {( N) {5 H- W& C  @& {
  1. 示例代码27.4.2.2 信号量使用示例
      i/ U& g& y* a! E0 E5 Q
  2. struct semaphore sem;           /* 定义信号量         */& M7 L5 h( w& j

  3. / k( O% `1 w. k* |% c
  4. sema_init(&sem, 1);           /* 初始化信号量 *// Y' I' n  f$ b2 A3 i$ M
  5. : e2 _4 w0 x$ c$ T2 w3 ?
  6. down(&sem);                                 /* 申请信号量         */
    5 V6 J9 C, q$ s3 \
  7. /* 临界区 */3 u: z3 e+ z# K5 w
  8. up(&sem);                                   /* 释放信号量         */
复制代码

3 R- N3 C% u" l' O7 [* A- d27.5 互斥体' R. y6 E2 r2 B* D' {
27.5.1 互斥体简介
/ j4 F4 C% l4 q. x在FreeRTOS和UCOS中也有互斥体,将信号量的值设置为1就可以使用信号量进行互斥访问了,虽然可以通过信号量实现互斥,但是Linux提供了一个比信号量更专业的机制来进行互斥,它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源,不能递归申请互斥体。在我们编写Linux驱动的时候遇到需要互斥访问的地方建议使用mutex。Linux内核使用mutex结构体表示互斥体,定义如下(省略条件编译部分):8 F- @/ M3 J$ v. E. _+ W

0 Q7 Q' y0 i6 d9 b& Y) i- ]
  1. 示例代码27.5.1.1 mutex结构体
    + L/ x/ J! g/ G; W; R/ V9 U
  2. struct mutex {3 H/ G: y1 E" ]
  3.     atomic_long_t             owner;
    3 r, ?4 u9 C4 h) [: m0 b
  4.     spinlock_t              wait_lock;
      K; Z0 F8 A: r' {1 w* H
  5. };
复制代码
7 z/ _# B5 X& O* y" x
在使用mutex之前要先定义一个mutex变量。在使用mutex的时候要注意如下几点:
$ u+ u6 M7 d. U! Q①、mutex可以导致休眠,因此不能在中断中使用mutex,中断中只能使用自旋锁。$ N; n% W5 [2 r- s5 c
②、和信号量一样,mutex保护的临界区可以调用引起阻塞的API函数。
$ @4 e, x1 `: u$ }③、因为一次只有一个线程可以持有mutex,因此,必须由mutex的持有者释放mutex。并且mutex不能递归上锁和解锁。% t$ W) u/ ?( C9 C7 I6 y+ Q% l
27.5.2 互斥体API函数
! m  `/ E" P) C0 P# m4 u有关互斥体的API函数如表27.5.2.1所示:
' W: [; L! d8 l0 l# m, P函数 描述
  D& Q  H8 A( N* N/ q! a- d; tDEFINE_MUTEX(name) 定义并初始化一个mutex变量。
, M6 |6 x, w$ P! \4 M6 w8 lvoid mutex_init(mutex *lock) 初始化mutex。  \/ z1 j5 H3 R4 N) X6 O
void mutex_lock(struct mutex *lock) 获取mutex,也就是给mutex上锁。如果获取不到就进休眠。
$ p7 h# T; G1 ]: J: F# T3 jvoid mutex_unlock(struct mutex *lock) 释放mutex,也就给mutex解锁。
6 ]' m# u2 [5 W0 p+ f+ f1 fint mutex_trylock(struct mutex *lock) 尝试获取mutex,如果成功就返回1,如果失败就返回0。# p3 n% o$ d# ~; x( a
int mutex_is_locked(struct mutex *lock) 判断mutex是否被获取,如果是的话就返回1,否则返回0。+ s" K! a  X5 Q) y: K# H* v
int mutex_lock_interruptible(struct mutex *lock) 使用此函数获取信号量失败进入休眠以后可以被信号打断。9 @$ A% u* q7 C" W: J
表27.5.2.1 互斥体API函数& p/ {5 N3 |, T
互斥体的使用如下所示:& P7 u8 B( T) i
! w8 ?( r  V/ |) O2 n% Q9 h
  1. 示例代码27.5.2.1 互斥体使用示例5 C' l3 v; Z  x- \  r! _, ~% `
  2. 1 struct mutex lock;            /* 定义一个互斥体         */2 L- H8 K0 N' v1 z7 Q
  3. 2 mutex_init(&lock);            /* 初始化互斥体                 */8 X# _0 W- M8 N4 q. Q) d
  4. 3 6 d3 z) H2 D: T! [% l
  5. 4 mutex_lock(&lock);            /* 上锁                         */( @! C: @8 q* L9 `) R
  6. 5 /* 临界区 */; }. ~5 |) n. h2 t
  7. 6 mutex_unlock(&lock);   /* 解锁                         */
复制代码
/ U! N/ J2 A2 n" c  z& P% D
关于Linux中的并发和竞争就讲解到这里,Linux内核还有很多其他的处理并发和竞争的机制,本章我们主要  k* n/ v  u' Q# z0 r& F9 {
————————————————4 L9 F9 H2 O  G+ g/ w) V8 \
版权声明:正点原子
1 |* C: o, @7 P9 s/ @9 d
  w3 R- }/ {' i( [' U* {3 f  f* H9 z8 c4 i: W: }
赞 收藏 评论0 发布时间:2022-9-26 21:12

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版