标签: Soft Lockup

  • 深入 Linux 内核调度陷阱排查:滥用 SCHED_FIFO 引发的 RCU 饥饿与节点 Hard Lockup 实战

    某次接手排查一个核心低延迟网关的间歇性“假死”问题。现象极为惨烈:物理节点突然与控制面失联,监控指标白屏,SSH 无法建立连接(TCP 握手超时),但基础的 ICMP Ping 依然能通。最终强制重启并在终端外接主板收集到了崩溃现场。

    结论先行:业务开发为了追求所谓的“极致低延迟”,绕过 SRE 压测体系,在 systemd service 中私自将网关进程的 CPU 调度策略设置为 SCHED_FIFO(实时调度)且优先级拉满到 99,甚至顺手把内核保护机制 kernel.sched_rt_runtime_us 改成了 -1。这种鲁莽的操作导致用户态死循环轮询(Busy-Polling)线程霸占了 CPU,直接饿死内核 RCU (Read-Copy Update) 宽限期线程和其他系统守护进程,最终触发内核 Watchdog 机制,导致节点引发 Hard Lockup 彻底瘫痪。

    正确的低延迟调优绝不是靠暴力抢占调度权,而是通过 isolcpusNO_HZ_FULL 以及网卡中断亲和性绑定来实现 CPU 的“纯净隔离”。

    事故现场:SSH 进不去的诡异假死

    排查过程中,通过带外管理(IPMI)查看崩溃前的系统终端,满屏飘着内核报错日志。提取出的核心堆栈如下:

    watchdog: BUG: soft lockup - CPU#4 stuck for 22s! [gateway-worker:14322]
    ...
    rcu: INFO: rcu_sched self-detected stall on CPU
    rcu:     4-....c1e.. dps: 125199 GPs: 43232121
    rcu:     (t=60000 jiffies g=123321 q=123)
    Task dump for CPU 4:
    task:gateway-worker  state:R  running task    stack:0     pid:14322 ppid:1
    Call Trace:
     <IRQ>
     rcu_dump_cpu_stacks+0xdf/0x110
     rcu_check_callbacks+0x7b5/0x8e0
     update_process_times+0x2c/0x50
     tick_sched_timer+0x4d/0x90
     __hrtimer_run_queues+0x10b/0x290
     hrtimer_interrupt+0xf4/0x210
     smp_apic_timer_interrupt+0x5e/0x120
     ...
    

    从日志看,CPU 4 陷入了长达 22 秒的 Soft Lockup,随后 RCU 机制检测到了 CPU 停滞(Stall)。当前在这个 CPU 上运行的进程正是业务的核心网关程序 gateway-worker

    为什么 SSH 连不上但 Ping 能通? 因为 ICMP 包的响应通常在网卡软中断(SoftIRQ)上下文中处理,而 SSHD 是运行在完全公平调度器(CFS)下的普通用户态进程。如果 CPU 被比 CFS 优先级更高的任务死死咬住,普通进程根本分不到时间片,连 shell 提示符都弹不出来。

    扒开配置的底裤:夺命的优先级

    挂载崩溃节点的系统盘后,我直接翻看了业务侧提交的 systemd 配置文件,发现了令人窒息的代码片段:

    [Service]
    ExecStart=/opt/gateway/bin/gateway-worker
    # 业务开发自行添加的“性能优化”配置
    CPUSchedulingPolicy=fifo
    CPUSchedulingPriority=99
    

    不仅如此,他们在服务的 pre-start 脚本中,还加入了这样一行 sysctl 注入:

    sysctl -w kernel.sched_rt_runtime_us=-1
    

    这套组合拳的逻辑漏洞在于,他们完全没有理解 Linux 内核调度类的层次结构。

    Linux 调度器分为不同的调度类,优先级从高到低依次为: Stop > Deadline > Real-Time (RT) > Completely Fair Scheduler (CFS) > Idle

    业务代码使用的 SCHED_FIFO 属于 RT 调度类。在 SCHED_FIFO 策略下,一旦线程拿到 CPU,除非它主动让出(阻塞于 I/O、调用 sched_yield),或者被更高优先级的 RT 线程抢占,否则它将永远运行下去。 而该网关程序为了降低网络处理延迟,采用了类似于 DPDK 的 Busy-Polling 模式(死循环空跑轮询队列)。

    正常情况下,Linux 为了防止这种流氓进程锁死系统,内核有一个保护参数 /proc/sys/kernel/sched_rt_runtime_us,默认值为 950000(即每秒钟最多允许 RT 进程运行 950ms,必须留 50ms 给非 RT 进程如 CFS 调度类)。 但这位开发者不知从哪搜来的“黑魔法”,把这个值改成了 -1(完全关闭限制)。

    结果是灾难性的: 优先级 99 的死循环线程独占了 CPU。内核的 RCU 宽限期线程(rcu_sched)、迁移线程(migration)、甚至是负责清理内存的内核工作队列,全部被饿死。RCU 无法推进,系统内部锁积压,最终 Watchdog 狗咬死,节点硬重启。

    真正的防御性调优:如何正确榨干 CPU 性能?

    追求低延迟,不应该在调度器上玩火,而是要通过CPU 隔离与亲和性绑定,把 CFS 的干扰降到最低。

    正确的改造方案如下:

    1. 隔离 CPU,避免系统进程干扰 在 Grub 内核启动参数中,将部分核心(如物理核 4-15)完全隔离开来,不参与普通进程的 CFS 调度,并开启无滴答模式(减少时钟中断):

    GRUB_CMDLINE_LINUX="... isolcpus=4-15 nohz_full=4-15 rcu_nocbs=4-15"
    

    这样,这几个核心将被彻底“净化”,系统默认进程不会跑在上面。

    2. 使用 cset 或 taskset 绑定业务进程 将业务进程锁定在这些被隔离的核心上。在 systemd 中,使用 CPUAffinity 替代愚蠢的 CPUSchedulingPolicy

    [Service]
    ExecStart=/opt/gateway/bin/gateway-worker
    CPUAffinity=4-15
    # 确保不要使用 fifo 策略,保持默认的 other (CFS) 即可
    

    3. 剥离网卡中断 默认情况下,irqbalance 服务会在所有 CPU 上随机分配网卡硬中断。为了防止网卡中断打断我们的轮询线程,需要修改 irqbalance 配置,或者手动设置网卡的 SMP affinity,将中断绑定到非隔离的 CPU(如 0-3)上。

    通过这套“隔离+绑定”的方案,业务进程在独占的 CPU 核心上运行,既能享受近似 100% 的时间片(无上下文切换抖动),又不会影响内核在其他核心上处理基础系统任务,这才是真正企业级高可用的落地做法。

    排查清单与同类问题速查

    1. RCU Stall / Soft Lockup 初判dmesg 如果频繁出现 rcu_sched self-detected stallBUG: soft lockup,首查占用该 CPU 的进程是否进入了死循环,其次查是否滥用了实时调度优先级。

    2. 实时调度策略审查:使用 chrt -m 查看系统支持的优先级范围,使用 ps -eo pid,ni,rtprio,psr,comm,policy | grep FIFO 审查生产环境是否存在未经审批的 SCHED_FIFOSCHED_RR 进程。

    3. RT 防御机制检查:绝不要在生产环境将 kernel.sched_rt_runtime_us 设为 -1。如果确需微调,请保留至少 50000(50ms)的余量给系统进程。

    4. 低延迟优化正规军:对 CPU 密集型或轮询型低延迟业务,标准答案是 isolcpus 隔离 + taskset 亲和性绑定 + nohz_full 关闭时钟滴答,切勿试图通过篡改全局调度策略来插队。

    5. 假死现象倒推:如果 SSH 无法登录但 Ping 延迟极低且稳定,说明网络中断层正常但用户态调度已瘫痪,重点排查 CPU 抢占和 OOM 导致的 fork 拒绝。

  • 深入 Falco 规则雪崩排查:高频 Syscall 拦截引发的 eBPF RingBuffer 溢出与 Node 假死实战

    排查过程中最让人血压升高的,往往不是底层的内核 Bug,而是安全策略的“盲目自信”。近期处理了一起严重的生产事故:某高吞吐的 Kafka 与 Elasticsearch 混合部署集群,在安全团队下发新版容器运行时合规规则后,多台 Node 节点相继出现 Load Average 飙升至 200+,Kubelet 心跳超时导致节点变成 NotReady,业务大面积断流。

    一句话总结排查结论:安全工程师在 Falco 规则中写了一个监听 writepwrite64 系统调用的规则,但漏掉了针对文件路径的宏过滤(Macro Filter)。这导致底层 eBPF 探针毫无节制地拦截节点上每秒数十万次的高频 I/O 系统调用,海量事件瞬间撑爆 eBPF Perf Ring Buffer,引发严重的 CPU Sys 态占用与 Soft Lockup,最终饿死 Kubelet 进程。

    防御性安全加固是必须的,但脱离业务压测的规则下发,本质上就是对生产环境的自杀式 DDoS。

    案发现场:系统态 CPU 的狂欢

    监控系统发出刺耳的告警,Kafka 集群的 P99 延迟从 10ms 飙升到了 5000ms。切到终端,尝试 SSH 登录故障 Node,光是建立连接就卡了近十秒。

    好不容易敲下 top 命令,看到的数据令人极度不适:

    %Cpu(s):  5.2 us, 88.4 sy,  0.0 ni,  1.1 id,  0.2 wa,  0.0 hi,  5.1 si,  0.0 st
    Load average: 214.35, 180.12, 110.45
    

    用户态(us)CPU 只有 5%,而系统态(sy)竟然高达 88%,软中断(si)也有 5%。这说明 CPU 根本没在处理业务逻辑,全在内核态里打转。

    pidstat -p ALL 1 查看具体是谁在消耗 CPU,排在第一的是 falco 进程,单进程跑满了约 400% 的 CPU(4核),但这还不足以解释整个 64 核宿主机的瘫痪。

    真正致命的信息藏在 dmesg 里:

    [ 3451.123456] NMI watchdog: BUG: soft lockup - CPU#12 stuck for 22s! [java:14562]
    [ 3451.123470] RIP: 0010:bpf_prog_3a2b1c4d_falco_sys_enter+0x124/0x500
    [ 3451.123485] Call Trace:
    [ 3451.123490]  <TASK>
    [ 3451.123492]  trace_call_bpf+0x9a/0x150
    [ 3451.123495]  perf_trace_sys_enter+0x140/0x200
    [ 3451.123500]  syscall_trace_enter.constprop.0+0x1a8/0x220
    [ 3451.123505]  do_syscall_64+0x15/0x80
    

    内核调用栈清晰地指明了真凶:bpf_prog_..._falco_sys_enter。Kafka 进程(Java)在发起系统调用时,被 Falco 的 eBPF 程序钩住,由于处理逻辑极其繁重,直接触发了 CPU 软锁死(Soft Lockup)。

    与此同时,查看 Falco 自身的日志: {"level":"warning","msg":"Falco internal: drop event. Total drops: 850392019"} 系统正在以每秒数百万的量级丢弃事件。

    抽丝剥茧:愚蠢的规则与 eBPF 的阿喀琉斯之踵

    为了快速恢复业务,第一反应是直接介入现场,执行 systemctl stop falcokubectl delete ds falco -n falco。拔掉这个“安全探针”后,节点 Load 瞬间掉回个位数,Kafka 恢复正常。

    业务稳住了,接下来就是扒安全团队的“底裤”。调出引发故障的那个自定义规则配置文件 falco_rules.local.yaml,找到了罪魁祸首:

    - rule: Detect Suspicious File Modifications
      desc: Monitor write operations to system directories
      condition: >
        evt.type in (write, pwrite64, pwritev) 
        and container.id != host 
        and proc.name != "fluentd"
      output: "Suspicious write detected (user=%user.name file=%fd.name)"
      priority: WARNING
    

    看懂了吗?写规则的人忘记加上目标目录的限制。 他们的本意可能是监控对 /etc/bin 的写操作,但由于漏掉了类似 fd.name startswith "/etc/" 的前置过滤宏,这条规则的语义变成了:拦截所有容器内除 fluentd 外的任意写操作

    要理解为什么这会导致系统雪崩,必须弄懂 Falco eBPF 探针的工作原理。

    Falco 的架构分为内核态的 eBPF 探针和用户态的规则引擎。内核探针挂载在 raw_tracepoint/sys_entersys_exit 上。 当 Falco 启动时,它会解析所有启用的规则,提取出需要监听的系统调用类型(Syscall ID)。一旦任何一条规则声明了对 write 系统调用的监听,eBPF 探针就会在内核中对全局所有的 write 操作进行上下文采集。

    在这个 Kafka/ES 集群中,I/O 是极其密集的。

    1. 每次 write,eBPF 程序都会被触发。

    2. eBPF 需要从内核空间提取进程信息、文件描述符、参数,打包成事件结构体。

    3. 将事件推入 Perf Ring Buffer 或 BPF Ringbuf。

    4. 如果用户态 Falco 引擎处理速度跟不上,Ring Buffer 就会满。

    5. Buffer 满后,eBPF 程序内部自旋锁或丢弃逻辑会产生极大的 CPU 开销,严重拉长了 write 系统调用的耗时。

    原本一个只需几微秒的内核写操作,被强行注入了高昂的 eBPF 观测开销。海量的事件上下文切换不仅榨干了 CPU Sys 资源,更直接饿死了 Kubelet 的 PLEG(Pod Lifecycle Event Generator)循环,导致集群管控面认为节点宕机,开始触发 Pod 驱逐,最终演变成全局雪崩。

    修复与避坑:防御性观测的底线

    事后复盘,我给安全团队划定了三条绝对不可触碰的红线:

    1. 绝对禁止无限制拦截高频 I/O 系统调用。 像 read, write, recvfrom, sendto, epoll_wait 这些系统调用,在任何生产环境的运行时安全监控中,除非在 eBPF 层面有极度严苛的 In-Kernel 过滤机制,否则坚决不能放入全局监控规则中。

    2. 修正规则语义,利用内核态过滤。 如果非要监控关键文件的修改,不应该去 Hook 宽泛的 write。更好的方式是使用 openat 系统调用配合 O_TRUNC / O_RDWR 标志位,或者利用 eBPF 的 LSM(Linux Security Modules)钩子针对特定 inode 进行监控。 修改后的合理规则应该尽量将条件收敛: yaml condition: > open_write and container and fd.name startswith "/etc/"

    3. 容器安全探针必须做资源硬隔离。 Falco DaemonSet 必须配置严格的 CPU Limit 和优先级。如果它的性能跟不上,宁可让它 OOM 或被 Cgroup 限制,也不能让它拖垮整台宿主机的内核栈。

    排查清单:Falco/eBPF 性能雪崩同类问题速查

    如果你怀疑容器安全组件引发了性能问题,请按以下步骤快速确认:

    1. CPU 态势观测:使用 topmpstat 观察 sy(系统态)指标,如果 sy 持续异常偏高(>50%),且 wa(I/O等待)不高,大概率是系统调用被大量 Hook 或频繁陷入内核态引发。

    2. 内核阻塞确认:通过 dmesg -T | grep -i "soft lockup" 检查是否出现 CPU 死锁。如果 Call Trace 中包含 bpf_prog_trace_call_bpfperf_trace_sys_enter,直接锁定 eBPF 探针。

    3. Drop 指标核对:检查 Falco 或其他安全探针的 Metrics / 日志,搜索 Total dropsRing buffer full 关键字。事件大量丢弃是规则过于宽泛的铁证。

    4. 探针快速止血:情况危急时,不要花时间分析规则,直接停止安全组件服务(systemctl stop 或删减 DS),若系统负载在 5 秒内骤降恢复,即可定性为该组件引发的故障。

    安全不仅要防范外部的黑客,更要防范内部失控的代码。在操作系统底层,哪怕是一行看似无害的过滤遗漏,也会在流量洪峰下化作摧毁整个集群的核弹。

  • 深入 SCHED_FIFO 调度死锁排查:RT 优先级滥用引发的 RCU Stall 与 Node 假死实战

    某次线上核心交易集群出现诡异的 Node 批量假死现象。故障发生时,API 响应瞬间超时(p99 从 2ms 飙升至 10s 以上),K8S 节点状态接连翻转为 NotReady,SSH 彻底失去响应。监控面板在断点前最后上报的数据显示:系统 Load Average 飙升至 800+,某几个单核 CPU 突然被打至 100%。

    最终结论:研发为了追求极致的低延迟,在业务代码中强行将关键线程的调度策略修改为 SCHED_FIFO(实时调度,优先级 99),并且在这个线程里写了一个没有退让机制的死循环 Spinlock。这导致对应的 CPU 核被完全霸占,内核态的 RCU (Read-Copy Update) 宽限期线程、ksoftirqd 等关键内核线程被彻底饿死,最终触发 rcu_sched stall,引发系统 Soft Lockup 进而 Panic。

    现场还原与死亡日志

    排查这种彻底死机的节点,常规的 topstrace 根本来不及敲,只能依赖保留的 kdump 或者重启后的 dmesg 遗言。在 messages 日志中,我提取到了最核心的崩溃栈:

    [ 1345.678901] watchdog: BUG: soft lockup - CPU#4 stuck for 22s! [bidding_worker:45092]
    [ 1345.678915] INFO: rcu_sched self-detected stall on CPU
    [ 1345.678920]  4-....: (59999 ticks this GP) idle=001/1/0x4000000000000000 softirq=45123/45123 fqs=14998
    [ 1345.678925]  (t=60000 jiffies g=123456 q=8901)
    [ 1345.678931] NMI backtrace for cpu 4
    [ 1345.678950] RIP: 0033:0x00007f8a9b2c3d4e (用户态死循环地址)
    

    日志非常清晰:CPU 4 卡死了 22 秒,RCU 机制检测到宽限期(Grace Period)已经 60000 个 jiffies 没有推进了。卡死 CPU 的进程是 bidding_worker,且 RIP 寄存器停留在用户态 (0033)。

    这意味着,不是内核出了 Bug,而是用户态进程死死咬住 CPU 不放,连内核的中断下半部和调度器都抢不回控制权。

    为什么用户态能干掉内核态?

    我拉取了该进程的调度配置,破案了:

    $ chrt -p 45092
    pid 45092's current scheduling policy: SCHED_FIFO
    pid 45092's current scheduling priority: 99
    

    这正是让人血压升高的操作。在 Linux 调度器(CFS,Completely Fair Scheduler)面前,所有普通进程(SCHED_OTHER)都要乖乖按时间片和 vruntime 来排队。但 SCHED_FIFOSCHED_RR 属于 Real-Time(实时)调度类,它的权限是凌驾于 CFS 之上的。

    SCHED_FIFO 的语义是:只要该线程不主动睡眠(sleep/wait)、不主动让出 CPU(sched_yield),或者不被更高优先级的 RT 线程抢占,它就会永远霸占当前的 CPU 核。

    业务代码里是怎么写的?

    // 致命的自旋锁逻辑
    while (!atomic_load(&task_ready)) {
        // 没有任何 sleep,没有 cpu_relax(),没有 sched_yield()
        // 纯纯的死循环烧 CPU
    }
    

    当优先级设定为 99 的 SCHED_FIFO 线程进入上述死循环时,灾难开始了:

    1. 抢占屏蔽:内核的普通调度器完全无法剥夺它的执行权。

    2. RCU 饿死:Linux 内核广泛使用 RCU 机制来管理无锁数据结构。RCU 需要等待所有 CPU 经过一次上下文切换(Quiescent State)来清理旧数据。CPU 4 被死循环霸占,永远不发生上下文切换,RCU 宽限期无限延长,内存无法释放,最终触发 RCU Stall Panic。

    3. 软中断阻塞:网卡收发包依赖的 ksoftirqd 默认也是普通优先级。CPU 4 上的网络包无法被处理,导致网络层面的“假死”。

    消失的最后一道防线

    按理说,Linux 内核对这种 RT 调度器的滥用是有防御机制的。kernel.sched_rt_runtime_uskernel.sched_rt_period_us 这两个 sysctl 参数,默认配置为每 1000000 微秒(1秒)内,RT 进程最多只能运行 950000 微秒(0.95秒)。剩下的 0.05 秒会强制留给普通进程(比如内核线程)续命。

    为什么没生效? 排查发现,某位前任 SRE 为了追求极限的内核调优,在初始化的 Ansible 剧本里加了一行: sysctl -w kernel.sched_rt_runtime_us=-1

    将该值设为 -1,意味着彻底关闭了 RT 进程的运行时间限制,扒光了内核的最后底裤。两者结合,精准击穿了系统的可用性防线。

    极低延迟的正确实现姿势

    如果业务真的需要旁路内核、避免调度开销来实现极低延迟(如 DPDK/SPDK 架构),绝不是简单粗暴地改个 SCHED_FIFO 就能搞定的。正确的系统级架构应该走CPU 隔离与绑核的路线:

    1. 内核启动参数隔离:通过 Grub 传入 isolcpus=4-7 nohz_full=4-7 rcu_nocbs=4-7。这会让操作系统把 CPU 4 到 7 隔离开,不往上面扔普通的定时器中断,不调度普通进程,并将 RCU 回调转移到其他核。

    2. 中断亲和性调整:配置 irqbalance 或手动修改 /proc/irq/xxx/smp_affinity,确保网卡和磁盘的硬件中断不要打到被隔离的核上。

    3. 应用侧精准绑核:业务进程启动后,使用 tasksetpthread_setaffinity_np,将死循环 Polling 的线程严格绑定在上述隔离核上。

    这时候,你用死循环轮询没有任何问题,因为这几个核本来就是买来专门给你“烧”的,不会影响系统大盘。

    排查清单与同类问题速查

    1. RCU Stall 定位确认 通过 dmesg -T | grep -i rcu_sched 查看是否有 self-detected stall。如果有,必须顺着堆栈找到是哪个 PID 卡死了特定的 CPU,并且留意 ticks this GP 是否异常庞大。

    2. 全网进程调度策略巡检 排查系统中是否有越权的调度策略:ps -eo pid,tid,class,rtprio,ni,pri,psr,pcpu,comm | awk '$3 != "TS" && $3 != "-" {print $0}' (TS 代表 SCHED_OTHER,重点关注 FF/RR 类型的进程)。

    3. 内核防御机制校验 检查 /proc/sys/kernel/sched_rt_runtime_us 是否被手贱修改为 -1。在非专用的隔离物理机上,强烈建议保持默认值 950000

    4. 自旋锁的防御性编程 在任何 C/C++/Rust 的用户态 Spinlock 实现中,循环体内必须加入 cpu_relax()(在 x86 下编译为 PAUSE 指令),这不仅能降低 CPU 流水线功耗,也能缓解总线争用。