引言

如果你在 NVMe SSD 上跑过 fio 基准测试,可能会注意到一个奇怪的现象:单进程顺序读写能达到 3GB/s,但开启多进程并发后,总吞吐量几乎没有提升,反而延迟急剧抖动。这不是硬件的问题——而是 Linux 内核传统块层(Block Layer)架构的锅。

在 NVMe SSD 时代,单盘 IOPS 轻松突破 50万,延迟低至 10μs。然而,传统的单队列块层设计(Legacy Block Layer)使用一个全局 request_queue 自旋锁,在 16 核甚至 32 核服务器上,这把锁的争用成为灾难性的瓶颈。

blk-mq(Multi-Queue Block Layer)正是为解决这个问题而生。它从 Linux 3.13(2014 年)开始引入,到 5.x 时代完全成熟,成为内核 I/O 路径上最重要的架构变革之一。

本文将深入 blk-mq 的架构设计、核心数据结构、与 NVMe 驱动的协同机制、io_uring 集成路径,以及生产环境性能调优的实战经验。


一、传统单队列块层:锁争用的泥潭

1.1 Legacy Block Layer 的工作方式

传统块层使用"生产者-消费者"模型。每个块设备有一个全局请求队列(struct request_queue),所有 CPU 核心通过 blk_queue_bio() 将 bio 结构体提交到同一个队列中。

核心问题在于队列锁:


// 简化示意:传统块层的队列操作
spin_lock_irqsave(&q->queue_lock, flags);
elv_merge(q, &rq, bio);     // 尝试与已有请求合并
spin_unlock_irqrestore(&q->queue_lock, flags);

在 32 核机器上,32 个 CPU 同时执行这段代码时,queue_lock 的争用导致核心时间消耗在自旋等待上。

1.2 量化问题

我们用一个简单模型来估算锁争用开销。假设每次锁持有时长为 $t_{hold}$,请求到达率为 $\lambda$ 次/秒,那么自旋锁的平均等待时间为:

$$t_{wait} \approx \frac{\lambda \cdot t_{hold}^2}{2(1 - \rho)}$$

其中 $\rho = \lambda \cdot t_{hold}$ 是利用率。当 $\rho$ 接近 1 时(高 IOPS 场景),等待时间趋向无穷。

实测数据:在 Intel P4800X NVMe SSD 上,单队列模式 16 核并发随机读 IOPS 约 180k,而 blk-mq 模式下可达 520k,提升接近 3 倍。


二、blk-mq 架构设计:分而治之

2.1 核心设计思想

blk-mq 的关键设计是引入两级队列映射:

  1. 软件队列(Software Staging Queue):每个 CPU(或 NUMA 节点)一个队列,用于缓冲来自用户态的 I/O 请求
  2. 硬件队列(Hardware Dispatch Queue):与硬件实际并行能力对齐的提交队列,映射到 NVMe SQ(Submission Queue)

                    ┌─────────────┐
                    │  用户态 I/O  │
                    └──────┬──────┘
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │ CPU 0 SWQ│ │ CPU 1 SWQ│ │ CPU 2 SWQ│  ← 软件队列(每个 CPU 一个)
        └────┬─────┘ └────┬─────┘ └────┬─────┘
             │            │            │
             └────────────┼────────────┘
                          ▼
                   ┌─────────────┐
                   │ 调度与合并层  │  (可选:mq-deadline/bfq)
                   └──────┬──────┘
                          │
              ┌───────────┼───────────┐
              ▼           ▼           ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │ HW Queue0│ │ HW Queue1│ │ HW Queue2│  ← 硬件队列(per-NUMA)
        └────┬─────┘ └────┬─────┘ └────┬─────┘
             │            │            │
             └────────────┼───────────┘
                          ▼
                   ┌─────────────┐
                   │  NVMe SSD   │
                   └─────────────┘

2.2 关键数据结构

blk-mq 的核心是 struct blk_mq_tag_set,它定义了队列的拓扑和标签管理:


struct blk_mq_tag_set {
    const struct blk_mq_ops *ops;       // 操作函数表(queue_rq、complete_rq等)
    unsigned int            nr_maps;    // 队列映射表数量(通常1或2)
    unsigned int            *nr_hw_queues;  // 每个 map 的硬件队列数
    unsigned int            queue_depth;    // 每个队列的深度
    unsigned int            numa_node;      // NUMA 节点亲和性
    void                    *driver_data;   // 驱动私有数据
    struct blk_mq_queue_map *queue_maps;    // CPU→HW Queue 映射表
    struct blk_mq_tags     **tags;          // 标签集合(用于 request 分配)
};

blk_mq_ops 是设备驱动必须实现的操作函数表:


struct blk_mq_ops {
    blk_status_t (*queue_rq)(struct blk_mq_hw_ctx *hcb,
                            const struct blk_mq_queue_data *bd);
    void (*complete_rq)(struct request *rq);
    void (*commit_rqs)(struct blk_mq_hw_ctx *hcb);
    bool (*poll_rq)(struct request *rq);
    int (*init_hctx)(struct blk_mq_hw_ctx *hctx, void *driver_data,
                     unsigned int hctx_idx);
    int (*init_request)(struct blk_mq_tag_set *set, struct request *rq,
                        unsigned int hctx_idx, unsigned int numa_node);
};

2.3 队列映射策略

blk-mq 提供两种队列映射方式:

blk_mq_queue_map(线性映射):最简单的 CPU→HW Queue 映射,适用于大多数场景:


// 初始化队列映射
blk_mq_queue_map_queues(&tag_set->map[0], 0, nr_hw_queues);

// 映射逻辑(简化)
hw_queue = cpu % nr_hw_queues;  // 线性取模

blk_mq_pci_map_queues(PCIe 设备 NUMA 感知映射):考虑 PCIe 设备与 NUMA 节点的亲和性,减少跨 NUMA 访问:


blk_mq_pci_map_queues(&tag_set->map[0], pdev, 0);

// 映射逻辑(简化)
hw_queue = pci_device_numa_node_affinity(cpu);

正确选择映射策略对性能至关重要。对于连接在 NUMA node 0 PCIe 总线上的 NVMe SSD,应该将硬件队列绑定到 node 0 的 CPU 上。


三、Request 生命周期与标签管理

3.1 请求分配

blk-mq 使用"标签"机制来唯一标识每个请求。标签本质上是一个连续整数索引,用于在硬件中匹配完成通知。


// 在硬件队列上下文中分配 request
static inline struct request *blk_mq_alloc_request(struct request_queue *q,
                                                    unsigned int op,
                                                    blk_mq_req_flags_t flags)
{
    struct blk_mq_alloc_data data = { .q = q, .flags = flags };
    struct request *rq;
    
    rq = __blk_mq_alloc_request(&data);
    if (rq) {
        rq->cmd_flags = op;
        rq->q = q;
    }
    return rq;
}

3.2 提交路径

提交路径是 blk-mq 的热路径(hot path),核心函数是 blk_mq_submit_bio()(Linux 5.9+)和 blk_mq_make_request()(更早版本):


// 简化后的提交流程
blk_status_t blk_mq_submit_bio(struct bio *bio)
{
    // 1. 确定硬件队列(通过映射表)
    blk_mq_hw_ctx *hctx = queue_ctx_from_map(bio->bi_disk, bio);
    
    // 2. 在软件队列中插入/合并
    spin_lock(&hctx->lock);
    blk_bio_plug_add(hctx, bio);  // 先加入 plug 延迟合并
    spin_unlock(&hctx->lock);
    
    // 3. 触发提交(plug flush 或立即提交)
    blk_mq_flush_plug_list(hctx);
}

3.3 完成路径与硬中断

blk-mq 的完成路径设计为支持 MSI-X 中断的并行处理。每个硬件队列可以关联到不同的中断向量:


// NVMe 驱动中的 CQE 完成处理
static void nvme_pci_complete_rq(struct request *req)
{
    struct nvme_queue *nvmeq = req->end_io_data;
    
    // 更新完成计数器(写入 CQ doorbell)
    writel(nvmeq->cq_tail, nvmeq->cq_db);
    
    // 释放 request 回标签池
    blk_mq_free_request(req);
}

四、NVMe 驱动与 blk-mq 的深度集成

4.1 队列深度与 MSI-X

NVMe 协议允许每个 SQ/CQ 最多 64K 条目(实际受限于 MSI-X 向量数和 CQ 大小 NVMe 字段)。现代 NVMe 控制器通常支持 128-256 个 MSI-X 向量。


// NVMe 队列配置示例
static int nvme_setup_io_queues(struct nvme_dev *dev)
{
    int nr_io_queues;
    
    // 队列数量 = min(MSI-X 向量数 - 1, CPU 核心数)
    nr_io_queues = num_possible_cpus();
    if (dev->max_qid - 1 < nr_io_queues)
        nr_io_queues = dev->max_qid - 1;
    
    // 设置 tag_set
    dev->tagset.nr_hw_queues = nr_io_queues;
    dev->tagset.queue_depth = NVME_AQ_DEPTH;  // 通常 128-1024
    
    blk_mq_alloc_tag_set(&dev->tagset);
}

4.2 中断合并(Interrupt Coalescing)

NVMe 硬件支持自适应中断合并(Adaptive Coalescing),blk-mq 层可以通过 blk_mq_poll 实现混合轮询模式:


// blk-mq poll 机制
bool blk_mq_poll(struct request_queue *q, blk_qc_t cookie)
{
    struct blk_mq_hw_ctx *hctx = q->queue_hw_ctx[cookie.hctx_idx];
    
    // 检查硬件队列 CQ 是否有新的完成条目
    return hctx->tags->rqs[cookie.tag]->state == MQ_RQ_COMPLETE;
}

Linux 5.1+ 引入了 io_poll syscall 和轮询模式,能在空闲时降低延迟,在高负载时保持 CPU 亲和力。

4.3 Polled Mode 深度解析

对于延迟敏感型应用(如 SPDK),NVMe 驱动支持 Polled Mode,完全绕过硬件中断:


// 将 NVMe 队列配置为 Poll 模式
static int nvme_poll_irqdisable(struct nvme_queue *nvmeq)
{
    // 禁用 MSI-X 中断
    disable_irq(pci_irq_vector(nvmeq->dev->pci_dev, nvmeq->cq_vector));
    
    // 轮询检查 CQ
    while (nvme_cq_pending(nvmeq)) {
        nvme_process_cq(nvmeq);
    }
}

Polled Mode 的核心权衡是 CPU 利用率:100% 轮询一个核心换取稳定低延迟(< 5μs),而中断模式引入的延迟抖动通常在 10-50μs 之间。


五、io_uring 与 blk-mq 的协同

5.1 io_uring 固定缓冲区 + 直通块设备

io_uring 的 IOSQE_FIXED_FILE + IORING_OP_READ/WRITE 可以直接作用于块设备文件(如 /dev/nvme0n1)。当配置了 IORING_SETUP_SQPOLL 时,内核侧轮询线程绕过系统调用,直接调用 blk_mq_submit_bio:


// io_uring 直接 I/O 路径(简化)
static int io_read_write(struct io_kiocb *req, unsigned int issue_flags)
{
    struct file *file = req->file;
    
    if (file->f_op->submit_bio) {
        // 块设备文件:直接走 submit_bio
        return io_do_block_direct(req);
    } else {
        // 普通文件:走 page cache
        return io_buffered_rw(req);
    }
}

5.2 uring_cmd:绕过块层直达 NVMe

Linux 5.18+ 引入 uring_cmd,允许驱动注册自定义 io_uring 命令。NVMe 驱动通过 nvme_uring_cmd 实现绕过块层的直通访问:


// 用户态代码示例
struct nvme_user_io cmd = {
    .opcode  = nvme_cmd_write,
    .slba    = offset / 512,
    .length  = (len / 512) - 1,
    .addr    = (__u64)buf,
};

sqe = io_uring_get_sqe(&ring);
io_uring_prep_uring_cmd(sqe, NVME_URING_CMD_IO, 
                         (void *)&cmd, sizeof(cmd), 0);
sqe->fd = open("/dev/nvme0n1", O_RDWR);
io_uring_submit(&ring);

这种方式避免了 bio 层开销,直接操作 NVMe SQ/CQ doorbell,理论上能将延迟降到硬件最低水平。


六、I/O 调度器:mq-deadline、BFQ 与 Kyber

6.1 多队列调度器的设计约束

在 blk-mq 中,每个硬件队列有独立的调度上下文。传统 CFQ 调度器被彻底废弃,因为它依赖单一公平队列(fairness queue),与多队列架构不兼容。

6.2 三种调度器对比

调度器 算法 适用场景 性能特征
mq-deadline 过期时间+批量合并 通用、数据库 简单高效,延迟可控
BFQ 预算公平队列 桌面、交互式 保证公平性,吞吐略低
Kyber 目标延迟反馈调节 NVMe 低延迟 极简设计,自适应吞吐/延迟

6.3 Kyber 深度分析

Kyber 调度器采用两阶段设计,核心思想是根据当前延迟动态调整批次大小:


// Kyber 延迟控制逻辑
static void kyber_timer_fn(struct timer_list *t)
{
    struct kybe_cpu_latency *kl = container_of(t, ...);
    
    // 测量当前 I/O 完成延迟
    u64 latency = ktime_get_ns() - kl->target_start;
    
    // 如果延迟 > 目标值,减小批次(降低吞吐)
    if (latency > kl->target_latency) {
        kl->cur_batch = max(1, kl->cur_batch / 2);
    } else {
        // 延迟良好,增大批次(提高吞吐)
        kl->cur_batch = min(MAX_BATCH, kl->cur_batch * 2);
    }
}

Kyber 的优势在于:

  • 代码量仅约 800 行(vs BFQ 的 8000+ 行)
  • 几乎无锁设计(per-cpu 状态)
  • 自动在吞吐和延迟间取得平衡

七、生产环境性能调优实战

7.1 队列参数调优


# 查看当前块设备队列参数
cat /sys/block/nvme0n1/queue/nr_requests       # 硬件队列深度
cat /sys/block/nvme0n1/queue/nr_hw_queues       # 硬件队列数量
cat /sys/block/nvme0n1/queue/io_poll            # 是否启用轮询
cat /sys/block/nvme0n1/queue/io_poll_delay      # 轮询延迟策略

# 优化 NVMe 数据库场景
echo 0 > /sys/block/nvme0n1/queue/add_random     # 禁用 entropy 贡献
echo 2 > /sys/block/nvme0n1/queue/rq_affinity     # 完成在提交 CPU
echo 128 > /sys/block/nvme0n1/queue/nr_requests   # 减小队列深度避免 bufferbloat
echo none > /sys/block/nvme0n1/queue/scheduler    # NVMe 设备禁用调度器

7.2 CPU 隔离与中断亲和性


# 查看 NVMe 中断分布
cat /proc/interrupts | grep nvme

# 将 MSI-X 中断绑定到特定 CPU(避免跨 NUMA)
echo 2 > /procirq/XX/smp_affinity

# 隔离核心 + iothread 绑定
# GRUB: isolcpus=4-7 nohz_full=4-7 rcu_nocbs=4-7

# 使用 taskset 绑定 fio 进程到设备本地 NUMA
taskset -c 4-7 fio --name=randread --ioengine=io_uring \
  --filename=/dev/nvme0n1 --rw=randread --bs=4k --iodepth=256

7.3 监控与诊断


# 使用 blktrace + blkparse 分析 I/O 模式
blktrace -d /dev/nvme0n1 -o trace -w 10
blkparse -i trace.blktrace.0 | head -100

# 使用 bpftrace 跟踪 blk_mq 提交延迟
bpftrace -e '
kprobe:blk_mq_start_request {
    @start[tid] = nsecs;
}
kprobe:blk_mq_end_request {
    @lat_us = hist((nsecs - @start[tid]) / 1000);
    delete(@start[tid]);
}'

# 查看 NVMe 控制器状态
nvme smart-log /dev/nvme0n1
nvme error-log /dev/nvme0n1

八、未来演进方向

8.1 ublk:用户态块设备

Linux 6.0+ 引入 ublk(userspace block device),将块设备的控制平面和完全移至用户态。ublk 后端通过 io_uring 与内核通信,将 I/O 请求提交到用户态处理:


内核态                    用户态
┌─────────┐    io_uring    ┌──────────┐
│ ublk drv│ ──────────────▶│ ublk ser │ (用户态块设备后端)
│ (1000行)│ ◀──────────────┤ (C++/Rust)│
└─────────┘    CQ entries  └──────────┘
  • Ceph RBD、NFS-over-ublk 等方案正在快速发展
  • 相比 FUSE,ublk 只移除了约 3-5% 的额外开销

8.2 Flexible Buffers(IORing Passthrough)

Linux 6.1+ 引入 IORING_CMD_FIXED + 硬件直通,允许 SCSI/NVMe 等驱动将 io_uring 提交队列直接映射到硬件 doorbell,实现完全零拷贝、零系统调用的 I/O 路径。


九、总结

blk-mq 多队列块层是 Linux 内核为适应高速存储设备而做出的关键架构变革。掌握它的核心原理和调优方法,对于构建高性能存储系统、数据库引擎、缓存系统至关重要。

关键要点总结:

  1. 架构设计:两级队列映射将软中断、硬件中断、NUMA 亲和性有机结合
  2. 性能关键路径:sofrware staging queue(无锁/每CPU)→ hardware dispatch queue(MSI-X 并行)
  3. io_uring 协同:固定缓冲区 + polling + uring_cmd 三条路径降低延迟
  4. 调度器选择:NVMe 场景优先 Kyber/mq-deadline,必要时禁用
  5. 生产调优:CPU 隔离 + NUMA 绑定 + 队列深度控制 + 监控体系

blk-mq 的演进也反映了一个更广泛的趋势:内核正在从"通用但保守"向"专用但极致"的方向演进,而用户态 I/O(io_uring、SPDK、ublk)正在不断蚕食传统内核路径的地盘。


*本文基于 Linux 6.1+ 内核源代码分析,实验环境:AMD EPYC 7763 + Samsung PM9A3 NVMe SSD。*

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部