嵌入式 Linux 与 RTOS / 系统课时

处理并发同步与等待队列

处理并发同步与等待队列

设备驱动里的竞态往往不是“锁没加够”,而是锁用错了上下文。本节从能否睡眠出发选择 mutex、spinlock、atomic 与 wait queue,并用一个定时器模拟异步事件,建立“更新条件—唤醒—重新检查”的可靠等待路径。

学习目标

  • 根据进程上下文与原子上下文判断 mutex、spinlock 和 atomic 的适用边界
  • 正确使用 wait queue 让线程休眠等待条件,而不是忙轮询
  • 识别锁顺序、睡眠边界和唤醒条件中的常见竞态

先用上下文判断锁

Linux 驱动里最先要问的不是“共享变量用什么锁”,而是当前路径能不能睡眠。进程上下文通常可以睡眠;硬中断、softirq、tasklet、定时器回调等原子上下文不能调用可能调度出去的接口。

工具 是否可能睡眠 适合保护什么 典型边界
mutex 是 进程上下文中的较长临界区、配置状态 不能在硬中断、softirq、定时器回调中持有
spinlock 否 原子上下文与进程上下文都访问的短临界区 临界区内不能睡眠,必须尽快释放
atomic_t 否 独立计数器、简单标志 不能替代多个字段之间的不变量保护
wait queue 等待者会睡眠 “条件未满足就休眠,满足后再运行” 它不是锁,仍需单独保护共享状态

如果同一份数据既在进程上下文访问,又会在中断或 softirq 路径访问,常见做法是在两侧都用 spin_lock_irqsave() 保护短临界区。若数据只在可睡眠的进程上下文访问,优先考虑 mutex,避免无谓占用 CPU。

进程上下文与原子上下文的同步工具选择

把等待队列当作条件等待

wait queue 的关键不是“有人调用了 wake_up_interruptible()”,而是等待者始终围绕一个可重复检查的条件工作。推荐写成 wait_event_interruptible(queue, condition):条件为假时线程休眠,被唤醒后再次检查,条件仍为假就继续睡。

更新共享状态时,应先让新状态对等待者可见,再唤醒队列。不要把 wake_up_interruptible() 当成事件本身;如果没有可检查的状态,唤醒可能发生在等待之前,随后线程会永久睡下。

用软中断生产事件并唤醒线程

下面的完整模块用内核定时器模拟异步事件。定时器回调运行在不可睡眠的上下文中,用 spinlock 更新 pending;内核线程在 wait queue 上休眠,醒来后取走一个事件。stopping 是独立停止标志,使用 atomic_t 即可。

c
#include <linux/atomic.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/jiffies.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/wait.h>

static DECLARE_WAIT_QUEUE_HEAD(event_wq);
static DEFINE_SPINLOCK(event_lock);
static atomic_t stopping = ATOMIC_INIT(0);
static struct task_struct *worker;
static struct timer_list producer_timer;
static unsigned int pending;

static bool event_available(void)
{
    unsigned long flags;
    bool ready;

    spin_lock_irqsave(&event_lock, flags);
    ready = pending > 0;
    spin_unlock_irqrestore(&event_lock, flags);
    return ready;
}

static void producer_fn(struct timer_list *timer)
{
    unsigned long flags;

    if (atomic_read(&stopping))
        return;

    spin_lock_irqsave(&event_lock, flags);
    pending++;
    spin_unlock_irqrestore(&event_lock, flags);

    wake_up_interruptible(&event_wq);
    if (!atomic_read(&stopping))
        mod_timer(&producer_timer, jiffies + HZ);
}

static int worker_fn(void *data)
{
    while (!kthread_should_stop()) {
        unsigned long flags;
        int ret;

        ret = wait_event_interruptible(
            event_wq,
            atomic_read(&stopping) || event_available());
        if (ret)
            continue;
        if (atomic_read(&stopping))
            break;

        spin_lock_irqsave(&event_lock, flags);
        if (pending > 0)
            pending--;
        spin_unlock_irqrestore(&event_lock, flags);

        pr_info("sync_wait_demo: processed event\n");
    }
    return 0;
}

static int __init sync_wait_demo_init(void)
{
    timer_setup(&producer_timer, producer_fn, 0);
    worker = kthread_run(worker_fn, NULL, "sync_wait_worker");
    if (IS_ERR(worker))
        return PTR_ERR(worker);

    mod_timer(&producer_timer, jiffies + HZ / 2);
    pr_info("sync_wait_demo: loaded\n");
    return 0;
}

static void __exit sync_wait_demo_exit(void)
{
    atomic_set(&stopping, 1);
    del_timer_sync(&producer_timer);
    wake_up_interruptible(&event_wq);
    kthread_stop(worker);
    pr_info("sync_wait_demo: unloaded\n");
}

module_init(sync_wait_demo_init);
module_exit(sync_wait_demo_exit);
MODULE_LICENSE("GPL");

把源码保存为 sync_wait_demo.c,同目录创建 Kbuild 文件:

makefile
obj-m += sync_wait_demo.o

在已经安装当前内核头文件的测试机上构建并运行:

bash
make -s -C /lib/modules/$(uname -r)/build M="$PWD" modules
echo "build ok"
sudo insmod sync_wait_demo.ko
sleep 3
sudo rmmod sync_wait_demo
sudo dmesg | grep sync_wait_demo | tail -n 8

预期输出至少包含以下关键行;processed event 的重复次数会随实际调度略有不同。

text
build ok
sync_wait_demo: loaded
sync_wait_demo: processed event
sync_wait_demo: unloaded

排查竞态、死锁与忙轮询

看到偶发卡死时,先检查是否在持有 spinlock 时调用了 copy_to_user()、kmalloc(..., GFP_KERNEL)、mutex_lock() 等可能睡眠的路径;这类错误不是性能问题,而是上下文违规。看到 CPU 占用异常时,再检查是否用 while (!ready) cpu_relax(); 之类轮询代替了 wait queue。

死锁通常来自锁顺序不一致。若路径 A 按“锁 X→锁 Y”获取,而路径 B 按“锁 Y→锁 X”获取,就存在环形等待风险。驱动中应固定全局锁顺序,并缩短临界区,不在持锁期间调用不可控的外部回调。

最后确认等待条件和唤醒顺序:先更新条件,再释放保护该条件的锁,最后唤醒等待者。这样 wait queue 只负责睡眠与唤醒,mutex、spinlock 或 atomic 各自负责状态一致性,职责不会混在一起。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

处理并发同步与等待队列

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通