当前位置：首页 > news >正文

嵌入式Linux驱动开发 - 并发控制机制

news 2025/8/30 6:48:19

嵌入式Linux驱动开发 - 并发控制机制

一、项目概述

本项目深入探讨了嵌入式Linux驱动开发中的并发控制机制，通过三个示例项目展示了三种不同的同步方法：原子操作、自旋锁和信号量（互斥锁）。这些机制用于解决多进程/多线程环境下对共享资源的并发访问问题，确保数据的一致性和完整性。

二、开发环境

开发板：i.MX6ULL阿尔法开发板
内核版本：Linux 4.1.15
开发工具链：交叉编译工具链
硬件平台：NXP i.MX6ULL处理器

三、代码结构

concurrency_control/
├── 8_atomic/          // 原子操作示例
│   ├── atomic.c
│   ├── atomicAPP.c
│   └── Makefile
├── 9_spinlock/        // 自旋锁示例
│   ├── spinlock.c
│   ├── spinlockAPP.c
│   └── Makefile
└── 10_semaphore/      // 信号量/互斥锁示例├── semaphore.c├── semaphoreAPP.c└── Makefile

四、并发控制理论基础

1. 并发问题的来源

在多处理器系统或多任务环境中，多个进程或线程可能同时访问共享资源，导致：

竞态条件（Race Condition）：多个线程对共享资源的访问顺序不确定，导致结果不可预测
数据不一致：共享数据在多个线程间不一致
资源冲突：多个线程同时修改同一资源

2. 并发控制的目标

互斥性：确保同一时间只有一个线程可以访问临界区
可见性：确保一个线程对共享变量的修改对其他线程可见
有序性：确保操作的执行顺序符合预期

3. 临界区与原子操作

临界区：访问共享资源的代码段，需要互斥访问
原子操作：不可中断的操作，要么完全执行，要么完全不执行

五、原子操作（Atomic Operations）

1. 原子操作原理

原子操作是最简单的并发控制机制，通过硬件支持的原子指令实现。Linux内核提供了原子变量类型atomic_t和一系列原子操作函数。

2. 原子操作API

atomic_set()：设置原子变量的值
atomic_read()：读取原子变量的值
atomic_inc()：原子递增
atomic_dec()：原子递减
atomic_dec_and_test()：原子递减并测试是否为0

3. 原子操作代码分析 (atomic.c)

struct gpioled_dev
{// ...atomic_t lock;
};
struct gpioled_dev gpioled;static int gpioled_open(struct inode *inode, struct file *filp)
{filp->private_data = &gpioled;if (!atomic_dec_and_test(&gpioled.lock)){atomic_inc(&gpioled.lock);return -EBUSY;}return 0;
}static int gpioled_release(struct inode *inode, struct file *filp)
{atomic_inc(&gpioled.lock);return 0;
}

实现机制：

初始化：atomic_set(&gpioled.lock, 1)将锁初始化为1
打开设备：使用atomic_dec_and_test()原子递减并测试
- 如果结果为0，表示获取锁成功
- 如果结果不为0，表示设备已被占用，返回-EBUSY
释放设备：atomic_inc()原子递增，释放锁

4. 原子操作特点

优点：
- 执行速度快，无上下文切换开销
- 适用于简单的计数和标志操作
- 可在中断上下文中使用
缺点：
- 功能有限，只能进行简单的算术和逻辑操作
- 不能用于复杂的临界区保护
- 不支持阻塞等待

5. 用户空间测试程序 (atomicAPP.c)

int main(int argc, char *argv[])
{int cnt = 0;if (argc != 3){fprintf(stderr, "Usage: %s <led_device> <0|1>\n", argv[0]);return -1;}char *fileanme;unsigned char databuf[1];fileanme = argv[1];databuf[0] = atoi(argv[2]);int fd = 0;int ret = 0;fd = open(fileanme, O_RDWR);if (fd < 0){perror("open led device error");return -1;}ret = write(fd, databuf, 1);if (ret < 0){perror("write led device error");close(fd);return -1;}while (1){sleep(5);if (cnt++ >= 5)break;printf("APP running times is: %d\r\n", cnt);}printf("APP runing finished! \r\n");close(fd);return 0;
}

测试说明：

程序会尝试打开设备并写入数据
模拟长时间运行的应用程序
当另一个进程已经打开设备时，新进程将无法打开，返回-EBUSY

六、自旋锁（Spinlock）

1. 自旋锁原理

自旋锁是一种忙等待的锁机制。当一个线程尝试获取已被占用的自旋锁时，它会在一个循环中不断检查锁的状态，直到锁被释放。

2. 自旋锁API

spinlock_t：自旋锁类型
spin_lock_init()：初始化自旋锁
spin_lock()：获取自旋锁
spin_unlock()：释放自旋锁
spin_trylock()：尝试获取自旋锁（不阻塞）

3. 自旋锁代码分析 (spinlock.c)

struct gpioled_dev
{// ...int dev_status;spinlock_t lock;
};
struct gpioled_dev gpioled;static int gpioled_open(struct inode *inode, struct file *filp)
{filp->private_data = &gpioled;spin_lock(&gpioled.lock);if (gpioled.dev_status){spin_unlock(&gpioled.lock);return -EBUSY;}spin_unlock(&gpioled.lock);gpioled.dev_status++;return 0;
}static int gpioled_release(struct inode *inode, struct file *filp)
{struct gpioled_dev *dev = filp->private_data;spin_lock(&dev->lock);if (dev->dev_status){dev->dev_status--;}spin_unlock(&dev->lock);return 0;
}

实现机制：

初始化：spin_lock_init(&gpioled.lock)初始化自旋锁
打开设备：
- 获取自旋锁
- 检查dev_status状态
- 如果设备已被占用，释放锁并返回-EBUSY
- 如果设备空闲，设置状态并释放锁
释放设备：
- 获取自旋锁
- 递减状态计数
- 释放锁

4. 自旋锁特点

优点：
- 执行速度快，无上下文切换开销
- 适用于短时间的临界区保护
- 可在中断上下文中使用
- 保证CPU不会被调度出去
缺点：
- 占用CPU资源，造成忙等待
- 不适用于长时间的临界区
- 可能导致优先级反转问题
- 在单处理器系统中可能导致死锁

5. 用户空间测试程序 (spinlockAPP.c)

与原子操作示例相同，用于测试自旋锁的互斥功能。

七、信号量与互斥锁

1. 信号量原理

信号量是一种更高级的同步机制，允许指定数量的线程同时访问资源。当资源不可用时，线程会被阻塞并放入等待队列，直到资源可用。

2. 互斥锁原理

互斥锁是信号量的特例，信号量值为1，确保同一时间只有一个线程可以访问资源。Linux内核推荐使用互斥锁而不是二进制信号量。

3. 信号量/互斥锁API

struct mutex：互斥锁类型
mutex_init()：初始化互斥锁
mutex_lock()：获取互斥锁（可能阻塞）
mutex_unlock()：释放互斥锁
mutex_trylock()：尝试获取互斥锁（不阻塞）
mutex_is_locked()：检查互斥锁是否被占用

4. 信号量/互斥锁代码分析 (semaphore.c)

struct gpioled_dev
{// ...struct mutex lock;
};
struct gpioled_dev gpioled;static int gpioled_open(struct inode *inode, struct file *filp)
{filp->private_data = &gpioled;mutex_lock(&gpioled.lock);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;
}

实现机制：

初始化：mutex_init(&gpioled.lock)初始化互斥锁
打开设备：mutex_lock()获取互斥锁
- 如果锁可用，立即获取
- 如果锁被占用，进程进入睡眠状态，直到锁被释放
释放设备：mutex_unlock()释放互斥锁

5. 信号量/互斥锁特点

优点：
- 不占用CPU资源，线程在等待时进入睡眠状态
- 适用于长时间的临界区保护
- 支持复杂的同步需求
- 有完善的错误处理机制
缺点：
- 可能导致上下文切换开销
- 不能在中断上下文中使用
- 实现相对复杂

6. 用户空间测试程序 (semaphoreAPP.c)

与前两个示例相同，用于测试互斥锁的互斥功能。

八、三种机制对比分析

特性	原子操作	自旋锁	互斥锁
实现复杂度	简单	中等	复杂
执行效率	高	高	中等
CPU占用	低	高（忙等待）	低（睡眠等待）
适用场景	简单计数、标志	短时间临界区	长时间临界区
中断上下文	可用	可用	不可用
阻塞行为	不阻塞	不阻塞	阻塞
上下文切换	无	无	可能有
内存开销	小	小	较大
死锁风险	低	中等	中等
优先级反转	无	可能	可能（可通过优先级继承解决）

九、选择合适的并发控制机制

1. 选择原则

简单计数和标志操作：使用原子操作
短时间临界区，且在中断上下文中：使用自旋锁
长时间临界区，且在进程上下文中：使用互斥锁
需要等待队列和睡眠机制：使用互斥锁

2. 性能考虑

响应时间：原子操作 > 自旋锁 > 互斥锁
吞吐量：互斥锁 > 原子操作 > 自旋锁
CPU利用率：互斥锁 > 原子操作 > 自旋锁

3. 安全性考虑

死锁风险：互斥锁 > 自旋锁 > 原子操作
优先级反转：互斥锁 > 自旋锁 > 原子操作
中断禁用：自旋锁 > 原子操作 > 互斥锁

十、并发控制最佳实践

1. 临界区设计原则

最小化临界区：尽量减少临界区的代码量
避免在临界区内睡眠：特别是在自旋锁保护的临界区
避免在临界区内调用可能阻塞的函数：如内存分配、文件操作等
保持锁的顺序：避免死锁

2. 错误处理

检查返回值：特别是mutex_lock_interruptible()
设置超时：避免无限等待
使用mutex_trylock()：非阻塞尝试获取锁

3. 调试技巧

使用mutex_is_locked()：调试时检查锁状态
添加调试信息：记录锁的获取和释放
使用静态分析工具：检测潜在的死锁和竞态条件

十一、编译与测试流程

1. 编译驱动

# 原子操作
cd 8_atomic
make -C /path/to/kernel/source M=$(PWD) modules# 自旋锁
cd 9_spinlock
make -C /path/to/kernel/source M=$(PWD) modules# 互斥锁
cd 10_semaphore
make -C /path/to/kernel/source M=$(PWD) modules

2. 加载驱动

# 原子操作
insmod atomic.ko# 自旋锁
insmod spinlock.ko# 互斥锁
insmod semaphore.ko

3. 测试并发控制

# 编译测试程序
arm-linux-gnueabi-gcc -o atomicAPP atomicAPP.c
arm-linux-gnueabi-gcc -o spinlockAPP spinlockAPP.c
arm-linux-gnueabi-gcc -o semaphoreAPP semaphoreAPP.c# 测试原子操作
./atomicAPP /dev/gpioled 1 &  # 第一个实例
./atomicAPP /dev/gpioled 1     # 第二个实例（应失败）# 测试自旋锁
./spinlockAPP /dev/gpioled 1 &  # 第一个实例
./spinlockAPP /dev/gpioled 1    # 第二个实例（应失败）# 测试互斥锁
./semaphoreAPP /dev/gpioled 1 &  # 第一个实例
./semaphoreAPP /dev/gpioled 1    # 第二个实例（应阻塞）