xv6-riscv 内核文件结构以及源码解析

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 在程序中的内存位置
  1. entry.S

    • 为每个hart(硬件线程)分配栈空间
    • call start -> start.c/start()
  2. start.c/start() 启动时钟中断、 main.c/main()

    • w_mepc((uint64)main)
    • asm volatile (mret) -> main.c/main()
  3. main.c/main()


xv6 系统陷阱调用流程

用户态陷入内核态

  • 用户触发陷阱,由 stvec [uservec] 跳入
    • trampoline.S/uservec
      • trampoline.S/uservec/jalr [trap.c/usertrap]
        • trap.c/prepare_return()
          • 设置 sstatus 和 sepc
        • trap.c/usertrap()/return satp
    • trampoline.S/userret
      • sret 利用 sepc 返回用户态

内核态跳入用户态

首次进入

  • proc.c/scheduler()
    • swtch.S/swtch()

创建新进程

  • proc.c/forkret()
    • trap.c/prepare_return()
      • 设置 sstatus 和 sepc
    • trampline.S/userret
      • sret 利用 sepc 返回用户态

内核态自身的独立陷阱

  • 内核触发陷阱,由 stvec [kernelvec] 跳入
    • kernelvec.S/kernelvec/call [trap.c/kerneltrap()]
      • yeild()
      • 设置 sstatus 和 sepc
    • kernelvec.S/kernelvec
      • sret 返回到内核中被中断的位置

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
{
/*
* 确保 entry.S / _entry 在 0x80000000 地址处
* 保证 qemu -kernel 跳转到正确位置
*/
. = 0x80000000;

# 指令段
.text : {
kernel/entry.o(_entry) /* 指定 _entry 的位置,强制将 entry.S/_entry 段放入 .text 段的开头 */
*(.text .text.*)
. = ALIGN(0x1000); /* 页对齐 */
_trampoline = .; /* trampoline 代码独占一页 */
*(trampsec)
. = ALIGN(0x1000);
ASSERT(. - _trampoline == 0x1000, "error: trampoline larger than one page");
PROVIDE(etext = .);
}

# 只读数据段
.rodata : {
. = ALIGN(16); /* 段对齐 */
*(.srodata .srodata.*) /* 在 .rodata 段中不需要区分 .srodata .srodata.* 段划分 */
. = ALIGN(16);
*(.rodata .rodata.*)
}

# 数据段
.data : {
. = ALIGN(16);
*(.sdata .sdata.*) /* do not need to distinguish this from .data */
. = ALIGN(16);
*(.data .data.*)
}

# 基址段
.bss : {
. = ALIGN(16);
*(.sbss .sbss.*) /* do not need to distinguish this from .bss */
. = 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, ... /* %0, %1, ... %n */
: 输入操作数x, 输入操作数y, ... /* %n+1, %n+2, ... 接着编号 */
: 破坏列表
);

如

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
// 读取 machine status register 即 mstatus 的值
// output operands
// "=r" 只写输出到 x值所在的 寄存器
static inline uint64
r_mstatus()
{
uint64 x;
asm volatile("csrr %0, mstatus" : "=r"(x));
// csrr: Control and Status Register Read
return x;
}

// 将 x 值写入 mstatus 寄存器
// input operands
// "r" 从存储x值通用寄存器写入 mstatus 寄存器
static inline void
w_mstatus(uint64 x)
{
asm volatile("csrw mstatus, %0" : : "r"(x));
// csrw: Control and Status Register Write
}

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 // Directory
#define T_FILE 2 // File
#define T_DEVICE 3 // Device

struct stat {
int dev; // File system's disk device
uint ino; // Inode number
short type; // Type of file
short nlink; // Number of links to file
uint64 size; // Size of file in bytes
};

主程序 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(); // 初始化格式化输入
/*
printf("\n");
printf("xv6 kernel is booting\n");
printf("\n");
*/
kinit(); // kalloc.c 物理页分配器
kvminit(); // vm.c 创建内核页表
kvminithart(); // vm.c 启动内核页表
procinit(); // proc.c 初始化进程表
trapinit(); // trap.c 初始化陷阱向量(初始化陷阱锁)
trapinithart(); // trap.c 安装内核陷阱向量
plicinit(); // plic.c 设置中断控制器 (riscv Platform Level Interrupt Controller, PLIC)
plicinithart(); // plic.c 初始化PLIC设备中断
binit(); // bio.c 缓冲区缓存
iinit(); // fs.c 初始化inode表
fileinit(); // fs.c 初始化文件表
virtio_disk_init(); // virtio_disk.c 模拟硬盘
userinit(); // proc.c 第一个用户进程

__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);
/**
* 回显硬件线程启动信息
printf("hart %d starting\n", cpuid());
*/
kvminithart(); // vm.c 启用分页
trapinithart(); // trap.c 安装陷阱向量
plicinithart(); // plic.c 初始化PLIC硬件中断

启动进程调度程序

1
scheduler();    // proc.c 启动调度程序

start.c

主要依赖 riscv.h 中riscv架构处理器寄存器操作函数、宏

  • start()
    • 启动程序,调起 main.c/main()
  • timerinit()
    • 初始化处理器时钟中断(定时器中断)

设置机器状态,启动分页,调起时钟中断初始化,返回到 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();    // 获取mstatus寄存器的值
x &= ~MSTATUS_MPP_MASK; // 重置mstatus寄存器的MPP段状态
x |= MSTATUS_MPP_S; // 设置mstatus寄存器的MPP段为S模式
w_mstatus(x); // 将已设置的x_mstatus值写回mstatus寄存器
// 完成mstatus寄存器MPP段的设置

mret 检查 mepc 寄存器中的地址(即 main() 的地址)进行返回,跳转到 main.c/main() 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
// 通知每个硬件线程产生定时器中断
void
timerinit()
{
// 启用 Sstc 扩展(Supervisor Timmer Compate),即stimecmp寄存器
w_menvcfg(r_menvcfg() | (1L << 63));

// 允许监管者使用 stimecmp 和 time 寄存器
w_mcounteren(r_mcounteren() | 2);

// 请求(触发)第一个定时器中断
w_stimecmp(r_time() + 1000000);
}

trap.c

陷阱相关操作定义

  • proc.c

    • myproc()
  • printf.c

    • panic()
1
2
3
4
5
6
// defs.h
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[]; // 从 trampoline.S 导入 trampoline、uservec 地址
void kernelvec(); // 从 kernelvec.S 导入 kerneltrap() 函数定义
extern int devintr(); // 导入设备中断处理程序 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 (监管者地址翻译与投影) 寄存器

  1. [核心] 使用 w_stvec((uint64)kernelvec) 更新 stvec 寄存器中的中断处理入口

    • 在我们身处内核态时,用于向 kerneltrap() 发送中断与异常,由 kernelvec 调起
  2. 在陷阱帧中保存用户的程序计数器

    • p->trapframe->epc = r_sepc(); 交由后续操作决定是否让出cpu
  3. [核心] 检查 scause (陷阱原因寄存器) 寄存器的值,根据 scause 分发处理

    • 系统调用
      • scause == 0
    • 设备中断
      • 记录 witch_dev
    • 缺页异常
      • scause == 15 加载页错误
      • scause == 13 存储页错误
      • 惰性分配
        • vmfault() 尝试处理惰性分配的页
        • 按需分配内存,避免提前分配,浪费内存
    • 预期外的陷阱
  4. 进程退出检查

    • if(killed(p)) kexit(-1);
  5. 设备定时器中断时让出cpu

    • if (witch_dev == 2) yield();
    • 触发定时中断,实现进程调度
  6. 准备返回用户态

    • prepare_return()
  7. 返回用户页表地址给 trampoline.S

    • 用户页可交换
    • uint64 satp = MAKE_SATP(p->pagetable); return satp;
  8. 注意,此时已经返回到 trampoline 中,直接按序向下执行 trampoline.S/userret 程序

使用汇编进行底层的上下文切换,C做高层的逻辑判断


kerneltrap()

内核陷阱

在 trampoline.S/kernelvec 切换页表后调用,负责 分类处理所有来自内核态的陷阱 ,并最终返回内核态
只能被内核态触发

  • kernelvec.S
    • kernelvec 陷阱向量程序调用
  • riscv.h
    • intr_get() 确定设备中断是否启用

在保存调用者保存的寄存器后,调起 kerneltrap()
kerneltrap() 返回内核中被中断的位置

  1. 获取对应寄存器的值

  2. 根据陷阱原因寄存器 scause 的值分发陷阱处理过程

    • 模式检测
      • (sstatus & SSTATUS_SPP) == 0
      • 检查是否通过监管者模式调起
    • [核心] 检测重复中断
      • intr_get() != 0
      • 防止内核陷阱处理过程本身被嵌套中断打断,内核陷阱必须在元自行的上下文中处理,避免竟态条件
    • 设备中断
      • 记录 witch_dev
    • 时钟中断
      • which_dev == 2 && myproc() != 0
  3. 直接返回 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();

// 我们将要交换陷阱处理入口 stvec 由 kerneltrap() 变为 usertrap()
// 因为内核代码中的陷阱作为用户陷阱将是一场灾难,(用户陷阱入口被错误路由)
// 关闭中断
intr_off(); // 实际上是一种临界区保护

// 将未来的系统调用、中断以及异常导向 trampoline.S/uservec
uint64 trampoline_uservec = TRAMPOLINE + (uservec - trampoline);
w_stvec(trampoline_uservec);

// 设置进程跳入下一个内核陷阱时 trampoline.S/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(); // cpuid() 作为 hartid

// 设置寄存器,使 trampoline.S 中的 sret 指令返回用户态

// set S Previous Privilege mode to User.
// 将 S 模式的前一个特权级设置为用户模式
unsigned long x = r_sstatus();
x &= ~SSTATUS_SPP; // 将SPP清理为0 设置为用户态
x |= SSTATUS_SPIE; // 设置 spie位 在用户模式下重启中断(保证用户态的中断是打开的)
w_sstatus(x);

// 设置 sepc (监管者异常程序计数器) 寄存器为被保存的用户程序计数器
w_sepc(p->trapframe->epc); // 由 sret 指令使用,返回到用户态
}

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[]; // trampoline.S

// helps ensure that wakeups of wait()ing
// parents are not lost. helps obey the
// memory model when using p->parent.
// must be acquired before any p->lock.
struct spinlock wait_lock;
1
2
3
4
// 初始化进程表
// 由 main.c/main() 函数调起
void
procinit(void)

wfi 指令 Wait For Interrupt 等待中断指令

可以使用 myproc() 获取指向当前执行的进程结构的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 返回当前执行指令的cpu结构
// 执行该函数时,中断一定是不可用的(无中断产生,保证上下文语义的准确性)
struct cpu *
mycpu(void)
{
int id = cpuid();
struct cpu *c = &cpus[id]; // 根据cpuid从cpus数组中获取当前cpu所在的偏移位置
return c;
}
// 返回指向当前的进程结构的指针 struct proc * , 或返回零表示什么也没有
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
// 每个CPU都要执行该调度器。
// 每个CPU在设置好他们自己后都会调用 scheduler() 函数(main.c/main())
// 调度器自循环永不返回
// 其功能是:
// - 选择一个进程运行
// - 调用 swtch 开始运行该进程
// - 最终,该进程通过 swtch 将控制权交换回调度器
void
scheduler(void)
{
struct proc *p;
struct cpu *c = mycpu();

c->proc = 0;
for (;;) {
// 最近运行的进程可能已关闭中断;
// 为避免所有进程都在等待时死锁,先启用中断。
// 然后再禁用中断,避免中断与 wfi 之间出现竞态。
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);

// 进程暂时停止运行。
// 在返回之前,它应该已经更改过自己的 p->state。
c->proc = 0;
found = 1;
}
release(&p->lock);
}
if (found == 0) { // 没有找到可执行的就绪进程
// 没有可运行的进程;停止该核心上的运行,直到中断发生。
asm volatile("wfi");
}
}
}

// 交换到调度器。
// 必须只持有的 p->lock 并且已经更改了 proc->state
// 保存并恢复 intena 因为 intena 属于内核线程,而非该CPU
// 理想情况下应保存为 proc->intena 且 proc->noff,
// 但,这会在少数的“持有锁却没有对应线程”的场景下出错
void
sched(void)
{
int intena;
struct proc *p = myproc();

if (!holding(&p->lock)) // 未持有 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); // 将进程上下文与当前cpu中处理的上下文进行交换
mycpu()->intena = intena;
}

// 在通道链中进行睡眠,释放状态锁 lk
// 当唤醒后重新获取 lk 锁
void
sleep(void *chan, struct spinlock *lk)
{
struct proc *p = myproc();

// 必须获取 p->lock 更改 p->state 并且调用 sched 。
// 由于曾持有 p->lock ,我们能被保证,我们将不会错过任何一次唤醒(唤醒锁 p->lock),所以释放 lk 锁可接受

// 在此处先获取 p->lock 锁再释放 lk 锁
// 是为了保证进程原子的进入睡眠,设置睡眠状态
// 保证了无抢占窗口,保证之后设置的睡眠状态能被探查

acquire(&p->lock); //DOC: sleeplock1
release(lk);

// 进入睡眠
p->chan = chan;
p->state = SLEEPING; // 设置进程状态为 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
// 这个宏返回 UART 在内存中映射的其中一个寄存器
#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
// UART 控制寄存器。
// 有些寄存器在读取和写入时含义不同。
#define RHR 0 // 接收保持寄存器(用于输入字节)
#define THR 0 // 发送保持寄存器(用于输出字节)
#define IER 1 // 中断使能寄存器
#define IER_RX_ENABLE (1 << 0) // 接收中断
#define IER_TX_ENABLE (1 << 1) // 发送中断
#define FCR 2 // FIFO 控制寄存器
#define FCR_FIFO_ENABLE (1 << 0)
#define FCR_FIFO_CLEAR (3 << 1) // 清除两个 FIFO 的内容
#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) // RHR 中有输入数据等待读取
#define LSR_TX_IDLE (1 << 5) // THR 可以接受下一个待发送字符
1
2
3
4
5
6
7
// 供发送线程与 uart"就绪"中断 同步
static struct spinlock tx_lock;
static int tx_busy; // UART 是否在忙(正在发送)?
static int tx_chan; // &tx_chan 是 等待通道

extern volatile int panicking; // from printf.c
extern volatile int panicked; // from printf.c
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
// 将 buf[] 中的数据发送到 UART
// 若 UART 正忙,该函数会阻塞
// 所以该函数不能在中断上下文中被调用
// 只能由 write() 系统调用调用
void
uartwrite(char buf[], int n)
{
acquire(&tx_lock);

int i = 0;
while (i < n) {
while (tx_busy != 0) {
// 等待 UART 发送完成 中断设置 tx_buzy 为 0
sleep(&tx_chan, &tx_lock);
}

WriteReg(THR, buf[i]);
i += 1;
tx_busy = 1;
}

release(&tx_lock);
}

// 不使用中断的情况下,向uart设备写入一字节,
// 供内核 printf() 使用,并用于回显字符。
// 自旋等待 UART 输出寄存器空闲
void
uartputc_sync(int c)
{
if (panicking == 0)
push_off();

if (panicked) {
for (;;)
;
}

// wait for UART to set Transmit Holding Empty in LSR.
// 等待 UART 在状态设置寄存器中设置传输保持空闲
// #define LSR_TX_IDLE (1 << 5) // THR 可以接受下一个待发送字符
while ((ReadReg(LSR) & LSR_TX_IDLE) == 0)
;
WriteReg(THR, c);

if (panicking == 0)
pop_off();
}

// 尝试从 UART 中读取一个输入字符
// 若没有等待接收到字符,返回 -1
static int
uartgetc(void)
{
// 输入是否就绪?
if (ReadReg(LSR) & LSR_RX_READY) {
return ReadReg(RHR);
} else {
return -1;
}
}

// 处理一个 uart 中断,该中断因以下原因被触发:
// 输入已到达,
// uart 已准备好输出更多的数据,
// 或两者同时发生
// 由 devintr() 调起
void
uartintr(void)
{
ReadReg(ISR); // 读取中断状态

acquire(&tx_lock);
if (ReadReg(LSR) & LSR_TX_IDLE) {
// UART 完成发送;唤醒等待的发送线程
tx_busy = 0;
wakeup(&tx_chan);
}
release(&tx_lock);

// 读取并处理 UART 输入的任何字符
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 (表示4KB) 传入寄存器a0
csrr a1, mhartid # 控制与状态寄存器读取mhartid hart栈的索引
addi a1, a1, 1 # a1寄存器值增加1
mul a0, a0, a1 # 计算栈偏移 4byte * (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 调用,而是硬件在 产生陷阱时自动跳转 而来

  • trap.c
    • kerneltrap()
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/ 目录下