M2: 交互边界与内核接口

# 查看中断分布
cat /proc/interrupts

# 设置 IRQ 16 只由 CPU 0 和 CPU 1 处理
echo 3 > /proc/irq/16/smp_affinity  # 二进制 11 = 0x3

# 使用 irqbalance 自动均衡
systemctl status irqbalance

// 64-bit IDT 门描述符 (16 字节)
struct idt_gate {
    uint16_t offset_low;      // 处理程序偏移 [15:0]
    uint16_t segment;         // 段选择子 (通常指向内核代码段)
    uint8_t  ist;             // IST 索引 (0 = 使用传统栈切换)
    uint8_t  type_attr;       // 类型 + DPL + P
    uint16_t offset_mid;      // 处理程序偏移 [31:16]
    uint32_t offset_high;     // 处理程序偏移 [63:32]
    uint32_t reserved;        // 保留
};

// arch/x86/kernel/idt.c

// 异常处理程序注册
static const __initconst struct idt_data def_idts[] = {
    INTG(X86_TRAP_DE,       asm_exc_divide_error),      // #DE
    INTG(X86_TRAP_NMI,      asm_exc_nmi),               // NMI
    INTG(X86_TRAP_BP,       asm_exc_int3),              // #BP
    INTG(X86_TRAP_PF,       asm_exc_page_fault),        // #PF
    // ...
};

// 系统调用入口 (传统 int 0x80)
void __init idt_setup_traps(void) {
    idt_setup_from_table(idt_table, def_idts, ARRAY_SIZE(def_idts), true);
}

特权级切换情况 (Ring 3 → Ring 0):

1. 从 TSS 读取 rsp0 (内核栈指针)
2. 切换到内核栈
3. 按顺序压入:
   ┌─────────────────┐
   │       SS        │ (旧栈段)
   ├─────────────────┤
   │      RSP        │ (旧栈指针)
   ├─────────────────┤
   │     RFLAGS      │ (标志寄存器)
   ├─────────────────┤
   │       CS        │ (旧代码段)
   ├─────────────────┤
   │      RIP        │ (返回地址)
   ├─────────────────┤
   │   Error Code    │ (仅部分异常)
   └─────────────────┘
4. 从 IDT 加载新 CS:RIP
5. 如果是中断门, 清除 IF 位

// 上半部 (硬中断上下文, 不可睡眠, 应尽快完成)
irqreturn_t my_interrupt_handler(int irq, void *dev_id) {
    // 1. 检查是否是本设备产生的中断
    if (!my_device_interrupt_pending())
        return IRQ_NONE;
    
    // 2. 确认中断 (清除设备中断标志)
    acknowledge_interrupt();
    
    // 3. 快速处理必要操作
    save_data_to_buffer();
    
    // 4. 调度下半部处理
    tasklet_schedule(&my_tasklet);
    
    return IRQ_HANDLED;
}

// 注册 softirq (仅内核静态定义, 共 10 种)
open_softirq(NET_RX_SOFTIRQ, net_rx_action);

// 触发 softirq
raise_softirq(NET_RX_SOFTIRQ);

// softirq 处理函数
static void net_rx_action(struct softirq_action *h) {
    // 处理网络收包, 可能非常耗时
    process_backlog(...);
}

// 定义
DECLARE_TASKLET(my_tasklet, my_tasklet_func);

// 处理函数
void my_tasklet_func(struct tasklet_struct *t) {
    // 处理数据...
}

// 在中断上半部调度
tasklet_schedule(&my_tasklet);

// 定义工作项
DECLARE_WORK(my_work, my_work_func);

// 处理函数 (可睡眠!)
void my_work_func(struct work_struct *work) {
    mutex_lock(&my_mutex);  // OK: 可睡眠
    // 处理数据...
    mutex_unlock(&my_mutex);
}

// 调度到系统工作队列
schedule_work(&my_work);

// 调度到自定义工作队列
queue_work(my_wq, &my_work);

// include/linux/interrupt.h
enum {
    HI_SOFTIRQ,          // 高优先级 tasklet
    TIMER_SOFTIRQ,       // 定时器
    NET_TX_SOFTIRQ,      // 网络发送
    NET_RX_SOFTIRQ,      // 网络接收
    BLOCK_SOFTIRQ,       // 块设备
    IRQ_POLL_SOFTIRQ,    // IRQ 轮询
    TASKLET_SOFTIRQ,     // tasklet
    SCHED_SOFTIRQ,       // 调度器
    HRTIMER_SOFTIRQ,     // 高精度定时器
    RCU_SOFTIRQ,         // RCU 回调
    NR_SOFTIRQS           // softirq 数量
};

// 键盘驱动的中断处理程序
irqreturn_t keyboard_interrupt(int irq, void *dev_id) {
    unsigned char scancode;
    
    // 1. 从键盘控制器读取扫描码
    scancode = inb(0x60);  // 端口 0x60
    
    // 2. 将扫描码放入缓冲区
    keyboard_buffer[kb_write_pos++] = scancode;
    kb_write_pos %= BUFFER_SIZE;
    
    // 3. 唤醒等待键盘输入的进程
    wake_up_interruptible(&keyboard_wait_queue);
    
    return IRQ_HANDLED;
}

// 驱动初始化时注册中断
request_irq(1, keyboard_interrupt, IRQF_SHARED, "keyboard", &dev_id);

// 定时器中断 (Linux 简化版)
void timer_interrupt_handler(void) {
    // 1. 更新系统时间
    jiffies_64++;
    update_wall_time();
    
    // 2. 检查当前进程时间片
    if (--current->time_slice <= 0) {
        current->time_slice = 0;
        set_tsk_need_resched(current);  // 标记需要调度
    }
    
    // 3. 处理定时器链表上到期的定时器
    run_local_timers();
    
    // 4. 触发调度器软中断
    raise_softirq(SCHED_SOFTIRQ);
}

# 触发软中断, 进入向量 128 的处理程序
mov eax, 1          # 系统调用号 (exit)
mov ebx, 0          # 参数1 (退出码)
int 0x80            # 陷入内核

# x86-64 快速系统调用
mov rax, 60         # 系统调用号 (exit)
mov rdi, 0          # 参数1
syscall             # 快速陷入

// arch/x86/entry/syscall_64.c
const sys_call_ptr_t sys_call_table[__NR_syscall_max+1] = {
    [0]   = __x64_sys_read,
    [1]   = __x64_sys_write,
    [2]   = __x64_sys_open,
    [3]   = __x64_sys_close,
    // ...
    [57]  = __x64_sys_fork,
    [59]  = __x64_sys_execve,
    [60]  = __x64_sys_exit,
    // ...
};

// arch/x86/entry/entry_64.S (简化)
SYM_CODE_START(entry_SYSCALL_64)
    // 1. 切换到内核栈
    movq    %rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
    movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    
    // 2. 保存用户态寄存器
    pushq   $__USER_DS                  // SS
    pushq   PER_CPU_VAR(cpu_tss_rw + TSS_sp2)  // RSP
    pushq   %r11                        // RFLAGS
    pushq   $__USER_CS                  // CS
    pushq   %rcx                        // RIP
    
    // 3. 保存其他寄存器
    PUSH_AND_CLEAR_REGS rax=$-ENOSYS
    
    // 4. 调用实际处理函数
    movq    %rax, %rdi                  // syscall 号作为参数
    call    do_syscall_64
    
    // 5. 恢复并返回
    RESTORE_REGS
    USERGS_SYSRET64
SYM_CODE_END(entry_SYSCALL_64)

// include/linux/syscalls.h
// SYSCALL_DEFINE3 表示 3 个参数的系统调用
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
                size_t, count)
{
    return ksys_write(fd, buf, count);
}

ldd /bin/ls
# linux-vdso.so.1 (0x00007ffe...)

cat /proc/self/maps | grep vdso
# 7ffe... r-xp 00000000 00:00 0 [vdso]

#include <linux/seccomp.h>
#include <linux/filter.h>
#include <sys/prctl.h>

struct sock_filter filter[] = {
    // 加载系统调用号
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 
             offsetof(struct seccomp_data, nr)),
    
    // 允许 read (0)
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_read, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
    
    // 允许 write (1)
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
    
    // 允许 exit_group (231)
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_exit_group, 0, 1),
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
    
    // 拒绝其他所有
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL),
};

struct sock_fprog prog = {
    .len = sizeof(filter) / sizeof(filter[0]),
    .filter = filter,
};

// 应用过滤器
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

# 查看 Docker 默认 seccomp profile
docker info | grep -i seccomp

# 运行容器时禁用 seccomp (不推荐)
docker run --security-opt seccomp=unconfined ...

# 追踪进程的系统调用
strace ls

# 统计系统调用次数
strace -c ls

# 追踪特定系统调用
strace -e trace=open,read,write ls

# 追踪网络相关
strace -e trace=network curl example.com

# 追踪系统调用事件
perf trace ls

# 统计系统调用延迟
perf trace -s ls

# 生成火焰图
perf record -g -a -- sleep 10
perf script | stackcollapse-perf.pl | flamegraph.pl > out.svg

// arch/x86/include/asm/ptrace.h
struct pt_regs {
    /* (1) 内核入口代码手动压入 */
    unsigned long r15, r14, r13, r12;
    unsigned long rbp, rbx;
    unsigned long r11, r10, r9, r8, rax, rcx, rdx, rsi, rdi;
    unsigned long orig_rax; // 系统调用号 (仅用于系统调用)

    /* (2) 硬件在特权级切换时自动压入 */
    unsigned long rip, cs, eflags, rsp, ss;
};

// 定义一个 Map
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10240);
    __type(key, u32);    // PID
    __type(value, u64);  // 计数器
} process_count SEC(".maps");

// 在 BPF 程序中使用
SEC("kprobe/do_sys_open")
int trace_open(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    u64 *count = bpf_map_lookup_elem(&process_count, &pid);
    if (count)
        (*count)++;
    return 0;
}

// 无需为每个内核版本编译
// CO-RE 自动处理 task_struct->comm 的偏移差异
char comm[16];
bpf_probe_read_kernel_str(comm, sizeof(comm), 
                          task->comm);  // 自动重定位

# 追踪所有文件打开操作
bpftrace -e 'tracepoint:syscalls:sys_enter_openat { 
    printf("%s %s\n", comm, str(args->filename)); 
}'

# 统计系统调用延迟分布
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @start[tid] = nsecs; }
             tracepoint:raw_syscalls:sys_exit  { 
                 @latency = hist(nsecs - @start[tid]); 
                 delete(@start[tid]); 
             }'