中断和异常的分类：

硬件中断（异步）
  ├── 可屏蔽中断 (IRQ) — IF=1 时响应，IF=0 时忽略
  └── 不可屏蔽中断 (NMI) — 硬件故障，如内存奇偶校验错误

CPU 异常（同步）
  ├── Fault（故障）— 可修复，可回到触发指令重新执行
  │   ├── #DE（除零）
  │   ├── #PF（Page Fault）
  │   └── #GP（通用保护）
  ├── Trap（陷阱）— 有意触发，执行后继续下一条指令
  │   ├── #DB（调试断点）
  │   └── #OF（溢出）
  └── Abort（中止）— 不可恢复，记录错误，终止进程
      └── #DF（双重故障）

IDT Gate Descriptor（8字节 = 64位）格式：

┌──────────────────────────────────────────────────────────────┐
│  Bit 63-48:  Offset [31:16]  (处理函数地址高16位)            │
│  Bit 47-40:  Reserved / Selector (代码段选择子)             │
│  Bit 39-36:  Zero                                          │
│  Bit 35-32:  Gate Type（门类型）                            │
│  Bit 31-16:  Offset [15:0]   (处理函数地址低16位)            │
│  Bit 15-8:   Selector (代码段选择子)                        │
│  Bit 7-0:    IST / Reserved                                │
└──────────────────────────────────────────────────────────────┘

Gate Type 值：
  0x5E = 64位 Interrupt Gate（中断门）
  0x6E = 64位 Trap Gate（陷阱门）
  0x7E = 64位 Task Gate（任务门，较少用）

Interrupt Gate vs Trap Gate 的区别：
  Interrupt Gate：跳转时自动关闭中断（IF=0），防止嵌套
  Trap Gate：跳转时保持 IF 不变，允许嵌套中断（但要小心）

IDT 向量分配（x86 通用约定）：

向量号   名称   类型        说明
0x00    #DE    Fault       除零错误
0x01    #DB    Fault/Trap  调试
0x02    NMI    Interrupt   不可屏蔽中断
0x03    #BP    Trap        断点（INT3）
0x04    #OF    Trap        溢出（INTO）
0x05    #BR    Fault       越界（BOUND）
0x06    #UD    Fault       无效操作码
0x07    #NM    Fault       设备不可用（无数学协处理器）
0x08    #DF    Abort       双重故障
0x09    Copr   —           协处理器段超限（已废弃）
0x0A    #TS    Fault       无效TSS
0x0B    #NP    Fault       段不存在
0x0C    #SS    Fault       栈故障
0x0D    #GP    Fault       通用保护（最常见）
0x0E    #PF    Fault       页 fault（最常见）
0x0F    —      Reserved
0x10    #MF    Fault       x87 浮点错误
...
0x20-0x2F  外设中断（IRQ0-IRQ15，对应 8259A PIC）
0x80    系统调用 (Linux INT 0x80)

// 设置 IDT（简化版）
setup_idt:
    # 加载 IDT 基址到 IDTR
    lidt idt_descriptor

    # 对每个中断向量填写 gate
    movw $0x08, %ax        # 代码段选择子（Ring 0 代码段）
    movb $0x8E, %dl        # P=1, DPL=00, D=1（32位中断门）

    # 填写 vector 0（#DE 除零）
    movl $handler_0, (idt_base + 0*8)         # offset 低32位
    movw $0, (idt_base + 0*8 + 4)             # selector
    movb $0, (idt_base + 0*8 + 5)             # zero + type
    movw $0, (idt_base + 0*8 + 6)             # offset 高16位

    # 填写 vector 0x0E（#PF 页 fault）
    movl $handler_pf, (idt_base + 0x0E*8)
    ...

idt_descriptor:
    .word 256 * 8 - 1   # IDT  limit = 256 entries × 8 bytes
    .quad idt_base       # IDT  base address

8259A PIC 级联结构：

        CPU
          ↑
          │
      ┌───┴───┐
      │ 8259A │  ← 主 PIC（IRQ0-IRQ7）
      └───┬───┘
          │
      ┌───┴───┐
      │ 8259A │  ← 从 PIC（IRQ8-IRQ15）
      └───┬───┘
         /|
    IRQ0-7   IRQ8-15

主 PIC 端口：0x20（命令）, 0x21（数据）
从 PIC 端口：0xA0（命令）, 0xA1（数据）

向量映射：主 PIC IRQ0 → IDT 0x20
          从 PIC IRQ0 → IDT 0x28

LAPIC 结构：

┌──────────────────────────────────────┐
│  ID Register (0xFEE00020)            │  ← LAPIC ID（每个核唯一）
│  Version Register (0xFEE00030)        │
│  TPR (Task Priority Register)        │  ← 屏蔽低优先级中断
│  PPR (Processor Priority Register)    │
│  EOI (0xFEE000B0)                    │  ← 中断结束，写 0
│  LVT (Local Vector Table)             │  ← 本地中断配置
│  INR (In-Service Register)            │  ← 正在处理的中断
│  IRR (Interrupt Request Register)     │  ← 待处理的中断
└──────────────────────────────────────┘

IOAPIC → 系统总线 → LAPIC → CPU

键盘按下 → IRQ1 → 主 PIC → 发送 INT 信号给 CPU
    ↓
CPU 完成当前指令
    ↓
从 IDT[IRQ1_vector] 读取 gate 描述符
    ↓
检查 gate 类型，保存上下文（CS/EIP/EFLAGS）
    ↓
如果是中断门，自动关闭 IF（可屏蔽中断）
    ↓
跳转到 ISR 入口（handler_ keyboard）
    ↓
ISR 处理键盘读取（从端口 0x60 读扫描码）
    ↓
写 LAPIC EOI（通知中断处理完成）
    ↓
恢复上下文，返回被中断的代码继续执行

#PF Exception Handler（简化流程）：

handler_pf:
    # 保存错误码和触发地址
    push %rax
    movl %cr2, %rax          # CR2 存触发 fault 的线性地址
    push %rax
    push %ds
    push %es
    ...

    # 判断是哪种 fault
    movl %cr2, %edi           # 虚拟地址
    movl 8(%rsp), %esi        # 错误码

    # 检查地址是否在合法 VMA
    find_vma(mm, addr)
    je valid_access

    # 非法访问 → SIGSEGV
    send_sigsegv(current, addr)
    jmp restore_and_exit

valid_access:
    # 页面不在内存 → 换入
    handle_page_fault(vma, addr, error_code)
    # 换入后更新 PTE，重新执行触发指令

restore_and_exit:
    # 恢复上下文
    # iretq 回到触发指令（Fault 可重新执行）

#PF Error Code 位域：
┌──────┬──────┬──────┬──────┐
│ P    │ W    │ U    │ RSVD  │
└──────┴──────┴──────┴──────┘

Bit 0: P (Present) = 0 → 页不存在，= 1 → 权限错误
Bit 1: W (Write) = 1 → 写操作，= 0 → 读操作
Bit 2: U (User) = 1 → 用户态，= 0 → 内核态
Bit 3: RSVD = 1 → 写入了保留位（如页表项的保留位）

组合判断：
  P=0, W=0, U=0 → 内核读不存在的页（可能是换出）
  P=0, W=1, U=1 → 用户态写不存在页（COW 或换入）
  P=1, W=1, U=0 → 内核写只读页（bug）

# 查看注册的中断处理函数（/proc/interrupts）
cat /proc/interrupts

           CPU0
  0:          0   IO-APIC   2   edge      timer
  1:          5   IO-APIC   1   edge      i8042
  8:          1   IO-APIC   0   edge      rtc0
  9:          0   IO-APIC   9   fasteoi   acpi
 12:        100   IO-APIC  12   edge      i8042
 24:          0   Local-APIC  2   edge      intel_bxt_hrt

# NMI 计数器（看硬件错误）
cat /proc/interrupts | grep NMI

# 查看每个 CPU 核心的中断统计
cat /proc/softirqs

# 观察中断上半部/下半部（tasklet/softirq）
watch -n1 "cat /proc/softirqs | grep NET"

# 用 perf 观察中断频率
perf record -e irq:irq_handler_entry -a sleep 5
perf report

# 手动触发一个 #PF（读取 /proc/self/maps 之外的有效地址）
# 不会崩溃，只会产生 page fault
python3 -c "
import mmap
m = mmap.mmap(-1, 4096, prot=mmap.PROT_READ)
# 读取映射区以外地址会触发 SIGSEGV，不是 page fault
# 读取已映射但未分配的匿名页会产生 soft page fault
"

# wandos IDT 初始化（简化版）
# 源码：arch/x86/idt.S

.section .text
.global idt_init
.type idt_init, @function

idt_init:
    # 加载 IDT 基址和界限到 IDTR
    movq $idt_table, %rax
    movw $(256 * 16 - 1), %cx    # 256 个门描述符 × 16字节（64位）
    lidt (%rcx, %rax)

    # 初始化 PIC（屏蔽所有 IRQ，等待 LAPIC 配置）
    movb $0x11, %al              # ICW1: 初始化 + 需要 ICW4
    outb %al, $0x20              # 主 PIC 命令端口
    outb %al, $0xA0              # 从 PIC 命令端口

    movb $0x20, %al              # IRQ0 → 中断向量 0x20
    outb %al, $0x21              # 主 PIC 屏蔽码
    movb $0x28, %al              # IRQ8 → 中断向量 0x28
    outb %al, $0xA1              # 从 PIC 屏蔽码

    ret

# wandos 通用中断处理宏
# 源码：arch/x86/interrupt.S

# 定义通用的中断入口
.macro INTERRUPT_HANDLER name
.global name
name:
    # 保存寄存器上下文
    pushq %rax
    pushq %rbx
    pushq %rcx
    ...

    # 调用 C 处理函数
    movq $name, %rdi            # 中断向量号作参数
    call interrupt_handler_c

    # 恢复寄存器
    popq %rcx
    popq %rbx
    popq %rax

    # 中断返回（自动恢复 IF）
    iretq
.endm

# 为每个向量生成处理函数
INTERRUPT_HANDLER handler_0    # 除零
INTERRUPT_HANDLER handler_1    # 调试
...
INTERRUPT_HANDLER handler_14  # Page Fault
...
INTERRUPT_HANDLER handler_32  # IRQ0 时钟
INTERRUPT_HANDLER handler_33  # IRQ1 键盘

// wandos IDT C 代码
// 源码：arch/x86/idt.c

// IDT 门描述符结构
struct idt_gate {
    uint16_t offset_low;         // 处理函数地址低16位
    uint16_t selector;           // 代码段选择子
    uint8_t  ist;                // IST 表
    uint8_t  type_attr;          // Gate Type + 属性
    uint16_t offset_mid;         // 处理函数地址中16位
    uint32_t offset_high;        // 处理函数地址高32位
    uint32_t reserved;
} __attribute__((packed));

// 设置单个 IDT entry
void idt_set_gate(int vector, void *handler,
                  uint8_t dpl, bool user) {
    struct idt_gate *gate = &idt_table[vector];
    uint64_t addr = (uint64_t)handler;

    gate->offset_low = addr & 0xFFFF;
    gate->offset_mid = (addr >> 16) & 0xFFFF;
    gate->offset_high = (addr >> 32) & 0xFFFFFFFF;
    gate->selector = 0x08;           // 内核代码段
    gate->ist = 0;
    gate->type_attr = 0x8E;          // P=1, DPL=0, 64位中断门
    if (user) {
        gate->type_attr = 0xEE;      // DPL=3，允许用户态调用
    }
}

// Page Fault handler
void page_fault_handler(uint64_t fault_addr, uint64_t error_code) {
    // 判断 fault 类型
    bool present = (error_code & 1);
    bool write = (error_code & 2);
    bool user = (error_code & 4);

    if (!present && !user) {
        // 内核态访问未映射页面 → 可能是换页
        // 或内核 bug（空指针解引用）
        panic("Kernel page fault at %pn", fault_addr);
    } else if (!present) {
        // 用户态换入页面
        handle_user_page_fault(fault_addr);
    } else {
        // 权限错误（写只读、用户访问内核页）
        send_sigsegv(current_task, fault_addr);
    }
}