APIC (Advanced Programmable Interrupt Controller)

x86 시스템의 인터럽트(Interrupt) 라우팅(Routing) 핵심인 APIC 아키텍처를 종합적으로 다룹니다. 8259A PIC에서 APIC으로의 진화, LAPIC 내부 레지스터(Register), I/O APIC 리다이렉션 테이블, x2APIC MSR 인터페이스, APIC Timer, MSI/MSI-X, Intel APICv와 AMD AVIC 가상화(Virtualization) 지원, 커널 struct apic 서브시스템까지 전체 경로를 심층 분석합니다.

8259A → APIC 진화

초기 IBM PC/AT는 Intel 8259A PIC(Programmable Interrupt Controller) 2개를 캐스케이드하여 최대 15개의 IRQ 라인을 지원했습니다. 이 구조는 단일 프로세서 시스템에서는 충분했지만, 멀티프로세서 시스템에서는 근본적인 한계가 있었습니다.

8259A PIC 구조

8259A 초기화 코드 (커널 레거시 경로)

/* arch/x86/kernel/i8259.c - 8259A PIC 초기화 */
static void init_8259A(int auto_eoi)
{
    /* ICW1: 초기화 시작, ICW4 필요 */
    outb(0x11, PIC_MASTER_CMD);
    outb(0x11, PIC_SLAVE_CMD);

    /* ICW2: 벡터 오프셋 (IRQ 0→벡터 0x20, IRQ 8→벡터 0x28) */
    outb(0x20, PIC_MASTER_IMR);   /* 마스터: 벡터 32~39 */
    outb(0x28, PIC_SLAVE_IMR);    /* 슬레이브: 벡터 40~47 */

    /* ICW3: 캐스케이드 설정 */
    outb(0x04, PIC_MASTER_IMR);   /* 마스터 IRQ2에 슬레이브 */
    outb(0x02, PIC_SLAVE_IMR);    /* 슬레이브 ID = 2 */

    /* ICW4: 8086 모드, auto-EOI 옵션 */
    if (auto_eoi)
        outb(MASTER_ICW4_DEFAULT | PIC_ICW4_AEOI, PIC_MASTER_IMR);
    else
        outb(MASTER_ICW4_DEFAULT, PIC_MASTER_IMR);
    outb(SLAVE_ICW4_DEFAULT, PIC_SLAVE_IMR);

    /* 모든 IRQ 마스크 (APIC 전환 전) */
    outb(0xff, PIC_MASTER_IMR);
    outb(0xff, PIC_SLAVE_IMR);
}

APIC 전환 과정 (부트 시퀀스)

/* arch/x86/kernel/apic/apic.c - APIC 초기 설정 흐름
 *
 * 부트 순서:
 * 1. BIOS가 8259A PIC 모드로 시작
 * 2. 커널이 APIC 하드웨어 감지 (CPUID)
 * 3. 8259A를 마스크하고 APIC으로 전환
 * 4. x2APIC 지원 시 MSR 모드로 업그레이드
 */

void __init init_bsp_APIC(void)
{
    unsigned int value;

    /* APIC이 비활성화 상태면 건너뜀 */
    if (!boot_cpu_has(X86_FEATURE_APIC))
        return;

    /* APIC 기본 주소 확인 (MSR 0x1B) */
    value = apic_read(APIC_SPIV);

    /* Spurious Vector Register: APIC 활성화 + 벡터 0xFF */
    value &= ~APIC_VECTOR_MASK;
    value |= APIC_SPIV_APIC_ENABLED;
    value |= APIC_SPIV_FOCUS_DISABLED;
    value |= SPURIOUS_APIC_VECTOR;    /* 벡터 0xFF */

    apic_write(APIC_SPIV, value);
}

APIC 감지 및 모드 결정

/* CPUID를 통한 APIC 기능 감지 */
static bool detect_apic_mode(void)
{
    u32 eax, ebx, ecx, edx;

    /* CPUID.01H: EDX[9] = APIC 존재 여부 */
    cpuid(0x01, &eax, &ebx, &ecx, &edx);

    if (!(edx & (1 << 9))) {
        pr_err("APIC not present\n");
        return false;
    }

    /* ECX[21] = x2APIC 지원 여부 */
    if (ecx & (1 << 21))
        pr_info("x2APIC supported\n");

    /* IA32_APIC_BASE MSR (0x1B):
     *   [11]  = APIC Global Enable
     *   [10]  = x2APIC Enable
     *   [8]   = BSP Flag
     *   [12:N] = APIC Base Address (기본 0xFEE00000)
     */
    u64 msr = rdmsrl(MSR_IA32_APICBASE);
    pr_info("APIC Base: %llx, BSP: %d, Enabled: %d, x2APIC: %d\n",
            msr & 0xFFFFF000ULL,
            !!(msr & (1 << 8)),
            !!(msr & (1 << 11)),
            !!(msr & (1 << 10)));
    return true;
}

APIC 시스템 아키텍처

APIC 시스템은 LAPIC(Local APIC, 각 CPU 코어에 내장)과 I/O APIC(칩셋에 위치, 외부 장치 인터럽트 수집)으로 구성됩니다. 인터럽트는 시스템 버스(또는 ICC Bus)를 통해 I/O APIC에서 적절한 LAPIC으로 전달됩니다. 현대 시스템에서는 MSI/MSI-X를 통해 I/O APIC을 우회하는 경로도 있습니다.

APIC 기본 주소 (IA32_APIC_BASE MSR)

/* IA32_APIC_BASE MSR 읽기/쓰기 */
static u64 read_apic_base(void)
{
    return rdmsrl(MSR_IA32_APICBASE);  /* MSR 0x1B */
}

/* xAPIC → x2APIC 전환:
 * 1) EN=1, EXTD=0 (xAPIC)
 * 2) EN=1, EXTD=1 (x2APIC)
 * 주의: EN=0으로 비활성화 후 재활성화 시 RESET 필요 */
static void enable_x2apic_mode(void)
{
    u64 msr = rdmsrl(MSR_IA32_APICBASE);
    msr |= X2APIC_ENABLE;   /* bit[10] = 1 */
    wrmsrl(MSR_IA32_APICBASE, msr);
}

LAPIC 내부 구조

LAPIC(Local APIC)은 각 프로세서 코어에 내장된 인터럽트 컨트롤러입니다. 인터럽트 수신, 우선순위 판단, 벡터 전달, IPI 발신, 로컬 타이머 등 핵심 기능을 담당합니다. xAPIC 모드에서는 4KB MMIO 공간(0xFEE00000)으로 매핑(Mapping)되고, x2APIC 모드에서는 MSR로 접근합니다.

LAPIC 레지스터 맵 (주요 항목)

IRR/ISR/TMR 256-bit 비트 벡터

/* IRR, ISR, TMR은 각각 256비트(8개 32비트 레지스터)로 구성
 * 벡터 N에 대응하는 비트: 레지스터[N/32]의 비트[N%32]
 *
 * 벡터 범위:
 *   0~15:  예약 (x86 예외)
 *   16~31: 예약
 *   32~255: 사용 가능 (리눅스: 32~0xEF 일반, 0xF0~0xFF 특수)
 */

/* IRR 읽기 예시 */
static u32 read_irr_vector_range(int reg_index)
{
    /* reg_index: 0~7, 각 32비트 */
    return apic_read(APIC_IRR + reg_index * 0x10);
}

/* 모든 펜딩 인터럽트 확인 */
static void dump_irr(void)
{
    int i;
    pr_info("IRR (Interrupt Request Register):\n");
    for (i = 7; i >= 0; i--) {
        u32 val = apic_read(APIC_IRR + i * 0x10);
        if (val)
            pr_info("  IRR[%d] (vec %d-%d): 0x%08x\n",
                    i, i * 32, i * 32 + 31, val);
    }
}

TPR/PPR 우선순위 계산

/* TPR (Task Priority Register):
 *   [7:4] = Task Priority Class
 *   [3:0] = Task Priority Sub-Class
 *
 * PPR (Processor Priority Register):
 *   PPR = max(TPR, ISRV)
 *   여기서 ISRV = ISR에서 가장 높은 비트의 벡터 값
 *
 * 인터럽트 수신 조건:
 *   새 벡터의 [7:4] > PPR[7:4] 일 때만 수신
 *   같은 우선순위 클래스 내에서는 차단됨
 */

/* TPR 설정으로 저우선순위 인터럽트 차단 */
static void set_task_priority(u8 priority_class)
{
    /* priority_class: 0~15 (0이면 모든 인터럽트 수신) */
    apic_write(APIC_TASKPRI, priority_class << 4);
}

/* cr8 레지스터: 64비트 모드에서 TPR[7:4]의 바로가기
 * mov cr8, rax 는 TPR[7:4] = rax[3:0] 과 동일 */
static inline void write_cr8(u64 val)
{
    asm volatile("mov %0, %%cr8" :: "r"(val));
}

LVT 엔트리 포맷

/* LVT 설정 예시: LINT0을 ExtINT, LINT1을 NMI로 설정 */
static void setup_lapic_lvt(void)
{
    /* LINT0: External Interrupt (8259A 호환) */
    apic_write(APIC_LVT0,
        APIC_DM_EXTINT | APIC_LVT_LEVEL_TRIGGER);

    /* LINT1: NMI */
    apic_write(APIC_LVT1,
        APIC_DM_NMI);

    /* Error: 벡터 0xFE로 에러 인터럽트 */
    apic_write(APIC_LVTERR, ERROR_APIC_VECTOR);

    /* Thermal Monitor: 벡터 지정 */
    apic_write(APIC_LVTTHMR,
        THERMAL_APIC_VECTOR | APIC_DM_FIXED);

    /* Performance Counter: 벡터 지정 */
    apic_write(APIC_LVTPC,
        LOCAL_PERF_VECTOR | APIC_DM_FIXED);
}

EOI 처리 메커니즘

EOI(End of Interrupt)는 인터럽트 핸들러(Handler) 완료를 LAPIC에 알리는 핵심 동작입니다. EOI 레지스터에 0을 쓰면 ISR에서 가장 높은 우선순위 비트가 클리어됩니다. Level 트리거 인터럽트의 경우 I/O APIC의 Remote IRR 비트도 클리어되어야 합니다.

EOI 흐름

/* EOI 전송 - 리눅스 커널 내부 */
static inline void ack_APIC_irq(void)
{
    /* EOI 레지스터에 0을 쓰면 ISR에서 최고 비트 클리어
     * x2APIC에서는 MSR 0x80B에 wrmsr */
    apic_write(APIC_EOI, 0);
}

/* Level 트리거 EOI: I/O APIC의 Remote IRR 클리어 필요
 * Directed EOI (SVR[12]=1): 브로드캐스트 대신 특정 벡터만 EOI */
static void eoi_ioapic_pin(unsigned int apic, unsigned int pin)
{
    /* I/O APIC EOI 레지스터에 벡터 번호 쓰기 (I/O APIC v2+) */
    io_apic_eoi(apic, pin);
}

/* 커널의 irq_chip.eoi 콜백 */
static void apic_ack_edge(struct irq_data *data)
{
    irq_complete_move(data);
    irq_move_irq(data);
    ack_APIC_irq();   /* Edge: LAPIC EOI만으로 충분 */
}

static void apic_ack_level(struct irq_data *data)
{
    struct irq_cfg *cfg = irqd_cfg(data);

    irq_complete_move(data);
    irq_move_irq(data);
    ack_APIC_irq();   /* ISR 클리어 */

    /* Level: I/O APIC Remote IRR 확인 및 클리어 */
    if (irqd_is_level_type(data))
        eoi_ioapic_pin(cfg->apic, cfg->pin);
}

I/O APIC

I/O APIC(I/O Advanced Programmable Interrupt Controller)은 칩셋(보통 사우스브리지 또는 PCH)에 위치하며, 외부 장치의 인터럽트를 수집하여 시스템 버스를 통해 적절한 LAPIC으로 전달합니다. 주요 기능은 Redirection Table Entry(RTE)를 통한 인터럽트 라우팅입니다.

I/O APIC 레지스터 접근

I/O APIC은 MMIO 기반으로 접근하며, 기본 주소는 0xFEC00000입니다. 간접 주소 방식(Index/Data)을 사용합니다.

I/O APIC 프로그래밍

/* I/O APIC 간접 접근 매크로 */
static inline u32 io_apic_read(unsigned int apic, unsigned int reg)
{
    struct io_apic __iomem *io = io_apic_base(apic);

    writel(reg, &io->index);     /* IOREGSEL에 레지스터 번호 */
    return readl(&io->data);     /* IOWIN에서 데이터 읽기 */
}

static inline void io_apic_write(unsigned int apic, unsigned int reg, u32 val)
{
    struct io_apic __iomem *io = io_apic_base(apic);

    writel(reg, &io->index);
    writel(val, &io->data);
}

/* RTE 읽기 (64비트: low + high) */
static void ioapic_read_entry(int apic, int pin,
                              struct IO_APIC_route_entry *e)
{
    unsigned long flags;

    raw_spin_lock_irqsave(&ioapic_lock, flags);
    e->w1 = io_apic_read(apic, 0x10 + 2 * pin);      /* Low 32-bit */
    e->w2 = io_apic_read(apic, 0x10 + 2 * pin + 1);  /* High 32-bit */
    raw_spin_unlock_irqrestore(&ioapic_lock, flags);
}

/* RTE 쓰기 */
static void ioapic_write_entry(int apic, int pin,
                               struct IO_APIC_route_entry e)
{
    unsigned long flags;

    raw_spin_lock_irqsave(&ioapic_lock, flags);
    /* 주의: High 먼저 쓰기 (Low 쓰기 시 인터럽트 트리거 가능) */
    io_apic_write(apic, 0x10 + 2 * pin + 1, e.w2);
    io_apic_write(apic, 0x10 + 2 * pin, e.w1);
    raw_spin_unlock_irqrestore(&ioapic_lock, flags);
}

ACPI MADT를 통한 I/O APIC 감지

/* ACPI MADT (Multiple APIC Description Table)에서 I/O APIC 정보 파싱
 *
 * MADT Entry Type 1: I/O APIC
 *   - I/O APIC ID
 *   - I/O APIC Address (기본 0xFEC00000)
 *   - Global System Interrupt Base
 *
 * MADT Entry Type 2: Interrupt Source Override
 *   - ISA IRQ → GSI 매핑 (예: IRQ 0 → GSI 2 타이머 리다이렉트)
 */

static int __init acpi_parse_ioapic(
    union acpi_subtable_headers *header,
    const unsigned long end)
{
    struct acpi_madt_io_apic *ioapic =
        (struct acpi_madt_io_apic *)header;

    pr_info("I/O APIC: id=%d addr=0x%x gsi_base=%d\n",
            ioapic->id, ioapic->address,
            ioapic->global_irq_base);

    mp_register_ioapic(ioapic->id, ioapic->address,
                        ioapic->global_irq_base, NULL);
    return 0;
}

I/O APIC 핀-GSI-벡터 매핑

I/O APIC의 핀 번호, GSI(Global System Interrupt), 리눅스 IRQ 번호, 그리고 실제 CPU 벡터 사이의 매핑을 이해하는 것이 인터럽트 라우팅 디버깅(Debugging)의 핵심입니다.

/* I/O APIC 핀 → GSI 변환 */
static unsigned int pin_to_gsi(int ioapic_idx, int pin)
{
    return mp_ioapic_gsi_routing(ioapic_idx)->gsi_base + pin;
}

/* ISA IRQ → GSI 리다이렉트 (ACPI Interrupt Source Override)
 * 일반적인 리다이렉트:
 *   ISA IRQ 0 (PIT Timer) → GSI 2 (I/O APIC pin 2)
 *   ISA IRQ 9 (ACPI SCI)  → GSI 9 (Level, Low)
 */
static int __init acpi_parse_int_src_ovr(
    union acpi_subtable_headers *header,
    const unsigned long end)
{
    struct acpi_madt_interrupt_override *ovr =
        (struct acpi_madt_interrupt_override *)header;

    pr_info("INT_SRC_OVR: bus=%d src_irq=%d gsi=%d flags=0x%x\n",
            ovr->bus, ovr->source_irq, ovr->global_irq, ovr->inti_flags);

    /* flags[1:0]: Polarity (00=Bus default, 01=Active High, 11=Active Low)
     * flags[3:2]: Trigger  (00=Bus default, 01=Edge, 11=Level) */

    mp_override_legacy_irq(ovr->source_irq, ovr->inti_flags,
                           ovr->global_irq);
    return 0;
}

I/O APIC RTE 설정 예시

/* 특정 핀에 대한 완전한 RTE 설정 예시 */
static void setup_ioapic_irq(int apic_id, int pin,
                              int vector, int dest_apicid)
{
    struct IO_APIC_route_entry entry;

    memset(&entry, 0, sizeof(entry));

    /* Delivery Mode: Fixed (000) */
    entry.delivery_mode = APIC_DELIVERY_MODE_FIXED;

    /* Destination Mode: Physical (단일 CPU 지정) */
    entry.dest_mode_logical = 0;

    /* Trigger Mode: Edge (대부분의 ISA 장치) */
    entry.is_level = 0;

    /* Pin Polarity: Active High (ISA 기본) */
    entry.active_low = 0;

    /* Mask: 활성화 (0 = unmask) */
    entry.masked = 0;

    /* Vector 및 Destination 설정 */
    entry.vector = vector;
    entry.destid_0_7 = dest_apicid & 0xFF;

    /* RTE 쓰기 (High word 먼저!) */
    ioapic_write_entry(apic_id, pin, entry);
}

/* PCI 인터럽트는 일반적으로 Level-triggered, Active-Low
 * INTA# → 핀은 ACPI _PRT (PCI Routing Table)에서 결정
 * 또는 PIRQ 라우터 (레거시 시스템)로 매핑 */

인터럽트 전달 흐름

외부 장치에서 발생한 인터럽트가 CPU의 IDT 핸들러에 도달하기까지의 전체 과정입니다. I/O APIC 경로와 MSI 경로를 모두 포함하며, LAPIC의 우선순위 판단 로직이 핵심입니다.

벡터 우선순위 규칙

/* arch/x86/include/asm/irq_vectors.h - 리눅스 벡터 할당 */
#define FIRST_EXTERNAL_VECTOR       0x20
#define FIRST_SYSTEM_VECTOR         0xF0

/* 시스템 벡터 */
#define LOCAL_TIMER_VECTOR          0xF0
#define RESCHEDULE_VECTOR           0xF1
#define CALL_FUNCTION_VECTOR        0xF2
#define CALL_FUNCTION_SINGLE_VECTOR 0xF3
#define THERMAL_APIC_VECTOR         0xFB
#define THRESHOLD_APIC_VECTOR       0xFC
#define DEFERRED_ERROR_VECTOR       0xFD
#define ERROR_APIC_VECTOR           0xFE
#define SPURIOUS_APIC_VECTOR        0xFF

/* 벡터 할당 (동적): FIRST_EXTERNAL_VECTOR ~ FIRST_SYSTEM_VECTOR-1
 * 리눅스는 per-CPU 벡터 할당으로 같은 벡터를 다른 CPU에서 다른 IRQ에 사용 가능 */

x2APIC

x2APIC은 xAPIC의 확장으로, Intel Nehalem 이후 프로세서에서 지원됩니다. MMIO 대신 MSR(Model Specific Register)을 통해 LAPIC 레지스터에 접근하며, APIC ID가 8비트에서 32비트로 확장되어 이론적으로 4G 이상의 프로세서를 지원합니다.

x2APIC MSR 매핑

x2APIC 활성화 코드

/* arch/x86/kernel/apic/apic.c - x2APIC 활성화 */
void __init enable_x2apic(void)
{
    u64 msr;

    /* CPUID로 x2APIC 지원 확인 */
    if (!boot_cpu_has(X86_FEATURE_X2APIC)) {
        pr_info("x2APIC not supported\n");
        return;
    }

    /* Interrupt Remapping (VT-d/IOMMU) 필수 확인
     * x2APIC은 32-bit destination을 사용하므로
     * IR 없이는 보안 위험 (임의 CPU에 인터럽트 주입 가능) */
    if (!x2apic_supported_by_iommu()) {
        pr_warn("x2APIC requires Interrupt Remapping\n");
        return;
    }

    /* IA32_APIC_BASE MSR에서 x2APIC 활성화 */
    msr = rdmsrl(MSR_IA32_APICBASE);

    if (!(msr & X2APIC_ENABLE)) {
        msr |= X2APIC_ENABLE;   /* bit[10] = 1 */
        wrmsrl(MSR_IA32_APICBASE, msr);
    }

    pr_info("x2APIC enabled, APIC ID: %u\n",
            native_apic_msr_read(APIC_ID));
}

/* x2APIC Cluster 모드에서의 LDR 값
 * LDR = (Cluster ID << 16) | (1 << (APIC_ID % 16))
 * 하드웨어가 자동 설정 (소프트웨어 수정 불가) */

x2APIC Cluster 모드 상세

x2APIC의 Cluster 모드는 대규모 NUMA 시스템에서 효율적인 인터럽트 라우팅을 제공합니다. 32비트 APIC ID가 Cluster ID(상위 16비트)와 Logical ID(하위 16비트)로 분할됩니다.

/* x2APIC Cluster 모드: IPI 전송 최적화
 *
 * Cluster 모드에서 같은 클러스터 내 여러 CPU에 IPI를 보낼 때
 * 단일 ICR 쓰기로 비트맵 OR 전송 가능 (브로드캐스트 최적화)
 *
 * 예: Cluster 0의 CPU 0,1,3에 IPI 전송
 *   Destination = (0 << 16) | (1<<0 | 1<<1 | 1<<3) = 0x0000000B
 */
static void x2apic_send_IPI_mask_cluster(
    const struct cpumask *mask, int vector)
{
    unsigned int cpu, this_cluster, dest;
    unsigned long flags;

    local_irq_save(flags);

    /* 클러스터별로 묶어서 전송 */
    for_each_cpu(cpu, mask) {
        u32 apicid = per_cpu(x86_cpu_to_apicid, cpu);
        this_cluster = apicid >> 16;
        dest = apicid;  /* Cluster ID + Logical ID */

        /* 같은 클러스터의 다른 CPU도 비트맵에 추가 */
        /* (실제 구현은 클러스터별 그룹핑 최적화 포함) */

        __x2apic_send_IPI_dest(dest, vector,
                               APIC_DEST_LOGICAL);
    }

    local_irq_restore(flags);
}

/* xAPIC → x2APIC 전환 시 주의사항:
 * 1. DFR 레지스터가 제거됨 (x2APIC에서는 존재하지 않음)
 * 2. LDR은 읽기 전용 (하드웨어가 APIC ID 기반으로 자동 설정)
 * 3. ICR이 64비트 단일 MSR로 통합 (두 번 쓰기 불필요)
 * 4. Self IPI 전용 MSR 추가 (벡터만 지정, 최소 레이턴시)
 * 5. xAPIC으로 역전환 불가 (RESET 필요)
 */

x2APIC 성능 이점

IPI 메커니즘 상세

IPI(Inter-Processor Interrupt)는 한 CPU가 다른 CPU에게 인터럽트를 보내는 메커니즘입니다. LAPIC의 ICR(Interrupt Command Register)에 쓰기를 통해 발신하며, 리눅스 커널에서는 리스케줄링(Rescheduling), TLB 플러시(Flush), 함수 호출(Call Function), AP(Application Processor) 부팅 등에 사용됩니다.

ICR (Interrupt Command Register) 비트 필드

IPI 종류와 리눅스 커널 사용

INIT-SIPI-SIPI: AP 부팅 시퀀스

멀티프로세서 시스템에서 BSP(Bootstrap Processor)가 AP(Application Processor)를 부팅할 때 사용하는 표준 시퀀스입니다. Intel MP 스펙에 정의된 이 프로토콜은 INIT IPI로 AP를 리셋하고, SIPI(Startup IPI)로 시작 주소를 전달합니다.

/* arch/x86/kernel/smpboot.c - AP 부팅 (INIT-SIPI-SIPI) */
static int wakeup_secondary_cpu_via_init(int phys_apicid,
                                         unsigned long start_eip)
{
    unsigned long send_status, accept_status;
    int num_starts, j;

    /* 1단계: INIT IPI 전송
     * ICR: Level=Assert, Trigger=Level, DeliveryMode=INIT */
    apic_icr_write(APIC_INT_LEVELTRIG | APIC_INT_ASSERT |
                    APIC_DM_INIT, phys_apicid);
    udelay(200);  /* 200μs 대기 (INIT assert) */

    /* INIT de-assert */
    apic_icr_write(APIC_INT_LEVELTRIG | APIC_DM_INIT,
                    phys_apicid);

    /* 10ms 대기 (Intel MP 스펙 요구) */
    mdelay(10);

    /* 2단계: SIPI 2회 전송 (안전을 위한 재시도) */
    num_starts = 2;
    for (j = 1; j <= num_starts; j++) {
        /* SIPI: Vector = 시작 주소 / 4KB
         * 예: start_eip=0x8000 → Vector=0x08
         *     AP는 CS:IP = 0x0800:0x0000에서 시작 */
        apic_icr_write(APIC_DM_STARTUP |
                        (start_eip >> 12), phys_apicid);

        udelay(300);  /* 300μs 대기 */

        /* Delivery Status 확인 */
        send_status = safe_apic_wait_icr_idle();
        if (send_status)
            pr_err("SIPI #%d not delivered to CPU %d\n",
                    j, phys_apicid);
    }

    return send_status ? -EIO : 0;
}

/* AP 트램폴린 코드 (Real Mode 진입점)
 * arch/x86/realmode/rm/trampoline_64.S:
 *   1. Real Mode → Protected Mode → Long Mode 전환
 *   2. 커널이 준비한 스택/GDT/IDT 로드
 *   3. start_secondary() C 함수 호출
 */

리눅스 커널 IPI 전송 코드

/* 리눅스 커널의 주요 IPI 전송 함수들 */

/* 1. Reschedule IPI: 대상 CPU의 스케줄러 재평가 */
void smp_send_reschedule(int cpu)
{
    /* TIF_NEED_RESCHED 플래그가 설정된 후 호출
     * 대상 CPU가 idle이면 깨워서 스케줄러 실행 */
    apic->send_IPI(cpu, RESCHEDULE_VECTOR);  /* 0xF1 */
}

/* 2. Call Function IPI: 대상 CPU에서 함수 실행 */
void smp_call_function_single(int cpu,
    smp_call_func_t func, void *info, int wait)
{
    /* call_single_data 큐에 함수 등록 후 IPI 전송
     * wait=1이면 대상 CPU 실행 완료까지 대기 */
    generic_exec_single(cpu, func, info, wait);
}

/* 3. TLB Shootdown: 다른 CPU의 TLB 무효화 */
static void flush_tlb_others(
    const struct cpumask *cpumask,
    const struct flush_tlb_info *info)
{
    /* 페이지 테이블 변경 후 다른 CPU의 stale TLB 제거
     * SMP 시스템에서 메모리 일관성 핵심 메커니즘 */
    apic->send_IPI_mask(cpumask, INVALIDATE_TLB_VECTOR);
}

/* 4. x2APIC Self IPI (최소 레이턴시) */
static inline void x2apic_send_IPI_self(int vector)
{
    /* 전용 Self-IPI MSR: 벡터만 지정, ~15 cycles */
    wrmsrl(APIC_SELF_IPI, vector);
}

/* 5. NMI IPI: 디버깅/프로파일링용 */
void apic_send_nmi_to_offline_cpu(unsigned int cpu)
{
    apic->send_IPI(cpu, NMI_VECTOR);
}

APIC Timer

LAPIC에는 프로세서별 독립 타이머가 내장되어 있습니다. 전통적인 8254 PIT이나 HPET을 대체하며, 각 CPU 코어가 독립적인 타이머 인터럽트를 받을 수 있어 멀티프로세서 환경에서 필수적입니다. 세 가지 모드를 지원합니다: One-shot, Periodic, TSC-Deadline.

APIC Timer 설정 코드

/* One-shot 모드 설정 */
static void lapic_timer_oneshot(u32 count)
{
    /* LVT Timer: One-shot 모드 + 벡터 설정 */
    apic_write(APIC_LVTT, LOCAL_TIMER_VECTOR);  /* [18:17]=00 */

    /* 분주비 설정 (16분주) */
    apic_write(APIC_TDCR, APIC_TDR_DIV_16);

    /* Initial Count 쓰기 → 카운트다운 시작 */
    apic_write(APIC_TMICT, count);
}

/* Periodic 모드 설정 */
static void lapic_timer_periodic(u32 count)
{
    apic_write(APIC_LVTT,
        LOCAL_TIMER_VECTOR | APIC_LVT_TIMER_PERIODIC);  /* [18:17]=01 */
    apic_write(APIC_TDCR, APIC_TDR_DIV_16);
    apic_write(APIC_TMICT, count);
}

/* TSC-Deadline 모드 설정 */
static void lapic_timer_tsc_deadline(u64 deadline)
{
    /* LVT Timer: TSC-Deadline 모드 */
    apic_write(APIC_LVTT,
        LOCAL_TIMER_VECTOR | APIC_LVT_TIMER_TSCDEADL);  /* [18:17]=10 */

    /* IA32_TSC_DEADLINE MSR에 목표 TSC 값 쓰기
     * TSC >= deadline 시 인터럽트 발생
     * 인터럽트 후 자동으로 0 리셋 (재설정 필요) */
    wrmsrl(MSR_IA32_TSC_DEADLINE, deadline);
}

/* 리눅스 clockevent 연동 */
static int lapic_next_deadline(unsigned long delta,
                              struct clock_event_device *evt)
{
    u64 tsc = rdtsc();
    wrmsrl(MSR_IA32_TSC_DEADLINE, tsc + ((u64)delta));
    return 0;
}

APIC Timer 캘리브레이션

One-shot/Periodic 모드에서는 APIC Timer의 클럭 속도를 먼저 측정해야 정확한 시간 간격을 설정할 수 있습니다. 커널은 부팅 시 PIT 또는 TSC를 기준으로 APIC Timer 주파수를 캘리브레이션합니다.

/* arch/x86/kernel/apic/apic.c - APIC Timer 캘리브레이션 */
static void __init calibrate_APIC_clock(void)
{
    struct clock_event_device *levt = this_cpu_ptr(&lapic_events);
    u64 tsc_perj = 0, tsc_start = 0;
    unsigned long deltaj;
    long delta, deltatsc;
    int pm_referenced = 0;

    /* TSC-Deadline 모드 사용 가능하면 캘리브레이션 불필요 */
    if (boot_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER)) {
        levt->features &= ~CLOCK_EVT_FEAT_DUMMY;
        levt->features |= CLOCK_EVT_FEAT_ONESHOT;
        levt->set_next_event = lapic_next_deadline;
        clockevents_config_and_register(levt,
            tsc_khz * 1000, 0xF, ~0UL);
        return;
    }

    /* APIC Timer를 최대 분주비로 설정하고 알려진 기간 대기 */
    apic_write(APIC_TDCR, APIC_TDR_DIV_1);
    apic_write(APIC_TMICT, ~0U);

    /* jiffies 기반 10ms 대기 */
    deltaj = jiffies_to_msecs(1);
    mdelay(deltaj);

    /* 카운트다운 양으로 주파수 계산 */
    delta = ~0U - apic_read(APIC_TMCCT);

    /* 주파수 = delta / (deltaj_ms / 1000) */
    lapic_timer_period = (delta * 1000) / deltaj;

    pr_info("APIC timer calibrated: %lu.%03lu MHz\n",
            lapic_timer_period / 1000000,
            (lapic_timer_period / 1000) % 1000);
}

clockevent 연동 구조

/* 리눅스 clockevent 장치로 등록 */
static struct clock_event_device lapic_clockevent = {
    .name           = "lapic",
    .features       = CLOCK_EVT_FEAT_PERIODIC |
                      CLOCK_EVT_FEAT_ONESHOT |
                      CLOCK_EVT_FEAT_DUMMY,
    .shift          = 32,
    .set_state_periodic = lapic_timer_set_periodic,
    .set_state_oneshot  = lapic_timer_set_oneshot,
    .set_state_shutdown = lapic_timer_shutdown,
    .set_next_event     = lapic_next_event,
    .broadcast          = lapic_timer_broadcast,
    .rating             = 100,
    .irq                = -1,
};

/* One-shot 모드 진입 */
static int lapic_timer_set_oneshot(struct clock_event_device *evt)
{
    apic_write(APIC_LVTT, LOCAL_TIMER_VECTOR);  /* [18:17]=00 */
    apic_write(APIC_TMICT, 0);  /* 카운터 정지 */
    return 0;
}

/* 다음 이벤트 설정 (hrtimer가 호출) */
static int lapic_next_event(unsigned long delta,
                            struct clock_event_device *evt)
{
    apic_write(APIC_TMICT, delta);
    return 0;
}

/* TSC-Deadline vs One-shot 선택 기준:
 *   1. CPUID.06H:EAX[2] = 1 → TSC-Deadline 지원
 *   2. TSC가 invariant (constant_tsc, nonstop_tsc)
 *   3. 두 조건 모두 만족 시 TSC-Deadline 우선 사용
 *   4. 미지원 시 One-shot + PIT/HPET 캘리브레이션 폴백
 */

APIC Timer와 전원 관리(Power Management) 상호작용

MSI/MSI-X

MSI(Message Signaled Interrupts)와 MSI-X는 PCIe 장치가 I/O APIC을 우회하여 메모리 쓰기(Memory Write Transaction)로 직접 LAPIC에 인터럽트를 전달하는 현대적 방식입니다. 물리적인 인터럽트 라인이 필요 없으며, 벡터 수도 크게 확장됩니다.

/* MSI-X Table Entry 구조 (BAR 공간, 16바이트/엔트리) */
struct msix_entry {
    u32 msg_addr_lo;    /* [31:0]  Message Address Low */
    u32 msg_addr_hi;    /* [63:32] Message Address High (0 for 32-bit) */
    u32 msg_data;       /* [31:0]  Message Data */
    u32 vector_ctrl;    /* [0] Mask bit (1=마스크) */
};

/* 리눅스 MSI/MSI-X 설정 API */
int pci_alloc_irq_vectors(struct pci_dev *dev,
                          unsigned int min_vecs,
                          unsigned int max_vecs,
                          unsigned int flags);

/* 사용 예시 */
int nvecs = pci_alloc_irq_vectors(pdev, 1, num_cpus,
                PCI_IRQ_MSIX | PCI_IRQ_MSI | PCI_IRQ_LEGACY);
if (nvecs < 0)
    return nvecs;

/* 벡터별 IRQ 번호 조회 */
int irq = pci_irq_vector(pdev, vector_index);

/* IRQ 핸들러 등록 */
request_irq(irq, my_handler, 0, "my_device", priv);

/* 해제 */
pci_free_irq_vectors(pdev);

Interrupt Remapping

인터럽트 리매핑(Interrupt Remapping, IR)은 Intel VT-d 또는 AMD IOMMU가 제공하는 하드웨어 기능으로, MSI/MSI-X와 I/O APIC 인터럽트를 IOMMU의 리매핑 테이블(Remapping Table)을 통해 변환합니다. 이를 통해 DMA 공격에 의한 임의 인터럽트 주입을 방지하고, x2APIC의 32비트 Destination을 지원합니다.

Interrupt Remapping 아키텍처

IRTE (Interrupt Remapping Table Entry) 구조

/* Intel VT-d Interrupt Remapping Table Entry (IRTE) */
struct irte {
    union {
        struct {
            u64 present         : 1;   /* IRTE 유효 여부 */
            u64 fpd             : 1;   /* Fault Processing Disable */
            u64 dst_mode        : 1;   /* 0=Physical, 1=Logical */
            u64 redir_hint      : 1;   /* Redirection Hint */
            u64 trigger_mode    : 1;   /* 0=Edge, 1=Level */
            u64 dlvry_mode      : 3;   /* Delivery Mode (Fixed/LP) */
            u64 avail           : 4;   /* Available for software */
            u64 rsvd_1          : 3;
            u64 irte_mode       : 1;   /* 0=Remapped, 1=Posted */
            u64 vector          : 8;   /* Interrupt Vector */
            u64 rsvd_2          : 8;
            u64 dest_id         : 32;  /* Destination APIC ID */
        };
        u64 low;
    };
    union {
        struct {
            u64 sid             : 16;  /* Source ID (BDF) */
            u64 sq              : 2;   /* Source Qualification */
            u64 svt             : 2;   /* Source Validation Type */
            u64 rsvd_3          : 44;
        };
        u64 high;
    };
};

/* IRTE 설정 예시 */
static void setup_irte(struct irte *irte, int vector,
                      u32 dest_apicid, u16 source_bdf)
{
    memset(irte, 0, sizeof(*irte));

    irte->present = 1;
    irte->dst_mode = 0;        /* Physical */
    irte->trigger_mode = 0;    /* Edge */
    irte->dlvry_mode = 0;      /* Fixed */
    irte->vector = vector;
    irte->dest_id = dest_apicid;

    /* Source Validation: 장치 BDF 확인 */
    irte->sid = source_bdf;
    irte->svt = 1;   /* Source ID 검증 활성화 */
    irte->sq = 0;    /* 전체 BDF 일치 필요 */
}

Posted Interrupt (VT-d IR과 APICv 연동)

IRTE의 irte_mode=1로 설정하면, 외부 장치의 인터럽트가 IOMMU를 통해 직접 vCPU의 PID(Posted Interrupt Descriptor)에 기록됩니다. 이는 KVM의 Device Passthrough(장치 패스스루) 환경에서 호스트 개입 없이 게스트에 인터럽트를 전달하는 제로카피(Zero-Copy) 인터럽트 경로입니다.

Intel APICv (APIC Virtualization)

Intel APICv는 VT-x의 확장으로, 가상 머신의 APIC 접근을 하드웨어에서 직접 처리하여 VM Exit 오버헤드를 제거합니다. 주요 기능은 Virtual-APIC Page, TPR Shadow, Virtual Interrupt Delivery, Process Posted Interrupts입니다.

/* KVM의 APICv Posted Interrupt 처리 */
struct pi_desc {
    u32 pir[8];        /* Posted Interrupt Requests (256-bit) */
    union {
        struct {
            u16 on      : 1;  /* Outstanding Notification */
            u16 sn      : 1;  /* Suppress Notification */
            u16 rsvd    : 14;
            u8  nv;           /* Notification Vector */
            u8  rsvd2;
            u32 ndst;         /* Notification Destination */
        };
        u64 control;
    };
} __attribute__((aligned(64)));

/* Posted Interrupt 주입 흐름:
 * 1. 외부 장치 인터럽트 → KVM 핸들러
 * 2. PIR[vector] 비트 atomic OR 세팅
 * 3. ON 비트가 0이면 1로 세팅하고 notification IPI 발송
 * 4. 타겟 CPU의 PI handler가 PIR → vIRR로 병합
 * 5. Guest는 VM Exit 없이 인터럽트 수신
 */
static void vmx_deliver_posted_interrupt(struct kvm_vcpu *vcpu, int vector)
{
    struct vcpu_vmx *vmx = to_vmx(vcpu);
    struct pi_desc *pid = &vmx->pi_desc;

    /* PIR 비트 세팅 */
    if (pi_test_and_set_pir(vector, pid))
        return;  /* 이미 세팅됨 */

    /* ON 비트 세팅 + notification IPI */
    if (!pi_test_and_set_on(pid))
        apic_send_IPI(vcpu_to_pcpu(vcpu), POSTED_INTR_VECTOR);
}

AMD AVIC (Advanced Virtual Interrupt Controller)

AMD AVIC은 AMD-V(SVM)의 확장으로, Intel APICv에 대응하는 APIC 가상화 기능입니다. Backing Page, Physical/Logical APIC ID Table, Doorbell Mechanism을 사용하여 Guest의 APIC 접근을 하드웨어에서 직접 처리합니다.

AVIC vs APICv 비교

/* KVM의 AVIC 초기화 (arch/x86/kvm/svm/avic.c) */
static int avic_init_vcpu(struct vcpu_svm *svm)
{
    struct kvm_vcpu *vcpu = &svm->vcpu;
    struct page *page;

    /* Backing Page 할당 (4KB per vCPU) */
    page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);
    if (!page)
        return -ENOMEM;

    svm->avic_backing_page = page;

    /* VMCB에 Backing Page 물리 주소 설정 */
    svm->vmcb->control.avic_backing_page =
        page_to_phys(page) | AVIC_HPA_MASK;

    /* Physical APIC ID Table 엔트리 설정 */
    avic_update_physical_id_entry(vcpu, vcpu->vcpu_id);

    return 0;
}

/* AVIC Doorbell 전송 (IPI 가상화) */
static void avic_ring_doorbell(struct kvm_vcpu *vcpu)
{
    int cpu = READ_ONCE(vcpu->cpu);
    if (cpu != -1)
        wrmsrl(MSR_AMD64_SVM_AVIC_DOORBELL, cpu_to_apicid(cpu));
}

KVM LAPIC 에뮬레이션

KVM은 게스트 VM에 가상 LAPIC을 제공합니다. APICv/AVIC 미지원 시 소프트웨어 에뮬레이션으로, 지원 시 하드웨어 가속과 소프트웨어 폴백을 혼합합니다. struct kvm_lapic이 핵심 자료구조입니다.

/* arch/x86/kvm/lapic.h - KVM LAPIC 구조체 */
struct kvm_lapic {
    unsigned long base_address;       /* Guest가 보는 LAPIC 기본 주소 */
    struct kvm_io_device dev;          /* MMIO exit 처리용 */
    struct kvm_timer lapic_timer;     /* APIC 타이머 에뮬레이션 */
    u32 divide_count;                  /* 타이머 분주비 */
    struct kvm_vcpu *vcpu;            /* 소유 vCPU */
    bool sw_enabled;                   /* SVR[8] 소프트웨어 활성화 */
    bool irr_pending;                  /* IRR에 pending 인터럽트 있음 */
    bool lvt_lint0_watch;

    /* 가상 APIC 레지스터 페이지 (4KB)
     * APICv에서는 Virtual-APIC Page로 사용
     * 소프트웨어 에뮬레이션에서는 이 버퍼에서 직접 R/W */
    void *regs;

    /* 최고 ISR 벡터 캐시 (PPR 계산 최적화) */
    int highest_isr_cache;
};

/* Guest의 APIC MMIO 접근 처리 (APICv 미사용 시) */
static int apic_mmio_write(struct kvm_vcpu *vcpu,
                           struct kvm_io_device *dev,
                           gpa_t addr, int len, const void *val)
{
    u32 offset = addr & 0xFF0;
    u32 data = *(u32 *)val;

    switch (offset) {
    case APIC_EOI:
        apic_set_eoi(vcpu->arch.apic);
        break;
    case APIC_TASKPRI:
        apic_set_tpr(vcpu->arch.apic, data);
        break;
    case APIC_ICR:
        apic_send_ipi(vcpu->arch.apic, data);
        break;
    case APIC_TMICT:
        start_apic_timer(vcpu->arch.apic, data);
        break;
    /* ... 기타 레지스터 ... */
    }
    return 0;
}

/* 인터럽트 주입 가능 여부 확인 */
bool kvm_apic_has_interrupt(struct kvm_vcpu *vcpu)
{
    struct kvm_lapic *apic = vcpu->arch.apic;
    int highest_irr;

    if (!kvm_apic_present(vcpu))
        return false;

    highest_irr = apic_find_highest_irr(apic);
    if (highest_irr == -1)
        return false;

    /* PPR보다 높은 우선순위인지 확인 */
    return (highest_irr >> 4) > (kvm_apic_get_reg(apic, APIC_PROCPRI) >> 4);
}

KVM APIC Timer 에뮬레이션

/* KVM의 APIC Timer 에뮬레이션 */
struct kvm_timer {
    struct hrtimer timer;          /* 호스트 hrtimer 사용 */
    s64 period;                     /* 주기 (나노초) */
    ktime_t target_expiration;      /* 다음 만료 시각 */
    u32 timer_mode;                 /* One-shot/Periodic/TSC-Deadline */
    u32 timer_mode_mask;
    u64 tscdeadline;                /* TSC-Deadline 목표값 */
    u64 expired_tscdeadline;
    atomic_t pending;               /* 미처리 타이머 인터럽트 수 */
    bool hv_timer_in_use;           /* HW preemption timer 사용 여부 */
};

/* Guest가 APIC Timer ICR에 쓸 때 호출 */
static void start_apic_timer(struct kvm_lapic *apic)
{
    struct kvm_timer *ktimer = &apic->lapic_timer;
    u64 ns;

    if (ktimer->timer_mode == APIC_LVT_TIMER_TSCDEADL) {
        /* TSC-Deadline: HW preemption timer 사용 시도 (VM Exit 없이 만료) */
        if (kvm_can_use_hv_timer(apic->vcpu)) {
            ktimer->hv_timer_in_use = true;
            kvm_set_hv_timer(apic->vcpu, ktimer->tscdeadline);
            return;
        }
        /* 폴백: TSC → 나노초 변환 후 hrtimer 사용 */
        ns = kvm_scale_tsc(ktimer->tscdeadline - kvm_read_l1_tsc(apic->vcpu));
    } else {
        /* One-shot/Periodic: 카운트 × 분주비 → 나노초 */
        ns = (u64)kvm_apic_get_reg(apic, APIC_TMICT) *
             APIC_BUS_CYCLE_NS * apic->divide_count;
    }

    hrtimer_start(&ktimer->timer, ktime_add_ns(ktime_get(), ns),
                  HRTIMER_MODE_ABS_HARD);
}

가상화 레벨별 APIC 처리 비교

KVM APIC 관련 커널 모듈(Kernel Module) 파라미터

# APICv 활성화/비활성화 확인
cat /sys/module/kvm_intel/parameters/enable_apicv
# 1 = 활성화 (기본), 0 = 비활성화

# AVIC 활성화/비활성화 확인
cat /sys/module/kvm_amd/parameters/avic
# 1 = 활성화 (기본), 0 = 비활성화

# APICv 비활성화 (디버깅/비교 테스트용)
# /etc/modprobe.d/kvm.conf:
# options kvm_intel enable_apicv=0

# Guest에서 APIC 모드 확인
dmesg | grep -i "apic\|x2apic"

# KVM 통계로 APIC VM Exit 빈도 확인
perf kvm stat live
# 또는
cat /sys/kernel/debug/kvm/*/vcpu*/stats | grep -i apic

커널 struct apic 서브시스템

리눅스 커널은 다양한 APIC 모드(flat, physical, cluster, x2apic 등)를 struct apic 드라이버 모델로 추상화합니다. 부팅 시 하드웨어와 BIOS 설정에 따라 적절한 APIC 드라이버가 선택되며, IPI 전송, APIC ID 읽기 등의 연산을 드라이버별로 구현합니다.

/* arch/x86/include/asm/apic.h - struct apic 주요 콜백 */
struct apic {
    /* 이름과 우선순위 */
    const char *name;

    /* 프로빙: 이 드라이버가 현재 HW에 적합한지 검사 */
    int  (*probe)(void);

    /* IPI 전송 */
    void (*send_IPI)(int cpu, int vector);
    void (*send_IPI_mask)(const struct cpumask *mask, int vector);
    void (*send_IPI_all)(int vector);
    void (*send_IPI_allbutself)(int vector);
    void (*send_IPI_self)(int vector);

    /* APIC ID 관련 */
    u32  (*read)(u32 reg);
    void (*write)(u32 reg, u32 val);
    u32  (*get_apic_id)(u32 id);
    u32  (*set_apic_id)(u32 id);

    /* 논리적 목적지 설정 */
    void (*init_apic_ldr)(void);
    u32  (*calc_dest_apicid)(unsigned int cpu);

    /* IRQ 어피니티 */
    int  (*cpu_mask_to_apicid)(const struct cpumask *mask,
                               struct irq_data *irqdata,
                               unsigned int *dest);

    /* 기타 */
    int (*wakeup_secondary_cpu)(int apicid, unsigned long start_eip);
};

/* 전역 APIC 드라이버 포인터 */
extern struct apic *apic;

/* 사용 예: IPI 전송 */
apic->send_IPI(cpu, RESCHEDULE_VECTOR);

드라이버 선택 과정

/* arch/x86/kernel/apic/probe_64.c - 드라이버 선택 */
void __init default_setup_apic_routing(void)
{
    /* x2APIC + Interrupt Remapping 사용 가능? */
    if (x2apic_enabled()) {
        if (x2apic_phys)
            apic_install_driver(&apic_x2apic_phys);
        else
            apic_install_driver(&apic_x2apic_cluster);
        return;
    }

    /* xAPIC: CPU 수에 따라 선택 */
    if (num_possible_cpus() <= 8)
        apic_install_driver(&apic_flat);      /* Flat Logical */
    else
        apic_install_driver(&apic_physflat);  /* Physical Flat */
}

/* 커널 명령줄 옵션:
 *   apic=debug       - APIC 디버그 로그 활성화
 *   noapic           - I/O APIC 비활성화 (8259A 사용)
 *   nolapic          - LAPIC 비활성화
 *   x2apic_phys      - x2APIC Physical 모드 강제
 */

APIC 드라이버별 특성 비교

APIC 초기화 전체 흐름

부트 순서 (BSP):
  1. BIOS: 8259A PIC 모드로 시작, ACPI MADT 테이블 준비
  2. early_acpi_boot_init()
     └─ acpi_parse_madt() → LAPIC/I/O APIC 정보 수집
  3. init_apic_mappings()
     └─ LAPIC MMIO 매핑 (0xFEE00000)
  4. default_setup_apic_routing()
     └─ struct apic 드라이버 선택 (flat/cluster/x2apic)
  5. enable_x2apic() (지원 시)
     └─ IA32_APIC_BASE[10] = 1, IR 확인
  6. setup_local_APIC()
     └─ SVR 활성화, LVT 설정, TPR 초기화
  7. setup_IO_APIC()
     └─ RTE 프로그래밍, ISA IRQ 매핑
  8. 8259A PIC 마스크 (disable_8259A_irq)
  9. AP 부트: INIT-SIPI-SIPI → 각 AP에서 setup_local_APIC()

dmesg 출력 예시:
  [    0.000000] ACPI: LAPIC (acpi_id[0x00] lapic_id[0x00] enabled)
  [    0.000000] ACPI: IOAPIC (id[0x02] address[0xfec00000] gsi_base[0])
  [    0.000000] Using ACPI (MADT) for SMP configuration
  [    0.004000] x2apic: IRQ remapping enabled
  [    0.004000] Switched APIC routing to: x2apic_cluster

APIC ID 토폴로지

APIC ID는 단순한 프로세서 식별자가 아니라, 시스템의 물리적 토폴로지(Topology) 정보를 인코딩하고 있습니다. 소켓(Socket/Package), 코어(Core), 논리 프로세서(Thread/SMT) 계층이 APIC ID의 비트 필드에 반영되며, 커널은 이를 통해 NUMA 노드, 캐시 공유 관계, 스케줄링 도메인(Scheduling Domain)을 구성합니다.

APIC ID 비트 필드 구조

/* CPUID를 통한 APIC 토폴로지 파싱 */
static void detect_apic_topology(void)
{
    u32 eax, ebx, ecx, edx;
    int subleaf = 0;

    /* CPUID Leaf 0x0B: Extended Topology Enumeration
     * Sub-leaf 0: SMT 레벨
     * Sub-leaf 1: Core 레벨
     * Sub-leaf 2+: Die/Module 레벨 (최신 CPU) */
    do {
        cpuid_count(0x0B, subleaf, &eax, &ebx, &ecx, &edx);

        int level_type = (ecx >> 8) & 0xFF;
        int shift = eax & 0x1F;
        int num_procs = ebx & 0xFFFF;

        if (level_type == 0)
            break;  /* 더 이상 레벨 없음 */

        pr_info("Topology level %d: type=%s shift=%d procs=%d\n",
                subleaf,
                level_type == 1 ? "SMT" :
                level_type == 2 ? "Core" :
                level_type == 5 ? "Die" : "Unknown",
                shift, num_procs);

        subleaf++;
    } while (1);

    /* x2APIC ID: edx 값 (Leaf 0x0B 어느 sub-leaf에서든 동일) */
    pr_info("This CPU x2APIC ID: 0x%x\n", edx);
}

/* APIC ID에서 토폴로지 정보 추출 */
static void parse_apic_id(u32 apicid, int smt_shift, int core_shift)
{
    int smt_id  = apicid & ((1 << smt_shift) - 1);
    int core_id = (apicid >> smt_shift) & ((1 << (core_shift - smt_shift)) - 1);
    int pkg_id  = apicid >> core_shift;

    pr_info("APIC ID 0x%x → Package=%d Core=%d SMT=%d\n",
            apicid, pkg_id, core_id, smt_id);
}

토폴로지 확인 명령

# CPU별 APIC ID 및 토폴로지 확인
lscpu -e=CPU,SOCKET,CORE,ONLINE,NODE
# CPU SOCKET CORE ONLINE NODE
#   0      0    0      y    0
#   1      0    0      y    0    ← CPU 0과 하이퍼스레드 쌍
#   2      0    1      y    0
#   ...
#  16      1    0      y    1    ← 두 번째 소켓

# APIC ID 직접 확인
grep "apicid" /proc/cpuinfo | head -8
# apicid		: 0
# apicid		: 1
# apicid		: 2
# apicid		: 3

# 토폴로지 상세 (/sys)
for cpu in /sys/devices/system/cpu/cpu[0-9]*; do
    c=$(basename $cpu)
    pkg=$(cat $cpu/topology/physical_package_id 2>/dev/null)
    core=$(cat $cpu/topology/core_id 2>/dev/null)
    siblings=$(cat $cpu/topology/thread_siblings_list 2>/dev/null)
    echo "$c: socket=$pkg core=$core ht_siblings=[$siblings]"
done

# NUMA 노드별 CPU 매핑
numactl --hardware | grep "node.*cpus"
# node 0 cpus: 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
# node 1 cpus: 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31

실전 성능 튜닝

APIC 관련 성능 튜닝은 주로 인터럽트 어피니티(Interrupt Affinity) 설정, IRQ 분배 최적화, MSI-X 벡터 할당, IPI 오버헤드 감소에 집중됩니다. 고성능 네트워킹(Networking)이나 스토리지(Storage) 워크로드에서 이러한 튜닝이 처리량(Throughput)과 레이턴시(Latency)에 큰 영향을 미칩니다.

IRQ 어피니티 설정

# IRQ 어피니티 확인
cat /proc/irq/<IRQ번호>/smp_affinity_list
cat /proc/irq/<IRQ번호>/smp_affinity     # 비트마스크 형식

# IRQ를 특정 CPU에 고정 (예: IRQ 42를 CPU 3에)
echo 3 > /proc/irq/42/smp_affinity_list

# IRQ를 CPU 그룹에 분배 (예: CPU 0-3)
echo 0-3 > /proc/irq/42/smp_affinity_list

# 비트마스크로 설정 (CPU 0,2,4,6 = 0x55)
echo 55 > /proc/irq/42/smp_affinity

# MSI-X 벡터별 어피니티 설정 (NVMe 예시)
# NVMe는 보통 CPU당 1개 큐 = 1개 MSI-X 벡터
for irq in $(grep nvme /proc/interrupts | awk '{print $1}' | tr -d ':'); do
    echo "IRQ $irq: CPUs $(cat /proc/irq/$irq/smp_affinity_list)"
done

irqbalance 설정

고성능 워크로드 튜닝 체크리스트

# === 고성능 NIC 튜닝 예시 ===

# 1. MSI-X 벡터 확인
ethtool -l eth0
# Channel parameters for eth0:
# Pre-set maximums:
#   Combined:   64
# Current hardware settings:
#   Combined:   16

# 2. 큐 수를 CPU 수에 맞춤
ethtool -L eth0 combined 16

# 3. NUMA 노드 확인
cat /sys/class/net/eth0/device/numa_node
# 0

# 4. 해당 NUMA 노드의 CPU에만 IRQ 할당
NODE_CPUS=$(numactl --hardware | grep "node 0 cpus:" | cut -d: -f2)
i=0
for irq in $(grep eth0 /proc/interrupts | awk '{print $1}' | tr -d ':'); do
    cpu=$(echo $NODE_CPUS | awk "{print \$$((i+1))}")
    echo $cpu > /proc/irq/$irq/smp_affinity_list
    echo "IRQ $irq → CPU $cpu"
    i=$((i+1))
done

# 5. irqbalance에서 해당 IRQ 제외
for irq in $(grep eth0 /proc/interrupts | awk '{print $1}' | tr -d ':'); do
    IRQBALANCE_ARGS="$IRQBALANCE_ARGS --banirq=$irq"
done

# 6. Interrupt Coalescing 설정
ethtool -C eth0 rx-usecs 50 tx-usecs 50 rx-frames 64 tx-frames 64

# 7. 결과 확인: 인터럽트 분배 모니터링
watch -n 1 'grep eth0 /proc/interrupts'

디버깅

APIC 관련 문제는 인터럽트가 전달되지 않거나 잘못된 CPU로 라우팅되는 형태로 나타납니다. /proc/interrupts, ESR(Error Status Register), 커널 트레이스포인트, dmesg 로그를 활용하여 진단합니다.

/proc/interrupts 분석

# APIC 관련 인터럽트 확인
cat /proc/interrupts | head -5
#            CPU0       CPU1       CPU2       CPU3
# 0:         22          0          0          0  IR-IO-APIC   2-edge      timer
# 1:          0          0          3          0  IR-IO-APIC   1-edge      i8042
# 8:          0          0          0          1  IR-IO-APIC   8-edge      rtc0
# 9:          0         12          0          0  IR-IO-APIC   9-fasteoi   acpi

# 키 식별자:
#   IR-IO-APIC  : Interrupt Remapping + I/O APIC 경로
#   IR-PCI-MSI  : Interrupt Remapping + MSI 경로
#   IO-APIC     : IR 없는 I/O APIC (레거시)
#   PCI-MSI     : IR 없는 MSI

# APIC 내부 인터럽트
cat /proc/interrupts | grep -E "LOC|RES|CAL|TLB|ERR|SPU"
# LOC:  Local timer interrupts (APIC Timer)
# RES:  Rescheduling interrupts (IPI)
# CAL:  Function call interrupts (IPI)
# TLB:  TLB shootdowns (IPI)
# ERR:  APIC error count
# SPU:  Spurious interrupts

# IRQ 어피니티 확인
for irq in /proc/irq/*/smp_affinity_list; do
    echo "$(dirname $irq | xargs basename): $(cat $irq)"
done

# x2APIC 모드 확인
dmesg | grep -i "x2apic\|apic\|ioapic"

ESR (Error Status Register) 분석

/* ESR 읽기 (두 번 읽기 프로토콜) */
static u32 read_apic_esr(void)
{
    /* ESR은 "쓰기 후 읽기" 방식:
     * 1. ESR에 0을 쓰면 내부 에러 상태가 ESR로 래치
     * 2. ESR을 읽으면 래치된 값 반환 */
    apic_write(APIC_ESR, 0);
    return apic_read(APIC_ESR);
}

/* APIC 에러 인터럽트 핸들러 */
static void smp_error_interrupt(struct pt_regs *regs)
{
    u32 esr;

    entering_irq();
    esr = read_apic_esr();

    pr_err("APIC error on CPU%d: ESR=0x%x (%s%s%s%s%s%s%s%s)\n",
           smp_processor_id(), esr,
           (esr & 0x01) ? "Send_CS " : "",
           (esr & 0x02) ? "Recv_CS " : "",
           (esr & 0x04) ? "Send_Accept " : "",
           (esr & 0x08) ? "Recv_Accept " : "",
           (esr & 0x10) ? "Redir_IPI " : "",
           (esr & 0x20) ? "Send_Illegal " : "",
           (esr & 0x40) ? "Recv_Illegal " : "",
           (esr & 0x80) ? "Illegal_Reg " : "");

    ack_APIC_irq();
    exiting_irq();
}

커널 트레이스포인트

# APIC 관련 트레이스포인트 목록
ls /sys/kernel/debug/tracing/events/irq_vectors/
# local_timer_entry/exit    - APIC Timer 인터럽트
# reschedule_entry/exit     - Reschedule IPI
# call_function_entry/exit  - Call Function IPI
# error_apic_entry/exit     - APIC Error
# spurious_apic_entry/exit  - Spurious 인터럽트
# thermal_apic_entry/exit   - Thermal Monitor

# APIC Timer 인터럽트 트레이싱
echo 1 > /sys/kernel/debug/tracing/events/irq_vectors/local_timer_entry/enable
cat /sys/kernel/debug/tracing/trace_pipe | head -20

# ftrace로 APIC 함수 추적
echo function > /sys/kernel/debug/tracing/current_tracer
echo 'apic_*' > /sys/kernel/debug/tracing/set_ftrace_filter
cat /sys/kernel/debug/tracing/trace

# perf로 APIC 관련 오버헤드 측정
perf stat -e irq_vectors:local_timer_entry \
          -e irq_vectors:reschedule_entry \
          -e irq_vectors:call_function_entry \
          -a sleep 5

bpftrace를 이용한 APIC 진단

# 레시피 1: APIC Timer 인터럽트 빈도 및 레이턴시 측정
bpftrace -e '
tracepoint:irq_vectors:local_timer_entry {
    @timer_count = count();
    @start[cpu] = nsecs;
}
tracepoint:irq_vectors:local_timer_exit / @start[cpu] / {
    $lat = (nsecs - @start[cpu]) / 1000;
    @timer_lat_us = hist($lat);
    delete(@start[cpu]);
}
interval:s:5 {
    printf("=== APIC Timer 통계 (5초) ===\n");
    printf("총 인터럽트: "); print(@timer_count);
    printf("처리 레이턴시 (μs):\n"); print(@timer_lat_us);
    clear(@timer_count); clear(@timer_lat_us);
}'

# 레시피 2: IPI 종류별 빈도 측정
bpftrace -e '
tracepoint:irq_vectors:reschedule_entry { @ipi[\"reschedule\"] = count(); }
tracepoint:irq_vectors:call_function_entry { @ipi[\"call_func\"] = count(); }
tracepoint:irq_vectors:call_function_single_entry { @ipi[\"call_single\"] = count(); }
interval:s:5 {
    printf("=== IPI 종류별 빈도 (5초) ===\n");
    print(@ipi);
    clear(@ipi);
}'

# 레시피 3: APIC Error 실시간 감시
bpftrace -e '
tracepoint:irq_vectors:error_apic_entry {
    printf("APIC ERROR on CPU %d at %llu\n", cpu, nsecs);
    @err_count = count();
}
tracepoint:irq_vectors:spurious_apic_entry {
    printf("SPURIOUS APIC on CPU %d at %llu\n", cpu, nsecs);
    @spur_count = count();
}'

# 레시피 4: EOI 레이턴시 히스토그램 (함수 프로브)
bpftrace -e '
kprobe:ack_APIC_irq {
    @eoi_start[tid] = nsecs;
}
kretprobe:ack_APIC_irq / @eoi_start[tid] / {
    @eoi_ns = hist(nsecs - @eoi_start[tid]);
    delete(@eoi_start[tid]);
}
interval:s:10 { print(@eoi_ns); clear(@eoi_ns); }'

APIC 상태 진단 스크립트

#!/bin/bash
# apic_diag.sh: APIC 관련 진단 정보 수집

echo "=== 1. APIC 모드 확인 ==="
dmesg | grep -iE "apic|x2apic|ioapic" | tail -20

echo
echo "=== 2. /proc/interrupts (상위 20줄) ==="
head -22 /proc/interrupts

echo
echo "=== 3. APIC 관련 카운터 ==="
grep -E "LOC|RES|CAL|TLB|ERR|SPU|MIS|PMI|TRM" /proc/interrupts

echo
echo "=== 4. IRQ 어피니티 (장치 IRQ만) ==="
for d in /proc/irq/*/smp_affinity_list; do
    irq=$(echo "$d" | cut -d/ -f4)
    name=""
    [ -f "/proc/irq/$irq/actions" ] && name=$(cat "/proc/irq/$irq/actions" 2>/dev/null | head -1)
    [ -z "$name" ] && continue
    echo "  IRQ $irq ($name): CPUs $(cat $d)"
done

echo
echo "=== 5. MSI/MSI-X 장치 ==="
lspci -vvv 2>/dev/null | grep -B 10 "MSI-X\|MSI:" | grep -E "^[0-9a-f]|MSI"

echo
echo "=== 6. IOMMU / Interrupt Remapping 상태 ==="
dmesg | grep -iE "DMAR|IOMMU|interrupt remapping" | tail -10

echo
echo "=== 7. CPU별 APIC ID ==="
for cpu in /sys/devices/system/cpu/cpu[0-9]*; do
    id=$(cat "$cpu/topology/core_id" 2>/dev/null)
    pkg=$(cat "$cpu/topology/physical_package_id" 2>/dev/null)
    echo "  $(basename $cpu): package=$pkg core=$id"
done

echo
echo "=== 8. APIC 에러 확인 ==="
ERR=$(grep "ERR:" /proc/interrupts | awk '{sum=0; for(i=2;i<=NF-1;i++) sum+=$i; print sum}')
SPU=$(grep "SPU:" /proc/interrupts | awk '{sum=0; for(i=2;i<=NF-1;i++) sum+=$i; print sum}')
echo "  Total APIC errors: $ERR"
echo "  Total Spurious: $SPU"
[ "$ERR" -gt 0 ] && echo "  ⚠ APIC 에러 발생 - dmesg 확인 필요"

일반적인 APIC 문제 진단 플로우

일반적인 실수

자주 묻는 질문 (FAQ)

커널 명령줄 APIC 관련 옵션 정리

참고자료

커널 공식 문서

• Linux x86 APIC Documentation — 커널 공식 APIC 문서
• Linux generic IRQ handling — 범용 IRQ 처리 프레임워크 문서
• x86 Topology — x86 CPU 토폴로지와 APIC ID 매핑 문서
• MSI/MSI-X HOWTO — MSI/MSI-X 인터럽트 설정 가이드
• KVM API Documentation — KVM APIC 관련 ioctl 인터페이스 문서
• x86_64 Boot Options — noapic, nolapic, nox2apic 등 APIC 관련 부트 파라미터 설명

커널 소스 코드

• arch/x86/kernel/apic/ — APIC 서브시스템 디렉터리 (LAPIC, I/O APIC, x2APIC, IPI)
• arch/x86/kernel/apic/apic.c — Local APIC 핵심 초기화 및 관리 코드
• arch/x86/kernel/apic/io_apic.c — I/O APIC 드라이버, RTE 프로그래밍, IRQ 라우팅
• arch/x86/kernel/apic/x2apic_cluster.c — x2APIC Cluster 모드 구현
• arch/x86/kernel/apic/x2apic_phys.c — x2APIC Physical 모드 구현
• arch/x86/kernel/apic/ipi.c — IPI 전송 구현
• arch/x86/kernel/apic/vector.c — IRQ 벡터 할당 및 관리
• arch/x86/kernel/apic/msi.c — x86 MSI/MSI-X 인터럽트 도메인 구현
• arch/x86/include/asm/apicdef.h — APIC 레지스터 오프셋 및 상수 정의
• arch/x86/include/asm/apic.h — struct apic 정의 및 APIC 접근 함수
• arch/x86/kvm/lapic.c — KVM LAPIC 에뮬레이션 (struct kvm_lapic)
• arch/x86/kvm/irq_comm.c — KVM 인터럽트 라우팅 및 MSI 전달
• drivers/iommu/intel/irq_remapping.c — Intel VT-d Interrupt Remapping 구현

Intel/AMD 규격 문서

• Intel 64 and IA-32 Architectures Software Developer's Manual — Volume 3A, Chapter 10 "APIC": LAPIC 레지스터, x2APIC MSR, IPI, APIC Timer 상세 규격
• Intel 82093AA I/O Advanced Programmable Interrupt Controller (I/O APIC) Datasheet — I/O APIC 레지스터 맵, RTE 포맷, 전기적 특성
• Intel VT-x / VT-d 규격 — Volume 3C, Chapter 29-30: APICv (Virtual APIC, Posted Interrupts), Volume 3D: Interrupt Remapping
• AMD64 Architecture Programmer's Manual — Volume 2, Chapter 16 "APIC": AMD LAPIC/I/O APIC 구현, AVIC 규격
• ACPI Specification — MADT — Multiple APIC Description Table (MADT) 포맷, Local APIC/I/O APIC/x2APIC 엔트리 정의

LWN.net 기사

• x2APIC support and interrupt remapping — x2APIC 지원과 인터럽트 리매핑 관련 논의
• The x86 interrupt system — x86 인터럽트 시스템 전반에 대한 심층 분석
• Posted interrupts — KVM Posted Interrupt 메커니즘 소개
• The MSI-X interrupt mechanism — MSI-X 인터럽트 메커니즘 상세 설명
• The arrival of the x2APIC — x2APIC 도입 배경과 기술적 변화

OSDev 위키

• OSDev — APIC — Local APIC 프로그래밍 기초, 레지스터 맵, 초기화 절차
• OSDev — I/O APIC — I/O APIC 레지스터 접근, RTE 프로그래밍, IRQ 리다이렉션
• OSDev — APIC Timer — APIC 타이머 One-shot/Periodic/TSC-Deadline 모드 프로그래밍
• OSDev — Interrupts — 인터럽트 전반 개요, IDT, 벡터 할당
• OSDev — 8259 PIC — 레거시 PIC 프로그래밍, APIC으로의 전환 배경
• OSDev — MADT (Multiple APIC Description Table) — ACPI MADT 파싱 및 APIC 엔트리 해석

외부 기술 자료

• Towards Transparent CPU Scheduling (OLS 2007) — APIC 기반 인터럽트 라우팅과 CPU 스케줄링 관계 분석
• Understanding Virtual Interrupt in KVM — KVM의 가상 인터럽트 처리 (APICv, Posted Interrupt) 내부 구조 해설
• Linux Insides — Non-early initialization of the IRQs — Local APIC 초기화 과정 소스 코드 수준 추적
• Linux Insides — Handling of deferred interrupts (Softirq, Tasklets) — APIC EOI 이후 지연 인터럽트 처리 흐름