250329 인터럽트 개념과 핸들러 등록 (8.1~8.3)

8 인터럽트

8.1 인터럽트의 개념

8.1.1인터럽트란?

• 프로세서(cpu, gpu ..) 에 즉각적인 주의를 요청하기 위한 시그널
• 하드웨어나 소프트웨어에서 생성

8.1.2 인터럽트 컨트롤러

여러 디바이스들이 보내는 인터럽트를 인터럽트 컨트롤러에서 멀티플렉싱(하나의 통신 채널을 통해 여러 개의 신호나 데이터 스트림을 동시에 전송하는 기술) 한다.

인터럽트 컨트롤러의 역할

• 멀티플렉싱 및 라우팅
• 인터럽트 우선순위 지정
• 인터럽트 마스킹

인터럽트 컨트롤러를 여러개 사용하기도 한다. 종속 구조, 계층 구조를 사용.

8.2 리눅스 인터럽트 서브 시스템

리눅스는 인터럽트 컨트롤러와 신호를 추상화 하여, 아키텍처와 플랫폼에 상관없이 동일한 디바이스 드라이버로 인터럽트 처리가 가능하다.

8.2.1 include/linux/irq.h irq_chip: 인터럽트 컨트롤러

하드웨어 인터럽트 칩(컨트롤러) 에 대한 디스크립터

• 인터럽트 호출 콜백, 종료 콜백, 마스크(금지) 등을 관리

struct irq_chip {
    const char    *name;
    unsigned int    (*irq_startup)(struct irq_data *data);
    void        (*irq_shutdown)(struct irq_data *data);
    ...

8.2.2 include/linux/irqdomain.h irq_domain: 인터럽트 도메인

• 리눅스에서 사용하는 인터럽트 번호 공간을 관리하는 자료구조.
• 인터럽트 컨트롤러가 1개라면, 중복되지 않게 관리하기 쉽지만 여러 인터럽트 컨트롤러를 사용할때는 어렵기 때문에 이 매핑을 관리한다.

/**
 * struct irq_domain - Hardware interrupt number translation object
 * @revmap_tree: Radix map tree for hwirqs that don't fit in the linear map
 * @linear_revmap: Linear table of hwirq->virq reverse mappings
 */
struct irq_domain {
    ...
    struct radix_tree_root revmap_tree;
    unsigned int linear_revmap[];
};

8.2.3 include/linux/irq_desc: 인터럽트 디스크립터

개별 인터럽트에 대한 디스크립터. 인터럽트 번호와 1:1로 대응

/**
 * struct irq_desc - interrupt descriptor
 * @handle_irq:        highlevel irq-events handler
 * @action:        the irq action chain
 */
struct irq_desc {
    ...
    irq_flow_handler_t    handle_irq;
    struct irqaction    *action;    /* IRQ action list */
} ____cacheline_internodealigned_in_smp;

8.3 인터럽트 핸들러 등록과 처리

8.3.1 인터럽트 핸들러 등록

8-1 include/linux/linterrupt.h request_irq

인터럽트 번호와 handler 를 등록한다.

static inline int __must_check request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
        const char *name, void *dev)
{
    return request_threaded_irq(irq, handler, NULL, flags, name, dev);
}

cat /proc/interrupts

clucle@DESKTOP-N5AJSPQ:~$ cat /proc/interrupts
           CPU0       CPU1       CPU2       CPU3       CPU4       CPU5       CPU6       CPU7       CPU8       CPU9       CPU10      CPU11
  8:          0          0          0          0          0          0          0          0          0          0          0          0  IR-IO-APIC   8-edge      rtc0
  9:          0          0          0          0          0          0          0          0          0          0          0          0  IR-IO-APIC   9-fasteoi   acpi
...

8-2 kernel/irq/manage.c request_threaded_irq

인터럽트 핸들러 등록하기

struct irq_desc *irq_to_desc(unsigned int irq)
{
    return radix_tree_lookup(&irq_desc_tree, 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)
{
    // IRQF_SHARED-여러 device 에서 irq를 공유 할 수 있음.
    // suspend 요청 조건 검사
    if (
        ((irqflags & IRQF_SHARED) && !dev_id) || // shared 인 경우 device id 가 필요
        (!(irqflags & IRQF_SHARED) && (irqflags & IRQF_COND_SUSPEND)) ||
        ((irqflags & IRQF_NO_SUSPEND) && (irqflags & IRQF_COND_SUSPEND)))
        return -EINVAL;

    desc = irq_to_desc(irq);

    if (!handler) {
        if (!thread_fn)
            return -EINVAL;
        handler = irq_default_primary_handler; // IRQ_WAKE_THREAD
    }

    action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
    if (!action)
        return -ENOMEM;

    action->handler = handler; // action 설정
    action->thread_fn = thread_fn;
    action->flags = irqflags;
    action->name = devname;
    action->dev_id = dev_id;

    chip_bus_lock(desc);
    retval = __setup_irq(irq, desc, action);
    chip_bus_sync_unlock(desc);

    if (retval) {
        kfree(action->secondary);
        kfree(action);
    }
    return retval;
}

/**
 * struct irqaction - per interrupt action descriptor
 * @handler:    interrupt handler function
 * @name:    name of the device
 * @dev_id:    cookie to identify the device
 * @percpu_dev_id:    cookie to identify the device
 * @next:    pointer to the next irqaction for shared interrupts
 * @irq:    interrupt number
 * @flags:    flags (see IRQF_* above)
 * @thread_fn:    interrupt handler function for threaded interrupts
 * @thread:    thread pointer for threaded interrupts
 * @secondary:    pointer to secondary irqaction (force threading)
 * @thread_flags:    flags related to @thread
 * @thread_mask:    bitmask for keeping track of @thread activity
 * @dir:    pointer to the proc/irq/NN/name entry
 */
struct irqaction {
    irq_handler_t        handler;
    void            *dev_id;
    void __percpu        *percpu_dev_id;
    struct irqaction    *next;
    irq_handler_t        thread_fn; // irq 를 별도 쓰레드에서 실행하는 경우 핸들러 ex) irq/48-cpr (num-name)
    struct task_struct    *thread;
    struct irqaction    *secondary;
    unsigned int        irq;
    unsigned int        flags;
    unsigned long        thread_flags;
    unsigned long        thread_mask;
    const char        *name;
    struct proc_dir_entry    *dir;
} ____cacheline_internodealigned_in_smp;

static int
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
{

    nested = irq_settings_is_nested_thread(desc);
    if (nested) { // 별도 쓰레드에서 돈다면
        if (!new->thread_fn) {
            ret = -EINVAL;
            goto out_mput;
        }
        new->handler = irq_nested_primary_handler;
    } else { // 공용 쓰레드에서 돈다면
        if (irq_settings_can_thread(desc)) { // 별도 쓰레드에서 돌수 있다면 돌게하자
            ret = irq_setup_forced_threading(new);
            if (ret)
                goto out_mput;
        }
    }

    if (new->thread_fn && !nested) { // thread_fn 이 있으면 쓰레드 생성해주려고 함
        ret = setup_irq_thread(new, irq, false);
        if (ret)
            goto out_mput;
        if (new->secondary) { // 보조 핸들러도 있었으면, 보조 핸들러도 쓰레드
            ret = setup_irq_thread(new->secondary, irq, true);
            if (ret)
                goto out_thread;
        }
    }

    if (!alloc_cpumask_var(&mask, GFP_KERNEL)) { // 마스크 할당
        ret = -ENOMEM;
        goto out_thread;
    }

    if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE) // chip handler에 대한 IRQCHIP_ONESHOT_SAFE이 있으면 chip handler단에처리를 할것이므로 action handelr에선 불필요하므로 빼준다.
        new->flags &= ~IRQF_ONESHOT;

    raw_spin_lock_irqsave(&desc->lock, flags);
    old_ptr = &desc->action;
    old = *old_ptr;
    if (old) { // old 가 있었으면 thread_mask 를 다 or 해서 가져옴
        do {
            /*
             * Or all existing action->thread_mask bits,
             * so we can find the next zero bit for this
             * new action.
             */
            thread_mask |= old->thread_mask;
            old_ptr = &old->next;
            old = *old_ptr;
        } while (old);
        shared = 1;
    }

    if (new->flags & IRQF_ONESHOT) { // 1번만 처리했는지
        if (thread_mask == ~0UL) {
            ret = -EBUSY;
            goto out_mask;
        }
        new->thread_mask = 1 << ffz(thread_mask);
    } else if (new->handler == irq_default_primary_handler &&
           !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) {
        pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
               irq);
        ret = -EINVAL;
        goto out_mask;
    }

    if (!shared) {
        // 처음등록할때 여기서 세팅들
    } else if (new->flags & IRQF_TRIGGER_MASK) {
        // 기존에 추가라면 마스킹만
    }

    *old_ptr = new;

    irq_pm_install_action(desc, new);

    /* Reset broken irq detection when installing new handler */
    desc->irq_count = 0;
    desc->irqs_unhandled = 0;

    // 깨우기
    if (new->thread)
        wake_up_process(new->thread);
    if (new->secondary)
        wake_up_process(new->secondary->thread);

    register_irq_proc(irq, desc);
    new->dir = NULL;
    register_handler_proc(irq, new);
    free_cpumask_var(mask);

    return 0;

    ...
out_mput:
    module_put(desc->owner);
    return ret;
}

8.3.2 인터럽트 핸들러 호출 과정

arm64 에서는 interrupt 가 오면, domain 에 매핑된 irq 를 가져와서 실행한다.

entry.S el1_irq -> irq_hanlder -> handle_arch_irq -> gic_handle_irq -> handle_domain_irq -> generic_handle_irq -> ... handle_irq

irqreturn_t handle_irq_event(struct irq_desc *desc)
{
    ret = handle_irq_event_percpu(desc);
}

8-3 kernel/irq/hanle.c __handle_rq_event_per_cpu

#define for_each_action_of_desc(desc, act)            \
    for (act = desc->act; act; act = act->next)

irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
{
    irqreturn_t retval = IRQ_NONE;
    unsigned int flags = 0, irq = desc->irq_data.irq;
    struct irqaction *action;

    for_each_action_of_desc(desc, action) {
        res = action->handler(irq, action->dev_id);

        switch (res) {
        case IRQ_WAKE_THREAD:
            if (unlikely(!action->thread_fn)) {
                warn_no_thread(irq, action);
                break;
            }

            __irq_wake_thread(desc, action); // 인터럽트 쓰레드를 깨우기
            // fall through
        case IRQ_HANDLED:
            flags |= action->flags; // handler 에서 이미 처리됨
            break;

        default:
            break;
        }

        retval |= res;
    }
    return retval;
}

IPI (Inter Processor Interrupts) 프로세서 사이의 통신

• 코어간 전달해야 하여 아키텍처에 의존적임
• IPI 를 수신하는 코어는 하나일수도, 모든 코어일수도 있음 (cpu mask)
• 인터럽트 번호에따라 handle_domain_irq 대신 handle_IPI 를 호출해 처리함

ARM64 IPI 의 종류

enum ipi_msg_type {
    IPI_RESCHEDULE, // 팬딩된 task 깨우기
    IPI_CALL_FUNC, // 특정 함수 호출
    IPI_CPU_STOP, // 다른 cpu 정지
    IPI_TIMER, // 틱 디바이스 이벤트 핸들러 호출
    IPI_IRQ_WORK, // 현재 cpu 의 irq_work 실행
    IPI_WAKEUP // 다른 cpu 깨우기
};

8.3.3 인터럽트 활성화와 비활성화

8-4 arch/arm64/include/asm/irqflags.h

• include/linux/irqflags.h 에 정의된 함수를 구현
• 현재코어의 인터럽트 활성화와 비활성화
• DAIF 중 2번 인터럽트에 마스킹

static inline void arch_local_irq_enable(void)
{
    asm volatile(
        "msr    daifclr, #2        // arch_local_irq_enable"
        :
        :
        : "memory");
}

static inline void arch_local_irq_disable(void)
{
    asm volatile(
        "msr    daifset, #2        // arch_local_irq_disable"
        :
        :
        : "memory");
}

특정 인터럽트의 활성화와 비활성화

8-5 kernel/irq/manage.c disable_irq, disable_irq_nosync

void disable_irq(unsigned int irq)
{
    if (!__disable_irq_nosync(irq)) // 비활성화 후 
        synchronize_irq(irq); // 다른 cpu 에서 수행되고있을지 모르는 핸들러를 기다림 (자원 공유하면 데드락 발생 가능)
}

void disable_irq_nosync(unsigned int irq)
{
    __disable_irq_nosync(irq); // 비활성화만
}

static int __disable_irq_nosync(unsigned int irq)
{
    unsigned long flags;
    struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);

    if (!desc)
        return -EINVAL;
    __disable_irq(desc); // desc 가져와서 disable
    irq_put_desc_busunlock(desc, flags);
    return 0;
}

void __disable_irq(struct irq_desc *desc)
{
    if (!desc->depth++) // 비활성화 함수 호출되는 카운터
        irq_disable(desc); // depth 가 0이었던 경우. 즉 활성화->비활성화인 경우에 호출
}

void irq_disable(struct irq_desc *desc)
{
    irq_state_set_disabled(desc); // irq 상태를 비활성화
    if (desc->irq_data.chip->irq_disable) { // 인터럽트 컨트롤러가 비활성화를 지원하면 마스킹
        desc->irq_data.chip->irq_disable(&desc->irq_data);
        irq_state_set_masked(desc);
    } else if (irq_settings_disable_unlazy(desc)) { // lazy 사용하지 않는 경우, 바로 마스킹. (lazy 를 사용하면 특정 조건에서만 비활성화)
        mask_irq(desc);
    }
}

8-6 kernel/irq/manage.c enable_irq(), __enable_irq

void enable_irq(unsigned int irq)
{
    // 특정 irq 에 대한 컨트롤러 명령 전후에 버스락. 버스차원의 동기화 보장
    struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
    __enable_irq(desc); // 가져와서 켜기
out:
    irq_put_desc_busunlock(desc, flags);
}


void __enable_irq(struct irq_desc *desc)
{
    switch (desc->depth) {
    case 0: // 불가능한 케이스
 err_out:
    case 1: { // 비활성화 -> 활성화
        irq_enable(desc);
        /* fall-through */
    }
    default:
        desc->depth--; // 카운터 빼기
    }
}

8.3.4 인터럽트 초기화 과정

start_kernel 에서 호출되는 초기화

8-7 kernel/irq/irqdersc.c early_irq_init

init/main.c start_kernel 에서 호출

int __init early_irq_init(void)
{
    int i, initcnt, node = first_online_node; // NUMA 에서 사용가능한 첫번째 노드
    struct irq_desc *desc;

    // typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
    init_irq_default_affinity(); // NR_CPU 만큼 선언된 cpumask 비트앱 초기화

    initcnt = arch_probe_nr_irqs(); // 아키텍처별 먼저 처리해야하는 인터럽트 수 arm64 는 0
    if (initcnt > nr_irqs) nr_irqs = initcnt;

    for (i = 0; i < initcnt; i++) { // irq 에 등록
        desc = alloc_desc(i, node, NULL);
        set_bit(i, allocated_irqs); 
        irq_insert_desc(i, desc); // CONFIG_SPARSE_IRQ 사용한 경우에만  radix tree 에 등록
    }
    return arch_early_irq_init(); // 아키텍처 별로 정의된 early 초기화
}

8-8 arch/arm64/kernel/irq.c init_IRQ

• 디바이스 트리에서 사용가능한 인터럽트 컨트롤러 찾아 초기화. of_irq_init 을 호출하게됨

extern struct of_device_id __irqchip_of_table[];

void __init irqchip_init(void)
{
    of_irq_init(__irqchip_of_table);
    acpi_probe_device_table(irqchip);
}

8-9 drivers/of/irq.c of_irq_init

of: open firmware

struct device_node *of_node_get(struct device_node *node)
{
    if (node)
        kobject_get(&node->kobj);
    return node;
}

// 인터럽트 컨트롤러의 속성을 위한 구조체
struct of_intc_desc {
    struct list_head    list;
    of_irq_init_cb_t    irq_init_cb;
    struct device_node    *dev;
    struct device_node    *interrupt_parent;
};

// Scan and init matching interrupt controllers in DT
void __init of_irq_init(const struct of_device_id *matches)
{
    for_each_matching_node_and_match(np, matches, &match) { // matches 와 일치하는 노드 순회
        if (!of_find_property(np, "interrupt-controller", NULL) ||  // interrupt controller 만 찾기
                !of_device_is_available(np))
            continue;

        desc = kzalloc(sizeof(*desc), GFP_KERNEL); 

        desc->irq_init_cb = match->data;
        desc->dev = of_node_get(np); // 디바이스 트리 노드를 가리키게 하기
        desc->interrupt_parent = of_irq_find_parent(np);
        if (desc->interrupt_parent == np)
            desc->interrupt_parent = NULL;
        list_add_tail(&desc->list, &intc_desc_list); // 인터럽트 컨트롤러 desc 에 추가
    }

8-10 of_irq_init 2

    // typedef int (*of_irq_init_cb_t)(struct device_node *, struct device_node *);

    // parent 가 null 인 인터럽트 컨트롤러는 루트만 가능
    while (!list_empty(&intc_desc_list)) {
        list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) {
            int ret;

            if (desc->interrupt_parent != parent)
                continue;
            // 처음에는 루트가 통과
            // 그 다음부터는 앞서 통과한 부모를 갖는 컨트롤러 찾기
            list_del(&desc->list);

            ret = desc->irq_init_cb(desc->dev,
                        desc->interrupt_parent);

            list_add_tail(&desc->list, &intc_parent_list); // 부모 후보에 등록
        }

        desc = list_first_entry_or_null(&intc_parent_list,
                        typeof(*desc), list);
        if (!desc) {
            pr_err("of_irq_init: children remain, but no parents\n");
            break;
        }
        list_del(&desc->list);
        parent = desc->dev;
        kfree(desc);
    }
}