引言

内核中的死锁是最难调试的并发问题之一。不同于用户态可以利用 Valgrind 或 TSan 等工具,内核态的竞态条件往往在极端负载或特定 CPU 交错过才会触发,复现成本极高。Lockdep(Lock Dependency Checker)是 Linux 内核内置的运行时锁验证器,它通过跟踪锁的获取顺序构建有向图,在锁获取时动态检测潜在的循环依赖,能在系统投产前就暴露设计出缺陷的锁协议。

本文从 lockdep 的底层数据结构出发,结合内核源码分析其工作原理,然后深入生产环境中典型的死锁场景、lockdep 报告解读方法、以及如何设计 lock 子系统使其通过 lockdep 验证。最后讨论 lockdep 的局限性以及当报告 false positive 时的处理策略。


一、Lockdep 核心数据结构精析

Lockdep 的核心是一个有向图,节点代表锁类(lock class),边代表锁获取顺序。与跟踪单个锁实例不同,lockdep 将语义相同(即同一 lock_class 关键字初始化)的锁归为一个锁类,这使得检测复杂度从 O(实例数²) 降为 O(类数²)。

1.1 lockdep_map 与 lock_class


// include/linux/lockdep_types.h
struct lockdep_map {
    struct lock_class_key   *key;           // 锁类的唯一标识
    struct lock_class       *class_cache[NR_LOCKDEP_BITS]; // 缓存
    const char              *name;           // 锁的名称(用于报告)
    ...
};

struct lock_class {
    struct hlist_node       hash_entry;     // 全局锁类哈希表
    struct list_head        lock_order_entries; // 已确认的获取顺序
    struct list_head        locks_after;    // 本锁之后可获取的锁
    struct list_head        locks_before;   // 本锁之前必须已持有的锁
    unsigned int            subclass;       // 子类编号(用于读写锁的不同读侧)
    ...
};

lockdep_map 是每个锁实例的元数据(嵌入在 struct mutex、struct spinlock 等内部),而 lock_class 是全局唯一的锁类对象。多个互斥锁如果共享同一个 lock_class_key,就属于同一个 lock class。

1.2 前向与反向链表

Lockdep 维护两种关系链表:

  • locks_before:在持有 A 锁期间从未获取过的锁(A→B 的边尚未建立)
  • locks_after:在持有 A 锁期间成功获取过的锁(A→B 的边已确认存在)

当内核尝试获取锁 B 时,lockdep 检查 B 是否在 A 的 locks_before 链表中。如果在,说明这是一个新发现的顺序,创建一条从前向后的边;如果 B 在 A 的 locks_after 链表中,说明是已有顺序,跳过。

1.3 六种锁模式

Lockdep 区分六种锁模式(lock_usage_bit_t):

模式 含义
LOCK_USED 任何上下文获取该锁
LOCK_USED_READ 读侧获取(rwlock/rwsem)
LOCK_USED_WRITE 写侧获取
LOCK_ENABLED_IRQ 获取时本地中断启用
LOCK_ENABLED_IRQ_READ 读侧获取时中断启用
LOCK_ENABLED_WRITE_IRQ 写侧获取时中断启用

这六种模式使 lockdep 不仅能检测 ABBA 经典死锁,还能检测 硬中断-软中断 交错导致的 A∩irq→A 死锁变体。


二、死锁图检测算法

2.1 DFS 环检测

当 lockdep 发现新的锁获取顺序 A→B 时,执行一次 DFS(深度优先搜索)以检查是否存在从 B→...→A 的路径。如果存在,则形成环,报告潜在死锁。


// kernel/locking/lockdep.c 简化逻辑
static int check_irq_usage(struct task_struct *curr, struct lockdep_map *lock,
                           unsigned long bits)
{
    // 检查是否 A(irq-safe) → A(irq-unsafe)
    // 即:同一个锁类,中断上下文中先获取,又在中断被屏蔽时获取
}

2.2 触发时机

Lockdep 的检测发生在以下时机:

  1. lock_acquire() 路径:通过 spin_lock()、mutex_lock() 等进入时
  2. 中断上下文切换:local_irq_disable() 时标记中断状态快照
  3. 软中断/Tasklet 调度:open_softirq() 登记软中断锁模式

2.3 报告结构解读

一个典型的 lockdep 报告包含以下关键段落:


[   42.123456] ======================================================
[   42.123456] POSSIBLE DEADLOCK
[   42.123456] ======================================================
[   42.123456] [ INFO: possible circular locking dependency detected ]
[   42.123456] 6.8.0-rc3-lockdep #1 Not tainted
[   42.123456] ------------------------------------------------------
[   42.123456] kworker/0:1H/145 is trying to acquire lock:
[   42.123456] ffff88810023c5a0 (&mydev->data_lock){+.+.}-{2:2}, at: process_request+0x3f/0x110 [my_driver]
[   42.123456]                but task is already holding:
[   42.123456] ffff88810023c540 (&mydev->ctrl_lock){+.+.}-{2:2}, at: handle_ctrl+0x2a/0xc0 [my_driver]
[   42.123456]
[   42.123456]                which lock already depends on the new lock.
...
[   42.123456] 2 locks held by kworker/0/145:
[   42.123456]  #0: ffff88810023c540 (&mydev->ctrl_lock){+.+.}-{2:2}, at: handle_ctrl+0x2a/0xc0
[   42.123456]  #1: ...
[   42.123456]
[   42.123456] stack backtrace:
[   42.123456] CPU: 0 PID: 145 Comm: kworker/0:1H

解读顺序:

  • 第1行:当前要获取的锁(data_lock)和代码位置
  • 第2行:已经持有的锁(ctrl_lock)和代码位置
  • 第3行-结尾:完整的环形依赖链(反向追踪,展示 data_lock → ctrl_lock → data_lock 的完整路径)

三、生产环境经典死锁场景

3.1 场景一:设备驱动中的双锁逆序

某 NVMe 控制器在初始化路径中执行 ctrl_lock → queue_lock,而在 I/O 完成路径中执行 queue_lock → ctrl_lock。这种经典的 ABBA 死锁在 lockdep 配合压力测试时被立即捕获。

解决方案:重构初始化路径,将需要同时持有两锁的逻辑改为临界区内部不触发 I/O 完成回调;或者在获取 queue_lock 时使用 mutex_trylock() 配合回退路径。


// 修改后:统一的获取顺序
int safe_submit_io(struct nvme_dev *dev, struct io_request *req)
{
    // 统一规则:ctrl 锁总是先于 queue 锁
    mutex_lock(&dev->ctrl_lock);
    spin_lock(&dev->queue_lock);
    // ...
    spin_unlock(&dev->queue_lock);
    mutex_unlock(&dev->ctrl_lock);
}

3.2 场景二:中断处理函数中遺忘了 irq save

某网络设备驱动在 hardirq 上下文中获取 rx_lock,同时在 NAPI poll 中(软中断上下文)也获取 rx_lock,但后者未使用 spin_lock_irqsave()。当硬中断在已持有 rx_lock 的线程上触发,试图获取同一锁时导致(lockdep视角)A(irq)→A死锁报告。


static int __init my_driver_init(void)
{
    // 中断处理内:spin_lock(&rx_lock) — 此时 hardirq 自动标记
    // NAPI poll 内:spin_lock(&rx_lock) — 没有 irq 标记
    // Lockdep 报告: rx_lock 既被标记为 irq 安全又被标记为 irq 不安全
}

修复方法是:NAPI poll 中也使用 spin_lock_irq() 或确保该锁在中断禁用区内获取。

3.3 场景三:回调链中的隐藏递归

文件系统路径中,ext4 的日志提交(journal_lock)可能触发页分配,页分配在内存压力下可能回写,回写可能再次获取文件系统某元数据锁形成 元数据锁 → journal_lock → 内存锁 → 元数据锁 的四元环。

Lockdep 能通过追踪 lockdep_map 的递归深度发现此类问题。对于必须跨层释放/重入的场景,使用 lock_nest_lock() 或 mutex_lock_nested() 显式声明嵌套子类:


// 使用嵌套子类避免 false positive
mutex_lock_nested(&fs_info->nested_mutex, SUBCLASS_FS_RECOVERY);

四、Lockdep 的局限性与 False Positive 处理

4.1 局限性清单

局限性 说明
不检测数据竞争 lockdep 只关注锁顺序,不检查 guard 变量的原子性
依赖正确标注 spin_lock_init() 时需正确设置 lock_class
性能开销 启用时每条锁获取路径增加约 50-100 个 CPU 周期
不覆盖 RCU 读侧锁 RCU 读侧不参与 lockdep 检测
跨进程不跟踪 用户态 futex 等不纳入
raw_spin_lock 不纳入 使用 raw variant 时绕过 lockdep

4.2 False Positive 识别

False positive 通常由以下原因导致:

  1. 锁的"语义同一但条件分岔":如一个互斥锁在热路径和中断上下文中共享,但实际这两种上下文从不交叉
  2. 条件编译路径差异:某些锁只在 DEBUG 模式下使用
  3. SDK/API 隐藏回调:第三方驱动的 probe/remove 在不预期的时间点调用我们的锁
  4. 嵌套深度超限:lockdep 默认最多跟踪 48 层嵌套,超出部分被标记为 unreliable

4.3 绕过策略


// 方法1:标记为"BABABA"式设计确实安全的情况
lockdep_set_notrace_class(&my_special_lock); // 不再参与检测

// 方法2:使用 lockdep_map_novalidate()(极少使用,等同放弃保护)
void lockdep_map_novalidate(struct lockdep_map *lock);

// 方法3:正确做法——通过 lockdep_init_map() 为不同用途分配不同 key
static DEFINE_MUTEX(ctrl_lock);    // key A
static DEFINE_MUTEX(ctrl_lock_x);  // key B — 同类型但不同用途

强烈建议:lockdep_set_notrace_class() 是最后手段。大多数"false positives"实际上是真正的锁协议缺陷在特定路径下才会暴露。


五、高级用法:自定义 Lockdep 规则验证

5.1 lockdep_assert_held 系列

编码期断言锁状态:


void update_stats(struct device *dev)
{
    lockdep_assert_held(&dev->stat_lock);  // 编译时若未持锁,直接 BUG_ON
    // ...
}

这不同于 WARN_ON(!mutex_is_locked(...)):

  • lockdep_assert_held():lockdep 开启时等价于 WARN_ON(),关闭时编译为空操作(零开销)
  • WARN_ON(!mutex_is_locked(...)):始终产生运行时检查开销

5.2 自定义锁类管理器

对于动态数量的锁(如连接池中的每连接锁),使用 lockdep_register_key() / lockdep_unregister_key() 管理全局 key:


struct conn_pool {
    spinlock_t locks[MAX_CONNS];        // 锁实例
    struct lockdep_map dep_maps[MAX_CONNS]; // 每个实例独立的 dep_map
    struct lock_class_key *keys[MAX_CONNS]; // 运行时分配 key
};

int conn_pool_init(struct conn_pool *pool)
{
    for (int i = 0; i < MAX_CONNS; i++) {
        pool->keys[i] = kzalloc(sizeof(struct lock_class_key), GFP_KERNEL);
        if (!pool->keys[i]) return -ENOMEM;
        lockdep_register_key(pool->keys[i]);
        spin_lock_init(&pool->locks[i]);
        lockdep_init_map(&pool->dep_maps[i], "conn_lock", pool->keys[i], 0);
    }
}

这确保每个连接锁拥有独立的 lock class,lockdep 能精确检测每对锁的顺序违规。

5.3 Lockdep 统计接口

通过 /proc/lockdep_stats 和 /proc/lockdep_chains 运行时查询 lockdep 的内部状态:


# 查看锁类数量、深度链最大长度
cat /proc/lockdep

# 查看具体的锁链关系
grep -A 5 "type:" /proc/lockdep_chains

# 运行时临时禁用(危险!)
echo 0 > /proc/sys/kernel/lockoff

六、Lockdep 与 Lockstat 的协同

Lockdep(依赖检测)与 Lockstat(竞争统计)互补:

维度 Lockdep Lockstat
检测目标 潜在死锁(future risk) 现实争用(current contention)
开销 中(每条锁路径 ~100ns) 高(每条锁路径 ~500ns)
实现 有向图 + DFS 每个锁实例的计数器
适用阶段 开发/集成测试 性能回归测试
开启方式 CONFIG_LOCKDEP=y CONFIG_LOCK_STAT=y

最佳实践:开发阶段全量启用 lockdep,集成测试阶段启用 lockstat 定位热点。生产环境两者都关闭——它们是为诊断而设计的,不适合长期在生产运行。


七、Lockstat 数据解读示例


# echo 1 > /proc/sys/kernel/lock_stat
# <执行测试负载>
# cat /proc/lock_stat

class name: &zone->lock
con-bounces: 15234      ← 被抢占次数,高值提示该锁是热点
contentions:   892     ← 获取时已被持有的次数
waittime-min:   12 ns  ← 最小等待时间
waittime-max: 1523 µs  ← 最大等待时间(说明偶尔严重争用)
waittime-total:  2.34 s
acq-bounces:   423

判断准则:con-bounces 超过 contentions 的 10 倍,通常意味着该锁保护的临界区过细或持有时间过长,需要拆分或改用 rcu 读侧优化。


八、总结:Lockdep 驱动的锁设计原则

  1. 锁协议优先于实现:在画架构图时就标注锁获取顺序,并用 lockdep_assert_held() 编码期验证
  2. 子类优于重写:对于语义相同但层次不同的嵌套锁,使用 *_nested() 而非 lockdep_set_notrace_class()
  3. 锁命名的可读性:lockdep_init_map(&lock, "dev->ctrl_lock", key) 中的 name 字段会出现在死锁报告中——请用心起名
  4. 早检测早迭代:lockdep 检测到死锁时,系统尚未真正卡死,此时修复成本极低;等真实环境出现冻结再定位,成本放大百倍
  5. 不迷信 false positive:90% 的 false positive 经深入排查后为真实缺陷,只是触发条件在测试中未被合成

Lockdep 作为 Linux 内核最有价值的调试子系统之一,其"运行时验证+设计时断言"的双重模式,为内核开发者提供了一种独特的锁安全网。掌握其原理与高级用法,是从"能写并发代码"到"能设计并发协议"的关键一步。


参考资料:

  • kernel/locking/lockdep.c(Linux 6.8 内核源码)
  • Documentation/locking/lockdep-design.rst (内核文档)
  • "Lock ordering in the Linux kernel: A lockdep approach" (LWN.net)

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部