[MIT 6.S081] Lab 3: page tables

已于 2022-08-15 21:15:53 修改
阅读量5.8k 收藏 24
点赞数 19
分类专栏： MIT 6.S081 Labs 文章标签： 操作系统
于 2021-11-15 19:09:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LostUnravel/article/details/121340933
版权

Lab 3: page tables

Print a page table (easy)

要点

  • 不输出无效的 PTE

步骤

  1. 在 kernel/vm.c 中编写函数 vmprint()
    此处可以参考 freewalk() 函数的实现. 对于输出, 此处可以采用循环和递归两种方式实现: 循环的实现即三重循环遍历三级页目录即可; 递归的实现与 freewalk() 函数很相似, 通过其代码可以看到 (PTE_R | PTE_W | PTE_X)) == 0 可以作为判断是否不为最低级页目录的条件, 即对于上两级页目录的 PTE 索引到的内容是下一级页目录的 PTE, 应该均不可读写执行; 而最低级页目录的 PTE 索引到的是一个页表, 其中的内容应该满足读写执行的条件之一, 进而根据该条件作为递归的出口.
  • 循环实现:
// print page tables lab3-1
void vmprint(pagetable_t pagetable) {
    printf("page table %p\n", pagetable);
    // range top page dir
    const int PAGE_SIZE = 512;
    // 遍历最高级页目录
    for (int i = 0; i < PAGE_SIZE; ++i) {
        pte_t top_pte = pagetable[i];
        if (top_pte & PTE_V) {
            printf("..%d: pte %p pa %p\n", i, top_pte, PTE2PA(top_pte));
            // this PTE points to a lower-level page table.
            pagetable_t mid_table = (pagetable_t) PTE2PA(top_pte);
            // 遍历中间级页目录
            for (int j = 0; j < PAGE_SIZE; ++j) {
                pte_t mid_pte = mid_table[j];
                if (mid_pte & PTE_V) {
                    printf(".. ..%d: pte %p pa %p\n",
                           j, mid_pte, PTE2PA(mid_pte));
                    pagetable_t bot_table = (pagetable_t) PTE2PA(mid_pte);
                    // 遍历最低级页目录
                    for (int k = 0; k < PAGE_SIZE; ++k) {
                        pte_t bot_pte = bot_table[k];
                        if (bot_pte & PTE_V) {
                            printf(".. .. ..%d: pte %p pa %p\n",
                                   k, bot_pte, PTE2PA(bot_pte));
                        }
                    }
                }
            }
        }
    }
}
  • 递归实现:
// lab3-1
void vmprinthelper(pagetable_t pagetable, int level) {
    for (int i = 0; i < 512; ++i) {
        pte_t pte = pagetable[i];
        // 判断PTE是否有效
        if (pte & PTE_V) {
            switch(level)
            {
                case 3:
                    printf(".. ");
                case 2:
                    printf(".. ");
                case 1:
                    printf("..%d: pte %p pa %p\n", i, pte, PTE2PA(pte));
            }
            pagetable_t child = (pagetable_t) PTE2PA(pte);
            // 判断是否不为最低级页目录
            if ((pte & (PTE_R | PTE_W | PTE_X)) == 0) {
                vmprinthelper(child, level + 1);
            }
        }
    }
}

// print page tables lab3-1
void vmprint(pagetable_t pagetable) {
    printf("page table %p\n", pagetable);
    vmprinthelper(pagetable,1);
}
  1. 在 kernel/defs.h 文件中添加函数原型
    在这里插入图片描述
  2. 在 kernel/exec.c 的 exec 函数的 return argc 前插入 if(p->pid==1) vmprint(p->pagetable)
    这里考虑 xv6 的启动过程, 推测 pid==1 的进程为 kernel/main.c 中 main() 函数中调用的 userinit() 函数所建立的控制台进程.
    在这里插入图片描述

测试

编译启动 xv6 时即显示如下:
在这里插入图片描述
在这里插入图片描述

思考题

  • Q: Explain the output of vmprint in terms of Fig 3-4 from the text. What does page 0 contain? What is in page 2? When running in user mode, could the process read/write the memory mapped by page 1?
    A:
    根据 exec() 函数和 xv6 指导书可以看到如下代码会为 ELF 文件的段(segment)分配内存并进行加载, 因此推测该内容即为 page 0 所存放的.
    在这里插入图片描述
    根据下端代码的注释可以看到, 在加载 ELF 段后会分配两个 page, 对应 page1 和 page2, 而 page 2 用作用户的栈.
    在这里插入图片描述
    在这里插入图片描述
    进一步根据 图3.4 可以看出, page0 应该主要是应用程序的代码段和数据段; 而 page2 即对应着用户栈; 中间的 page1 应该是 guard page, 无物理地址实际映射, 用于溢出检测.

A kernel page table per process (hard)

要点

  • 每个用户进程有一个独立的内核页表. 这里的内核页表同样是带有三级页目录的页表结构.
  • 修改 struct proc , 并在进程切换时切换到用户进程的内核页表到 STAP 寄存器.
  • 当没有进程运行时使用原本的内核页表 kernel_pagetable

步骤

1. 在 proc 结构体中添加内核页表成员

在 kernel/proc.h 中的 struct proc 结构体中添加成员变量 kpagetable, 代表进程的内核页表. 此外, 该内核页表是进程私有的, 因此置于结构体下半部分.

// 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 kpagetable;      // kernel pagetable - lab3-1
};
2. 构建进程的内核页表的映射函数 proc_kpagetable()
  • 参考 kernel/vm.c 中的 kvminit() 函数, kvminit() 中通过调用 kvmmap() 函数完成 UARTO、VIRTIO0、CLINT 等部分的映射, 其底层是调用的 mappages() 函数, 默认页表为全局的内核页表 kernel_pagetable . 因此此处不能直接调用该函数, 而是需要替换 kvmmap() 函数从而不是构建全局内核页表.
  • 此处同样可以借鉴 kernel/proc.c 中的 proc_pagetable() 函数, 构建页表可以直接复用 uvmcreate() 函数.
  • 接下来考虑 UARTO、VIRTIO0、CLINT 等部分的映射. 通过比较可以看到: 在 kvminit() 中对应构建失败的情况是直接 panic("kvmmap") 引发 panic 终止; 而在 proc_pagetable(), 则是通过 uvmunmap() 和 uvmfree() 来分别取消先前的页表映射和释放页表三级结构, 然后返回 0, 由上层函数处理失败.
    在这里插入图片描述
  • 这里笔者最终选择了类似 kvminit() 的方法. 原因有二:
    1. 一方面内核页表的映射结构比较复杂, 每次在使用 uvmunmap() 取消先前映射时代码比较冗长;
    2. 而更重要的一点是 uvmunmap() 函数的第 3 个参数是 npages, 即需要是页表大小 PGSIZE 的整数倍, 而对于内核的代码段的长度为 etext-KERNBASE 为 0x8000, 不为 PGSIZE 的整数倍, 但 uvmunmap() 要求取消映射的页表中的所有 PTE 必须是有效的, 若不为 PGSIZE 的整数倍则意味着一部分 PTE 不能释放(向下取整), 或者引发 panic (向上取整), 虽然实际上基本该情况基本不会发生, 但本身存在逻辑错误.
      在这里插入图片描述
  • 最终代码首先在 kernel/vm.c 中仿照 kvmmap() 编写了函数 uvmmap(), 区别在于添加了 pagetable_t 的参数, 用于传入进程自身的内核页表结构体.
void uvmmap(pagetable_t pagetable, uint64 va, uint64 pa, uint64 sz, int perm) {
    if(mappages(pagetable, va, sz, pa, perm) != 0) {
        panic("uvmmap");
    }
}
  • 而 proc_kpagetable() 则基本参照 kvminit() 编写即可.
// create a kernel page table for the given process - lab3-2
pagetable_t proc_kpagetable(struct proc *p) {
    // 创建空页表
    pagetable_t kpagetable = uvmcreate();
    if(kpagetable == 0){
        return 0;
    }

    uvmmap(kpagetable, UART0, UART0, PGSIZE, PTE_R | PTE_W);
    uvmmap(kpagetable, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
    uvmmap(kpagetable, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
    uvmmap(kpagetable, PLIC, PLIC, 0x400000, PTE_R | PTE_W);
    uvmmap(kpagetable, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);
    uvmmap(kpagetable, (uint64)etext, (uint64)etext, PHYSTOP-(uint64)etext, PTE_R | PTE_W);
    uvmmap(kpagetable, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);    // 注意va为TRAMPOLINE

    return kpagetable;
}
  • 最后在 kernel/proc.c 的 allocproc() 函数中调用, 该函数如其名称所示, 是用于分配一个进程.
static struct proc*
allocproc(void)
{
  //...
  // An empty user page table.
  p->pagetable = proc_pagetable(p);
  if(p->pagetable == 0){
    freeproc(p);
    release(&p->lock);
    return 0;
  }
  // process's kernel page table - lab3-2
  p->kpagetable = proc_kpagetable(p);
  if (p->kpagetable == 0) {
    freeproc(p);
    release(&p->lock);
    return 0;
  }  
  //...
}
3. 为进程的内核页表添加内核栈的映射
  • 参考 kernel/proc.c 的 procinit() 函数, 其中通过循环遍历进程数组 proc[NPPROC] 中的每个进程, 来为其初始化进程的自旋锁和内核栈. 首先便是将其中为每个进程在全局内核页表中创建内核栈的部分代码注释掉, 因为之后进程的内核栈被映射到了自身的内核页表中了.
// 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");
// lab3-2
//      // 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;
  }
  kvminithart();
}
  • 将上述注释的构建内核栈映射的代码可以直接置于 allocproc() 中来对进程自身内核栈进行映射. 值得一提的是, 由于每个进程有自己的内核页表, 因此不会像全局内核页表一样会有所有进程的内核栈, 因此映射时可以直接固定地址空间. 最终 allocproc() 代码如下:
// 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;
  }

  // process's kernel page table - lab3-2
  p->kpagetable = proc_kpagetable(p);
  if (p->kpagetable == 0) {
    freeproc(p);
    release(&p->lock);
    return 0;
  }
  // Allocate a page for the process's kernel stack. - lab3-2
  char *pa = kalloc();    // 分配页面
  if(pa == 0) {
    panic("kalloc");
  }
  uint64 va = KSTACK(0);
  // 进行虚拟地址和物理地址的映射
  uvmmap(p->kpagetable,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;
}
  • 注: 这里有一个很需要注意的地方, 可以看到 p->context.sp = p->kstack + PGSIZE; 这一行代码设置了内核栈顶指针, 因此在这之前必须保证内核栈已经分配且映射完成. 否则指向就会出错, 运行后 xv6 会卡住.
    在这里插入图片描述
4. 修改进程调度函数加载内核页表到 SATP 寄存器
  • kernel/proc.c 中 scheduler() 函数会在 kernel/main.c 的 main() 的最后调用, 其中有一个死循环, 会一直遍历线程数组 proc[NPROC]选取一个可运行进程进行运行. 选取该进程后会设置进程的状态并切换 CPU 的上下文.
  • 由于原本是使用的全局的内核页表(在 kernel/main.c 的 main() 函数中 调用 kvminithart()设置), 因此当前运行进程时需要同时切换到进程自己的内核页表.
  • 代码直接参考 kvminithart(), 其中 w_satp() 函数用于设置最高级页目录地址的寄存器 SATP, sfence_vam() 用于清空当前 TLB.
  • 同时, 根据要求, 当没有进程运行时使用全局的内核页表. 根据注释, 在 swtch() 之后, 进程已经运行结束, 此时调用 kvminithart() 切换会全局内核页表. 注意, 此处开始认为是当 found==0 时才切换回全局内核页表, 但这样测试的最后一个样例不能通过.
// Per-CPU process scheduler.
// Each CPU calls scheduler() after setting itself up.
// Scheduler never returns.  It loops, doing:
//  - choose a process to run.
//  - 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;
        // load the process's kernel page table - lab3-2
        w_satp(MAKE_SATP(p->kpagetable));
        // flush the TLB - lab3-2
        sfence_vma();
        swtch(&c->context, &p->context);

        // Process is done running for now.
        // use kernel_pagetable when no process is running - lab3-2
//        kvminithart();
        // It should have changed its p->state before coming back.
        c->proc = 0;

        found = 1;
      }
      release(&p->lock);
    }
    if(found == 0) {
        kvminithart();
    }
#if !defined (LAB_FS)
    if(found == 0) {
      intr_on();
      asm volatile("wfi");
    }
#else
    ;
#endif
  }
}
5. 释放内核页表和内核栈
  • 线程释放时会调用 kernel/proc.c 的 freeproc() 函数, 其中会将结构体 struct proc 中的成员变量清零.
  • 此处需要考虑将内核页表包括内核栈的映射进行清空. 按照要求, 内核页表清除映射但不清除物理内存, 而内核栈由于是进程独有, 因此可以连同清除物理内存.
  • 对于内核栈, 由于其是分配在线程的内核页表中的, 因此只需要考虑清除映射以及释放物理内存, 可以直接使用 uvmunmap(), 该函数的第四个参数 do_free 设置为正值, 会将其物理内存同时释放.
  • 对于整个内核页表, 可以参考 proc_freepagetable() 函数进行映射的清除和页表结构的释放. proc_freepagetable() 中和kvminit() 中构建失败的情况是一致的, 通过 uvmunmap() 和 uvmfree() 来分别取消先前的页表映射和释放页表三级结构. 此处可以直接借鉴. 与之前 proc_kpagetable() 不同, 由于此时是对整个内核页表清除映射, 因此可以将内核的代码段(长度 etext-KERNBASE)和数据段、FreeMemory(长度 PHYSTOP-etext)一起释放, 这样其就满足 PGSIZE 整数倍的要求, 便可以使用 uvmunmap() 函数清除映射, 将页面对应的最低级页目录中的 PTE 清零; 然后 uvmfree()会调用 freewalk() 函数将三级页目录结构进行内存释放. 需要说明的是 uvmunmap() 的第 4 个参数 do_free 表征是否释放其物理内存, 以及 uvmfree() 的第 2 个参数表示释放物理内存的大小, 由于需要保留内核地址空间的物理内存的内容, 因此均置零.
// free kernel page table without freeing physical memory - lab3-2
void proc_freekpagetable(pagetable_t kpagetable) {
    uvmunmap(kpagetable, UART0, 1, 0);
    uvmunmap(kpagetable, VIRTIO0, 1, 0);
    uvmunmap(kpagetable, CLINT, 0x10000 / PGSIZE, 0);
    uvmunmap(kpagetable, PLIC, 0x400000 / PGSIZE, 0);
    uvmunmap(kpagetable, KERNBASE, (PHYSTOP - KERNBASE) / PGSIZE, 0);
    uvmunmap(kpagetable, TRAMPOLINE, 1, 0);
    uvmfree(kpagetable, 0);
}
  • 除了上述方法之外, 可以参考 freewalk() 函数之间进行三级页表结构的清除以及页目录内存释放. 与 freewalk() 不同的是, freewalk() 执行前需要通过 uvmunmap() 将最低级页目录的映射清除, 即最低级页目录的 PTE 均为 0, 负责清除前两级页目录的映射结构和三级页目录的物理内存. 而下述代码则是同时将最低级页目录的 PTE 清零.
// free kernel page table without freeing physical memory - lab3-2
void proc_freekpagetable(pagetable_t kpagetable) {
    for(int i = 0; i < 512; i++){
        pte_t pte = kpagetable[i];
        if((pte & PTE_V)){
            kpagetable[i] = 0;    // 对于有效的PTE都清零
            // 递归清除
            if ((pte & (PTE_R|PTE_W|PTE_X)) == 0) {
                uint64 child = PTE2PA(pte);
                proc_freekpagetable((pagetable_t)child);
            }
        }
    }
    kfree((void*)kpagetable);
}
  • 以上两种 proc_kfreepagetable() 均可通过所有测试.
  • freeproc() 代码如下, 还需注意的一点是, 内核栈 p->stack 需要在内核页表 p->kpagetable 之前清除.
// 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;
  // free kernel stack - lab3-2
  if(p->kstack) {
    uvmunmap(p->kpagetable, p->kstack, 1, 1);
  }
  p->kstack = 0;
  // free kernel page table without freeing physical memory - lab3-2
  if(p->kpagetable){
    proc_freekpagetable(p->kpagetable);
  }
  p->kpagetable=0;
  p->state = UNUSED;
}
6. 修改 kvmpa() 函数
  • kvmpa() 函数用于将内核虚拟地址转换为物理地址, 其中调用 walk() 函数时使用了全局的内核页表. 此时需要换位当前进程的内核页表. 修改方法有两种, 一种是直接修改 kvmpa() 内部, 将 walk() 的第一个参数改为 myproc()->kpagetable; 第二种则是将 kvmpa() 的参数增加一个 pagetable_t, 在 kernel/virtio_disk.c 的 virtio_disk_rw() 调用时传入 myproc()->kpagetable. 两种方法效果是一样的, 此处选择了第二种, 主要考虑到未来扩展时可能会使用全局内核页表的情况, 则第一种不能适用.
    在这里插入图片描述
    在这里插入图片描述
  • 注: 该改动在实验指导中并没有提及, 若不进行改动会出现 panic: kvmpa 或者 virtio_disk_intr status 的错误, 使 xv6 卡住.

测试

在 make qemu 启动 xv6 后, 执行 usertests 进行测试的结果:
在这里插入图片描述
在这里插入图片描述

补充

在 Lec 7 Q&A labs 中, 提供了解决该部分实验的两种做法: 一种是"复制(copy)"方法, 另一种是"共享(share)"方法.
上述代码实现的即为"复制"方法, 每个进程是创建了一个完整的内核页表的副本.
而"共享"方法更为巧妙, 这也是 Lec 7 中上课老师所使用的方法. 根据内核页表的组成, 我们可以发现, 在 CLINT 及其之上, 每个进程的内核页表与全局内核页表是一致的(此处考虑进程的内核栈的位置与其在全局内核页表中的位置一致). 因此, 可以不完成的创建内核页表的副本, 对于这些相同的部分完全可以让进程内核页表直接共享全局内核页表的内容, 而只需要创建低地址空间用来映射用户程序的部分(这是下一部分实验). 而对于共享部分, 只需要将全局内核页表的最高级页目录拷贝到进程内核页表的最高级页目录即可, 低两级的页目录就可以直接使用全局内核页表的了. 这样可以减少低两级的页目录的分配和设置, 大幅度简化实验.
这里需要注意的是, 由于最高级页目录 1 个 PTE 对应 0x40000000B 大小的地址空间, 因此低地址空间中 UART0, VIRTIO0, CLINT 以及 PLIC 都是属于一个最高级 PTE 的, 因此该 PTE 对应的下面低级的页目录以及虚拟空间需要单独映射.

pagetable_t proc_kpagetable(struct proc *p) {
    int i;
    // 创建空页表
    pagetable_t kpagetable = uvmcreate();
    if(kpagetable == 0){
        return 0;
    }
    // 0x40000000之上部分与全局内核页表共享
    for(i = 1; i < 512; ++i) {  
        kpagetable[i] = kernel_pagetable[i];
    }
    // 第一个PTE对应的虚拟空间单独映射
    uvmmap(kpagetable, UART0, UART0, PGSIZE, PTE_R | PTE_W);
    uvmmap(kpagetable, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);
    uvmmap(kpagetable, CLINT, CLINT, 0x10000, PTE_R | PTE_W);
    uvmmap(kpagetable, PLIC, PLIC, 0x400000, PTE_R | PTE_W);
    return kpagetable;
}

对于释放进程页表也是一样的, 由于只使用了一个最高级 PTE, 其余均共享的全局内核页表. 因此释放的时候只需要释放第 0 个最高级 PTE 下对应的低级页目录即可(虚拟空间对应的物理内存不释放).

void proc_freekpagetable(pagetable_t kpagetable) {
    pte_t pte = kpagetable[0];    // 第1个PTE
    pagetable_t level1 = (pagetable_t) PTE2PA(pte);    // 第1个PTE对应的中间级页目录
    // 遍历中间级页目录
    for(int i = 0; i < 512; i++){
        pte_t pte = level1[i];    // 中间级 PTE
        if((pte & PTE_V)){
            uint64 level2 = PTE2PA(pte);
            kfree((void*)level2);    // 释放最低级页目录
            level1[i] = 0;
        }
    }
    kfree((void*)level1);    // 释放中间级页目录
    kfree((void*)kpagetable);    // 释放最高级页目录
}

需要额外说明的是, 在上述 #步骤3 中, 注释掉了内核页表中为进程分配的内核栈, 而在这种方式下要保留全局页表中内核栈的分配, 因为进程内核页表中的内核栈直接映射到了全局内核页表中该进程的内核栈.

Simplify copyin/copyinstr (hard)

要点

  • 修改 xv6 以防止进程地址超过内核的 PLIC 地址
  • 使用 copyin_new() 和 copyinstr_new
  • 在进程的内核页表中添加用户地址的映射.
  • 在内核对用户页表映射进行改动时要同时要调整进程的内核页表映射.
  • 注意 PTE_U 用户权限的页表不在内核态访问

思路

通过添加用户地址空间的映射到进程的内核页表, 这样在内核系统调用 copyin() 和 copyinstr() 就不用使用 walk() 函数让操作系统将虚拟地址换为物理地址进行字符拷贝(因为全局内核页表不知道用户地址空间的映射情况); 而是直接通过 MMU 完成虚拟地址到物理地址的转换. 这需要保证用户页表 p->pagetable 变动的同时修改 p->kpagetable, 根据指导书主要修改 fork(), exec(), sbrk() 三个函数.

步骤

1. 编写用户页表拷贝到内核页表的函数 u2kvmcopy()
  • 其可以参考 kernel/vm.c 中的 uvmcopy() 函数, 该函数是在 fork() 时用于将父进程用户页表拷贝到子进程.
  • 此处的 uvmcopy() 在拷贝时并没有使用写时复制, 而是直接分配相应的页面(物理内存)并复制字节. 而将用户页表拷贝到内核页表时, 物理地址空间实际上是不变的, 只是多了一次映射, 因此 u2kvmcopy() 中就没有使用 kalloc() 分配页面, 而是直接复用的 walk() 返回的物理地址.
  • 此外考虑到后面 growproc() 函数的需要, u2kvmcopy()可以设置复制的起始位置(uvmcopy() 直接为 0). 此处对于起始位置需要使用 PGROUND() 向上取整, 因为其向下取整的页面之前已经被映射过了.
  • 另一方面, 指导书中提到, 带有 PTE_U 标志的 PTE 不能被内核访问, 因此需要在拷贝用户页表时, 将 PTE 中的 PTE_U 标志清除掉. 这一点比较难以想到.
  • 在这里有一点需要特别说明, 即调用的 mappages() 函数, 该函数会在发现当前 PTE 重映射时引发 panic. 根据指导书, 内核页表拷贝的用户页表的地址空间不应超过 PLIC 部分, 但是根据实验的第二部分和课程视频中可以看到, PLIC 的低地址处是有一个 CLINT 部分的, 因此在页表复制是可能会引发重映射, 但在最新的 xv6 指导书中会发现内核虚拟地址 PLIC 下面是没有 CLINT部分的. 解决方案有两种, 一个是网上普遍采用的方案, 即重写一个类 mappages() 函数, 注释掉中间的重映射代码 if(*pte & PTE_V) panic("remap");; 另一个方案是将 Lab3-2 中 proc_kpagetable() 函数中为 CLINT 部分创建映射的代码注释掉, 因为其存在重映射的可能, 也就从另一方面说明了该部分应该不会被实际映射. 经过测试两种方法都可通过测试. 这里笔者采用的是第二种方法.
// copy the user page table into its kernel page table from 'begin' to 'end'  - lab3-3
int u2kvmcopy(pagetable_t upagetable, pagetable_t kpagetable, uint64 begin, uint64 end) {
    pte_t *pte;
    uint64 pa, i;
    uint flags;
    uint64 begin_page = PGROUNDUP(begin);    // 向上取整
    for(i = begin_page; i < end; i += PGSIZE){
        if((pte = walk(upagetable, i, 0)) == 0)
            panic("uvmcopy2kvm: pte should exist");
        if((*pte & PTE_V) == 0)
            panic("uvmcopy2kvm: page not present");
        pa = PTE2PA(*pte);
        flags = PTE_FLAGS(*pte) & (~PTE_U); // clear PTE_U flag
        // map to the physical memory same as user's pa instead of kalloc()
        if(mappages(kpagetable, i, PGSIZE, pa, flags) != 0){
            goto err;
        }
    }
    return 0;

err:
    uvmunmap(kpagetable, begin_page, (i- begin_page) / PGSIZE, 0);
    return -1;
}
2. 修改 fork() 函数
  • kernel/proc.c 中的 fork() 函数用于创建子进程, 其中在用户页表从父进程复制到子进程之后, 同样要将子进程的用户页表拷贝到子进程的内核页表, 使用 u2kvmcopy().
  • 需要注意的是, 这里不能使用 uvmcopy() 拷贝父进程的内核页表到子进程, 因为 uvmcopy() 会分配新的页面, 而非指向子进程的用户空间.
// Create a new process, copying the parent.
// Sets up child kernel stack to return as if from fork() system call.
int
fork(void)
{
  // ...
  // Copy user memory from parent to child.
  if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
    freeproc(np);
    release(&np->lock);
    return -1;
  }
  np->sz = p->sz;
  // copy user page table to kernel page table - lab3-3
  if(u2kvmcopy(np->pagetable, np->kpagetable, 0, np->sz) < 0) {
    freeproc(np);
    release(&np->lock);
    return -1;
  }

  np->parent = p;
  // ...
}
3. 修改 exec() 函数
  • kernel/exec.c 中的 exec() 函数用于替换进程镜像, 在替换之后会将原用户页表释放替换为新的用户页表, 因此需要同样更新进程的内核页表.
  • 由于内核页表中虚拟地址实际上指向的也是用户空间的物理地址, 因此不需要像用户页表一样连同物理空间一并释放, 而是使用 uvmunmap() 清除映射, 然后使用 u2kvmcopy() 进行页表的复制.
int
exec(char *path, char **argv)
{
  // ...  
  // 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);

  // unmap old kernel page table, and copy the new one - lab3-3
  uvmunmap(p->kpagetable, 0, PGROUNDUP(oldsz)/PGSIZE, 0);
  if(u2kvmcopy(p->pagetable, p->kpagetable, 0, p->sz) < 0){
      goto bad;
  }

  // print page table - lab3-1
  if (p->pid == 1) {
    vmprint(p->pagetable);
  }
  // ...
}
4. 修改 growproc() 函数
  • sbrk() 函数即系统调用 sys_brk() 函数, 最终会调用 kernel/proc.c 中的 growproc() 函数, 用来增长或减少虚拟内存空间. 根据指导书要求, 要保证用户空间的大小在 PLIC 部分之下, 因此, 在 n>0 时要判断 sz + n > PLIC 的情况, 满足则返回失败. 此处不取等, 是因为 sz+n 是个空间大小, 在与 PLIC 相等时恰好未使用 PLIC 地址.
  • 对于 n>0 时, 则在 uvmalloc() 分配新的内存后, 将新增的用户地址空间使用 u2kvmcopy() 复制到内核页表.
  • 对于 n<0 时, 则需要在 uvmdealloc() 之后连通将内核页表的这部分空间解除映射. 需要注意的是, uvmdealloc() 底层调用的 uvmunmap() 函数是连通物理地址一起释放了, 因此在这了不能调用该函数释放内核页表, 会导致物理地址重复释放, 必须直接调用 uvmunmap() 并将第 4 个参数置零.
  • 另外还需要注意的一点是, sz 变量在 uvmalloc() 或 uvmdealloc() 调用后会被更新, 在调整内核页表时需要注意.
// 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){
    // prevent process from growing to PLIC address - lab3-3
    if(sz + n > PLIC){
      return -1;
    }
    if((sz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
      return -1;
    }
    // copy the increase user page table to kernel page table - lab3-3
    if(u2kvmcopy(p->pagetable, p->kpagetable, p->sz, sz) < 0){
      return -1;
    }
  } else if(n < 0){
    sz = uvmdealloc(p->pagetable, sz, sz + n);
    // free process's kernel page table without free physical memory - lab3-3
    if (PGROUNDUP(sz) < PGROUNDUP(p->sz)) {
      uvmunmap(p->kpagetable, PGROUNDUP(sz),
               (PGROUNDUP(p->sz) - PGROUNDUP(sz)) / PGSIZE, 0);
    }
  }
  p->sz = sz;
  return 0;
}
5. 修改 userinit() 函数
  • kernel/proc.c 中的 userinit() 函数用于初始化 xv6 启动时第一个用户进程, 该进程的加载是独立的, 因此也需要将其用户页表拷贝到内核页表.
// 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;
  // init kernel pagetable - lab3-3
  u2kvmcopy(p->pagetable, p->kpagetable, 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);
}
6. 替换 copyin() 和 copyinstr()
  • 直接将 copyin() 和 copyinstr() 两个函数的原有代码注释掉, 并分别调用已提供好的 kernel/vmcopyin.c 中的 copyin_new() 和 copyinstr_new() 函数. 可以看到这两个函数相比原来的函数, 其中未使用 walk() 获取物理地址, 而是直接对虚拟地址进行拷贝操作.
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);
}

遇到问题

  • xv6 卡住, 一直不能进行正常显示, 如下图:
    在这里插入图片描述
    解决: 这是由于 u2kvmcopy() 中使用了 kalloc() 新分配了内存而非映射到用户空间.
  • 执行命令没有输出, 如下图所示:
    在这里插入图片描述
    解决: 这是由于 fork() 创建进程时调用 u2kvmcopy() 复制的是错误的父进程用户页表, 应该复制子进程页表.
  • 正常执行命令通过, 执行 usertests 测试引发重映射 panic, 如下图所示:
    在这里插入图片描述
    解决: 这是由于 CLINT 部分导致的重映射, 具体解决方案有两种, 上文已经阐述.

测试

  • xv6 中执行 usertests 测试:
    在这里插入图片描述
  • make grade 测试:
    在这里插入图片描述

思考题

  • Q: Explain why the third test srcva + len < srcva is necessary in copyin_new(): give values for srcva and len for which the first two test fail (i.e., they will not cause to return -1) but for which the third one is true (resulting in returning -1).
    A: 三个 return -1 的条件分别为 srcva >= p->sz, srcva+len >= p->sz 和 srcva+len < srcva. 很显然, 此处第三个条件主要是进行溢出检测, 防止无符号整数上溢. 由于 srcva 和 len 均为 uint64 类型的变量, 当 srcva 小于 p->sz 但是 len 为一个极大的数时, 如 0xffff...ffff(即对应 -1), 由于无符号整数溢出便可以满足 srcva+len < p->sz 这一条件, 但实际上复制了大量内存. 但通过 srcva+len < srcva 这一判断条件能够检测出溢出.

真实情况

Linux 系统中的进程虚拟地址的实现与此处实现的内核页表类似, 是使用同一个进程页表来同时映射用户空间和内核空间, 而没有再使用一个用户页表. 32 位操作系统中用户空间为 3GB, 内核空间为 1GB, 且内核空间不同进程映射的是相同的共享空间, 用于用户态陷入内核调用系统调用等.

PeakCrosser
关注
专栏目录
MIT6.S081-2020-Lab: page tables
Valishment的博客
08-02 823
继续上次的xv6实验，从做完第一个实验后，到现在已经过去很久了6.S081-Lab: Xv6 and Unix utilities 操作系统实验分享。中途只做完了系统调用，也没有写上笔记。 这次学习页表一章，从看书到看代码再到编写实验，花费了很多时间，遇到了很多坑，反反复复修改代码才得到正确的结果。 还是和以前一样，对操作系统有兴趣的千万不要错过这个实验。这次的实验会接触到很多内核知识，尤其是编写实验代码过程中，将页表理论知识化为实际的代码，别说有多舒服了。 分页可谓是操作系统中一个非常重要的思想，在操作系
2021 MIT6.S081 Lab: page table
m0_52394388的博客
08-03 608
2021的Lab3在设计上相比2020精简了许多内容，很快就做完了，第三个assignment的边界检查没做也能过就懒得做了
操作系统MIT6.S081：Lab3-＞Page tables
InnerPeaceHQ的博客
07-21 4100
在本实验中，你将探索页表并修改它们来简化将数据从用户空间复制到内核空间的函数。，它捕获内存的布局。kern/vm.c，包含大多数虚拟内存(VM)相关的代码。，包含分配和释放物理内存的代码。开始实验前，使用以下命令将实验分支切换至pgtbl。...
Lab3: page tables
最新发布
Lane的小屋
07-30 714
xv6 操作系统
lab pagetable
maoyl0506的博客
07-29 338
lab pgtbl
MIT 6.S081---Lab: page tables
weixin_43917399的博客
01-15 487
这样做的话有个问题，因为内核的页表不包含这些映射，进行系统调用时必须传入物理地址而不能传入虚拟地址，而本处要做的便是在每个用户进程内都维护一个内核页表，进程切换的时候在硬件维度就切换内核页表，分配时也要用这个内核页表。（也就是用新的内核页表替代用户页表）本题的目标是要用copyin_new 来取代copyin，用copyinstr_new取代copyinstr，其中需要在修改原用户页表时也同步修改新建的内核页表。在XV6原先的设计下，只有一张内核表，而每个进程都维护了一张自己的进程用户页表。
XV6 Lab: page tables
qq_37366291的博客
05-18 929
XV6 Lab: page tables 文章目录XV6 Lab: page tables一、vscode调试xv6代码二、调试过程1. kinit();2. kvminit();总结 一、vscode调试xv6代码 参考 二、调试过程 1. kinit(); void kinit() { initlock(&kmem.lock, "kmem"); freerange(end, (void*)PHYSTOP); } 对于end变量的赋值是通过kernel.ld确定的。（链接脚本） 对
OS Lab 【Page tables】
Jeekzhang的博客
02-24 281
操作系统实验Lab 3:Page tables(MIT 6.S081 FALL 2022)
【MIT-6.1810】Lab: page tables
weixin_46322986的博客
06-26 1237
页表的初始化位于函数 proc_pagetable 中，通过 mappages 在页表中注册新的 PTE，参考 TRAPFRAME 的方式，将 USYSCALL 映射到 p->usyscall 中。实验要求实现一个系统调用 sys_pgaccess，其会从一个虚拟地址对应的 PTE 开始，往下搜索一定数量的被访问（read/write）过的页表，并把结果通过 mask 的方式返回给用户。但是，该 lab 是利用页表，而不是编写页表，所以比较简单。其次，PTE 是连续的，那么对应的虚拟地址也应是连续的。
2020 MIT6.s081 os Lab: page tables
sun%moon
07-21 697
2020 MIT6.s081 os lab page tables
【MIT 6.S081】Lab3: page tables
juruo_c的博客
03-23 606
PgtblPrint a page tableA kernel page table per processSimplify copyin/copyinstr 本Lab简单优化了系统的页表功能，使得程序在内核态时可以直接解析用户态的指针。 笔者用时约8h Print a page table 第一部分是为系统添加一个打印给定页表的函数vmprint，该函数接收一个参数pagetable（根页表的物理地址），递归遍历整张页表，打印有效的表项。 参考freewalk函数（定义在kernel/vm.c:331），
【MIT 6.S081】2020, 实验记录（3），Lab: page tables
VLyb
01-13 601
MIT 6.S081 2020 的 lab 3 的实验记录
【MIT6.S081】Lab3: page tables(详细解答版)
lllllllllljg的博客
04-13 2194
实验内容网址：https://xv6.dgs.zone/labs/requirements/lab3.html本实验的代码分支：https://gitee.com/dragonlalala/xv6-labs-2020/tree/pgtbl2/
Lab3: page tables (hard!) 详解
qq_53111905的博客
10-27 2263
Lab3: page tables (hard!) 这个实验难度被MIT的老师评价为第一 文章目录Lab3: page tables (hard!)Print a page table (easy)第一步第二步第三步给每一个进程弄一个kernel_pagetable (hard)第一步 添加一个内核页表第二步 确保内核页表映射到该进程的内核栈第三步 修改scheduler第四步 释放内核页表简化 `copyin`/`copyinstr`（hard）第一步 替换`copyin()`、`copyinstr`
6.S081 Lab3 page tables 页表
qq_40686526的博客
04-19 2787
Speed up system calls 加速系统调用 有些操作系统会通过在用户空间和内核空间之间共享一些内存来加速系统调用。
MIT 6.S081 lab3 pagetable
NP_hard的博客
12-02 775
参考 知乎：https://zhuanlan.zhihu.com/p/280914560 掘金：https://juejin.cn/post/7008487319976017928 实验指导书：https://pdos.csail.mit.edu/6.828/2020/labs/pgtbl.html 文章目录Print a page tableA kernel page table per process创建进程内核页表和内核栈切换到进程内核页表释放进程内核页表Simplify Print a pa.
Lab3：Page Tables(1) —— 源码解读
weixin_44752577的博客
05-21 199
--------24.6.13------------   目前，我通过了 的实验，通过各种办法，阅读 的中文译本，参考别人的思路、代码等等，不完全是自己的思路，但也总算是将该实验完成了。   所以就有了一些想法，想要通过博客的方式记录自己做 的过程，以及对操作系统的相关收获，预计会写几篇博客来叙述，目前还没有怎么构思好，因为在这个lab着实花费了不少时间，踩了不少坑，想要更完整地记录学习的过程。该部分具体内容可以查看xv6参考书，这里进行简单介绍
mit6.s081 lab lock
10-06
mit6.s081 lab lock是麻省理工学院计算机科学与人工智能实验室的一个项目，主要目的是实现一个基本的锁系统。 这个项目的核心是一个用户态的锁库，它提供了一组函数来实现锁的创建、加锁和解锁等操作。用户可以在自己的程序中使用这些函数来确保关键代码段的互斥访问，从而避免并发访问带来的问题。 mit6.s081 lab lock的实现基于操作系统的进程管理与调度机制。在具体实现中，它借助于系统调用来实现进程的阻塞和唤醒，以及对共享资源的保护。 通过实现这个锁系统的项目，学生可以深入理解操作系统中与并发相关的核心概念，如原子操作、互斥和临界区等。同时，学生还可以学习到如何进行系统级编程，理解用户态和内核态之间的交互。 此外，mit6.s081 lab lock还涉及到对锁性能的评估，学生可以通过实验测量和分析锁的性能指标，如吞吐量和延迟等。这样的实践让学生能够更好地理解并发编程中的性能优化与瓶颈分析。 总之，mit6.s081 lab lock是一个对操作系统和并发编程进行深入学习的项目。通过参与这个项目，学生可以加深对锁机制及其原理的理解，并掌握一些实用的并发编程技术。
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值