4. 自旋锁的使用与陷阱：spin_lock/spin_unlock、中断上下文中的自旋锁、IRQ与BH锁

自旋锁（Spinlock）是 Linux 内核中最基础的锁机制之一，设计用于保护短临界区。与互斥锁不同，自旋锁在锁被持有时，等待线程不会睡眠，而是持续“自旋”检查锁状态。这种忙等行为在单核或抢占式内核中会引发严重问题，尤其是在中断上下文中使用时，稍有不慎就会导致死锁或系统挂起。

4.1 spin_lock / spin_unlock 基础用法

自旋锁的核心 API 围绕 spinlock_t 类型展开。标准使用模式如下：

#include <linux/spinlock.h>

spinlock_t my_lock;

// 静态初始化
DEFINE_SPINLOCK(my_lock);

// 动态初始化
void init_module(void) {
    spin_lock_init(&my_lock);
}

// 临界区
void my_function(void) {
    unsigned long flags;

    spin_lock_irqsave(&my_lock, flags);  // 保存中断状态并获取锁
    // ... 受保护的共享数据操作 ...
    spin_unlock_irqrestore(&my_lock, flags); // 恢复中断状态并释放锁
}

4.2 中断上下文中的自旋锁陷阱

当中断处理程序（ISR）与进程上下文共享自旋锁时，必须防止“中断处理程序在锁被持有时抢占进程上下文”。下图展示了经典死锁场景：

解决方案：在中断上下文中访问共享锁时，必须使用 spin_lock_irqsave() 在进程上下文中关闭本地 CPU 中断，确保中断处理程序不会在锁持有期间被调度。

// 正确的做法：进程上下文中关闭中断
void process_context_func(void) {
    unsigned long flags;
    spin_lock_irqsave(&my_lock, flags);
    // 此时本地 CPU 中断被关闭，ISR 不会抢占
    shared_data++;
    spin_unlock_irqrestore(&my_lock, flags);
}

// 中断处理程序：只需普通 spin_lock（因为中断已关闭）
irqreturn_t my_isr(int irq, void *dev_id) {
    spin_lock(&my_lock);
    // 操作共享数据
    spin_unlock(&my_lock);
    return IRQ_HANDLED;
}

4.3 IRQ 锁与 BH 锁的区别

Linux 内核将中断处理分为上半部（Hard IRQ）和下半部（Soft IRQ / Tasklet / Workqueue）。自旋锁 API 针对不同中断层级提供了细粒度控制：

4.4 自旋锁使用陷阱清单

以下是驱动开发中常见的自旋锁错误，每个都可能导致死锁或数据损坏：

4.5 自旋锁与抢占的关系

自旋锁的实现与内核抢占密切相关。在抢占式内核（CONFIG_PREEMPT）中，spin_lock() 会隐式调用 preempt_disable()，防止当前任务被抢占。这意味着：

• 持有自旋锁时，当前 CPU 不会发生进程切换。这是自旋锁能保护数据的关键——锁持有者不会被其他进程抢占。
• 中断仍然可以发生。即使抢占被禁用，硬件中断仍会触发。这就是为什么中断上下文需要额外的 irqsave 保护。
• 在单核 CPU 上，spin_lock() 退化为 preempt_disable() + 内存屏障，没有真正的自旋等待。

// spin_lock() 在抢占式内核中的简化实现（概念性）
static inline void spin_lock(spinlock_t *lock) {
    preempt_disable();          // 禁止抢占
    if (unlikely(!raw_spin_trylock(lock))) {
        // 自旋等待直到获取锁
        while (!raw_spin_trylock(lock)) {
            cpu_relax();        // 告诉 CPU 我们在自旋等待
        }
    }
}

4.6 实战：编写安全的自旋锁驱动代码

以下是一个完整的中断共享自旋锁示例，展示了正确的上下文处理：

#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>

static spinlock_t my_lock;
static int shared_counter = 0;

// 硬中断处理程序
static irqreturn_t my_irq_handler(int irq, void *dev_id) {
    // 中断上下文：使用 spin_lock（因为进程上下文已关闭中断）
    spin_lock(&my_lock);
    shared_counter++;
    spin_unlock(&my_lock);
    return IRQ_HANDLED;
}

// 进程上下文函数
static void process_work(void) {
    unsigned long flags;

    // 保存中断状态并获取锁
    spin_lock_irqsave(&my_lock, flags);
    shared_counter += 10;
    // 此时本地 CPU 中断关闭，ISR 不会执行
    spin_unlock_irqrestore(&my_lock, flags);
}

// 软中断（Tasklet）上下文
static void my_tasklet_func(unsigned long data) {
    // 软中断上下文：使用 spin_lock_bh 防止其他软中断抢占
    spin_lock_bh(&my_lock);
    shared_counter += 5;
    spin_unlock_bh(&my_lock);
}

static int __init my_driver_init(void) {
    spin_lock_init(&my_lock);
    // 注册中断、初始化 tasklet 等
    return 0;
}

module_init(my_driver_init);

上述代码遵循了以下安全原则：

1. 进程上下文使用 spin_lock_irqsave()，确保硬中断不会在锁持有期间抢占。
2. 硬中断上下文使用 spin_lock()，因为进程上下文已经关闭了中断，不会发生竞争。
3. 软中断上下文使用 spin_lock_bh()，防止其他软中断实例同时执行。
4. 所有 API 严格配对，没有混用 _irqsave 和 _irqrestore 以外的组合。