Linux 并发与竞争

Linux是一个多任务操作系统，肯定会存在多个任务共同操作同一段内存或者设备的情况，多个任务甚至中断都能访问的资源叫做共享资源，就和共享单车一样。

在驱动开发中要注意对共享资源的保护，也就是要处理对共享资源的并发访问。比如共享单车，大家按照谁扫谁骑走的原则来共用这个单车，如果没有这个并发访问共享单车的原则存在，只怕到时候为了一辆单车要打起来了。在 Linux 驱动编写过程中对于并发控制的管理非常重要，本章我们就来学习一下如何在 Linux 驱动中处理并发。

1|并发与竞争

1、并发与竞争简介

并发就是多个“用户”同时访问同一个共享资源，比如你们公司有一台打印机，你们公司的所有人都可以使用。现在小李和小王要同时使用这一台打印机，都要打印一份文件。

这两份文档肯定是各自打印出来的，不能相互影响。当两个人同时打印的话如果打印机不做处理的话可能会出现小李的文档打印了一行，然后开始打印小王的文档，这样打印出来的文档就错乱了。

这是绝对不允许的。如果有多人同时向打印机发送了多份文档，打印机必须保证一次只能打印一份文档，只有打印完成以后才能打印其他的文档。

Linux 系统是个多任务操作系统，会存在多个任务同时访问同一片内存区域，这些任务可能会相互覆盖这段内存中的数据，造成内存数据混乱。针对这个问题必须要做处理，严重的话可能会导致系统崩溃。现在的 Linux 系统并发产生的原因很复杂，总结一下有下面几个主要原因：

①、多线程并发访问，Linux 是多任务(线程)的系统，所以多线程访问是最基本的原因。
②、抢占式并发访问，从 2.6 版本内核开始，Linux 内核支持抢占，也就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程。
③、中断程序并发访问，这个无需多说，学过 STM32 的同学应该知道，硬件中断的权利可是很大的。
④、SMP(多核)核间并发访问，现在 ARM 架构的多核 SOC 很常见，多核 CPU 存在核间并发访问。

并发访问带来的问题就是竞争，学过FreeRTOS和UCOS的同学应该知道临界区这个概念，所谓的临界区就是共享数据段，对于临界区必须保证一次只有一个线程访问，也就是要保证临界区是原子访问的，注意这里的“原子”不是正点原子的“原子”。我们都知道，原子是化学反应不可再分的基本微粒，这里的原子访问就表示这一个访问是一个步骤，不能再进行拆分。如果多个线程同时操作临界区就表示存在竞争，我们在编写驱动的时候一定要注意避免并发和防止竞争访问。很多 Linux 驱动初学者往往不注意这一点，在驱动程序中埋下了隐患，这类问题往往又很不容易查找，导致驱动调试难度加大、费时费力。所以我们一般在编写驱动的时候就要考虑到并发与竞争，而不是驱动都编写完了然后再处理并发与竞争。

2、保护内容是什么

前面一直说要防止并发访问共享资源，换句话说就是要保护共享资源，防止进行并发访问。那么问题来了，什么是共享资源？现实生活中的公共电话、共享单车这些是共享资源，我们都很容易理解，那么在程序中什么是共享资源？也就是保护的内容是什么？我们保护的不是代码，而是数据！某个线程的局部变量不需要保护，我们要保护的是多个线程都会访问的共享数据。一个整形的全局变量 a 是数据，一份要打印的文档也是数据，虽然我们知道了要对共享数据进行保护，那么怎么判断哪些共享数据要保护呢？找到要保护的数据才是重点，而这个也是难点，因为驱动程序各不相同，那么数据也千变万化，一般像全局变量，设备结构体这些肯定是要保护的，至于其他的数据就要根据实际的驱动程序而定了。

当我们发现驱动程序中存在并发和竞争的时候一定要处理掉，接下来我们依次来学习一下Linux 内核提供的几种并发和竞争的处理方法。

2|原子操作

1、原子操作简介

首先看一下原子操作，原子操作就是指不能再进一步分割的操作，一般原子操作用于变量或者位操作。假如现在要对无符号整形变量 a 赋值，值为 3，对于 C 语言来讲很简单，直接就是：

a = 3;

但是 C 语言要先编译为成汇编指令，ARM 架构不支持直接对寄存器进行读写操作，比如要借助寄存器 R0、R1 等来完成赋值操作。假设变量 a 的地址为 0X3000000，“a=3”这一行 C语言可能会被编译为如下所示的汇编代码：

1 ldr r0, =0X30000000 /* 变量 a 地址 */
2 ldr r1, = 3 /* 要写入的值 */
3 str r1, [r0] /* 将 3 写入到 a 变量中 */

示例代码只是一个简单的举例说明，实际的结果要比示例代码复杂的多。从上述代码可以看出，C 语言里面简简单单的一句“a=3”，编译成汇编文件以后变成了 3 句，那么程序在执行的时候肯定是按照示例代码中的汇编语句一条一条的执行。假设现在线程 A要向 a 变量写入 10 这个值，而线程 B 也要向 a 变量写入 20 这个值，我们理想中的执行顺序如图所示：

按照图所示的流程，确实可以实现线程 A 将 a 变量设置为 10，线程 B 将 a 变量设置为 20。但是实际上的执行流程可能如下图所示：

按照图所示的流程，线程 A 最终将变量 a 设置为了 20，而并不是要求的 10！线程B 没有问题。这就是一个最简单的设置变量值的并发与竞争的例子，要解决这个问题就要保证示例代码中的三行汇编指令作为一个整体运行，也就是作为一个原子存在。

Linux 内核提供了两组原子操作 API 函数，一组是对整形变量进行操作的，一组是对位进行操作的，我们接下来看一下这些 API 函数。

2、原子整形操作API函数

Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量，此结构体定义在 include/linux/types.h 文件中，定义如下：

175 typedef struct {
176 	int counter;
177 } atomic_t;

如果要使用原子操作 API 函数，首先要先定义一个 atomic_t 的变量，如下所示：

atomic_t a; //定义 a

也可以在定义原子变量的时候给原子变量赋初值，如下所示：

atomic_t b = ATOMIC_INIT(0); //定义原子变量 b 并赋初值为 0

可以通过宏 ATOMIC_INIT 向原子变量赋初值。

原子变量有了，接下来就是对原子变量进行操作，比如读、写、增加、减少等等，Linux 内核提供了大量的原子操作 API 函数，如表所示：

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

如果使用 64 位的 SOC 的话，就要用到 64 位的原子变量，Linux 内核也定义了 64 位原子结构体，如下所示

typedef struct {
	long long counter;
} atomic64_t;

相应的也提供了 64 位原子变量的操作 API 函数，这里我们就不详细讲解了，和表中的 API 函数用法一样，只是将“atomic_”前缀换为“atomic64_”，将 int 换为 long long。如果使用的是 64 位的 SOC，那么就要使用 64 位的原子操作函数。Cortex-A7 是 32 位的架构，所以本文档只使用表 47.2.2.1 中的 32 位原子操作函数。原子变量和相应的 API 函数使用起来很简单，参考如下示例：

atomic_t v = ATOMIC_INIT(0); /* 定义并初始化原子变零 v=0 */
atomic_set(10); 		/* 设置 v=10 */
atomic_read(&v); 		/* 读取 v 的值，肯定是 10 */
atomic_inc(&v); 		/* v 的值加 1，v=11 */

3、原子位操作 API 函数

位操作也是很常用的操作，Linux 内核也提供了一系列的原子位操作 API 函数，只不过原子位操作不像原子整形变量那样有个 atomic_t 的数据结构，原子位操作是直接对内存进行操作，API 函数如表所示：

函数	描述
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 位原来的值。

3|自旋锁

1、自旋锁简介

原子操作只能对整形变量或者位进行保护，但是，在实际的使用环境中怎么可能只有整形变量或位这么简单的临界区。举个最简单的例子，设备结构体变量就不是整型变量，我们对于结构体中成员变量的操作也要保证原子性，在线程 A 对结构体变量使用期间，应该禁止其他的线程来访问此结构体变量，这些工作原子操作都不能胜任，需要本节要讲的锁机制，在 Linux内核中就是自旋锁。

当一个线程要访问某个共享资源的时候首先要先获取相应的锁，锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程 A 持有，线程 B 想要获取自旋锁，那么线程 B 就会处于忙循环-旋转-等待状态，线程 B 不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里“转圈圈”的等待锁可用。比如现在有个公用电话亭，一次肯定只能进去一个人打电话，现在电话亭里面有人正在打电话，相当于获得了自旋锁。此时你到了电话亭门口，因为里面有人，所以你不能进去打电话，相当于没有获取自旋锁，这个时候你肯定是站在原地等待，你可能因为无聊的等待而转圈圈消遣时光，反正就是哪里也不能去，要一直等到里面的人打完电话出来。终于，里面的人打完电话出来了，相当于释放了自旋锁，这个时候你就可以使用电话亭打电话了，相当于获取到了自旋锁。

自旋锁的“自旋”也就是“原地打转”的意思，“原地打转”的目的是为了等待自旋锁可以用，可以访问共享资源。把自旋锁比作一个变量 a，变量 a=1 的时候表示共享资源可用，当 a=0的时候表示共享资源不可用。现在线程 A 要访问共享资源，发现 a=0(自旋锁被其他线程持有)，那么线程 A 就会不断的查询 a 的值，直到 a=1。从这里我们可以看到自旋锁的一个缺点：那就是等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。所以自旋锁适用于短时期的轻量级加锁，如果遇到需要长时间持有锁的场景那就需要换其他的方法了，这个我们后面会讲解。

Linux 内核使用结构体 spinlock_t 表示自旋锁，结构体定义如下所示：

64 typedef struct spinlock {
65 		union {
66 			struct raw_spinlock rlock;
67
68 #ifdef CONFIG_DEBUG_LOCK_ALLOC
69 # define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
70 			struct {
71 				u8 __padding[LOCK_PADSIZE];
72 				struct lockdep_map dep_map;
73 			};
74 #endif
75 		};
76 } spinlock_t;

在使用自旋锁之前，肯定要先定义一个自旋锁变量，定义方法如下所示：

spinlock_t lock; //定义自旋锁

定义好自旋锁变量以后就可以使用相应的 API 函数来操作自旋锁。

2、自旋锁 API 函数

最基本的自旋锁 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。

(建议使用下面的 spin_lock_irqsave/ spin_unlock_irqrestore 函数来获取锁释放锁)

表中的自旋锁API函数适用于SMP或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。

自旋锁会自动禁止抢占，也就说当线程 A得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放，好了，死锁发生了！

表中的 API 函数用于线程之间的并发访问，如果此时中断也要插一脚，中断也想访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC来说会有多个 CPU 核)，否则可能导致锁死现象的发生，如图所示：

在图中，线程 A 先运行，并且获取到了 lock 这个锁，当线程 A 运行 functionA 函数的时候中断发生了，中断抢走了 CPU 使用权。右边的中断服务函数也要获取 lock 这个锁，但是这个锁被线程 A 占有着，中断就会一直自旋，等待锁有效。但是在中断服务函数执行完之前，线程 A 是不可能执行的，线程 A 说“你先放手”，中断说“你先放手”，场面就这么僵持着，死锁发生！

最好的解决方法就是获取锁之前关闭本地中断，Linux 内核提供了相应的 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)	将中断状态恢复到以前的状态，并且激活本地中断，释放自旋锁。

使用 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 DEFINE_SPINLOCK(lock) /* 定义并初始化一个锁 */
2
3 /* 线程 A */
4 void functionA (){
5 		unsigned long flags; /* 中断状态 */
6 		spin_lock_irqsave(&lock, flags) /* 获取锁 */
7 		/* 临界区 */
8 		spin_unlock_irqrestore(&lock, flags)  /* 释放锁 */
9 }
10
11 /* 中断服务函数 */
12 void irq() {
13 		spin_lock(&lock) /* 获取锁 */
14 		/* 临界区 */
15 		spin_unlock(&lock) /* 释放锁 */
16 }

下半部(BH) 也会竞争共享资源，有些资料也会将下半部叫做底半部。关于下半部后面的章节会讲解，如果要在下半部里面使用自旋锁，可以使用表中的 API 函数：

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

3、其他类型的锁

在自旋锁的基础上还衍生出了其他特定场合使用的锁，这些锁在驱动中其实用的不多，更多的是在 Linux 内核中使用，本节我们简单来了解一下这些衍生出来的锁。

读写自旋锁

现在有个学生信息表，此表存放着学生的年龄、家庭住址、班级等信息，此表可以随时被修改和读取。此表肯定是数据，那么必须要对其进行保护，如果我们现在使用自旋锁对其进行保护。每次只能一个读操作或者写操作，但是，实际上此表是可以并发读取的。只需要保证在修改此表的时候没人读取，或者在其他人读取此表的时候没有人修改此表就行了。也就是此表的读和写不能同时进行，但是可以多人并发的读取此表。

像这样，当某个数据结构符合读/写或生产者/消费者模型的时候就可以使用读写自旋锁。读写自旋锁为读和写操作提供了不同的锁，一次只能允许一个写操作，也就是只能一个线程持有写锁，而且不能进行读操作。但是当没有写操作的时候允许一个或多个线程持有读锁，可以进行并发的读操作。Linux 内核使用 rwlock_t 结构体表示读写锁，结构体定义如下(删除了条件编译)：

typedef struct {
	arch_rwlock_t raw_lock;
} rwlock_t;

读写锁操作 API 函数分为两部分，一个是给读使用的，一个是给写使用的，这些 API 函数如表所示：

顺序锁

顺序锁在读写锁的基础上衍生而来的，使用读写锁的时候读操作和写操作不能同时进行。使用顺序锁的话可以允许在写的时候进行读操作，也就是实现同时读写，但是不允许同时进行并发的写操作。虽然顺序锁的读和写操作可以同时进行，但是如果在读的过程中发生了写操作，最好重新进行读取，保证数据完整性。顺序锁保护的资源不能是指针，因为如果在写操作的时候可能会导致指针无效，而这个时候恰巧有读操作访问指针的话就可能导致意外发生，比如读取野指针导致系统崩溃。Linux 内核使用 seqlock_t 结构体表示顺序锁，结构体定义如下：

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

关于顺序锁的 API 函数如表 47.3.3.2 所示：

4、自旋锁使用注意事项

综合前面关于自旋锁的信息，我们需要在使用自旋锁的时候要注意一下几点：

①、因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如稍后要讲的信号量和互斥体。
②、自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。
③、不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己把自己锁死了！
④、在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。

4|信号量

1、信号量简介

大家如果有学习过 FreeRTOS 或者 UCOS 的话就应该对信号量很熟悉，因为信号量是同步的一种方式。Linux 内核也提供了信号量机制，信号量常常用于控制对共享资源的访问。

举一个很常见的例子，某个停车场有 100 个停车位，这 100 个停车位大家都可以用，对于大家来说这100 个停车位就是共享资源。假设现在这个停车场正常运行，你要把车停到这个这个停车场肯定要先看一下现在停了多少车了？还有没有停车位？当前停车数量就是一个信号量，具体的停车数量就是这个信号量值，当这个值到 100 的时候说明停车场满了。停车场满的时你可以等一会看看有没有其他的车开出停车场，当有车开出停车场的时候停车数量就会减一，也就是说信号量减一，此时你就可以把车停进去了，你把车停进去以后停车数量就会加一，也就是信号量加一。

这就是一个典型的使用信号量进行共享资源管理的案例，在这个案例中使用的就是计数型信号量。

相比于自旋锁，信号量可以使线程进入休眠状态，比如 A 与 B、C 合租了一套房子，这个房子只有一个厕所，一次只能一个人使用。某一天早上 A 去上厕所了，过了一会 B 也想用厕所，因为 A 在厕所里面，所以 B 只能等到 A 用来了才能进去。B 要么就一直在厕所门口等着，等 A 出来，这个时候就相当于自旋锁。B 也可以告诉 A，让 A 出来以后通知他一下，然后 B 继续回房间睡觉，这个时候相当于信号量。

可以看出，使用信号量会提高处理器的使用效率，毕竟不用一直傻乎乎的在那里“自旋”等待。但是，信号量的开销要比自旋锁大，因为信号量使线程进入休眠状态以后会切换线程，切换线程就会有开销。总结一下信号量的特点：

①、因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合。
②、因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
③、如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。

信号量有一个信号量值，相当于一个房子有 10 把钥匙，这 10 把钥匙就相当于信号量值为10。因此，可以通过信号量来控制访问共享资源的访问数量，如果要想进房间，那就要先获取一把钥匙，信号量值减 1，直到 10 把钥匙都被拿走，信号量值为 0，这个时候就不允许任何人进入房间了，因为没钥匙了。如果有人从房间出来，那他要归还他所持有的那把钥匙，信号量值加 1，此时有 1 把钥匙了，那么可以允许进去一个人。相当于通过信号量控制访问资源的线程数，在初始化的时候将信号量值设置的大于 1，那么这个信号量就是计数型信号量，计数型信号量不能用于互斥访问，因为它允许多个线程同时访问共享资源。如果要互斥的访问共享资源那么信号量的值就不能大于 1，此时的信号量就是一个二值信号量。

2、信号量 API 函数

Linux 内核使用 semaphore 结构体表示信号量，结构体内容如下所示：

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

要想使用信号量就得先定义，然后初始化信号量。有关信号量的 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)	释放信号量

信号量的使用如下所示：

struct semaphore sem; /* 定义信号量 */

sema_init(&sem, 1)； /* 初始化信号量 */
    
down(&sem); /* 申请信号量 */
/* 临界区 */
up(&sem); /* 释放信号量 */

5|互斥体

1、互斥体简介

在 FreeRTOS 和 UCOS 中也有互斥体，将信号量的值设置为 1 就可以使用信号量进行互斥访问了，虽然可以通过信号量实现互斥，但是 Linux 提供了一个比信号量更专业的机制来进行互斥，它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。在我们编写 Linux 驱动的时候遇到需要互斥访问的地方建议使用 mutex。Linux 内核使用 mutex 结构体表示互斥体，定义如下(省略条件编译部分)：

struct mutex {
    /* 1: unlocked, 0: locked, negative: locked, possible waiters */
    atomic_t count;
    spinlock_t wait_lock;
};

在使用 mutex 之前要先定义一个 mutex 变量。在使用 mutex 的时候要注意如下几点：

①、mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
②、和信号量一样，mutex 保护的临界区可以调用引起阻塞的 API 函数。
③、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并且 mutex 不能递归上锁和解锁。

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

互斥体的使用如下所示：

关于 Linux 中的并发和竞争就讲解到这里，Linux 内核还有很多其他的处理并发和竞争的机制，本章我们主要讲解了常用的原子操作、自旋锁、信号量和互斥体。以后我们在编写 Linux驱动的时候就会频繁的使用到这几种机制，希望大家能够深入理解这几个常用的机制。

Linux并发与竞争实验

在上一章中我们学习了 Linux 下的并发与竞争，并且学习了四种常用的处理并发和竞争的机制：原子操作、自旋锁、信号量和互斥体。本章我们就通过四个实验来学习如何在驱动中使用这四种机制。

1|原子操作实验

本例程我们在前面的 gpioled.c 文件基础上完成。在本节使用中我们使用原子操作来实现对 LED 这个设备的互斥访问，也就是一次只允许一个应用程序可以使用 LED 灯。

LED 驱动修改

实验在实验驱动文件 gpioled.c 的基础上修改而来。新建名为“7_atomic”的文件夹，然后在 7_atomic 文件夹里面创建 vscode 工程，工作区命名为“atomic”。将 5_gpioled实验中的 gpioled.c 复制到 7_atomic 文件夹中，并且重命名为 atomic.c。

本节实验重点就是使用atomic 来实现一次只能允许一个应用访问 LED，所以我们只需要在 atomic.c 文件源码的基础上加上添加 atomic 相关代码即可，完成以后的 atomic.c 文件内容如下所示：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>


typedef enum led_switch_enum{
	LED_OFF = 0,
	LED_ON = !LED_OFF
}led_switch_t;


/* 设备号个数 */
#define GPIOLED_DEV_NUM 1

/* gpioled设备结构体 */
struct gpioled_dev {	
	struct cdev cdev;
	dev_t devid;
	struct class *class;
	struct device *device;
	int major;
	int minor;
	char *devname;
	struct device_node *np;	//设备树节点
	int led_gpio;			//led所使用的GPIO编号
	atomic_t lock;			//原子变量
};

static struct gpioled_dev gpioled;


static void led_switch(led_switch_t sw)
{
	//int val = 0;
	if(sw == LED_ON)
	{
		/* 设置GPIO电平为低电平 点亮LED */
		gpio_set_value(gpioled.led_gpio, 0);
	}
	else
	{
		/* 设置GPIO电平为高电平 关闭LED */
		gpio_set_value(gpioled.led_gpio, 1);
	}
}


static int gpioled_open(struct inode *inode, struct file *filp)
{
	/* 通过判断原子变量的值来检查 LED 有没有被别的应用使用 */
	/* 原子变量为1说明没有被使用 */
	if (!atomic_dec_and_test(&gpioled.lock)){
		atomic_inc(&gpioled.lock);	/*  小于 0  的话就加 1, 使其原子变量等于 0 */
		return -EBUSY;				/* LED  被使用，返回忙 */
	}

	filp->private_data = &gpioled;	/* 设置私有数据 */
	return 0;
}

static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	//struct gpioled_dev *dev = (struct gpioled_dev*)filp->private_data;	/* 以访问私有数据 */
	char userDataBuf[1];
	int ret = 0;
	ret = copy_from_user(userDataBuf, buf, cnt);
	if(ret < 0)
	{
		printk("write failed!\r\n");
		return -1;
	}
	led_switch(userDataBuf[0]);
	return 0;

}

static int gpioled_release(struct inode *inode, struct file *filp)
{
	struct gpioled_dev *dev = filp->private_data;
	/* 关闭驱动文件的时候释放原子变量 */
	atomic_inc(&dev->lock);
	return 0;
}







/* 设备操作集合 */
static const struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.write = gpioled_write,
	.read = gpioled_read,
	.open = gpioled_open,
	.release = gpioled_release

};

static int __init gpioled_init(void)
{
	int ret = 0;
	int result = 0;


	/* 初始化原子变量 */
	atomic_set(&gpioled.lock, 1);	/* 原子变量初始值为 1 */

	/* 注册设备号 */
	gpioled.devname = "atomicled";
	gpioled.major = 0;
	if(gpioled.major){
		gpioled.devid = MKDEV(gpioled.major, gpioled.minor);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM, gpioled.devname);
	}
	else{
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_DEV_NUM, gpioled.devname);
	}
	gpioled.major = MAJOR(gpioled.devid);
	gpioled.minor = MINOR(gpioled.devid);
	if(ret < 0){
		printk("register devid failed!\r\n");
		result = -EINVAL;
		goto fail_register_devid;
	}
	printk("gpioled  MAJOR:%d  MINOR:%d\r\n", gpioled.major, gpioled.minor);

	/* 添加字符设备 */
	gpioled.cdev.owner = gpioled_fops.owner;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_DEV_NUM);
	if(ret < 0){
		printk("register chrdev failed!\r\n");
		result = -EINVAL;
		goto fail_register_cdev;
	}
	/* 创建设备节点 */
	/* 	1.创建类 */
	gpioled.class = class_create(THIS_MODULE, gpioled.devname);
	if(IS_ERR(gpioled.class)){
		printk("fail to create class!\r\n");
		result = PTR_ERR(gpioled.class);
		goto fail_class;
	}
	/*	2.创建设备*/
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, gpioled.devname);
	if(IS_ERR(gpioled.device)){
		printk("fail to create device!\r\n");
		result = PTR_ERR(gpioled.device);
		goto fail_device;
	}
	

	/* 获取设备节点 */
	gpioled.np = of_find_node_by_path("/gpioled");
	if(gpioled.np == NULL){
		printk("no device_node found!\r\n");
		result = -EINVAL;
		goto fail_findnd;
	}

	/* 获取LED对应的GPIO */
	gpioled.led_gpio = of_get_named_gpio(gpioled.np, "led-gpio", 0);
	if(gpioled.led_gpio < 0){
		result = -EINVAL;
		printk("can't find gpio!\r\n");
		goto fail_get_gpio;
	}

	printk("gpio num is:%d \r\n", gpioled.led_gpio);

	/* 申请IO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");
	if(ret){
		printk("request GPIO failed!\r\n");
		result = -EINVAL;
		goto fail_request_gpio;
	}

	/* 使用IO */
	ret = gpio_direction_output(gpioled.led_gpio, 1/* HIGH默认关闭LED */);
	if(ret){
		printk("set GPIO output failed!\r\n");
		result = -EINVAL;
		goto fail_gpio_failed;
	}

	/* 设置GPIO电平 */
	printk("set LED-GPIO to 0\r\n");
	gpio_set_value(gpioled.led_gpio, 0);	/* 默认开灯 */

	return 0;

fail_gpio_failed:
	/* 释放IO */
	gpio_free(gpioled.led_gpio);
fail_request_gpio:
fail_get_gpio:
fail_findnd:
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
fail_device:
	/* 摧毁类 */
	class_destroy(gpioled.class);
fail_class:
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
fail_register_cdev:
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);
fail_register_devid:
	return result;
}


static void __exit gpioled_exit(void)
{
	/* 关灯 */
	gpio_set_value(gpioled.led_gpio, 1);	

	/* 释放IO */
	gpio_free(gpioled.led_gpio);
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
	/* 摧毁类 */
	class_destroy(gpioled.class);
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);

}

/* 驱动入口和出口 */
module_init(gpioled_init);
module_exit(gpioled_exit);

/* 许可 */
MODULE_LICENSE("GPL");
/* 作者信息 */
MODULE_AUTHOR("LXG@firestaradmin");

添加了原子变量 lock，用来实现一次只能允许一个应用访问 LED 灯，led_init 驱动入口函数会将 lock 的值设置为 1。

每次调用 open 函数打开驱动设备的时候先申请 lock，如果申请成功的话就表示LED灯还没有被其他的应用使用，如果申请失败就表示LED灯正在被其他的应用程序使用。每次打开驱动设备的时候先使用atomic_dec_and_test 函数将 lock 减 1，如果 atomic_dec_and_test函数返回值为真就表示 lock 当前值为 0，说明设备可以使用。如果 atomic_dec_and_test 函数返回值为假，就表示 lock 当前值为负数(lock 值默认是 1)，lock 值为负数的可能性只有一个，那就是其他设备正在使用 LED。其他设备正在使用 LED 灯，那么就只能退出了，在退出之前调用函数 atomic_inc 将 lock 加 1，因为此时 lock 的值被减成了负数，必须要对其加 1，将 lock 的值变为 0。

LED 灯使用完毕，应用程序调用 close 函数关闭的驱动文件，gpioled_release 函数执行，调用atomic_inc 释放 lcok，也就是将 lock 加 1。

驱动初始化函数初始化原子变量 lock，初始值设置为 1，这样每次就只允许一个应用使用 LED灯。

APP编写

新建名为 atomicApp.c 的测试 APP，在里面输入如下所示内容：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>


/*
 *  usage:
 *  ./ledAPP     <openFileName>     <0:OFF|1:ON>   
 *  ./ledAPP     /dev/gpioled           0               //关灯
 *  ./ledAPP     /dev/gpioled           1               //开灯
 */

int main(int argc, char *argv[])
{
    int ret = 0, cnt = 0;
    int fd = 0;
    char *filename;
    char writebuf [1]; 
    filename = argv[1];

    if(argc != 3)
    {
        printf("bad usage!\r\n");
        printf("usage:\r\n./ledAPP     <openFileName>     <0:OFF|1:ON>  \r\n");
        return -1;
    }

    /* 打开 */
    fd =  open(filename, O_WRONLY);
    if(fd < 0){
        printf("can't open file %s\r\n", filename);
        return -1;
    }

    writebuf[0] = atoi(argv[2]);
    ret = write(fd, writebuf, sizeof(writebuf));
    if(ret < 0){
        printf("write file %s failed!\r\n", filename);
        close(fd);
        return -1;
    }
    else {
        printf("write file %s success!\r\n", filename);
    }

    /* 模拟占用 25S LED */
    while(1) {
        sleep(5);
        cnt++;
        printf("App running times:%d s.\r\n", cnt * 5);
        if(cnt >= 5) break;
    }

    /* 关闭 */
    ret = close(fd);
    if(ret < 0){
        printf("close file %s failed！\r\n", filename);
    }
}

atomicApp.c 中的内容就是在 ledAPP.c 的基础上修改而来的，重点是加入了模拟占用 25 秒 LED 的代码。测试 APP 在获取到 LED 灯驱动的使用权以后会使用 25S，在使用的这段时间如果有其他的应用也去获取 LED 灯使用权的话肯定会失败！

运行测试：

将编译出来的 atomic.ko 和 atomicApp 这两个文件拷贝到 rootfs/lib/modules/4.1.15目录中，重启开发板，进入到目录 lib/modules/4.1.15 中，输入如下命令加载 atomic.ko 驱动模块：

depmod //第一次加载驱动的时候需要运行此命令
modprobe atomic.ko  //加载驱动

驱动加载成功以后就可以使用 atomicApp 软件来测试驱动是否工作正常，输入如下命令以后台运行模式打开 LED 灯，“&”表示在后台运行 atomicApp 这个软件：

./atomicApp /dev/atomicled 1& //打开 LED 灯

然后在app程序结束前，再次输入：

./atomicApp /dev/atomicled 0 //关闭 LED 灯

会发现提示 error can’t open file.

2|自旋锁实验

上一节我们使用原子变量实现了一次只能有一个应用程序访问 LED 灯，本节我们使用自旋锁来实现此功能。在使用自旋锁之前，先回顾一下自旋锁的使用注意事项：

①、自旋锁保护的临界区要尽可能的短，因此在 open 函数中申请自旋锁，然后在 release 函数中释放自旋锁的方法就不可取。我们可以使用一个变量来表示设备的使用情况，如果设备被使用了那么变量就加一，设备被释放以后变量就减 1，我们只需要使用自旋锁保护这个变量即可。
②、考虑驱动的兼容性，合理的选择 API 函数。

综上所述，在本节例程中，我们通过定义一个变量 dev_stats 表示设备的使用情况，dev_stats为 0 的时候表示设备没有被使用，dev_stats 大于 0 的时候表示设备被使用。驱动 open 函数中先判断 dev_stats 是否为 0，也就是判断设备是否可用，如果为 0 的话就使用设备，并且将 dev_stats加 1，表示设备被使用了。使用完以后在 release 函数中将 dev_stats 减 1，表示设备没有被使用了。因此真正实现设备互斥访问的是变量 dev_stats，但是我们要使用自旋锁对 dev_stats 来做保护。

驱动程序编写

本节实验在第上一节实验驱动文件 atomic.c 的基础上修改而来。新建名为“8_spinlock”的文件夹，然后在 8_spinlock 文件夹里面创建 vscode 工程，工作区命名为“spinlock”。将 7_atomic实验中的 atomic.c 复制到 8_spinlock 文件夹中，并且重命名为 spinlock.c。将原来使用 atomic 的地方换为 spinlock 即可，其他代码不需要修改，完成以后的 spinlock.c 文件内容如下所示：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>


typedef enum led_switch_enum{
	LED_OFF = 0,
	LED_ON = !LED_OFF
}led_switch_t;


/* 设备号个数 */
#define GPIOLED_DEV_NUM 1

/* gpioled设备结构体 */
struct gpioled_dev {	
	struct cdev cdev;
	dev_t devid;
	struct class *class;
	struct device *device;
	int major;
	int minor;
	char *devname;
	struct device_node *np;	//设备树节点
	int led_gpio;			//led所使用的GPIO编号
	int dev_status;			//设备状态|0:设备未使用|>0:设备被使用
	spinlock_t lock;		//自旋锁
};

static struct gpioled_dev gpioled;


static void led_switch(led_switch_t sw)
{
	//int val = 0;
	if(sw == LED_ON)
	{
		/* 设置GPIO电平为低电平 点亮LED */
		gpio_set_value(gpioled.led_gpio, 0);
	}
	else
	{
		/* 设置GPIO电平为高电平 关闭LED */
		gpio_set_value(gpioled.led_gpio, 1);
	}
}


static int gpioled_open(struct inode *inode, struct file *filp)
{
	unsigned long flags;
	filp->private_data = &gpioled; /* 设置私有数据 */

	spin_lock_irqsave(&gpioled.lock, flags); /*  上锁 */
	if (gpioled.dev_status) { /*  如果设备被使用了 */
		spin_unlock_irqrestore(&gpioled.lock, flags); /*  解锁 */
		return -EBUSY;
	}
	gpioled.dev_status++; /*  如果设备没有打开，那么就标记已经打开了 */
	spin_unlock_irqrestore(&gpioled.lock, flags);/*  解锁 */

	return 0;
}

static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	//struct gpioled_dev *dev = (struct gpioled_dev*)filp->private_data;	/* 以访问私有数据 */
	char userDataBuf[1];
	int ret = 0;
	ret = copy_from_user(userDataBuf, buf, cnt);
	if(ret < 0)
	{
		printk("write failed!\r\n");
		return -1;
	}
	led_switch(userDataBuf[0]);
	return 0;

}

static int gpioled_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_status) {
		dev->dev_status--;
	}
	spin_unlock_irqrestore(&dev->lock, flags);/*  解锁 */
	return 0;
}







/* 设备操作集合 */
static const struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.write = gpioled_write,
	.read = gpioled_read,
	.open = gpioled_open,
	.release = gpioled_release

};

static int __init gpioled_init(void)
{
	int ret = 0;
	int result = 0;


	/* 初始化自旋锁 */
	spin_lock_init(&gpioled.lock);	

	/* 注册设备号 */
	gpioled.devname = "spinlock_led";
	gpioled.major = 0;
	if(gpioled.major){
		gpioled.devid = MKDEV(gpioled.major, gpioled.minor);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM, gpioled.devname);
	}
	else{
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_DEV_NUM, gpioled.devname);
	}
	gpioled.major = MAJOR(gpioled.devid);
	gpioled.minor = MINOR(gpioled.devid);
	if(ret < 0){
		printk("register devid failed!\r\n");
		result = -EINVAL;
		goto fail_register_devid;
	}
	printk("gpioled  MAJOR:%d  MINOR:%d\r\n", gpioled.major, gpioled.minor);

	/* 添加字符设备 */
	gpioled.cdev.owner = gpioled_fops.owner;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_DEV_NUM);
	if(ret < 0){
		printk("register chrdev failed!\r\n");
		result = -EINVAL;
		goto fail_register_cdev;
	}
	/* 创建设备节点 */
	/* 	1.创建类 */
	gpioled.class = class_create(THIS_MODULE, gpioled.devname);
	if(IS_ERR(gpioled.class)){
		printk("fail to create class!\r\n");
		result = PTR_ERR(gpioled.class);
		goto fail_class;
	}
	/*	2.创建设备*/
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, gpioled.devname);
	if(IS_ERR(gpioled.device)){
		printk("fail to create device!\r\n");
		result = PTR_ERR(gpioled.device);
		goto fail_device;
	}
	

	/* 获取设备节点 */
	gpioled.np = of_find_node_by_path("/gpioled");
	if(gpioled.np == NULL){
		printk("no device_node found!\r\n");
		result = -EINVAL;
		goto fail_findnd;
	}

	/* 获取LED对应的GPIO */
	gpioled.led_gpio = of_get_named_gpio(gpioled.np, "led-gpio", 0);
	if(gpioled.led_gpio < 0){
		result = -EINVAL;
		printk("can't find gpio!\r\n");
		goto fail_get_gpio;
	}

	printk("gpio num is:%d \r\n", gpioled.led_gpio);

	/* 申请IO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");
	if(ret){
		printk("request GPIO failed!\r\n");
		result = -EINVAL;
		goto fail_request_gpio;
	}

	/* 使用IO */
	ret = gpio_direction_output(gpioled.led_gpio, 1/* HIGH默认关闭LED */);
	if(ret){
		printk("set GPIO output failed!\r\n");
		result = -EINVAL;
		goto fail_gpio_failed;
	}

	/* 设置GPIO电平 */
	printk("set LED-GPIO to 0\r\n");
	gpio_set_value(gpioled.led_gpio, 0);	/* 默认开灯 */

	return 0;

fail_gpio_failed:
	/* 释放IO */
	gpio_free(gpioled.led_gpio);
fail_request_gpio:
fail_get_gpio:
fail_findnd:
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
fail_device:
	/* 摧毁类 */
	class_destroy(gpioled.class);
fail_class:
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
fail_register_cdev:
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);
fail_register_devid:
	return result;
}


static void __exit gpioled_exit(void)
{
	/* 关灯 */
	gpio_set_value(gpioled.led_gpio, 1);	

	/* 释放IO */
	gpio_free(gpioled.led_gpio);
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
	/* 摧毁类 */
	class_destroy(gpioled.class);
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);

}

/* 驱动入口和出口 */
module_init(gpioled_init);
module_exit(gpioled_exit);

/* 许可 */
MODULE_LICENSE("GPL");
/* 作者信息 */
MODULE_AUTHOR("LXG@firestaradmin");

dev_stats 表示设备状态，如果为 0 的话表示设备还没有被使用，如果大于 0 的话就表示设备已经被使用了。定义自旋锁变量 lock。使用自旋锁实现对设备的互斥访问，

调用 spin_lock_irqsave 函数获取锁，为了考虑到驱动兼容性，这里并没有使用 spin_lock 函数来获取锁。判断dev_stats 是否大于 0，如果是的话表示设备已经被使用了，那么就调用spin_unlock_irqrestore函数释放锁，并且返回-EBUSY。如果设备没有被使用的话就将 dev_stats 加 1，表示设备要被使用了，然后调用 spin_unlock_irqrestore 函数释放锁。自旋锁的工作就是保护dev_stats 变量，真正实现对设备互斥访问的是 dev_stats。

在 release 函数中将 dev_stats 减 1，表示设备被释放了，可以被其他的应用程序使用。将 dev_stats 减 1 的时候需要自旋锁对其进行保护。

在驱动入口函数 led_init 中调用 spin_lock_init 函数初始化自旋锁。

运行测试

编译运行。

驱动加载成功以后就可以使用 spinlockApp 软件测试驱动是否工作正常，测试方法和前面测试小节中一样，先输入如下命令让 spinlockAPP 软件模拟占用 25S 的 LED 灯：

./atomicApp /dev/spinlock_led 1& //打开 LED 灯

紧接着再输入如下命令关闭 LED 灯：

./atomicApp /dev/spinlock_led 0 //关闭 LED 灯

看一下能不能关闭 LED 灯，驱动正常工作的话并不会马上关闭 LED 灯，会提示你“open failed!”，必须等待第一个 atomicApp 软件运行完成(25S 计时结束)才可以再次操作 LED 灯。

3|信号量实验

本节我们来使用信号量实现了一次只能有一个应用程序访问 LED 灯，信号量可以导致休眠，因此信号量保护的临界区没有运行时间限制，可以在驱动的 open 函数申请信号量，然后在release 函数中释放信号量。但是信号量不能用在中断中，本节实验我们不会在中断中使用信号量。

LED 驱动修改

本节实验在实验驱动文件 spinlock.c 的基础上修改而来。新建名为“9_semaphore”的文件夹，然后在 9_semaphore 文件夹里面创建 vscode 工程，工作区命名为“semaphore”。将8_spinlock 实验中的 spinlock.c 复制到 9_semaphore 文件夹中，并且重命名为 semaphore.c。将原来使用到自旋锁的地方换为信号量即可，其他的内容基本不变，完成以后的 semaphore.c 文件内容如下所示：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>

typedef enum led_switch_enum{
	LED_OFF = 0,
	LED_ON = !LED_OFF
}led_switch_t;


/* 设备号个数 */
#define GPIOLED_DEV_NUM 1

/* gpioled设备结构体 */
struct gpioled_dev {	
	struct cdev cdev;
	dev_t devid;
	struct class *class;
	struct device *device;
	int major;
	int minor;
	char *devname;
	struct device_node *np;	//设备树节点
	int led_gpio;			//led所使用的GPIO编号
	struct semaphore sem; 	//信号量
};

static struct gpioled_dev gpioled;


static void led_switch(led_switch_t sw)
{
	//int val = 0;
	if(sw == LED_ON)
	{
		/* 设置GPIO电平为低电平 点亮LED */
		gpio_set_value(gpioled.led_gpio, 0);
	}
	else
	{
		/* 设置GPIO电平为高电平 关闭LED */
		gpio_set_value(gpioled.led_gpio, 1);
	}
}


static int gpioled_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;
}

static ssize_t gpioled_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	//struct gpioled_dev *dev = (struct gpioled_dev*)filp->private_data;	/* 以访问私有数据 */
	char userDataBuf[1];
	int ret = 0;
	ret = copy_from_user(userDataBuf, buf, cnt);
	if(ret < 0)
	{
		printk("write failed!\r\n");
		return -1;
	}
	led_switch(userDataBuf[0]);
	return 0;

}

static int gpioled_release(struct inode *inode, struct file *filp)
{
	struct gpioled_dev *dev = filp->private_data;

	up(&dev->sem); /*  释放信号量，信号量值加 1 */

	return 0;
}







/* 设备操作集合 */
static const struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.write = gpioled_write,
	.read = gpioled_read,
	.open = gpioled_open,
	.release = gpioled_release

};

static int __init gpioled_init(void)
{
	int ret = 0;
	int result = 0;


	/* 初始化信号量 */
	sema_init(&gpioled.sem, 1);

	/* 注册设备号 */
	gpioled.devname = "semaphore_led";
	gpioled.major = 0;
	if(gpioled.major){
		gpioled.devid = MKDEV(gpioled.major, gpioled.minor);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM, gpioled.devname);
	}
	else{
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_DEV_NUM, gpioled.devname);
	}
	gpioled.major = MAJOR(gpioled.devid);
	gpioled.minor = MINOR(gpioled.devid);
	if(ret < 0){
		printk("register devid failed!\r\n");
		result = -EINVAL;
		goto fail_register_devid;
	}
	printk("gpioled  MAJOR:%d  MINOR:%d\r\n", gpioled.major, gpioled.minor);

	/* 添加字符设备 */
	gpioled.cdev.owner = gpioled_fops.owner;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_DEV_NUM);
	if(ret < 0){
		printk("register chrdev failed!\r\n");
		result = -EINVAL;
		goto fail_register_cdev;
	}
	/* 创建设备节点 */
	/* 	1.创建类 */
	gpioled.class = class_create(THIS_MODULE, gpioled.devname);
	if(IS_ERR(gpioled.class)){
		printk("fail to create class!\r\n");
		result = PTR_ERR(gpioled.class);
		goto fail_class;
	}
	/*	2.创建设备*/
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, gpioled.devname);
	if(IS_ERR(gpioled.device)){
		printk("fail to create device!\r\n");
		result = PTR_ERR(gpioled.device);
		goto fail_device;
	}
	

	/* 获取设备节点 */
	gpioled.np = of_find_node_by_path("/gpioled");
	if(gpioled.np == NULL){
		printk("no device_node found!\r\n");
		result = -EINVAL;
		goto fail_findnd;
	}

	/* 获取LED对应的GPIO */
	gpioled.led_gpio = of_get_named_gpio(gpioled.np, "led-gpio", 0);
	if(gpioled.led_gpio < 0){
		result = -EINVAL;
		printk("can't find gpio!\r\n");
		goto fail_get_gpio;
	}

	printk("gpio num is:%d \r\n", gpioled.led_gpio);

	/* 申请IO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");
	if(ret){
		printk("request GPIO failed!\r\n");
		result = -EINVAL;
		goto fail_request_gpio;
	}

	/* 使用IO */
	ret = gpio_direction_output(gpioled.led_gpio, 1/* HIGH默认关闭LED */);
	if(ret){
		printk("set GPIO output failed!\r\n");
		result = -EINVAL;
		goto fail_gpio_failed;
	}

	/* 设置GPIO电平 */
	printk("set LED-GPIO to 0\r\n");
	gpio_set_value(gpioled.led_gpio, 0);	/* 默认开灯 */

	return 0;

fail_gpio_failed:
	/* 释放IO */
	gpio_free(gpioled.led_gpio);
fail_request_gpio:
fail_get_gpio:
fail_findnd:
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
fail_device:
	/* 摧毁类 */
	class_destroy(gpioled.class);
fail_class:
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
fail_register_cdev:
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);
fail_register_devid:
	return result;
}


static void __exit gpioled_exit(void)
{
	/* 关灯 */
	gpio_set_value(gpioled.led_gpio, 1);	

	/* 释放IO */
	gpio_free(gpioled.led_gpio);
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
	/* 摧毁类 */
	class_destroy(gpioled.class);
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);

}

/* 驱动入口和出口 */
module_init(gpioled_init);
module_exit(gpioled_exit);

/* 许可 */
MODULE_LICENSE("GPL");
/* 作者信息 */
MODULE_AUTHOR("LXG@firestaradmin");

要使用信号量必须添加<linux/semaphore.h>头文件。

在设备结构体中添加一个信号量成员变量 sem。然后在open函数中申请信号量，可以使用down函数，也可以使用down_interruptible函数。如果信号量值大于等于 1 就表示可用，那么应用程序就会开始使用 LED 灯。如果信号量值为 0 就表示应用程序不能使用 LED 灯，此时应用程序就会进入到休眠状态。等到信号量值大于 1 的时候应用程序就会唤醒，申请信号量，获取 LED 灯使用权。

在 release 函数中调用 up 函数释放信号量，这样其他因为没有得到信号量而进入休眠状态的应用程序就会唤醒，获取信号量。

在驱动入口函数中调用 sema_init 函数初始化信号量 sem 的值为 1，相当于 sem是个二值信号量。

运行测试

编译后，加载运行。

测试方法和前面小节中一样，先输入如下命令让软件模拟占用 25S 的 LED 灯：

./atomic /dev/semaphore_led 1& //打开 LED 灯

紧接着再输入如下命令关闭 LED 灯：

./atomic /dev/semaphore_led 0& //打开 LED 灯

注意两个命令都是运行在后台，第一条命令先获取到信号量，因此可以操作 LED 灯，将LED 灯打开，并且占有 25S。第二条命令因为获取信号量失败而进入休眠状态，等待第一条命令运行完毕并释放信号量以后才拥有 LED 灯使用权，将 LED 灯关闭，运行结果如图所示：

4|互斥体实验

前面我们使用原子操作、自旋锁和信号量实现了对 LED 灯的互斥访问，但是最适合互斥的就是互斥体 mutex 了。本节我们来学习一下如何使用 mutex 实现对 LED 灯的互斥访问。

LED驱动修改

本节实验在第上一节实验驱动文件 semaphore.c 的基础上修改而来。新建名为“10_mutex”的文件夹，然后在10_mutex文件夹里面创建vscode工程，工作区命名为“mutex”。将9_semaphore实验中的semaphore.c 复制到 10_mutex 文件夹中，并且重命名为 mutex.c。将原来使用到信号量的地方换为mutex即可，其他的内容基本不变，完成以后的mutex.c文件内容如下所示：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>


typedef enum led_switch_enum{
	LED_OFF = 0,
	LED_ON = !LED_OFF
}led_switch_t;


/* 设备号个数 */
#define GPIOLED_DEV_NUM 1

/* gpioled设备结构体 */
struct gpioled_dev {	
	struct cdev cdev;
	dev_t devid;
	struct class *class;
	struct device *device;
	int major;
	int minor;
	char *devname;
	struct device_node *np;	//设备树节点
	int led_gpio;			//led所使用的GPIO编号
	struct mutex lock; 		/*  互斥体 */
};

static struct gpioled_dev gpioled;


static void led_switch(led_switch_t sw)
{
	//int val = 0;
	if(sw == LED_ON)
	{
		/* 设置GPIO电平为低电平 点亮LED */
		gpio_set_value(gpioled.led_gpio, 0);
	}
	else
	{
		/* 设置GPIO电平为高电平 关闭LED */
		gpio_set_value(gpioled.led_gpio, 1);
	}
}


static int gpioled_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 ssize_t gpioled_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

static ssize_t gpioled_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	//struct gpioled_dev *dev = (struct gpioled_dev*)filp->private_data;	/* 以访问私有数据 */
	char userDataBuf[1];
	int ret = 0;
	ret = copy_from_user(userDataBuf, buf, cnt);
	if(ret < 0)
	{
		printk("write failed!\r\n");
		return -1;
	}
	led_switch(userDataBuf[0]);
	return 0;

}

static int gpioled_release(struct inode *inode, struct file *filp)
{
	struct gpioled_dev *dev = filp->private_data;
	/* 释放互斥锁 */
	mutex_unlock(&dev->lock);

	return 0;
}







/* 设备操作集合 */
static const struct file_operations gpioled_fops = {
	.owner = THIS_MODULE,
	.write = gpioled_write,
	.read = gpioled_read,
	.open = gpioled_open,
	.release = gpioled_release

};

static int __init gpioled_init(void)
{
	int ret = 0;
	int result = 0;


	/* 初始化互斥体 */
	mutex_init(&gpioled.lock);

	/* 注册设备号 */
	gpioled.devname = "mutex_led";
	gpioled.major = 0;
	if(gpioled.major){
		gpioled.devid = MKDEV(gpioled.major, gpioled.minor);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM, gpioled.devname);
	}
	else{
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_DEV_NUM, gpioled.devname);
	}
	gpioled.major = MAJOR(gpioled.devid);
	gpioled.minor = MINOR(gpioled.devid);
	if(ret < 0){
		printk("register devid failed!\r\n");
		result = -EINVAL;
		goto fail_register_devid;
	}
	printk("gpioled  MAJOR:%d  MINOR:%d\r\n", gpioled.major, gpioled.minor);

	/* 添加字符设备 */
	gpioled.cdev.owner = gpioled_fops.owner;
	cdev_init(&gpioled.cdev, &gpioled_fops);
	ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_DEV_NUM);
	if(ret < 0){
		printk("register chrdev failed!\r\n");
		result = -EINVAL;
		goto fail_register_cdev;
	}
	/* 创建设备节点 */
	/* 	1.创建类 */
	gpioled.class = class_create(THIS_MODULE, gpioled.devname);
	if(IS_ERR(gpioled.class)){
		printk("fail to create class!\r\n");
		result = PTR_ERR(gpioled.class);
		goto fail_class;
	}
	/*	2.创建设备*/
	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, gpioled.devname);
	if(IS_ERR(gpioled.device)){
		printk("fail to create device!\r\n");
		result = PTR_ERR(gpioled.device);
		goto fail_device;
	}
	

	/* 获取设备节点 */
	gpioled.np = of_find_node_by_path("/gpioled");
	if(gpioled.np == NULL){
		printk("no device_node found!\r\n");
		result = -EINVAL;
		goto fail_findnd;
	}

	/* 获取LED对应的GPIO */
	gpioled.led_gpio = of_get_named_gpio(gpioled.np, "led-gpio", 0);
	if(gpioled.led_gpio < 0){
		result = -EINVAL;
		printk("can't find gpio!\r\n");
		goto fail_get_gpio;
	}

	printk("gpio num is:%d \r\n", gpioled.led_gpio);

	/* 申请IO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");
	if(ret){
		printk("request GPIO failed!\r\n");
		result = -EINVAL;
		goto fail_request_gpio;
	}

	/* 使用IO */
	ret = gpio_direction_output(gpioled.led_gpio, 1/* HIGH默认关闭LED */);
	if(ret){
		printk("set GPIO output failed!\r\n");
		result = -EINVAL;
		goto fail_gpio_failed;
	}

	/* 设置GPIO电平 */
	printk("set LED-GPIO to 0\r\n");
	gpio_set_value(gpioled.led_gpio, 0);	/* 默认开灯 */

	return 0;

fail_gpio_failed:
	/* 释放IO */
	gpio_free(gpioled.led_gpio);
fail_request_gpio:
fail_get_gpio:
fail_findnd:
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
fail_device:
	/* 摧毁类 */
	class_destroy(gpioled.class);
fail_class:
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
fail_register_cdev:
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);
fail_register_devid:
	return result;
}


static void __exit gpioled_exit(void)
{
	/* 关灯 */
	gpio_set_value(gpioled.led_gpio, 1);	

	/* 释放IO */
	gpio_free(gpioled.led_gpio);
	/* 摧毁设备 */
	device_destroy(gpioled.class, gpioled.devid);
	/* 摧毁类 */
	class_destroy(gpioled.class);
	/* 注销字符设备 */
	cdev_del(&gpioled.cdev);
	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_DEV_NUM);

}

/* 驱动入口和出口 */
module_init(gpioled_init);
module_exit(gpioled_exit);

/* 许可 */
MODULE_LICENSE("GPL");
/* 作者信息 */
MODULE_AUTHOR("LXG@firestaradmin");

运行测试

驱动加载成功以后就可以使用 mutexApp 软件测试驱动是否工作正常，测试方法和前面测试信号量的方法一样。

NOTE ARM-Linux 驱动开发篇

Embedded ARM Linux 驱动开发

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议，转载请注明出处！

7| Linux按键输入驱动实验上一篇

6| Linux 并发与竞争

Linux 并发与竞争

1|并发与竞争

1、并发与竞争简介

2、保护内容是什么

2|原子操作

1、原子操作简介

2、原子整形操作API函数

3、原子位操作 API 函数

3|自旋锁

1、自旋锁简介

2、自旋锁 API 函数

3、其他类型的锁

读写自旋锁

顺序锁

4、自旋锁使用注意事项

4|信号量

1、信号量简介

2、信号量 API 函数

5|互斥体

1、互斥体简介

2、互斥体 API 函数

Linux并发与竞争实验

1|原子操作实验

LED 驱动修改

APP编写

运行测试：

2|自旋锁实验

驱动程序编写

运行测试

3|信号量实验

LED 驱动修改

运行测试

4|互斥体实验

LED驱动修改

运行测试