执行上下文（Execution Context）的组成：

CPU 寄存器：
  - 通用寄存器：rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp, r8-r15
  - 指令指针：rip（下一条要执行的指令地址）
  - 栈指针：rsp
  - 段寄存器：cs, ds, es, fs, gs, ss
  - FLAGS：rflags（条件码，如 ZF, SF, OF 等）

控制寄存器：
  - cr0（保护模式开关、缓存开关等）
  - cr2（Page Fault 地址）
  - cr3（页表基址——每个进程不同！）
  - cr4（PAE、Page Size Extension 等）

浮点和 SIMD 状态：
  - xmm0-xmm15, ymm0-ymm15, zmm0-zmm31（AVX512）
  - x87 FPU 寄存器（st0-st7）
  - MXCSR（FPU 控制/状态）

特权级别：
  - CPL（Current Privilege Level）
  - RSP（用户态栈指针，需要在切换时保存）

其他：
  - IDTR（中断描述符表位置）
  - GDTR（全局描述符表位置）

每个进程有两把栈：

用户态栈（进程空间，Ring 3）：
  → 程序执行 main() / 函数调用 / 局部变量时用
  → 切换到内核时，硬件自动把 SS/RSP/RFLAGS/CS/RIP 压到内核栈

内核栈（内核空间，Ring 0）：
  → 系统调用、中断、异常处理时用
  → 进程切换时，CPU 寄存器保存在这里
  → 大小固定（通常是 8KB 或 16KB，对齐到页面）

┌──────────────────────────────────────┐
│         内核栈（Ring 0）              │
│                                      │
│  ...                                 │
│  SS（用户栈选择子）                   │ ← 中断入口时自动压入
│  RSP（用户栈指针）                    │
│  RFLAGS                              │
│  CS（用户代码段选择子）               │
│  RIP（用户下一条指令）                │
│  error code / vector                 │
│  ...                                 │
│  callee-saved registers              │ ← switch_to 保存
│  ...                                 │
│  task_struct *current                │ ← 调度器用
└──────────────────────────────────────┘

# x86_64 switch_to 宏（简化版）
# 源码：arch/x86/include/asm/switch_to.h

.macro SWITCH_TO prev, next, saved_reg
    # 保存 prev 的 callee-saved 寄存器
    pushf                         # 保存 RFLAGS
    pushq %rbp
    pushq %r12
    pushq %r13
    pushq %r14
    pushq %r15
    pushq %rbx

    # 把 prev 的栈指针保存到 prev->thread.sp
    movq %rsp, (prev + THREAD_SP)($1)

    # 把 next 的栈指针恢复到 RSP（切换到 next 的栈！）
    movq (next + THREAD_SP)($2), %rsp

    # 恢复 next 的 callee-saved 寄存器
    popq %rbx
    popq %r15
    popq %r14
    popq %r13
    popq %r12
    popq %rbp
    popf

    # 此时 CPU 在 next 的栈上运行
    # next 的 rip 已经在栈上（上次切换时保存的）
    # ret 指令会弹出这个 rip，next 从断点继续执行
.endm

// Linux context_switch（简化版）
// 源码：kernel/sched/core.c

static __always_inline void
context_switch(struct rq *rq, struct task_struct *prev,
               struct task_struct *next) {
    // Step 1: 切换地址空间（页表）
    if (next->mm != prev->mm) {
        // 加载 next 的页表（CR3）
        switch_mm(prev->mm, next->mm);
    } else {
        // 同一地址空间（线程），只切换栈
    }

    // Step 2: 切换内核栈
    // 这行汇编做了真正的寄存器保存/恢复
    switch_to(prev, next, prev->thread.sp);

    // 当 switch_to 返回时，CPU 已经在 next 的上下文里
    // prev 和 next 的角色互换（下一个调度周期里，prev 会再次被切换回来）
}

context_switch 被调用的时机：

schedule()
    ↓
pick_next_task() 选出了 next
    ↓
context_switch(rq, prev, next)
    ↓
switch_to(prev, next)  ← 真正的寄存器切换
    ↓
next 进程从 switch_to 返回，继续执行

fork() 的返回路径（子进程视角）：

main() {
    pid = fork();   ← 调用 libc fork()
        ↓
    syscall(SYS_fork) → do_fork() → copy_process()
        ↓
    子进程被 schedule() 调度到
        ↓
    switch_to(父进程, 子进程)  ← 切换寄存器
        ↓
    子进程恢复执行（从它上次被中断的地方）
        ↓
    在子进程的栈上，rax = 0（copy_process 里设置的）
        ↓
    ret 指令从 syscall 返回
        ↓
    libc 读到 rax = 0 → return 0（子进程）
}

进程切换（prev->mm != next->mm）：
  → 必须切换 CR3（页表基址）
  → TLB 自动失效（或用 invpcid 刷新）
  → 代价较大（大约 100-200 个 CPU 周期）

线程切换（prev->mm == next->mm）：
  → 不切换 CR3，共享同一个地址空间
  → TLB 不失效（同一个进程的线程）
  → 只需要切换寄存器（栈、IP、通用寄存器）
  → 代价小（约 20-50 个 CPU 周期）

// 调度器对进程和线程的区别处理
context_switch() {
    if (prev->mm != next->mm) {
        // 进程：切换地址空间（慢）
        load_cr3(next->pgd);
        // TLB flush
    }
    // 线程：不需要 load_cr3（快）
    // ...

    // 切换寄存器（都需要的）
    switch_to(prev, next);
}

# 观察系统整体上下文切换次数
vmstat 1

# 每秒上下文切换次数（cs 列）
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0      0 655360  12340 234567    0    0     0     0   34  120  5  2 93  0  0
# cs = context switches per second

# 用 pidstat 看单个进程的上下文切换
pidstat -w 1 2

# 输出：
# UID       PID   cswch/s  mig/s
# root     1234      150     0
# cswch = voluntary context switches（进程主动让出）
# mig = involuntary context switches（被调度器抢走）

# 用 perf 观察上下文切换热点
perf record -e sched:sched_switch -a sleep 5
perf report

# 观察调度延迟
perf sched record -a sleep 10
perf sched latency

# 显示每个进程的调度延迟（avg, max）
# 延迟大 = 调度不及时，可能影响响应

# 观察 CPU 在不同进程间的迁移
cat /proc/$$/status | grep Ctx

# 用 strace 观察系统调用导致的切换
strace -f -e trace=read,write ls /tmp
# -f 同时追踪 fork 出来的子进程

# wandos 上下文切换汇编
# 源码：kernel/process/switch.S

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

# 参数：rdi = prev PCB*, rsi = next PCB*
switch_to:
    # 保存 callee-saved 寄存器
    pushq %rbp
    pushq %r12
    pushq %r13
    pushq %r14
    pushq %r15
    pushq %rbx

    # 保存当前栈指针到 prev->sp
    movq %rsp, (%rdi)

    # 恢复下一个进程的栈指针
    movq (%rsi), %rsp

    # 恢复下一个进程的寄存器
    popq %rbx
    popq %r15
    popq %r14
    popq %r13
    popq %r12
    popq %rbp

    # 返回（弹出之前保存的 rip）
    ret

// wandos 调度器中的上下文切换调用
// 源码：kernel/process/scheduler.cpp

void schedule(void) {
    struct process_control_block *prev = current;
    struct process_control_block *next = pick_next_process();

    if (next == prev) return;  // 同一进程，不需要切换

    current = next;             // 更新当前进程指针

    // 汇编切换函数（rdi=prev, rsi=next）
    switch_to(prev, next);      // ← 关键：寄存器切换

    // 切换返回后，继续执行新进程
}

// PCB 结构中与切换相关的字段
struct process_control_block {
    uint32_t pid;
    // ...

    // 内核栈指针（在 switch_to 里保存/恢复）
    uint64_t kernel_sp;

    // 通用寄存器快照（switch_to 之外保留完整上下文）
    uint64_t rax, rbx, rcx, rdx;
    uint64_t rsi, rdi, rbp;
    uint64_t r8, r9, r10, r11, r12, r13, r14, r15;
    uint64_t rip;          // 下一条指令地址（恢复时用）
    uint64_t rflags;       // FLAGS 寄存器

    // 页表基址（CR3）
    void *page_table;
};

// 用 setjmp/longjmp 实现两个协程的切换
jmp_buf env1, env2;

void coro1(void) {
    printf("A1n");
    longjmp(env2, 1);  // 切换到 coro2
    printf("A2n");
}

void coro2(void) {
    printf("B1n");
    longjmp(env1, 1);  // 切换到 coro1
    printf("B2n");
}

int main() {
    if (setjmp(env1) == 0) coro1();  // 首次设置，返回 0
    if (setjmp(env2) == 0) coro2();  // 首次设置，返回 0
    // 循环切换...
}