xv6-riscv 内核文件结构以及源码解析
RISC-V 架构的三种模式(保留了一种)
Level
Encode
Name
Abbreviation
0
00
User/Application 用户模式
U
1
01
Supervisor 监管者模式
S
2
10
Reserved 保留
-
3
11
Machine 机器模式
M
xv6 系统启动流程
阅读内核代码最好从启动入口开始,针对启动时的主要调用进行跟踪式的阅读
在kernel/目录下
kernel.ld
控制程序的内存模型
控制 entry.S 的链接位置
控制 _trampoline 在程序中的内存位置
entry.S
为每个hart(硬件线程)分配栈空间
call start -> start.c/start()
start.c/start() 启动时钟中断、 main.c/main()
w_mepc((uint64)main)
asm volatile (mret) -> main.c/main()
main.c/main()
xv6 系统陷阱调用流程 用户态陷入内核态
用户触发陷阱,由 stvec [uservec] 跳入
trampoline.S/uservec
trampoline.S/uservec/jalr [trap.c/usertrap]
trap.c/prepare_return()
trap.c/usertrap()/return satp
trampoline.S/userret
内核态跳入用户态 首次进入
创建新进程
proc.c/forkret()
trap.c/prepare_return()
trampline.S/userret
内核态自身的独立陷阱
内核触发陷阱,由 stvec [kernelvec] 跳入
kernelvec.S/kernelvec/call [trap.c/kerneltrap()]
yeild()
设置 sstatus 和 sepc
kernelvec.S/kernelvec
kernel/
以下代码文件在 xv6-riscv/kernel 目录下
xv6-riscv/kernel 目录下共有 45 个文件.h 文件 17 个.c 文件 23 个.S 文件 4 个.ld 文件 1 个
kernel.ld 链接器脚本
是一个 链接器脚本 描述链接器如何将编译产生的 多个目标文件(.o) 组合成一个可执行文件 各段依次排列 决定内核镜像的内存布局,约束生成的程序
ALIGN(exp) 内置函数,返回当前 位置计数器( . ) ,向上对齐到到 exp 的整数倍后的地址(通常是2的幂次) 保证后续的某个位置也满足对齐要求位置计数器 会自动累加,并不是说 . = 0x80000000 就定义了 当前 . 的值,而是指 . 从 0x80000000 这个初始值累加,记录地址段大小 使用 ALIGN(exp) 就是返回将当前位置的 位置计数器 向上对齐后的值,通过 . = ALIGN(0x100) 将 . 更新为对齐后的计数器位置值
_trampoline 代码独占一内存页,单独对齐,在xv6中,trampline页会同时被内核页表和用户页表以 相同虚拟地址 映射,当 CPU 在这页上执行时,就可以安全地切换页表。如果不独占一页,就可能混入其他内核代码,导致切换时出现安全或正确性问题。ASSERT 强制大小为一整页,防止生成有缺陷的内核
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 OUTPUT_ARCH( "riscv" ) # 设置输出格式与架构 ENTRY( _entry ) # 指定程序入口点 # 定义各地址段 SECTIONS { . = 0x80000000 ; # 指令段 .text : { kernel/entry.o(_entry) *(.text .text.*) . = ALIGN(0x1000 ); _trampoline = .; *(trampsec) . = ALIGN(0x1000 ); ASSERT(. - _trampoline == 0x1000 , "error: trampoline larger than one page" ); PROVIDE(etext = .); } # 只读数据段 .rodata : { . = ALIGN(16 ); *(.srodata .srodata.*) . = ALIGN(16 ); *(.rodata .rodata.*) } # 数据段 .data : { . = ALIGN(16 ); *(.sdata .sdata.*) . = ALIGN(16 ); *(.data .data.*) } # 基址段 .bss : { . = ALIGN(16 ); *(.sbss .sbss.*) . = ALIGN(16 ); *(.bss .bss.*) } # 标记内核镜像在内存中的末尾位置 PROVIDE(end = .); }
defs.h
在 xv6 中,程序的组织被设计为,使用 kernel/defs.h 作为 全局声明汇总头文件 ,集成了几乎所有内核函数的原型声明,便于各个源文件进行调用。
types.h
定义了 xv6 系统源文件中的统一数据类型
param.h
定义了一组宏,描述 xv6 操作系统的各项基础参数
memlayout.h
定义了一组宏操作,定义了 xv6 操作系统在qemu模拟器中运行时的 物理内存布局(Physic Memory Layout)
riscv.h
定义了对 RISC-V 架构处理器的描述以及对底层寄存器的操作函数
r_*() 读取处理器寄存器值
w_*() 值写入处理器寄存器
asm() 用于在C代码中嵌入汇编代码,即 内联汇编 技术。GCC编译器中 __asm()__ 与其等价。volatile 关键字可以避免编译器优化内联的汇编代码 需要注意的是,内联的汇编代码通常与平台绑定,所以几乎无可移植性。
gcc的内联汇编扩展
1 2 3 4 5 6 7 asm [volatile ] ( assembler template : output operands : input operands : clobbers : goto labels );
汇编指令区域中 %0 %1 %... 表示操作数所使用的寄存器
1 2 3 4 5 asm ( "assemble template" : 输出操作数0 , 输出操作数1 , ... : 输入操作数x, 输入操作数y, ... : 破坏列表 );
如
1 2 3 4 5 6 int sum = 0 ;int a = 0 ;int b = 0 ;asm ( "add %0, %1, %2" : "=r" (sum) : "r" (a), "r" (b));
如以下内联riscv架构汇编 rsicv.h
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 static inline uint64r_mstatus () { uint64 x; asm volatile ("csrr %0, mstatus" : "=r" (x)) ; return x; } static inline void w_mstatus (uint64 x) { asm volatile ("csrw mstatus, %0" : : "r" (x)) ; }
proc.h
定义了 xv6 操作系统下,cpu虚拟化相关的结构类型struct context 进程上下文struct cpu cpu 结构struct trapframe 陷阱帧struct proc 进程结构
stat.h
定义了 xv6 操作系统下,文件状态描述结构
1 2 3 4 5 6 7 8 9 10 11 #define T_DIR 1 #define T_FILE 2 #define T_DEVICE 3 struct stat { int dev; uint ino; short type; short nlink; uint64 size; };
主程序 main.c
内核启动文件,是整个内核的入口函数
其内部结构很简单,只包含一对简单的 if-else 条件分支,并进行内核程序的直接初始化以及调度程序 scheduler() 的启用
其设计也很有意思,由于 xv6 是一个多核系统,则势必需要进行不同cpu核心的任务调度分配, 在 if 条件分支中,为了区分不同核心的不同动态,使用 cpuid() 调用,在主核心进行内核程序的初始化, 在 main.c 这一文件中还包含一个 volatile 修饰的静态全局变量 started ,使用 volatile 的作用是为了 **防止编译器优化 else 分支中的 while(started == 0) 这一忙等待循环。防止cpu读取寄存器中的缓存值,导致死循环。
cpuid() 在 kernel/defs.c 中声明,在 kernel/proc.c 中定义,
scheduler() 在 kernel/defs.c 中声明,在 kernel/proc.c 中定义 是 xv6 的核心调度循环,在启动后持续运行,不断在各个进程(或空闲状态)之间切换。每个hart都会进入该调度器。实际上,main.c程序在关机前都不会结束,这个就是整个 xv6 系统的主函数。
还可以看到 __atomic_thread_fence(__ATOMIC_SEQ_CST) 在设置 started 前后,保证在其前的 初始化操作都完成后 再将 started 赋值为1 (hart0 发布屏障);在 忙等待 之后再进行 其它hart 的初始化。
保证了多核之间的内存可见性顺序 ,构成一个 无锁同步 模式
volatile 保障轮询的有效性(从内存中读取,以防止编译器优化,导致的寄存器缓存变量在忙等待中的死循环问题)
__atomic_thread_fence(__ATOMIC_SEQ_CST) 屏障保障数据的发布与订阅顺序(保证程序的逻辑顺序在编译时不受指令重排影响)。
volatile 关键字: 禁止编译器优化对变量的访问 ,表示不保证被修饰变量的值是否会在不知情的情况下被改变,在每次使用受 volatile 修饰的变量时都需要 从内存中 重新读取,而不使用寄存器中的缓存值。 注意: volatile 不能保证原子性 ,也 不保证顺序 ,仅能保证在使用时读取内存中的值
__atomic_thread_fence() 是 gcc 和 clang 提供的一个内置函数,用于生成一条硬件内存屏障指令,是 编译器内建的原子操作原语 , 是编译器内置的 内存屏障 。强制编译器不会将屏障前后的访存指令跨屏障重排,同时会生成一条 CPU 硬件屏障指令,禁止硬件运行时对内存操作进行乱序执行,即保证在编译时指令重排操作不影响程序的逻辑顺序
hart 即 Hardware Thread (Tar T) 是 RSIC-V 指令集架构中的标准术语,表示 一个独立的硬件执行单元,或一个硬件线程 一个 CPU 核心 通常包含一套完整的运算单元 一个 hart 代表该核心上的一条独立指令执行流 大多数简单系统中,一个核心就是一个执行流,此时 一个核心 = 一个hart 若该线程支持超线程,一个物理核心可以同时运行多条指令流,此时 一个核心 = 多个hart
主核心 cpu0
cpuid() == 0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 consoleinit(); printfinit(); kinit(); kvminit(); kvminithart(); procinit(); trapinit(); trapinithart(); plicinit(); plicinithart(); binit(); iinit(); fileinit(); virtio_disk_init(); userinit(); __atomic_thread_fence(__ATOMIC_SEQ_CST); started = 1 ;
riscv 平台级中断控制器 (riscv Platform-Level Interrupt Controller, PLIC)
子cpu 1 2 3 4 5 6 7 8 9 10 while (started == 0 ) ; __atomic_thread_fence(__ATOMIC_SEQ_CST); kvminithart(); trapinithart(); plicinithart();
启动进程调度程序
start.c 主要依赖 riscv.h 中riscv架构处理器寄存器操作函数、宏
设置机器状态,启动分页,调起时钟中断初始化,返回到 main()
使用 w_mepc((uint64)main); 将 main() 函数的地址写入 mepc 寄存器,标识异常处理程序的起始地址
mepc :是“机器异常程序计数器”(Machine Exception Program Counter)。 当 CPU 发生异常或中断而被迫跳转到 M-mode 的陷阱处理程序时,硬件会自动把被打断的指令地址(或下一条指令的地址)保存到 mepc 中。等内核处理完异常,执行 mret 指令时,CPU 就把 mepc 的值加载到普通 PC,从而实现精确返回。
mret : 机器模式返回寄存器 (Machine Return),从机器模式的陷阱处理中返回
使用 asm volatile("mret"); 利用RISC-V的陷阱返回机制, mret 指令查看 mstatus 的 MPP (M Previous Privilege mode)字段,该字段已经通过以下方式设置
1 2 3 4 5 unsigned long x = r_mstatus(); x &= ~MSTATUS_MPP_MASK; x |= MSTATUS_MPP_S; w_mstatus(x);
mret 检查 mepc 寄存器中的地址(即 main() 的地址)进行返回,跳转到 main.c/main() 函数
1 2 3 4 5 6 7 8 9 10 11 12 13 void timerinit () { w_menvcfg(r_menvcfg() | (1L << 63 )); w_mcounteren(r_mcounteren() | 2 ); w_stimecmp(r_time() + 1000000 ); }
trap.c
陷阱相关操作定义
1 2 3 4 5 6 extern uint ticks;void trapinit (void ) ;void trapinithart (void ) ;extern struct spinlock tickslock ;void prepare_return (void ) ;
1 2 3 4 5 struct spinlock tickslock ;uint ticks; extern char trampoline[], uservec[]; void kernelvec () ; extern int devintr () ;
usertrap()
用户陷阱
在 trampoline.S/uservec 切换页表后调用,负责 分类处理所有来自用户态的陷阱 ,并最终返回用户态只能被用户态触发
trampoline.S
uservec 陷阱向量调用
ld t0, 16(a0) … jalr t0 调用 p->trapframe->kernel_trap
处理来自于用户态的中断、异常或系统调用 从 trampoline.S 调用,并返回到 trampoline.S 返回值是用户寄存器(保存指向用户页表物理地址的指针) satp 供 trampoline.S 切换使用
satp 即 Supervisor Address Translation and Projection (监管者地址翻译与投影) 寄存器
[核心] 使用 w_stvec((uint64)kernelvec) 更新 stvec 寄存器中的中断处理入口
在我们身处内核态时,用于向 kerneltrap() 发送中断与异常,由 kernelvec 调起
在陷阱帧中保存用户的程序计数器
p->trapframe->epc = r_sepc(); 交由后续操作决定是否让出cpu
[核心] 检查 scause (陷阱原因寄存器) 寄存器的值,根据 scause 分发处理
系统调用
设备中断
缺页异常
scause == 15 加载页错误
scause == 13 存储页错误
惰性分配
vmfault() 尝试处理惰性分配的页
按需分配内存,避免提前分配,浪费内存
预期外的陷阱
进程退出检查
设备定时器中断时让出cpu
if (witch_dev == 2) yield();
触发定时中断,实现进程调度
准备返回用户态
返回用户页表地址给 trampoline.S
用户页可交换
uint64 satp = MAKE_SATP(p->pagetable); return satp;
注意,此时已经返回到 trampoline 中,直接按序向下执行 trampoline.S/userret 程序
使用汇编进行底层的上下文切换,C做高层的逻辑判断
kerneltrap()
内核陷阱
在 trampoline.S/kernelvec 切换页表后调用,负责 分类处理所有来自内核态的陷阱 ,并最终返回内核态只能被内核态触发
在保存调用者保存的寄存器后,调起 kerneltrap()kerneltrap() 返回内核中被中断的位置
获取对应寄存器的值
根据陷阱原因寄存器 scause 的值分发陷阱处理过程
模式检测
(sstatus & SSTATUS_SPP) == 0
检查是否通过监管者模式调起
[核心] 检测重复中断
intr_get() != 0
防止内核陷阱处理过程本身被嵌套中断打断,内核陷阱必须在元自行的上下文中处理,避免竟态条件
设备中断
时钟中断
which_dev == 2 && myproc() != 0
直接返回 kernelvec
prepare_return(void)
set up trapframe and control registers for a return to user space 设置陷阱帧并控制寄存器返回到用户态
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 void prepare_return (void ) { struct proc *p = myproc(); intr_off(); uint64 trampoline_uservec = TRAMPOLINE + (uservec - trampoline); w_stvec(trampoline_uservec); 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(); unsigned long x = r_sstatus(); x &= ~SSTATUS_SPP; x |= SSTATUS_SPIE; w_sstatus(x); w_sepc(p->trapframe->epc); }
proc.c
定义了与进程相关的操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 struct cpu cpus [NCPU ];struct proc proc [NPROC ];struct proc *initproc ;int nextpid = 1 ;struct spinlock pid_lock ;extern void forkret (void ) ;static void freeproc (struct proc *p) ;extern char trampoline[]; struct spinlock wait_lock ;
wfi 指令 Wait For Interrupt 等待中断指令
可以使用 myproc() 获取指向当前执行的进程结构的指针
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 struct cpu *mycpu (void ) { int id = cpuid(); struct cpu *c = &cpus[id]; return c; } struct proc *myproc (void ) { push_off(); struct cpu *c = mycpu(); struct proc *p = c->proc; pop_off(); return p; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 void scheduler (void ) { struct proc *p ; struct cpu *c = mycpu(); c->proc = 0 ; for (;;) { intr_on(); intr_off(); int found = 0 ; for (p = proc; p < &proc[NPROC]; p++) { acquire(&p->lock); if (p->state == RUNNABLE) { p->state = RUNNING; c->proc = p; swtch(&c->context, &p->context); c->proc = 0 ; found = 1 ; } release(&p->lock); } if (found == 0 ) { asm volatile ("wfi" ) ; } } } void sched (void ) { int intena; struct proc *p = myproc(); if (!holding(&p->lock)) panic("sched p->lock" ); if (mycpu()->noff != 1 ) panic("sched locks" ); if (p->state == RUNNING) panic("sched RUNNING" ); if (intr_get()) panic("sched interruptible" ); intena = mycpu()->intena; swtch(&p->context, &mycpu()->context); mycpu()->intena = intena; } void sleep (void *chan, struct spinlock *lk) { struct proc *p = myproc(); acquire(&p->lock); release(lk); p->chan = chan; p->state = SLEEPING; sched(); p->chan = 0 ; release(&p->lock); acquire(lk); }
uart.c
UART 是 Universal Asynchronous Receiver/Transmitter 通用异步收发传输器
uart.c 通过 内存映射 I/O (MMIO) 访问 UART 外设 是为 16550a UART 编写的底层驱动,提供对 UART 设备的控制
UART 的控制寄存器被映射到 UART0 为开头的地址区域。 // the UART control registers are memory-mapped at address UART0.
1 2 3 4 5 #define Reg(reg) ((volatile unsigned char *)(UART0 + (reg))) #define ReadReg(reg) (*(Reg(reg))) #define WriteReg(reg, v) (*(Reg(reg)) = (v))
UART 控制寄存器参考
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #define RHR 0 #define THR 0 #define IER 1 #define IER_RX_ENABLE (1 << 0) #define IER_TX_ENABLE (1 << 1) #define FCR 2 #define FCR_FIFO_ENABLE (1 << 0) #define FCR_FIFO_CLEAR (3 << 1) #define ISR 2 #define LCR 3 #define LCR_EIGHT_BITS (3 << 0) #define LCR_BAUD_LATCH (1 << 7) #define LSR 5 #define LSR_RX_READY (1 << 0) #define LSR_TX_IDLE (1 << 5)
1 2 3 4 5 6 7 static struct spinlock tx_lock ;static int tx_busy; static int tx_chan; extern volatile int panicking; extern volatile int panicked;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 void uartwrite (char buf[], int n) { acquire(&tx_lock); int i = 0 ; while (i < n) { while (tx_busy != 0 ) { sleep(&tx_chan, &tx_lock); } WriteReg(THR, buf[i]); i += 1 ; tx_busy = 1 ; } release(&tx_lock); } void uartputc_sync (int c) { if (panicking == 0 ) push_off(); if (panicked) { for (;;) ; } while ((ReadReg(LSR) & LSR_TX_IDLE) == 0 ) ; WriteReg(THR, c); if (panicking == 0 ) pop_off(); } static int uartgetc (void ) { if (ReadReg(LSR) & LSR_RX_READY) { return ReadReg(RHR); } else { return -1 ; } } void uartintr (void ) { ReadReg(ISR); acquire(&tx_lock); if (ReadReg(LSR) & LSR_TX_IDLE) { tx_busy = 0 ; wakeup(&tx_chan); } release(&tx_lock); while (1 ) { int c = uartgetc(); if (c == -1 ) break ; consoleintr(c); } }
4份底层汇编文件 entry.S
xv6 系统真正的汇编入口,在每个CPU上都需要一个栈(在 start.c 中使用 __attribute__((aligned(16))) char stack0[4096 * NCPU]; 进行设置,定义了 stack0 )_entry 为每个hart独立运行
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 # qemu -kernel 将内核加载到地址 0x80000000 位置 # 并且将所有hart(物理线程 在此处可以理解为cpu)跳转到该地址位置 # kernel.ld 将接下来的代码放入地址 0x80000000 处 .section .text .global _entry _entry: # 设置一个供C代码使用的栈 # stack0 已在 start.c 中定义 # 为每个cpu分配 4096 字节的栈空间 # 栈指针 sp = stack0 + ((hartid + 1 ) * 4096 ) 按hart编号为每个hart分配栈空间 # sp = stack0 + ((hartid + 1) * 4096) 为以下指令的功能,通过hardid区分各个hart所拥有的栈空间 la sp, stack0 # 将stack0的地址传入栈指针sp li a0, 1024 *4 # 将立即数 1024 *4 (表示4 KB) 传入寄存器a0 csrr a1, mhartid # 控制与状态寄存器读取mhartid hart栈的索引 addi a1, a1, 1 # a1寄存器值增加1 mul a0, a0, a1 # 计算栈偏移 4b yte * (mhardid + 1 ) 栈指针要指向栈顶(栈向低地址增长) add sp, sp, a0 # 更新栈指针 call start # 跳转到 start.c/start() spin: # 自旋 作为保护,防止错误配置的mret或意外的_entry跳转,防止程序计数器混乱 j spin # 跳转到spin段
swtch.S
上下文交换程序 接口为: void swtch(struct context *old, struct context *new); 保存当前的寄存器旧值,加载新的寄存器值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 .globl swtch swtch: sd ra, 0 (a0) sd sp, 8 (a0) sd s0, 16 (a0) sd s1, 24 (a0) sd s2, 32 (a0) sd s3, 40 (a0) sd s4, 48 (a0) sd s5, 56 (a0) sd s6, 64 (a0) sd s7, 72 (a0) sd s8, 80 (a0) sd s9, 88 (a0) sd s10, 96 (a0) sd s11, 104 (a0) ld ra, 0 (a1) ld sp, 8 (a1) ld s0, 16 (a1) ld s1, 24 (a1) ld s2, 32 (a1) ld s3, 40 (a1) ld s4, 48 (a1) ld s5, 56 (a1) ld s6, 64 (a1) ld s7, 72 (a1) ld s8, 80 (a1) ld s9, 88 (a1) ld s10, 96 (a1) ld s11, 104 (a1) ret
trampoline.S
依赖 risv.h 依赖 memlayout.h 依赖 trap.c
trap.c
usertrap(void)
prepare_return(void)
proc.h
提供 struct trapframe 类型 p->trapframe变量
提供 struct proc 类型 p变量
memlayout.h
#define TRAMPOLINE (MAXVA - PGSIZE)
#define TRAPFRAME (TRAMPOLINE - PGSIZE)
跳板汇编程序 用于处理 从用户空间到内核的陷阱的、从内核返回用户的 低级代码
内核将持有这段代码的页, 映射到用户和内核空间中的同一虚拟地址 (TRAMPOLINE), 使得它在切换页表时能够继续工作。kernel.ld 使此代码起始于一个页边界,并独立拥有该页
1 2 3 4 5 6 7 8 9 10 11 12 13 #include "riscv.h" #include "memlayout.h" .section trampsec # trampsec trampsec 段 .globl trampoline # 暴露 trampoline .globl usertrap # 暴露 usertrap trampoline: # trampoline 段 .align 4 .globl uservec # 暴露 uservec uservec: # uservec 段 # ... .globl userret # 暴露 userret userret: # userret 段
uservec 用户陷入内核态
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 uservec: # trap.c 设置 stvec 寄存器指向 uservec # 所以 traps 用户态的陷阱会从这开始 # 在监管者模式下,但是仍在使用用户页表 # 保存用户的 a0 寄存器到 sscratch 寄存器 # a0 寄存器可以在 TRAPFRAME 中获取并被使用 csrw sscratch, a0 # 每个进程都有一个独立的 p->trapframe 内存区域 # 但是所有进程的用户页表中,这片区域都被映射到相同的虚拟地址 (TRAPFRAME) # 所以可以直接使用立即数加载到 a0 寄存器中 li a0, TRAPFRAME # 保存用户寄存器到 TRAPFRAME 陷阱帧 sd ra, 40 (a0) sd sp, 48 (a0) sd gp, 56 (a0) sd tp, 64 (a0) ... # 保存 30 个寄存器的值 # 将用户寄存器 a0 保存至 p->trapframe->a0 中 csrr t0, sscratch sd t0, 112 (a0) # 初始化内核栈指针 p->trapframe->kernel_sp ld sp, 8 (a0) # make tp hold the current hartid, from p->trapframe->kernel_hartid # 使用线程栈寄存器 tp 保存当前的 hartid p->trapframe->kernel_hartid ld tp, 32 (a0) # 加载usertrap()的地址 p->trapframe->kernel_trap ld t0, 16 (a0) # 取内核页表地址 p->trapframe->kernel_satp ld t1, 0 (a0) # 等待之前所有的内存操作完成 # 确保这些操作都使用用户页表 sfence.vma zero, zero # 安装内核页表 csrw satp, t1 # 刷新 TLB(转换检测缓冲区) 中现已过时的用户页表 sfence.vma zero, zero # 调起 usertrap() jalr t0
userret 返回用户态
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 userret: # usertrap() 返回到此处 此时 a0 = 用户页表物理地址 即将写入 satp # 从内核态返回用户态 # 交换(切换)到用户页表 sfence.vma zero, zero csrw satp, a0 sfence.vma zero, zero li a0, TRAPFRAME # a0 指向 TRAPFRAME 基址 # 从 TRAPFRAME 中恢复所有除 a0 之外的寄存器 ld ra, 40 (a0) ld sp, 48 (a0) ld gp, 56 (a0) ld tp, 64 (a0) ... # 恢复用户寄存器 a0 ld a0, 112 (a0) # 返回用户态,恢复用户的程序计数器 # prepare_return() 设置 sstatus 以及 sepc 寄存器 sret # supervisor ret 监管者模式返回
TRAPFRAME 在 任何进程的用户页表 中都指向进程自己的 trapframe 页面,而内核在创建进程时负责建立该映射。trampoline 的代码只有一份,但被映射到所有进程的同一虚拟地址
kernelvec.S
内核态,不通过 call 调用,而是硬件在 产生陷阱时自动跳转 而来
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 # 在监管者模式下发生的中断和异常会来到这里 # 当前栈是内核栈 # 保存寄存器,调用 kerneltrap() # 当 kerneltrap() 返回后,恢复寄存器并返回 .globl kerneltrap .globl kernelvec .align 4 kernelvec: # 扩展栈空间保存寄存器 addi sp, sp, -256 # 保存调用者保存寄存器 sd ra, 0 (sp) # sd sp, 8(sp) sd gp, 16 (sp) # sd tp, 24(sp) sd t0, 32 (sp) sd t1, 40 (sp) sd t2, 48 (sp) sd a0, 72 (sp) sd a1, 80 (sp) sd a2, 88 (sp) sd a3, 96 (sp) sd a4, 104 (sp) sd a5, 112 (sp) sd a6, 120 (sp) sd a7, 128 (sp) sd t3, 216 (sp) sd t4, 224 (sp) sd t5, 232 (sp) sd t6, 240 (sp) # 调用trap.c代码中的C陷阱处理程序 call kerneltrap # 恢复寄存器 ld ra, 0 (sp) # ld sp, 8(sp) ld gp, 16 (sp) # not tp (contains hartid), in case we moved CPUs ld t0, 32 (sp) ld t1, 40 (sp) ld t2, 48 (sp) ld a0, 72 (sp) ld a1, 80 (sp) ld a2, 88 (sp) ld a3, 96 (sp) ld a4, 104 (sp) ld a5, 112 (sp) ld a6, 120 (sp) ld a7, 128 (sp) ld t3, 216 (sp) ld t4, 224 (sp) ld t5, 232 (sp) ld t6, 240 (sp) addi sp, sp, 256 # 返回内核中被中断的位置 sret
关于陷阱向量 uservec kernelvec ,都是由硬件进行调用,地址由 stvec 状态向量寄存器保存 在用户态时, stvec 为 uservec 地址 在内核态时, stvec 为 kernelvec 地址 通过 riscv.h/w_stvec() 在状态切换到边缘动态更新该寄存器,保证CPU在各模式下,陷阱都能进入正确的处理入口
从 xv6 的设计角度上,对于 内核态-用户态 模型, stvec 寄存器仅会保留 uservec kernelvec 这两种状态陷阱处理入口 当然,这两种陷阱入口的名字可由个人喜好进行设定,只要保证对相应状态的处理功能完备, 理论上也可以保存任意合法的陷阱入口地址 为什么仅有两种状态?因为上下文仅有 内核态、用户态 保证了设计的简洁性
user/
以下代码文件在 xv6-riscv/user/ 目录下