MIT 6.S081 2020 Lab3 page tables 个人全流程

零、写在前面

1、关于页表

页表的根本概念及原理见：主存储器管理
关于 Cache、TLB见：第五章具体梳理
这里举行扼要介绍。
页式存储管理将物理内存和假造内存划分为等长固定大小的页(Page)，通过一张大概多张**页表(Page Table)来记载假造页和物理页之间的映射(Mapping)**关系。
2、RISC-V Rv39页表机制

RISC-V 支持 32、39、48、57 和 64 多种分页方式，本实验的 xv6 则是采用的Rv39：

• 假造地址(Virtual Address) 空间为39位，即单个历程最大可寻址 2^39 / 2^30 = 2^9 = 512 GB 的内存
  
• 56 位的 **物理地址(Physical Address)**空间，即 39位的 假造地址会被转换为 56位的物理地址
  
• 三级页表结构，每级页表包含 512 个页表项(PTE, Page Table Entry)，每个页表项为 64 字节
  
  
  
  • 每张表占用 64 * 512 = 4096 = 4KB 的内存
    
  • 每个历程有三张表，统共需要12KB的内存
    
  
  
• 每页大小为4KB，同时还支持 2MB 和 1GB 的大页模式，但是 xv6 并未采用
  

页表图如下，按照树形结构组织：

3、假造地址设计

1. 63        39 38        30 29        21 20        12 11         0
2. +------------+------------+------------+------------+------------+
3. |    保留位   |   VPN[2]   |   VPN[1]   |   VPN[0]   |   页内偏移  |
4. +------------+------------+------------+------------+------------+

复制代码

• 第 63~39 位：前25位为保存位，无用
  
• 第 38~30 位：9位，2^9 = 512，代表在 第二级页表 中的索引值(VPN[2])
  
• 第 29-21 位：在 第一级页表 中的下标索引(VPN[1])
  
• 第 20-12位：在 零级页表 中的索引(VPN[0])。
  
• 第 11-0 位：共 12 位，体现 页内偏移，2^12=4096，保证能够访问到页内的每一个 字节。
  

4、页表项设计

RISC-V Sv39 有 三级页表，每张 页表 都包含 512 个 页表项(PTE)，这里介绍下 页表项（PTE） 的物理结构

1. 63        54 53                              10 9    8 7 6 5 4 3 2 1 0
2. +------------+----------------------------------+------+-+-+-+-+-+-+-+-+
3. |   保留位    |              44位物理地址          | RSW  |D|A|G|U|X|W|R|V|
4. +------------+----------------------------------+------+-+-+-+-+-+-+-+-+

复制代码

RISC-V 64位 页表项 在不同的 分页模式 下有不同的结构，由于 xv6 没有效到 RISC-V Sv39 的 大页模式，所以，我们这里也只介绍 Sv39 4KB 的 页表项 结构：

• V：即Valid，有效位，体现该PTE是否有效
  
• R：Readable，可读
  
• W：Writable，可写
  
• X：Executable，可执行
  
• U：User，用户模式可访问
  
• 本实验不涉及 G, A, D, RSW 标记位，所以先略
  
• 10~53位：下一级页表 大概 假造内存 的物理地址
  
  
  
  • 对于怎样使用PTE中44位的地址得到56位的地址也是OS / 计组课程中必不可少的内容了
    
  • 这44位实际上是 56位 地址的高44位，访问 下一级页表 的时候我们把低12位置零
    
  • 如果访问到零级页表，我们把12位页内偏移和该44位地址拼接即可得到假造地址对应的物理地址
    
  • 怎样得到12位页内偏移？——即假造地址的低12位。
    
  
  

5、访存流程

SATP 64寄存器用来控制是否开启分页，高4位 为 mode 位，为 0 体现关闭分页，为 8 体现启用 Sv39 模式

• 当 mode = 0，体现 MMU(Memory Mapping Unit，内存映射部件) 处于 直通(pass-through) 模式，所有地址视为物理地址，直接转给 访存部件处理。
  
  
  
  • 访存部件完成读操作后，将数据写入 数据总线，然后通过 控制总线 关照 CPU
    
  
  
• 当 mode = 8，CPU 执行的所有访存都是假造地址，MMU 借助页表(当然也可能会有TLB的辅助)完成假造地址转换
  
  
  
  • 读L2页表，得到L1页表地址
    
  • 读L1页表，得到 L0页表地址
    
  • 读L0页表，和页内地址偏移拼接得到物理地址
    
  • 访存部件去查找对应内容（Cache / 内存）
    
  
  

Sv39 中 SATP的位布局：
位数名称说明63MODE地址转换模式（0=裸模式，8=Sv39）62:44ASID地址空间标识符（Address Space ID）43:0PPN页表的物理页号（Page-Table Physical Page Number）43~0 即根页表的物理地址。
6、xv6 的页表切换

顶级页表放在哪？
xv6 中 页表是 pagetable_t 类型的指针，定义在 riscv.h 中

1. // kernel/riscv.h
2. typedef uint64 *pagetable_t;  // 512 PTEs

复制代码

内核的顶级页表在 kernel/proc.c 中定义，用户页表则存放在 proc 结构体的字段中

1. // kernel/proc.c
2. extern pagetable_t kernel_pagetable; // kernel page table
4. // kernel/proc.h
5. struct proc {
6.   pagetable_t pagetable;       // User page table
7. };

复制代码

切换历程的时候，需要重新设置 satp 寄存器，同步切换 页表

1. // kernel/proc.c
3. void scheduler(void)
4. {
5.   struct proc *p;
6.   struct cpu *c = mycpu();
7.   
8.   c->proc = 0;
9.   for(;;){
10.     // ...
11.     for(p = proc; p < &proc[NPROC]; p++) {
12.       acquire(&p->lock);
13.       if(p->state == RUNNABLE) {
14.         // 切换到新进程
15.         p->state = RUNNING;
16.         c->proc = p;
17.         w_satp(MAKE_SATP(p->pagetable));  // 把新进程的顶级页表设置到 satp 寄存器
18.         sfence_vma(); // 刷新 TLB
19.         swtch(&c->context, &p->context);
20.         // ...
21.       }
22.       release(&p->lock);
23.     }
24.   }
25. }

复制代码

7、页表遍历

实在就是用软件方法来模拟 MMU 对于页表的遍历，实现在 xv6 的walk函数中

1. // kernel/vm.c
3. pte_t *walk(pagetable_t pagetable, uint64 va, int alloc)
4. {
5.   // 遍历三级页表
6.   for(int level = 2; level > 0; level--) {
7.     // 1. 从虚拟地址中提取VPN索引
8.     pte_t *pte = &pagetable[PX(level, va)];
9.    
10.     // 2. 检查PTE是否有效
11.     if(*pte & PTE_V) {
12.       // 有效，获取下一级页表地址
13.       pagetable = (pagetable_t)PTE2PA(*pte);
14.     } else {
15.       // 无效，需要分配新页表
16.       if(!alloc || (pagetable = (pte_t*)kalloc()) == 0)
17.         return 0;
18.       memset(pagetable, 0, PGSIZE);
19.       *pte = PA2PTE((uint64)pagetable) | PTE_V;
20.     }
21.   }
22.   
23.   // 3. 返回最后一级页表项的地址
24.   return &pagetable[PX(0, va)];
25. }

复制代码

下面是实验流程，注意切换分支到 pgtbl
其次，2021 的lab 不知道为什么第一个assignment 启动时的顶级页表地址和要求的不一样导致一直无法通过test，所以我换成了2020的lab

---

一、Print a page table

1.1 说明

为了帮助你更好地了解 RISC-V 的页表，以及未来的调试，这个任务要求编写一个函数来打印页表内容。

• 定义一个vmprint() 函数，它需要吸收一个pagetable_t参数，按照下面描述的格式打印。在 exec.c 的return argc 前面添加 if(p->pid==1) vmprint(p->pagetable)，来打印第一个历程的页表。
  

当你启动 xv6，应该有雷同如下输出，当完成exec()的时候描述第一个历程的页表

1. page table 0x0000000087f6e000
2. ..0: pte 0x0000000021fda801 pa 0x0000000087f6a000
3. .. ..0: pte 0x0000000021fda401 pa 0x0000000087f69000
4. .. .. ..0: pte 0x0000000021fdac1f pa 0x0000000087f6b000
5. .. .. ..1: pte 0x0000000021fda00f pa 0x0000000087f68000
6. .. .. ..2: pte 0x0000000021fd9c1f pa 0x0000000087f67000
7. ..255: pte 0x0000000021fdb401 pa 0x0000000087f6d000
8. .. ..511: pte 0x0000000021fdb001 pa 0x0000000087f6c000
9. .. .. ..510: pte 0x0000000021fdd807 pa 0x0000000087f76000
10. .. .. ..511: pte 0x0000000020001c0b pa 0x0000000080007000

复制代码

第一行是 vmprint 的参数，随后每一行对应一个页表项，包罗指向页表树更深层的页的PTE。每一行 PTE 都以多少个 .. 缩进，.. 的数量体现它在树中的深度。每一行 PTE 都展示了他在页表中的索引，pte 位 以及从 PTE中提取的物理地址。不要打印无效PTE。在上面的例子中，顶层页表页包含了索引 0 和 255 的映射。对于索引 0，下一级页表页只映射了索引 0，而该索引 0 的最底层页表页映射了索引 0、1 和 2。
你的代码输出的物理地址可能和上面不同，但是条目数目和假造地址应该雷同。
官网的一些提示：

• 可以把 vmprint() 放在 kernel/vm.c.
  
• 可以使用在 kernel/riscv.h 末尾的宏
  
• 函数 freewalk 或许会对你有所开导
  
• 在kernel/defs.h 中声明 vmprint 以便于在 exec.c 中调用
  
• 在 %p 格式控制符可以打印十六进制 PTE的64位地址
  

1.2 实现

先在 defs.h 添加声明：

vmprint的实现

• 由于页表是树形组织，所以考虑前序遍历即可
  
• 注意缩进格式
  

1. void vmprint_PreOrder_dfs(pagetable_t pagetable, int d) {
2.     // 4092 = 512 PTES
3.     for (int i = 0; i < 512; i++) {
4.         pte_t pte = pagetable[i];
5.         // valid
6.         if (pte & PTE_V) {
7.             // 打印缩进
8.             for (int j = 0; j < d; j++) {
9.                 printf(".. ");
10.             }
12.             uint64 pa = PTE2PA(pte);
13.             printf("..%d: pte %p pa %p\n", i, pte, pa);
15.             if ((pte & (PTE_R | PTE_W | PTE_X)) == 0) {
16.                 vmprint_PreOrder_dfs((pagetable_t) pa, d + 1);
17.             }
18.         }
19.     }
20. }
22. void vmprint(pagetable_t pagetable) {
23.     printf("page table %p\n", pagetable);
24.     vmprint_PreOrder_dfs(pagetable, 0);
25. }

复制代码

添加 vmprint 的调用

测试
脚本测试：

qemu运行：

二、A kernel page table per process

2.1 说明

Xv6 只有一个内核页表，在执行内核代码时都会使用这个页表。内核页表是一个对物理地址的直接映射，因此内核假造地址 x 会映射到物理地址 x。Xv6 还为每个历程的用户地址空间维护一个独立的页表，该页表仅包含该历程用户内存的映射，起始于假造地址 0。由于内核页表不包含这些映射，用户地址在内核中是无效的。因此，当内核需要使用系统调用中传入的用户指针（比方传递给 write() 的缓冲区指针）时，必须首先将该指针转换为物理地址。本节及下一节的目的是让内核能够直接解引用用户指针。
你的第一个任务是修改内核，使每个历程在执行内核代码时都使用自己独立的内核页表副本。你需要修改 struct proc 来为每个历程维护一个内核页表，并修改调度器，在切换历程时切换内核页表。在此阶段，每个历程的内核页表应与当前全局的内核页表完全雷同。如果 usertests 能够正常运行，你就完成了这一部分的实验。
阅读本作业开头提到的册本章节和代码；理解假造内存的工作方式会更容易正确地修改相关代码。页表设置中的错误可能会导致陷阱（trap），原因是缺失映射，也可能导致读写操作影响到料想之外的物理内存页，乃至可能导致指令从错误的内存页中被执行。
官网的一些提示：

• 在 struct proc 中添加一个字段，用于存储历程的内核页表。
  
• 一种为新历程生成内核页表的公道方法是，实现一个修改版的 kvminit，它生成一个新的页表而不是修改 kernel_pagetable。你应该从 allocproc 中调用该函数。
  
• 确保每个历程的内核页表中都包含该历程内核栈的映射。在未经修改的 xv6 中，所有内核栈都是在 procinit 中设置的。你需要将这部分或全部功能移动到 allocproc 中。
  
• 修改 scheduler()，将历程的内核页表加载到 CPU 内核的 satp 寄存器中（可以参考 kvminithart 的实现）。不要忘记在调用 w_satp() 后调用 sfence_vma()。
  
• 当没有历程运行时，scheduler() 应该使用 kernel_pagetable。
  
• 在 freeproc 中开释历程的内核页表。
  
• 你需要一种开释页表而不开释其叶子节点（即物理页）的方法。
  
• vmprint 可能会对调试页表有所帮助。
  
• 修改 xv6 的函数或添加新函数是允许的；你可能至少需要在 kernel/vm.c 和 kernel/proc.c 中如许做。（但不要修改 kernel/vmcopyin.c、kernel/stats.c、user/usertests.c 和 user/stats.c。）
  
• 缺失的页表映射可能会导致内核发生页错误，它会打印一条错误消息，其中包罗雷同 sepc=0x00000000XXXXXXXX 的内容。你可以在 kernel/kernel.asm 中搜索 XXXXXXXX 来找到出错的位置。
  

2.2 初始化 / 映射相关

• 我们阅读下 procinit会发现历程块初始化的时候都预留了一页大小的栈空间
  
• 我们需要把这部分内容移动到 allocproc 中，所以我们注释掉栈空间分配的代码即可
  
• 即不在初始化的时候提前预留栈空间，而是历程创建的时候再创建栈空间
  

1. // initialize the proc table at boot time.
2. void procinit(void)
3. {
4.   struct proc *p;
6.   initlock(&pid_lock, "nextpid");
7.   for(p = proc; p < &proc[NPROC]; p++) {
8.       initlock(&p->lock, "proc");
10.       // Allocate a page for the process's kernel stack.
11.       // Map it high in memory, followed by an invalid
12.       // guard page.
13. //      char *pa = kalloc();
14. //      if(pa == 0)
15. //        panic("kalloc");
16. //      uint64 va = KSTACK((int) (p - proc));
17. //      kvmmap(va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
18. //      p->kstack = va;
19.   }
20.   kvminithart();
21. }

复制代码

然后我们发现有几个映射相关的函数：

• kvmmap：添加映射关系到内核页表
  
  
  
  • 1. // add a mapping to the kernel page table.
    2. // only used when booting.
    3. // does not flush TLB or enable paging.
    4. void
    5. kvmmap(uint64 va, uint64 pa, uint64 sz, int perm)
    6. {
    7.   if(mappages(kernel_pagetable, va, sz, pa, perm) != 0)
    8.     panic("kvmmap");
    9. }

    复制代码
  • 发现它默认把这个映射加到内核页表，这显然不是我们想要的
    
  • 为了提高泛用性，我们实现一个函数vmmap，来支持对任意页表添加映射
    
  
  
• kvmpa：从内核页表查询假造地址对应的物理地址
  
  
  
  • 1. // translate a kernel virtual address to
    2. // a physical address. only needed for
    3. // addresses on the stack.
    4. // assumes va is page aligned.
    5. uint64
    6. kvmpa(uint64 va)
    7. {
    8.   uint64 off = va % PGSIZE;
    9.   pte_t *pte;
    10.   uint64 pa;
    11.   
    12.   pte = walk(kernel_pagetable, va, 0);
    13.   if(pte == 0)
    14.     panic("kvmpa");
    15.   if((*pte & PTE_V) == 0)
    16.     panic("kvmpa");
    17.   pa = PTE2PA(*pte);
    18.   return pa+off;
    19. }

    复制代码
  • 这显然也不是我们想要的，我们需要给这个函数添加页表参数，由于只有内核页表是全局变量
    
  
  
• kvminit：创建内核页表
  
  
  
  • 1. /*
    2. * create a direct-map page table for the kernel.
    3. */
    4. void
    5. kvminit()
    6. {
    7.   kernel_pagetable = (pagetable_t) kalloc();
    8.   memset(kernel_pagetable, 0, PGSIZE);
    10.   // uart registers
    11.   kvmmap(UART0, UART0, PGSIZE, PTE_R | PTE_W);
    13.   // virtio mmio disk interface
    14.   kvmmap(VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
    16.   // CLINT
    17.   kvmmap(CLINT, CLINT, 0x10000, PTE_R | PTE_W);
    19.   // PLIC
    20.   kvmmap(PLIC, PLIC, 0x400000, PTE_R | PTE_W);
    22.   // map kernel text executable and read-only.
    23.   kvmmap(KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);
    25.   // map kernel data and the physical RAM we'll make use of.
    26.   kvmmap((uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);
    28.   // map the trampoline for trap entry/exit to
    29.   // the highest virtual address in the kernel.
    30.   kvmmap(TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);
    31. }

    复制代码
  • 这个函数的意义在于为我们提供了创建页表需要做的工作，我们可以直接copy
    
  • 我们实现函数kvminit 来实现对任意页表的初始化，这需要借助我们前面实现的vmmap函数
    
  
  

知道要做什么后，我们就可以动手实现：
先在 defs.h 中修改/添加函数定义：

• <img alt="image-20250511203652996" />
  
  
• 
  
  
• 
  
  

vvminit实现

• 我们把原来的kvminit 那边的代码copy过来，让后让 kvminit 调用 vminit
  
• 值得注意的是，对于 CLINT 的映射，只放到内核页表中
  
• CLINT 代表的是硬件寄存器被映射到的基内存地址，提供了访问硬件的入口点，十分重要。
  

1. /*
2. * create a direct-map page table for the kernel.
3. */
4. void kvminit() {
5.     kernel_pagetable = (pagetable_t) kalloc();
6.     vminit(kernel_pagetable);
7. }
9. void vminit(pagetable_t pagetable) {
10.     memset(pagetable, 0, PGSIZE);
12.     // uart registers
13.     vmmap(pagetable, UART0, UART0, PGSIZE, PTE_R | PTE_W);
15.     // virtio mmio disk interface
16.     vmmap(pagetable, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
18.     if (pagetable == kernel_pagetable) {
19.         // CLINT only for kernalpgt
20.         vmmap(pagetable, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
21.     }
23.     // PLIC
24.     vmmap(pagetable, PLIC, PLIC, 0x400000, PTE_R | PTE_W);
26.     // map kernel text executable and read-only.
27.     vmmap(pagetable, KERNBASE, KERNBASE, (uint64) etext - KERNBASE, PTE_R | PTE_X);
29.     // map kernel data and the physical RAM we'll make use of.
30.     vmmap(pagetable, (uint64) etext, (uint64) etext, PHYSTOP - (uint64) etext, PTE_R | PTE_W);
32.     // map the trampoline for trap entry/exit to
33.     // the highest virtual address in the kernel.
34.     vmmap(pagetable, TRAMPOLINE, (uint64) trampoline, PGSIZE, PTE_R | PTE_X);
35. }

复制代码

kvmpa的修改

• 我们为其增加一个页表参数
  
• 将原先代码中查内核页表改为查传入得页表
  

1. // translate a kernel virtual address to
2. // a physical address. only needed for
3. // addresses on the stack.
4. // assumes va is page aligned.
5. uint64
6. kvmpa(pagetable_t  pagetable, uint64 va) {
7.     uint64 off = va % PGSIZE;
8.     pte_t *pte;
9.     uint64 pa;
11.     pte = walk(pagetable, va, 0);
12.     if (pte == 0)
13.         panic("kvmpa");
14.     if ((*pte & PTE_V) == 0)
15.         panic("kvmpa");
16.     pa = PTE2PA(*pte);
17.     return pa + off;
18. }

复制代码

由于kvmpa 定义修改了，所以要在调用出也都加以修改：
在 virtio_disk.c 中有一处调用：

• 修改为使用 用户内核页表 来查询地址
  

1. ...
2. #include "virtio.h"
3. #include "proc.h" // 导入
5. void
6. virtio_disk_rw(struct buf *b, int write)
7. {
8.   uint64 sector = b->blockno * (BSIZE / 512);
9.   
10.   ...
11.   buf0.sector = sector;
13.   // buf0 is on a kernel stack, which is not direct mapped,
14.   // thus the call to kvmpa().
15.   disk.desc[idx[0]].addr = (uint64) kvmpa(myproc()->kpgtbl, (uint64) &buf0);
16. }

复制代码

vmmap的实现

• 把 kvmmap 的代码拿过来，然后注意对 内核页表的环境特判一下
  

1. int vmmap(pagetable_t pagetable, uint64 va, uint64 pa, uint64 sz, int perm) {
2.     if (mappages(pagetable, va, sz, pa, perm) != 0) {
3.         if(pagetable == kernel_pagetable){
4.             panic("vmmap");
5.         }
6.         return -1;
7.     }
8.     return 0;
9. }

复制代码

2.3 用户内核页表的创建和回收

由于原先历程创建时并未创建用户内核页表，所以我们还要添加用户内核页表的创建和回收的逻辑：

• 定义函数 createUsrpgt 来创建并初始化用户内核页表
  
• 在 allocproc() 中创建历程时
  
  
  
  • 调用新增的 createUsrpgt() 同步创建用户内核页表
    
  • 为新历程分配一页 内核栈空间，并将这页内存 映射 到 用户内核页表，用于执行内核代码
    
  
  
• 在 freeproc() 中，增加开释 用户内核页表 和 栈空间 的逻辑
  

先添加定义：

createUsrpgt 的实现

1. // create user pagetable and initialize
2. pagetable_t createUsrpgt() {
3.     pagetable_t res = (pagetable_t) kalloc();
4.     vminit(res);
5.     return res;
6. }

复制代码

freeUsrpgt 的实现
我们直接两重for循环去开释即可，末了把顶级页表也开释了

1. void freeUsrpgt(pagetable_t pagetable) {
2.     // 512 PTES for each pgt
3.     for(int i = 0; i < 512; ++ i){
4.         // level-1 page table entry
5.         pte_t l1pte = pagetable[i];
6.         if((l1pte & PTE_V) && (l1pte & (PTE_R | PTE_W | PTE_X)) == 0){
7.             uint64 l1ptepa = PTE2PA(l1pte);
8.             for(int j = 0; j < 512; ++ j){
9.                 // level-0 page table entry
10.                 pte_t l0pte = ((pagetable_t)l1ptepa)[j];
11.                 if((l0pte & PTE_V) && (l0pte & (PTE_R | PTE_W | PTE_X)) == 0){
12.                     kfree((void*)PTE2PA(l0pte));
13.                 }
14.             }
15.             kfree((void*)l1ptepa);
16.         }
17.     }
18.     // level-2 page table
19.     kfree(pagetable);
20. }

复制代码

末了我们只需为历程控制块添加用户内核页表成员变量，在历程的创建和开释函数中调用我们书写的逻辑即可：

allocproc()的修改：

1. // allocproc
2. static struct proc *allocproc(void)
3. {
4.   // ...
5.   // An empty user page table.
6.   p->pagetable = proc_pagetable(p);
7.   if(p->pagetable == 0){
8.     freeproc(p);
9.     release(&p->lock);
10.     return 0;
11.   }
13.   // create pgt
14.   if((p->kpgtbl = createUsrpgt()) == 0){
15.       freeproc(p);
16.       release(&p->lock);
17.       return 0;
18.   }
20.   char *pa = kalloc();
21.   if(pa == 0) {
22.       freeproc(p);
23.       release(&p->lock);
24.       return 0;
25.   }
26.   uint64 va = KSTACK((int)0);
27.   if(vmmap(p->kpgtbl, va, (uint64)pa, PGSIZE, PTE_R | PTE_W) !=0){
28.       kfree((void*)pa);
29.       freeproc(p);
30.       release(&p->lock);
31.       return 0;
32.   }
33.   p->kstack = va;
35.   return p;
36. }

复制代码

freeproc() 的修改：

1. // free a proc structure and the data hanging from it,
2. // including user pages.
3. // p->lock must be held.
4. static void freeproc(struct proc *p)
5. {
6.   // ...
7.   if(p->pagetable)
8.     proc_freepagetable(p->pagetable, p->sz);
9.   p->pagetable = 0;
11.   void *kstack_pa = (void *)kvmpa(p->kpgtbl, p->kstack);
12.   kfree(kstack_pa);
14.   // free pgt
15.   if(p->kpgtbl)
16.       freeukpgtbl(p->kpgtbl);
17.   p->kpgtbl = 0;
18.   // ...
19. }

复制代码

2.4 历程切换 / 页表加载

根据官网提示的内容，

• 在 scheduler() 函数中，当切换到一个历程时，加载该历程的 用户内核页表
  
• 当切换回调度器时，规复全局 内核页表
  

1. // Per-CPU process scheduler.
2. // Each CPU calls scheduler() after setting itself up.
3. // Scheduler never returns.  It loops, doing:
4. //  - choose a process to run.
5. //  - swtch to start running that process.
6. //  - eventually that process transfers control
7. //    via swtch back to the scheduler.
8. void scheduler(void)
9. {
10.     // ...
11.     if(p->state == RUNNABLE) {
12.         // Switch to chosen process.  It is the process's job
13.         // to release its lock and then reacquire it
14.         // before jumping back to us.
15.         p->state = RUNNING;
16.         c->proc = p;
18.         // switch the pgt
19.         w_satp(MAKE_SATP(p->kpgtbl));
20.         sfence_vma();
22.         swtch(&c->context, &p->context);
24.         // revert
25.         w_satp(MAKE_SATP(kernel_pagetable));
26.         sfence_vma();
28.         // Process is done running for now.
29.         // It should have changed its p->state before coming back.
30.         c->proc = 0;
32.         found = 1;
33.     }
34.         // ...
35. }

复制代码

我们最终测试一下：
运行QEMU，输入 usertests

三、Simplify copyin/copyinstr

3.1 说明

内核的 copyin 函数会读取由用户指针指向的内存。它通过将这些指针转换为物理地址来实现这一点，如许内核就可以直接解引用它们。该转换是通过软件方式遍历历程的页表来完成的。本实验的这一部分任务是：为每个历程的内核页表（在上一节中已创建）添加用户地址映射，以便 copyin（以及相关的字符串函数 copyinstr）可以直接解引用用户指针。
将 kernel/vm.c 中 copyin 的函数体替换为调用 copyin_new（定义在 kernel/vmcopyin.c 中）；对 copyinstr 和 copyinstr_new 也做同样的替换。为每个历程的内核页表添加用户地址的映射，以便 copyin_new 和 copyinstr_new 能够正常工作。
该方案依赖于用户假造地址范围与内核自身使用的指令和数据假造地址范围不重叠。Xv6 为用户地址空间使用从零开始的假造地址，荣幸的是，内核的内存从更高的地址开始。然而，这也限定了用户历程的最大大小必须小于内核使用的最低假造地址。在内核启动后，该地址为 0xC000000，即 PLIC 寄存器的地址；参见 kernel/vm.c 中的 kvminit()、kernel/memlayout.h，以及课本中的图 3-4。你需要修改 xv6，以防止用户历程的大小超过 PLIC 的地址。
官网的一些提示：

• 首先将 copyin() 替换为对 copyin_new() 的调用，并使其运行正常，然后再处理 copyinstr。
  
• 每当内核改变一个历程的用户页表映射时，也要同步修改该历程的内核页表。如许的地方包罗 fork()、exec() 和 sbrk()。
  
• 不要忘了在 userinit 中，也要将第一个历程的用户页表包含到它的内核页表中。
  
• 用户地址在历程的内核页表中的页表项（PTE）应该具有什么权限？（带有 PTE_U 标志的页在内核模式下是无法访问的。）
  
• 不要忽视上面提到的 PLIC 限定。
  
• Linux 使用了一种雷同你将要实现的技能。直到几年前，许多内核都在用户态和内核态使用雷同的每历程页表，即同时映射用户地址和内核地址，以避免在用户态和内核态之间切换时更换页表。然而，这种设计允许了像 Meltdown 和 Spectre 如许的侧信道攻击。
  

3.2 copyin_new / copyinstr_new

添加两个函数的声明：

按照官网提示，我们将原来的函数实现放到新函数中，然后在老函数调用新函数：

1. int copyin(pagetable_t pagetable, char *dst, uint64 srcva, uint64 len) {
2. //    uint64 n, va0, pa0;
3. //
4. //    while (len > 0) {
5. //        va0 = PGROUNDDOWN(srcva);
6. //        pa0 = walkaddr(pagetable, va0);
7. //        if (pa0 == 0)
8. //            return -1;
9. //        n = PGSIZE - (srcva - va0);
10. //        if (n > len)
11. //            n = len;
12. //        memmove(dst, (void *) (pa0 + (srcva - va0)), n);
13. //
14. //        len -= n;
15. //        dst += n;
16. //        srcva = va0 + PGSIZE;
17. //    }
18. //    return 0;
19.     return copyin_new(pagetable, dst, srcva, len);
20. }
22. // Copy a null-terminated string from user to kernel.
23. // Copy bytes to dst from virtual address srcva in a given page table,
24. // until a '\0', or max.
25. // Return 0 on success, -1 on error.
26. int copyinstr(pagetable_t pagetable, char *dst, uint64 srcva, uint64 max) {
27. //    uint64 n, va0, pa0;
28. //    int got_null = 0;
29. //
30. //    while (got_null == 0 && max > 0) {
31. //        va0 = PGROUNDDOWN(srcva);
32. //        pa0 = walkaddr(pagetable, va0);
33. //        if (pa0 == 0)
34. //            return -1;
35. //        n = PGSIZE - (srcva - va0);
36. //        if (n > max)
37. //            n = max;
38. //
39. //        char *p = (char *) (pa0 + (srcva - va0));
40. //        while (n > 0) {
41. //            if (*p == '\0') {
42. //                *dst = '\0';
43. //                got_null = 1;
44. //                break;
45. //            } else {
46. //                *dst = *p;
47. //            }
48. //            --n;
49. //            --max;
50. //            p++;
51. //            dst++;
52. //        }
53. //
54. //        srcva = va0 + PGSIZE;
55. //    }
56. //    if (got_null) {
57. //        return 0;
58. //    } else {
59. //        return -1;
60. //    }
61.     return copyinstr_new(pagetable, dst, srcva, max);
62. }

复制代码

3.3 用户页表拷贝到用户内核页表‘

添加函数 u2kvmcopy 声明，该函数负责拷贝用户页表到用户内核页表：

然后实现：

• 函数从 begin 开始，以页为单位（PGSIZE）遍历到 end ，为每一页创建映射。
  
• 使用 walk() 函数去用户页表内里，找假造地址 i 对应的页表项（PTE），检查该页表项是否存在，以及该页是否有效。
  
• 拿到pte后我们进一步得到物理地址pa
  
• unset 掉 PTE_U 位，由于内核页表不能被用户访问
  
• 调用 mappages() 把 pa 映射到 用户内核页表 即可，这一步执行完以后，satp 中的根页表设置为 用户内核页表，如许也可以访问用户内存了。
  

1. int u2kvmcopy(pagetable_t upgtbl, pagetable_t kpgtbl, uint64 begin, uint64 end)
2. {
3.     pte_t *pte;
4.     uint64 pa, i;
5.     uint flags;
7.     for(i = begin; i < end; i += PGSIZE){
8.         if((pte = walk(upgtbl, i, 0)) == 0)
9.             panic("uvmmap_copy: pte should exist");
10.         if((*pte & PTE_V) == 0)
11.             panic("uvmmap_copy: page not present");
12.         pa = PTE2PA(*pte);
13.         // unset PTE_U because dest is kernal
14.         flags = PTE_FLAGS(*pte) & (~PTE_U);
15.         if(mappages(kpgtbl, i, PGSIZE, pa, flags) != 0){
16.             uvmunmap(kpgtbl, 0, i / PGSIZE, 0);
17.             return -1;
18.         }
19.     }
20.     return 0;
21. }

复制代码

3.4 同步映射

在创建（fork、exec）、修改（growproc）用户空间页表时，调用 u2kvmcopy() 把新增或修改的用户页表内容，同步 映射 到用户内核页表中。

• fork()
  

1. -   ```c
2.     // Create a new process, copying the parent.
3.     // Sets up child kernel stack to return as if from fork() system call.
4.     int fork(void)
5.     {
6.       //...
7.       // Copy user memory from parent to child.
8.       if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
9.         freeproc(np);
10.         release(&np->lock);
11.         return -1;
12.       }
13.       np->sz = p->sz;
14.    
15.       // copy pgt of np to user kernal pgt
16.       if (u2kvmcopy(np->pagetable, np->kpgtbl, 0, np->sz) < 0) {
17.           freeproc(np);
18.           release(&np->lock);
19.           return -1;
20.       }
21.    
22.       np->parent = p;
23.       //
24.     }
25.     ```

复制代码

• exec()
  
  
  
  • 1. int exec(char *path, char **argv)
    2. {
    3.   ...
    4.   // Save program name for debugging.
    5.   for(last=s=path; *s; s++)
    6.     if(*s == '/')
    7.       last = s+1;
    8.   safestrcpy(p->name, last, sizeof(p->name));
    10.   // remove the former mappings
    11.   uvmunmap(p->kpgtbl, 0, PGROUNDUP(oldsz) / PGSIZE, 0);
    12.   // copy the new pgt to kernal pgt
    13.   if (u2kvmcopy(pagetable, p->kpgtbl, 0, sz) < 0) {
    14.       goto bad;
    15.   }
    17.   // Commit to the user image.
    18.   oldpagetable = p->pagetable;
    19.   p->pagetable = pagetable;
    20.   ...
    21. }

    复制代码
  
  
• growproc()
  
  
  
  • 1. int growproc(int n)
    2. {
    3.   uint sz;
    4.   struct proc *p = myproc();
    6.   sz = p->sz;
    8.   // can't exceed PLIC
    9.   if(n > 0 && sz + n >= PLIC)
    10.       return -1;
    12.   uint oldsz = sz;
    14.   if(n > 0){
    15.     if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
    16.       return -1;
    17.     }
    18.     // add new memory mapping to kpgtbl after malloc
    19.     u2kvmcopy(p->pagetable, p->kpgtbl, PGROUNDUP(oldsz), sz);
    20.   } else if(n < 0){
    21.     sz = uvmdealloc(p->pagetable, sz, sz + n);
    22.     // likewise, remove map after free
    23.     uvmunmap(p->kpgtbl, PGROUNDUP(sz), (PGROUNDUP(oldsz) - PGROUNDUP(sz)) / PGSIZE, 0);
    24.   }
    25.   p->sz = sz;
    26.   return 0;
    27. }

    复制代码
  
  
• userinit
  
  
  
  • 官网提示了要在 userinit 这里把第一个用户历程特殊处理，由于第一个用户历程是用户空间第一个历程，内核代码初始化完成了以后直接跳转，并没有调用fork 和 exec
    
  • 1. // Set up first user process.
    2. void
    3. userinit(void)
    4. {
    5.   ...
    6.   // allocate one user page and copy init's instructions
    7.   // and data into it.
    8.   uvminit(p->pagetable, initcode, sizeof(initcode));
    9.   p->sz = PGSIZE;
    11.   // first user process map user pgt to kernal pgt
    12.   if (u2kvmcopy(p->pagetable, p->kpgtbl, 0, PGSIZE) < 0)
    13.     panic("userinit: u2kvmcopy");
    15.   // prepare for the very first "return" from kernel to user.
    16.   p->trapframe->epc = 0;      // user program counter
    17.   p->trapframe->sp = PGSIZE;  // user stack pointer
    18.   ...
    19. }

    复制代码
  
  
• 在 vminit 中对CLINT特判，由于 CLINT 已经映射到用户内核页表，如果重复对 CLINT映射，会报 remap 重复映射的错误
  
  
  
  • 事实上 CLINT 是每一个CPU核独有的部分，因而除了用户内核页表外，都不能对其映射。
    
  • 1. void vminit(pagetable_t pagetable) {
    2.     memset(pagetable, 0, PGSIZE);
    3.     ...
    4.     // virtio mmio disk interface
    5.     vmmap(pagetable, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
    7.     if (pagetable == kernel_pagetable) {
    8.         // CLINT
    9.         vmmap(pagetable, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
    10.     }
    12.     // PLIC
    13.     vmmap(pagetable, PLIC, PLIC, 0x400000, PTE_R | PTE_W);
    14.     ...
    15. }

    复制代码
  
  

运行测试：
我们运行 make qemu 来测试一下：

也是终于结束了。目前耗时最长的一个lab了qwq

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告