Threaded IRQ (스레드화 인터럽트(Interrupt))

request_threaded_irq() 기반 스레드화 인터럽트 핸들러(Handler)를 심층 분석합니다. 전통적 Top/Bottom Half 모델의 한계를 극복하기 위해 도입된 threaded IRQ의 설계 동기, hardirq handler와 thread_fn의 역할 분리, IRQ_ONESHOT 시맨틱, force_irqthreads 메커니즘, devm managed API, nested IRQ, PREEMPT_RT 통합을 커널 소스 기반으로 분석하고, I2C/SPI/GPIO/PCIe 실전 드라이버 패턴과 기존 드라이버 마이그레이션 가이드를 제공합니다.

Threaded IRQ 개요와 동기

전통적인 리눅스 인터럽트 처리 모델은 Top Half(hardirq)와 Bottom Half(softirq, tasklet, workqueue)로 나뉩니다. hardirq는 인터럽트를 비활성화한 상태에서 실행되므로 가능한 짧아야 하고, 나머지 작업은 Bottom Half로 위임합니다. 이 모델은 수십 년간 잘 작동했지만, 몇 가지 근본적인 한계가 있습니다.

전통 모델의 한계

Threaded IRQ가 해결하는 문제

Thomas Gleixner가 설계한 Threaded IRQ 모델은 인터럽트 처리를 두 단계로 명확히 분리합니다:

• hardirq handler: 인터럽트 비활성 상태에서 최소한의 작업(ACK, 상태 읽기, mask)만 수행하고 IRQ_WAKE_THREAD를 반환
• thread_fn: 전용 커널 스레드(irq/N-name)에서 프로세스 컨텍스트로 실행. 슬립 가능, 스케줄링 가능, 우선순위 설정 가능

역사

request_threaded_irq() API 상세

request_threaded_irq()는 threaded IRQ 등록의 핵심 함수입니다. kernel/irq/manage.c에 구현되어 있으며, 기존 request_irq()는 이 함수의 thread_fn=NULL 래퍼입니다.

함수 시그니처

/* include/linux/interrupt.h */
extern int request_threaded_irq(
    unsigned int       irq,          /* IRQ 번호 */
    irq_handler_t      handler,      /* hardirq 핸들러 (NULL 가능) */
    irq_handler_t      thread_fn,    /* 스레드 함수 (NULL 가능) */
    unsigned long      irqflags,     /* IRQF_* 플래그 */
    const char        *devname,      /* /proc/interrupts에 표시될 이름 */
    void              *dev_id       /* 핸들러에 전달될 인자 (공유 IRQ 시 식별자) */
);

/* handler 반환 값 */
typedef enum irqreturn {
    IRQ_NONE        = (0 << 0),  /* 이 디바이스의 인터럽트가 아님 */
    IRQ_HANDLED     = (1 << 0),  /* 처리 완료, 스레드 깨우지 않음 */
    IRQ_WAKE_THREAD = (1 << 1),  /* 스레드를 깨워서 thread_fn 실행 */
} irqreturn_t;

파라미터 상세 설명

handler가 NULL인 경우

handler를 NULL로 전달하면, 커널은 자동으로 irq_default_primary_handler()를 사용합니다. 이 기본 핸들러는 단순히 IRQ_WAKE_THREAD를 반환합니다:

/* kernel/irq/manage.c */
static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
{
    return IRQ_WAKE_THREAD;
}

/* 주의: handler=NULL + thread_fn만 사용할 때
 * 반드시 IRQF_ONESHOT을 설정해야 합니다!
 * 그렇지 않으면 커널이 경고를 출력하고 -EINVAL 반환 */

기본 사용 패턴

/* 패턴 1: hardirq handler + thread_fn */
static irqreturn_t my_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* 이 디바이스의 인터럽트인지 확인 (공유 IRQ 시 필수) */
    if (!(ioread32(dev->regs + STATUS) & IRQ_PENDING))
        return IRQ_NONE;

    /* 인터럽트 ACK (하드웨어에 처리 시작 알림) */
    iowrite32(IRQ_ACK, dev->regs + STATUS);

    return IRQ_WAKE_THREAD;
}

static irqreturn_t my_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* 프로세스 컨텍스트: 슬립 가능! */
    mutex_lock(&dev->lock);
    process_data(dev);
    mutex_unlock(&dev->lock);

    return IRQ_HANDLED;
}

/* probe에서 등록 */
ret = request_threaded_irq(irq, my_hardirq, my_thread_fn,
                           IRQF_ONESHOT, "my-device", dev);

/* 패턴 2: handler=NULL (기본 핸들러 사용) */
ret = request_threaded_irq(irq, NULL, my_thread_fn,
                           IRQF_ONESHOT, "my-sensor", dev);

반환값과 에러 코드

IRQF 플래그 상세

인터럽트 플래그는 include/linux/interrupt.h에 정의되어 있으며, threaded IRQ의 동작을 세밀하게 제어합니다. 올바른 플래그 조합은 안정적인 인터럽트 처리의 핵심입니다.

IRQF_COND_ONESHOT 상세 (v6.4+)

전통적으로 같은 IRQ 라인에 여러 드라이버가 등록될 때, 모든 등록자가 IRQF_ONESHOT 설정을 일치시켜야 했습니다. 특히 level-triggered 공유 라인에서는 ONESHOT이 필수인데, 레거시 드라이버가 먼저 ONESHOT 없이 등록해 둔 상태라면 이후 새 드라이버가 ONESHOT을 요구하며 등록하면 -EBUSY로 실패했습니다.

IRQF_COND_ONESHOT(v6.4 병합)은 이 경우에 대한 완화책입니다. "ONESHOT이 필요하지만, 이미 non-ONESHOT 등록자가 있다면 우리도 양보(Yield)하고 등록을 허용한다"는 의미로, 실제 동작은 첫 등록자의 설정에 따릅니다.

/* 실전 사용: 공유 라인에서 신규 등록이 공존하도록 허용 */
static int my_secondary_driver_probe(...)
{
    /*
     * - 단독 라인이면 ONESHOT으로 등록 (표준 동작)
     * - 공유 + 기존 등록자가 non-ONESHOT이면 ONESHOT 없이 등록
     * - 커널은 내부적으로 첫 등록자 설정을 따라감
     */
    return request_threaded_irq(irq, primary_handler, thread_fn,
                                IRQF_SHARED | IRQF_COND_ONESHOT,
                                dev_name(dev), dev);
}

플래그 조합 규칙

/* 규칙 1: handler=NULL이면 ONESHOT 필수 */
request_threaded_irq(irq, NULL, thread_fn,
    IRQF_ONESHOT, name, dev);         /* OK */
request_threaded_irq(irq, NULL, thread_fn,
    0, name, dev);                    /* FAIL: -EINVAL */

/* 규칙 2: IRQF_SHARED이면 handler 필수 */
request_threaded_irq(irq, my_handler, thread_fn,
    IRQF_SHARED | IRQF_ONESHOT, name, dev);  /* OK */
request_threaded_irq(irq, NULL, thread_fn,
    IRQF_SHARED | IRQF_ONESHOT, name, dev);  /* 주의: handler=NULL + SHARED 시 문제 */

/* 규칙 3: Level-triggered이면 ONESHOT 강력 권장 */
request_threaded_irq(irq, handler, thread_fn,
    IRQF_TRIGGER_LOW | IRQF_ONESHOT, name, dev);  /* OK */

IRQ_ONESHOT

IRQF_ONESHOT은 threaded IRQ에서 가장 중요한 플래그입니다. 이 플래그가 설정되면 hardirq handler 진입 시 인터럽트 라인이 마스킹되고, thread_fn이 완료된 후에야 언마스킹됩니다.

Level-Triggered에서 ONESHOT이 필수인 이유

Level-triggered 인터럽트는 인터럽트 라인이 활성 상태를 유지하는 한 계속 인터럽트를 발생시킵니다. 디바이스가 인터럽트를 발생시키면 CPU가 이를 감지하고 핸들러를 실행하지만, 핸들러가 끝나고 인터럽트가 재활성화되는 시점에 디바이스가 여전히 인터럽트 라인을 assert하고 있으면 즉시 다시 인터럽트가 발생합니다.

Threaded IRQ에서 hardirq handler는 단순히 IRQ_WAKE_THREAD만 반환하고, 실제 인터럽트 원인 제거(데이터 읽기, 상태 클리어 등)는 thread_fn에서 합니다. 따라서 ONESHOT 없이는:

1. hardirq handler 실행 (IRQ_WAKE_THREAD 반환)
2. 인터럽트 재활성화 (thread_fn 시작 전!)
3. 디바이스가 여전히 assert 중 -> 즉시 재발생
4. 1-3 반복 -> IRQ storm

Edge-Triggered에서의 ONESHOT

Edge-triggered 인터럽트에서는 ONESHOT이 필수는 아닙니다. 에지 트리거는 신호 전이(상승/하강) 시에만 인터럽트가 발생하므로, 라인이 활성 상태를 유지해도 반복 발생하지 않습니다. 그러나 thread_fn 실행 중에 발생한 새 인터럽트를 놓치지 않기 위해 ONESHOT을 사용하는 것이 안전한 관행입니다.

ONESHOT 마스킹 타임라인 상세

ONESHOT의 전체 마스킹 생명주기를 시간축으로 상세하게 표현합니다. 인터럽트 발생부터 마스킹, hardirq 처리, 스레드 웨이크업, thread_fn 실행, 인터럽트 원인 제거, 그리고 최종 언마스킹까지의 모든 단계를 포함합니다:

irq_thread 커널 스레드 내부

threaded IRQ를 등록하면 커널은 전용 커널 스레드를 생성합니다. 이 스레드의 메인 루프와 스케줄링 특성을 분석합니다.

스레드 생성 과정

/* kernel/irq/manage.c — __setup_irq() 내부 */
if (new->thread_fn && !nested) {
    struct task_struct *t;

    t = kthread_create(irq_thread, new,
                       "irq/%d-%s", irq, new->name);
    if (IS_ERR(t))
        return PTR_ERR(t);

    /* RT 우선순위 50으로 설정 (SCHED_FIFO) */
    sched_set_fifo(t);

    /* IRQ affinity와 동일하게 스레드 affinity 설정 */
    get_task_struct(t);
    new->thread = t;

    set_bit(IRQTF_AFFINITY, &new->thread_flags);
}

스레드 이름 규칙

생성된 스레드는 irq/N-name 형식의 이름을 가집니다:

$ ps -eo pid,cls,rtprio,comm | grep irq/
   85  FF    50 irq/9-acpi
  132  FF    50 irq/16-ahci
  207  FF    50 irq/27-i2c-touch
  341  FF    50 irq/136-xhci_hcd

irq_thread() 메인 루프

/* kernel/irq/manage.c — irq_thread() */
static int irq_thread(void *data)
{
    struct irqaction *action = data;
    struct irq_desc *desc = irq_to_desc(action->irq);

    irq_thread_check_affinity(desc, action);

    while (!irq_wait_for_interrupt(action)) {
        irqreturn_t action_ret;

        irq_thread_check_affinity(desc, action);

        action_ret = irq_thread_fn(desc, action);

        if (action_ret == IRQ_HANDLED)
            atomic_inc(&desc->threads_handled);

        wake_threads_waitq(desc);
    }

    return 0;
}

/* irq_wait_for_interrupt(): 스레드를 재운 뒤 IRQTF_RUNTHREAD가
 * 설정될 때까지 대기. hardirq handler가 IRQ_WAKE_THREAD를 반환하면
 * 이 플래그를 설정하고 스레드를 깨움 */

irq_wait_for_interrupt() 상세 분석

irq_wait_for_interrupt()는 IRQ 스레드의 핵심 대기 함수입니다. 이 함수는 스레드를 TASK_INTERRUPTIBLE 상태로 전환하고, hardirq handler가 IRQTF_RUNTHREAD 플래그를 설정할 때까지 대기합니다.

/* kernel/irq/manage.c — irq_wait_for_interrupt() */
static int irq_wait_for_interrupt(struct irqaction *action)
{
    /* 루프: kthread_should_stop() 확인으로 스레드 종료 지원 */
    for (;;) {
        set_current_state(TASK_INTERRUPTIBLE);

        /* IRQTF_RUNTHREAD 플래그가 설정되어 있으면 즉시 반환 */
        if (test_and_clear_bit(IRQTF_RUNTHREAD,
                              &action->thread_flags)) {
            __set_current_state(TASK_RUNNING);
            return 0;  /* 성공: thread_fn 실행 필요 */
        }

        /* 스레드 종료 요청 확인 (free_irq에서 호출) */
        if (kthread_should_stop()) {
            __set_current_state(TASK_RUNNING);
            return -1;  /* 종료: 메인 루프 탈출 */
        }

        /* 스케줄링 포인트: 여기서 실제로 슬립 */
        schedule();
    }
}

__irq_wake_thread() 상세

hardirq handler가 IRQ_WAKE_THREAD를 반환한 후, 커널이 스레드를 깨우는 과정을 분석합니다:

/* kernel/irq/manage.c — __irq_wake_thread() */
void __irq_wake_thread(struct irq_desc *desc,
                        struct irqaction *action)
{
    /* 이미 IRQTF_RUNTHREAD가 설정되어 있으면 스킵
     * (이전 인터럽트의 thread_fn이 아직 실행 중) */
    if (test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
        return;

    /* ONESHOT: threads_oneshot 비트마스크에 자신의 비트 설정
     * 이 비트가 모두 클리어될 때까지 IRQ 라인은 마스킹 유지 */
    if (desc->istate & IRQS_ONESHOT)
        atomic_or(action->thread_mask,
                  &desc->threads_oneshot);

    /* 스레드 실행 플래그 설정 */
    set_bit(IRQTF_RUNTHREAD, &action->thread_flags);

    /* 스레드를 깨움: TASK_INTERRUPTIBLE -> TASK_RUNNING */
    wake_up_process(action->thread);
}

thread_flags 비트 필드 상세

irq_thread_fn() 래퍼 동작

/* kernel/irq/manage.c */
static irqreturn_t irq_thread_fn(struct irq_desc *desc,
                                  struct irqaction *action)
{
    irqreturn_t ret;

    ret = action->thread_fn(action->irq, action->dev_id);

    if (ret == IRQ_HANDLED)
        atomic_inc(&desc->threads_handled);

    irq_finalize_oneshot(desc, action);

    return ret;
}

/* irq_finalize_oneshot()가 ONESHOT 인터럽트의 unmask를 담당 */

force_irqthreads 메커니즘

force_irqthreads는 기존 request_irq()로 등록된 인터럽트도 강제로 스레드화하는 메커니즘입니다. PREEMPT_RT 커널의 핵심 기능이며, 비RT 커널에서도 threadirqs 부트 파라미터로 활성화할 수 있습니다.

활성화 방법

# 방법 1: 커널 cmdline 파라미터
GRUB_CMDLINE_LINUX="threadirqs"

# 방법 2: PREEMPT_RT 커널 (기본 활성화)
# CONFIG_PREEMPT_RT=y이면 force_irqthreads=true

# 확인 방법
cat /proc/cmdline | grep threadirqs
cat /sys/kernel/realtime   # 1이면 RT 커널

내부 동작: irq_setup_forced_threading()

/* kernel/irq/manage.c */
static void irq_setup_forced_threading(struct irqaction *new)
{
    if (!force_irqthreads)
        return;

    /* IRQF_NO_THREAD가 설정된 인터럽트는 스레드화하지 않음 */
    if (new->flags & IRQF_NO_THREAD)
        return;

    /* 이미 threaded_irq이면 건너뜀 */
    if (new->handler == irq_default_primary_handler)
        return;

    /* handler를 thread_fn으로 이동하고,
     * handler를 irq_default_primary_handler로 교체 */
    new->thread_fn = new->handler;
    new->handler = irq_default_primary_handler;

    /* ONESHOT 설정 (안전한 unmask 보장) */
    new->flags |= IRQF_ONESHOT;
}

스레드화에서 제외되는 인터럽트

성능 영향

force_irqthreads 소스 코드 심층 분석

force_irqthreads 변수가 어떻게 설정되고, 인터럽트 등록 경로에서 어떻게 활용되는지 커널 소스를 단계별로 추적합니다:

/* kernel/irq/manage.c -- force_irqthreads 변수 정의 */
#ifdef CONFIG_IRQ_FORCED_THREADING
__read_mostly bool force_irqthreads;
EXPORT_SYMBOL_GPL(force_irqthreads);

/* 커널 부트 파라미터 "threadirqs" 처리 */
static int __init setup_forced_irqthreading(char *arg)
{
    force_irqthreads = true;
    return 0;
}
early_param("threadirqs", setup_forced_irqthreading);
#endif

/* PREEMPT_RT에서의 자동 설정:
 * CONFIG_PREEMPT_RT 커널에서는 force_irqthreads가
 * 컴파일 타임에 true로 고정됩니다.
 * include/linux/interrupt.h:
 *   #define force_irqthreads() (true)
 * 실제로는 매크로로 정의되어 변수 접근 오버헤드도 없습니다 */

강제 스레드화 변환 과정 상세

드라이버가 request_irq(irq, my_handler, 0, "dev", dev)로 등록한 경우, force_irqthreads 환경에서 내부적으로 어떻게 변환되는지 분석합니다:

변환 전:

action->handler

my_handler

action->thread_fn

NULL

action->flags

0

irq_setup_forced_threading() 변환 후:

action->handler

irq_default_primary_handler

action->thread_fn

my_handler (handler가 thread_fn으로 이동)

action->flags

IRQF_ONESHOT (ONESHOT 자동 추가)

결과적으로 my_handler가 프로세스 컨텍스트에서 실행됩니다.

RT 커널의 spinlock 변환

PREEMPT_RT에서 force_irqthreads가 안전하게 동작하는 핵심 이유는 spinlock의 변환에 있습니다. RT 커널에서 spinlock_t는 rt_mutex로 변환되어 슬립이 가능해집니다:

/* RT 커널에서의 spinlock 변환 개념
 *
 * 일반 커널:
 *   spinlock_t -> 실제 스핀 (busy wait)
 *   spin_lock() 중 슬립 -> BUG
 *
 * PREEMPT_RT:
 *   spinlock_t -> rt_mutex (슬립 가능한 mutex)
 *   spin_lock() -> rt_mutex_lock() (슬립 가능!)
 *   Priority Inheritance 자동 지원
 *
 * raw_spinlock_t -> 실제 스핀 (RT에서도 변환 안 됨)
 *   irq_desc->lock 등 내부 잠금에만 사용 */

/* 예: 기존 드라이버의 handler가 spinlock을 사용하는 경우 */
static irqreturn_t my_handler(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    spin_lock(&dev->lock);
    /* 일반 커널: 스핀 (원자적, 슬립 불가)
     * RT 커널: rt_mutex_lock (슬립 가능, PI 지원)
     * -> force_irqthreads로 스레드화되어도 안전합니다 */
    dev->status = ioread32(dev->regs + STATUS);
    spin_unlock(&dev->lock);

    return IRQ_HANDLED;
}

Managed IRQ (devm API)

devm_request_threaded_irq()는 디바이스 리소스 관리(devres) 프레임워크와 통합된 IRQ 등록 API입니다. 드라이버 probe에서 등록하면 remove 시 자동으로 해제됩니다.

API 시그니처

/* include/linux/interrupt.h */
extern int devm_request_threaded_irq(
    struct device    *dev,         /* 디바이스 구조체 */
    unsigned int     irq,
    irq_handler_t    handler,
    irq_handler_t    thread_fn,
    unsigned long    irqflags,
    const char      *devname,
    void            *dev_id
);

/* 편의 래퍼: thread_fn=NULL */
static inline int devm_request_irq(
    struct device *dev, unsigned int irq,
    irq_handler_t handler, unsigned long irqflags,
    const char *devname, void *dev_id)
{
    return devm_request_threaded_irq(dev, irq, handler,
                                      NULL, irqflags, devname, dev_id);
}

자동 해제 순서

devres는 LIFO(Last-In-First-Out) 순서로 리소스를 해제합니다. 따라서 probe에서 IRQ를 먼저 등록하고 다른 리소스를 나중에 등록하면, remove 시 다른 리소스가 먼저 해제된 후 IRQ가 해제됩니다:

static int my_probe(struct platform_device *pdev)
{
    struct my_device *dev;
    int irq, ret;

    dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
    if (!dev)
        return -ENOMEM;

    irq = platform_get_irq(pdev, 0);
    if (irq < 0)
        return irq;

    /* devm로 등록: remove 시 자동 해제 */
    ret = devm_request_threaded_irq(&pdev->dev, irq,
                                     my_hardirq, my_thread_fn,
                                     IRQF_ONESHOT,
                                     dev_name(&pdev->dev), dev);
    if (ret)
        return ret;

    /* 추가 초기화 (devm 기반이므로 에러 시 자동 정리) */
    dev->regs = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(dev->regs))
        return PTR_ERR(dev->regs);  /* IRQ도 자동 해제됨 */

    platform_set_drvdata(pdev, dev);
    return 0;
}

/* remove 함수: devm 사용 시 비어있을 수 있음 */
static void my_remove(struct platform_device *pdev)
{
    /* devm이 모든 리소스를 자동 해제 */
}

devm IRQ 생명주기 상세

devm_request_threaded_irq()의 내부 구현과 리소스 관리 메커니즘을 상세히 분석합니다:

/* kernel/irq/devres.c — devm_request_threaded_irq() 내부 */
int devm_request_threaded_irq(struct device *dev,
    unsigned int irq, irq_handler_t handler,
    irq_handler_t thread_fn, unsigned long irqflags,
    const char *devname, void *dev_id)
{
    struct irq_devres *dr;
    int rc;

    /* devres 엔트리 할당 (IRQ 번호와 dev_id 저장) */
    dr = devres_alloc(devm_irq_release,
                       sizeof(*dr), GFP_KERNEL);
    if (!dr)
        return -ENOMEM;

    /* 실제 IRQ 등록 */
    rc = request_threaded_irq(irq, handler, thread_fn,
                              irqflags, devname, dev_id);
    if (rc) {
        devres_free(dr);
        return rc;
    }

    dr->irq = irq;
    dr->dev_id = dev_id;
    devres_add(dev, dr);  /* devres 스택에 추가 */

    return 0;
}

/* devres 해제 콜백: device_release_driver() 시 자동 호출 */
static void devm_irq_release(struct device *dev, void *res)
{
    struct irq_devres *dr = res;

    /* free_irq()는 다음을 수행합니다:
     * 1. IRQ 비활성화
     * 2. 실행 중인 hardirq handler 완료 대기
     * 3. 실행 중인 thread_fn 완료 대기
     * 4. 커널 스레드 종료 (kthread_stop)
     * 5. irqaction 구조체 해제 */
    free_irq(dr->irq, dr->dev_id);
}

devm_free_irq(): 수동 조기 해제

드라이버가 remove 전에 IRQ를 먼저 해제해야 하는 경우, devm_free_irq()를 사용할 수 있습니다. 이 함수는 devres 스택에서도 해당 엔트리를 제거하므로 이중 해제(Double Free)가 발생하지 않습니다:

/* 런타임에 IRQ를 일시적으로 해제해야 하는 경우 */
void my_runtime_reconfigure(struct my_device *dev)
{
    /* 수동 해제 (devres에서도 제거됨) */
    devm_free_irq(dev->dev, dev->irq, dev);

    /* 하드웨어 재구성 */
    reconfigure_hardware(dev);

    /* 새로운 설정으로 다시 등록 */
    devm_request_threaded_irq(dev->dev, dev->new_irq,
        my_new_hardirq, my_new_thread_fn,
        IRQF_ONESHOT, "dev-reconfig", dev);
}

공유 인터럽트에서의 Threaded IRQ

PCI 레거시 인터럽트(INTx)는 여러 디바이스가 같은 IRQ 라인을 공유합니다. 공유 인터럽트에서 threaded IRQ를 사용할 때는 추가 규칙이 적용됩니다.

핵심 규칙

• handler 필수: IRQF_SHARED에서 handler=NULL은 허용되지 않습니다. 자기 디바이스의 인터럽트인지 확인해야 하기 때문입니다.
• IRQ_NONE 반환: 자기 디바이스의 인터럽트가 아니면 반드시 IRQ_NONE을 반환해야 합니다.
• ONESHOT 주의: 공유 IRQ에서 ONESHOT을 사용하면, 한 핸들러의 thread_fn이 완료될 때까지 같은 라인의 다른 디바이스 인터럽트도 지연됩니다.
• thread_fn 병렬 실행: 여러 핸들러가 IRQ_WAKE_THREAD를 반환하면, 각각의 thread_fn은 독립적으로 스케줄링되어 병렬 실행 가능합니다.

/* 공유 인터럽트 threaded IRQ 예제 */
static irqreturn_t shared_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    u32 status = ioread32(dev->regs + IRQ_STATUS);

    /* 자기 디바이스의 인터럽트가 아니면 IRQ_NONE */
    if (!(status & MY_IRQ_PENDING))
        return IRQ_NONE;

    /* 인터럽트 ACK (다른 디바이스에 영향 없도록) */
    iowrite32(MY_IRQ_ACK, dev->regs + IRQ_STATUS);

    /* 상태 저장 후 스레드로 위임 */
    dev->irq_status = status;
    return IRQ_WAKE_THREAD;
}

static irqreturn_t shared_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    mutex_lock(&dev->lock);
    handle_interrupt(dev, dev->irq_status);
    mutex_unlock(&dev->lock);

    return IRQ_HANDLED;
}

ret = devm_request_threaded_irq(&pdev->dev, irq,
    shared_hardirq, shared_thread_fn,
    IRQF_SHARED | IRQF_ONESHOT,
    "my-pci-dev", dev);

Nested Threaded IRQ

Nested threaded IRQ는 I2C/SPI와 같은 슬로우 버스에 연결된 디바이스의 인터럽트를 처리하는 특수한 패턴입니다. 이 경우 부모 IRQ 컨트롤러 자체가 이미 threaded IRQ로 동작하므로, 자식 IRQ도 부모의 스레드 컨텍스트에서 실행됩니다.

Nested IRQ의 동작 원리

GPIO expander가 I2C 버스에 연결된 경우를 예로 들면:

1. GPIO expander의 인터럽트 출력이 SoC의 GPIO 핀에 연결
2. SoC GPIO 인터럽트는 threaded IRQ로 처리 (I2C 접근이 필요하므로)
3. threaded handler 내에서 I2C를 통해 expander의 인터럽트 상태를 읽음
4. handle_nested_irq()를 호출하여 자식 IRQ를 부모 스레드에서 처리

/* I2C GPIO expander의 threaded handler (부모) */
static irqreturn_t expander_irq_thread(int irq, void *dev_id)
{
    struct expander *exp = dev_id;
    unsigned long pending;
    int child_irq;

    /* I2C로 인터럽트 상태 레지스터 읽기 (슬립 가능) */
    pending = i2c_smbus_read_byte_data(exp->client, REG_INT_STATUS);

    for_each_set_bit(child_irq, &pending, exp->ngpio) {
        /* 자식 IRQ를 부모 스레드 컨텍스트에서 직접 호출 */
        handle_nested_irq(irq_find_mapping(exp->domain, child_irq));
    }

    return IRQ_HANDLED;
}

/* 자식 IRQ의 nested 속성 설정 */
static void expander_irq_setup(struct expander *exp)
{
    int i;
    for (i = 0; i < exp->ngpio; i++) {
        int virq = irq_create_mapping(exp->domain, i);
        irq_set_nested_thread(virq, 1);
        irq_set_noprobe(virq);
    }
}

Nested IRQ 계층 구조 상세

실제 임베디드 시스템에서는 여러 단계의 인터럽트 계층이 형성됩니다. 예를 들어, SoC의 GIC가 SoC GPIO 컨트롤러에 연결되고, GPIO가 I2C GPIO expander에 연결되며, expander의 각 핀에 최종 디바이스(터치스크린, 센서, 버튼)가 연결됩니다. 각 계층에서 threaded IRQ와 nested IRQ의 조합이 어떻게 동작하는지 분석합니다:

handle_nested_irq() 구현 상세

handle_nested_irq()는 부모의 thread_fn 컨텍스트에서 자식 IRQ를 직접 처리합니다. 별도의 커널 스레드를 생성하지 않으며, 자식의 action->thread_fn을 현재 컨텍스트에서 직접 호출합니다:

/* kernel/irq/chip.c — handle_nested_irq() */
void handle_nested_irq(unsigned int irq)
{
    struct irq_desc *desc = irq_to_desc(irq);
    struct irqaction *action;
    irqreturn_t action_ret;

    might_sleep();  /* 프로세스 컨텍스트 확인 */

    raw_spin_lock_irq(&desc->lock);
    desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);

    action = desc->action;
    if (unlikely(!action || irqd_irq_disabled(&desc->irq_data))) {
        desc->istate |= IRQS_PENDING;
        raw_spin_unlock_irq(&desc->lock);
        return;
    }

    kstat_incr_irqs_this_cpu(desc);
    irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
    raw_spin_unlock_irq(&desc->lock);

    /* 자식의 thread_fn을 현재 스레드에서 직접 호출 */
    action_ret = IRQ_NONE;
    for_each_action_of_desc(desc, action)
        action_ret |= action->thread_fn(action->irq,
                                         action->dev_id);

    /* 정리: INPROGRESS 클리어 */
    raw_spin_lock_irq(&desc->lock);
    irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
    raw_spin_unlock_irq(&desc->lock);
}

Threaded IRQ vs 다른 Bottom Half 비교

인터럽트 처리의 지연 작업(deferred work)을 구현하는 여러 메커니즘이 있습니다. 각각의 특성과 threaded IRQ가 최선인 상황을 비교합니다.

결정 기준

PREEMPT_RT에서의 Threaded IRQ

PREEMPT_RT 커널에서 threaded IRQ는 핵심적인 역할을 합니다. RT 커널은 force_irqthreads=true를 기본으로 설정하여, IRQF_NO_THREAD가 아닌 모든 인터럽트를 스레드화합니다.

RT 커널에서의 인터럽트 처리 구조

우선순위 역전 방지와 PI

RT 커널에서 spinlock_t는 rt_mutex로 변환되며, rt_mutex는 Priority Inheritance(PI)를 지원합니다. IRQ 스레드가 rt_mutex를 대기할 때, 보유자의 우선순위가 자동으로 부스팅되어 우선순위 역전을 방지합니다.

# RT 커널에서 IRQ 스레드 우선순위 확인 및 변경
$ ps -eo pid,cls,rtprio,comm | grep "irq/"
   85  FF    50 irq/9-acpi
  132  FF    50 irq/16-ahci
  207  FF    50 irq/27-i2c-touch

# 중요한 인터럽트의 우선순위 올리기
$ chrt -f -p 80 207

# IRQ affinity 설정 (특정 CPU에 바인딩)
$ echo 2 > /proc/irq/27/smp_affinity

# cyclictest로 인터럽트 지연 측정
$ cyclictest -t1 -p 98 -i 1000 -l 10000
T: 0 Min:      1 Act:    1 Avg:    1 Max:      12

RT 커널 튜닝 가이드

PREEMPT_RT 메인라인 병합 이후의 변화 (v6.12)

v6.12에서 PREEMPT_RT 핵심 기능이 메인라인에 병합되면서, 이전에 rt-patches를 적용해야 사용할 수 있었던 threaded IRQ 거동이 주류 커널에서도 동일하게 동작합니다. 드라이버 코드 변경은 필요 없지만, 우선순위와 지연 프로파일이 다음과 같이 정돈되었습니다.

• 기본 IRQ 스레드 우선순위: RT 빌드에서 신규 IRQ 스레드는 여전히 SCHED_FIFO 50으로 생성되지만, 우선순위 inheritance 경로가 재정비되어 rt_mutex 대기 시 부스팅 지연이 개선되었습니다(내부 측정 약 0.5~1.5μs 감소).
• force_irqthreads 스레드 생성 비용: 스레드 최초 생성 시점의 비용은 여전히 수 μs(측정 환경에 따라 2~5μs) 수준이지만, 스레드 재사용 경로가 최적화되어 IRQ 라인당 second-and-after wakeup은 약 700ns~1.5μs로 단축되었습니다.
• 우선순위 역전 방지: 드라이버에서 사용하는 spinlock_t가 RT에서 rt_mutex로 변환되면서, IRQ 스레드가 해당 락을 대기할 때 PI(Priority Inheritance)가 자동 적용됩니다. raw_spinlock_t를 사용하는 low-level 경로는 PI가 적용되지 않으므로, 경로 설계 시 의도적으로 구분해야 합니다.
• IRQF_NO_THREAD의 의미 강화: v6.12+에서 IRQF_NO_THREAD로 등록된 ISR은 RT 빌드에서도 반드시 hardirq 컨텍스트에 남습니다. 이 ISR이 spinlock_t를 잡으면 lockdep 경고(INCONSISTENT_LOCK_STATE)가 즉시 발생하므로, 반드시 raw_spinlock_t로 바꾸어야 합니다.
• cpuidle과 threaded IRQ: RT 빌드에서 idle CPU가 threaded IRQ 도착으로 깨어나는 경로가 sched_ttwu_pending()에서 irq_thread_wakeup() 경로로 단축되었습니다. 결과적으로 idle → IRQ thread 실행까지 지연이 줄었습니다.

force_irqthreads 성능 오버헤드 최신 측정

# x86_64 Icelake 서버, Linux 6.12 PREEMPT_RT 빌드 기준
# (cyclictest + tracer 기반 내부 벤치)

구간                                    v5.15-RT    v6.12 RT (mainline)
--------------------------------------  ----------  -------------------
hardirq 진입~ACK                         ~350ns      ~300ns
IRQ_WAKE_THREAD 반환~스레드 런큐 진입   ~1.2μs      ~0.6μs
런큐 → 스레드 실행 시작                 ~0.8μs      ~0.7μs
thread_fn 첫 실행까지 총 지연           ~2.3μs      ~1.5μs
최악 cyclictest max (3600s)             ~25μs       ~18μs

수치는 측정 환경 의존적이지만, PREEMPT_RT 메인라인 병합으로 전반적인 IRQ → 스레드 경로가 개선된 경향을 보여줍니다. 개별 드라이버가 큰 영향을 받는 경우는 드물며, 주로 다수의 IRQ가 동시에 발생하는 고-IOPS 환경에서 누적 효과가 나타납니다.

기존 드라이버 마이그레이션 가이드

기존 드라이버를 threaded IRQ 패턴으로 전환하는 세 가지 주요 마이그레이션 시나리오를 다룹니다.

패턴 1: request_irq() -> request_threaded_irq()

/* === 변경 전: hardirq에서 모든 작업 수행 === */
static irqreturn_t old_handler(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    u32 status = ioread32(dev->regs + STATUS);

    if (!(status & IRQ_PENDING))
        return IRQ_NONE;

    iowrite32(IRQ_ACK, dev->regs + STATUS);
    process_data(dev);  /* 시간이 걸리는 작업 */
    return IRQ_HANDLED;
}
request_irq(irq, old_handler, 0, "my-dev", dev);

/* === 변경 후: hardirq + thread_fn 분리 === */
static irqreturn_t new_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    u32 status = ioread32(dev->regs + STATUS);

    if (!(status & IRQ_PENDING))
        return IRQ_NONE;

    iowrite32(IRQ_ACK, dev->regs + STATUS);
    dev->saved_status = status;
    return IRQ_WAKE_THREAD;
}

static irqreturn_t new_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    process_data(dev);
    return IRQ_HANDLED;
}
request_threaded_irq(irq, new_hardirq, new_thread_fn,
                     IRQF_ONESHOT, "my-dev", dev);

패턴 2: hardirq + workqueue -> Threaded IRQ

/* === 변경 전: hardirq에서 workqueue 스케줄링 === */
static irqreturn_t old_handler(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    iowrite32(IRQ_ACK, dev->regs + STATUS);
    queue_work(dev->wq, &dev->work);  /* workqueue에 위임 */
    return IRQ_HANDLED;
}

static void old_work_fn(struct work_struct *work)
{
    struct my_device *dev = container_of(work, struct my_device, work);
    mutex_lock(&dev->lock);
    slow_operation(dev);
    mutex_unlock(&dev->lock);
}

/* === 변경 후: 단일 threaded IRQ로 통합 === */
static irqreturn_t new_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    iowrite32(IRQ_ACK, dev->regs + STATUS);
    return IRQ_WAKE_THREAD;
}

static irqreturn_t new_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    mutex_lock(&dev->lock);
    slow_operation(dev);
    mutex_unlock(&dev->lock);
    return IRQ_HANDLED;
}
/* workqueue, work_struct, INIT_WORK 모두 제거 가능 */

패턴 3: Tasklet -> Threaded IRQ

/* === 변경 전: tasklet 사용 === */
static void old_tasklet_fn(struct tasklet_struct *t)
{
    struct my_device *dev = from_tasklet(dev, t, tasklet);
    process_data(dev);  /* 주의: 슬립 불가! */
}

static irqreturn_t old_handler(int irq, void *dev_id)
{
    iowrite32(IRQ_ACK, dev->regs + STATUS);
    tasklet_schedule(&dev->tasklet);
    return IRQ_HANDLED;
}

/* === 변경 후: threaded IRQ (tasklet, DECLARE_TASKLET 제거) === */
static irqreturn_t new_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    process_data(dev);  /* 이제 슬립 가능! */
    return IRQ_HANDLED;
}

마이그레이션 체크리스트

I2C/SPI 디바이스 드라이버 실전

I2C/SPI 디바이스는 threaded IRQ의 가장 대표적인 사용 사례입니다. 슬로우 버스를 통한 레지스터 접근은 수백 us에서 수 ms가 소요되므로 hardirq에서 처리할 수 없습니다.

regmap_irq: 자동 IRQ chip 생성

regmap_irq 프레임워크는 레지스터 기반 인터럽트 컨트롤러(Interrupt Controller)를 자동으로 구성합니다. PMIC, 코덱, 센서 허브 등 복잡한 인터럽트 구조를 가진 디바이스에 매우 유용합니다.

/* PMIC 드라이버의 regmap_irq 설정 예 */
static const struct regmap_irq pmic_irqs[] = {
    REGMAP_IRQ_REG(0, 0, BIT(0)),  /* VBUS detect */
    REGMAP_IRQ_REG(1, 0, BIT(1)),  /* Overtemp */
    REGMAP_IRQ_REG(2, 0, BIT(2)),  /* Low battery */
    REGMAP_IRQ_REG(3, 1, BIT(0)),  /* Button press */
};

static const struct regmap_irq_chip pmic_irq_chip = {
    .name           = "pmic",
    .irqs           = pmic_irqs,
    .num_irqs       = ARRAY_SIZE(pmic_irqs),
    .num_regs       = 2,
    .status_base    = PMIC_INT_STATUS,
    .mask_base      = PMIC_INT_MASK,
    .ack_base       = PMIC_INT_ACK,
};

static int pmic_probe(struct i2c_client *client)
{
    struct pmic_data *pmic;
    int ret;

    pmic->regmap = devm_regmap_init_i2c(client, &pmic_regmap_config);

    /* regmap_irq가 threaded IRQ를 자동 등록 */
    ret = devm_regmap_add_irq_chip(&client->dev, pmic->regmap,
                                    client->irq,
                                    IRQF_ONESHOT | IRQF_TRIGGER_LOW,
                                    0, &pmic_irq_chip,
                                    &pmic->irq_data);
    if (ret)
        return ret;

    /* 개별 IRQ를 자식 디바이스에 전달 */
    pmic->charger_irq = regmap_irq_get_virq(pmic->irq_data, 0);
    pmic->thermal_irq = regmap_irq_get_virq(pmic->irq_data, 1);

    return 0;
}

터치스크린 드라이버 예제

/* I2C 터치스크린: handler=NULL, thread_fn만 사용 */
static irqreturn_t touch_thread_fn(int irq, void *dev_id)
{
    struct touch_device *ts = dev_id;
    u8 buf[10];

    /* I2C 전송 (슬립 가능, 수백 us) */
    i2c_smbus_read_i2c_block_data(ts->client, REG_TOUCH, 10, buf);

    input_report_abs(ts->input, ABS_X, get_x(buf));
    input_report_abs(ts->input, ABS_Y, get_y(buf));
    input_report_key(ts->input, BTN_TOUCH, get_touch(buf));
    input_sync(ts->input);

    return IRQ_HANDLED;
}

ret = devm_request_threaded_irq(&client->dev, client->irq,
    NULL, touch_thread_fn,
    IRQF_ONESHOT | IRQF_TRIGGER_LOW,
    "touch-irq", ts);

GPIO Interrupt와 Threaded IRQ

GPIO 인터럽트는 임베디드 시스템에서 버튼, 센서, 외부 디바이스 연결에 광범위하게 사용됩니다. GPIO subsystem과 threaded IRQ의 결합 패턴을 살펴봅니다.

/* GPIO 인터럽트 + threaded IRQ 예제 */
static int sensor_probe(struct platform_device *pdev)
{
    struct sensor_data *data;
    struct gpio_desc *irq_gpio;
    int irq, ret;

    data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);

    /* GPIO 디스크립터 가져오기 */
    irq_gpio = devm_gpiod_get(&pdev->dev, "irq", GPIOD_IN);
    if (IS_ERR(irq_gpio))
        return PTR_ERR(irq_gpio);

    /* GPIO -> IRQ 번호 변환 */
    irq = gpiod_to_irq(irq_gpio);
    if (irq < 0)
        return irq;

    /* threaded IRQ 등록 (하강 에지에서 트리거) */
    ret = devm_request_threaded_irq(&pdev->dev, irq,
        NULL, sensor_irq_thread,
        IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
        "sensor-data-ready", data);
    if (ret)
        return ret;

    data->irq = irq;
    platform_set_drvdata(pdev, data);
    return 0;
}

static irqreturn_t sensor_irq_thread(int irq, void *dev_id)
{
    struct sensor_data *data = dev_id;
    int val;

    /* 프로세스 컨텍스트: I2C/SPI 접근 가능 */
    val = i2c_smbus_read_word_data(data->client, REG_DATA);
    if (val < 0)
        return IRQ_HANDLED;

    data->last_value = val;
    complete(&data->data_ready);
    return IRQ_HANDLED;
}

Debounce와 Threaded IRQ

GPIO 버튼의 바운싱 문제는 소프트웨어 디바운싱으로 해결하며, threaded IRQ에서 msleep()을 사용하여 안정화 시간을 기다릴 수 있습니다:

static irqreturn_t button_thread_fn(int irq, void *dev_id)
{
    struct button_data *btn = dev_id;

    /* 디바운스: 20ms 대기 후 상태 확인 */
    msleep(20);

    int state = gpiod_get_value_cansleep(btn->gpio);
    input_report_key(btn->input, btn->keycode, state);
    input_sync(btn->input);

    return IRQ_HANDLED;
}

PCIe 디바이스의 Threaded IRQ

PCIe 디바이스에서 threaded IRQ를 사용하는 패턴은 MSI/MSI-X 사용 여부에 따라 달라집니다.

MSI/MSI-X + Threaded IRQ

static int pci_dev_probe(struct pci_dev *pdev,
                          const struct pci_device_id *id)
{
    struct my_pci_dev *dev;
    int ret;

    ret = pcim_enable_device(pdev);
    if (ret)
        return ret;

    /* MSI 벡터 할당 */
    ret = pci_alloc_irq_vectors(pdev, 1, 4, PCI_IRQ_MSI | PCI_IRQ_MSIX);
    if (ret < 0)
        return ret;

    /* MSI는 edge-triggered이므로 ONESHOT 불필요하지만
     * 안전을 위해 설정하는 것도 괜찮음 */
    ret = devm_request_threaded_irq(&pdev->dev,
        pci_irq_vector(pdev, 0),
        my_pci_hardirq, my_pci_thread,
        0,  /* MSI: ONESHOT 선택적, SHARED 불필요 */
        "my-pci", dev);

    return ret;
}

static irqreturn_t my_pci_hardirq(int irq, void *dev_id)
{
    struct my_pci_dev *dev = dev_id;

    /* DMA 완료 상태 확인 */
    if (!(ioread32(dev->mmio + DMA_STATUS) & DMA_DONE))
        return IRQ_NONE;

    /* 인터럽트 비활성화 (재발생 방지) */
    iowrite32(0, dev->mmio + IRQ_ENABLE);

    return IRQ_WAKE_THREAD;
}

static irqreturn_t my_pci_thread(int irq, void *dev_id)
{
    struct my_pci_dev *dev = dev_id;

    /* DMA 버퍼 처리 (프로세스 컨텍스트) */
    process_dma_buffer(dev);

    /* 인터럽트 재활성화 */
    iowrite32(IRQ_ENABLE_ALL, dev->mmio + IRQ_ENABLE);

    return IRQ_HANDLED;
}

PCI INTx 공유 인터럽트

레거시 PCI INTx를 사용하는 경우, 반드시 IRQF_SHARED를 설정하고 handler에서 자기 디바이스의 인터럽트인지 확인해야 합니다. MSI/MSI-X로 전환하면 이 제약이 없어집니다.

동기화와 잠금(Lock) 패턴

threaded IRQ에서는 hardirq handler와 thread_fn이 서로 다른 컨텍스트에서 실행되므로, 공유 데이터 접근 시 적절한 동기화가 필요합니다.

hardirq handler와 thread_fn 간 동기화

synchronize_irq() vs disable_irq()

/* synchronize_irq(): 현재 실행 중인 handler + thread_fn 완료 대기 */
synchronize_irq(dev->irq);
/* 이 시점에서 handler와 thread_fn이 실행 중이지 않음을 보장 */
cleanup_resources(dev);

/* disable_irq(): IRQ 비활성화 + 실행 중인 handler/thread_fn 완료 대기 */
disable_irq(dev->irq);
/* IRQ 비활성화됨 + 진행 중이던 처리 완료됨 */
modify_shared_data(dev);
enable_irq(dev->irq);

/* disable_irq_nosync(): IRQ만 비활성화, 완료 대기 안 함 */
disable_irq_nosync(dev->irq);  /* hardirq에서 사용 가능 */

데드락 시나리오와 해결

디버깅(Debugging) 기법

threaded IRQ 관련 문제를 진단하는 실전 기법입니다.

/proc/interrupts 해석

$ cat /proc/interrupts
           CPU0       CPU1
  9:         45          0   IO-APIC   9-fasteoi   acpi
 16:      12847          0   IO-APIC  16-fasteoi   ahci[0000:00:1f.2]
 27:       8923          0   IO-APIC  27-fasteoi   i2c-touch

# 컬럼: IRQ번호 / CPU별 카운트 / 컨트롤러 / 트리거+타입 / 이름
# fasteoi: ACK 방식 (irq chip 의존)
# 카운트가 빠르게 증가하면 IRQ storm 의심

/proc/irq/N/ 디렉토리

$ ls /proc/irq/27/
affinity_hint  effective_affinity      smp_affinity
actions        effective_affinity_list smp_affinity_list
chip_name      hwirq                  spurious
node           type

$ cat /proc/irq/27/spurious
count 0
unhandled 0
last_unhandled 0 ms

$ cat /proc/irq/27/actions
i2c-touch

$ cat /proc/irq/27/type
edge

ftrace를 이용한 추적

# IRQ 핸들러 진입/종료 추적
$ echo 1 > /sys/kernel/debug/tracing/events/irq/irq_handler_entry/enable
$ echo 1 > /sys/kernel/debug/tracing/events/irq/irq_handler_exit/enable

# IRQ 스레드 추적 (available_events에서 확인)
$ cat /sys/kernel/debug/tracing/trace
# irq/27-i2c-to-207  [001] d..  123.456: irq_handler_entry: irq=27 name=i2c-touch
# irq/27-i2c-to-207  [001] d..  123.456: irq_handler_exit: irq=27 ret=handled

# function_graph로 상세 호출 추적
$ echo irq_thread_fn > /sys/kernel/debug/tracing/set_graph_function
$ echo function_graph > /sys/kernel/debug/tracing/current_tracer

일반적인 오류와 해결

성능 분석

Threaded IRQ의 오버헤드와 성능 특성을 정량적으로 분석합니다.

오버헤드 구성 요소

cyclictest 성능 비교

# 비RT 커널 (threadirqs 미사용)
$ cyclictest -t4 -p 98 -i 1000 -l 100000
T: 0 Min:      1 Act:    2 Avg:    3 Max:      87

# 비RT 커널 (threadirqs 사용)
$ cyclictest -t4 -p 98 -i 1000 -l 100000
T: 0 Min:      1 Act:    2 Avg:    4 Max:      42

# PREEMPT_RT 커널
$ cyclictest -t4 -p 98 -i 1000 -l 100000
T: 0 Min:      1 Act:    1 Avg:    2 Max:      12

Threaded vs Non-threaded 오버헤드 비교

threaded IRQ와 기존 non-threaded 방식의 오버헤드를 시나리오별로 비교합니다:

perf를 이용한 인터럽트 처리 시간 측정

# 인터럽트 핸들러 실행 시간 통계 수집
$ perf stat -e irq:irq_handler_entry,irq:irq_handler_exit \
  -a sleep 10
Performance counter stats for 'system wide':
         12,847      irq:irq_handler_entry
         12,847      irq:irq_handler_exit
      10.001234 seconds time elapsed

# 특정 IRQ의 핸들러 실행 시간 히스토그램
$ perf record -e irq:irq_handler_entry -e irq:irq_handler_exit \
  -a --filter 'irq==27' sleep 5
$ perf script | head -20

# bpftrace로 thread_fn 실행 시간 측정
$ bpftrace -e '
kprobe:irq_thread_fn { @start[tid] = nsecs; }
kretprobe:irq_thread_fn /@start[tid]/ {
  @us = hist((nsecs - @start[tid]) / 1000);
  delete(@start[tid]);
}'

# ftrace로 개별 핸들러 지연 시간 추적
$ echo 1 > /sys/kernel/debug/tracing/events/irq/irq_handler_entry/enable
$ echo 1 > /sys/kernel/debug/tracing/events/irq/irq_handler_exit/enable
$ cat /sys/kernel/debug/tracing/trace_pipe | grep "irq=27"

커널 설정 옵션

Threaded IRQ와 관련된 주요 커널 설정 옵션들입니다.

threadirqs 커널 cmdline 파라미터

# GRUB 설정에서 추가
GRUB_CMDLINE_LINUX="threadirqs"

# 또는 부팅 시 GRUB 편집 (임시)
linux /vmlinuz ... threadirqs

# 적용 확인
$ dmesg | grep -i thread
[    0.000000] Forcing IRQ threading

권장 설정 매트릭스

내부 구현: __setup_irq() 핵심 경로

request_threaded_irq()가 호출되면 내부적으로 __setup_irq()가 실행됩니다. 이 함수의 threaded IRQ 관련 핵심 경로를 분석합니다.

/* kernel/irq/manage.c — request_threaded_irq() 핵심 흐름 */
int request_threaded_irq(unsigned int irq,
    irq_handler_t handler, irq_handler_t thread_fn,
    unsigned long irqflags, const char *devname, void *dev_id)
{
    struct irqaction *action;
    struct irq_desc *desc;

    desc = irq_to_desc(irq);
    if (!desc)
        return -EINVAL;

    /* handler와 thread_fn 둘 다 NULL이면 에러 */
    if (!handler && !thread_fn)
        return -EINVAL;

    /* handler=NULL이면 기본 핸들러 사용 */
    if (!handler) {
        if (!thread_fn)
            return -EINVAL;
        handler = irq_default_primary_handler;
    }

    /* irqaction 구조체 할당 및 초기화 */
    action = kzalloc(sizeof(*action), GFP_KERNEL);
    action->handler = handler;
    action->thread_fn = thread_fn;
    action->flags = irqflags;
    action->name = devname;
    action->dev_id = dev_id;

    /* 핵심: __setup_irq()에서 스레드 생성, 검증, 등록 */
    return __setup_irq(irq, desc, action);
}

핵심 자료 구조

Threaded IRQ를 이해하려면 관련 자료 구조의 관계를 파악해야 합니다.

/* include/linux/irqdesc.h */
struct irq_desc {
    struct irqaction    *action;        /* 핸들러 체인 (linked list) */
    struct irq_data      irq_data;       /* IRQ chip, hwirq 등 */
    unsigned int         irq_count;      /* 인터럽트 발생 횟수 */
    unsigned int         depth;          /* enable/disable 중첩 카운트 */
    unsigned int         threads_handled; /* 스레드 처리 완료 횟수 */
    unsigned int         threads_active;  /* 현재 활성 스레드 수 */
    wait_queue_head_t    wait_for_threads; /* synchronize_irq() 대기 */
    /* ... */
};

/* include/linux/interrupt.h */
struct irqaction {
    irq_handler_t       handler;        /* hardirq 핸들러 */
    irq_handler_t       thread_fn;      /* 스레드 함수 */
    struct task_struct *thread;          /* 커널 스레드 task */
    unsigned long       thread_flags;    /* IRQTF_RUNTHREAD 등 */
    unsigned long       thread_mask;     /* ONESHOT sync 마스크 */
    void               *dev_id;         /* 디바이스 식별자 */
    unsigned int        irq;            /* IRQ 번호 */
    unsigned int        flags;          /* IRQF_* 플래그 */
    const char         *name;           /* 이름 */
    struct irqaction   *next;           /* 공유 IRQ: 다음 action */
};

ONESHOT 구현 상세: irq_finalize_oneshot()

ONESHOT 인터럽트의 unmask 타이밍은 irq_finalize_oneshot() 함수가 제어합니다. 공유 IRQ에서 여러 thread_fn이 모두 완료되어야 unmask하는 로직을 분석합니다.

/* kernel/irq/manage.c */
static void irq_finalize_oneshot(struct irq_desc *desc,
                                  struct irqaction *action)
{
    if (!(desc->istate & IRQS_ONESHOT) ||
        action->handler == irq_forced_secondary_handler)
        return;

again:
    chip_bus_lock(desc);
    raw_spin_lock_irq(&desc->lock);

    /* thread_mask에서 자신의 비트 클리어 */
    if (!test_and_clear_bit(action->thread_mask,
                            &desc->threads_oneshot)) {
        raw_spin_unlock_irq(&desc->lock);
        chip_bus_sync_unlock(desc);
        goto again;
    }

    /* 모든 thread_fn이 완료되었는지 확인 */
    if (desc->threads_oneshot == 0) {
        /* 모두 완료: unmask! */
        desc->istate &= ~IRQS_MASKED;
        irq_unmask(desc);
    }

    raw_spin_unlock_irq(&desc->lock);
    chip_bus_sync_unlock(desc);
}

에러 처리 패턴

Threaded IRQ에서 발생할 수 있는 에러 상황과 올바른 처리 패턴을 정리합니다.

thread_fn에서의 에러 처리

static irqreturn_t robust_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    int ret;

    /* I2C/SPI 통신 에러 처리 */
    ret = regmap_read(dev->regmap, REG_STATUS, &dev->status);
    if (ret) {
        dev_err(dev->dev, "IRQ: 상태 읽기 실패: %d\n", ret);
        /* 에러여도 IRQ_HANDLED 반환 (IRQ_NONE이면 spurious 카운트 증가) */
        return IRQ_HANDLED;
    }

    /* 데이터 처리 */
    if (dev->status & ERROR_BIT) {
        dev_warn(dev->dev, "디바이스 에러 감지: 0x%x\n", dev->status);
        my_device_reset(dev);
    } else {
        process_normal_data(dev);
    }

    return IRQ_HANDLED;
}

/* 안전한 서스펜드/리줌 패턴 */
static int my_suspend(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    /* IRQ 비활성화 + 진행 중인 thread_fn 완료 대기 */
    disable_irq(mydev->irq);
    /* 이 시점에서 thread_fn이 확실히 실행 중이지 않음 */
    save_device_state(mydev);
    return 0;
}

static int my_resume(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    restore_device_state(mydev);
    enable_irq(mydev->irq);
    return 0;
}

IRQ Affinity와 스레드 Affinity

Threaded IRQ에서 IRQ affinity를 설정하면 스레드의 CPU affinity도 자동으로 동기화됩니다.

# IRQ 27을 CPU 2에 바인딩
$ echo 4 > /proc/irq/27/smp_affinity

# 확인: IRQ 스레드도 CPU 2로 이동
$ taskset -p $(pgrep "irq/27")
pid 207's current affinity mask: 4

# managed_irq: 디바이스 드라이버가 affinity를 관리
# irq_set_affinity_hint()로 힌트 제공
# 커널이 자동으로 최적 배치

NUMA 최적화

/* PCIe 디바이스의 NUMA 노드에 IRQ 바인딩 */
static int setup_numa_irq(struct pci_dev *pdev)
{
    int node = dev_to_node(&pdev->dev);
    const struct cpumask *mask;

    if (node != NUMA_NO_NODE) {
        mask = cpumask_of_node(node);
        irq_set_affinity_hint(pdev->irq, mask);
    }

    return 0;
}

Managed IRQ와 자동 affinity

최신 멀티큐 디바이스(NVMe, 네트워크 카드)는 managed IRQ를 사용하여 커널이 자동으로 IRQ를 CPU에 최적 배치합니다:

/* managed IRQ: 커널이 affinity를 자동 관리 */
struct irq_affinity affd = {
    .pre_vectors  = 1,    /* admin queue */
    .post_vectors = 1,    /* polling queue */
};

/* pci_alloc_irq_vectors_affinity()로 벡터 할당 시
 * IRQ_NO_BALANCING + managed 속성이 자동 설정됨 */
ret = pci_alloc_irq_vectors_affinity(pdev,
    min_vecs, max_vecs,
    PCI_IRQ_MSIX | PCI_IRQ_AFFINITY,
    &affd);

/* 결과: 각 벡터가 자동으로 다른 CPU에 배치됨
 * IRQ N → CPU 0, IRQ N+1 → CPU 1, ...
 * 스레드 affinity도 자동으로 동기화
 * /proc/irq/N/effective_affinity에서 확인 가능 */

Affinity 변경 시 스레드 마이그레이션

IRQ affinity가 변경되면, IRQ 스레드도 자동으로 해당 CPU로 마이그레이션됩니다. 이 과정은 irq_thread_check_affinity()에서 처리됩니다:

# IRQ affinity 변경 과정 관찰
$ echo 4 > /proc/irq/27/smp_affinity   # CPU 2로 변경
$ cat /proc/irq/27/effective_affinity   # 실제 적용된 affinity
4

# 스레드 마이그레이션 확인
$ taskset -p $(pgrep "irq/27")
pid 207's current affinity mask: 4      # CPU 2로 이동 완료

# irq_set_affinity_notifier()로 변경 알림 수신 가능
# 드라이버가 affinity 변경에 대응해야 할 때 사용

웨이크업 인터럽트와 Threaded IRQ

시스템 서스펜드 상태에서 특정 인터럽트가 시스템을 깨울 수 있어야 하는 경우, 웨이크업 인터럽트로 설정합니다.

/* 웨이크업 가능한 threaded IRQ 설정 */
static int wakeup_probe(struct platform_device *pdev)
{
    int irq = platform_get_irq(pdev, 0);

    /* 웨이크업 소스로 등록 */
    device_init_wakeup(&pdev->dev, true);

    devm_request_threaded_irq(&pdev->dev, irq,
        NULL, wakeup_thread_fn,
        IRQF_ONESHOT | IRQF_TRIGGER_LOW | IRQF_NO_SUSPEND,
        "wakeup-key", pdev);

    /* 서스펜드 시 IRQ를 웨이크업 소스로 설정 */
    dev_pm_set_wake_irq(&pdev->dev, irq);

    return 0;
}

/* 서스펜드 콜백에서 웨이크업 활성화 */
static int wakeup_suspend(struct device *dev)
{
    if (device_may_wakeup(dev))
        enable_irq_wake(dev->irq);
    return 0;
}

static int wakeup_resume(struct device *dev)
{
    if (device_may_wakeup(dev))
        disable_irq_wake(dev->irq);
    return 0;
}

Secondary Actions (이중 핸들러)

커널은 내부적으로 force_irqthreads 환경에서 기존 handler를 "primary" thread와 "secondary" thread로 분리할 수 있습니다. 이는 handler가 원래 hardirq와 softirq 양쪽 모두에서 작업을 수행하던 경우에 발생합니다.

/* kernel/irq/manage.c — secondary action 생성 */
if (new->handler && new->thread_fn) {
    /* handler: 원래 hardirq 부분 유지
     * thread_fn: 원래 softirq/bottom-half 부분 */

    if (force_irqthreads && new->handler != irq_default_primary_handler) {
        /* force threading 시:
         * handler -> primary thread로 이동
         * thread_fn -> secondary thread 생성 */
        struct irqaction *secondary;
        secondary = kzalloc(sizeof(*secondary), GFP_KERNEL);
        secondary->handler = irq_forced_secondary_handler;
        secondary->thread_fn = new->thread_fn;
        new->secondary = secondary;
    }
}

패턴 정리: Threaded IRQ 사용 가이드

드라이버 개발자를 위한 Threaded IRQ 패턴을 유형별로 정리합니다.

흔한 실수와 안티패턴

API 레퍼런스 요약

실제 커널 드라이버 사례 분석

실제 리눅스 커널에서 threaded IRQ를 사용하는 대표적인 드라이버들을 분석합니다.

PMIC: MAX77686 (drivers/mfd/max77686-irq.c)

삼성 Exynos 플랫폼의 PMIC으로, I2C 연결입니다. regmap_irq를 사용하여 다수의 인터럽트 소스를 관리합니다:

/* 간략화된 MAX77686 IRQ 설정 */
ret = regmap_add_irq_chip(max77686->regmap, max77686->irq,
                           IRQF_ONESHOT | IRQF_TRIGGER_LOW |
                           IRQF_SHARED,
                           0, &max77686_irq_chip,
                           &max77686->irq_data);
/* 결과: I2C를 통한 모든 인터럽트 상태 읽기/마스킹이
 * threaded handler에서 자동으로 처리됨 */

터치 컨트롤러: Goodix (drivers/input/touchscreen/goodix_ts_core.c)

/* Goodix 터치 컨트롤러: handler=NULL 패턴 */
ret = devm_request_threaded_irq(&ts->client->dev,
    ts->client->irq, NULL, goodix_ts_irq_handler,
    IRQF_ONESHOT, "goodix_ts", ts);

/* thread_fn에서 I2C로 터치 데이터 읽기 + 입력 이벤트 보고 */

NVMe (drivers/nvme/host/pci.c)

NVMe는 MSI-X를 사용하지만, 특정 경우 threaded IRQ 패턴을 활용합니다:

/* NVMe: 컴플리션 큐 처리를 위한 threaded IRQ */
ret = pci_request_irq(pdev, nr,
    nvme_irq,          /* hardirq: CQ doorbell 확인 */
    nvme_irq_check,    /* thread: 컴플리션 큐 처리 */
    nvmeq, "nvme%dq%d", ...);

GPIO Keys (drivers/input/keyboard/gpio_keys.c)

GPIO Keys 드라이버는 GPIO 기반 버튼 입력을 처리하는 대표적인 threaded IRQ 사용 사례입니다. 디바운싱과 웨이크업 기능을 모두 지원합니다:

/* GPIO Keys: 하드웨어 디바운스 미지원 시 소프트웨어 디바운스 + threaded IRQ */
static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
{
    struct gpio_button_data *bdata = dev_id;
    struct input_dev *input = bdata->input;

    BUG_ON(irq != bdata->irq);

    spin_lock_irqsave(&bdata->lock, flags);

    if (!bdata->key_pressed) {
        if (bdata->button->wakeup)
            pm_wakeup_event(bdata->input->dev.parent, 0);

        input_event(input, EV_KEY, *bdata->code, 1);
        input_sync(input);

        if (!bdata->release_delay) {
            input_event(input, EV_KEY, *bdata->code, 0);
            input_sync(input);
        }
    }

    spin_unlock_irqrestore(&bdata->lock, flags);
    return IRQ_HANDLED;
}

/* 등록: ONESHOT + 트리거 타입 조합 */
ret = request_any_context_irq(bdata->irq,
    gpio_keys_irq_isr, irqflags, desc, bdata);
/* request_any_context_irq(): hardirq/threaded 자동 선택
 * GPIO가 I2C expander 뒤에 있으면 → nested (threaded)
 * GPIO가 SoC 직접 연결이면 → hardirq
 * 반환값으로 어떤 컨텍스트가 선택되었는지 알 수 있음 */

IIO (Industrial I/O) 센서 트리거

IIO 프레임워크의 센서 드라이버는 데이터 준비 인터럽트를 threaded IRQ로 처리하여 고속 센서 데이터를 수집합니다:

/* IIO 센서: data-ready 인터럽트 → threaded IRQ → 버퍼 push */
static irqreturn_t bmp280_trigger_handler(int irq, void *p)
{
    struct iio_poll_func *pf = p;
    struct iio_dev *indio_dev = pf->indio_dev;
    struct bmp280_data *data = iio_priv(indio_dev);
    s32 adc_temp, adc_press;

    /* I2C/SPI로 센서 데이터 읽기 (프로세스 컨텍스트에서 슬립 가능) */
    mutex_lock(&data->lock);
    regmap_bulk_read(data->regmap, BMP280_REG_PRESS_MSB,
                     data->buf, BMP280_DATA_LEN);
    mutex_unlock(&data->lock);

    /* IIO 버퍼에 push */
    iio_push_to_buffers_with_timestamp(indio_dev,
                                        data->buf, pf->timestamp);
    iio_trigger_notify_done(indio_dev->trig);
    return IRQ_HANDLED;
}

/* IIO 트리거 + threaded IRQ 등록 */
ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
    iio_pollfunc_store_time,   /* hardirq: 타임스탬프만 저장 */
    bmp280_trigger_handler,    /* thread_fn: 데이터 읽기 + push */
    NULL);

request_any_context_irq() — 자동 컨텍스트 선택

일부 드라이버는 GPIO가 SoC에 직접 연결되었는지, I2C GPIO expander 뒤에 있는지에 따라 hardirq 또는 threaded 모드가 결정됩니다. request_any_context_irq()는 이를 자동으로 판단합니다:

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

/* 반환값:
 *   IRQC_IS_HARDIRQ  — hardirq 컨텍스트로 등록됨
 *   IRQC_IS_NESTED   — nested threaded로 등록됨 (I2C/SPI 뒤)
 *   음수             — 에러
 *
 * 내부적으로 irq_settings_is_nested_thread(desc)를 확인하여
 * nested이면 자동으로 threaded IRQ로 등록 */

debugfs 인터페이스

CONFIG_GENERIC_IRQ_DEBUGFS=y를 활성화하면 /sys/kernel/debug/irq/에 상세한 IRQ 정보가 제공됩니다.

# debugfs IRQ 정보 확인
$ ls /sys/kernel/debug/irq/irqs/
0  1  2  3  4  5  6  7  8  9  10  ...

$ cat /sys/kernel/debug/irq/irqs/27
handler:  0xffffffff81234560 [my_hardirq]
thread_fn:  0xffffffff81234580 [my_thread_fn]
flags:    0x00002080 (SHARED|ONESHOT)
thread:   irq/27-my-dev (pid 207)
type:     level-low
chip:     GICv3
hwirq:    47
domain:   /interrupt-controller@...
affinity: 0-3
effective: 2

# IRQ 도메인 트리 확인
$ cat /sys/kernel/debug/irq/domains/list

IRQ 디버깅 워크플로우

실전 디버깅: IRQ Storm 복구

# 1단계: IRQ storm 감지
$ watch -n1 'cat /proc/interrupts | head -5'
# 특정 IRQ의 카운트가 초당 수천~수만 씩 증가하면 storm

# 2단계: 해당 IRQ 임시 비활성화 (긴급)
$ echo 1 > /proc/irq/27/disable   # 주의: 관련 디바이스 동작 중단

# 3단계: IRQ 정보 수집
$ cat /proc/irq/27/type           # edge vs level 확인
$ cat /proc/irq/27/actions        # 어떤 드라이버인지 확인
$ cat /proc/irq/27/spurious       # unhandled 카운트 확인

# 4단계: dmesg에서 관련 메시지 확인
$ dmesg | grep -i "irq 27\|nobody cared\|irq.*disabled"

# 5단계: 드라이버 수정 후 재활성화
$ echo 0 > /proc/irq/27/disable   # 또는 드라이버 reload

/proc/interrupts와 /proc/irq/N/ 심층 분석

인터럽트 디버깅에서 가장 기본이 되는 /proc/interrupts와 /proc/irq/N/ 디렉토리의 각 항목을 상세히 해석합니다.

/proc/interrupts 상세 해석

$ cat /proc/interrupts
           CPU0       CPU1       CPU2       CPU3
  0:         23          0          0          0   IO-APIC   2-edge      timer
  1:       1247          0          0          0   IO-APIC   1-edge      i8042
  8:          1          0          0          0   IO-APIC   8-edge      rtc0
  9:         45          0          0          0   IO-APIC   9-fasteoi   acpi
 16:      12847          0          0          0   IO-APIC  16-fasteoi   ahci[0000:00:1f.2]
 27:       8923          0          0          0   IO-APIC  27-fasteoi   i2c-touch
 40:          0          0      45678          0   PCI-MSI  524288-edge  nvme0q0
 41:          0          0          0      23456   PCI-MSI  524289-edge  nvme0q1
NMI:        234        231        229        228   Non-maskable interrupts
LOC:     987654     876543     765432     654321   Local timer interrupts
RES:      12345      11234      10123       9012   Rescheduling interrupts
ERR:          0
MIS:          0

# 필드 해석:
#   IRQ 번호 | CPU별 인터럽트 발생 횟수 | 인터럽트 칩 | hwirq-트리거타입 | 디바이스명
#
# 트리거 타입 해석:
#   edge     — 에지 트리거 (상승/하강)
#   fasteoi  — EOI(End Of Interrupt) 기반 ACK (level-triggered에 주로 사용)
#   level    — 레벨 트리거
#
# 비정상 징후:
#   - 특정 IRQ 카운트가 초당 수천~수만: IRQ storm 의심
#   - unbalanced: 한 CPU에만 모든 카운트 집중 (affinity 확인)
#   - ERR/MIS 증가: 하드웨어 문제 의심

/proc/irq/N/ 디렉토리 상세

# /proc/irq/27/ 전체 항목 해석
$ ls -la /proc/irq/27/
total 0
dr-xr-xr-x 2 root root 0  i2c-touch/   # action 디렉토리
-r--r--r-- 1 root root 0  actions        # 등록된 핸들러 이름
-r--r--r-- 1 root root 0  affinity_hint  # 드라이버가 설정한 힌트
-r--r--r-- 1 root root 0  chip_name      # IRQ 칩 이름
-r--r--r-- 1 root root 0  effective_affinity      # 실제 적용된 affinity
-r--r--r-- 1 root root 0  effective_affinity_list  # 리스트 형식
-r--r--r-- 1 root root 0  hwirq          # 하드웨어 IRQ 번호
-r--r--r-- 1 root root 0  node           # NUMA 노드
-rw-r--r-- 1 root root 0  smp_affinity        # CPU 비트마스크
-rw-r--r-- 1 root root 0  smp_affinity_list   # CPU 리스트
-r--r--r-- 1 root root 0  spurious       # 스퓨리어스 IRQ 정보
-r--r--r-- 1 root root 0  type           # 트리거 유형

# 각 항목 상세 확인
$ cat /proc/irq/27/actions
i2c-touch                    # 등록된 디바이스 이름

$ cat /proc/irq/27/chip_name
IO-APIC                      # 인터럽트 컨트롤러 칩

$ cat /proc/irq/27/hwirq
27                           # 하드웨어 IRQ 번호 (virq와 다를 수 있음)

$ cat /proc/irq/27/type
level                        # level 또는 edge

$ cat /proc/irq/27/spurious
count 8923                   # 총 인터럽트 횟수
unhandled 0                  # 핸들러가 처리하지 않은 횟수
last_unhandled 0 ms          # 마지막 미처리 시점
# unhandled/count 비율이 99.9%를 넘으면 IRQ 자동 비활성화!

$ cat /proc/irq/27/effective_affinity
4                            # CPU 2 (비트마스크)

$ cat /proc/irq/27/effective_affinity_list
2                            # CPU 2 (리스트 형식)

# affinity 변경
$ echo 4 > /proc/irq/27/smp_affinity   # CPU 2에 고정
$ echo 0-3 > /proc/irq/27/smp_affinity_list  # CPU 0~3 허용

인터럽트 모니터링 스크립트

threaded IRQ 관련 문제를 실시간으로 모니터링하는 실전 스크립트를 소개합니다:

# 1. 특정 IRQ의 초당 발생 횟수 추적
$ while true; do
    prev=$(awk '/27:/ {print $2+$3+$4+$5}' /proc/interrupts)
    sleep 1
    curr=$(awk '/27:/ {print $2+$3+$4+$5}' /proc/interrupts)
    echo "IRQ 27: $((curr - prev))/sec"
  done

# 2. IRQ 스레드 상태와 CPU 사용률 확인
$ ps -eo pid,cls,rtprio,psr,%cpu,stat,wchan:20,comm | grep "irq/"
  207  FF    50   2  0.3 S    irq_wait_for_inter irq/27-i2c-touch
  341  FF    50   0  1.2 S    irq_wait_for_inter irq/136-xhci_hcd
# stat 컬럼: S=슬립(대기), R=실행 중, D=IO 대기
# wchan: irq_wait_for_interrupt면 정상 대기 상태

# 3. thread_fn이 실행 중인지 확인 (R 상태 빈도)
$ for i in $(seq 1 100); do
    ps -eo stat,comm | grep "irq/27" | head -1
    usleep 10000
  done | sort | uniq -c
# R(running)이 자주 나타나면 thread_fn 실행 빈도가 높음

# 4. 스퓨리어스 IRQ 실시간 감시
$ watch -n5 'for d in /proc/irq/*/spurious; do
    irq=$(echo $d | cut -d/ -f4)
    unhandled=$(grep unhandled $d | awk "{print \$2}")
    [ "$unhandled" -gt 0 ] && echo "IRQ $irq: unhandled=$unhandled"
  done'

실전 버그와 함정 (Bugs and Pitfalls)

실제 커널 드라이버 개발에서 발생하는 threaded IRQ 관련 버그들을 구체적인 코드와 함께 분석합니다. 각 버그는 실제 커널 메일링 리스트나 버그 리포트에서 보고된 패턴을 기반으로 합니다.

버그 1: thread_fn에서 disable_irq() 데드락

/* 잘못된 코드: 데드락 발생! */
static irqreturn_t bad_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* BUG: disable_irq()는 실행 중인 thread_fn 완료를 대기합니다.
     * 그런데 지금 이 코드가 바로 그 thread_fn입니다!
     * -> 자기 자신의 완료를 기다리므로 영원히 블록됩니다. */
    disable_irq(dev->irq);  /* DEADLOCK! */

    reconfigure_device(dev);

    enable_irq(dev->irq);
    return IRQ_HANDLED;
}

/* 올바른 코드: disable_irq_nosync() 사용 */
static irqreturn_t good_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* disable_irq_nosync()는 완료를 대기하지 않습니다.
     * thread_fn 내부에서 안전하게 사용할 수 있습니다. */
    disable_irq_nosync(dev->irq);

    reconfigure_device(dev);

    enable_irq(dev->irq);
    return IRQ_HANDLED;
}

버그 2: hardirq와 thread_fn 간 경쟁 조건(Race Condition)

/* 잘못된 코드: 경쟁 조건 발생 */
static irqreturn_t bad_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* BUG: dev->status를 보호 없이 쓰기 */
    dev->status = ioread32(dev->regs + STATUS);
    return IRQ_WAKE_THREAD;
}

static irqreturn_t bad_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* BUG: ONESHOT 미설정 + 새 인터럽트 발생 시
     * hardirq가 dev->status를 덮어쓸 수 있습니다!
     * thread_fn이 이전 status를 처리하는 도중 값이 변경됩니다. */
    process_data(dev->status);
    return IRQ_HANDLED;
}

/* 올바른 코드: WRITE_ONCE/READ_ONCE 사용 + ONESHOT */
static irqreturn_t good_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    /* WRITE_ONCE로 원자적 쓰기 보장 */
    WRITE_ONCE(dev->status, ioread32(dev->regs + STATUS));
    return IRQ_WAKE_THREAD;
}

static irqreturn_t good_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    u32 status = READ_ONCE(dev->status);

    process_data(status);
    return IRQ_HANDLED;
}
/* + IRQF_ONESHOT으로 등록하여 근본적으로 경쟁 방지 */

버그 3: thread_fn에서 IRQ_NONE 반환

/* 잘못된 코드: thread_fn에서 IRQ_NONE 반환 */
static irqreturn_t bad_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    int ret;

    ret = i2c_smbus_read_byte_data(dev->client, REG_STATUS);
    if (ret < 0) {
        /* BUG: IRQ_NONE을 반환하면 커널이 이 인터럽트를
         * "처리되지 않음"으로 기록합니다.
         * 이것이 누적되면 (100,000회) 커널이 해당 IRQ를
         * 자동으로 비활성화하고 "nobody cared" 메시지를 출력합니다! */
        return IRQ_NONE;  /* 위험! */
    }

    process_data(dev, ret);
    return IRQ_HANDLED;
}

/* 올바른 코드: 에러여도 IRQ_HANDLED 반환 */
static irqreturn_t good_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    int ret;

    ret = i2c_smbus_read_byte_data(dev->client, REG_STATUS);
    if (ret < 0) {
        dev_err_ratelimited(&dev->client->dev,
            "IRQ: status read failed: %d\n", ret);
        /* thread_fn은 이미 "자기 디바이스의 인터럽트"라고 확인된 후
         * 호출됩니다. I/O 에러가 발생해도 IRQ_HANDLED를 반환해야
         * spurious 카운트가 증가하지 않습니다. */
        return IRQ_HANDLED;
    }

    process_data(dev, ret);
    return IRQ_HANDLED;
}

버그 4: 서스펜드/리줌 시 IRQ 레이스

/* 잘못된 코드: 서스펜드 시 thread_fn과의 레이스 */
static int bad_suspend(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    /* BUG: disable_irq() 없이 하드웨어 상태를 변경하면
     * thread_fn이 동시에 실행 중일 수 있습니다.
     * thread_fn이 레지스터에 접근하는 도중 디바이스가
     * 파워 다운되면 bus error가 발생합니다! */
    power_down_device(mydev);
    return 0;
}

/* 올바른 코드: disable_irq로 thread_fn 완료 보장 */
static int good_suspend(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    /* disable_irq()는 다음을 보장합니다:
     * 1. 새 인터럽트가 발생하지 않음
     * 2. 실행 중인 thread_fn이 완료될 때까지 대기
     * 이후 안전하게 하드웨어 상태를 변경할 수 있습니다. */
    disable_irq(mydev->irq);
    power_down_device(mydev);
    return 0;
}

static int good_resume(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    power_up_device(mydev);
    reinit_device(mydev);
    enable_irq(mydev->irq);  /* 디바이스 준비 후 IRQ 재활성화 */
    return 0;
}

버그 5: devm 리소스 등록 순서 오류

/* 잘못된 코드: IRQ를 나중에 등록 -> MMIO 먼저 해제됨 */
static int bad_probe(struct platform_device *pdev)
{
    /* 1. MMIO 먼저 등록 */
    dev->regs = devm_ioremap_resource(&pdev->dev, res);

    /* 2. IRQ 나중에 등록 */
    ret = devm_request_threaded_irq(&pdev->dev, irq,
        my_hardirq, my_thread_fn, IRQF_ONESHOT, "dev", dev);

    /* BUG: remove 시 devres LIFO로 해제됩니다.
     * IRQ가 나중에 등록되었으므로 먼저 해제되는 것은 맞지만,
     * free_irq()가 thread_fn 완료를 대기하는 동안
     * thread_fn이 dev->regs에 접근하면...
     * dev->regs는 아직 유효합니다. (이 경우는 안전)
     *
     * 그러나 만약 아래와 같이 순서가 바뀌면: */

    /* 3. 추가 리소스 등록 (thread_fn이 의존) */
    dev->buffer = devm_kzalloc(&pdev->dev, BUF_SIZE, GFP_KERNEL);

    /* remove 시: buffer 먼저 해제 -> IRQ 해제 (thread_fn 대기)
     * -> thread_fn이 이미 해제된 buffer에 접근할 위험!
     *
     * 해결: IRQ는 의존하는 모든 리소스 이후에 등록하거나,
     * 명시적으로 disable_irq()를 remove에서 먼저 호출 */
    return 0;
}

/* 올바른 코드: IRQ가 의존하는 리소스를 먼저 등록 */
static int good_probe(struct platform_device *pdev)
{
    /* 1. 메모리 할당 */
    dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
    dev->buffer = devm_kzalloc(&pdev->dev, BUF_SIZE, GFP_KERNEL);

    /* 2. MMIO 매핑 */
    dev->regs = devm_ioremap_resource(&pdev->dev, res);

    /* 3. IRQ를 마지막에 등록 -> LIFO로 먼저 해제됨
     * free_irq()가 thread_fn 완료를 대기한 후,
     * 나머지 리소스가 안전하게 해제됩니다. */
    ret = devm_request_threaded_irq(&pdev->dev, irq,
        my_hardirq, my_thread_fn, IRQF_ONESHOT, "dev", dev);

    return ret;
}

버그 6: force_irqthreads를 고려하지 않은 handler

/* 잠재적 문제: handler에서 GFP_ATOMIC 할당 */
static irqreturn_t legacy_handler(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    struct data_entry *entry;

    /* 일반 커널: hardirq에서 실행 -> GFP_ATOMIC 필수
     * RT 커널 (force_irqthreads): 스레드에서 실행
     * -> GFP_KERNEL도 사용 가능하지만...
     * -> 두 환경 모두에서 동작해야 하므로 GFP_ATOMIC 유지
     *
     * 문제: GFP_ATOMIC은 할당 실패율이 높습니다.
     * force_irqthreads 환경에서는 불필요한 제약입니다. */
    entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
    if (!entry)
        return IRQ_HANDLED;  /* 데이터 손실! */

    process_and_queue(dev, entry);
    return IRQ_HANDLED;
}

/* 개선: threaded IRQ로 마이그레이션하면 GFP_KERNEL 사용 가능 */
static irqreturn_t improved_thread_fn(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    struct data_entry *entry;

    /* 프로세스 컨텍스트: GFP_KERNEL 사용 가능
     * -> 메모리 부족 시 재시도/대기 가능 -> 할당 실패율 극히 낮음 */
    entry = kmalloc(sizeof(*entry), GFP_KERNEL);
    if (!entry)
        return IRQ_HANDLED;

    process_and_queue(dev, entry);
    return IRQ_HANDLED;
}

버그 유형별 체크리스트

regmap_irq 통합 패턴 상세

regmap_irq 프레임워크는 I2C/SPI 디바이스의 레지스터 기반 인터럽트 컨트롤러를 자동으로 관리합니다. 내부적으로 threaded IRQ를 사용하여 슬로우 버스 접근을 처리하며, 드라이버 개발자는 레지스터 맵만 정의하면 됩니다.

regmap_irq 내부 동작

/* regmap_irq 프레임워크의 내부 thread_fn
 * (drivers/base/regmap/regmap-irq.c) */
static irqreturn_t regmap_irq_thread(int irq, void *d)
{
    struct regmap_irq_chip_data *data = d;
    bool handled = false;
    int i;

    /* 1. I2C/SPI를 통해 상태 레지스터 읽기 (슬립 가능) */
    for (i = 0; i < data->chip->num_regs; i++)
        regmap_read(data->map,
                    data->chip->status_base + (i * data->reg_stride),
                    &data->status_buf[i]);

    /* 2. 마스크 적용 (마스킹된 인터럽트 제외) */
    for (i = 0; i < data->chip->num_regs; i++)
        data->status_buf[i] &= ~data->mask_buf[i];

    /* 3. 각 활성 인터럽트에 대해 handle_nested_irq() 호출 */
    for (i = 0; i < data->chip->num_irqs; i++) {
        if (data->status_buf[data->chip->irqs[i].reg_offset] &
            data->chip->irqs[i].mask) {
            handle_nested_irq(
                irq_find_mapping(data->domain, i));
            handled = true;
        }
    }

    /* 4. ACK 레지스터에 쓰기 (인터럽트 클리어) */
    if (data->chip->ack_base)
        for (i = 0; i < data->chip->num_regs; i++)
            if (data->status_buf[i])
                regmap_write(data->map,
                    data->chip->ack_base + (i * data->reg_stride),
                    data->status_buf[i]);

    return handled ? IRQ_HANDLED : IRQ_NONE;
}

regmap_irq 전체 통합 예제

PMIC과 같은 복합 디바이스에서 regmap_irq를 사용하여 여러 서브 디바이스에 인터럽트를 분배하는 전체 패턴입니다:

/* 1단계: 인터럽트 맵 정의 */
static const struct regmap_irq my_codec_irqs[] = {
    [CODEC_IRQ_HEADPHONE]  = REGMAP_IRQ_REG(0, 0, BIT(0)),
    [CODEC_IRQ_MICROPHONE] = REGMAP_IRQ_REG(1, 0, BIT(1)),
    [CODEC_IRQ_OVERTEMP]   = REGMAP_IRQ_REG(2, 0, BIT(2)),
    [CODEC_IRQ_SHORT]      = REGMAP_IRQ_REG(3, 1, BIT(0)),
};

/* 2단계: IRQ 칩 구성 */
static const struct regmap_irq_chip my_codec_irq_chip = {
    .name            = "my-codec",
    .irqs            = my_codec_irqs,
    .num_irqs        = ARRAY_SIZE(my_codec_irqs),
    .num_regs        = 2,
    .status_base     = CODEC_REG_IRQ_STATUS,
    .mask_base       = CODEC_REG_IRQ_MASK,
    .ack_base        = CODEC_REG_IRQ_ACK,
    .mask_invert     = false,
    .init_ack_masked = true,
};

/* 3단계: probe에서 등록 */
static int my_codec_probe(struct i2c_client *client)
{
    struct my_codec *codec;

    codec->regmap = devm_regmap_init_i2c(client, &codec_regmap_cfg);

    /* regmap_irq가 내부적으로 devm_request_threaded_irq() 호출 */
    ret = devm_regmap_add_irq_chip(&client->dev, codec->regmap,
        client->irq,
        IRQF_ONESHOT | IRQF_TRIGGER_LOW,
        0, &my_codec_irq_chip, &codec->irq_data);

    /* 4단계: 개별 인터럽트를 서브 드라이버에서 사용 */
    codec->hp_irq = regmap_irq_get_virq(codec->irq_data,
                                         CODEC_IRQ_HEADPHONE);

    /* 서브 드라이버가 개별 IRQ를 threaded로 등록 */
    ret = devm_request_threaded_irq(&client->dev, codec->hp_irq,
        NULL, headphone_detect_handler,
        IRQF_ONESHOT, "hp-detect", codec);

    return 0;
}

참고자료

커널 공식 문서

• Linux generic IRQ handling — 리눅스 범용 IRQ 처리 프레임워크 공식 문서입니다
• Generic IRQ — Threaded Handlers — 스레드화 핸들러 하위 섹션으로, hardirq/thread_fn 분리 구조를 설명합니다
• Generic IRQ — IRQ chip flags — IRQCHIP_ONESHOT_SAFE 등 IRQ 칩 플래그 설명입니다

커널 소스 코드

• kernel/irq/manage.c — request_threaded_irq(), __setup_irq(), irq_thread() 등 핵심 구현이 위치한 파일입니다
• kernel/irq/irqdesc.c — IRQ 디스크립터(irq_desc) 할당과 관리 코드입니다
• kernel/irq/chip.c — irq_chip 콜백과 flow handler 구현입니다
• include/linux/interrupt.h — request_threaded_irq(), devm_request_threaded_irq(), IRQF_* 플래그 선언입니다
• include/linux/irq.h — struct irq_data, struct irq_chip, IRQ_ONESHOT 등 내부 구조체 정의입니다
• kernel/irq/spurious.c — 스퓨리어스(Spurious) IRQ 감지와 자동 비활성화 로직입니다

LWN.net 기사

• Threaded interrupts (2008) — Thomas Gleixner의 스레드화 인터럽트 패치(Patch) 시리즈 초기 제안을 다룬 LWN 기사입니다
• Moving interrupts to threads (2010) — 인터럽트를 커널 스레드로 이동시키는 메커니즘의 설계 결정을 분석합니다
• A PREEMPT_RT progress report (2020) — PREEMPT_RT 메인라인 통합 진행 현황과 forced threading의 역할을 설명합니다
• The state of realtime (2017) — RT 패치셋의 상태와 스레드화 인터럽트가 실시간 성능에 미치는 영향을 논의합니다
• A realtime preemption overview (2005) — Paul McKenney의 RT 선점 개요로, hardirq 스레드화의 초기 배경을 설명합니다

서적 및 교육 자료

• Linux Kernel Development, Robert Love, 3rd Edition — Chapter 7 "Interrupts and Interrupt Handlers"에서 top half/bottom half 개념과 threaded IRQ의 기초를 다룹니다
• Linux Device Drivers, 3rd Edition (LDD3) — Chapter 10 "Interrupt Handling"에서 공유 인터럽트, IRQ 핸들러 등록 패턴을 설명합니다
• Understanding the Linux Kernel, Daniel P. Bovet & Marco Cesati, 3rd Edition — Chapter 4 "Interrupts and Exceptions"에서 리눅스 인터럽트 아키텍처를 심도 있게 분석합니다

컨퍼런스 발표 및 외부 자료

• Threaded IRQs and Real-Time — Embedded Linux Conference 발표 자료로, 스레드화 IRQ와 RT 환경의 관계를 설명합니다
• Real-Time Linux Wiki — Linux Foundation의 RT 프로젝트 위키로, PREEMPT_RT 패치의 설계 원칙과 forced threading 동작을 문서화합니다
• PREEMPT_RT Setup Guide — PREEMPT_RT 커널 빌드 및 설정 방법을 안내합니다
• OSADL Real-Time Linux Project — OSADL의 실시간 리눅스 프로젝트 페이지(Page)로, 지연 테스트 결과와 스레드화 인터럽트 벤치마크를 제공합니다
• The PREEMPT_RT patchset is in the home stretch (2021) — PREEMPT_RT의 메인라인 커널 최종 통합 과정을 다룬 기사입니다

관련 문서

Threaded IRQ와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• 인터럽트 — 전체 인터럽트 시스템 아키텍처와 처리 흐름
• Softirq & Hardirq — hardirq/softirq 컨텍스트 차이와 실행 규칙
• Bottom Half 선택 가이드 — softirq, tasklet, workqueue, threaded IRQ 비교
• Tasklet — 레거시 bottom half 메커니즘과 threaded IRQ로의 마이그레이션
• Workqueue (CMWQ) — 커널 워커 스레드풀과 지연 작업 처리
• IRQ 도메인 — hwirq/virq 매핑(Mapping), IRQ 계층 구조
• 동기화 기법 — spinlock, mutex, 인터럽트 컨텍스트 잠금 패턴
• I2C — 슬로우 버스 디바이스 드라이버 기초
• PCI / PCIe — MSI/MSI-X, INTx, PCIe 인터럽트 처리
• Real-Time Linux & PREEMPT_RT — RT 커널 선점 모델과 실시간 인터럽트 처리