/*
 * 软中断优先级枚举定义：数值越小，调度优先级越高
 * 内核固定排序，运行时不可修改，决定全局中断抢占逻辑
 * Linux 5.4 LTS 固定原生代码，无任何厂商自定义修改
 */
enum
{
    HI_SOFTIRQ=0,        /* 最高优先级：紧急硬件下半部 */
    TIMER_SOFTIRQ,       /* 定时器时序调度 */
    NET_TX_SOFTIRQ,      /* 网络发包软中断 */
    NET_RX_SOFTIRQ,      /* 网络收包软中断（雪崩核心诱因） */
    BLOCK_SOFTIRQ,       /* 块设备IO软中断 */
    IRQ_POLL_SOFTIRQ,    /* IO轮询软中断 */
    TASKLET_SOFTIRQ,     /* 通用任务切片软中断 */
    SCHED_SOFTIRQ,       /* 进程调度/负载均衡软中断（优先级低于网络收包） */
    HRTIMER_SOFTIRQ,     /* 高精度定时器 */
    RCU_SOFTIRQ,         /* RCU回收（最低优先级） */
    NR_SOFTIRQS          /* 软中断类型总数 */
};

asmlinkage void __do_softirq(void)
{
    unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
    int max_restart = MAX_SOFTIRQ_RESTART;
    struct softirq_action *h;

    /* 锁定软中断上下文，彻底禁止进程调度切入 */
    __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);

restart:
    /* 严格按优先级从高到低遍历执行软中断 */
    h = softirq_vec;
    do {
        if (softirq_pending(smp_processor_id())) {
            h->action(h);
            softirq_pending_clear(smp_processor_id());
        }
        h++;
    } while (h < softirq_vec + NR_SOFTIRQS);

    /* 核心雪崩机制：未超时则无限循环执行，不释放CPU */
    if ((jiffies < end) && --max_restart)
        goto restart;

    __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
}

static void net_rx_action(struct softirq_action *h)
{
    struct net_device *dev;
    int budget = netdev_budget;

    /* 持续收割Ring Buffer积压skb，耗尽budget为止 */
    while (!list_empty(&poll_list) && budget > 0) {
        dev = list_first_entry(&poll_list, struct net_device, poll_list);
        if (!dev->poll(dev, &budget))
            list_del_init(&dev->poll_list);
    }

    /* 关键雪崩闭环：残留报文未处理完毕，重新触发NET_RX软中断，无限抢占 */
    if (!list_empty(&poll_list))
        raise_softirq(NET_RX_SOFTIRQ);
}

int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
{
    struct irq_desc *desc = irq_to_desc(irq);
    unsigned long flags;

    raw_spin_lock_irqsave(&desc->lock, flags);
    /* 仅被动更新掩码，无实时流量感知、无突发负载预判 */
    cpumask_copy(&desc->affinity, mask);
    raw_spin_unlock_irqrestore(&desc->lock, flags);

    return 0;
}

unsigned long cpu_load_read(int cpu)
{
    /* 仅统计整体负载，彻底忽略软中断独占负载场景 */
    return weighted_cpuload(cpu);
}

static inline struct sk_buff *__alloc_skb(unsigned int size,
                                          gfp_t gfp_mask, int flags, int node)
{
    struct sk_buff *skb;
    /* 小包无批量缓存，每包独立调用SLUB分配 */
    skb = kmem_cache_alloc_node(skbuff_cache, gfp_mask, node);
    if (unlikely(!skb))
        return NULL;

    skb_init(skb);
    return skb;
}

void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
{
    struct slab *slab;
    void *object;

    /* 严格单对象分配，无小包批量复用、无预缓存 */
    slab = get_slab(s, node);
    object = slab_alloc(s, slab, gfpflags, node);
    return object;
}

static void watchdog_timer_fn(struct timer_list *t)
{
    struct watchdog_data *wd_data = from_timer(wd_data, t, timer);
    unsigned long touch = wd_data->touch_time;

    /* 核心判定：20s无心跳=无调度、无上下文切换，触发软锁死 */
    if (time_after(jiffies, touch + softlockup_thresh * HZ)) {
        pr_err("BUG: soft lockup - CPU#%d stuck for %lus!\n",
               smp_processor_id(), softlockup_thresh);
        dump_stack();
    }
}

/* x86架构默认8K内核栈，固定不可扩容，软中断递归极易溢出 */
#define THREAD_SIZE_ORDER 1
#define THREAD_SIZE  (PAGE_SIZE << THREAD_SIZE_ORDER)

uname -r