在多线程与中断上下文交织的内核世界里,锁是最常见的同步原语。但它也是最致命的 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 的已知局限
- 不跟踪条件分支内的锁状态:LockDep 处理的是 history-based,每条有向边都可能被标注为依赖。
- 对 eBPF 内核程序的锁定跟踪基本缺失:当 BPF map spinlock 与用户态锁组合时,LockDep 无能为力。
- Rust 内核代码的
Mutex、SpinLock:目前通过lockdep_set_class()显式标注,覆盖率有限。 - 性能开销: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 内核提供的最强静态+动态锁分析工具,它的核心价值在于把死锁消灭在开发阶段。通过依赖图的即时环检测,程序员不必等到生产环境发生严重故障才拿到事故现场。
工程师的成长路径建议从以下三步走:
- 先会读 splat:拿到一份 LockDep 报告后,能定位持锁路径、区分直接冲突与反向依赖。
- 再会排假阳:使用
lockdep_set_class()、*_nested()等手段区分不同属性的锁实例。 - 最终学会析构:在模块设计初期就规划好锁层级(例如 "dev_lock 永远在 queue_lock 之上"),并集成到 CI lockdep 自检中。
-Werror 必须死?LockDep 告诉你:带上 -Werror-lockdep。让 CI 替你守卫锁顺序。
关键 takeaway:LockDep 不是测试覆盖率的替代品,而是对锁依赖顺序的形式化证明——它追踪的是"锁获取的偏序关系"而非"代码路径的执行次数"。这种"状态空间探索"式的检测思路,是内核开发者必修课。

发表评论 取消回复