中断陷阱

uservec:    
        #
        # trap.c sets stvec to point here, so
        # traps from user space start here,
        # in supervisor mode, but with a
        # user page table.

        # trap.c 会将 stvec 寄存器设置为该地址
        # 使得用户态陷入（如系统调用或异常）时，CPU 能跳转到这里执行陷入处理流程

        # save user a0 in sscratch so
        # a0 can be used to get at TRAPFRAME.

        # csrw 是 “Control and Status Register Write” 的缩写，用于将一个通用寄存器的值写入指定的 CSR
        # sscratch 是 supervisor 模式下的临时寄存器
        # 常用于陷入（trap）处理过程中保存和传递关键数据，比如内核栈指针或进程控制块指针
        # a0 是一个通用寄存器，通常在陷入切换或上下文切换时，
        # 内核会把需要后续 trap handler 使用的数据（如内核栈地址）写入 sscratch，方便 trap handler 直接读取
        csrw sscratch, a0 # 将用户态的 a0 寄存器值保存到 sscratch 寄存器中
                          # 以便后续代码可以使用 a0 寄存器来访问 TRAPFRAME

        # each process has a separate p->trapframe memory area,
        # but it's mapped to the same virtual address
        # (TRAPFRAME) in every process's user page table.

        # 每个进程都有独立的 p->trapframe 内存区域（用于保存该进程的用户态寄存器等陷入上下文）
        # 但在每个进程的用户页表中，这块物理内存都被映射到相同的虚拟地址 TRAPFRAME
        li a0, TRAPFRAME # 将 TRAPFRAME 的地址加载到 a0 寄存器中
                          # 以便后续代码可以通过 a0 访问当前进程的陷入上下文

# save the user registers in TRAPFRAME
# 把进程相关的用户态寄存器保存到 TRAPFRAME 中 
sd ra, 40(a0)
sd sp, 48(a0)
sd gp, 56(a0)
sd tp, 64(a0)
sd t0, 72(a0)
sd t1, 80(a0)
sd t2, 88(a0)
sd s0, 96(a0)
sd s1, 104(a0)
sd a1, 120(a0)
sd a2, 128(a0)
sd a3, 136(a0)
sd a4, 144(a0)
sd a5, 152(a0)
sd a6, 160(a0)
sd a7, 168(a0)
sd s2, 176(a0)
sd s3, 184(a0)
sd s4, 192(a0)
sd s5, 200(a0)
sd s6, 208(a0)
sd s7, 216(a0)
sd s8, 224(a0)
sd s9, 232(a0)
sd s10, 240(a0)
sd s11, 248(a0)
sd t3, 256(a0)
sd t4, 264(a0)
sd t5, 272(a0)
sd t6, 280(a0)

# save the user a0 in p->trapframe->a0

# 即把用户态 a0 的值保存到 p->trapframe->a0
# 在 xv6 的 trap 处理流程中，sscratch 通常保存了用户态 a0 的值
csrr t0, sscratch # 从 sscratch 寄存器中读取用户态的 a0 值到 t0 寄存器
sd t0, 112(a0) # 将用户态的 a0 值保存到 TRAPFRAME 中的 a0 字段

# initialize kernel stack pointer, from p->trapframe->kernel_sp
  # 从当前进程的 trapframe 结构体中的 kernel_sp 字段加载内核栈指针
  # 偏移 8 字节正好是 kernel_sp 字段的位置
  ld sp, 8(a0) # 从以 a0 为基址、偏移 8 字节的位置读取 64 位数据，并将其加载到 sp（栈指针寄存器）中

# make tp hold the current hartid, from p->trapframe->kernel_hartid
# 偏移 32 字节正好是 kernel_hartid 字段的位置
ld tp, 32(a0) # 从以 a0 为基址、偏移 32 字节的位置读取 64 位数据，并将其加载到 tp（线程指针寄存器）中

# load the address of usertrap(), from p->trapframe->kernel_trap
# 偏移 16 字节正好是 kernel_trap 字段的位置
ld t0, 16(a0) # 从以 a0 为基址、偏移 16 字节的位置读取 64 位数据，并将其加载到 t0 寄存器中
                  # t0 现在保存了 usertrap() 函数的地址，后续会跳转到该地址执行

# fetch the kernel page table address, from p->trapframe->kernel_satp.
# 偏移 24 字节正好是 kernel_satp 字段的位置
ld t1, 0(a0) # 从以 a0 为基址、偏移 0 字节的位置读取 64 位数据，并将其加载到 t1 寄存器中
# t1 现在保存了内核页表的 satp 值，后续会用它来切换到内核页表

# wait for any previous memory operations to complete, so that
# they use the user page table.

# 确保之前的内存操作（如保存寄存器到 TRAPFRAME）都完成
# 以防止内存操作使用错误的页表
sfence.vma zero, zero # sfence.vma 是 RISC-V 指令，用于刷新虚拟内存的地址转换缓存（TLB）

# install the kernel page table.
csrw satp, t1 # 将内核页表的 satp 值写入 satp 寄存器，切换到内核页表

# flush now-stale user entries from the TLB.
sfence.vma zero, zero # 再次刷新 TLB，确保切换页表后不会使用过时的用户页表条目

# jump to usertrap(), which does not return
# usertrap() 处理完陷入后不会返回到这里
jr t0 # 跳转到 usertrap() 函数地址，开始执行陷入处理流程

// send interrupts and exceptions to kerneltrap(),
// since we're now in the kernel.
// 由于当前已经处于内核态，接下来所有的中断和异常都应该交由 kerneltrap() 处理 

// 设置陷入向量寄存器（stvec）
w_stvec((uint64)kernelvec); // 后续的中断和异常都跳转到 kerneltrap() 进行处理

struct proc *p = myproc(); // 获取当前运行的（用户态）进程结构体指针

// save user program counter.
p->trapframe->epc = r_sepc(); // 保存用户程序计数器（sepc）到进程的 trapframe 中

if(r_scause() == 8){ // 系统调用
                // system call

                if(killed(p)) // 进程已经停止，直接退出
                                exit(-1); 

                // sepc points to the ecall instruction,
                // but we want to return to the next instruction.
                // sepc（Supervisor Exception Program Counter）寄存器此时指向触发系统调用的 ecall 指令本身
                // 为了让用户程序在系统调用返回后能继续执行下一条指令
                // 需要将 sepc 增加 4（RISC-V 指令长度为 4 字节）
                p->trapframe->epc += 4;

                // an interrupt will change sepc, scause, and sstatus,
                // so enable only now that we're done with those registers.

                // 中断发生时会改变 sepc、scause 和 sstatus 这几个关键寄存器的值
                // 只有在这些寄存器相关的操作全部完成后，才调用 intr_on() 重新开启中断
                // 避免在处理中断或异常信息时被新的中断打断，导致数据不一致或处理流程混乱。
                intr_on(); // 重新开启中断，允许处理其他中断

                syscall(); // 调用系统调用处理函数，根据系统调用号执行相应的内核功能
} else if((which_dev = devintr()) != 0){ 
                // ok
} else { // 其他异常 或无法识别的中断 打印出错信息，并停止进程
                printf("usertrap(): unexpected scause 0x%lx pid=%d\n", r_scause(), p->pid);
                printf("            sepc=0x%lx stval=0x%lx\n", r_sepc(), r_stval());
                setkilled(p); // 标记进程为已终止状态
}

usertrapret(); // 返回用户态

struct proc *p = myproc(); // 获取当前（用户态）进程结构体指针

// we're about to switch the destination of traps from
// kerneltrap() to usertrap(), so turn off interrupts until
// we're back in user space, where usertrap() is correct. 

// 当前即将把陷入处理的入口从 kerneltrap() 切换为 usertrap()
// 在内核态时，陷入应该由 kerneltrap() 处理
// 而回到用户空间后，陷入才应该由 usertrap() 处理 
// 只有等回到用户空间后，才重新允许中断，此时陷入目标已经正确设置为 usertrap()
intr_off(); // 关闭中断，防止在内核态时被新的中断打断

// send syscalls, interrupts, and exceptions to uservec in trampoline.S

// 这段代码的作用是设置陷入向量寄存器（stvec）
// 让后续的用户态的系统调用、中断和异常都跳转到 trampoline.S 文件中的 uservec 入口进行处理

// TRAMPOLINE 是 trampoline 代码段在虚拟地址空间中的基地址
// uservec 和 trampoline 都是外部符号，分别表示 trampoline 代码段中 uservec 和 trampoline 标签的地址
// uservec - trampoline 计算出 uservec 相对于 trampoline 段起始的偏移
uint64 trampoline_uservec = TRAMPOLINE + (uservec - trampoline); // uservec 在虚拟地址空间中的实际入口地址
w_stvec(trampoline_uservec); // 设置陷入向量寄存器 stvec，指向 uservec 入口

// set up trapframe values that uservec will need when
// the process next traps into the kernel.
// 当前进程的 trapframe（陷入帧）结构体设置一组关键字段
// 这些字段会在下次进程从用户态陷入内核态时，被 uservec 使用
p->trapframe->kernel_satp = r_satp();         // kernel page table 内核页表
p->trapframe->kernel_sp = p->kstack + PGSIZE; // process's kernel stack 内核栈顶
p->trapframe->kernel_trap = (uint64)usertrap;  // usertrap() 函数地址
p->trapframe->kernel_hartid = r_tp();         // hartid for cpuid() 内核线程指针（tp）

// set S Previous Privilege mode to User.
unsigned long x = r_sstatus(); // 读取当前的 sstatus 寄存器值
// 清除 SPP 位，设置为 0，表示返回用户态
// SPP 位表示陷入发生时 CPU 的前一个特权级
x &= ~SSTATUS_SPP; // clear SPP to 0 for user mode 
// 用户态允许中断
x |= SSTATUS_SPIE; // enable interrupts in user mode
w_sstatus(x); // 将修改后的值写回 sstatus 寄存器

// set S Exception Program Counter to the saved user pc.
// sepc 寄存器保存了用户程序计数器（pc），即用户程序发生陷入时的指令地址
// 该地址会在从内核态返回用户态时，执行sret命令后重新加载到 pc 中
w_sepc(p->trapframe->epc); // 将保存的用户进程的 pc 写回 sepc 寄存器

// tell trampoline.S the user page table to switch to.
uint64 satp = MAKE_SATP(p->pagetable); // 计算用户进程对应的内存页表的 satp 值

// jump to userret in trampoline.S at the top of memory, which 
 // switches to the user page table, restores user registers,
 // and switches to user mode with sret.
 // 将跳转到 trampoline.S 汇编文件中的 userret 入口
 // 该入口负责切换到用户页表、恢复用户寄存器，并通过 sret 指令切换回用户模式
 uint64 trampoline_userret = TRAMPOLINE + (userret - trampoline); // 计算 userret 在虚拟地址空间中的实际入口地址

// 将该地址强制转换为一个接受 uint64 参数的函数指针，并调用它，同时传入 satp（用户页表的寄存器值）
// 这样 trampoline 代码就能切换到用户页表，并完成用户态的恢复和跳转
// (void (*)(uint64) 表示一个函数指针，指向一个接受 uint64 参数且无返回值的函数
((void (*)(uint64))trampoline_userret)(satp); 

userret: 
        # userret(pagetable) 
        # called by usertrapret() in trap.c to
        # switch from kernel to user.
        # a0: user page table, for satp.

        # 由 trap.c 文件中的 usertrapret() 调用，用于完成从内核返回用户空间的最后步骤
        # 切换过程中，a0 寄存器传递用户页表的物理地址
        # 这个地址会被写入 satp 寄存器，从而激活用户进程的虚拟内存映射

        # 切换到用户级的页表
        # switch to the user page table.
        sfence.vma zero, zero # 确保之前的内存操作都完成，防止使用错误的页表 
        csrw satp, a0 # 将用户页表的物理地址写入 satp 寄存器，切换到用户页表
        sfence.vma zero, zero # 刷新 TLB，确保不会使用过时的内存映射条目

li a0, TRAPFRAME # 将 TRAPFRAME 的地址加载到 a0 寄存器中
# 以便后续代码可以通过 a0 访问当前进程的陷入上下文

  # restore all but a0 from TRAPFRAME 
  # 从 TRAPFRAME 中恢复除 a0 之外的所有用户态寄存器
  ld ra, 40(a0)
  ld sp, 48(a0)
  ld gp, 56(a0)
  ld tp, 64(a0)
  ld t0, 72(a0)
  ld t1, 80(a0)
  ld t2, 88(a0)
  ld s0, 96(a0)
  ld s1, 104(a0)
  ld a1, 120(a0)
  ld a2, 128(a0)
  ld a3, 136(a0)
  ld a4, 144(a0)
  ld a5, 152(a0)
  ld a6, 160(a0)
  ld a7, 168(a0)
  ld s2, 176(a0)
  ld s3, 184(a0)
  ld s4, 192(a0)
  ld s5, 200(a0)
  ld s6, 208(a0)
  ld s7, 216(a0)
  ld s8, 224(a0)
  ld s9, 232(a0)
  ld s10, 240(a0)
  ld s11, 248(a0)
  ld t3, 256(a0)
  ld t4, 264(a0)
  ld t5, 272(a0)
  ld t6, 280(a0)

# restore user a0
  ld a0, 112(a0) # 最后才恢复 a0, 因为前面一直在用它

# return to user mode and user pc.
# usertrapret() set up sstatus and sepc.

# usertrapret() 已经设置好了 sstatus（特权级和中断状态）和 sepc（异常返回地址）
# sret 指令是 RISC-V 架构下的“Supervisor Return”
# 它会将 sepc 的值加载到程序计数器（pc），并根据 sstatus 恢复特权级和中断状态
# 从而让 CPU 跳转回用户态并继续执行被中断的用户程序
sret # 使用 sret 指令从内核态返回用户态，恢复用户程序的执行

void
syscall(void)
{
                int num;
                struct proc *p = myproc();

                num = p->trapframe->a7; // 获取系统调用号
                // 检查系统调用号是否有效
                // 1. num > 0 
                // 2. num < NELEM(syscalls) 系统调用号在 syscalls 数组内
                // 3. syscalls[num] 对应的系统调用函数指针有效
                if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
                                // Use num to lookup the system call function for num, call it,
                                // and store its return value in p->trapframe->a0
                                // 根据系统调用号调用对应的函数指针，并把返回值放入  p->trapframe->a0
                                p->trapframe->a0 = syscalls[num]();
                } else { // 系统调用号无效
                                printf("%d %s: unknown sys call %d\n",
                                           p->pid, p->name, num);
                                p->trapframe->a0 = -1; // 把 -1 作为返回值
                }
}