标签: NVMe

  • 深入 Linux IO 栈陷阱排查:ext4 jbd2 屏障阻塞引发的 NVMe 队列挂起与 MySQL 抖动实战

    NVMe SSD 时代,数据库 IO 瓶颈往往不在硬件,而在内核 IO 栈的锁与同步机制。排查表明,ext4 的 jbd2 日志线程在提交事务时触发的全盘 Flush/FUA 屏障,会导致底层 blk-mq 硬件队列短暂挂起,引发 MySQL fsync 延迟飙升及 D 状态风暴。本文通过关闭易失性缓存、切换 none 调度器并压平脏页水位,将 99 线延迟从 250ms 压回 2ms 以内。

    故障现场:明明 IOPS 富裕,MySQL 却大面积卡顿

    近期在处理一个高并发支付核心库的性能问题时,遇到一个极其典型的 IO 栈陷阱。 环境为 CentOS 8 Stream,内核 5.15.0,文件系统 ext4,底层挂载企业级 NVMe SSD,MySQL 版本 8.0.32

    症状表现: 压测期间,数据库 QPS 偶尔从 25k 骤降到 500,Load Average 瞬间飙升到 150+。 通过 iostat -x 1 观察,发现磁盘 %util 只有 15% 左右,IOPS 甚至不到 2万(这块 NVMe 标称 50万 IOPS),但是 w_await(写等待时间)却经常出现 200ms 以上的尖刺。

    抓取现场 D 状态进程栈(echo w > /proc/sysrq-trigger 或查阅 dmesg),满屏都是 MySQL 的 page cleaner 线程和业务写入线程卡在内核态:

    [<0>] blk_execute_rq+0x5c/0x100
    [<0>] blkdev_issue_flush+0x6d/0xb0
    [<0>] ext4_sync_file+0x187/0x360 [ext4]
    [<0>] vfs_fsync_range+0x49/0x80
    [<0>] do_fsync+0x3d/0x70
    

    同时,内核的 ext4 日志提交线程 jbd2 也处于阻塞状态:

    [<0>] blk_execute_rq+0x5c/0x100
    [<0>] jbd2_journal_commit_transaction+0x18e5/0x1f00 [jbd2]
    [<0>] kjournald2+0xb5/0x260 [jbd2]
    

    为什么极速的 NVMe 也会被 jbd2 拖垮?

    很多开发甚至运维都有一个误区:只要换上 NVMe,IO 问题就迎刃而解。但这忽视了 Linux IO 栈的屏障(Barrier)机制。

    默认情况下,ext4 采用 data=ordered 日志模式。为了保证崩溃一致性(Crash Consistency),jbd2 内核线程每隔几秒或在满足一定条件时,会将内存中的元数据和数据写入磁盘的 Journal 区。 为确保这些写入真正落盘而不是停留在 SSD 的 DRAM 缓存中,jbd2 会向下层 block layer 发送带有 REQ_OP_FLUSHREQ_FUA(Force Unit Access)标志的 BIO。

    当这个 Flush 请求到达 blk-mq(多队列块层)时,灾难开始了。

    1. 块层会暂停当前块设备所有常规 IO 的下发,必须等待 Flush 完成。

    2. NVMe 控制器收到 Flush 指令后,需要将其内部易失性缓存(Volatile Write Cache, VWC)中的脏数据全部刷入 NAND Flash。

    3. 如果此时系统中有大量碎片化的脏页堆积,或者 SSD 的 GC(垃圾回收)任务正好触发,这个 Flush 操作可能耗时几十甚至上百毫秒。

    4. 在这上百毫秒内,整个 /dev/nvme0n1 队列被“冻结”。MySQL 的 Redo log 发起的 fsync() 全部阻塞,直接导致 TPS 暴跌,连接数堆积。

    深度排查:bpftrace 抓取幽灵延迟

    为了拿到实锤数据,我们直接用 bpftrace 追踪 jbd2_journal_commit_transaction 的耗时分布:

    bpftrace -e '
    kprobe:jbd2_journal_commit_transaction {
        @start[tid] = nsecs;
    }
    kretprobe:jbd2_journal_commit_transaction /@start[tid]/ {
        @ns = hist((nsecs - @start[tid]) / 1000000); 
        delete(@start[tid]);
    }
    '
    

    运行 5 分钟后的输出直方图(单位:毫秒):

    @ns: 
    [2, 4)                 12 |@@                                                 |
    [4, 8)                 45 |@@@@@@@@                                           |
    [8, 16)                89 |@@@@@@@@@@@@@@@@                                   |
    [16, 32)              156 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@                     |
    [32, 64)              201 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@            |
    [64, 128)              54 |@@@@@@@@@                                          |
    [128, 256)             12 |@@                                                 |
    [256, 512)              3 |                                                   |
    

    可以看到,大量 jbd2 提交耗时超过了 32ms,极端情况甚至达到了 256ms 以上,这在 NVMe 盘上是绝对不可接受的。

    核心调优与防御性配置

    面对这种内核级的锁竞争与队列挂起,一味调整 MySQL 的 innodb_io_capacity 是徒劳的。必须从 Linux IO 栈自底向上进行防御性加固。

    1. 禁用物理盘易失性缓存(绕过 Flush 屏障)

    前提条件: 你的 NVMe 必须是企业级 SSD,自带掉电保护电容(PLP – Power Loss Protection),或者服务器挂接了可靠的 BBU(电池备份单元)。

    既然硬件保证了掉电不丢数据,我们就不需要内核一遍遍地发 Flush 指令。 老版本的内核可以通过 mount 参数 nobarrier 来禁用屏障,但在 4.19+ 及 5.x 内核中,ext4 的 nobarrier 参数实际上已被废弃并忽略。现代内核的做法是直接关闭底层块设备的 write cache 特性,内核探测到设备没有缓存,就不会再下发 REQ_OP_FLUSH

    对于 NVMe,使用 nvme-cli 直接修改控制器特性:

    # 查看当前 VWC 状态
    nvme get-feature /dev/nvme0 -f 0x6
    
    # 禁用 Volatile Write Cache
    nvme set-feature /dev/nvme0 -f 0x6 -v 0x0
    
    # 通知内核重新校验设备
    echo 1 > /sys/block/nvme0n1/device/rescan
    

    执行后,再次用 bpftrace 观察,jbd2 提交延迟会断崖式下降到 1-2ms 内。

    2. 剥离无用的软件调度器(blk-mq 优化)

    很多系统默认给 NVMe 分配了 mq-deadlinebfq 调度器。对于具备极高并发处理能力且没有磁头寻道开销的 NVMe 来说,软件层的电梯算法纯属多此一举,还会引入额外的 spinlock 竞争。

    立即切到 none 调度器:

    # 实时生效
    echo none > /sys/block/nvme0n1/queue/scheduler
    
    # 持久化(通过 udev 规则,确保重启不丢)
    cat << 'EOF' > /etc/udev/rules.d/60-io-scheduler.rules
    ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/scheduler}="none"
    EOF
    udevadm control --reload-rules && udevadm trigger
    

    3. 启用 ext4 快速提交(Fast Commit)

    如果是较新的内核( >= 5.10 )和 e2fsprogs,强烈建议开启 ext4 的 fast_commit 特性。它通过精简元数据日志的格式,大幅减少了 jbd2 提交时的写入量。

    # 需在 unmount 状态下执行
    tune2fs -O fast_commit /dev/nvme0n1p1
    

    挂载后,可通过 dumpe2fs 确认是否生效。配合 MySQL 这样大量执行 fsync 的应用,fast_commit 可以带来 15%~20% 的吞吐提升。

    4. 压平 VM 脏页水位

    不要让系统的脏页堆积到触发全局同步刷盘的地步,这会加剧 IO 队列深度突刺。 修改 /etc/sysctl.conf

    # 后台异步刷盘阈值压低到 5%(默认 10%)
    vm.dirty_background_ratio = 5
    # 进程同步阻塞刷盘阈值压低到 10%(默认 20%)
    vm.dirty_ratio = 10
    # 缩短脏页老化时间到 5秒(默认 30秒)
    vm.dirty_expire_centisecs = 500
    

    执行 sysctl -p 生效。通过让内核高频、小批量地刷脏,避免 jbd2 或后台 flusher 线程一次性将底层 IO 队列打满。

    常见问题

    Q1:如果是 XFS 文件系统,也会有类似 jbd2 的日志阻塞问题吗? XFS 同样有日志提交流程(xfsaild 线程)。但 XFS 采用延迟日志(Delayed Logging)机制,且支持多 Allocation Group (AG) 并发,锁竞争粒度比 ext4 小得多。在极高并发的数据库场景,XFS 的表现通常更平稳,这也是为什么绝大多数现代 DB 推荐使用 XFS 的原因。不过,如果硬件 VWC 未关闭,XFS 发出的 Flush 依然会导致 NVMe 队列阻塞。

    Q2:数据库改用 io_uring 能绕过这个底层 Flush 瓶颈吗? 不能。io_uring 解决的是系统调用开销(User to Kernel 的 SQE/CQE 环形队列)和线程阻塞问题。但当请求进入到块层(Block Layer),如果发生 Flush 屏障,底层硬件队列 hctx 依然会暂停。即使内核 worker 线程不阻塞用户态应用,IO 仍会积压在环形队列中,最终表现为请求超时。

    Q3:云上的块存储(如 AWS EBS / 阿里云 ESSD)需要禁用 Write Cache 吗? 云盘通常由后端的分布式存储集群(如 Ceph/盘古)保障多副本和持久化。对于 Guest OS 而言,很多云平台会在虚拟化层忽略前端发来的 REQ_FLUSH,因为只要写入成功即代表落盘。但这取决于具体云厂商的实现。实践中,建议查阅云厂商文档,若支持,依然建议在 OS 层面直接把块设备的调度器改为 none,避免宿主机和虚拟机两层排队。

  • 深入 XFS 日志阻塞排查:高并发小文件写入引发的 NVMe IO Stall 与 blk-mq 调度瓶颈实战

    针对 NVMe 盘在高并发小文件(Metadata 密集型)写入场景下出现的 iowait 飙升与进程 D 状态堆积问题,核心原因是 XFS 默认 logbsize 过小导致高频元数据刷盘(xfsaild 锁竞争),叠加底层 blk-mq 错误使用 mq-deadline 调度器引发的自旋锁开销。通过挂载参数调优 logbsize=256k,logbufs=8 并将 NVMe 调度器改为 none,可直接将 IO 99线延迟从 800ms 压降至 2ms 以内。

    案发现场:Load 飙升与幽灵般的 D 状态

    排查过程中接到告警,某核心图片处理集群(Kernel 5.10, XFS v5)的 Load Average 突然飙升至节点 CPU 核数的 3 倍以上。业务反馈接口响应超时,API Gateway 层面大量 503。

    登录机器,第一反应看 iostat。结果非常反直觉:

    $ iostat -dxm 1
    Device:         rrqm/s   wrqm/s     r/s     w/s    rMB/s    wMB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
    nvme0n1           0.00     0.00    0.00 8540.00     0.00    35.20     8.44   124.50   14.50    0.00   14.50   0.12 100.00
    

    磁盘 %util 打满 100%,写入 IOPS w/s 仅为 8500 左右,吞吐量 wMB/s 才 35MB/s。对于一块企业级 NVMe SSD 来说,这个负载连热身都算不上(标称 IOPS 在 40万+),但 await 已经涨到了 14.5ms,甚至偶发飙到数百毫秒。

    抓取当前处于 D(Disk Sleep)状态的进程,直接看内核调用栈:

    $ for i in $(ps -eo pid,state | awk '$2=="D"{print $1}'); do cat /proc/$i/stack; echo "-----"; done
    [<0>] xfs_log_force_lsn+0x2d1/0x3a0 [xfs]
    [<0>] xfs_bmap_extents_to_btree+0x2a2/0x7c0 [xfs]
    [<0>] xfs_bmapi_write+0x3ab/0x650 [xfs]
    [<0>] xfs_iomap_write_direct+0x1eb/0x290 [xfs]
    [<0>] iomap_apply+0x11b/0x270
    ...
    

    大量进程阻塞在 xfs_log_force_lsn。这意味着业务虽然在写数据,但实际上是被文件系统的 Journal(日志)同步刷盘机制卡住了。

    为什么超高性能的 NVMe 会被 XFS 日志拖死?

    XFS 是一种强一致性的日志文件系统。为了保证 Crash Consistency,任何对元数据(Metadata,如修改文件大小、分配新 Block、修改时间戳)的更改,都必须先写入日志(Journal),然后才能落盘到实际的设备位置。

    在这个业务场景中,大量并发写入 KB 级别的小文件,引发了海量的 Block Allocation(块分配)操作,导致元数据剧烈变化。

    默认情况下,XFS 的内存日志缓冲区大小(logbsize)为 32KB。当并发小文件写入极度密集时,这个 32KB 的 Buffer 瞬间就被填满。一旦填满,XFS 的 CIL(Committed Item List)机制就会被强制触发同步刷盘(Log Force)。 更致命的是,日志写入是串行的。成百上千个并发线程在等待这 32KB 的日志落盘,底层 NVMe 的并发优势被文件系统层的全局自旋锁(Spinlock)和同步等待队列彻底抹平。

    可以通过 xfs_info 查看当前挂载的日志参数:

    $ xfs_info /data
    meta-data=/dev/nvme0n1           isize=512    agcount=32, agsize=30517961 blks
             =                       sectsz=4096  attr=2, projid32bit=1
             =                       crc=1        finobt=1, sparse=1, rmapbt=0
             =                       reflink=1    bigtime=0 inobtcount=0
    data     =                       bsize=4096   blocks=976574768, imaxpct=25
             =                       sunit=0      swidth=0 blks
    naming   =version 2              bsize=4096   ascii-ci=0, ftype=1
    log      =internal log           bsize=4096   blocks=476843, version=2
             =                       sectsz=4096  sunit=1 blks, lazy-count=1
    realtime =none                   extsz=4096   blocks=0, rtextents=0
    

    要缓解日志锁竞争,必须放大缓冲,降低刷盘频率。

    深入块设备层:blk-mq 调度器的额外损耗

    除了文件系统,底层的 IO 调度器也在这里扮演了“反面角色”。 通过检查 NVMe 设备的调度器配置:

    $ cat /sys/block/nvme0n1/queue/scheduler
    [mq-deadline] kyber bfq none
    

    系统默认使用了 mq-deadline。这是针对传统 SATA/SAS SSD 优化的多队列调度器,它试图在软件层对 IO 请求进行合并(Merge)和排序,以保证请求不会饿死。

    但在纯 NVMe 环境下,NVMe 硬件控制器本身已经具备了极深的金字塔形硬件队列(通常有 64K 个队列,每个队列深 64K)。在极高的并发下,mq-deadline 在内核态维护软件队列的自旋锁开销,反而成了多核 CPU 下的严重瓶颈。

    我们通过 perf 抓取内核热点:

    $ perf top -F 99 -e cpu-clock
    

    可以看到 blk_mq_sched_insert_requestssbitmap_get 占据了大量的 CPU 周期,这全是调度器无谓的锁开销。

    解决方案与性能对撞

    既然定位到了两个层面的阻塞,解法就非常明确了:降低 XFS 元数据刷盘频率,卸载块设备的软件调度开销。

    1. 调整 XFS 挂载参数

    将日志缓冲区大小直接拉到最大限制 256KB,并增加缓冲数量到 8 个(默认 8 个,无需显式改但推荐确认)。开启 noatime 避免读取时引发元数据更新。

    # 在 /etc/fstab 中修改挂载参数,或在线 remount
    $ mount -o remount,noatime,logbsize=256k,logbufs=8 /data
    

    2. 更改 NVMe 调度器为 none

    彻底旁路 IO 调度器,将请求直接打入 NVMe 硬件队列:

    $ echo none > /sys/block/nvme0n1/queue/scheduler
    

    注:为了持久化,建议写入 udev rule,例如 /etc/udev/rules.d/60-io-scheduler.rules ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/scheduler}="none"

    优化效果对比

    应用上述两步操作后,业务请求无缝恢复,再次观察 iostat

    Device:         rrqm/s   wrqm/s     r/s     w/s    rMB/s    wMB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
    nvme0n1           0.00     0.00    0.00 42500.00    0.00   285.20    13.74     1.50    0.03    0.00    0.03   0.01  38.50
    
    • IOPS 直接冲上 4.2万(业务并发量完全释放)。

    • 吞吐量达到 285 MB/s。

    • await 从 14.5ms 暴降至 0.03ms

    • %util 回落到 38.5% 的健康水位。 D 状态进程彻底消失。

    常见问题

    Q1:ext4 是否存在类似的日志瓶颈?如何排查? 存在。ext4 的日志由 jbd2 内核线程负责。在高并发小IO下,若经常看到 jbd2/nvme0n1-8 占用 100% 单核 CPU,或者大量进程阻塞在 wait_transaction_locked,即为典型的 ext4 日志瓶颈。可通过挂载参数 data=writeback 降低日志开销(牺牲部分数据安全性),或将日志放在独立的外部极速设备上(mke2fs -O journal_dev)。

    Q2:如果业务已经在使用 io_uring,还会被 XFS 的日志锁阻塞吗? 会。io_uring 解决的是系统调用(Syscall)开销和 Block 层的异步投递问题,但文件系统层的元数据操作(尤其是文件大小扩展、分配新块)如果在内核中必须走同步的 Log Force,io_uring 也会回退到慢速路径(Worker Thread)。为了让 io_uring 彻底发挥性能,建议使用预分配(fallocate)锁定空间,使后续的写操作变为纯粹的覆写(Overwrite),从而彻底避开元数据更新。

    Q3:如何动态观测 XFS 日志的写入频率和延迟? 可以使用 BCC (eBPF) 工具集中的 xfsdistxfsslower 工具。 执行 xfsslower 1,如果屏幕上疯狂打印出 xfs_log_force 的调用堆栈且延迟 > 1ms,就足以说明当前系统的 IO 瓶颈不在介质本身,而在于文件系统的日志同步机制。

  • 深入 NVMe 队列阻塞排查:blk-mq 调度器误用引发的 XFS 元数据锁雪崩与 sys CPU 饱和实战

    高并发写入场景下,NVMe 盘配合 XFS 极易触发 sys CPU 满载与 IO 夯死。核心原因是 NVMe 误用了 mq-deadline 调度器,导致 blk-mq 软件队列自旋锁争用,进而引发 XFS 分配元数据时在 xfs_log_commit_cil 处发生锁雪崩。直接结论:NVMe 设备的 IO 调度器必须设为 none,同时对于高并发盘,需在格式化时调大 XFS 的 agcount 以打散锁粒度。

    故障现场:数据库写入 p99 突增与 sys CPU 飙升

    某次排查过程中,一套承载核心业务的 PostgreSQL 集群(内核版本 5.10.134-el8,底层存储为裸金属物理机的 PCIe Gen4 NVMe SSD)在高并发 COPY 导入数据时,QPS 出现周期性断崖式下跌。

    通过 top 观察,CPU sys 态长期飙升至 70% 以上,iowait 反而在 10% 左右波动。这极不寻常——对于一块标称 100万 IOPS 的 NVMe 盘,IO 没有跑满,CPU 却在内核态被榨干。

    抓取当时的 iostat -x 1 核心指标:

    Device:         r/s     w/s     rkB/s     wkB/s   rrqm/s   wrqm/s  %rrqm  %wrqm r_await w_await aqu-sz rareq-sz wareq-sz  svctm  %util
    nvme0n1        12.0 42351.0     192.0  680512.0     0.0     0.0    0.0    0.0    0.15   18.42   12.5   16.00    16.06   0.02  85.40
    

    注意 w_await 达到了惊人的 18.42ms,对于 NVMe 来说,这个延迟意味着底层已经严重阻塞。但 %util 只有 85%,设备并未完全饱和。

    使用 perf top -U 直接看内核态热点,现场如下:

      18.45%  [kernel]  [k] queued_spin_lock_slowpath
      12.31%  [kernel]  [k] dd_insert_requests
       8.52%  [kernel]  [k] xfs_log_commit_cil
       6.14%  [kernel]  [k] blk_mq_submit_bio
       5.33%  [kernel]  [k] _raw_spin_lock_irqsave
    

    热点非常集中:dd_insert_requestsxfs_log_commit_cil。这表明系统同时在块设备调度层和文件系统日志提交层发生了严重的锁争用。

    为什么 NVMe 设备使用 mq-deadline 会导致 IO 栈雪崩?

    问题出在 Linux blk-mq(Block Multi-Queue)架构的调度器选择上。

    在传统的单队列(Single Queue)时代,所有 IO 请求进入一个全局队列,需要 CFQ 或 Deadline 这种电梯算法(Elevator)进行合并和排序,以减少机械硬盘的磁头寻道。

    到了 NVMe 时代,硬件支持多达 64K 个提交/完成队列。Linux 为此重构了 blk-mq 架构,分为软件队列(Software Staging Queues,通常每个 CPU 核心一个)和硬件分发队列(Hardware Dispatch Queues)。

    排查发现,该服务器的 NVMe 被默认配置了 mq-deadline 调度器:

    $ cat /sys/block/nvme0n1/queue/scheduler
    [mq-deadline] kyber bfq none
    

    底层阻塞原理: 当调度器设置为 mq-deadline(甚至 bfq)时,IO 请求在进入硬件队列前,必须先挂载到电梯算法的软件队列中。dd_insert_requests 就是 mq-deadline 插入请求的内核函数。由于高并发下成千上万个线程试图向这个软件队列提交 BIO(Block I/O),这就不可避免地触发了自旋锁(queued_spin_lock_slowpath)。 NVMe 的纳秒级响应速度完全被软件队列的自旋锁开销抹平,导致 CPU 在 sys 态空转,IO 提交路径被硬生生卡住。

    剥茧抽丝:XFS 延迟分配与 AIL/CIL 阻塞

    块设备的延迟飙升,迅速引发了文件系统层的连锁反应,这也是为什么 perf 中出现了大量 xfs_log_commit_cil

    XFS 是一种强依赖 Allocation Group(AG)并发设计的日志文件系统(当前版本 V5)。当数据库执行大量写入时,XFS 会利用延迟分配(Delayed Allocation)机制,在内存中缓存数据,直到刷盘时才真正分配物理 Block 并更新元数据。

    1. CIL(Committed Item List)雪崩:元数据变更首先写入内存中的 CIL。当底层 NVMe 因为 mq-deadline 阻塞时,后台刷脏线程(xfsaild)将 AIL(Active Item List)刷入磁盘的速度骤降。

    2. AG 锁争用:CIL 空间被占满,前端业务线程在调用 xfs_alloc_vextent 申请新的空间块时,必须等待日志空间释放。大量 PostgreSQL 线程被迫在同一个 AG 的元数据锁上排队。

    3. 全局夯死:IO 栈的阻塞放大了 XFS 的锁临界区时间,最终导致原本并行的 IO 瀑布般退化为串行等待,形成死锁态势的雪崩。

    解决方案与防御性配置

    解决该问题不需要修改业务代码,纯属系统级架构调优,分为治标和治本两步。

    1. 立即剥离软件调度器(实时恢复)

    将 NVMe 设备的调度器强行切换为 none,绕过所有电梯算法,让 BIO 请求直接从软件多队列打入硬件队列。

    echo none > /sys/block/nvme0n1/queue/scheduler
    

    执行瞬间,sys CPU 从 70% 骤降至 8%,PostgreSQL QPS 恢复正常,w_await 回落至 0.05ms。

    为了防止重启失效,通过 udev 固化防御策略:

    # vim /etc/udev/rules.d/60-io-scheduler.rules
    ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/scheduler}="none"
    

    2. XFS AG 并发度调优(底层重构)

    默认情况下,mkfs.xfs 根据磁盘大小自动计算 agcount(通常是 4 或 8)。对于大容量、极高吞吐的 NVMe 盘和数据库场景,默认 AG 数量太少,容易发生并发分配碰撞。 在节点下线重装阶段,调整格式化参数,人为扩大 AG 数量打散锁粒度:

    # 格式化 XFS:强制启用 32 个 AG,对齐 512M 日志大小
    mkfs.xfs -f -K -d agcount=32 -l size=512m,version=2,su=256k /dev/nvme0n1
    

    注:agcount 并非越大越好,过大会增加 mount 时间和内存开销,通常 16-32 针对高端 NVMe 是甜点区间。

    常见问题

    Q1: io_uring 在遇到这种 XFS 锁争用时,会退化成同步阻塞吗? 会。这是很多人使用 io_uring 踩坑的地方。虽然 io_uring 是异步 IO,但如果在文件系统层发生 metadata 锁争用(比如 XFS 分配 block),底层的 IORING_OP_WRITE 且带有 RWF_NOWAIT 标志位时,内核会直接返回 -EAGAIN。随后 io_uring 只能将这个 IO 任务推入后台的 io_worker 线程池进行同步阻塞处理,纯异步链路被击穿,高并发下依然会导致线程池耗尽。

    Q2: 调度器设置为 none 后,系统还有 IO 合并能力吗? 有,但发生在不同层级。none 确实禁用了电梯算法层的合并,但 blk-mq 在软件队列层(Software Staging Queue)和块设备硬件驱动层依然会利用 scatter-gather list 进行有限的相邻物理段合并。对于 NVMe 而言,本身 4K 随机 IO 的性能极高,强行进行复杂的 IO 合并排序带来的 CPU 锁开销远大于其收益。

    Q3: 如何在生产环境无损监控 XFS 的 AG 锁争用情况? 极力推荐使用 eBPF/bpftrace 而不是 SystemTap。可以通过挂载 tracepoint 实时监控 CIL 提交延迟:

    bpftrace -e 'tracepoint:xfs:xfs_log_commit_cil { @start[tid] = nsecs; } tracepoint:xfs:xfs_log_commit_cil_wait { if(@start[tid]) { @usecs = hist((nsecs - @start[tid]) / 1000); delete(@start[tid]); } }'
    

    如果输出的直方图显示大量调用耗时超过 1000 微秒(1ms),说明文件系统日志提交已出现严重积压,需立即排查底层块设备延迟。

  • 深入 NVMe IO 延迟雪崩排查:默认调度器误用引发的 blk-mq 锁争用与软中断打满实战

    某次核心分布式 KV 存储集群进行底层硬件换代,全面升级至 Gen4 NVMe SSD。本以为硬件红利能让 IO 性能起飞,结果压测一上,QPS 刚到 8 万,99线(p99 latency)就开始周期性从 2ms 剧烈抖动到 300ms 以上。Load Average 狂飙至机器核数的两倍,大量写入线程陷入 D 状态(Uninterruptible Sleep)。 一句话交代结论:这是一起典型的“旧时代运维习惯毒害新硬件”的事故。系统镜像中遗留的 udev 规则将 NVMe 设备的 IO 调度器默认设置成了 mq-deadline。在极高并发下,这个多余的软件调度层在内核 blk-mq(块设备多队列)中引发了极其严重的自旋锁争用(Spinlock Contention),直接打满 ksoftirqd 软中断,导致 IO 请求在 OS 提交队列里排队,根本没送进物理磁盘。 解决方式极其简单:echo none > /sys/block/nvme0n1/queue/scheduler

    案发现场与指标拆解

    排查过程中,第一直觉是新批次的 NVMe 盘存在固件缺陷或发生了 GC(垃圾回收)拥塞。习惯性敲下 iostat -xz 1,看到的数据却极为诡异:

    Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
    nvme0n1           0.00    12.00  340.00 45000.00  5440.00 720000.00    32.00   145.50  180.20    1.50  182.10   0.01  15.20%
    

    注意看这几个核心指标的矛盾点:

    1. %util 只有 15.20%:说明磁盘底层的物理带宽和 IOPS 根本没跑满,处于极度饥饿状态。

    2. svctm(服务时间)仅为 0.01ms:说明盘的物理响应极快,一旦请求交到硬件手里,瞬间就能处理完。

    3. w_await 高达 182.10ms,avgqu-sz(平均队列长度)达到 145.5:请求虽然处理得快,但排队时间长得离谱。

    这说明一个铁打的事实:IO 根本没有卡在硬件设备上,而是卡在了 Linux 内核的 IO 栈里。

    为了抓现行,直接祭出 perf top 观察内核态的 CPU 热点,结果满屏红彤彤的自旋锁:

      18.45%  [kernel]       [k] native_queued_spin_lock_slowpath
      12.30%  [kernel]       [k] blk_mq_sched_insert_request
       9.15%  [kernel]       [k] sbitmap_get
       7.20%  [kernel]       [k] dd_insert_requests
    

    再看 CPU 状态,top 显示多核的 si(软中断)飙升,对应的进程全是 ksoftirqd/x

    愚蠢的配置与底层原理解析

    走到这一步,根因已经水落石出:dd_insert_requests 这个函数的出现,意味着系统正在使用 mq-deadline IO 调度器。

    查看设备的调度器配置,果不其然:

    $ cat /sys/block/nvme0n1/queue/scheduler
    [mq-deadline] kyber bfq none
    

    为什么在 NVMe 上用 mq-deadline 是不可原谅的低级错误?

    在 SATA/SAS 机械硬盘时代,磁盘只有一个硬件队列(Queue Depth 通常只有 32 或 256)。为了防止磁头剧烈寻道,Linux 内核设计了 IO 调度器(如 Deadline、CFQ)在软件层面对 IO 请求进行合并(Merge)和重排(Sort)。 但在 NVMe 时代,协议原生支持多达 64K 个硬件队列(Submission/Completion Queues),每个队列深度可达 64K。Linux 内核为此重构了 blk-mq(Block Multi-Queue)架构,将 CPU Core 与 NVMe 硬件队列直接建立映射关系(Software Queue -> Hardware Dispatch Queue)。

    如果在 NVMe 上强行开启 mq-deadlinebfq,相当于在原本宽阔的双向 64 车道高速公路上,硬生生设了一个收费站。 所有并发请求走到 blk_mq_sched_insert_request 时,都需要去抢调度器内部的自旋锁,把请求塞进软件队列进行徒劳的合并尝试。在高并发的 KV 存储场景中,小块随机写极多,合并命中率极低,这种操作不仅毫无意义,反而引发了致命的锁争用(native_queued_spin_lock_slowpath)。同时,底层块设备完成 IO 后抛出的中断,在唤醒软中断处理(NET_RX / BLOCK)时又被上层阻塞,最终导致 ksoftirqd 把 CPU 吃干抹净。

    极客实战:彻底打通 IO 栈

    1. 拔掉收费站(关闭调度器)

    直接将调度器设置为 none,让 blk-mq 完全旁路软件调度层,直通硬件队列。

    echo none > /sys/block/nvme0n1/queue/scheduler
    

    修改后,p99 延迟瞬间从 300ms 回落到稳定的 1.5ms,Load Average 下降 80%。

    2. 防御性配置(根治固化)

    永远不要相信手动命令,写进 udev 规则才是 SRE 的基本素养:

    # /etc/udev/rules.d/60-io-scheduler.rules
    ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/scheduler}="none"
    ACTION=="add|change", KERNEL=="sd[a-z]*", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="mq-deadline"
    

    (注:对 SATA SSD 依然保留 mq-deadline 是一种保守策略,但对 NVMe 必须一律为 none)。

    3. 压榨最后一滴性能(中断亲和性)

    即使调度器改成了 none,如果你发现某些 CPU 核的 hi/si 依然不均衡,那是因为 NVMe 的 MSI-X 中断没有打散。现代 NVMe 驱动通常会自动分配 IRQ,但如果运行了老旧的 irqbalance 守护进程,可能会发生“劣化漂移”。 建议针对极度依赖 IO 的节点,关掉 irqbalance,并使用内核源码自带的 set_irq_affinity 脚本将 NVMe 的完成队列中断静态绑定到 NUMA 节点的对应 CPU 核心上。

    同类问题速查清单 (Troubleshooting Checklist)

    1. 检查 IO 调度器状态: 快速排查集群中所有块设备的调度器配置: awk -F'[][]' '{print $2}' /sys/block/*/queue/scheduler 如果 NVMe 设备输出非 none,立刻整改。

    2. 区分 OS 队列延迟与硬件延迟: 不要只看 iostatawait。使用 eBPF 工具(如 bcc-toolsbiolatency)深入观测: biolatency -Q 若输出中 OS Queue Time (Q-time) 远大于 Device Time (D-time),说明阻塞点在 Linux Block Layer。

    3. 检查 NVMe 多队列深度配置: 确认内核是否正确识别并启用了 NVMe 硬件队列: ls -d /sys/block/nvme0n1/mq/* | wc -l 该数值应接近或等于机器的 CPU 核心数。

    4. 观测软中断打散情况watch -n 1 'cat /proc/interrupts | grep nvme' 观察各 CPU 列的数值增长率。如果只有极少数 CPU 在狂飙,说明 IRQ 绑定策略失效,正在引发单核软中断瓶颈。