陷入

struct trapframe {
  uint64 kernel_satp;   // 内核页表
  uint64 kernel_sp;     // 进程内核栈顶
  uint64 kernel_trap;   // usertrap()
  uint64 epc;           // 保存的用户程序计数器
  uint64 kernel_hartid; // 保存的内核 tp
 
  uint64 ra;
  // ... 中间寄存器省略 ...
  uint64 t6;
};

uservec:
    csrw sscratch, a0        # 暂存用户 a0，腾出一个可用寄存器
    li a0, TRAPFRAME         # a0 = 本进程 trapframe 虚拟地址
    sd ra, 40(a0)            # 保存 31 个通用寄存器
    ...
    sd t6, 280(a0)
    csrr t0, sscratch        # 取回用户 a0
    sd t0, 112(a0)           # 存入 trapframe->a0
 
    ld sp, 8(a0)             # kernel_sp → sp，切换到本进程内核栈
    ld tp, 32(a0)            # kernel_hartid → tp
    ld t0, 16(a0)            # kernel_trap（usertrap 地址）
    ld t1, 0(a0)             # kernel_satp（内核页表）
 
    sfence.vma zero, zero    # 确保上面的 store 已完成
    csrw satp, t1            # 切换到内核页表
    sfence.vma zero, zero    # 清掉 TLB 中残留的用户页表项
 
    jalr t0                  # 调用 usertrap；ra = 下一条指令（userret）

  int which_dev = 0;
 
  if ((r_sstatus() & SSTATUS_SPP) != 0)
    panic("usertrap: not from user mode");
 

  // 将中断和异常发送给 kerneltrap()，
  // 因为我们现在已在内核中。
  w_stvec((uint64)kernelvec); //DOC: kernelvec

  struct proc *p = myproc();
 
  // 保存用户程序计数器。
  p->trapframe->epc = r_sepc();

  if (r_scause() == 8) {
    // 系统调用
 
    if (killed(p))
      kexit(-1);
 
    // sepc 指向 ecall 指令，
    // 但我们希望返回到下一条指令。
    p->trapframe->epc += 4;
 
    // 中断会改变 sepc、scause 和 sstatus，
    // 所以只有在我们处理完这些寄存器后才启用中断。
    intr_on();
 
    syscall();
  } else if ((which_dev = devintr()) != 0) {
    // 正常
  } else if ((r_scause() == 15 || r_scause() == 13) &&
             vmfault(p->pagetable, p->sz, r_stval(),
                     (r_scause() == 13) ? 1 : 0) != 0) {
    // 惰性分配页面的缺页异常
  } else {
    printk("usertrap(): unexpected scause 0x%lx pid=%d\n", r_scause(), p->pid);
    printk("            sepc=0x%lx stval=0x%lx\n", r_sepc(), r_stval());
    setkilled(p);
  }
 

  if (killed(p))
    kexit(-1);
 
  // 如果这是定时器中断，就让出 CPU。
  if (which_dev == 2)
    yield();
 
  prepare_return();
 
  // 要切换到的用户页表，供 trampoline.S 使用
  uint64 satp = MAKE_SATP(p->pagetable);
 
  // 返回到 trampoline.S；satp 值放在 a0 中。
  return satp;

void
prepare_return(void)
{
  struct proc *p = myproc();
 
  // 我们即将把陷阱的目标从 kerneltrap() 切换到
  // usertrap()。因为从内核代码陷入到 usertrap 会是一场灾难，
  // 所以关闭中断。
  intr_off();
 
  // 将系统调用、中断和异常发送到 trampoline.S 中的 uservec
  uint64 trampoline_uservec = TRAMPOLINE + (uservec - trampoline);
  w_stvec(trampoline_uservec);
 
  // 设置 uservec 在进程下次陷入内核时所需的 trapframe 值。
  p->trapframe->kernel_satp = r_satp();         // 内核页表
  p->trapframe->kernel_sp = p->kstack + PGSIZE; // 进程的内核栈
  p->trapframe->kernel_trap = (uint64)usertrap;
  p->trapframe->kernel_hartid = r_tp(); // 用于 cpuid() 的 hartid
 
  // 设置 trampoline.S 的 sret 将用来进入用户空间的寄存器。
 
  unsigned long x = r_sstatus();
  x &= ~SSTATUS_SPP; // 清除 SPP 为 0，表示用户模式
  x |= SSTATUS_SPIE; // 在用户模式下启用中断
  w_sstatus(x);
 
  // 将 S Exception Program Counter 设置为保存的用户 pc。
  w_sepc(p->trapframe->epc);
}

.globl userret
userret:
        # usertrap() 返回这里，a0 = 用户进程的 satp。
        # 刷新指令缓存，防止本核此前执行过同一虚拟地址上的旧代码
        fence.i
 
        # 切回用户页表。与 uservec 同理，
        # 代码仍位于两张页表同址映射的 trampoline 页上
        sfence.vma zero, zero
        csrw satp, a0
        sfence.vma zero, zero
 
        # 用用户页表访问本进程的 trapframe
        li a0, TRAPFRAME
 
        # 恢复除 a0 之外的 30 个寄存器
        ld ra, 40(a0)
        # ... 中间寄存器省略 ...
        ld t6, 280(a0)
 
        # 最后恢复用户 a0：系统调用的返回值就在这里
        ld a0, 112(a0)
 
        # 返回用户态：PC←sepc，特权级←SPP，SIE←SPIE，SPIE←1
        # sepc 与 sstatus 已由 prepare_return() 设置
        sret