MIT 6.S081 | Lab3: page tables
课程地址：https://pdos.csail.mit.edu/6.S081/2020/schedule.html 代码地址：https://github.com/36-H/xv6-labs-2020/tree/pgtbl
#Lab3: page tables
##Print a page table (easy)
YOUR JOB 定义一个名为vmprint()的函数。它应当接收一个pagetable_t作为参数，并以下面描述的格式打印该页表。在exec.c中的return argc之前插入if(p->pid==1) vmprint(p->pagetable)，以打印第一个进程的页表。如果你通过了pte printout测试的make grade，你将获得此作业的满分。
我们预想实现该函数后，会产生如下效果：
page table 0x0000000087f6e000
..0: pte 0x0000000021fda801 pa 0x0000000087f6a000
.. ..0: pte 0x0000000021fda401 pa 0x0000000087f69000
.. .. ..0: pte 0x0000000021fdac1f pa 0x0000000087f6b000
.. .. ..1: pte 0x0000000021fda00f pa 0x0000000087f68000
.. .. ..2: pte 0x0000000021fd9c1f pa 0x0000000087f67000
..255: pte 0x0000000021fdb401 pa 0x0000000087f6d000
.. ..511: pte 0x0000000021fdb001 pa 0x0000000087f6c000
.. .. ..510: pte 0x0000000021fdd807 pa 0x0000000087f76000
.. .. ..511: pte 0x0000000020001c0b pa 0x0000000080007000
我们能够在kernel/vm.c中查看到，xv6的页表管理
// The risc-v Sv39 scheme has three levels of page-table
// pages. A page-table page contains 512 64-bit PTEs.
// A 64-bit virtual address is split into five fields:
// 39..63 -- must be zero.
// 30..38 -- 9 bits of level-2 index.
// 21..29 -- 9 bits of level-1 index.
// 12..20 -- 9 bits of level-0 index.
// 0..11 -- 12 bits of byte offset within the page.
// 采用三级页表的形式，9 bit 一级索引找到二级页表，
// 9 bit 二级索引找到三级页表，
// 9 bit 三级索引找到内存页，
// 最低 12 bit 为页内偏移（即一个页 4096 bytes）。
我们要去模拟如上的CPU查询页表的过程。
在kernel/defs.h中添加函数声明
int copyout(pagetable_t, uint64, char *, uint64);
int copyin(pagetable_t, char *, uint64, uint64);
int copyinstr(pagetable_t, char *, uint64, uint64);
int vmprint(pagetable_t pagetable); //here
参考kernel/vm.c中的freewalk()函数
在kernel/vm.c中添加下述函数：
int
pgtbl_print(pagetable_t pagetable,int depth){
// there are 2^9 = 512 PTEs in a page table.
for(int i = 0; i < 512; i++){
pte_t pte = pagetable[i];
//该页表项有效
if(pte & PTE_V){
printf("..");
for(int j = 0; j < depth; j++){
printf(" ..");
}
printf("%d: pte %p pa %p\n", i, pte, PTE2PA(pte));
//判断是否为叶子节点
//判断页表项是否为叶子节点的方法是检查 R、W、X 位是否至少有一个被设置为1。
//如果这些位之一被设置，这意味着这个页表项直接映射到物理页而不是指向另一级页表。
if(!(pte & (PTE_R | PTE_W | PTE_X))){
//PTE2PA(pte) (((pte) >> 10) << 12)
//右移10位 去除了控制位
//左移12位 就能拿到页号
//这时候根据偏移量就能拿到物理地址~
uint64 child = PTE2PA(pte);
pgtbl_print((pagetable_t)child, depth + 1);
}
}
}
return 0;
}
int
vmprint(pagetable_t pagetable){
printf("page table %p\n",pagetable);
return pgtbl_print(pagetable,0);
}
在kernel/exec.c中添加该函数的引用
int
exec(char *path, char **argv)
{
// ......
//print the pagetable info
vmprint(p->pagetable);
return argc;
}
##A kernel page table per process (hard)
YOUR JOB 你的第一项工作是修改内核来让每一个进程在内核中执行时使用它自己的内核页表的副本。修改struct proc来为每一个进程维护一个内核页表，修改调度程序使得切换进程时也切换内核页表。对于这个步骤，每个进程的内核页表都应当与现有的的全局内核页表完全一致。如果你的usertests程序正确运行了，那么你就通过了这个实验。
仔细研究kernel/vm.c代码，我们可以发现，用户进程在用户态使用各自的用户态页表，但是一旦进入内核态，则切换到内核页表（通过修改 satp 寄存器，trampoline.S）。然而这个内核页表是全局共享的，也就是全部进程进入内核态都共用同一个内核态页表：
// 全局变量，共享的内核页表
pagetable_t kernel_pagetable;
创建进程内核页表与内核栈
在kernel/proc.h中，给结构体proc，添加内核态页表变量。
// Per-process state
struct proc {
struct spinlock lock;
// p->lock must be held when using these:
enum procstate state; // Process state
struct proc *parent; // Parent process
void *chan; // If non-zero, sleeping on chan
int killed; // If non-zero, have been killed
int xstate; // Exit status to be returned to parent's wait
int pid; // Process ID
// these are private to the process, so p->lock need not be held.
uint64 kstack; // Virtual address of kernel stack
uint64 sz; // Size of process memory (bytes)
pagetable_t pagetable; // User page table
struct trapframe *trapframe; // data page for trampoline.S
struct context context; // swtch() here to run process
struct file *ofile[NOFILE]; // Open files
struct inode *cwd; // Current directory
char name[16]; // Process name (debugging)
pagetable_t kernel_pgtable; // 内核页表
};
修改kernel/vm.c中的kvminit函数，抽象出一个可以为任何内核页表添加固定映射的函数,并对kminit进行修改。
/**
* 对内核页表进行映射
*/
void
map_pgtbl(pagetable_t pgtbl){
// uart registers
kvmmap(pgtbl, UART0, UART0, PGSIZE, PTE_R | PTE_W);
// virtio mmio disk interface
kvmmap(pgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
// CLINT
kvmmap(pgtbl, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
// PLIC
kvmmap(pgtbl, PLIC, PLIC, 0x400000, PTE_R | PTE_W);
// map kernel text executable and read-only.
kvmmap(pgtbl, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);
// map kernel data and the physical RAM we'll make use of.
kvmmap(pgtbl, (uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);
// map the trampoline for trap entry/exit to
// the highest virtual address in the kernel.
kvmmap(pgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
}
/**
* create the new page table
* for each proc to own a kernel pagetable
*/
pagetable_t
kvminit_newpgtbl(void){
pagetable_t pgtbl = (pagetable_t) kalloc();
memset(pgtbl, 0, PGSIZE);
map_pgtbl(pgtbl);
return pgtbl;
}
/*
* create a direct-map page table for the kernel.
*/
void
kvminit()
{
// 分配并初始化内核页表 全局kernel_pagetable 定义在21行
kernel_pagetable = kvminit_newpgtbl();
}
// only used when booting.
// does not flush TLB or enable paging.
//添加第一个参数 pgtbl
void
kvmmap(pagetable_t pgtbl,uint64 va, uint64 pa, uint64 sz, int perm)
{
if(mappages(pgtbl, va, sz, pa, perm) != 0)
panic("kvmmap");
}
// addresses on the stack.
// assumes va is page aligned.
// 添加第一个参数 pgtbl
uint64
kvmpa(pagetable_t pgtbl,uint64 va)
{
uint64 off = va % PGSIZE;
pte_t *pte;
uint64 pa;
pte = walk(pgtbl, va, 0);
if(pte == 0)
panic("kvmpa");
if((*pte & PTE_V) == 0)
kfree((void*)pagetable);
}
我们还需要对内核栈进行处理，在xv6 设计中，所有处于内核态的进程都共享同一个页表，即意味着共享同一个地址空间。由于 xv6 支持多核/多进程调度，同一时间可能会有多个进程处于内核态，所以需要对所有处于内核态的进程创建其独立的内核态内的栈，也就是内核栈，供给其内核态代码执行过程。
xv6 在启动过程中，会在 procinit() 中为所有可能的 64 个进程位都预分配好内核栈 kstack，具体为在高地址空间里，每个进程使用一个页作为 kstack，并且两个不同 kstack 中间隔着一个无映射的 guard page 用于检测栈溢出错误。如下图：
每一个进程都会有自己独立的内核页表，并且每个进程也只需要访问自己的内核栈，而不需要能够访问所有 64 个进程的内核栈。所以可以将所有进程的内核栈 map 到其各自内核页表内的固定位置（不同页表内的同一逻辑地址，指向不同物理内存）。
在kernel/proc.c中
// initialize the proc table at boot time.
void
procinit(void)
{
struct proc *p;
initlock(&pid_lock, "nextpid");
for(p = proc; p < &proc[NPROC]; p++) {
initlock(&p->lock, "proc");
// Allocate a page for the process's kernel stack.
// Map it high in memory, followed by an invalid
// guard page.
// char *pa = kalloc();
// if(pa == 0)
// panic("kalloc");
// uint64 va = KSTACK((int) (p - proc));
// kvmmap(va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
// p->kstack = va;
// 当我们变为每个用户进程都有一个内核页表的时候，那么每个进程就只用访问到自己的内核页表即可
// 所以可以将所有进程的内核栈映射到各自内核页表的固定位置
// 只需要创建进程的时候再创建内核栈
// 查看allocproc函数
}
kvminithart();
}
// Look in the process table for an UNUSED proc.
// If found, initialize state required to run in the kernel,
// and return with p->lock held.
// If there are no free procs, or a memory allocation fails, return 0.
static struct proc*
allocproc(void)
{
struct proc *p;
for(p = proc; p < &proc[NPROC]; p++) {
acquire(&p->lock);
if(p->state == UNUSED) {
goto found;
} else {
release(&p->lock);
}
}
return 0;
found:
p->pid = allocpid();
// Allocate a trapframe page.
if((p->trapframe = (struct trapframe *)kalloc()) == 0){
release(&p->lock);
return 0;
}
// An empty user page table.
p->pagetable = proc_pagetable(p);
if(p->pagetable == 0){
freeproc(p);
release(&p->lock);
return 0;
}
// here 我们开始创建内核页表
p->kernel_pgtable = kvminit_newpgtbl();
// 分配一个物理页，作为新进程的内核栈使用
char *pa = kalloc();
if(pa == 0){
panic("kalloc");
}
//将内核栈映射进内核页表
uint64 va = KSTACK((int)0);
kvmmap(p->kernel_pgtable, va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
p->kstack = va;
// Set up new context to start executing at forkret,
// which returns to user space.
memset(&p->context, 0, sizeof(p->context));
p->context.ra = (uint64)forkret;
p->context.sp = p->kstack + PGSIZE;
return p;
}
切换到进程内核页表
在进程调度的时候，要切换到进程的内核页表
// - swtch to start running that process.
// - eventually that process transfers control
// via swtch back to the scheduler.
void
scheduler(void)
{
struct proc *p;
struct cpu *c = mycpu();
c->proc = 0;
for(;;){
// Avoid deadlock by ensuring that devices can interrupt.
intr_on();
int found = 0;
for(p = proc; p < &proc[NPROC]; p++) {
acquire(&p->lock);
if(p->state == RUNNABLE) {
// Switch to chosen process. It is the process's job
// to release its lock and then reacquire it
// before jumping back to us.
p->state = RUNNING;
c->proc = p;
// 切换到进程独立的内核页表
w_satp(MAKE_SATP(p->kernel_pgtable));
sfence_vma(); // 清除快表缓存
// 调度
swtch(&c->context, &p->context);
//切换回全局内核页表
kvminithart();
// Process is done running for now.
// It should have changed its p->state before coming back.
c->proc = 0;
found = 1;
}
release(&p->lock);
}
#if !defined (LAB_FS)
if(found == 0) {
intr_on();
asm volatile("wfi");
}
#else
;
#endif
}
}
###释放进程内核页表 进程结束后，我们应该释放进程独享的页表以及内核栈，回收资源，否则会导致内存泄漏。
// kernel/vm.c
// free a proc structure and the data hanging from it,
// including user pages.
// p->lock must be held.
static void
freeproc(struct proc *p)
{
if(p->trapframe)
kfree((void*)p->trapframe);
p->trapframe = 0;
if(p->pagetable)
proc_freepagetable(p->pagetable, p->sz);
p->pagetable = 0;
p->sz = 0;
p->pid = 0;
p->parent = 0;
p->name[0] = 0;
p->chan = 0;
p->killed = 0;
p->xstate = 0;
//释放内核栈
void *kstack_pa = (void *)kvmpa(p->kernel_pgtable,p->kstack);
kfree(kstack_pa);
p->kstack = 0;
//释放进程内核页
kvm_free_kernelpgtbl(p->kernel_pgtable);
p->state = UNUSED;
}
void
kvm_free_kernelpgtbl(pagetable_t pagetable)
{
// there are 2^9 = 512 PTEs in a page table.
for(int i = 0; i < 512; i++){
pte_t pte = pagetable[i];
// 如果该页表项指向更低一级的页表
if((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0){
uint64 child = PTE2PA(pte);
// 递归释放低一级页表及其页表项
kvm_free_kernelpgtbl((pagetable_t)child);
pagetable[i] = 0;
}
}
// 释放当前级别页表所占用空间
kfree((void*)pagetable);
}
virtio 磁盘驱动 virtio_disk.c 中调用了 kvmpa() 用于将虚拟地址转换为物理地址
// virtio_disk.c
#include "proc.h" // 添加头文件引入
// ......
void
virtio_disk_rw(struct buf *b, int write)
{
// ......
disk.desc[idx[0]].addr = (uint64) kvmpa(myproc()->kernel_pgtable, (uint64) &buf0); // 调用 myproc()，获取进程内核页表
// ......
}
##Simplify copyin/copyinstr（hard）
YOUR JOB 将定义在kernel/vm.c中的copyin的主题内容替换为对copyin_new的调用（在kernel/vmcopyin.c中定义）；对copyinstr和copyinstr_new执行相同的操作。为每个进程的内核页表添加用户地址映射，以便copyin_new和copyinstr_new工作。如果usertests正确运行并且所有make grade测试都通过，那么你就完成了此项作业。
内核的copyin函数读取用户指针指向的内存。它通过将用户指针转换为内核可以直接解引用的物理地址来实现这一点。这个转换是通过在软件中遍历进程页表来执行的。此方案依赖于用户的虚拟地址范围不与内核用于自身指令和数据的虚拟地址范围重叠。Xv6使用从零开始的虚拟地址作为用户地址空间，幸运的是内核的内存从更高的地址开始。然而，这个方案将用户进程的最大大小限制为小于内核的最低虚拟地址。内核启动后，在XV6中该地址是0xC000000，即PLIC寄存器的地址；我们需要在每一处内核对用户页表进行修改的时候，将同样的修改也同步应用在进程的内核页表上，使得两个页表的程序段（0 到 PLIC 段）地址空间的映射同步。
//kernel.dfs.h
int kvm_copy_map(pagetable_t, pagetable_t, uint64, uint64);
uint64 kvmdealloc(pagetable_t, uint64, uint64);
//kernel/vm.c
// 将 src 页表的一部分页映射关系拷贝到 dst 页表中。
// 只拷贝页表项，不拷贝实际的物理页内存。
// 成功返回0，失败返回 -1
int
kvm_copy_map(pagetable_t src, pagetable_t dst, uint64 start, uint64 sz){
pte_t *pte;
uint64 pa, i;
uint flags;
//向上舍入到页面边界
for(i = PGROUNDUP(start); i < start + sz; i += PGSIZE){
if((pte = walk(src, i, 0)) == 0){
panic("kvmcopymappings: pte should exist");
}
if((*pte & PTE_V) == 0){
panic("kvmcopymappings: page not present");
}
pa = PTE2PA(*pte);
// `& ~PTE_U` 表示将该页的权限设置为非用户页
// 必须设置该权限，RISC-V 中内核是无法直接访问用户页的。
flags = PTE_FLAGS(*pte) & ~PTE_U;
if(mappages(dst, i, PGSIZE, pa, flags) != 0){
goto err;
}
}
return 0;
err:
// thanks @hdrkna for pointing out a mistake here.
// original code incorrectly starts unmapping from 0 instead of PGROUNDUP(start)
uvmunmap(dst, PGROUNDUP(start), (i - PGROUNDUP(start)) / PGSIZE, 0);
return -1;
}
// 与 uvmdealloc 功能类似，将程序内存从 oldsz 缩减到 newsz。但区别在于不释放实际内存
// 用于内核页表内程序内存映射与用户页表程序内存映射之间的同步
uint64
kvmdealloc(pagetable_t pagetable, uint64 oldsz, uint64 newsz)
{
if(newsz >= oldsz)
return oldsz;
//检查向上舍入后的新的虚拟内存大小 PGROUNDUP(newsz) 是否小于向上舍入后的旧的虚拟内存大小
//PGROUNDUP(oldsz)
// 如果是，表示新的虚拟内存大小小于旧的虚拟内存大小
// 即有一部分内存需要被释放
if(PGROUNDUP(newsz) < PGROUNDUP(oldsz)){
//计算需要释放的页面数量
int npages = (PGROUNDUP(oldsz) - PGROUNDUP(newsz)) / PGSIZE;
//从虚拟内存地址 PGROUNDUP(newsz) 开始的一段内存
//将被取消映射，并且这些页面将被标记为未使用。
uvmunmap(pagetable, PGROUNDUP(newsz), npages, 0);
}
return newsz;
}
内核启动后，能够用于映射程序内存的地址范围是 [0,PLIC)，我们将把进程程序内存映射到其内核页表的这个范围内，首先要确保这个范围没有和其他映射冲突。
修改map_pgtbl
//kernel/vm.c
/**
* 对内核页表进行映射
*/
void
map_pgtbl(pagetable_t pgtbl){
// uart registers
kvmmap(pgtbl, UART0, UART0, PGSIZE, PTE_R | PTE_W);
// virtio mmio disk interface
kvmmap(pgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
// CLINT 在内核启动后，我们不需要clint的映射
// kvmmap(pgtbl, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
// PLIC
kvmmap(pgtbl, PLIC, PLIC, 0x400000, PTE_R | PTE_W);
// map kernel text executable and read-only.
kvmmap(pgtbl, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);
// map kernel data and the physical RAM we'll make use of.
kvmmap(pgtbl, (uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);
// map the trampoline for trap entry/exit to
// the highest virtual address in the kernel.
kvmmap(pgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
}
/**
* create the new page table
* for each proc to own a kernel pagetable
*/
pagetable_t
kvminit_newpgtbl(void){
pagetable_t pgtbl = (pagetable_t) kalloc();
memset(pgtbl, 0, PGSIZE);
map_pgtbl(pgtbl);
return pgtbl;
}
/*
* create a direct-map page table for the kernel.
*/
void
kvminit()
{
// 分配并初始化内核页表 全局kernel_pagetable 定义在21行
kernel_pagetable = kvminit_newpgtbl();
// CLINT 内核启动的时候需要 CLINT 映射存在
kvmmap(kernel_pagetable, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
}
###同步映射
// kernel/proc.c
// Set up first user process.
void
userinit(void)
{
struct proc *p;
p = allocproc();
initproc = p;
// allocate one user page and copy init's instructions
// and data into it.
uvminit(p->pagetable, initcode, sizeof(initcode));
p->sz = PGSIZE;
kvm_copy_map(p->pagetable, p->kernel_pgtable, 0, p->sz);
// prepare for the very first "return" from kernel to user.
p->trapframe->epc = 0; // user program counter
p->trapframe->sp = PGSIZE; // user stack pointer
safestrcpy(p->name, "initcode", sizeof(p->name));
p->cwd = namei("/");
p->state = RUNNABLE;
release(&p->lock);
}
// Grow or shrink user memory by n bytes.
// Return 0 on success, -1 on failure.
int
growproc(int n)
{
uint sz;
struct proc *p = myproc();
sz = p->sz;
if(n > 0){
uint64 newsz;
if((newsz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
return -1;
}
// 扩大内核页表中的映射
if(kvm_copy_map(p->pagetable, p->kernel_pgtable, sz, n) != 0) {
uvmdealloc(p->pagetable, newsz, sz);
return -1;
}
sz = newsz;
} else if(n < 0){
uvmdealloc(p->pagetable, sz, sz + n);
//缩减内核页表的映射
sz = kvmdealloc(p->kernel_pgtable, sz, sz + n);
}
p->sz = sz;
return 0;
}
// Create a new process, copying the parent.
// Sets up child kernel stack to return as if from fork() system call.
int
fork(void)
{
int i, pid;
struct proc *np;
struct proc *p = myproc();
// Allocate process.
if((np = allocproc()) == 0){
return -1;
}
// Copy user memory from parent to child.
// 这里我们还需要将子进程的用户页表映射到子进程的内核页表中
if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0
|| kvm_copy_map(np->pagetable, np->kernel_pgtable, 0, p->sz) < 0
){
freeproc(np);
release(&np->lock);
return -1;
}
np->sz = p->sz;
np->parent = p;
// copy saved user registers.
*(np->trapframe) = *(p->trapframe);
// Cause fork to return 0 in the child.
np->trapframe->a0 = 0;
// increment reference counts on open file descriptors.
for(i = 0; i < NOFILE; i++)
if(p->ofile[i])
np->ofile[i] = filedup(p->ofile[i]);
np->cwd = idup(p->cwd);
safestrcpy(np->name, p->name, sizeof(p->name));
pid = np->pid;
np->state = RUNNABLE;
release(&np->lock);
return pid;
}
// kernel/exec.c
int
exec(char *path, char **argv)
{
char *s, *last;
int i, off;
uint64 argc, sz = 0, sp, ustack[MAXARG+1], stackbase;
struct elfhdr elf;
struct inode *ip;
struct proghdr ph;
pagetable_t pagetable = 0, oldpagetable;
struct proc *p = myproc();
begin_op();
if((ip = namei(path)) == 0){
end_op();
return -1;
}
ilock(ip);
// Check ELF header
if(readi(ip, 0, (uint64)&elf, 0, sizeof(elf)) != sizeof(elf))
goto bad;
if(elf.magic != ELF_MAGIC)
goto bad;
if((pagetable = proc_pagetable(p)) == 0)
goto bad;
// Load program into memory.
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
if(readi(ip, 0, (uint64)&ph, off, sizeof(ph)) != sizeof(ph))
goto bad;
if(ph.type != ELF_PROG_LOAD)
continue;
if(ph.memsz < ph.filesz)
goto bad;
if(ph.vaddr + ph.memsz < ph.vaddr)
goto bad;
uint64 sz1;
if((sz1 = uvmalloc(pagetable, sz, ph.vaddr + ph.memsz)) == 0)
goto bad;
// 添加检测，防止程序大小超过 PLIC
if(sz1 >= PLIC) {
goto bad;
}
sz = sz1;
if(ph.vaddr % PGSIZE != 0)
goto bad;
if(loadseg(pagetable, ph.vaddr, ip, ph.off, ph.filesz) < 0)
goto bad;
}
iunlockput(ip);
end_op();
ip = 0;
p = myproc();
uint64 oldsz = p->sz;
// Allocate two pages at the next page boundary.
// Use the second as the user stack.
sz = PGROUNDUP(sz);
uint64 sz1;
if((sz1 = uvmalloc(pagetable, sz, sz + 2*PGSIZE)) == 0)
goto bad;
sz = sz1;
uvmclear(pagetable, sz-2*PGSIZE);
sp = sz;
stackbase = sp - PGSIZE;
// Push argument strings, prepare rest of stack in ustack.
for(argc = 0; argv[argc]; argc++) {
if(argc >= MAXARG)
goto bad;
sp -= strlen(argv[argc]) + 1;
sp -= sp % 16; // riscv sp must be 16-byte aligned
if(sp < stackbase)
goto bad;
if(copyout(pagetable, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
goto bad;
ustack[argc] = sp;
}
ustack[argc] = 0;
// push the array of argv[] pointers.
sp -= (argc+1) * sizeof(uint64);
sp -= sp % 16;
if(sp < stackbase)
goto bad;
if(copyout(pagetable, sp, (char *)ustack, (argc+1)*sizeof(uint64)) < 0)
goto bad;
// arguments to user main(argc, argv)
// argc is returned via the system call return
// value, which goes in a0.
p->trapframe->a1 = sp;
// Save program name for debugging.
for(last=s=path; *s; s++)
if(*s == '/')
last = s+1;
safestrcpy(p->name, last, sizeof(p->name));
// 清除内核页表中对程序内存的旧映射，然后重新建立映射。
uvmunmap(p->kernel_pgtable, 0, PGROUNDUP(oldsz)/PGSIZE, 0);
kvm_copy_map(pagetable, p->kernel_pgtable, 0, sz);
// Commit to the user image.
oldpagetable = p->pagetable;
p->pagetable = pagetable;
p->sz = sz;
p->trapframe->epc = elf.entry; // initial program counter = main
p->trapframe->sp = sp; // initial stack pointer
proc_freepagetable(oldpagetable, oldsz);
//print the pagetable info
vmprint(p->pagetable);
return argc; // this ends up in a0, the first argument to main(argc, argv)
bad:
if(pagetable)
proc_freepagetable(pagetable, sz);
if(ip){
iunlockput(ip);
end_op();
}
return -1;
}
###替换 copyin、copyinstr 实现
// kernel/vm.c
// 声明新函数原型
int copyin_new(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len);
int copyinstr_new(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max);
// 将 copyin、copyinstr 改为转发到新函数
int
copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len)
{
return copyin_new(pagetable, dst, srcva, len);
}
int
copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max)
{
return copyinstr_new(pagetable, dst, srcva, max);
}
运行 grade,需要通过的话,我们可能要手动创建time.txt和answers-pgtbl.txt文件
License:
CC BY 4.0