在多线程与中断上下文交织的内核世界里,锁是最常见的同步原语。但它也是最致命的 Bug 源头之一。LockDep 是 Linux 内核内置的运行时死锁检测引擎,它能在开发/测试阶段以接近 0 误报率发现程序中潜在的死锁路径——即便这些路径在测试中从未被执行到。本文 LockDep 核心原理出发,结合真实的内核模块 Bug 案例,系统讲解其依赖图模型、6 大死锁场景检测、lockdep splat 报告解读方法,以及锁类注解的实战技巧。

一、为什么需要 LockDep

内核代码每天都在与自旋锁、互斥锁、读写锁打交道。一个典型的块设备驱动会涉及 request_queue、request、bdev 等多个层次的锁;网络协议栈的锁依赖链往往横跨中断处理、软中断、用户态 syscall 三个上下文。

传统调试死锁的方法——printk、gdb 单步、核心转储——统统撞墙:

  • 死锁是路径敏感的:某些组合只在特定的中断时序下才触发。
  • 死锁 Bug 具有概率性:压力测试也未必能复现。
  • 核心转储无因果关系信息:你只知道某个线程卡住了,但不知道它为什么卡住。

LockDep 的答案是:在每次真实加锁时,实时构建并验证一个“锁获取顺序图”。遍历每一条可能的前向边,检查是否形成了环。只要环形成,就当场报警。

这意味着:即使某条死锁路径在测试中从未执行,但只要锁获取顺序图中出现了矛盾(线程 A 历史上先拿 L1 再拿 L2,某处又先拿 L2 再拿 L1),LockDep 就能在矛盾产生的瞬间抓住它。

二、LockDep 的核心数据模型

2.1 Lock Class vs. Lock Instance

LockDep 跟踪的是锁类(lock class),而非单独的锁实例。所有由同一 spinlock_t 或 mutex 初始化的锁实例属于同一个锁类。

这是一个巧妙的抽象:它大幅减少图中的节点数量(一个模块里可能有上千个 mutex,但只有几个 lock class),同时又不失精度——因为死锁本质上发生在不同类之间的获取顺序上。

// 内核源码 include/linux/lockdep.h 核心结构
struct lock_class {
    struct hash_list        hash_entry;
    struct list_head        lock_entry;
    struct list_head        locks_after;   // 依赖图:此类之后需要获取的锁
    struct list_head        locks_before;  // 依赖图:此类之前已被获取的锁
    // ...
    const char              *name;          // 锁类名称
    unsigned long           key;            // 实例区分 key
};

2.2 锁链(Lock Chain)

每当线程成功获取一个锁,LockDep 就生成一个锁链,记录“当前持锁上下文下,上一次持锁的类”。锁链的核心字段:

struct lock_chain {
    u16                     depth;         // 锁链深度
    u16                     max_lockdep_depth;
    unsigned long           chain_key;     // 唯一标识这条链
    struct lock_class       *chain_hlock;  // 当前锁类
    struct lock_chain       *prev_chain;   // 前一条链
};

2.3 依赖图构建

LockDep 的依赖图是一个有向图,节点是 lock class,边是获取顺序:

  • 线程持锁 L1 时又获取了 L2 → 添加边 L1 → L2。
  • 当新的边 (A → B) 加入时,LockDep 执行从 B 出发的前向 DFS,若搜索回到 A,则说明图中出现环 → 死锁。

关键约束:边的验证是“即时”的。加锁操作会被 lockdep 记录、验证、再执行——任何顺序矛盾当场触发 splat,不会等到真正死锁时才报告。

三、六大死锁场景的检测原理

LockDep 能识别 6 大类死锁场景:

场景 1:经典 AB-BA 死锁

最常见也是最容易疏忽的。


// 模块 A
spin_lock(&lock_a);
spin_lock(&lock_b);   // A: a → b
spin_unlock(&lock_b);
spin_unlock(&lock_a);

// 模块 B
spin_lock(&lock_b);
spin_lock(&lock_a);   // B: b → a,与 A 矛盾!
spin_unlock(&lock_a);
spin_unlock(&lock_b);

当模块 B 里 spin_lock(&lock_a) 执行时,LockDep 会发现:历史上已经记录过 a → b 的关系,现在出现 b → a,图中形成环。立即 splat。

场景 2:中断上下文反转

在 process context 关中断获取的锁,若也在中断处理函数中获取,会产生 IRQ-safe 反转。


// process context
spin_lock_irqsave(&lock_outer, flags);
spin_lock(&lock_inner);
spin_unlock(&lock_inner);
spin_unlock_irqrestore(&lock_outer, flags);

// 中断处理函数
spin_lock(&lock_inner);   // 危险!
spin_lock(&lock_outer);   // LockDep 检测到反转

LockDep 将"锁 + 中断状态"视为一个维度的 lock class。当不带 _irqsave 获取的锁出现在中断上下文中时,它被标记为 hardirq-safe;一旦有人在进程上下文关中断后获取该锁,LockDep 检测到反转——因为中断可能发生在 process context 持有 lock_inner 时,同时想获取 lock_outer。

场景 3:读写锁反转(Read-Write Lock Inversion)

读写锁的特殊语义(读共享、写独占)在 lockdep 中被建模为独立的锁类。不同情景下(写→写、读→写、写→ read 递归)有不同的依赖方向。


// 线程 1: 持有写锁,又获取另一把读锁
write_lock(&rwlock_a);     // 写获得 rwlock_a
read_lock(&rwlock_b);      // 读获得 rwlock_b
// ...
write_unlock(&rwlock_a);
read_unlock(&rwlock_b);

// 线程 2:反转路径
write_lock(&rwlock_b);     // 写获得 rwlock_b
read_lock(&rwlock_a);      // 读获得 rwlock_a —— lockdep splat

LockDep 根据"写"比"读"更严格的特性,推断两条锁链的反转。

场景 4:递归死锁

同一个锁被同一线程重入两次,第二次将死锁。LockDep 通过 lock_acquire() 检查当前线程的 held_locks 链表,若目标锁类已出现在当前持有锁链中,立即触发 splat。


spin_lock(&lock_x);
spin_lock(&lock_x);   // 立即触发 recursion 警告

场景 5:调度器中的锁禁止

内核禁止在持有某些锁时主动调用 schedule()(如持有自旋锁、持有 RCU read lock 等)。LockDep 跟踪持锁时是否进入 might_sleep 上下文。


spin_lock(&lock_x);
kmalloc(GFP_KERNEL);  // 可能睡眠,LockDep splat
spin_unlock(&lock_x);

场景 6:释放顺序与初始化不一致

释放锁的顺序应该与获取的顺序相反,LockDep 确保这一点。如果释放的锁不是最近获取的锁(LIFO 顺序被破坏),或将未持有的锁释放,LockDep 均会捕获。


spin_lock(&lock_a);
spin_lock(&lock_b);
spin_unlock(&lock_a);   // 错误:应该先释放 b
spin_unlock(&lock_b);

四、真实生产级案例:多队列块设备驱动的死锁修复

下面还原一个真实的内核模块 Bug,展示 LockDep 的 splat 报告解读方法。

4.1 模块设计

一个简化的多队列字符设备驱动,包含两个层次:

  • 队列层:每个队列持有 queue_lock 保护 pending list。
  • 设备层:持有 dev_lock 管理队列集合。

struct my_dev {
    spinlock_t dev_lock;
    struct list_head queues;
};

struct my_queue {
    spinlock_t queue_lock;
    struct list_head pending;
    struct my_dev *dev;
};

// 操作 1:enqueue 数据到某个队列
void enqueue(struct my_queue *q, struct req *r)
{
    spin_lock(&q->queue_lock);
    list_add_tail(&r->list, &q->pending);
    spin_unlock(&q->queue_lock);
}

// 操作 2:设备全局 flush(遍历所有队列并处理 pending)
void flush_dev(struct my_dev *dev)
{
    struct my_queue *q;
    spin_lock(&dev->dev_lock);
    list_for_each_entry(q, &dev->queues, node) {
        spin_lock(&q->queue_lock);
        process_pending(q);   // 长时间持有
        spin_unlock(&q->queue_lock);
    }
    spin_unlock(&dev->dev_lock);
}

// 操作 3:将请求 A 从队列 1 迁移到队列 2
void migrate(struct req *r, struct my_queue *dst)
{
    spin_lock(&r->q->queue_lock);
    list_del(&r->list);
    spin_unlock(&r->q->queue_lock);

    spin_lock(&dst->queue_lock);
    list_add_tail(&r->list, &dst->pending);
    spin_unlock(&dst->queue_lock);
}

4.2 LockDep 报告

加载模块并触发 flush+migrate 并发后,LockDep 报告:


======================================================
[ INFO: possible circular locking dependency detected ]
6.8.0-rc5-lockdep #1 Not tainted
------------------------------------------------------
migration/0/15 is trying to acquire lock:
ffff8881003a50c0 (&q2->queue_lock){+.+.}-{2:2}, at: migrate+0x42/0xc0 [my_lockdep]

but task is already holding lock:
ffff8881003a4e80 (&q1->queue_lock){+.+.}-{2:2}, at: migrate+0x1a/0xc0 [my_lockdep]

which lock already depends on the other lock, and new lock would create a circular dependency.

other info that might help us debug this:

 Possible unsafe locking sequence:

       CPU0                    CPU1
       ----                    ----
  lock(&q2->queue_lock);
                               lock(&dev->dev_lock);
                               lock(&q1->queue_lock);
  lock(&dev->dev_lock);

*** DEADLOCK ***

4.3 修复方案

核心问题是 flush_dev 在持有 dev_lock 时去获取 queue_lock,而 migrate 在释放 queue_lock 后又去获取 dev_lock。两者交叉形成环。

修复方法:统一锁获取顺序——迁移操作改造为"先获取源和目标的 queue_lock,再获取 dev_lock"。


void migrate_fixed(struct req *r, struct my_queue *dst)
{
    struct my_queue *src = r->q;

    // 统一按地址顺序获取 queue_lock,避免 AB-BA
    if (src < dst) {
        spin_lock(&src->queue_lock);
        spin_lock(&dst->queue_lock);
    } else {
        spin_lock(&dst->queue_lock);
        spin_lock(&src->queue_lock);
    }

    spin_lock(&src->dev->dev_lock);

    list_del(&r->list);
    r->q = dst;
    list_add_tail(&r->list, &dst->pending);

    spin_unlock(&src->dev->dev_lock);
    spin_unlock(&dst->queue_lock);
    spin_unlock(&src->queue_lock);
}

同时在 flush_dev 中也按地址顺序遍历:


void flush_dev_fixed(struct my_dev *dev)
{
    struct my_queue *q;
    spin_lock(&dev->dev_lock);
    list_for_each_entry(q, &dev->queues, node) {
        spin_lock_nested(&q->queue_lock, SINGLE_DEPTH_NESTING);
        process_pending(q);
        spin_unlock(&q->queue_lock);
    }
    spin_unlock(&dev->dev_lock);
}

LockDep 不再 splat。

五、LockDep 选项与生产使用建议

5.1 编译期配置


CONFIG_PROVE_LOCKING=y          # 启用 LockDep
CONFIG_LOCK_STAT=y              # 锁统计信息
CONFIG_DEBUG_LOCK_API SELFTEST=y # 自测试

5.2 运行时用 sysctl 调整


# 设置 LockDep 最大锁链追踪深度(默认 48)
echo 64 > /proc/sys/lockdep_depth

# 关闭 LockDep(基准测试对比)
echo 0 > /proc/sys/lockdep

5.3 常见陷阱:虚假警告的处理

LockDep 虽强大,但偶有虚假警告。常见处理办法:

情况 处理
不同锁实例的真实属性不同(如不同层级的 mutex) 用 lockdep_set_class() 分设不同锁类
递归锁(同一锁类允许重入) 使用 mutex_lock_nested() / spin_lock_nested() 指定 subclass
已知安全但以 lockdep 无法推理的组合 lockdep_off()/lockdep_on()(慎用)

示例:为不同层级的 mutex 区分锁类:


static struct lock_class_key percpu_mutex_key;

void init_device(struct device *dev)
{
    mutex_init(&dev->lock);
    lockdep_set_class(&dev->lock, &percpu_mutex_key);
}

5.4 LockDep 的已知局限

  1. 不跟踪条件分支内的锁状态:LockDep 处理的是 history-based,每条有向边都可能被标注为依赖。
  2. 对 eBPF 内核程序的锁定跟踪基本缺失:当 BPF map spinlock 与用户态锁组合时,LockDep 无能为力。
  3. Rust 内核代码的 Mutex、SpinLock:目前通过 lockdep_set_class() 显式标注,覆盖率有限。
  4. 性能开销:LockDep 开启后,内核整体性能下降约 10%-40%,仅建议在开发/CI 环境启用。

六、LockDep 与 Rust 内核锁的整合

随着 Rust-for-Linux 的发展,Rust kernel::sync::Mutex 和 kernel::sync::SpinLock 都通过 FFI 包裹内核原生锁。LockDep 的集成使用 lockdep_set_class() 实现:


// drivers/lockdep_test.rs

use kernel::sync::Mutex;
use kernel::lock_class::LockClassKey;

static MY_LOCK_KEY: LockClassKey = LockClassKey::new();

struct MyState {
    data: Mutex<u32>,
}

impl MyState {
    fn new() -> Self {
        let mut state = MyState {
            data: Mutex::new(0, &MY_LOCK_KEY),
        };
        state
    }
}

当一个 Rust-coded 模块与 C-coded 模块发生锁反转时,LockDep 能跨语言捕获并生成包含双方栈帧的 splat 报告。LockDep 的环检测算法是语言无关的——它依赖 lock class 的唯一性。

七、总结

LockDep 是 Linux 内核提供的最强静态+动态锁分析工具,它的核心价值在于把死锁消灭在开发阶段。通过依赖图的即时环检测,程序员不必等到生产环境发生严重故障才拿到事故现场。

工程师的成长路径建议从以下三步走:

  1. 先会读 splat:拿到一份 LockDep 报告后,能定位持锁路径、区分直接冲突与反向依赖。
  2. 再会排假阳:使用 lockdep_set_class()、*_nested() 等手段区分不同属性的锁实例。
  3. 最终学会析构:在模块设计初期就规划好锁层级(例如 "dev_lock 永远在 queue_lock 之上"),并集成到 CI lockdep 自检中。

-Werror 必须死?LockDep 告诉你:带上 -Werror-lockdep。让 CI 替你守卫锁顺序。

关键 takeaway:LockDep 不是测试覆盖率的替代品,而是对锁依赖顺序的形式化证明——它追踪的是"锁获取的偏序关系"而非"代码路径的执行次数"。这种"状态空间探索"式的检测思路,是内核开发者必修课。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部