ARM Linux 驱动开发篇--- Linux 并发与竞争实验（自旋锁实现 LED 设备互斥访问）--- Ubuntu20.04自旋锁实验

本次实验基于 I.MX6ULL 开发板，通过自旋锁实现了 LED 设备的互斥访问，完成了并发与竞争保护机制从原子操作到自旋锁的进阶实践。

济617

811人浏览 · 2026-03-03 15:31:11

济617 · 2026-03-03 15:31:11 发布

🎬 渡水无言：个人主页渡水无言

❄专栏传送门：《linux专栏》《嵌入式linux驱动开发》《linux系统移植专栏》

❄专栏传送门：《freertos专栏》《STM32 HAL库专栏》
⭐️流水不争先，争的是滔滔不绝

📚博主简介：第二十届中国研究生电子设计竞赛全国二等奖 |国家奖学金 | 省级三好学生

| 省级优秀毕业生获得者 | csdn新星杯TOP18 | 半导纵横专栏博主 | 211在读研究生

在这里主要分享自己学习的linux嵌入式领域知识；有分享错误或者不足的地方欢迎大佬指导，也欢迎各位大佬互相三连

二、硬件原理分析（看过之前博客的可以忽略）

三、实验程序编写

3.1 自旋锁 LED 驱动代码（spinlock.c）

3.2、驱动代码分段解析

3.2.1、设备结构体定义（28-39 行）

3.2.2、设备打开函数（50-64 行）

3.2.3、设备释放函数（115-128 行）

3.2.4、驱动入口函数（144-207 行）

前言

上一篇博客我们通过原子操作实现了 LED 设备的互斥访问（一次仅允许一个应用使用），本次我们将使用自旋锁完成同样的功能，并深入理解自旋锁的核心使用场景和编程规范。

一、实验基础说明

1.1、自旋锁简介

前面讲的原子操作，只能保护整形变量或位操作，但实际驱动开发中，我们常需要保护设备结构体、共享缓冲区等复杂资源——这时候就需要自旋锁登场了！

自旋锁的核心逻辑很简单，记住两点就行：

锁只能被一个线程持有，只要这个线程不释放锁，其他线程就无法获取。

未获取到锁的线程，不会进入休眠，而是忙循环等待（原地“自旋”），直到锁被释放。

还是用生活例子类比：公用电话亭（共享资源），里面有人正在打电话（持有锁），你到了门口，只能在原地等着（自旋），不能离开，也不能做其他事，直到里面的人打完电话出来（释放锁），你才能进去用。

自旋锁的特点：

忙等待：获取锁失败时，不会主动休眠，而是循环检测锁是否释放（“自旋”），直到获取到锁
低延迟：适合保护极短的临界区（几行代码），避免上下文切换开销
不可休眠：持有自旋锁期间，禁止进程休眠（否则会导致死锁）

1.2 本次实验设计思路

自旋锁保护的临界区必须尽可能短，因此不能在 open 函数中加锁、release 中解锁（会导致临界区过长）。我们采用 “状态变量 + 自旋锁” 的方案：
1、定义dev_stats变量标记设备状态：0= 空闲，>0= 被占用
2、用自旋锁保护dev_stats的读写操作（这是真正的临界区）
3、open 函数：自旋锁保护下检查dev_stats，空闲则置为占用
4、release 函数：自旋锁保护下将dev_stats减 1，释放设备

实验在此次博客基础上实现：

ARM Linux 驱动开发篇--- Linux 并发与竞争实验（原子操作）--- Ubuntu20.04-CSDN博客

二、硬件原理分析（看过之前博客的可以忽略）

从图中可以看出，LED0 接到了 GPIO_3 上，GPIO_3 就是 GPIO1_IO03，当 GPIO1_IO03 输出低电平 (0) 的时候发光二极管 LED0 就会导通点亮，当 GPIO1_IO03 输出高电平 (1) 的时候发光二极管 LED0 不会导通，因此 LED0 也就不会点亮。所以 LED0 的亮灭取决于 GPIO1_IO03 的输出电平，输出 0 就亮，输出 1 就灭。

三、实验程序编写

本次实验基于上一节原子操作的 LED 驱动修改，仅替换同步机制为自旋锁，硬件和设备树无需修改。把atomic.c文件改成spinlock.c 文件。

3.1 自旋锁 LED 驱动代码（spinlock.c）

  1 #include <linux/types.h>
  2 #include <linux/kernel.h>
  3 #include <linux/delay.h>
  4 #include <linux/ide.h>
  5 #include <linux/init.h>
  6 #include <linux/module.h>
  7 #include <linux/errno.h>
  8 #include <linux/gpio.h>
  9 #include <linux/cdev.h>
 10 #include <linux/device.h>
 11 #include <linux/of.h>
 12 #include <linux/of_address.h>
 13 #include <linux/of_gpio.h>
 14 #include <asm/mach/map.h>
 15 #include <asm/uaccess.h>
 16 #include <asm/io.h>
 17 /***************************************************************
 18 描述	   	: 自旋锁实验，使用自旋锁来实现对实现设备的互斥访问
 19 其他	   	: 无
 20 ***************************************************************/
 21 #define GPIOLED_CNT			1		  	/* 设备号个数 */
 22 #define GPIOLED_NAME		"gpioled"	/* 名字 */
 23 #define LEDOFF 				0			/* 关灯 */
 24 #define LEDON 				1			/* 开灯 */
 25 
 26 
 27 /* gpioled设备结构体 */
 28 struct gpioled_dev{
 29 	dev_t devid;			/* 设备号 	 */
 30 	struct cdev cdev;		/* cdev 	*/
 31 	struct class *class;	/* 类 		*/
 32 	struct device *device;	/* 设备 	 */
 33 	int major;				/* 主设备号	  */
 34 	int minor;				/* 次设备号   */
 35 	struct device_node	*nd; /* 设备节点 */
 36 	int led_gpio;			/* led所使用的GPIO编号		*/
 37 	int dev_stats;			/* 设备使用状态，0，设备未使用;>0,设备已经被使用 */
 38 	spinlock_t lock;		/* 自旋锁 */
 39 };
 40 
 41 struct gpioled_dev gpioled;	/* led设备 */
 42 
 43 /*
 44  * @description		: 打开设备
 45  * @param - inode 	: 传递给驱动的inode
 46  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 47  * 					  一般在open的时候将private_data指向设备结构体。
 48  * @return 			: 0 成功;其他 失败
 49  */
 50 static int led_open(struct inode *inode, struct file *filp)
 51 {
 52 	unsigned long flags;
 53 	filp->private_data = &gpioled; /* 设置私有数据 */
 54 
 55 	spin_lock_irqsave(&gpioled.lock, flags);	/* 上锁 */
 56 	if (gpioled.dev_stats) {					/* 如果设备被使用了 */
 57 		spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
 58 		return -EBUSY;
 59 	}
 60 	gpioled.dev_stats++;	/* 如果设备没有打开，那么就标记已经打开了 */
 61 	spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
 62 
 63 	return 0;
 64 }
 65 
 66 /*
 67  * @description		: 从设备读取数据 
 68  * @param - filp 	: 要打开的设备文件(文件描述符)
 69  * @param - buf 	: 返回给用户空间的数据缓冲区
 70  * @param - cnt 	: 要读取的数据长度
 71  * @param - offt 	: 相对于文件首地址的偏移
 72  * @return 			: 读取的字节数，如果为负值，表示读取失败
 73  */
 74 static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
 75 {
 76 	return 0;
 77 }
 78 
 79 /*
 80  * @description		: 向设备写数据 
 81  * @param - filp 	: 设备文件，表示打开的文件描述符
 82  * @param - buf 	: 要写给设备写入的数据
 83  * @param - cnt 	: 要写入的数据长度
 84  * @param - offt 	: 相对于文件首地址的偏移
 85  * @return 			: 写入的字节数，如果为负值，表示写入失败
 86  */
 87 static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
 88 {
 89 	int retvalue;
 90 	unsigned char databuf[1];
 91 	unsigned char ledstat;
 92 	struct gpioled_dev *dev = filp->private_data;
 93 
 94 	retvalue = copy_from_user(databuf, buf, cnt);
 95 	if(retvalue < 0) {
 96 		printk("kernel write failed!\r\n");
 97 		return -EFAULT;
 98 	}
 99 
100 	ledstat = databuf[0];		/* 获取状态值 */
101 
102 	if(ledstat == LEDON) {	
103 		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
104 	} else if(ledstat == LEDOFF) {
105 		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
106 	}
107 	return 0;
108 }
109 
110 /*
111  * @description		: 关闭/释放设备
112  * @param - filp 	: 要关闭的设备文件(文件描述符)
113  * @return 			: 0 成功;其他 失败
114  */
115 static int led_release(struct inode *inode, struct file *filp)
116 {
117 	unsigned long flags;
118 	struct gpioled_dev *dev = filp->private_data;
119 
120 	/* 关闭驱动文件的时候将dev_stats减1 */
121 	spin_lock_irqsave(&dev->lock, flags);	/* 上锁 */
122 	if (dev->dev_stats) {
123 		dev->dev_stats--;
124 	}
125 	spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */
126 
127 	return 0;
128 }
129 
130 /* 设备操作函数 */
131 static struct file_operations gpioled_fops = {
132 	.owner = THIS_MODULE,
133 	.open = led_open,
134 	.read = led_read,
135 	.write = led_write,
136 	.release = 	led_release,
137 };
138 
139 /*
140  * @description	: 驱动入口函数
141  * @param 		: 无
142  * @return 		: 无
143  */
144 static int __init led_init(void)
145 {
146 	int ret = 0;
147 
148 	/*  初始化自旋锁 */
149 	spin_lock_init(&gpioled.lock);
150 	
151 	/* 设置LED所使用的GPIO */
152 	/* 1、获取设备节点：gpioled */
153 	gpioled.nd = of_find_node_by_path("/gpioled");
154 	if(gpioled.nd == NULL) {
155 		printk("gpioled node not find!\r\n");
156 		return -EINVAL;
157 	} else {
158 		printk("gpioled node find!\r\n");
159 	}
160 
161 	/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
162 	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
163 	if(gpioled.led_gpio < 0) {
164 		printk("can't get led-gpio");
165 		return -EINVAL;
166 	}
167 	printk("led-gpio num = %d\r\n", gpioled.led_gpio);
168 
169 	/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭LED灯 */
170 	ret = gpio_direction_output(gpioled.led_gpio, 1);
171 	if(ret < 0) {
172 		printk("can't set gpio!\r\n");
173 	}
174 
175 	/* 注册字符设备驱动 */
176 	/* 1、创建设备号 */
177 	if (gpioled.major) {		/*  定义了设备号 */
178 		gpioled.devid = MKDEV(gpioled.major, 0);
179 		register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
180 	} else {						/* 没有定义设备号 */
181 		alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
182 		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
183 		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
184 	}
185 	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
186 	
187 	/* 2、初始化cdev */
188 	gpioled.cdev.owner = THIS_MODULE;
189 	cdev_init(&gpioled.cdev, &gpioled_fops);
190 	
191 	/* 3、添加一个cdev */
192 	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
193 
194 	/* 4、创建类 */
195 	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
196 	if (IS_ERR(gpioled.class)) {
197 		return PTR_ERR(gpioled.class);
198 	}
199 
200 	/* 5、创建设备 */
201 	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
202 	if (IS_ERR(gpioled.device)) {
203 		return PTR_ERR(gpioled.device);
204 	}
205 	
206 	return 0;
207 }
208 
209 /*
210  * @description	: 驱动出口函数
211  * @param 		: 无
212  * @return 		: 无
213  */
214 static void __exit led_exit(void)
215 {
216 	/* 注销字符设备驱动 */
217 	cdev_del(&gpioled.cdev);/*  删除cdev */
218 	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
219 
220 	device_destroy(gpioled.class, gpioled.devid);
221 	class_destroy(gpioled.class);
222 }
223 
224 module_init(led_init);
225 module_exit(led_exit);
226 MODULE_LICENSE("GPL");
227 MODULE_AUTHOR("duan");

3.2、驱动代码分段解析

3.2.1、设备结构体定义（28-39 行）

28 struct gpioled_dev{
29 	dev_t devid;			/* 设备号 	 */
30 	struct cdev cdev;		/* cdev 	*/
31 	struct class *class;	/* 类 		*/
32 	struct device *device;	/* 设备 	 */
33 	int major;				/* 主设备号	  */
34 	int minor;				/* 次设备号   */
35 	struct device_node	*nd; /* 设备节点 */
36 	int led_gpio;			/* led所使用的GPIO编号		*/
37 	int dev_stats;			/* 设备使用状态，0，设备未使用;>0,设备已经被使用 */
38 	spinlock_t lock;		/* 自旋锁 */
39 };

核心新增字段：
37 行：dev_stats 状态变量，替代原子操作中的原子变量，用于标记设备是否被占用；
38 行：spinlock_t lock 自旋锁变量，专门保护dev_stats的读写操作；
其他字段为字符设备驱动标准字段，负责设备号、GPIO、设备树节点等资源管理。

3.2.2、设备打开函数（50-64 行）

50 static int led_open(struct inode *inode, struct file *filp)
51 {
52 	unsigned long flags;
53 	filp->private_data = &gpioled; /* 设置私有数据 */
54 
55 	spin_lock_irqsave(&gpioled.lock, flags);	/* 上锁 */
56 	if (gpioled.dev_stats) {					/* 如果设备被使用了 */
57 		spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
58 		return -EBUSY;
59 	}
60 	gpioled.dev_stats++;	/* 如果设备没有打开，那么就标记已经打开了 */
61 	spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
62 
63 	return 0;
64 }

核心逻辑：
52 行：flags 用于保存中断状态，配合spin_lock_irqsave实现关中断加锁；
55 行：spin_lock_irqsave 上锁（关中断 + 自旋锁），兼顾中断上下文安全性，是嵌入式驱动的最佳实践；
56 行：检查dev_stats，非 0 表示设备已被占用，直接解锁并返回-EBUSY（设备忙）；
60 行：设备空闲时，将dev_stats加 1，标记为占用；
57/61 行：临界区结束立即解锁，严格遵守 “自旋锁临界区最短” 原则。

3.2.3、设备释放函数（115-128 行）

115 static int led_release(struct inode *inode, struct file *filp)
116 {
117 	unsigned long flags;
118 	struct gpioled_dev *dev = filp->private_data;
119 
120 	/* 关闭驱动文件的时候将dev_stats减1 */
121 	spin_lock_irqsave(&dev->lock, flags);	/* 上锁 */
122 	if (dev->dev_stats) {
123 		dev->dev_stats--;
124 	}
125 	spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */
126 
127 	return 0;
128 }

核心逻辑：
121 行：同样使用spin_lock_irqsave上锁，保护dev_stats的修改；
122-123 行：仅当dev_stats大于 0 时减 1，避免出现负数；
125 行：解锁，恢复中断状态，设备回到空闲状态。

3.2.4、驱动入口函数（144-207 行）

144 static int __init led_init(void)
145 {
146 	int ret = 0;
147 
148 	/*  初始化自旋锁 */
149 	spin_lock_init(&gpioled.lock);
150 	
151 	/* 设置LED所使用的GPIO */
152 	/* 1、获取设备节点：gpioled */
153 	gpioled.nd = of_find_node_by_path("/gpioled");
154 	if(gpioled.nd == NULL) {
155 		printk("gpioled node not find!\r\n");
156 		return -EINVAL;
157 	} else {
158 		printk("gpioled node find!\r\n");
159 	}
    // ... 省略GPIO解析和字符设备注册代码
206 	return 0;
207 }

核心步骤：
149 行：spin_lock_init 初始化自旋锁，驱动加载时必须执行，否则自旋锁不可用；
153-167 行：标准的设备树 GPIO 解析流程，获取 LED 对应的 GPIO 编号；
170 行：配置 GPIO 为输出模式，默认高电平（灭灯）；
175-204 行：Linux 字符设备驱动标准注册流程（创建设备号→初始化 cdev→创建类 / 设备节点）。

测试APP编写

直接复用原子操作实验的测试程序，仅重命名为spinlockApp.c，核心逻辑：

向 LED 驱动发送亮 / 灭控制指令；
模拟对 LED 设备的长时间占用（25 秒），验证在占用期间其他应用无法打开设备；
占用结束后释放设备，验证其他应用可正常访问。

代码如下：

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

#define LEDOFF 	0
#define LEDON 	1

int main(int argc, char *argv[])
{
	int fd, retvalue;
	char *filename;
	unsigned char cnt = 0;
	unsigned char databuf[1];
	
	if(argc != 3){
		printf("Error Usage!\r\n");
		return -1;
	}

	filename = argv[1];
	fd = open(filename, O_RDWR);
	if(fd < 0){
		printf("file %s open failed!\r\n", argv[1]);
		return -1;
	}

	databuf[0] = atoi(argv[2]);
	retvalue = write(fd, databuf, sizeof(databuf));
	if(retvalue < 0){
		printf("LED Control Failed!\r\n");
		close(fd);
		return -1;
	}

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

	printf("App running finished!\r\n");
	retvalue = close(fd);
	if(retvalue < 0){
		printf("file %s close failed!\r\n", argv[1]);
		return -1;
	}
	return 0;
}

四、运行测试

4.1、编译驱动程序和测试 APP

编写 Makefile 文件，本次实验的 Makefile 文件和之前的led实验基本一样，只是将 obj-m 变量的值改为spinlock.o，Makefile 内容如下所示：

KERNELDIR := /home/duan/linux/linux-imx-rel_imx_4.1.15_2.1.1_ga_alientek_v2.2
CURRENT_PATH := $(shell pwd)

obj-m := spinlock.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

第 4 行，设置 obj-m 变量的值为 spinlock.o。

输入如下命令编译出驱动模块文件：

make -j32

编译成功以后就会生成一个名为“spinlock.ko”的驱动模块文件。

编译测试 APP

输入如下命令编译测试试 spinlockApp.c 这个测试程序：

arm-linux-gnueabihf-gcc spinlockApp.c -o  spinlockApp

4.2、运行测试

将上一小节编译出来的spinlock.ko 和 spinlockApp这两个文件拷贝到 rootfs/lib/modules/4.1.15 目录中。

sudo cp spinlock.ko /home/duan/linux/nfs/rootfs/lib/modules/4.1.15/ -f

sudo cp  spinlockApp /home/duan/linux/nfs/rootfs/lib/modules/4.1.15/ -f

进入到目录 lib/modules/4.1.15 中，输入如下命令加载spinlock.ko 驱动模块：

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

驱动加载成功以后会在终端中输出一些信息，如下图所示：

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

./spinlockApp /dev/gpioled 1& //打开led

输入上述命令以后观察开发板上的红色 LED 灯是否点亮，然后每隔 5 秒都会输出一行“App

running times ”，如下图所示：

从上图可以看出，spinlockApp 运行正常，输出了“App running times:1”和“App running

times:2”，这就是模拟 25S 占用，说明 spinlockApp 这个软件正在使用 LED 灯。

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

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

看一下能不能关闭 LED 灯，驱动正常工作的话并不会马上关闭 LED 灯，会提示你“ file

/dev/gpioled open failed! ”，必须等待第一个 spinlockApp 软件运行完成 (25S 计时结束 ) 才可以再

次操作 LED 灯。如下图所示：

从上图可以看出，打开/dev/gpioled 失败！原因是在spinlockApp软件正在占用/dev/gpioled

必须等待图中的spinlockApp运行结束，也就是25S结束以后其他软件才能去操作/dev/gpioled。

如果要卸载驱动的话输入如下命令即可：

rmmod beep.ko

总结

本次实验基于 I.MX6ULL 开发板，通过自旋锁实现了 LED 设备的互斥访问，完成了并发与竞争保护机制从原子操作到自旋锁的进阶实践。

松山湖开发者村综合服务平台

助力广东及东莞地区开发者，代码托管、在线学习与竞赛、技术交流与分享、资源共享、职业发展，成为松山湖开发者首选的工作与学习平台

更多推荐

【题目翻译】2026 年国际数学建模挑战赛：规模化保护野生生物

松山湖开发者村综合服务平台

OpenClaw + 飞书集成：WebSocket 长连接 + 多 Agent 路由实战

松山湖开发者村综合服务平台

pdd小程序纯算逆向分析（codex版）

松山湖开发者村综合服务平台

所有评论(0)

查看更多评论

济617

@weixin_61186812

已为社区贡献7条内容