shell（用户态）
  → write() 函数（glibc 库函数）
  → 内核 sys_write（系统调用）
  → 终端驱动（内核）
  → 屏幕

// 用户态代码（32位保护模式）
mov eax, 4          // sys_write 系统调用号
mov ebx, 1         // fd = stdout
mov ecx, msg       // 缓冲区地址
mov edx, len       // 长度
int 0x80           // 触发中断，CPU 自动跳到 IDT[0x80]

# 32位：用 SYSENTER（Intel）
sysexit:
    mov ecx, edx        // 返回地址
    mov edx, esp        // 用户栈
    sysenter            // 跳入内核（无中断查表）
    ; 返回到 ecx

# 64位：用 SYSCALL（AMD）
syscall
    ; AMD 发明，Intel 后来也支持
    ; 更快：不用查 IDT，直接读 MSR

// 内核初始化时设置
wrmsr(0xC0000082, (unsigned long)syscall_entry);
// 从此 syscall 指令直接跳到这里

// 直接用 syscall
mov rax, 1          // sys_exit 系统调用号
mov rdi, 0          // exit code
syscall             // 进入内核 syscall_entry

0:   sys_read
1:   sys_write
2:   sys_open
3:   sys_close
4:   sys_newfstat
...
60:  sys_exit
231: sys_socketcall   // 嵌套调用

// glibc 源码简化
ssize_t write(int fd, const void *buf, size_t count) {
    ssize_t ret;
    __asm__ volatile(
        "movq $1, %%raxt"    // syscall 号 = 1
        "syscall"
        : "=a"(ret)
        : "D"(fd), "S"(buf), "d"(count)
        : "memory", "rcx", "r11"
    );
    return ret;
}

// syscall_entry（arch/x86/entry/entry_64.S）
ENTRY(syscall_entry)
    // 保存用户态寄存器到栈
    push    %r11             // rflags
    push    %rcx             // 返回地址
    push    %rax             // 系统调用号

    // 调用号作为索引进入 sys_call_table
    movq    %rax, %rcx
    shlq    $3, %rcx         // 每个 entry 8 字节
    leaq    sys_call_table(%rip), %rax
    movq    (%rax,%rcx), %rax    // 取函数指针
    call    *%rax           // 调用 sys_write

    // 返回值在 rax，恢复用户态
    jmp     syscall_return

// 内核源码
const sys_call_ptr_t sys_call_table[] = {
    [0] = __x64_sys_read,
    [1] = __x64_sys_write,
    [2] = __x64_sys_open,
    ...
    [60] = __x64_sys_exit,
};

// 相当于：
// rax=0 (sys_read), rdi=fd, rsi=buf, rdx=count
mov rax, 0
mov rdi, fd
mov rsi, buf
mov rdx, count
syscall
// 返回值在 rax（正数=读到的字节数，负数=错误码）

用户态
┌─────────────────────────┐
│ main()                  │
│   printf("hello");      │  ← glibc 库函数
│     → write(1, buf, 5) │  ← syscall 触发（C函数）
│       mov rax, 1        │  ← 写系统调用号
│       syscall          │  ← CPU 从 CPL=3 跳到 CPL=0
└─────────────────────────┘
        ↓
CPU 自动做的事（硬件级）：
  1. 保存 RIP、CS、RFLAGS、RSP、SS 到内核栈
  2. 加载 CS（内核代码段）→ CPL=0
  3. 从 MSR 读内核入口地址，跳过去

内核态
┌─────────────────────────┐
│ syscall_entry:           │  ← entry_64.S
│   SAVE_ALL              │  ← 保存所有寄存器到栈
│   call *sys_call_table  │  ← sys_write
│     → sys_write()       │  ← fs/read_write.c
│       → fd_ops.write    │  ← file_operations 结构
│         → tty_write     │  ← 终端驱动
│           → uart_write  │  ← 串口/屏幕
└─────────────────────────┘
        ↓
syscall_return:
  RESTORE_ALL              ← 恢复寄存器
  sysretq                  ← 返回用户态
        ↓
用户态恢复执行

当执行 syscall 时：
  CPU 检查目标代码段的 DPL（Descriptor Privilege Level）
  要求：DPL <= CPL（即：内核段 DPL=0，用户段 DPL=3）
  如果不满足 → #GP（General Protection Fault）

当访问内存页时：
  CPU 检查页表 entry 的 U/S 位
  如果当前是用户态（U/S=0 的页）→ #PF

// 假设我们知道 sys_write 地址
void *sys_write_addr = 0xffffffff81000000;
((int (*)(int, char*, int))sys_write_addr)(1, "hello", 5);