系统调用和 traps 密不可分，系统调用需要用到 traps，所以这里将系统调用和 traps 结合到一起理解，当然重点是 traps。
系统调用相关文件
user.husys.plsyscall.hsyscall.csysproc.csysfile.c
异常和中断相关文件
trampoline.Strap.cproc.h
异常与中断
关于异常和中断的详细内容可以看看[[七、中断与异常]]。这里粗略地讲讲：
上图是异常和中断的程序流，可以看到异常和中断的处理都是暂停当前程序（这里会保存上下文），转而执行另一程序，最后再返回当前程序（恢复上下文）。这种暂停当前程序转而执行另一程序的方式也成为陷入，即 traps。
系统调用的原理也是 traps。因此，这里我们需要把两者结合起来理解。首先从系统调用开始
系统调用
我们先来看一段 lab0 中中编写的简单程序：
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
int
main(int argc, char *argv[])
{
if (argc < 2) {
fprintf(2, "Usage: sleep time\n");
exit(1);
}
int time = atoi(argv[1]);
sleep(time);
exit(0);
}
在这个简单程序中，我们只是调用了 sleep 函数。sleep 函数允许一个进程暂停执行一段指定的时间，这个过程是由内核完成，因此会涉及系统调用。我们利用 IDE 的功能查看 sleep 函数定义在哪里。
可以看到 sleep 函数定义在 user.h 文件中，其中包含了很多系统调用函数，如下所示：
// user.h 节选
struct stat;
struct rtcdate;
struct sysinfo;
// system calls
int fork(void);
int exit(int) __attribute__((noreturn));
int wait(int*);
int pipe(int*);
int write(int, const void*, int);
int read(int, void*, int);
int close(int);
int kill(int);
int exec(char*, char**);
int open(const char*, int);
int mknod(const char*, short, short);
int unlink(const char*);
int fstat(int fd, struct stat*);
int link(const char*, const char*);
int mkdir(const char*);
int chdir(const char*);
int dup(int);
int getpid(void);
char* sbrk(int);
int sleep(int);
int uptime(void);
int trace(int);
int sysinfo(struct sysinfo *);
当然这些函数在 user.h 中仅仅是函数描述，而非实现，系统调用函数的实现在内核中。下面我们需要清楚调用系统调用函数时，是如何从用户空间陷入内核空间的。
经过查阅我们知道，操作系统会运行一段段 Perl 脚本 usys.pl 来生成 xv6 操作系统用户级系统调用入口。
# usys.pl
#!/usr/bin/perl -w
# Generate usys.S, the stubs for syscalls.
print "# generated by usys.pl - do not edit\n";
print "#include \"kernel/syscall.h\"\n";
sub entry {
my $name = shift;
print ".global $name\n";
print "${name}:\n";
print " li a7, SYS_${name}\n";
print " ecall\n";
print " ret\n";
}
entry("fork");
entry("exit");
entry("wait");
entry("pipe");
entry("read");
entry("write");
entry("close");
entry("kill");
entry("exec");
entry("open");
entry("mknod");
entry("unlink");
entry("fstat");
entry("link");
entry("mkdir");
entry("chdir");
entry("dup");
entry("getpid");
entry("sbrk");
entry("sleep");
entry("uptime");
entry("trace");
entry("sysinfo");
通过脚本注释可以知道，该脚本最终会生成系统调用的存根，也就是系统调用的入口 usys.S。
# usys.S
# generated by usys.pl - do not edit
#include "kernel/syscall.h"
.global fork
fork:
li a7, SYS_fork
ecall
ret
.global exit
exit:
li a7, SYS_exit
ecall
ret
.global wait
wait:
li a7, SYS_wait
ecall
ret
.global pipe
pipe:
li a7, SYS_pipe
ecall
ret
.global read
...
...
.global sleep
sleep:
li a7, SYS_sleep
ecall
ret
.global uptime
uptime:
li a7, SYS_uptime
ecall
ret
.global trace
trace:
li a7, SYS_trace
ecall
ret
.global sysinfo
sysinfo:
li a7, SYS_sysinfo
ecall
ret
上述系统调用代码基本按照以下模式：
系统调用函数名xxx:
li a7, SYS_xxx
ecall
ret
也就是说，操作系统首先会把 SYS_xxx 常量保存到a7寄存器中，然后执行 ecall 指令进入内核执行完内核系统调用函数，再使用 ret 从系统调用返回到用户程序。这一系列步骤和异常和中断处理一致。那么 SYS_xxx 是什么呢？再 perl 脚本中包含了 "kernel/syscall.h"，我们查看一下这个文件里的内容：
// syscall.h
// System call numbers
#define SYS_fork 1
#define SYS_exit 2
#define SYS_wait 3
#define SYS_pipe 4
#define SYS_read 5
#define SYS_kill 6
#define SYS_exec 7
#define SYS_fstat 8
#define SYS_chdir 9
#define SYS_dup 10
#define SYS_getpid 11
#define SYS_sbrk 12
#define SYS_sleep 13
#define SYS_uptime 14
#define SYS_open 15
#define SYS_write 16
#define SYS_mknod 17
#define SYS_unlink 18
#define SYS_link 19
#define SYS_mkdir 20
#define SYS_close 21
#define SYS_trace 22
#define SYS_sysinfo 23
惊喜的是，这个文件是就是包含了一系列的 SYS_xxx。SYS_xxx 只是常量，在操作系统中被称为系统调用编号。回到 usys.S 文件，我们要先把系统调用的编号存储到 a7 寄存器中，然后使用 ecall 陷入内核。那么这个系统调用编号在系统调用过程就非常重要了。那具体有什么用呢？以目前的认知，我们不知道。
我们现在只知道我们使用 ecall 指令陷入内核，所以我们接着理解 traps。
先在本文[[#traps]]部分理解 traps 过程，在 usertrap 函数中会通过 r_scause() 的值来判断陷入内核的原因，当 r_scause() == 8 时，表示系统调用中断。在这里，我们会调用 syscall() 函数处理系统调用。
// 如果 r_scause() 返回的值是 8（表示系统调用中断）
if(r_scause() == 8){
// system call
if(p->killed)
exit(-1);
// sepc points to the ecall instruction,
// but we want to return to the next instruction.
// 系统调用指令ecall的下一条指令是系统调用的返回地址，所以epc需要增加4。
p->trapframe->epc += 4;
// an interrupt will change sstatus &c registers,
// so don't enable until done with those registers.
// 调用 intr_on() 启用中断。
intr_on();
// 调用 syscall() 处理系统调用。
syscall();
}
syscall() 函数位于 syscall.c 文件中。
void
syscall(void)
{
int num;
struct proc *p = myproc();
// a7 寄存器的值是用户程序通过系统调用指令传递给内核的系统调用编号。
num = p->trapframe->a7;
// 检查系统调用编号 num 是否在有效范围内（大于0且小于syscalls数组的元素数量）。
// NELEM(syscalls) 宏计算syscalls数组的长度。同时检查syscalls数组的对应位置是否非空（即存在有效的系统调用函数）。
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
// 如果系统调用编号有效，调用对应的系统调用函数，并将结果存储在当前进程的陷阱帧的a0寄存器中。
// a0寄存器通常用于存储函数的返回值。
p->trapframe->a0 = syscalls[num]();
if((1 << num) & p->trace_mask) {
// <pid>: syscall <syscall_name> -> <return_value>
printf("%d: syscall %s -> %d\n", p->pid, syscall_names[num], p->trapframe->a0);
}
} else {
printf("%d %s: unknown sys call %d\n",
p->pid, p->name, num);
p->trapframe->a0 = -1;
}
}
从 syscall 函数中我们可以看到，存放在 a7 中的系统调用编号被复制给 num，然后通过 syscalls[num]() 调用系统调用函数，并将返回值赋值给 a0 寄存器。也就是说系统调用编号的作用是作为 syscalls 数组的索引。我们看看 syscalls 数组是什么？
static uint64 (*syscalls[])(void) = {
[SYS_fork] sys_fork,
[SYS_exit] sys_exit,
[SYS_wait] sys_wait,
[SYS_pipe] sys_pipe,
[SYS_read] sys_read,
[SYS_kill] sys_kill,
[SYS_exec] sys_exec,
[SYS_fstat] sys_fstat,
[SYS_chdir] sys_chdir,
[SYS_dup] sys_dup,
[SYS_getpid] sys_getpid,
[SYS_sbrk] sys_sbrk,
[SYS_sleep] sys_sleep,
[SYS_uptime] sys_uptime,
[SYS_open] sys_open,
[SYS_write] sys_write,
[SYS_mknod] sys_mknod,
[SYS_unlink] sys_unlink,
[SYS_link] sys_link,
[SYS_mkdir] sys_mkdir,
[SYS_close] sys_close,
[SYS_trace] sys_trace,
[SYS_sysinfo] sys_sysinfo,
};
每个系统调用编号对应 sys_xxx 函数，通过系统调用编号来获取系统调用函数，从而完成系统调用。系统调用函数具体的实现在 sysproc.c 和 sysfile.c 中。
traps
从[[xv6 内存管理]]中从用户空间到内核空间的转换离不开 trampoline。trampoline 直译过来是蹦床的意思，可以理解为它是一个 U 态到 S 态的蹦床。trampoline 位于虚拟地址空间的顶部，内核地址空间与用户地址空间有相同的映射。trampoline是一个神奇的东西，由于我们需要从用户态转换到内核态，执行内核代码，所以我们肯定要切换用户页表到内核页表，而无论用户页表还是内核页表中都有 trampoline 这个东西，并映射到了相同的位置，所以，在 trampoline 代码中切换页表是安全的，切换页表后程序不会崩溃，对于 trampoline 中的下一条指令，在切换后的页表中仍然存在相同的虚拟地址。
从用户空间到内核空间的转换在 trampoline.S 中，如下所示：
- 当进程在用户模式下运行时发生中断或异常，控制权将转移到
uservec例程。在该例程中跳转到trap.c文件中的usertrap函数。 usertrap函数里会根据r_scause()的值执行选择执行不同的异常中断函数，如r_scause() == 8执行系统调用。执行异常中断函数后，调用usertrapret函数准备返回。usertrapret函数会执行一系列准备措施，最后计算trampoline.S中userret函数的地址，并将其作为函数指针调用。跳到内存顶部的trampoline.S，它会切换到用户页表，恢复用户寄存器。userret将从内核返回用户空间。
#
# code to switch between user and kernel space.
#
# this code is mapped at the same virtual address
# (TRAMPOLINE) in user and kernel space so that
# it continues to work when it switches page tables.
#
# kernel.ld causes this to be aligned
# to a page boundary.
#
.section trampsec
.globl trampoline
trampoline:
.align 4
.globl uservec
uservec:
# 用户态陷阱入口，stvec 指向这里
csrrw a0, sscratch, a0 # 交换 a0 和 sscratch，a0 变为 TRAPFRAME
# 保存用户寄存器到 TRAPFRAME
sd ra, 40(a0)
sd sp, 48(a0)
# ... 保存 gp, tp, t0-t6, s0-s11, a1-a7 ...
csrr t0, sscratch
sd t0, 112(a0) # 保存用户 a0
# 加载内核环境
ld sp, 8(a0) # 内核栈指针
ld tp, 32(a0) # 内核 hartid
ld t0, 16(a0) # usertrap 地址
ld t1, 0(a0) # 内核页表
csrw satp, t1 # 切换到内核页表
sfence.vma zero, zero # 内存屏障，清 TLB
jr t0 # 跳转到 usertrap
.globl userret
userret:
csrw satp, a1 # 切换到用户页表
sfence.vma zero, zero # 清 TLB
ld t0, 112(a0) # 加载用户 a0
csrw sscratch, t0 # 保存到 sscratch
# 恢复用户寄存器（除 a0）
ld ra, 40(a0)
ld sp, 48(a0)
# ... 恢复 gp, tp, t0-t6, s0-s11, a1-a7 ...
csrrw a0, sscratch, a0 # 恢复用户 a0
sret # 返回用户态
struct trapframe {
/* 0 */ uint64 kernel_satp; // kernel page table
/* 8 */ uint64 kernel_sp; // top of process's kernel stack
/* 16 */ uint64 kernel_trap; // usertrap()
/* 24 */ uint64 epc; // saved user program counter
/* 32 */ uint64 kernel_hartid; // saved kernel tp
/* 40 */ uint64 ra;
/* 48 */ uint64 sp;
/* 56 */ uint64 gp;
/* 64 */ uint64 tp;
/* 72 */ uint64 t0;
/* 80 */ uint64 t1;
/* 88 */ uint64 t2;
/* 96 */ uint64 s0;
/* 104 */ uint64 s1;
/* 112 */ uint64 a0;
/* 120 */ uint64 a1;
/* 128 */ uint64 a2;
/* 136 */ uint64 a3;
/* 144 */ uint64 a4;
/* 152 */ uint64 a5;
/* 160 */ uint64 a6;
/* 168 */ uint64 a7;
/* 176 */ uint64 s2;
/* 184 */ uint64 s3;
/* 192 */ uint64 s4;
/* 200 */ uint64 s5;
/* 208 */ uint64 s6;
/* 216 */ uint64 s7;
/* 224 */ uint64 s8;
/* 232 */ uint64 s9;
/* 240 */ uint64 s10;
/* 248 */ uint64 s11;
/* 256 */ uint64 t3;
/* 264 */ uint64 t4;
/* 272 */ uint64 t5;
/* 280 */ uint64 t6;
};
//
// handle an interrupt, exception, or system call from user space.
// called from trampoline.S
//
void
usertrap(void)
{
int which_dev = 0;
// 检查是否从用户模式触发，SPP位如果不为 0 表示当前不是在用户模式下
if((r_sstatus() & SSTATUS_SPP) != 0)
panic("usertrap: not from user mode");
// send interrupts and exceptions to kerneltrap(),
// since we're now in the kernel.
// 将stvec寄存器设置为指向kernelvec的地址，这样后续的中断和异常将由kernelvec处理，因为我们现在处于内核模式。
w_stvec((uint64)kernelvec);
struct proc *p = myproc();
// save user program counter.
// 保存用户程序计数器
p->trapframe->epc = r_sepc();
// 如果 r_scause() 返回的值是 8（表示系统调用中断）
if(r_scause() == 8){
// system call
if(p->killed)
exit(-1);
// sepc points to the ecall instruction,
// but we want to return to the next instruction.
// 系统调用指令ecall的下一条指令是系统调用的返回地址，所以epc需要增加4。
p->trapframe->epc += 4;
// an interrupt will change sstatus &c registers,
// so don't enable until done with those registers.
// 调用 intr_on() 启用中断。
intr_on();
// 调用 syscall() 处理系统调用。
syscall();
} else if((which_dev = devintr()) != 0){ // 调用 devintr() 函数处理设备中断。如果 devintr() 返回非零值，表示有设备中断需要处理。
// ok
} else {
// 如果既不是系统调用也不是设备中断，则打印异常信息，包括 scause 和 pid，
// 以及引起异常的指令地址 sepc 和 stval。设置当前进程的 killed 标志为 1，表示进程被终止。
printf("usertrap(): unexpected scause %p pid=%d\n", r_scause(), p->pid);
printf(" sepc=%p stval=%p\n", r_sepc(), r_stval());
p->killed = 1;
}
if(p->killed)
exit(-1);
// give up the CPU if this is a timer interrupt.
// 如果 which_dev 等于 2（表示定时器中断），则调用 yield() 函数放弃 CPU，允许其他进程运行。
if(which_dev == 2) {
if(p->interval != 0) {
// 由于 ticks 一直是递增的，第二个 handler 始终无法执行。
// 只有当 sigreturn 执行完成后，ticks 才置为 0，这样就可以等待下一个 handler 执行了。
if((p->ticks == p->interval)) {
*p->pretrapframe = *p->trapframe;
p->trapframe->epc = p->handler;
}
p->ticks++;
}
yield();
}
// 调用usertrapret()函数恢复用户模式的上下文，以便继续执行用户程序。
usertrapret();
}
//
// return to user space
//
void
usertrapret(void)
{
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.
// 调用 intr_off() 函数关闭中断，以防止在返回用户模式的过程中接收到新的中断。
intr_off();
// send syscalls, interrupts, and exceptions to trampoline.S
// 使用 w_stvec() 函数将 stvec 寄存器设置为指向 trampoline.S 的地址。
// trampoline.S 是内核和用户模式之间的一个跳板，它负责处理从内核模式返回到用户模式的上下文切换。
w_stvec(TRAMPOLINE + (uservec - trampoline));
// set up trapframe values that uservec will need when
// the process next re-enters the kernel.
// 设置trapframe中当进程再次进入内核时所需要的数据
// 这也就是之前在trampoline中加载的，那些进程中的内核相关数据的来源
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;
p->trapframe->kernel_hartid = r_tp(); // hartid for cpuid()
// set up the registers that trampoline.S's sret will use
// to get to user space.
// set S Previous Privilege mode to User.
// 清除sstatus寄存器的SPP位，将特权级别设置为用户模式。
unsigned long x = r_sstatus();
x &= ~SSTATUS_SPP; // clear SPP to 0 for user mode
// 启用用户模式下的中断，设置SPIE位。
x |= SSTATUS_SPIE; // enable interrupts in user mode
w_sstatus(x);
// set S Exception Program Counter to the saved user pc.
// 设置 sepc 寄存器为保存的用户程序计数器 epc，这是进程返回到用户空间时的执行地址。
w_sepc(p->trapframe->epc);
// tell trampoline.S the user page table to switch to.
// satp变量赋值为用户进程页表
uint64 satp = MAKE_SATP(p->pagetable);
// jump to 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函数的地址，并将其作为函数指针调用。
// 跳到内存顶部的trampoline.S，它会切换到用户页表，恢复用户寄存器
uint64 fn = TRAMPOLINE + (userret - trampoline);
((void (*)(uint64,uint64))fn)(TRAPFRAME, satp);
}
扫一扫
1485
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
