Softirq & Hardirq

Linux 커널의 하드웨어 인터럽트(Hardirq)와 소프트웨어 인터럽트(Softirq)를 심층 분석합니다. 인터럽트 컨텍스트, Softirq 메커니즘, ksoftirqd, Tasklet, NAPI, 성능 최적화까지 종합적으로 다룹니다.

특히 "어떤 작업을 Hardirq에서 끝내고 어떤 작업을 Softirq로 넘겨야 하는가"를 판단할 수 있도록 실행 컨텍스트 제약, 지연(Latency) 시간 예산, per-CPU 병렬성, ksoftirqd/N로의 인계 조건을 구체적으로 설명합니다. 네트워크 경로의 NET_RX_SOFTIRQ 적체, CPU 사용률 급등, tail latency 증가 같은 현장을 기준으로 모니터링 지표와 튜닝 순서를 함께 제시하여 성능 문제를 재현 가능하게 분석할 수 있도록 했습니다.

개요

Linux 커널은 인터럽트 처리를 상반부(Top Half)와 하반부(Bottom Half)로 분리합니다. 이 분리는 초기 Unix 시스템에서부터 이어진 설계 원칙으로, 하드웨어 응답성과 복잡한 처리 로직을 동시에 만족시키기 위한 핵심 아키텍처입니다.

역사적 배경

Bottom Half의 개념은 Linux 2.0 시절 bh_base[] 배열(32개 슬롯)에서 시작되었습니다. 이 구조는 전역 락으로 보호되어 SMP 확장성이 매우 낮았습니다. Linux 2.3에서 softirq와 tasklet이 도입되면서 Per-CPU 실행이 가능해졌고, 2.5에서 workqueue가 추가되어 프로세스(Process) 컨텍스트 Bottom Half를 완성했습니다. Linux 4.x 이후에는 PREEMPT_RT 패치(Patch)셋의 mainline 통합이 진행되면서 softirq의 스레드화가 본격적으로 논의되었습니다.

Hardirq vs Softirq

인터럽트 처리 흐름

Hardirq (하드웨어 인터럽트)

Hardirq는 하드웨어가 CPU에 신호를 보내 즉시 실행되는 인터럽트 핸들러입니다.

Hardirq 핸들러 등록

/* include/linux/interrupt.h */
int request_irq(unsigned int irq,
               irq_handler_t handler,
               unsigned long flags,
               const char *name,
               void *dev);

/* 예제: UART 드라이버 */
static irqreturn_t uart_interrupt(int irq, void *dev_id)
{
    struct uart_port *port = dev_id;
    unsigned int status;

    /* 1. 하드웨어 상태 읽기 */
    status = readl(port->membase + UART_STATUS);

    /* 2. 최소한의 처리 */
    if (status & UART_RX_READY) {
        char ch = readl(port->membase + UART_DATA);
        uart_insert_char(port, ch);  /* 버퍼에 저장만 */
    }

    /* 3. Softirq로 실제 처리 위임 */
    tasklet_schedule(&port->tasklet);

    return IRQ_HANDLED;
}

인터럽트 스택 전환 메커니즘

하드웨어 인터럽트가 발생하면 CPU는 현재 프로세스의 커널 스택에서 전용 Per-CPU IRQ 스택으로 전환합니다. 이는 인터럽트 핸들러가 현재 태스크의 스택 공간을 소비하여 스택 오버플로(Stack Overflow)를 유발하는 것을 방지합니다.

/* arch/x86/kernel/irq_64.c - Per-CPU IRQ 스택 정의 */
DEFINE_PER_CPU_PAGE_ALIGNED(struct irq_stack, irq_stack_backing_store)
    __aligned(IRQ_STACK_SIZE);

/* IRQ 스택 크기 = THREAD_SIZE (보통 16KB, x86_64) */
#define IRQ_STACK_SIZE  THREAD_SIZE

/* arch/x86/include/asm/irq_stack.h - 스택 전환 매크로 */
#define call_on_irqstack_cond(func, regs, asm_call, argconstr, ...)  \
({                                                                    \
    /* 이미 IRQ 스택에 있는지 확인 */                              \
    if (__this_cpu_read(pcpu_hot.hardirq_stack_inuse)) {            \
        func(__VA_ARGS__);  /* 이미 IRQ 스택 → 직접 호출 */       \
    } else {                                                       \
        __this_cpu_write(pcpu_hot.hardirq_stack_inuse, true);       \
        asm_call_irq_on_stack(func, __VA_ARGS__);                   \
        __this_cpu_write(pcpu_hot.hardirq_stack_inuse, false);      \
    }                                                                  \
})

x86_64에서는 추가로 IST(Interrupt Stack Table)가 존재합니다. TSS(Task State Segment)에 7개의 IST 항목을 정의할 수 있으며, NMI, Double Fault, MCE(Machine Check Exception) 등 치명적 예외는 IST를 통해 현재 스택 상태와 무관하게 안전한 스택에서 실행됩니다.

IRQF 플래그 상세 레퍼런스

request_irq() 호출 시 전달하는 flags 매개변수는 인터럽트의 동작 방식을 세밀하게 제어합니다. 다음은 include/linux/interrupt.h에 정의된 주요 IRQF 플래그입니다.

/* 실전 IRQF 플래그 조합 예제 */

/* 1) PCI 디바이스 공유 IRQ */
request_irq(pci_irq, my_pci_handler, IRQF_SHARED,
            "my_pci_dev", dev);

/* 2) Threaded IRQ + Level-triggered (I2C 센서 등)
 *    IRQF_ONESHOT 필수: level-triggered에서 없으면
 *    threaded handler 실행 전에 인터럽트가 재발생하여 IRQ storm */
request_threaded_irq(gpio_irq,
    NULL,          /* hardirq handler 없음 */
    sensor_thread_fn,
    IRQF_TRIGGER_LOW | IRQF_ONESHOT,
    "i2c_sensor", sensor_data);

/* 3) 웨이크업 소스 (전원 버튼) */
request_irq(pwr_irq, power_btn_handler,
            IRQF_NO_SUSPEND | IRQF_TRIGGER_FALLING,
            "power_btn", NULL);

Edge Trigger vs Level Trigger

인터럽트 신호 방식은 크게 Edge-triggered와 Level-triggered로 나뉘며, 각각 다른 flow handler가 처리합니다. 이 차이는 인터럽트 유실과 IRQ storm 방지에 직접 영향을 미칩니다.

/* kernel/irq/chip.c - Edge vs Level 핵심 차이점 */

/* Edge-triggered: ACK 먼저 → 핸들러 → 재발생 확인 */
void handle_edge_irq(struct irq_desc *desc)
{
    raw_spin_lock(&desc->lock);
    desc->irq_data.chip->irq_ack(&desc->irq_data);  /* 즉시 ACK */

    do {
        handle_irq_event(desc);  /* 핸들러 체인 실행 */
    } while (desc->istate & IRQS_PENDING);  /* 실행 중 재발생? */

    raw_spin_unlock(&desc->lock);
}

/* Level-triggered: Mask → 핸들러 → Unmask */
void handle_level_irq(struct irq_desc *desc)
{
    raw_spin_lock(&desc->lock);
    mask_ack_irq(desc);  /* Mask + ACK (재발생 방지) */

    handle_irq_event(desc);  /* 핸들러가 HW 원인 제거 */

    cond_unmask_irq(desc);  /* Unmask (이제 안전) */
    raw_spin_unlock(&desc->lock);
}

Softirq 타입

Linux는 정적으로 10가지 Softirq 타입을 정의합니다.

Softirq 우선순위(Priority) 순서

Softirq 정의

/* include/linux/interrupt.h */
enum
{
    HI_SOFTIRQ=0,
    TIMER_SOFTIRQ,
    NET_TX_SOFTIRQ,
    NET_RX_SOFTIRQ,
    BLOCK_SOFTIRQ,
    IRQ_POLL_SOFTIRQ,
    TASKLET_SOFTIRQ,
    SCHED_SOFTIRQ,
    HRTIMER_SOFTIRQ,
    RCU_SOFTIRQ,

    NR_SOFTIRQS
};

/* kernel/softirq.c */
struct softirq_action {
    void (*action)(struct softirq_action *);
};

static struct softirq_action softirq_vec[NR_SOFTIRQS];

Softirq 메커니즘

Softirq는 raise_softirq()로 스케줄링되고 do_softirq()로 실행됩니다. 핵심 구조는 Per-CPU irq_stat.__softirq_pending 비트맵과 softirq_vec[] 핸들러 배열의 조합입니다.

10종 Softirq 벡터 상세

각 softirq 벡터는 커널의 특정 서브시스템에 전용으로 할당되어 있으며, 초기화 시 open_softirq()로 등록됩니다. 새로운 softirq 추가는 커널 서브시스템 수준의 결정이며, 드라이버에서는 tasklet이나 workqueue를 사용해야 합니다.

Softirq 스케줄링

/* kernel/softirq.c */
void raise_softirq(unsigned int nr)
{
    unsigned long flags;

    local_irq_save(flags);
    raise_softirq_irqoff(nr);
    local_irq_restore(flags);
}

inline void raise_softirq_irqoff(unsigned int nr)
{
    __raise_softirq_irqoff(nr);

    /* 현재 hardirq 컨텍스트가 아니면 즉시 처리 시도 */
    if (!in_interrupt())
        wakeup_softirqd();
}

void __raise_softirq_irqoff(unsigned int nr)
{
    /* CPU별 pending 비트 설정 */
    or_softirq_pending(1UL << nr);
}

Softirq 실행 (__do_softirq)

/* kernel/softirq.c */
asmlinkage void __do_softirq(void)
{
    unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
    int max_restart = MAX_SOFTIRQ_RESTART;
    struct softirq_action *h;
    __u32 pending;

restart:
    /* Pending softirq 비트 읽기 */
    pending = local_softirq_pending();
    set_softirq_pending(0);

    local_irq_enable();  /* ← 인터럽트 활성화! */

    h = softirq_vec;
    do {
        if (pending & 1) {
            unsigned int vec_nr = h - softirq_vec;

            trace_softirq_entry(vec_nr);
            h->action(h);  /* ← Softirq 핸들러 호출 */
            trace_softirq_exit(vec_nr);
        }
        h++;
        pending >>= 1;
    } while (pending);

    local_irq_disable();

    /* 새 pending이 생겼고 시간/반복 제한 내면 재실행 */
    pending = local_softirq_pending();
    if (pending && time_before(jiffies, end) && --max_restart)
        goto restart;

    /* 여전히 pending이 남았으면 ksoftirqd 깨우기 */
    if (pending)
        wakeup_softirqd();
}

Hardirq 핸들러 체인

하드웨어 인터럽트가 발생하면 CPU는 인터럽트 벡터 테이블을 통해 커널의 인터럽트 엔트리 포인트에 진입합니다. 이후 irq_desc 구조체(Struct)를 통해 등록된 핸들러 체인을 순회합니다.

/* kernel/irq/irqdesc.c - irq_desc 구조체 (핵심 필드) */
struct irq_desc {
    struct irq_data       irq_data;       /* 하드웨어 IRQ 정보 */
    struct irqaction     *action;         /* 핸들러 체인 (linked list) */
    struct irq_chip      *irq_chip;       /* 인터럽트 컨트롤러 ops */
    irq_flow_handler_t    handle_irq;     /* 흐름 핸들러 (level/edge) */
    unsigned int          irq_count;      /* 인터럽트 발생 횟수 */
    unsigned int          depth;          /* disable 깊이 */
    const char           *name;           /* 디바이스 이름 */
};

/* kernel/irq/handle.c - 핸들러 체인 실행 */
irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
{
    struct irqaction *action;
    irqreturn_t retval = IRQ_NONE;

    /* 공유 IRQ: 모든 핸들러를 순회 */
    for_each_action_of_desc(desc, action) {
        irqreturn_t res;
        res = action->handler(desc->irq_data.irq, action->dev_id);

        switch (res) {
        case IRQ_WAKE_THREAD:
            /* threaded handler 깨우기 */
            irq_wake_thread(desc, action);
            break;
        case IRQ_HANDLED:
            retval |= res;
            break;
        }
    }
    return retval;
}

irq_exit() → invoke_softirq() 전환

하드웨어 인터럽트 처리가 완료되면 irq_exit()에서 pending softirq를 확인하고 실행합니다. 이것이 Hardirq에서 Softirq로의 전환 지점입니다.

/* kernel/softirq.c */
void irq_exit(void)
{
    preempt_count_sub(HARDIRQ_OFFSET);  /* hardirq 카운트 감소 */

    if (!in_interrupt() && local_softirq_pending())
        invoke_softirq();  /* softirq 실행 시작 */

    tick_irq_exit();
}

static inline void invoke_softirq(void)
{
#ifdef CONFIG_IRQ_FORCED_THREADING
    if (force_irqthreads()) {
        /* PREEMPT_RT: ksoftirqd에서 처리 */
        wakeup_softirqd();
        return;
    }
#endif
    if (!force_irqthreads() || !__this_cpu_read(ksoftirqd)) {
        __do_softirq();  /* 인라인 실행 */
    } else {
        wakeup_softirqd();
    }
}

ksoftirqd 커널 스레드(Kernel Thread)

ksoftirqd는 CPU당 하나씩 존재하며, Softirq 부하가 높을 때 처리를 대신합니다.

ksoftirqd 메인 루프

/* kernel/softirq.c */
static int ksoftirqd(void *__bind_cpu)
{
    set_current_state(TASK_INTERRUPTIBLE);

    while (!kthread_should_stop()) {
        if (!local_softirq_pending())
            schedule();  /* Pending 없으면 sleep */

        set_current_state(TASK_RUNNING);

        while (local_softirq_pending()) {
            __do_softirq();  /* Softirq 처리 */
            cond_resched();  /* 스케줄링 포인트 */
        }

        set_current_state(TASK_INTERRUPTIBLE);
    }
    return 0;
}

ksoftirqd 프로세스 확인

ps aux | grep ksoftirqd
# root         5  0.0  0.0      0     0 ?        S    Jan01   0:12 [ksoftirqd/0]
# root        15  0.0  0.0      0     0 ?        S    Jan01   0:08 [ksoftirqd/1]
# root        20  0.0  0.0      0     0 ?        S    Jan01   0:05 [ksoftirqd/2]
# ...

ksoftirqd 활성화 조건

ksoftirqd가 깨어나는 경우는 세 가지입니다. 각 경로는 wakeup_softirqd()를 호출하여 해당 CPU의 ksoftirqd 스레드를 TASK_RUNNING으로 전환합니다.

인터럽트 컨텍스트 확인

현재 코드가 어떤 컨텍스트에서 실행 중인지 확인하는 매크로(Macro)입니다.

컨텍스트 확인 매크로

구현

/* include/linux/preempt.h */
#define in_irq()         (hardirq_count())
#define in_softirq()      (softirq_count())
#define in_interrupt()   (irq_count())
#define in_task()         (!in_interrupt() && !(current->flags & PF_EXITING))

/* 사용 예 */
void my_function(void)
{
    if (in_interrupt()) {
        /* 인터럽트 컨텍스트 - sleep 금지 */
        spin_lock(&my_lock);
    } else {
        /* 프로세스 컨텍스트 - mutex 사용 가능 */
        mutex_lock(&my_mutex);
    }
}

preempt_count 구조

인터럽트 컨텍스트 확인 매크로(in_irq(), in_softirq(), in_interrupt() 등)는 모두 preempt_count의 비트 필드를 검사합니다. 이 32비트 카운터는 PREEMPT(비트 0-7), SOFTIRQ(비트 8-15), HARDIRQ(비트 16-19), NMI(비트 20) 영역으로 나뉘어 현재 CPU의 실행 컨텍스트를 인코딩합니다. 비트 필드 구조, 각 매크로의 동작 원리, 선점 모델 비교 등 상세 내용은 preempt_count 문서를 참조하세요.

local_bh_disable/enable 메커니즘

프로세스 컨텍스트에서 softirq 핸들러와 공유 데이터를 보호하려면 local_bh_disable()/local_bh_enable()을 사용합니다. 이 API는 preempt_count의 SOFTIRQ 비트를 조작하여 현재 CPU에서 softirq 실행을 억제합니다. (preempt_count 비트 필드 구조와 in_softirq() 매크로의 동작 원리는 preempt_count 문서에서 다룹니다.)

/* kernel/softirq.c */
void __local_bh_disable_ip(unsigned long ip, unsigned int cnt)
{
    /* preempt_count에 SOFTIRQ_DISABLE_OFFSET 추가 */
    __preempt_count_add(cnt);
    barrier();
}

void __local_bh_enable_ip(unsigned long ip, unsigned int cnt)
{
    /* 주의: preempt_count 감소 전에 pending softirq 확인 */
    __preempt_count_sub(cnt);

    if (unlikely(!in_interrupt() && local_softirq_pending())) {
        /* BH 활성화 시점에 pending softirq가 있으면 즉시 처리 */
        do_softirq();
    }
    preempt_check_resched();
}

/* 사용 예: 프로세스 컨텍스트에서 softirq 보호 */
void my_data_access(void)
{
    local_bh_disable();
    /* 이 구간에서는 현재 CPU에서 softirq가 실행되지 않음 */
    /* 다른 CPU의 softirq는 여전히 실행 가능 → 공유 데이터면 spinlock 추가 */
    shared_data->counter++;
    local_bh_enable();  /* pending softirq가 있으면 여기서 처리됨 */
}

/* 동기화 계층 정리 */
/*
 * spin_lock_bh()  = spin_lock() + local_bh_disable()
 * spin_unlock_bh()= spin_unlock() + local_bh_enable()
 *
 * 용도: 프로세스 컨텍스트 ↔ softirq 간 공유 데이터 보호
 *       (다른 CPU의 softirq도 차단하려면 lock이 필요)
 */

Per-CPU Softirq Pending 비트맵

각 CPU는 독립적인 __softirq_pending 비트맵을 가집니다. 이 Per-CPU 설계 덕분에 softirq raise/check 시 락이 불필요합니다.

/* arch/x86/include/asm/hardirq.h */
typedef struct {
    unsigned int __softirq_pending;   /* 10비트 사용 (NR_SOFTIRQS=10) */
    unsigned int __nmi_count;
    unsigned int apic_timer_irqs;
    /* ... */
} irq_cpustat_t;

DECLARE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);

/* Per-CPU pending 비트 조작 API */
#define local_softirq_pending()  \
    __this_cpu_read(irq_stat.__softirq_pending)

#define set_softirq_pending(x)  \
    __this_cpu_write(irq_stat.__softirq_pending, (x))

#define or_softirq_pending(x)   \
    __this_cpu_or(irq_stat.__softirq_pending, (x))

각 Softirq 벡터 분석

10개의 softirq 벡터는 각각 커널의 핵심 서브시스템에 전용으로 할당되어 있습니다. 각 벡터의 내부 동작을 이해하면 /proc/softirqs 분석 시 어떤 서브시스템이 병목인지 빠르게 파악할 수 있습니다.

TIMER_SOFTIRQ: 타이머 휠 상호작용

TIMER_SOFTIRQ는 커널 타이머(timer_list)의 만료 콜백을 처리합니다. 타이머 휠(Timer Wheel)은 계층적 구조로 구성되어 효율적인 만료 검사를 수행합니다.

/* kernel/time/timer.c - run_timer_softirq 핵심 경로 */
static void run_timer_softirq(struct softirq_action *h)
{
    struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);

    __run_timers(base);
}

static void __run_timers(struct timer_base *base)
{
    raw_spin_lock_irq(&base->lock);

    /* base->clk를 현재 jiffies까지 전진시키며 만료 타이머 수집 */
    while (time_after_eq(jiffies, base->clk) &&
           (base->clk < base->next_expiry)) {
        struct hlist_head heads[LVL_DEPTH];
        int levels;

        /* 타이머 휠 각 레벨에서 만료 타이머 수집 */
        levels = collect_expired_timers(base, heads);
        base->clk++;

        while (levels--) {
            expire_timers(base, heads + levels);
        }
    }
    raw_spin_unlock_irq(&base->lock);
}

static void expire_timers(struct timer_base *base,
                          struct hlist_head *head)
{
    while (!hlist_empty(head)) {
        struct timer_list *timer;
        void (*fn)(struct timer_list *);

        timer = hlist_entry(head->first, struct timer_list, entry);
        base->running_timer = timer;  /* 디버그 추적 */
        fn = timer->function;

        raw_spin_unlock_irq(&base->lock);
        call_timer_fn(timer, fn, base->clk);  /* 콜백 실행 */
        raw_spin_lock_irq(&base->lock);
    }
}

타이머 휠은 9개 레벨(LVL_DEPTH)로 구성되며, 각 레벨은 64개 버킷(Bucket)을 가집니다. 레벨이 올라갈수록 타이머 해상도가 낮아지고 먼 미래의 타이머를 관리합니다.

BLOCK_SOFTIRQ와 IRQ_POLL_SOFTIRQ: 블록 I/O 완료

BLOCK_SOFTIRQ는 블록 디바이스의 I/O 완료 처리를 담당합니다. 디바이스 드라이버가 I/O 완료를 통지하면 Per-CPU blk_cpu_done 리스트에 request가 쌓이고, softirq에서 배치로 완료 콜백을 실행합니다.

/* block/blk-softirq.c - 블록 I/O 완료 softirq */
static DEFINE_PER_CPU(struct llist_head, blk_cpu_done);

static void blk_done_softirq(struct softirq_action *h)
{
    struct llist_node *entry;

    /* Per-CPU 완료 리스트를 atomic하게 가져옴 */
    entry = llist_del_all(this_cpu_ptr(&blk_cpu_done));
    entry = llist_reverse_order(entry);

    while (entry) {
        struct request *rq;
        rq = llist_entry(entry, struct request, ipi_list);
        entry = entry->next;

        rq->q->mq_ops->complete(rq);  /* blk-mq 완료 콜백 */
    }
}

/* 드라이버에서 I/O 완료 통지 */
void blk_complete_request(struct request *rq)
{
    /* 완료를 처리할 CPU 선택 (요청을 발생시킨 CPU 우선) */
    int cpu = cyclic_submit_cpu;

    if (llist_add(&rq->ipi_list, &per_cpu(blk_cpu_done, cpu)))
        raise_softirq_irqoff(BLOCK_SOFTIRQ);
}

IRQ_POLL_SOFTIRQ는 NVMe 등 고성능 블록 디바이스를 위한 NAPI 스타일 폴링 메커니즘입니다. 기존 인터럽트 방식 대신 폴링으로 I/O 완료를 감지하여 인터럽트 오버헤드를 제거합니다.

SCHED_SOFTIRQ: CPU 간 로드 밸런싱

SCHED_SOFTIRQ는 CFS(Completely Fair Scheduler) 또는 EEVDF 스케줄러의 CPU 간 로드 밸런싱을 트리거합니다. 스케줄링 도메인(Scheduling Domain) 계층을 순회하며 부하 불균형을 감지하고 태스크를 마이그레이션합니다.

/* kernel/sched/fair.c - SCHED_SOFTIRQ 핸들러 */
static void run_rebalance_domains(struct softirq_action *h)
{
    struct rq *this_rq = this_rq();
    enum cpu_idle_type idle;

    /* 현재 CPU가 idle인지 판단 */
    idle = this_rq->idle_balance ? CPU_IDLE : CPU_NOT_IDLE;

    /* nohz 밸런싱 트리거 (유휴 CPU 대신 밸런싱) */
    nohz_idle_balance(this_rq, idle);

    /* 스케줄링 도메인 계층 순회하며 밸런싱 */
    rebalance_domains(this_rq, idle);
}

static void rebalance_domains(struct rq *rq,
                              enum cpu_idle_type idle)
{
    struct sched_domain *sd;
    int continue_balancing = 1;

    /* 아래에서 위로: SMT → MC → DIE → NUMA */
    for_each_domain(cpu_of(rq), sd) {
        if (time_after_eq(jiffies, sd->next_balance)) {
            load_balance(cpu_of(rq), rq, sd, idle,
                        &continue_balancing);
            sd->next_balance = jiffies + sd->balance_interval;
        }
    }
}

RCU_SOFTIRQ: Grace Period와 콜백 처리

RCU_SOFTIRQ는 RCU(Read-Copy-Update) 서브시스템의 핵심 경로입니다. Grace period 진행 상태를 확인하고, 완료된 grace period의 콜백을 배치로 실행합니다.

/* kernel/rcu/tree.c - RCU softirq 핸들러 */
static void rcu_core_si(struct softirq_action *h)
{
    rcu_core();
}

static void rcu_core(void)
{
    struct rcu_data *rdp = this_cpu_ptr(&rcu_data);
    struct rcu_node *rnp = rdp->mynode;

    /* 1. 정지 상태(Quiescent State) 보고 */
    if (rdp->core_needs_qs) {
        rcu_report_qs_rdp(rdp);
    }

    /* 2. 완료된 grace period의 콜백 진행 */
    if (rcu_segcblist_ready_cbs(&rdp->cblist)) {
        rcu_do_batch(rdp);
    }

    /* 3. 새 grace period 시작 필요 시 처리 */
    rcu_check_gp_start_stall(rnp, rdp, rcu_jiffies_till_stall_check());
}

/* rcu_do_batch(): 콜백 배치 실행 */
static void rcu_do_batch(struct rcu_data *rdp)
{
    long bl = rdp->blimit;  /* 한 번에 처리할 콜백 수 제한 */

    while (rcu_segcblist_ready_cbs(&rdp->cblist) && bl--) {
        struct rcu_head *rhp;
        rhp = rcu_segcblist_dequeue(&rdp->cblist);

        /* RCU 콜백 실행 (kfree, 구조체 해제 등) */
        debug_rcu_head_callback(rhp);
        rhp->func(rhp);
    }
}

Per-CPU rcu_data 구조체는 세그먼트 콜백 리스트(segmented callback list)를 관리합니다. 콜백은 4단계로 분류됩니다:

Softirq

softirq는 커널에 정적으로 컴파일되는 Bottom Half 메커니즘으로, 10개의 고정 타입이 존재합니다. 네트워킹, 블록 I/O, 타이머 등 성능이 극도로 중요한 서브시스템에서 사용됩니다. 새로운 softirq를 추가하는 것은 커널 서브시스템 수준의 결정이며, 드라이버에서는 사용하지 않습니다.

open_softirq() 등록 API

softirq 핸들러는 커널 초기화 시 open_softirq()로 등록됩니다. 각 softirq 타입에 대해 하나의 핸들러만 존재하며, 런타임에 변경할 수 없습니다:

/* kernel/softirq.c */
static struct softirq_action softirq_vec[NR_SOFTIRQS];

void open_softirq(int nr, void (*action)(struct softirq_action *))
{
    softirq_vec[nr].action = action;
}

/* 각 서브시스템의 초기화 코드에서 등록 */
open_softirq(NET_TX_SOFTIRQ, net_tx_action);   /* net/core/dev.c */
open_softirq(NET_RX_SOFTIRQ, net_rx_action);   /* net/core/dev.c */
open_softirq(TASKLET_SOFTIRQ, tasklet_action);  /* kernel/softirq.c */
open_softirq(HI_SOFTIRQ, tasklet_hi_action);    /* kernel/softirq.c */
open_softirq(TIMER_SOFTIRQ, run_timer_softirq); /* kernel/time/timer.c */
open_softirq(SCHED_SOFTIRQ, run_rebalance_domains); /* kernel/sched/fair.c */
open_softirq(RCU_SOFTIRQ, rcu_core_si);         /* kernel/rcu/tree.c */

raise_softirq() vs raise_softirq_irqoff()

softirq를 트리거하려면 pending 비트를 설정해야 합니다. 두 가지 API가 존재합니다:

/* 일반적인 사용: 인터럽트 상태를 자동으로 저장/복원 */
void raise_softirq(unsigned int nr)
{
    unsigned long flags;
    local_irq_save(flags);       /* IRQ 비활성화 + 플래그 저장 */
    raise_softirq_irqoff(nr);
    local_irq_restore(flags);    /* 이전 IRQ 상태 복원 */
}

/* 이미 IRQ가 비활성화된 상태에서 사용 (top half 내부 등) */
void raise_softirq_irqoff(unsigned int nr)
{
    __raise_softirq_irqoff(nr);  /* or_softirq_pending(1 << nr) */
    /* 인터럽트 컨텍스트가 아니면 ksoftirqd를 깨움 */
    if (!in_interrupt())
        wakeup_softirqd();
}

/* 사용 예: hard IRQ 핸들러 내부 (이미 IRQ 비활성 상태) */
static irqreturn_t my_handler(int irq, void *dev)
{
    /* ... 최소 작업 ... */
    raise_softirq_irqoff(NET_RX_SOFTIRQ);  /* 효율적 */
    return IRQ_HANDLED;
}

__do_softirq() 내부 구현

__do_softirq()는 softirq의 핵심 실행 루프입니다. pending 비트맵을 순회하며 등록된 핸들러를 호출하되, starvation 방지를 위한 제한이 존재합니다:

/* kernel/softirq.c - 핵심 실행 루프 (간략화) */
#define MAX_SOFTIRQ_TIME    msecs_to_jiffies(2)   /* 최대 2ms */
#define MAX_SOFTIRQ_RESTART 10                    /* 최대 10회 재시작 */

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

    pending = local_softirq_pending();   /* Per-CPU pending 비트 읽기 */

    __local_bh_disable_ip(_RET_IP_, SOFTIRQ_OFFSET);

restart:
    set_softirq_pending(0);              /* pending 클리어 */
    local_irq_enable();                  /* IRQ 재활성화 */

    h = softirq_vec;
    while (pending) {
        if (pending & 1) {
            h->action(h);               /* softirq 핸들러 호출 */
        }
        h++;
        pending >>= 1;
    }

    local_irq_disable();
    pending = local_softirq_pending();   /* 새로 발생한 softirq 확인 */

    /* 재시작 조건: pending 있고, 횟수/시간 제한 이내 */
    if (pending && --max_restart &&
        time_before(jiffies, end))
        goto restart;

    /* 제한 초과: ksoftirqd에 위임 */
    if (pending)
        wakeup_softirqd();

    __local_bh_enable(SOFTIRQ_OFFSET);
}

ksoftirqd 생명주기

ksoftirqd는 Per-CPU 커널 스레드로, softirq 처리의 폴백 경로를 담당합니다:

/* kernel/softirq.c - ksoftirqd 메인 루프 (간략화) */
static int ksoftirqd_should_run(unsigned int cpu)
{
    return local_softirq_pending();
}

static void run_ksoftirqd(unsigned int cpu)
{
    local_irq_disable();
    if (local_softirq_pending()) {
        __do_softirq();
        local_irq_enable();
        cond_resched();         /* 다른 태스크에 CPU 양보 */
        return;
    }
    local_irq_enable();
}

/*
 * ksoftirqd 특성:
 * - Per-CPU: ksoftirqd/0, ksoftirqd/1, ...
 * - 스케줄링 정책: SCHED_NORMAL (nice 0)
 * - 깨어나는 조건:
 *   1. __do_softirq()에서 시간/횟수 제한 초과
 *   2. 인터럽트 비활성 상태에서 raise_softirq() 호출
 *   3. local_bh_enable()에서 pending softirq 발견
 * - ksoftirqd는 일반 프로세스와 동일한 우선순위로 스케줄링됨
 *   → 높은 부하에서 softirq 지연 발생 가능 (의도된 동작)
 */

Per-CPU 동시성 모델

softirq의 가장 중요한 특성은 같은 softirq 타입이 여러 CPU에서 동시에 실행될 수 있다는 점입니다. 이는 높은 성능을 제공하지만, 공유 데이터에 대한 동기화가 필수입니다:

/*
 * Softirq 동시성 규칙:
 *
 * 1. 같은 softirq가 여러 CPU에서 동시 실행 가능
 *    → NET_RX_SOFTIRQ: CPU0과 CPU1에서 동시 실행 가능
 *    → Per-CPU 데이터 사용으로 락 최소화
 *
 * 2. 같은 CPU에서는 softirq가 중첩되지 않음
 *    → softirq 실행 중 동일 CPU의 다른 softirq는 대기
 *
 * 3. Hard IRQ만 softirq를 선점 가능
 *    → softirq 실행 중 동일 CPU의 프로세스는 실행 불가
 *
 * 4. 동기화 패턴:
 *    - softirq 간: spin_lock() (preemption은 이미 비활성)
 *    - softirq + 프로세스: spin_lock_bh() (프로세스 쪽)
 *    - softirq + hard IRQ: spin_lock_irq() (softirq 쪽)
 */

/* 예: 네트워크 수신 softirq의 Per-CPU 데이터 활용 */
DEFINE_PER_CPU(struct softnet_data, softnet_data);

static void net_rx_action(struct softirq_action *h)
{
    /* Per-CPU 데이터 접근 → 락 불필요 */
    struct softnet_data *sd = this_cpu_ptr(&softnet_data);
    struct list_head *list = &sd->poll_list;

    while (!list_empty(list)) {
        /* NAPI polling ... */
    }
}

선점 모드별 동작

PREEMPT_RT에서의 Softirq 처리

PREEMPT_RT(Real-Time) 커널에서는 softirq의 동작이 근본적으로 변경됩니다. 모든 softirq가 ksoftirqd 커널 스레드에서 실행되어, softirq 핸들러도 선점 가능한 일반 스레드 컨텍스트에서 동작합니다. 이를 통해 결정적(deterministic) 지연시간을 보장합니다.

/* PREEMPT_RT에서의 주요 변환 */

/* 1. spin_lock → rt_mutex로 변환 */
/*    → softirq 핸들러도 sleep 가능 (priority inheritance 지원) */

/* 2. local_bh_disable() → Per-CPU 락으로 변환 */
/*    → softirq 직렬화를 preempt_count 대신 실제 락으로 구현 */

/* 3. ksoftirqd 우선순위 조정 */
/*    chrt -f -p 50 $(pgrep -f "ksoftirqd/0")
 *    → ksoftirqd를 SCHED_FIFO로 전환하여 softirq 지연 감소 */

/* 4. 개별 softirq 스레드 (일부 RT 패치) */
/*    softirq 유형별로 별도 스레드를 생성하여
 *    NET_RX와 TIMER의 우선순위를 독립적으로 조정 가능 */

CPU 격리와 Softirq

지연시간에 민감한 애플리케이션(HFT, 실시간 제어, 통신 장비)은 특정 CPU를 완전히 격리하여 softirq, 스케줄러 밸런싱, RCU 콜백 등의 간섭을 제거해야 합니다. Linux는 세 가지 커널 부트 파라미터를 조합하여 이를 달성합니다.

isolcpus, nohz_full, rcu_nocbs

# 완전 격리 커널 커맨드라인 예시 (CPU 4-7 격리)
isolcpus=managed_irq,domain,4-7 nohz_full=4-7 rcu_nocbs=4-7 irqaffinity=0-3

# 격리 상태 확인
cat /sys/devices/system/cpu/nohz_full
# 출력: 4-7

cat /sys/devices/system/cpu/isolated
# 출력: 4-7

# rcuog kthread 확인 (RCU 콜백 오프로드 스레드)
ps -eo pid,psr,comm | grep rcuog
# rcuog/4, rcuog/5, rcuog/6, rcuog/7 → 하우스키핑 CPU에서 실행

# 격리 CPU에서 softirq 거의 없는지 확인
cat /proc/softirqs
#            CPU0      CPU1      CPU2      CPU3      CPU4  CPU5  CPU6  CPU7
# TIMER: 13691355  12345678  11234567  10123456        2     1     1     0
# SCHED:  8745632   7654321   6543210   5432109        0     0     0     0
# RCU:    5367890   4567890   3456789   2345678        0     0     0     0

# 격리 CPU에 애플리케이션 고정
taskset -c 4-7 ./latency_critical_app

BPF/XDP와 Softirq 컨텍스트

XDP(eXpress Data Path)와 TC BPF(Traffic Control BPF)는 NET_RX_SOFTIRQ 경로에서 BPF 프로그램을 실행합니다. 이는 커널 네트워크 스택의 매우 초기 단계에서 패킷을 처리하여 높은 성능을 달성하지만, softirq 실행 시간에 직접 영향을 미칩니다.

/* XDP 실행 지점 — 드라이버 NAPI poll 내부 (igb 예시) */

/* drivers/net/ethernet/intel/igb/igb_main.c (간략화) */
static int igb_clean_rx_irq(struct igb_q_vector *q_vec,
                            const int budget)
{
    while (likely(total_packets < budget)) {
        struct xdp_buff xdp;

        /* DMA 완료된 디스크립터에서 데이터 포인터 설정 */
        xdp_prepare_buff(&xdp, hard_start, headroom, size, true);

        /* ★ XDP BPF 프로그램 실행 (skb 할당 전!) */
        u32 act = bpf_prog_run_xdp(xdp_prog, &xdp);

        switch (act) {
        case XDP_PASS:
            break;     /* 정상 경로: skb 생성 후 스택 진행 */
        case XDP_DROP:
            igb_rx_buffer_flip(rx_ring, rx_buffer);
            continue;  /* 패킷 폐기: skb 미생성, 매우 빠름 */
        case XDP_TX:
            igb_xdp_xmit_back(adapter, &xdp);
            continue;  /* 같은 NIC으로 TX: 헤어핀 모드 */
        case XDP_REDIRECT:
            xdp_do_redirect(netdev, &xdp, xdp_prog);
            continue;  /* 다른 NIC/AF_XDP 소켓으로 전달 */
        }

        /* XDP_PASS: 일반 경로 진행 — skb 할당 + GRO */
        skb = igb_construct_skb(rx_ring, rx_buffer, &xdp, timestamp);
        napi_gro_receive(&q_vector->napi, skb);
    }
}

# BPF 프로그램별 실행 시간/횟수 확인
bpftool prog show
# 출력:  run_time_ns: 1234567890  run_cnt: 50000000
# → 평균 24.7ns/packet

# softirq 시간 프로파일링
perf stat -e irq:softirq_entry,irq:softirq_exit -a sleep 5

# XDP 통계 확인
ip -s link show dev eth0 xdp
# XDP xdp0: prog_id 42  drv  actions: pass 1000 drop 50000 redirect 0

/proc/softirqs 분석 방법

/proc/softirqs는 부팅 이후 각 CPU에서 처리된 softirq 횟수를 누적 표시합니다. 이 데이터를 주기적으로 캡처하여 차이를 계산하면 실시간(Real-time) softirq 부하를 파악할 수 있습니다.

# 1초 간격으로 softirq 처리량 변화 확인
watch -d -n 1 'cat /proc/softirqs'

# 특정 시간 동안의 softirq 증가량 측정
cat /proc/softirqs > /tmp/softirq_before
sleep 10
cat /proc/softirqs > /tmp/softirq_after
diff /tmp/softirq_before /tmp/softirq_after

# perf로 softirq 실행 시간 프로파일링
perf stat -e irq:softirq_entry,irq:softirq_exit -a sleep 5

# ftrace로 개별 softirq 실행 추적
echo 1 > /sys/kernel/tracing/events/irq/softirq_entry/enable
echo 1 > /sys/kernel/tracing/events/irq/softirq_exit/enable
cat /sys/kernel/tracing/trace_pipe

Softirq 문제 진단 패턴

# CPU별 softirq 불균형 빠른 확인 스크립트
awk 'NR>1 {
  name=$1
  total=0
  for(i=2;i<=NF;i++) total+=$i
  printf "%-20s total=%10d\n", name, total
}' /proc/softirqs

# 출력 예:
# HI:                 total=         3
# TIMER:              total=  13691355
# NET_TX:             total=    386418
# NET_RX:             total=  32839506  ← 가장 높은 부하
# BLOCK:              total=    116046
# IRQ_POLL:           total=         0
# TASKLET:            total=     28934
# SCHED:              total=   8745632
# RCU:                total=   5367890

관련 Bottom Half 메커니즘

Softirq 위에 구현되거나 관련된 메커니즘들에 대한 상세 문서 안내입니다.

모니터링

Softirq와 Hardirq 활동을 모니터링하는 방법입니다.

/proc/softirqs

cat /proc/softirqs
#                    CPU0       CPU1       CPU2       CPU3
#       HI:          2          1          0          0
#    TIMER:    3456789    3234567    3012345    2987654
#   NET_TX:     123456      98765      87654      76543
#   NET_RX:    9876543    8765432    7654321    6543210  ← 높음!
#    BLOCK:      45678      34567      23456      12345
#      RCU:    1234567    1123456    1012345     987654

mpstat으로 softirq 비율 확인

mpstat -P ALL 1
# CPU    %usr   %nice    %sys %iowait    %irq   %soft  %idle
#   0    5.2     0.0    10.3     1.2     0.5    25.8   57.0   ← soft 25%!
#   1    3.1     0.0     8.7     0.8     0.3    18.2   68.9

/proc/interrupts

cat /proc/interrupts
#            CPU0       CPU1       CPU2       CPU3
#   45:  12345678   11234567   10123456    9012345   IR-PCI-MSI 524288-edge      eth0
#  125:       123        234        345        456   IR-PCI-MSI   1-edge      nvme0q1

성능 튜닝

Softirq 부하를 조정하고 최적화하는 방법입니다.

NAPI Budget 조정

# 한 번의 NAPI poll에서 처리할 최대 패킷 수
sysctl -w net.core.netdev_budget=600    # 기본값: 300

# NAPI poll이 소비할 수 있는 최대 시간 (μs)
sysctl -w net.core.netdev_budget_usecs=8000  # 기본값: 2000

IRQ Affinity 설정

# IRQ 45번을 CPU 2-3에만 할당
echo "c" > /proc/irq/45/smp_affinity  # 0xc = 0b1100 = CPU 2,3

# irqbalance 비활성화 (수동 설정 시)
systemctl stop irqbalance

RPS/RFS (네트워크)

# RPS (Receive Packet Steering): 패킷 처리를 여러 CPU로 분산
echo "f" > /sys/class/net/eth0/queues/rx-0/rps_cpus  # 0xf = CPU 0-3

# RFS (Receive Flow Steering): 애플리케이션 CPU로 패킷 전달
echo 32768 > /proc/sys/net/core/rps_sock_flow_entries
echo 2048 > /sys/class/net/eth0/queues/rx-0/rps_flow_cnt

인터럽트 코얼레싱(Interrupt Coalescing)

인터럽트 코얼레싱은 여러 이벤트를 하나의 인터럽트로 합쳐서 hardirq 빈도를 줄이는 기법입니다. 인터럽트가 줄어들면 softirq 트리거 빈도도 함께 줄어들어 CPU 오버헤드가 감소하지만, 개별 이벤트의 지연시간은 증가합니다.

하드웨어 코얼레싱 (ethtool -C)

대부분의 NIC는 하드웨어 수준의 인터럽트 코얼레싱을 지원합니다. ethtool -C로 설정합니다.

# 현재 코얼레싱 설정 확인
ethtool -c eth0
# Adaptive RX: on  TX: off
# rx-usecs: 3
# rx-frames: 0
# tx-usecs: 0
# tx-frames: 0

# 저지연 설정 (HFT, 실시간): 코얼레싱 최소화
ethtool -C eth0 rx-usecs 0 rx-frames 1 adaptive-rx off

# 고처리량 서버: 공격적 코얼레싱
ethtool -C eth0 rx-usecs 100 rx-frames 64 adaptive-rx off

# 균형 설정: NIC 자동 조정
ethtool -C eth0 adaptive-rx on adaptive-tx on

# 인터럽트 코얼레싱 효과 확인: IRQ 빈도 측정
watch -d -n 1 'grep eth0 /proc/interrupts'

소프트웨어 코얼레싱과 Busy Polling

하드웨어 코얼레싱 외에도 소프트웨어 수준에서 인터럽트-softirq 경로를 최적화하는 방법이 있습니다. 특히 Busy Polling은 softirq를 완전히 우회하는 극단적 최적화입니다.

Busy Polling은 애플리케이션 스레드가 직접 NIC을 폴링하여 패킷을 가져옵니다. IRQ → softirq → wakeup 체인을 건너뛰므로 지연시간이 극도로 낮아지지만, CPU를 전용으로 소비합니다.

/* 소켓 레벨 busy polling 설정 */
int val = 50;  /* 폴링 대기 시간 (μs) */
setsockopt(fd, SOL_SOCKET, SO_BUSY_POLL, &val, sizeof(val));

/* SO_PREFER_BUSY_POLL: 가능하면 항상 busy poll 우선 */
int prefer = 1;
setsockopt(fd, SOL_SOCKET, SO_PREFER_BUSY_POLL, &prefer, sizeof(prefer));

# 시스템 전체 busy polling 설정
sysctl -w net.core.busy_poll=50     # poll() 대기 시간 (μs)
sysctl -w net.core.busy_read=50     # read() 대기 시간 (μs)

# NAPI prefer busy poll (커널 5.13+)
echo 1 > /sys/class/net/eth0/napi_defer_hard_irqs
echo 200000 > /sys/class/net/eth0/gro_flush_timeout  # 200μs

NAPI 수신 경로

NET_RX_SOFTIRQ 부하의 대부분은 NAPI poll 루프에서 발생합니다. 패킷 한 개의 이동 경로를 정확히 보면 병목 지점을 빠르게 찾을 수 있습니다.

드라이버 IRQ부터 프로토콜 스택까지

/* net/core/dev.c 중심 경로 (간략화) */
static irqreturn_t igb_msix_ring(int irq, void *data)
{
    struct igb_q_vector *q_vector = data;

    /* 하드웨어 인터럽트 마스크 + NAPI 스케줄 */
    if (napi_schedule_prep(&q_vector->napi)) {
        igb_irq_disable(q_vector);
        __napi_schedule(&q_vector->napi);
    }
    return IRQ_HANDLED;
}

void __napi_schedule(struct napi_struct *n)
{
    struct softnet_data *sd = this_cpu_ptr(&softnet_data);
    list_add_tail(&n->poll_list, &sd->poll_list);
    __raise_softirq_irqoff(NET_RX_SOFTIRQ);
}

static void net_rx_action(struct softirq_action *h)
{
    struct softnet_data *sd = this_cpu_ptr(&softnet_data);
    int budget = netdev_budget;

    while (budget > 0 && !list_empty(&sd->poll_list)) {
        struct napi_struct *n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
        int work = n->poll(n, min(budget, n->weight));
        budget -= work;
    }
}

락 설계와 동기화 패턴

softirq 코드는 컨텍스트별 락 선택이 잘못되면 즉시 데드락이나 심각한 지연으로 이어집니다. 아래 표는 실무에서 가장 자주 쓰는 조합입니다.

/* 잘못된 예: softirq가 접근하는 큐에 mutex 사용 */
struct my_queue {
    struct list_head head;
    struct mutex lock;  /* softirq 경로에서 사용 불가 */
};

void bad_enqueue_from_softirq(struct my_queue *q, struct packet *p)
{
    mutex_lock(&q->lock);   /* BUG: sleep 가능 API */
    list_add_tail(&p->node, &q->head);
    mutex_unlock(&q->lock);
}

/* 올바른 예: 프로세스와 softirq 공유 큐 */
struct good_queue {
    struct list_head head;
    spinlock_t lock;
};

void enqueue_from_process(struct good_queue *q, struct packet *p)
{
    spin_lock_bh(&q->lock);
    list_add_tail(&p->node, &q->head);
    spin_unlock_bh(&q->lock);
}

void enqueue_from_softirq(struct good_queue *q, struct packet *p)
{
    spin_lock(&q->lock);
    list_add_tail(&p->node, &q->head);
    spin_unlock(&q->lock);
}

지연시간 타임라인 분석

tail latency는 대부분 "인터럽트 폭주 → softirq 재시작 반복 → ksoftirqd 이관" 구간에서 악화됩니다. 이벤트 타임라인을 단위 시간으로 나눠 보면 원인 구분이 쉬워집니다.

지연시간 계측 지표

실전 트러블슈팅 플레이북

운영 중 장애 상황에서 즉시 적용할 수 있는 점검 순서입니다. 핵심은 원인 축을 빠르게 좁히는 것입니다.

1. 증상 고정
   mpstat -P ALL 1, top -H로 어느 CPU에서 %soft와 ksoftirqd/N가 치솟는지 확인합니다.
2. softirq 타입 식별
   동일 구간의 /proc/softirqs 차분으로 NET_RX/TIMER/RCU 중 어떤 축이 급증하는지 확인합니다.
3. IRQ 소스 매핑(Mapping)
   /proc/interrupts에서 급증 IRQ를 NIC 큐/스토리지 큐와 매핑합니다.
4. 분산 정책 교정
   IRQ affinity, RPS/RFS/XPS를 재정렬해 한 CPU 집중을 먼저 해소합니다.
5. budget/코얼레싱 조정
   NAPI budget과 인터럽트 코얼레싱 값을 동시에 조정하며 처리량 대비 지연시간을 측정합니다.
6. RT/격리(Isolation) 검토
   tail latency 요구가 높으면 PREEMPT_RT 또는 CPU isolation을 적용합니다.

# 1) CPU별 softirq 상태 10초 캡처
for i in $(seq 1 10); do
  date +%T
  cat /proc/softirqs
  sleep 1
done > /tmp/softirq-sample.log

# 2) 인터럽트 상위 소스 확인
cat /proc/interrupts | sort -nrk2 | head -n 20

# 3) ksoftirqd 스케줄 지연 확인
perf sched record -a -- sleep 10
perf sched latency

# 4) tracepoint 기반 softirq 실행 추적
echo 1 > /sys/kernel/tracing/events/irq/softirq_entry/enable
echo 1 > /sys/kernel/tracing/events/irq/softirq_exit/enable
sleep 5
cat /sys/kernel/tracing/trace > /tmp/softirq-trace.txt

do_IRQ() → handle_irq_event() 호출 체인

하드웨어 인터럽트가 발생하면 CPU는 IDT(Interrupt Descriptor Table)를 통해 아키텍처별 진입점에 도달하고, 최종적으로 등록된 핸들러를 호출합니다. x86 기준 전체 호출 체인은 다음과 같습니다.

최종 단계인 __handle_irq_event_percpu()는 irq_desc에 연결된 irqaction 체인을 순회하며 각 핸들러를 호출합니다. 핸들러의 반환값(irqreturn_t)에 따라 후속 처리가 결정됩니다.

/* kernel/irq/handle.c - 간소화 */
irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc)
{
    irqreturn_t retval = IRQ_NONE;
    struct irqaction *action;

    /* irqaction 체인 순회 (공유 IRQ 지원) */
    for_each_action_of_desc(desc, action) {
        irqreturn_t res;

        trace_irq_handler_entry(desc->irq_data.irq, action);
        res = action->handler(desc->irq_data.irq, action->dev_id);
        trace_irq_handler_exit(desc->irq_data.irq, action, res);

        switch (res) {
        case IRQ_WAKE_THREAD:
            __irq_wake_thread(desc, action);
            /* fall through */
        case IRQ_HANDLED:
            retval |= res;
            break;
        default:
            break;
        }
    }

    return retval;
}

irqreturn_t 반환값 분석

모든 핸들러가 IRQ_NONE을 반환하면 커널은 note_interrupt()를 통해 spurious interrupt를 추적합니다. 연속 99,900회 이상 spurious가 발생하면 해당 IRQ 라인이 비활성화(__report_bad_irq)됩니다.

Softirq Raise/Execute 사이클 상세

Softirq의 생명주기는 크게 두 단계로 나뉩니다: Raise(대기 등록)와 Execute(실행). 이 두 단계는 Per-CPU pending 비트맵을 매개로 비동기적으로 연결됩니다.

Raise 경로

raise_softirq()는 지정된 softirq 번호에 해당하는 비트를 Per-CPU __softirq_pending에 설정합니다. 이 함수는 hardirq 핸들러, tasklet, 타이머 콜백 등 다양한 컨텍스트에서 호출됩니다.

Execute 경로

Softirq 실행은 세 가지 경로에서 트리거됩니다:

1. irq_exit() — hardirq 처리 완료 후 pending softirq가 있으면 __do_softirq() 호출
2. local_bh_enable() — BH 비활성화 해제 시 pending 확인
3. ksoftirqd — 위 두 경로에서 예산 초과 시 커널 스레드로 위임

__do_softirq() 루프 상세

__do_softirq()는 pending 비트맵을 순회하며 각 softirq 핸들러를 실행합니다. 재시작 횟수(MAX_SOFTIRQ_RESTART = 10)와 시간 제한(MAX_SOFTIRQ_TIME = 2ms)을 두어 softirq가 CPU를 독점하는 것을 방지합니다.

/* kernel/softirq.c - __do_softirq() 핵심 루프 상세 */
#define MAX_SOFTIRQ_TIME  msecs_to_jiffies(2)
#define MAX_SOFTIRQ_RESTART  10

asmlinkage __visible void __do_softirq(void)
{
    unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
    unsigned long old_flags = current->flags;
    int max_restart = MAX_SOFTIRQ_RESTART;
    struct softirq_action *h;
    bool in_hardirq;
    __u32 pending;

    /* softirq 진입: preempt_count에 SOFTIRQ_OFFSET 추가 */
    __local_bh_disable_ip(_RET_IP_, SOFTIRQ_OFFSET);

    /* hardirq에서 왔는지 확인 (irq_exit 경로) */
    in_hardirq = lockdep_softirq_start();

    /* 현재 CPU의 pending 비트를 읽고 초기화 */
restart:
    pending = local_softirq_pending();
    set_softirq_pending(0);

    local_irq_enable();  /* 인터럽트 재활성화 */

    h = softirq_vec;

    while (pending) {
        if (pending & 1) {
            unsigned int vec_nr = h - softirq_vec;
            int prev_count;

            kstat_incr_softirqs_this_cpu(vec_nr);
            trace_softirq_entry(vec_nr);
            h->action(h);          /* ← softirq 핸들러 실행 */
            trace_softirq_exit(vec_nr);
        }
        h++;
        pending >>= 1;
    }

    local_irq_disable();  /* 인터럽트 비활성화 후 pending 재확인 */

    pending = local_softirq_pending();
    if (pending) {
        /* 재시작 횟수 남아있고, 시간 제한 내이면 재시작 */
        if (time_before(jiffies, end) && !need_resched() &&
            --max_restart)
            goto restart;

        /* 예산 초과: ksoftirqd에 위임 */
        wakeup_softirqd();
    }

    __local_bh_enable(SOFTIRQ_OFFSET);
    current->flags = old_flags;
}

struct irq_desc / irqaction 구조체 분석

리눅스 커널의 인터럽트 관리는 두 핵심 구조체를 중심으로 구성됩니다. struct irq_desc는 각 IRQ 번호에 대한 메타데이터를, struct irqaction은 등록된 핸들러 정보를 담습니다.

/* include/linux/irqdesc.h - 핵심 필드 발췌 */
struct irq_desc {
    struct irq_data         irq_data;       /* IRQ 번호, HW IRQ, chip, domain */
    struct irqaction        *action;        /* 핸들러 연결 리스트 헤드 */
    irq_flow_handler_t     handle_irq;     /* flow handler (fasteoi, edge 등) */
    unsigned int           status_use_accessors; /* IRQ 상태 플래그 */
    unsigned int           depth;          /* disable 중첩 카운터 */
    unsigned int           irq_count;      /* spurious 감지용 인터럽트 총 횟수 */
    unsigned int           irqs_unhandled; /* spurious (IRQ_NONE) 횟수 */
    atomic_t               threads_handled; /* threaded 핸들러 완료 추적 */
    raw_spinlock_t         lock;           /* desc 보호 락 */
    unsigned int          *kstat_irqs;     /* Per-CPU 인터럽트 통계 */
    const char            *name;           /* /proc/interrupts 표시 이름 */
};

/* include/linux/interrupt.h - 핵심 필드 발췌 */
struct irqaction {
    irq_handler_t          handler;       /* hardirq 핸들러 (최상위 절반) */
    irq_handler_t          thread_fn;     /* threaded IRQ 핸들러 */
    struct task_struct     *thread;        /* IRQ 스레드 (자동 생성) */
    struct irqaction       *secondary;     /* 중첩 action (forced threading) */
    unsigned int           irq;           /* IRQ 번호 */
    unsigned int           flags;         /* IRQF_SHARED 등 플래그 */
    const char            *name;          /* /proc/interrupts 이름 */
    void                  *dev_id;        /* 디바이스 식별자 (공유 IRQ 구분) */
    void __percpu         *percpu_dev_id; /* Per-CPU 디바이스 ID */
    struct irqaction       *next;          /* 공유 IRQ 체인의 다음 action */
};

ksoftirqd 스레드 상세

ksoftirqd는 Per-CPU 커널 스레드로, softirq 처리가 __do_softirq()의 재시작 예산을 초과했을 때 나머지 pending softirq를 처리합니다. 우선순위 SCHED_NORMAL(nice 0)로 실행되어 일반 프로세스와 CPU를 공유합니다.

/* kernel/softirq.c - ksoftirqd 메인 루프 */
static void run_ksoftirqd(unsigned int cpu)
{
    /* pending softirq가 있는지 확인 */
    ksoftirqd_run_begin();

    if (local_softirq_pending()) {
        /* __do_softirq() 호출 — 동일한 softirq 실행 루프 */
        __do_softirq();
        ksoftirqd_run_end();
        cond_resched();     /* 자발적 선점 포인트 */
        return;
    }
    ksoftirqd_run_end();
}

/* ksoftirqd를 깨우는 조건들 */
static void wakeup_softirqd(void)
{
    struct task_struct *tsk = __this_cpu_read(ksoftirqd);

    if (tsk)
        wake_up_process(tsk);
}

wakeup_softirqd() 호출 조건

ksoftirqd가 깨어나는 주요 상황은 다음과 같습니다:

ksoftirqd의 실행 빈도는 /proc/softirqs에 직접 반영되지 않지만, ps -eo pid,psr,ni,comm | grep ksoftirq로 CPU 바인딩 상태와 실행 빈도를 확인할 수 있습니다. ksoftirqd가 높은 CPU 점유율을 보이면 softirq 폭주(특히 NET_RX)를 의심해야 합니다.

IRQ 스레드 마이그레이션과 어피니티

IRQ 어피니티(Affinity)는 특정 인터럽트를 어느 CPU에서 처리할지 제어하는 메커니즘입니다. 네트워크 카드의 RSS(Receive Side Scaling)나 NVMe의 다중 큐 구성에서 성능 최적화에 핵심적인 역할을 합니다.

irq_set_affinity() 경로

/* kernel/irq/manage.c - IRQ 어피니티 설정 경로 */
int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
{
    struct irq_desc *desc = irq_to_desc(irq);
    unsigned long flags;

    if (!desc)
        return -EINVAL;

    raw_spin_lock_irqsave(&desc->lock, flags);
    int ret = __irq_set_affinity_locked(
        irq_desc_get_irq_data(desc), mask, false);
    raw_spin_unlock_irqrestore(&desc->lock, flags);

    return ret;
}

/* 핵심 내부 함수 */
static int __irq_set_affinity_locked(
    struct irq_data *data, const struct cpumask *mask,
    bool force)
{
    struct irq_chip *chip = irq_data_get_irq_chip(data);

    if (!chip || !chip->irq_set_affinity)
        return -EINVAL;

    /* 하드웨어 수준에서 어피니티 변경 */
    int ret = chip->irq_set_affinity(data, mask, force);

    if (ret == IRQ_SET_MASK_OK || ret == IRQ_SET_MASK_OK_DONE) {
        cpumask_copy(irq_data_get_affinity_mask(data), mask);
        irqd_set(data, IRQD_AFFINITY_SET);
    }

    return ret;
}

CPU 핫플러그 시 IRQ 마이그레이션

CPU가 오프라인(offline)될 때, 해당 CPU에 할당된 모든 인터럽트는 다른 온라인 CPU로 마이그레이션되어야 합니다. irq_migrate_all_off_this_cpu()가 이 역할을 수행합니다.

/* kernel/irq/cpuhotplug.c - CPU 오프라인 시 IRQ 마이그레이션 */
void irq_migrate_all_off_this_cpu(void)
{
    unsigned int irq;
    struct irq_desc *desc;

    /* 모든 IRQ 디스크립터를 순회 */
    for_each_active_irq(irq) {
        desc = irq_to_desc(irq);

        /* Per-CPU 인터럽트는 마이그레이션 불필요 */
        if (irqd_is_per_cpu(&desc->irq_data))
            continue;

        raw_spin_lock(&desc->lock);

        /* 현재 CPU가 어피니티 마스크에 포함된 경우만 처리 */
        if (cpumask_test_cpu(smp_processor_id(),
                desc->irq_data.common->affinity)) {

            struct irq_data *d = &desc->irq_data;
            struct irq_chip *c = d->chip;
            int ret;

            /* 온라인 CPU 중에서 새 대상 선택 */
            cpumask_copy(&available, cpu_online_mask);
            cpumask_clear_cpu(smp_processor_id(), &available);

            ret = c->irq_set_affinity(d, &available, true);
            if (ret)
                pr_warn_ratelimited(
                    "IRQ%u: set affinity failed(%d)\n",
                    irq, ret);
        }

        raw_spin_unlock(&desc->lock);
    }
}

사용자 공간에서 IRQ 어피니티를 설정하려면 /proc/irq/<IRQ번호>/smp_affinity에 16진수 CPU 마스크를 기록합니다:

# IRQ 32를 CPU 0,1에만 할당
echo 3 > /proc/irq/32/smp_affinity

# 현재 어피니티 확인
cat /proc/irq/32/smp_affinity
# 출력: 00000003

# CPU 리스트 형식으로 설정 (더 직관적)
echo 0-1 > /proc/irq/32/smp_affinity_list

참고자료

커널 공식 문서

• Linux generic IRQ handling — 리눅스 범용 IRQ 처리 프레임워크 공식 문서입니다
• IRQ Domain Hierarchy — IRQ 도메인 계층 구조와 하드웨어 인터럽트 번호 매핑을 설명합니다
• RCU Requirements — RCU_SOFTIRQ의 설계 요구사항과 softirq 컨텍스트에서의 동작을 다룹니다
• NAPI — NET_RX_SOFTIRQ 기반 NAPI 폴링 메커니즘 공식 문서입니다
• Lock types and their rules — hardirq/softirq/process 컨텍스트별 락 사용 규칙을 정리합니다
• RT-mutex subsystem with PI support — PREEMPT_RT에서 softirq 스레드화와 관련된 RT-mutex를 설명합니다

커널 소스 코드

• kernel/softirq.c — softirq 코어 구현 (__do_softirq, raise_softirq, open_softirq, ksoftirqd)
• include/linux/interrupt.h — softirq 열거형, in_interrupt(), in_softirq() 매크로 정의입니다
• include/linux/hardirq.h — hardirq 카운터, irq_enter()/irq_exit() 매크로를 정의합니다
• include/linux/preempt.h — preempt_count 비트 필드 레이아웃 (HARDIRQ_OFFSET, SOFTIRQ_OFFSET)을 정의합니다
• kernel/irq/handle.c — handle_irq_event()와 IRQ 핸들러 실행 경로입니다
• kernel/irq/chip.c — IRQ 칩 드라이버 (level/edge/fasteoi 핸들러)입니다
• kernel/irq/manage.c — request_irq(), threaded IRQ, IRQ 어피니티 관리입니다
• net/core/dev.c — net_rx_action(), __napi_schedule() 등 NET_RX_SOFTIRQ 핸들러입니다
• block/blk-mq.c — BLOCK_SOFTIRQ를 사용하는 블록 I/O 완료 경로입니다
• kernel/rcu/tree.c — RCU_SOFTIRQ를 발생시키는 Tree RCU 구현입니다

LWN.net 기사

• Software interrupts and realtime (2012) — softirq의 역사와 PREEMPT_RT에서의 스레드화 문제를 심층 분석합니다
• Toward a better softirq model (2019) — softirq 모델 개선 논의와 ksoftirqd 제한 시간 문제를 다룹니다
• Softirqs and per-CPU variables (2020) — softirq에서 per-CPU 변수 사용 시 발생하는 미묘한 경합 조건을 분석합니다
• Closing the softirq debate (2023) — softirq 처리 횟수 제한과 ksoftirqd 전환 정책의 공정성 논쟁을 정리합니다
• Reworking NAPI (2016) — NET_RX_SOFTIRQ 기반 NAPI의 busy-polling 개선안을 설명합니다
• Generic interrupt flow handling — IRQ 흐름 핸들러(level, edge, fasteoi)의 커널 내부 동작을 해설합니다
• Moving interrupts to threads (2008) — Thomas Gleixner의 threaded IRQ 도입 배경과 hardirq 최소화 전략을 소개합니다

서적

• Understanding the Linux Kernel, 3rd Edition (Daniel P. Bovet, Marco Cesati) — Chapter 4 "Interrupts and Exceptions"에서 hardirq 처리를, Chapter 4.7 "Softirqs and Tasklets"에서 softirq 메커니즘을 상세히 설명합니다
• Linux Kernel Development, 3rd Edition (Robert Love) — Chapter 7 "Interrupts and Interrupt Handlers"와 Chapter 8 "Bottom Halves and Deferring Work"가 softirq/hardirq 경계를 명확히 구분합니다
• Linux Device Drivers, 3rd Edition (Jonathan Corbet, Alessandro Rubini, Greg Kroah-Hartman) — Chapter 10 "Interrupt Handling"에서 인터럽트 컨텍스트의 제약과 bottom-half 설계를 다룹니다
• Professional Linux Kernel Architecture (Wolfgang Mauerer) — Chapter 14 "Kernel Activities"에서 softirq 벡터별 동작과 ksoftirqd 스케줄링 정책을 분석합니다

외부 자료

• Monitoring and Tuning the Linux Networking Stack: Receiving Data — NET_RX_SOFTIRQ 경로를 패킷 수신 관점에서 커널 소스 레벨까지 추적합니다
• Linux Insides: Interrupts — x86 인터럽트 초기화부터 softirq 처리까지 단계별로 해설합니다
• Approaching Real-Time Linux (OLS 2006, Clark Williams) — PREEMPT_RT 패치에서 softirq 스레드화가 실시간 지연시간에 미치는 영향을 측정합니다

관련 문서

• 인터럽트 - 인터럽트 전체 개요
• IRQ 도메인 - 인터럽트 컨트롤러 추상화
• IPI - Inter-Processor Interrupt
• NMI - Non-Maskable Interrupt
• Tasklet - Tasklet 상태 머신, 직렬화, 마이그레이션
• Workqueue (CMWQ) - CMWQ 아키텍처, worker pool
• Bottom Half 선택 가이드 - 선택 기준, 실전 패턴
• 타이머 - TIMER_SOFTIRQ, HRTIMER_SOFTIRQ
• NAPI - 네트워크 폴링 최적화
• RCU - RCU_SOFTIRQ