引言

中断(Interrupt)是现代操作系统的基石——它是硬件与内核沟通的唯一异步通道。无论是键盘按键、网卡收包、磁盘 IO 完成,还是高精度定时器触发,所有外部事件都通过中断通知内核。理解中断子系统,不仅意味着掌握操作系统的运行机制,更是编写高性能驱动、优化实时系统、诊断内核问题的必备技能。

Linux 内核的中断子系统是一个经过二十多年持续演进的复杂架构。从最初的全局自旋锁 + 共享中断时代,发展到今天支持 threaded IRQ、interrupt affinity、hardirq/softirq 分层、NOHZ 等高级特性的成熟体系。在实际工程中,网络中断导致的 ksoftirqd CPU 飙高、实时系统因硬中断延迟超标而产生抖动、多队列网卡中断分发不均导致负载倾斜,这些生产级问题无一不需要对中断子系统有深入理解。

本文将从中断硬件原理讲起,深入剖析中断Descriptor 分配、上半部/下半部机制、softirq/tasklet/workqueue 的实现细节,以及中断亲和性、 threaded IRQ、timer interrupt 等高级主题,最后结合生产级案例(网卡中断风暴治理、实时系统中断隔离、 NMI watchdog 诊断)展示完整的实战路径。

1. 中断硬件基础

1.1 APIC 与中断路由

在现代 x86 架构中,中断由 Advanced Programmable Interrupt Controller (APIC) 管理。每个 CPU 核心配置一个 Local APIC(LAPIC),它接收来自 I/O APIC(集成在南桥/IOH 中)和 MSI(Message Signaled Interrupts)的中断消息。LAPIC 内部包含:

  • Local Vector Table (LVT):定义本地中断源的处理向量(Timer、Thermal、Performance Counter、LINT0/1、Error)
  • Timer:高精度本地定时器,支持 one-shot / periodic / TSC-deadline 模式,是内核 tick 机制的基础
  • IRR (In-Request Register):记录已收到但尚未 dispatch 的中断请求
  • ISR (In-Service Register):记录当前正在处理的中断
  • TPR (Task Priority Register):优先级阈值,仅允许优先级高于 TPR 的中断被投递

ARM64 架构通过 Generic Interrupt Controller (GIC) 实现类似功能:GICv3 引入 System Register 访问(ICC_* 寄存器),GICv4 支持 Virtual LPIs。无论架构有何不同,Linux 内核抽象了统一的 irq_chip 接口来屏蔽硬件差异。

1.2 MSI / MSI-X

传统中断引脚模式(INTx)每条 PCI 设备只有 4 根中断线,多个设备共享一根引脚,存在电平触发/边沿触发的兼容性问题和共享中断去重瓶颈。MSI(Message Signaled Interrupts)和 MSI-X 通过后门内存写操作(写入特定地址)来投递中断:

  • MSI:每个设备最多 32 个中断向量,共享一个消息地址但数据不同
  • MSI-X:每个设备最多 2048 个中断向量,每个向量独立的地址+数据,是 NVMe SSD 和多队列网卡的标准配置

内核通过 pci_alloc_irq_vectors() 或 pci_enable_msix_range() 申请中断向量。现代网卡(如 Intel E810、Mellanox ConnectX-6)利用 MSI-X 为每个 RX/TX 队列分配独立中断向量,这是 RSS(Receive Side Scaling)和 RPS/XPS 实现的基础。

2. 内核中断数据结构

2.1 irq_desc —— 中断描述符

每个硬件中断向量在内核中对应一个 irq_desc 结构体(定义于 kernel/irq/irqdesc.h):

struct irq_desc {
    struct irq_common_data  irq_common_data;
    struct irq_data        irq_data;
    unsigned int           __percpu *kstat_irqs;
    irq_flow_handler_t     handle_irq;
    struct irqaction       *action;         // 链表:共享中断的 action
    unsigned int           status_use_accessors;
    unsigned int           depth;          // 嵌套深度(disable/enable 计数)
    unsigned int           wake_depth;     // 唤醒使能深度
    unsigned int           irq_count;      // 防止中断风暴的计数
    unsigned long          last_unhandled; // 上次未处理时间
    unsigned int           irqs_unhandled;
    atomic_t               threads_active;  // 激活的 IRQ 线程数 raw_spinlock_t lock;
    struct cpumask         *percpu_enabled; // per-cpu 中断使能掩码
    const struct cpumask   *affinity_hint; // 用户设置的 affinity 提示
    struct irq_affinity_notify *affinity_notify;
    ...
};

关键字段含义:

  • action:指向 irqaction 链表。当多个设备共享一个中断线时(如 PCI INTx),每个设备驱动程序注册一个 irqaction,按链表依次调用 handler
  • depth:disable/enable 嵌套计数。disable_irq() 递增 depth,enable_irq() 递减;depth=0 时中断才被真正使能
  • irq_count:连续中断计数器。当短时间内中断触发次数超过 irq_count_thresh(通常 100000次/秒),内核认为发生中断风暴,会 disable 该中断并打印 "irq X: nobody cared"
  • percpu_enabled:支持 per-cpu 的中断控制,与 interrupt affinity 配合实现中断的 CPU 绑定

2.2 irqaction —— 中断处理动作

struct irqaction {
    irq_handler_t          handler;        // 中断处理函数
    void                   *dev_id;        // 注册时的标识符
    void                   *percpu_dev_id; // per-cpu 设备标识
    struct irqaction       *next;          // 共享中断链表
    irq_handler_t          thread_fn;      // 线程化中断处理函数
    struct task_struct     *thread;        // IRQ 线程 task_struct
    unsigned int           irq;            // 中断号
    unsigned int           flags;
    unsigned long          thread_flags;
    const char             *name;
    struct proc_dir_entry  *dir;
};

通过 request_irq() 或 request_threaded_irq() 注册 irqaction。共享中断必须设置 IRQF_SHARED 标志,dev_id 必须唯一(用于 free_irq 识别)。

2.3 irq_data 与 irq_chip

irq_data 是连接硬件层和虚拟 irq 层的桥梁,包含中断映射关系和硬件操作接口(irq_chip):

struct irq_data {
    unsigned int           irq;
    unsigned long          hwirq;
    unsigned int           node;
    struct irq_chip        *chip;
    struct irq_domain      *domain;
    void                   *chip_data;
    ...
};

struct irq_chip {
    const char             *name;
    unsigned int           (*startup)(struct irq_data *data);
    void                   (*shutdown)(struct irq_data *data);
    void                   (*enable)(struct irq_data *data);
    void                   (*disable)(struct irq_data *data);
    void                   (*ack)(struct irq_data *data);
    void                   (*mask)(struct irq_data *data);
    void                   (*mask_ack)(struct irq_data *data);
    void                   (*unmask)(struct irq_data *data);
    void                   (*eoi)(struct irq_data *data);    // End Of Interrupt
    int                    (*set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force);
    int                    (*set_type)(struct irq_data *data, unsigned int flow_type);
    ...
};

irq_chip 中的函数由驱动开发者实现(如 apic_chip、ioapic_chip 对应 x86 平台),用于操作外设的中断控制寄存器。部分芯片(如 ARM GIC)将这些函数直接写死在 drivers/irqchip/ 驱动中。

3. 上半部与下半部机制

3.1 上半部(Top Half / HardIRQ)

硬中断处理函数在硬件中断上下文中执行,以 ARM 为例,CPU 自动切换到 IRQ Mode(ARM32)或 CurrentEL.EL1h(ARM64)。硬中断上下文的关键特征:

  • 关闭中断(部分架构):多数架构进入硬中断时自动关闭同类型中断(防止重入),仅允许更高优先级中断嵌套。Linux 通过 IRQF_SHARED 或 IRQF_PERCPU 标志控制
  • 不可睡眠:硬中断上下文没有 task_struct 关联,执行 current 宏指向被打断的进程,在此调度会导致内核崩溃
  • 必须精简:在中断上下文中执行耗时操作会阻塞所有外部中断,导致其他设备响应延迟。因此硬中断处理仅执行必要的 ACK 记录

网卡驱动的硬中断通常只做:清除中断标志位、记录 NAPI poll 队列、调用 napi_schedule() 触发 softirq。NVMe 中断处理仅执行 complete() 唤醒等待队列。耗时工作全部交给下半部。

3.2 下半部演进:从 BH 到 Softirq

Linux 下半部机制经历了五轮演进:

时代机制特点淘汰原因
0.01 - 1.0BH (Bottom Half)全局 32 个链表,串行执行SMP 性能极差,同一时间只能有一个 BH 运行
1.x - 2.0Task Queue可注册多个 task,串行执行全局锁串行化,CPU 越多性能越差
2.0 - 2.3Softirq编译时静态注册,同类型可跨 CPU 并行需要修改内核源码,不可动态注册
2.3+Tasklet基于 Softirq 构建,动态注册,同类型串行继承 Softirq 性能,但串行化不利于高吞吐
2.3+Workqueue进程上下文,可调度、可睡眠开销大(涉及上下文切换),不适合高频路径

现代内核下半部家族的分工是:softirq 用于高性能网络路径、tasklet 用于驱动通用延迟处理、workqueue 用于需要睡眠的复杂操作。

4. Softirq 深度剖析

4.1 注册与激活

Softirq 通过静态枚举 enum 注册,编译时确定索引,每个 softirq 类型对应一个 softirq_action 函数指针数组:

// include/linux/interrupt.h
enum {
    HI_SOFTIRQ=0,          // 高优先级 tasklet(已过时)
    TIMER_SOFTIRQ,         // 定时器软中断
    NET_TX_SOFTIRQ,        // 网络发送
    NET_RX_SOFTIRQ,        // 网络接收
    IRQ_POLL_SOFTIRQ,      // Irq poll 机制
    BLOCK_SOFTIRQ,         // 块层完成通知
    IRQ_POLL_SOFTIRQ,      // IRQ poll(单核 fallback)
    TASKLET_SOFTIRQ,       // 通用 tasklet
    SCHED_SOFTIRQ,         // 调度器负载均衡
    HRTIMER_SOFTIRQ,       // 高精度定时器
    RCU_SOFTIRQ,           // RCU 回调执行
    NR_SOFTIRQS
};

// kernel/softirq.c - per-cpu 待执行队列
static struct softirq_action softirq_vec[NR_SOFTIRQS];

// 激活 softirq(在中断返回前调用)
raise_softirq(NET_RX_SOFTIRQ);
raise_softirq_irqoff(NET_RX_SOFTIRQ);  // 已在中断中直接用 irqoff

4.2 处理时机与重入

Softirq 的处理发生在以下几个关键时刻:

  1. 硬件中断返回时(irq_exit):这是最常见的触发点。中断处理完成后直接检查是否有 pending 的 softirq,有则执行
  2. ksoftirqd 内核线程:如果 softirq 被触发过于频繁(如在 do_softirq() 中累计已处理了 MAX_SOFTIRQ_RESTART = 10 次仍有 pending),则唤醒 ksofitrqd/%d 内核线程在后台继续处理
  3. 显式调用 local_bh_enable:在 local_bh_disable() 保护区域内(如获取自旋锁时隐式禁用 BH),BH 使能时检查并执行 pending softirq

do_softirq() 的核心逻辑:

asmlinkage __visible void do_softirq(void)
{
    unsigned long flags;
    struct list_head *cpu;

    if (in_softirq())  // 已在 softirq 上下文中,防止重入
        return;

    local_irq_save(flags);
    
    cpu = this_cpu_ptr(&tasklet_vec);
    if (!list_empty(cpu)) {
        local_irq_enable();
        // 处理 tasklet 和 high-prio tasklet
        ...
    }
    
    // 处理 softirq_vec 中的 pending 项
    pending = local_softirq_pending();
    if (pending) {
        ...
        h = softirq_vec;
        while ((softirq_bit = ffs(pending))) {
            h->action(h);
            h++;
            pending >>= softirq_bit;
        }
    }
    
    local_irq_restore(flags);
}

注意:softirq 在同一个 CPU 上不会重入(同类型在同一时刻只执行一份),但不同 CPU 可以并行执行同一个 softirq 类型。这意味着 softirq handler 内部无需担心并发,但访问共享数据时仍需 spin_lock 保护跨 CPU 访问。

4.3 Softirq 性能瓶颈:ksoftirqd CPU 飙高

在高网络吞吐场景(如 10Gbps+ 小包转发)中,NET_RX_SOFTIRQ 频繁中断 CPU,如果 softirq 的速率超过内核处理能力,ksoftirqd 内核线程会持续运行,消耗 100% CPU。这是生产环境中最常见的中断相关性能问题。

典型的解决方案包括:

  • NAPI (New API):网卡驱动在第一次中断后关闭硬件中断,改为轮询方式一次性处理多个报文,处理完成后再重新开启中断
  • RPS (Receive Packet Steering):在软件层将报文分发到不同 CPU 的 backlog 队列,实现多核并行接收
  • Poll Mode Driver (PMD):DPDK 方案完全禁用中断,用户态驱动直接轮询网卡寄存器,适用于极致吞吐场景(代价是 100% CPU 占用)
  • Busy Poll:让应用程序层在 recvfrom 时直接驱动 NAPI poll,减少内核态和用户态切换(setsockopt SO_BUSY_POLL)

5. Tasklet 详解

Tasklet 是基于 softirq 构建的下半部机制,在 HI_SOFTIRQ(高优先级)和 TASKLET_SOFTIRQ 两个 softirq slot 上实现。同一时刻同一个 tasklet 实体只在一个 CPU 上运行(串行保证),不同 tasklet 实体可以跨 CPU 并行运行。

Tasklet 数据结构:

struct tasklet_struct {
    struct tasklet_struct *next;
    unsigned long          state;          // TASKLET_STATE_SCHED / TASKLET_STATE_RUN
    atomic_t               count;          // 引用计数 0=enable
    void (*func)(unsigned long);
    unsigned long          data;
    unsigned long          flags;          // TASKLET_STATE_FLAGS
};

enum {
    TASKLET_STATE_SCHED,  // 已被调度
    TASKLET_STATE_RUN,    // 正在执行
    TASKLET_STATE_FLAGS   // 其他标志
};
;

API 用法:

// 静态声明
DECLARE_TASKLET(my_tasklet, my_handler, (unsigned long)dev);
DECLARE_TASKLET_DISABLED(my_tasklet, my_handler, (unsigned long)dev);

// 初始化
tasklet_init(&t->tasklet, my_handler, (unsigned long)dev);

// 调度(在 hardirq 中调用)
tasklet_schedule(&my_tasklet);      // 添加到 per-cpu tasklet_vec
tasklet_hi_schedule(&my_tasklet);   // 高优先级版本(已不推荐使用)

// 启用/禁用
tasklet_enable(&my_tasklet);   // count--,若 == 0 则允许调度
tasklet_disable(&my_tasklet);  // count++,增加调度延迟
tasklet_kill(&my_tasklet);     // 等待当前执行完成,阻止后续调度(不可在中断上下文调用)

Tasklet 适合在驱动中执行相对轻量且不操作全局状态的单 CPU 局部工作。但对于需要跨 CPU 并行、或操作不同实体的工作,应改用 softirq 或 workqueue。

6. Workqueue 详解

Workqueue 是唯一在中断下半部可以睡眠的机制。与普通 tasklet 不同,workqueue 在内核进程上下文中执行,允许调用可能阻塞的函数(如 mutex_lock、GFP_KERNEL 分配的 kmalloc、文件系统 IO 等)。

6.1 基础 Workqueue API

struct work_struct {
    atomic_long_t data;
    struct list_head entry;
    work_func_t func;
};

// 静态声明并初始化
DECLARE_WORK(n, f);                    // 普通的 work
DECLARE_DELAYED_WORK(n, f);            // 支持延迟执行

// 动态初始化
INIT_WORK(&work, func);
INIT_DELAYED_WORK(&work, func);
INIT_WORK(&dwork.work, func);

// 调度到系统全局工作队列
schedule_work(&work);                        // 调度到 system_wq
schedule_work_on(cpu, &work);                // 调度到指定 CPU 的 system_wq
schedule_delayed_work(&dwork, delay);         // 延迟执行(基于 timer)
schedule_delayed_work_on(cpu, &dwork, delay);// 指定 CPU + 延迟

// 取消
cancel_work_sync(&work);
cancel_delayed_work_sync(&dwork);

6.2 自定义 Workqueue

系统提供了多个默认工作队列,也可以创建自定义队列:

// 系统默认工作队列(include/linux/workqueue.h)
extern struct workqueue_struct *system_wq;           // 普通优先级
extern struct workqueue_struct *system_highpri_wq;   // 高优先级
extern struct workqueue_struct *system_long_wq;       // 长执行时间任务
extern struct workqueue_struct *system_unbound_wq;    // 不绑定 CPU(NUMA 感知)
extern struct workqueue_struct *system_freezable_wq;  // 系统休眠时冻结

// 创建工作队列(Linux 5.4+ 推荐 alloc_ordered_workqueue)
struct workqueue_struct *alloc_workqueue(fmt, flags, max_active, ...);
struct workqueue_struct *alloc_ordered_workqueue(fmt, flags, ...); // 严格串行

// 参数示例
wq = alloc_workqueue("mydrv-events", WQ_UNBOUND | WQ_HIGHPRI, 0);

标志位含义:

  • WQ_UNBOUND:工作线程不绑定特定 CPU,按 NUMA 节点分配。适用于线程执行时间长的场景
  • WQ_HIGHPRI:worker 线程以高优先级(nice -20)运行
  • WQ_CPU_INTENSIVE:标记为 CPU 密集型,不计入 workqueue 的 concurrency 限制
  • WQ_MEM_RECLAIM:标记为内存回收路径使用,确保内存不足时有执行线程
  • WQ_FREEZABLE:系统休眠时暂停执行

6.3 Workqueue 实现原理

Workqueue 的核心创新在于 "Concurrency Managed Workqueue (CMWQ)"(Linux 2.6.36+ 引入)。CMWQ 的要点:

  1. Worker Pool:每个 CPU 维护两个工作线程池——一个用于 system_wq(Per-CPU workers)和一个用于 system_unbound_wq(Node-wide workers)
  2. 动态深度调整:CMWQ 跟踪当前挂起的 work 数、idle worker 数和 busy worker 数。如果 work 快速产生但 worker 处理慢且 idle worker < 2,则创建新 worker;如果 idle worker > 1 且当前正在做非必要工作,则休眠 worker
  3. Work 着色:每个 work 的 data 字段包含 COLOR 位,当 work 被添加到同一个 workqueue 时,CMWQ 确保低级 CPU 上的 work 按先进先出(FIFO)顺序执行
  4. NUMA 分配策略:UNBOUND workqueue 按 NUMA 节点分配 worker pool,确保 work 在中心内存节点上执行

7. Threaded IRQ

Threaded IRQ 是 Linux 3.x 引入的机制,将 hardirq 处理拆分到独立内核线程中执行。这是解决实时系统硬中断延迟问题的关键方案。

7.1 注册方式

int request_threaded_irq(unsigned int irq, irq_handler_t handler,
                          irq_handler_t thread_fn, unsigned long flags,
                          const char *name, void *dev_id)

参数说明:

  • handler:硬中断处理函数。通常检查中断是否来自本设备,如果是则 ACK 中断返回 IRQ_WAKE_THREAD,否则返回 IRQ_NONE
  • thread_fn:线程化处理函数,在中断线程上下文中运行,可以睡眠、可以调度
  • flags:可以组合 IRQF_ONESHOT(关键标志)等

7.2 IRQF_ONESHOT 的重要性

使用 threaded IRQ 时必须指定 IRQF_ONESHOT 标志,其作用是:在 thread_fn 执行期间始终保持硬件中断处于 mask 状态(防止重复中断),thread_fn 执行完毕后自动 unmask。对比非 ONESHOT 模式:

  • IRQF_ONESHOT:中断在 thread_fn 完成后才 re-enable。确保中断处理程序不会被重入。这是 systemd/udev 默认要求驱动使用的模式(因为所有驱动通过 shared IRQ 注册到内核)
  • 不带 ONESHOT:中断在 hardirq 返回后立即 re-enable。如果设备的中断是边沿触发的,且 thread_fn 尚未完成 ACK,会导致重复触发 hardirq,不断产生新的 thread_fn 调用(中断风暴)

7.3 IRQ 线程管理

调用 request_threaded_irq 时,内核会创建一个名为 irq/%d-%s 的实时调度策略线程(通常是 SCHED_FIFO,优先级 50)。IRQ 线程具有以下特性:

  • 调度策略:默认 SCHED_FIFO rtprio=50,可通过 chrt 动态调整
  • CPU 亲和性:与硬件中断相同的 affinity 设置
  • 休眠支持:thread_fn 中可以调用 msleep()、mutex_lock() 等可能阻塞的函数
  • Cgroup 控制:通过 cpuset.cpus 限制 IRQ 线程的可用 CPU

8. 中断亲和性与多队列调度

8.1 irq_set_affinity

通过设置中断亲和性(affinity),将指定中断绑定到特定 CPU 核心:

// 用户空间设置
echo 4 > /proc/irq/128/smp_affinity  // 绑定到 CPU2(bitmask 方式,4=0100)
echo 2 > /proc/irq/128/smp_affinity_list // 绑定到 CPU1(列表方式)

// 内核空间设置
int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m);
int irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);

现代多队列网卡的推荐配置:每个 RX/TX 队列使用独立中断向量,通过 SMP affinity 分配到不同 CPU,实现线性扩展。例如 Intel E810 8 队列网卡推荐配置:

#!/bin/bash
# 将 8 个中断分别绑定到 CPU0-CPU7
irqs=$(grep eth0-TxRx /proc/interrupts | awk '{print $1}' | tr -d ':')
cpu=0
for irq in $irqs; do
    echo $cpu > /proc/irq/$irq/smp_affinity_list
    cpu=$((cpu + 1))
done

8.2 irqbalance 考虑

irqbalance 是用户空间守护进程,动态调整中断亲和性以平衡 CPU 负载,同时考虑 NUMA 局部性和 CACHE 一致性。常见问题:

  • irqbalance 与手动 affinity 冲突:手动设置 affinity 后 irqbalance 仍可能修改(取决于 irqbalance 版本和模式)。已知 FIXED 筛选模式可避免干扰
  • NUMA 节点内负载倾斜:当所有中断都分配到同一 NUMA 节点而应用跨节点运行时,会产生跨节点内存访问。此时应关闭 irqbalance 并手动绑定
  • 实时系统中关闭 irqbalance:irqbalance 的中断迁移可能导致实时任务的延迟抖动。建议关闭 irqbalance 并手动绑定中断

9. 不可屏蔽中断(NMI)与性能监控

NMI 是一种无法通过 local_irq_disable() 屏蔽的中断。常见来源包括:

  • Machine Check Exception (MCE):硬件错误(内存 ECC 错误、总线错误等)
  • NMI Watchdog:内核配置 CONFIG_LOCKUP_DETECTOR,用于检测 CPU 是否长时间未响应中断(softlockup)或中断中停留过长(hardlockup)
  • Performance Monitoring:perf 使用 NMI 进行采样式性能分析(PEBS),因为只有 NMI 能在中断 disabled 时采样
  • IPI (Inter-Processor Interrupt):部分架构使用 NMI 发送 IPI 进行 CPU 间通信(如 RESCHEDULE、CALL_FUNCTION)

NMI Watchdog 的实现方式是通过 Local APIC 的 Performance Counter Interrupt 周期性地检查 CPU 运行状态。如果在 WATCHDOG_THRESHOLD(默认 20s)秒内 PMI 中断未触发对应的 handler,说明 CPU 出现 softlockup/hardlockup,内核打印 WARNING 和当前调用栈。

10. 中断上下文与并发控制

10.1 上下文判断

  • in_interrupt():返回 true 表示当前在任何中断上下文中(hardirq 或 softirq)。不能睡眠,不能使用 GFP_KERNEL
  • in_irq():仅在 hardirq 上下文返回 true
  • in_softirq()、in_serving_softirq():判断是否正在执行 softirq
  • in_atomic():更严格,atomic context 下不能睡眠

10.2 自旋锁与 BH 版本的选择

锁作用域使用场景
spin_lock / spin_unlock全局禁用抢占 + 自旋等待非中断上下文保护
spin_lock_irq / spin_unlock_irq额外关中断(本地 CPU)hardirq 与进程上下文共享的数据
spin_lock_irqsave / spin_unlock_irqrestore保存并恢复中断状态re-entrant 场景,不确定之前中断是否已关
spin_lock_bh / spin_unlock_bh额外禁用下半部 (BH)softirq/tasklet/workqueue 与进程上下文共享的数据
local_irq_disable / local_irq_enable仅开关中断,无锁修改了全局中断路由时

11. 生产级实战案例

11.1 案例一:网卡中断风暴治理

问题描述:X710 40Gbps 网卡小包转发场景下,ksoftirqd CPU 100%,吞吐仅 8Gbps。

诊断步骤:

  1. 查看 /proc/interrupts 确认中断集中在单个 CPU
  2. 查看 /proc/softirqs 确认 NET_RX 计数快速增长
  3. 通过 mpstat -P ALL 1 确认 CPU 调度瓶颈
  4. 查看网卡队列数:ethtool -l eth0 确认是否开启多队列

解决方案:

  1. 开启网卡多队列:ethtool -L eth0 combined 16
  2. 对每个 RX 队列启用 RPS 分发
  3. 启用 busy poll:sysctl net.core.busy_poll=50
  4. 绑定中断到非实时任务 CPU(避免中断与业务任务竞争):通过 taskset 将用户进程绑定到中断未使用的 CPU 集合
  5. 终极方案:启用 NAPI weight 调优 sysctl net.core.netdev_budget=600 和 sysctl net.core.netdev_budget_usecs=8000 增加单次 NAPI poll 处理的报文数

11.2 案例二:实时系统中断隔离

问题描述:工业控制系统场景中,实时任务周期 50μs,偶尔出现 200μs 以上的延迟。

诊断步骤:

  1. 使用 cyclictrace -p 90 -g 50 -i 50 测量调度延迟
  2. 发现延迟与 SCSI 控制器中断处理时间相关
  3. 使用 trace-cmd record -e irq -e irq_handler_entry -e irq_handler_exit 确认中断时间分布

解决方案:

  1. GRUB 参数 isolcpus=2,3 nohz_full=2,3 rcu_nocbs=2,3:将 CPU2-3 从调度器、tick 和 RCU 中隔离
  2. 通过 cpuset 将所有中断亲和性排除 CPU2-3
  3. 实时任务通过 taskset -c 2-3 或 sched_setaffinity() 绑定到隔离 CPU
  4. 实时任务使用 SCHED_FIFO 优先级高于 IRQ 线程优先级(默认 50)
  5. 启用 PREEMPT_RT 内核补丁,进一步降低中断相关的不可抢占窗口

最终效果:实时任务调度延迟从 200μs 降至 30μs 以内。

11.3 案例三:中断处理函数优化

问题描述:自定义 FPGA 中断每 1ms 触发一次,后续处理需要 ~500μs,使用传统 hardirq 导致相邻设备中断被阻塞。

解决方案:改用 threaded IRQ + IRQF_ONESHOT:

static irqreturn_t fpga_hardirq_handler(int irq, void *dev_id)
{
    struct fpga_dev *dev = dev_id;
    
    // 步骤 1: 读取中断状态寄存器
    status = ioread32(dev->mmio + FPGA_INT_STATUS);
    
    if (!status)
        return IRQ_NONE;  // 不是本设备中断
    
    // 步骤 2: ACK 中断(清除设备端中断源)
    iowrite32(status, dev->mmio + FPGA_INT_CLEAR);
    
    // 步骤 3: 保存供 thread_fn 使用
    dev->irq_status = status;
    
    // 步骤 4: 唤醒线程
    return IRQ_WAKE_THREAD;
}

static irqreturn_t fpga_thread_fn(int irq, void *dev_id)
{
    struct fpga_dev *dev = dev_id;
    int status = dev->irq_status;
    
    // 耗时 500μs 的处理:解析数据、DMA 传输、通知用户空间
    // 这里可以使用 mutex、kmalloc(GFP_KERNEL) 等可能阻塞的函数
    process_fpga_data(dev, status);
    return IRQ_HANDLED;
}

// 注册
request_threaded_irq(pdev->irq, fpga_hardirq_handler, fpga_thread_fn,
                     IRQF_ONESHOT | IRQF_TRIGGER_RISING,
                    "fpga-int", dev);

效果:hardirq 处理时间从 500μs 降至 5μs(仅 ACK),不再阻塞其他设备中断。

12. 调试与观测工具

12.1 /proc/interrupts

cat /proc/interrupts 是最常用的中断统计工具,显示每个 CPU 上每种中断的触发计数。关键字段解读:

  • 第一列为中断号(IRQ number)
  • 各 CPU 列为该中断在各核心上的触发次数
  • Type 列为中断类型(PCI-MSI-edge、IO-APIC-edge 等)
  • 最后一列为设备标识
  • 某列计数 > 其他列 = 中断亲和性不均匀;所有 CPU 计数均衡 = 可能存在 RPS

如果发现某个中断计数异常高于其他中断(且对应网卡是单队列),可能需要 RPS 分发。

12.2 /proc/softirqs

cat /proc/softirqs 显示 softirq 触发计数。NET_RX 计数快速增加且 ksoftirqd CPU 高是典型的收包瓶颈。HI、TIMER、SCH 等类型的异常增长也需要关注。

12.3 ftrace irqsoff tracer

用于检测关中断的最长时间段:



推荐学习路径:先通过阅读 kernel/irq/handle.c(hardirq 分发入口)理解 handle_irq_event() 流程,再深入到 arch/x86/kernel/apic/ 阅读 APIC 驱动实现中断路由和优先级排队,最后结合 kernel/softirq.c 和 kernel/workqueue.c 理解下半部调度机制。硬件参考:Intel SDM Volume 3 Chapter 10(Local APIC 规范)、ARM IHI 0069(GIC 架构规范)。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部