超级会员免费看
Linux内核中的原子操作与同步技术解析
在Linux内核开发中，原子操作和同步技术是确保数据一致性和并发安全的关键。本文将深入探讨RMW（Read-Modify-Write）原子操作、位掩码搜索以及读写自旋锁等重要概念和技术。
1. RMW原子操作基础
在处理设备驱动时，RMW原子操作是一项重要技术。在深入了解之前，我们需要先了解一些相关的基础概念。
1.1 架构相关的引用计数实现
不同架构的引用计数实现可能存在差异。例如，x86架构有特定的引用计数实现，而ARM架构则没有。同时，官方内核文档提供了关于 atomic_t 和 refcount_t 的详细接口信息：
- atomic_t接口 ：
- Semantics and Behavior of Atomic and Bitmask Operations
- API ref: Atomics
- refcount_t接口（4.11+版本） ：
- refcount_t API compared to atomic_t
- API reference: Reference counting
1.2 内存排序与RMW原子操作
内存排序是一个复杂的话题，它对我们的代码有着重要影响。建议阅读 Linux-Kernel Memory Model (LKMM) 以了解其基础知识。
RMW原子操作是一组更高级的原子操作，可用于执行安全且不可分割的位操作。作为设备驱动开发者，在操作设备或外设寄存器时，很可能会用到这些操作。
2. 设备寄存器操作与RMW序列
在处理设备驱动时，我们经常需要对寄存器进行位操作，以修改其值。下面我们将详细介绍如何进行这些操作。
2.1 寄存器基础知识
一个字节由8位组成，从最低有效位（LSB，位0）到最高有效位（MSB，位7）。在设备驱动中，寄存器通常是外设设备（或芯片）内的一小块内存，其位宽通常为8、16或32位。这些寄存器提供控制、状态等信息，并且通常是可编程的。
例如，假设一个虚构的设备有两个8位宽的寄存器：状态寄存器和控制寄存器。在头文件中，我们可以这样定义它们的地址：
#define REG_BASE 0x5a00
#define STATUS_REG (REG_BASE+0x0)
#define CTRL_REG (REG_BASE+0x1)
2.2 RMW序列操作
为了修改寄存器的值，我们通常采用RMW（Read-Modify-Write）序列，具体步骤如下：
1. 将寄存器的当前值读取到一个临时变量中。
2. 修改临时变量为所需的值。
3. 将临时变量的值写回到寄存器中。
以下是一个示例代码，用于打开虚构设备的某个功能：
turn_on_feature_x_dev()
{
u8 tmp;
tmp = ioread8(CTRL_REG); /* read: the current register value into tmp */
tmp |= 0x80; /* modify: set bit 7 (MSB) of tmp */
iowrite8(tmp, CTRL_REG); /* write: the new tmp value into the register */
}
然而，这种方法存在并发和数据竞争的问题。因为寄存器是全局共享的可写内存位置，如果访问它的代码路径可以并发运行，就会构成一个临界区，需要进行保护。我们可以使用自旋锁来保护这个临界区。
3. 原子操作API
Linux内核提供了一系列原子操作API，用于确保数据安全。这些API可以分为非RMW操作和RMW操作两类。
3.1 非RMW操作
包括 atomic_read() 、 atomic_set() 、 atomic_read_acquire() 、 atomic_set_release() 等。
3.2 RMW操作
RMW操作的原子操作符可以分为以下几类：
- 算术操作 ： atomic_{add,sub,inc,dec}() 、 atomic_{add,sub,inc,dec}_return{,_relaxed,_acquire,_release}() 、 atomic_fetch_{add,sub,inc,dec}{,_relaxed,_acquire,_release}()
- 位操作 ： atomic_{and,or,xor,andnot}() 、 atomic_fetch_{and,or,xor,andnot}{,_relaxed,_acquire,_release}()
- 交换操作 ： atomic_xchg{,_relaxed,_acquire,_release}() 、 atomic_cmpxchg{,_relaxed,_acquire,_release}() 、 atomic_try_cmpxchg{,_relaxed,_acquire,_release}()
- 引用计数操作 ： atomic_add_unless() 、 atomic_inc_not_zero() 、 atomic_sub_and_test() 、 atomic_dec_and_test()
- 其他操作 ： atomic_inc_and_test() 、 atomic_add_negative() 、 atomic_dec_unless_positive() 、 atomic_inc_unless_negative()
4. RMW位操作API
RMW位操作API可以更方便地进行位操作。以下是一些常见的RMW位操作原子API：
| RMW位操作原子API | 说明 |
| — | — |
| void set_bit(unsigned int nr, volatile unsigned long *p); | 原子地将 p 的第 nr 位设置为1 |
| void clear_bit(unsigned int nr, volatile unsigned long *p) | 原子地将 p 的第 nr 位清零 |
| void change_bit(unsigned int nr, volatile unsigned long *p) | 原子地翻转 p 的第 nr 位 |
| int test_and_set_bit(unsigned int nr, volatile unsigned long *p) | 原子地设置 p 的第 nr 位，并返回该位的前一个值 |
| int test_and_clear_bit(unsigned int nr, volatile unsigned long *p) | 原子地清除 p 的第 nr 位，并返回该位的前一个值 |
| int test_and_change_bit(unsigned int nr, volatile unsigned long *p) | 原子地翻转 p 的第 nr 位，并返回该位的前一个值 |
5. 使用位操作原子操作符的示例
下面是一个简单的内核模块示例，展示了如何使用Linux内核的RMW原子位操作符：
// ch13/1_rmw_atomic_bitops/rmw_atomic_bitops.c
#include <linux/spinlock.h>
#include <linux/atomic.h>
#include <linux/bitops.h>
#include "../../convenient.h"
static unsigned long mem; // the memory variable we operate upon
static u64 t1, t2;
static int MSB = BITS_PER_BYTE - 1;
DEFINE_SPINLOCK(slock);
#define SHOW_MEM(index, msg) do { \
pr_info("%2d:%27s: mem : %3ld = 0x%02lx\n", index, msg, mem, mem); \
} while (0)
static int __init atomic_rmw_bitops_init(void)
{
int i = 1, ret;
pr_info("%s: inserted\n", OURMODNAME);
SHOW_MEM(i++, "at init");
setmsb_optimal(i++);
setmsb_suboptimal(i++);
clear_bit(MSB, &mem);
SHOW_MEM(i++, "clear_bit(7,&mem)");
change_bit(MSB, &mem);
SHOW_MEM(i++, "change_bit(7,&mem)");
ret = test_and_set_bit(0, &mem);
SHOW_MEM(i++, "test_and_set_bit(0,&mem)");
pr_info(" ret = %d\n", ret);
ret = test_and_clear_bit(0, &mem);
SHOW_MEM(i++, "test_and_clear_bit(0,&mem)");
pr_info(" ret (prev value of bit 0) = %d\n", ret);
ret = test_and_change_bit(1, &mem);
SHOW_MEM(i++, "test_and_change_bit(1,&mem)");
pr_info(" ret (prev value of bit 1) = %d\n", ret);
pr_info("%2d: test_bit(%d-0,&mem):\n", i, MSB);
for (i = MSB; i >= 0; i--)
pr_info(" bit %d (0x%02lx) : %s\n", i, BIT(i), test_bit(i, &mem)?"set":"cleared");
return 0; /* success */
}
/* Set the MSB: optimally, via the set_bit() RMW atomic API */
static inline void setmsb_optimal(int i)
{
t1 = ktime_get_real_ns();
set_bit(MSB, &mem);
t2 = ktime_get_real_ns();
SHOW_MEM(i, mem, "optimal: via set_bit(7,&mem)");
SHOW_DELTA(t2, t1);
}
/* Set the MSB: the traditional way, using a spinlock to protect
* the RMW critical section */
static inline void setmsb_suboptimal(int i)
{
u8 tmp;
t1 = ktime_get_real_ns();
spin_lock(&slock);
/* critical section begins: RMW : read, modify, write */
tmp = mem;
tmp |= 0x80; // 0x80 = 1000 0000 binary
mem = tmp;
/* critical section ends */
spin_unlock(&slock);
t2 = ktime_get_real_ns();
SHOW_MEM(i, mem, "set msb suboptimal: 7,&mem");
SHOW_DELTA(t2, t1);
}
这个示例展示了使用RMW位操作原子操作符比传统方法更简单、更快速。例如，在一个x86_64 Ubuntu 23.04 VM上运行时，使用 set_bit() API只需要29纳秒，而传统方法需要125纳秒（慢了4倍多）。
6. 高效搜索位掩码
内核中提供了一些高效的API用于搜索位掩码，这在许多算法中是一个常见的操作。以下是一些常用的API：
- unsigned long find_first_bit(const unsigned long *addr, unsigned long size) ：查找内存区域中第一个设置的位，并返回该位的编号；如果没有设置的位，则返回 size 。
- unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size) ：查找内存区域中第一个清零的位，并返回该位的编号；如果没有清零的位，则返回 size 。
- 其他例程包括 find_next_bit() 、 find_next_and_bit() 、 find_last_bit() 等。
这些API可以帮助我们更高效地处理位掩码搜索，特别是在对性能敏感的代码路径中。
7. 读写自旋锁
在处理内核或驱动代码中对大型全局数据结构（如双向循环链表）的搜索时，由于数据结构是全局共享且可写的，并发访问会构成临界区，需要进行保护。
假设搜索列表是非阻塞操作，通常会使用自旋锁来保护临界区。以下是一个简单的伪代码示例：
spin_lock(mylist_lock);
for (p = &listhead; (p = next_node(p)) != &listhead; ) {
// 处理列表节点
}
spin_unlock(mylist_lock);
虽然简单的读取操作可能会让人觉得不需要加锁，但实际上，即使是对共享可写数据的读取也需要保护，以防止同时发生的写入操作导致脏读或撕裂读。
综上所述，在Linux内核开发中，合理使用RMW原子操作、位掩码搜索和读写自旋锁等技术，可以有效地提高代码的性能和并发安全性。通过本文的介绍，希望读者能够对这些技术有更深入的理解，并在实际开发中灵活运用。
Linux内核中的原子操作与同步技术解析
8. 读写自旋锁的深入分析
读写自旋锁是一种特殊的锁机制，适用于读多写少的场景。它允许多个读者同时访问共享资源，但在有写操作时，会阻止其他读写操作，以保证数据的一致性。
8.1 读写自旋锁的工作原理
读写自旋锁基于计数器实现。当有读者进入临界区时，计数器加1；读者离开时，计数器减1。当有写者进入临界区时，它会等待计数器归零，以确保没有读者正在访问资源。写者进入后，会阻止其他读写操作，直到写操作完成。
以下是一个简单的流程图，展示了读写自旋锁的工作流程：
graph TD;
A[开始] --> B{是否有写者请求};
B -- 否 --> C{是否有读者请求};
C -- 是 --> D[读者进入，计数器加1];
D --> E[读者操作];
E --> F[读者离开，计数器减1];
F --> C;
C -- 否 --> B;
B -- 是 --> G[等待计数器归零];
G --> H[写者进入，锁定资源];
H --> I[写者操作];
I --> J[写者离开，解锁资源];
J --> B;
8.2 读写自旋锁的使用示例
以下是一个简单的示例，展示了如何在代码中使用读写自旋锁：
#include <linux/rwlock.h>
rwlock_t my_rwlock;
// 初始化读写自旋锁
rwlock_init(&my_rwlock);
// 读者函数
void reader_function()
{
read_lock(&my_rwlock);
// 读取共享资源
read_unlock(&my_rwlock);
}
// 写者函数
void writer_function()
{
write_lock(&my_rwlock);
// 写入共享资源
write_unlock(&my_rwlock);
}
9. 不同同步技术的比较
在Linux内核开发中，我们有多种同步技术可供选择，如自旋锁、读写自旋锁、原子操作等。以下是它们的比较：
| 同步技术 | 适用场景 | 优点 | 缺点 |
| — | — | — | — |
| 自旋锁 | 临界区代码执行时间短，CPU资源充足 | 简单易用，开销小 | 长时间持有会导致CPU资源浪费 |
| 读写自旋锁 | 读多写少的场景 | 允许多个读者并发访问，提高读性能 | 实现复杂，写操作会阻塞其他读写操作 |
| 原子操作 | 对单个变量的操作 | 高效，无锁开销 | 只能处理简单操作，不能保护复杂数据结构 |
10. 同步技术的选择策略
在选择同步技术时，需要考虑以下因素：
1. 临界区代码执行时间 ：如果临界区代码执行时间短，可以选择自旋锁；如果执行时间长，应考虑其他锁机制。
2. 读写比例 ：读多写少的场景适合使用读写自旋锁；读写均衡或写多的场景，可能需要其他锁机制。
3. 数据结构复杂度 ：对于简单的数据结构，原子操作可能足够；对于复杂的数据结构，需要使用锁机制来保护。
以下是一个选择同步技术的决策树：
graph TD;
A[开始] --> B{临界区代码执行时间短?};
B -- 是 --> C{读写比例如何?};
C -- 读多写少 --> D[读写自旋锁];
C -- 其他 --> E[自旋锁];
B -- 否 --> F{数据结构复杂度如何?};
F -- 简单 --> G[原子操作];
F -- 复杂 --> H[其他锁机制];
11. 总结与实践建议
在Linux内核开发中，同步技术是确保数据一致性和并发安全的关键。通过合理选择和使用RMW原子操作、位掩码搜索、读写自旋锁等技术，可以提高代码的性能和可靠性。
以下是一些实践建议：
1. 优先使用原子操作 ：对于简单的变量操作，优先使用原子操作，以减少锁的开销。
2. 根据读写比例选择锁机制 ：在读多写少的场景中，使用读写自旋锁；在其他场景中，根据临界区代码执行时间和数据结构复杂度选择合适的锁机制。
3. 测试和优化 ：在实际开发中，对不同的同步技术进行测试和优化，以找到最适合的方案。
通过不断学习和实践，我们可以更好地掌握这些同步技术，编写出高效、安全的Linux内核代码。希望本文能为你在Linux内核开发中提供有价值的参考。
扫一扫
1730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
