Lab3:page tables

最新推荐文章于 2024-09-01 10:20:57 发布
最新推荐文章于 2024-09-01 10:20:57 发布
阅读量93 收藏
点赞数
分类专栏： mit6.s081 文章标签： linux

学习资料：

https://pdos.csail.mit.edu/6.828/2020/schedule.html
https://mit-public-courses-cn-translatio.gitbook.io/mit6-s081/
https://th0ar.gitbooks.io/xv6-chinese/content/
https://www.bilibili.com/video/BV19k4y1C7kA

参考资料

https://blog.miigon.net/posts/s081-lab3-page-tables/#print-a-page-table-easy
https://zhuanlan.zhihu.com/p/625962093

  • kern/memlayout.h，捕获物理内存布局。
  • kern/vm.c，其中包含大部分虚拟内存 (VM) 代码。
  • kernel/kalloc.c，其中包含分配和释放物理内存的代码。

Print a page table (easy)

Define a function called vmprint(). It should take a pagetable_t
argument, and print that pagetable in the format described below.
Insert if(p->pid==1) vmprint(p->pagetable) in exec.c just before the
return argc, to print the first process’s page table. You receive full
credit for this assignment if you pass the pte printout test of 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

RISC-V 的逻辑地址寻址是采用三级页表的形式，9 bit 一级索引找到二级页表，9 bit 二级索引找到三级页表，9 bit 三级索引找到内存页，最低 12 bit 为页内偏移（即一个页 4096 bytes）。具体可以参考 xv6 book 的 Figure 3.2。

本函数需要模拟如上的 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); // 添加函数声明

因为需要递归打印页表，而 xv6 已经有一个递归释放页表的函数 freewalk()，将其复制一份，并将释放部分代码改为打印即可：

// kernel/vm.c
int pgtblprint(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));

      // 如果该节点不是叶节点，递归打印其子节点。
      if((pte & (PTE_R|PTE_W|PTE_X)) == 0){
        // this PTE points to a lower-level page table.
        uint64 child = PTE2PA(pte);
        pgtblprint((pagetable_t)child,depth+1);
      }
    }
  }
  return 0;
}

int vmprint(pagetable_t pagetable) {
  printf("page table %p\n", pagetable);
  return pgtblprint(pagetable, 0);
}

在exec.c中进行调用

// exec.c

int
exec(char *path, char **argv)
{
  // ......

  vmprint(p->pagetable); // 按照实验要求，在 exec 返回之前打印一下页表。
  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;

}

最后进行输出测试

$ ./grade-lab-pgtbl pte printout
make: `kernel/kernel' is up to date.
== Test pte printout == pte printout: OK (1.6s)

A kernel page table per process (hard)

Your first job is to modify the kernel so that every process uses its own copy of the kernel page table when executing in the kernel. Modify struct proc to maintain a kernel page table for each process, and modify the scheduler to switch kernel page tables when switching processes. For this step, each per-process kernel page table should be identical to the existing global kernel page table. You pass this part of the lab if usertests runs correctly.

xv6 原本的设计是，用户进程在用户态使用各自的用户态页表，但是一旦进入内核态（例如使用了系统调用），则切换到内核页表（通过修改 satp 寄存器，trampoline.S）。然而这个内核页表是全局共享的，也就是全部进程进入内核态都共用同一个内核态页表：

本 Lab 目标是让每一个进程进入内核态后，都能有自己的独立内核页表。

创建进程内核页表与内核栈

首先在进程的结构体 proc 中，添加一个 kernelpgtbl，用于存储进程专享的内核态页表。

// kernel/proc.h
// 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 kernelpgtbl;     // Kernel page table （在 proc 中添加该 field）
};

接下来修改 kvminit。内核需要依赖内核页表内一些固定的映射的存在才能正常工作，例如 UART 控制、硬盘界面、中断控制等。而 kvminit 原本只为全局内核页表 kernel_pagetable 添加这些映射。我们抽象出来一个可以为任何我们自己创建的内核页表添加这些映射的函kvm_map_pagetable()。

void kvm_map_pagetable(pagetable_t pgtbl) {
  // 将各种内核需要的 direct mapping 添加到页表 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);
}

pagetable_t
kvminit_newpgtbl()
{
  pagetable_t pgtbl = (pagetable_t) kalloc();
  memset(pgtbl, 0, PGSIZE);

  kvm_map_pagetable(pgtbl);

  return pgtbl;
}

/*
 * create a direct-map page table for the kernel.
 */
void
kvminit()
{
  kernel_pagetable = kvminit_newpgtbl(); // 仍然需要有全局的内核页表，用于内核 boot 过程，以及无进程在运行时使用。
}

// ......

// 将某个逻辑地址映射到某个物理地址（添加第一个参数 pgtbl）
void
kvmmap(pagetable_t pgtbl, uint64 va, uint64 pa, uint64 sz, int perm)
{
  if(mappages(pgtbl, va, sz, pa, perm) != 0)
    panic("kvmmap");
}

// kvmpa 将内核逻辑地址转换为物理地址（添加第一个参数 kernelpgtbl）
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)
    panic("kvmpa");
  pa = PTE2PA(*pte);
  return pa+off;
}

kvm_map_pagetable函数必须要在kvminit_newpgtbl函数之前，还有将这些函数在defs文件中进行声明，不然后续运行容易报错。

这里还有一个重要的需要处理，要为每个进程创建都属于自己的内核栈。 原本的 xv6 设计中，所有处于内核态的进程都共享同一个页表，即意味着共享同一个地址空间。由于 xv6 支持多核/多进程调度，同一时间可能会有多个进程处于内核态，所以需要对所有处于内核态的进程创建其独立的内核态内的栈，也就是内核栈，供给其内核态代码执行过程。

xv6 在启动过程中，会在 procinit() 中为所有可能的 64 个进程位都预分配好内核栈 kstack，具体为在高地址空间里，每个进程使用一个页作为 kstack，并且两个不同 kstack 中间隔着一个无映射的 guard page 用于检测栈溢出错误。具体参考 xv6 book 的 Figure 3.3。

在 xv6 原来的设计中，内核页表本来是只有一个的，所有进程共用，所以需要为不同进程创建多个内核栈，并 map 到不同位置（见 procinit() 和 KSTACK 宏）。

而我们的新设计中，每一个进程都会有自己独立的内核页表，并且每个进程也只需要访问自己的内核栈，而不需要能够访问所有 64 个进程的内核栈。所以可以将所有进程的内核栈 map 到其各自内核页表内的固定位置（不同页表内的同一逻辑地址，指向不同物理内存）。

//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");

      // 这里删除了为所有进程预分配内核栈的代码，变为创建进程的时候再创建内核栈，见 allocproc()
  }

  kvminithart();
}

然后，在创建进程的时候，为进程分配独立的内核页表，以及内核栈

// kernel/proc.c

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;
  }

// 新加部分 start //

  // 为新进程创建独立的内核页表，并将内核所需要的各种映射添加到新页表上
  p->kernelpgtbl = kvminit_newpgtbl();
  // printf("kernel_pagetable: %p\n", p->kernelpgtbl);

  // 分配一个物理页，作为新进程的内核栈使用
  char *pa = kalloc();
  if(pa == 0)
    panic("kalloc");
  uint64 va = KSTACK((int)0); // 将内核栈映射到固定的逻辑地址上
  // printf("map krnlstack va: %p to pa: %p\n", va, pa);
  kvmmap(p->kernelpgtbl, va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
  p->kstack = va; // 记录内核栈的逻辑地址，其实已经是固定的了，依然这样记录是为了避免需要修改其他部分 xv6 代码



  // 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;
}

到这里进程独立的内核页表就创建完成了，但是用户进程进入内核态后依然会使用全局共享的内核页表，因此还需要在 scheduler() 中进行相关修改。

切换到进程内核页表

在调度器将 CPU 交给进程执行之前，切换到该进程对应的内核页表：

// kernel/proc.c
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->kernelpgtbl));
        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/proc.c
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->kernelpgtbl, p->kstack);
  // printf("trace: free kstack %p\n", kstack_pa);
  kfree(kstack_pa);
  p->kstack = 0;
  
  // 注意：此处不能使用 proc_freepagetable，因为其不仅会释放页表本身，还会把页表内所有的叶节点对应的物理页也释放掉。
  // 这会导致内核运行所需要的关键物理页被释放，从而导致内核崩溃。
  // 这里使用 kfree(p->kernelpgtbl) 也是不足够的，因为这只释放了**一级页表本身**，而不释放二级以及三级页表所占用的空间。
  
  // 递归释放进程独享的页表，释放页表本身所占用的空间，但**不释放页表指向的物理页**
  kvm_free_kernelpgtbl(p->kernelpgtbl);
  p->kernelpgtbl = 0;
  p->state = UNUSED;
}

kvm_free_kernelpgtbl() 用于递归释放整个多级页表树，也是从 freewalk() 修改而来。

// kernel/vm.c

// 递归释放一个内核页表中的所有 mapping，但是不释放其指向的物理页
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];
    uint64 child = PTE2PA(pte);
    if((pte & PTE_V) && (pte & (PTE_R|PTE_W|PTE_X)) == 0){ // 如果该页表项指向更低一级的页表
      // 递归释放低一级页表及其页表项
      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()->kernelpgtbl, (uint64) &buf0); // 调用 myproc()，获取进程内核页表
// ......
}

进行最后测试

./grade-lab-pgtbl usertests

riscv64-unknown-elf-objdump -S kernel/kernel > kernel/kernel.asm
riscv64-unknown-elf-objdump -t kernel/kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$/d' > kernel/kernel.sym
== Test usertests == (229.8s)
== Test   usertests: copyin ==
  usertests: copyin: OK
== Test   usertests: copyinstr1 ==
  usertests: copyinstr1: OK
== Test   usertests: copyinstr2 ==
  usertests: copyinstr2: OK
== Test   usertests: copyinstr3 ==
  usertests: copyinstr3: OK
== Test   usertests: sbrkmuch ==
  usertests: sbrkmuch: OK
== Test   usertests: all tests ==
  usertests: all tests: OK

在这里插入图片描述

难点

难点一：释放页表的时候没有释放干净，要进行递归释放，

不能使用proc_freepagetable函数，这个不仅会释放页表，页表对应的叶节点物理页也会被释放

难点2：修改kvminit函数时，使用了kvminit_newpgtbl，这个函数要在后面才出现，要放在上面先声明一下才可以使用或者调换顺序

难点3：kvminit_newpgtbl和kvm_free_kernelpgtbl这些自己创建的函数要在内核的头文件defs.h里面声明。

simplify copyin/copyinstr

,我们需要保证每个进程的pagetable和kernelpgtbl的前半段映射一直保持一致, 这样我们才能在切入内核态时直接使用硬件支持的虚拟/物理内存地址寻址. 按照实验手册的提醒, 在fork(), sbrk(), exec()这些使得进程的pagetable发生增长/缩减的地方, 我们需要将kernelpgtbl与之进行同步更新.

首先我们写一个helper函数, 来将一段内存映射从pagetable复制到kpagetable.

# kernel/vm.c

// Same as mappages without panic on remapping
// 和mappages一模一样, 只不过不再panic remapping, 直接强制复写
int umappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm) {
  uint64 a, last;
  pte_t *pte;

  a = PGROUNDDOWN(va);
  last = PGROUNDDOWN(va + size - 1);
  for(;;){
    if((pte = walk(pagetable, a, 1)) == 0)
      return -1;
    *pte = PA2PTE(pa) | perm | PTE_V;
    if(a == last)
      break;
    a += PGSIZE;
    pa += PGSIZE;
  }
  return 0;
}

// copying from old page to new page from
// begin in old page to new in old page
// and mask off PTE_U bit
// 将从begin到end的虚拟地址的映射, 从oldpage复制到newpage
int
pagecopy(pagetable_t oldpage, pagetable_t newpage, uint64 begin, uint64 end) {
  pte_t *pte;
  uint64 pa, i;
  uint flags;
  begin = PGROUNDUP(begin);

  for (i = begin; i < end; i += PGSIZE) {
    if ((pte = walk(oldpage, i, 0)) == 0)
      panic("pagecopy walk oldpage nullptr");
    if ((*pte & PTE_V) == 0)
      panic("pagecopy oldpage pte not valid");
    pa = PTE2PA(*pte);
    flags = PTE_FLAGS(*pte) & (~PTE_U); // 把U flag抹去
    if (umappages(newpage, i, PGSIZE, pa, flags) != 0) {
      goto err;
    }
  }
  return 0;

err:
  uvmunmap(newpage, 0, i / PGSIZE, 1);
  return -1;
}

紧接着, 我们在fork(), exec(), sbrk() 和userinit()的相应位置进行pagetable和kernelpgtbl的同步.

fork()

# kernel/proc.c
// 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;

  if (pagecopy(np->pagetable, np->kernelpgtbl, 0, np->sz) != 0) {
    freeproc(np);
    release(&np->lock);
    return -1;
  }
  np->parent = p;

  ...
  return pid;
}

exec()

# kernel/exec.c
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);

  // 复制新的kernel page并刷新TLB
  if (pagecopy(p->pagetable, p->kernelpgtbl, 0, p->sz) != 0) {
    goto bad;
  }
  // 因为load进来了新的program, 刷新一下内存映射
  w_satp(MAKE_SATP(p->kernelpgtbl));
  sfence_vma();

  ...

  return argc; // this ends up in a0, the first argument to main(argc, argv)

}

sbrk()

# kernel/proc.c
// 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){
    // 内核页的虚拟地址不能溢出PLIC
    if (sz + n > PLIC || (sz = uvmalloc(p->pagetable, sz, sz + n)) == 0) {
      return -1;
    }
    if (pagecopy(p->pagetable, p->kernelpgtbl, p->sz, sz) != 0) {
      // 增量同步[old size, new size]
      return -1;
    }
  } else if(n < 0){
    sz = uvmdealloc(p->pagetable, sz, sz + n);
    if (sz != p->sz) {
      // 缩量同步[new size, old size]
      uvmunmap(p->kernelpgtbl, PGROUNDUP(sz), (PGROUNDUP(p->sz) - PGROUNDUP(sz)) / PGSIZE, 0);
    }
  }
  ukvminithard(p->kernelpgtbl);
  p->sz = sz;
  return 0;
}

在创建第一个进程的时候也要设置映射userinit()

# kernel/proc.c
// Set up first user process.
void
userinit(void)
{
  ...
  uvminit(p->pagetable, initcode, sizeof(initcode));
  p->sz = PGSIZE;

  pagecopy(p->pagetable, p->kernelpgtbl, 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

  ...
}

替换 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);
}

然后想要满分的话，还要加一个answers-pgtbl.txt文件。
编译后进行lab批分, 顺利通过.

vagrant@developer:/vagrant/xv6-labs/xv6-labs-2020$ make grade
== Test pte printout == 
$ make qemu-gdb
pte printout: OK (27.3s) 
== Test answers-pgtbl.txt == answers-pgtbl.txt: OK 
== Test count copyin == 
$ make qemu-gdb
count copyin: OK (3.8s) 
== Test usertests == 
$ make qemu-gdb
(219.0s) 
== Test   usertests: copyin == 
  usertests: copyin: OK 
== Test   usertests: copyinstr1 == 
  usertests: copyinstr1: OK 
== Test   usertests: copyinstr2 == 
  usertests: copyinstr2: OK 
== Test   usertests: copyinstr3 == 
  usertests: copyinstr3: OK 
== Test   usertests: sbrkmuch == 
  usertests: sbrkmuch: OK 
== Test   usertests: all tests == 
  usertests: all tests: OK 
== Test time == 
time: OK 
Score: 66/66

这个实验感觉是目前为止花费时间最多，做起来感觉最难的了，simplify copyin/copyinstr这块刚开始打算直接for循环然后加判断做的，发现走不通，后来看了其他大佬的，才算是勉强完成了，先继续往前走了. 之后学到后面对xv6有更深刻的理解后再回来看看。

陌养
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Lab3: page tables
Lane的小屋
07-30 629
xv6 操作系统
Lab3: page tables (hard!) 详解
qq_53111905的博客
10-27 2200
Lab3: page tables (hard!) 这个实验难度被MIT的老师评价为第一 文章目录Lab3: page tables (hard!)Print a page table (easy)第一步第二步第三步给每一个进程弄一个kernel_pagetable (hard)第一步 添加一个内核页表第二步 确保内核页表映射到该进程的内核栈第三步 修改scheduler第四步 释放内核页表简化 `copyin`/`copyinstr`（hard）第一步 替换`copyin()`、`copyinstr`
MIT6.S081最详解析与归纳——lab3:Page tables
qq_45456064的博客
07-15 1065
1.详细了解了页表2.虚拟内存相关知识，空间分配、回收、映射3.实现了页表的新功能，从全局内核页表到独立内核页表的替换4.简化了用户进程与内核之间的数据传输，将其升级为硬件方式。
MIT 6.S081 Lab3: page tables
落队的飞行兵
11-25 2228
今天做完了 6.S081 Lab3: page tables，实验三的主要任务是增加一个页表。本来计划上周就做完，但自己的基础知识实在匮乏，又先去补充了一下虚拟内存方面的知识，把李志军老师的操作系统慕课看了一些，周末才开始搞。中间遇到了一些bug，参考了一下大佬们的实现，磕磕绊绊算是做完了~，代码在 github 上。 感觉这个实验跟前两个不是一个级别~
Xv6 Lab3: page tables
qq_63841656的博客
06-23 1022
直到几年前，许多内核在用户和内核空间中都为当前进程使用相同的自身进程页表，并为用户和内核地址进行映射以避免在用户和内核空间之间切换时必须切换页表。Xv6使用从零开始的虚拟地址作为用户地址空间，幸运的是内核的内存从更高的地址开始。在本部分的实验中，您的工作是将用户空间的映射添加到每个进程的内核页表（上一节中创建），以允许。Xv6还为每个进程的用户地址空间提供了一个单独的页表，只包含该进程用户内存的映射，从虚拟地址0开始。你的第一项工作是修改内核来让每一个进程在内核中执行时使用它自己的内核页表的副本。
[MIT 6.S081] Lab 3: page tables
LostUnravel的博客
11-15 5738
Lab 3: page tables Lab Guidance: Lab: page tables Lab Code: https://github.com/VastRock-Huang/xv6-labs-2020/tree/pgtbl Print a page table (easy) 要点 不输出无效的 PTE 步骤 在 kernel/vm.c 中编写函数 vmprint() 此处可以参考 freewalk() 函数的实现. 对于输出, 此处可以采用循环和递归两种方式实现: 循环的实现即三重循
MIT6.S081Lab3：page tables
qq_46514141的博客
12-05 927
按照准备环境，即如果提示之前的修改没有提交的话可以把之前的修改去掉（备份一份）。
【MIT6.S081】Lab3: page tables(详细解答版)
lllllllllljg的博客
04-13 1782
实验内容网址：https://xv6.dgs.zone/labs/requirements/lab3.html本实验的代码分支：https://gitee.com/dragonlalala/xv6-labs-2020/tree/pgtbl2/
xv6---Lab3: page tables
zion--6135的博客
12-07 1732
程序在系统上执行，操作的是虚拟内存地址，而虚拟内存到物理内存的映射需要一个函数f(var1, var2);其中var1是页表，而var2是偏移量，于是当需要操作一个变量的时候，操作系统可通过函数f(var1, var2);的实现（kernel/exec.c），系统调用exec将存储在文件系统上的，新的用户程序装载进内存里，然后执行它。系统之上的内存分配叫虚拟内存，通过内核的MMU单元去管理并映射到物理内存。，然后我们将物理内存看成是定长槽块的阵列，这些槽块大小与页相同，每个槽块叫做。
【MIT 6.S081】Lab3: page tables
juruo_c的博客
03-23 580
PgtblPrint a page tableA kernel page table per processSimplify copyin/copyinstr 本Lab简单优化了系统的页表功能，使得程序在内核态时可以直接解析用户态的指针。 笔者用时约8h Print a page table 第一部分是为系统添加一个打印给定页表的函数vmprint，该函数接收一个参数pagetable（根页表的物理地址），递归遍历整张页表，打印有效的表项。 参考freewalk函数（定义在kernel/vm.c:331），
MIT6.S081学习总结-lab3:page tables
laplacebh的博客
06-15 3490
lab3 主要是页表相关，难度突然提高了好多，遇到了无数个坑，太难了。 打印页表 第一个进程启动时打印页表内容 实现： kernel/vm.c里添加，递归实现即可 每个进程一张内核页表 目前xv6的实现里，每个进程只有一张独立的用户地址空间页表，共享一张内核页表，这样的话每次内核不能直接使用用户指针，只能先将其通过用户页表转为物理地址。本节及下一节要做的是使内核可以直接解引用用户指针，就是可以直接通过虚拟地址访问。 本节要做的就是为每个进程复制一个内核页表。 实现 省略了 添加函数到defs.h的步骤，这
6.S081 Xv6 Lab 3: page tables
clownote
03-12 6511
Lab: page tables MIT 6.S081 Xv6-riscv Lab 3: https://pdos.csail.mit.edu/6.S081/2020/labs/pgtbl.html In this lab you will explore page tables and modify them to simplify the functions that copy data from user space to kernel space. Print a page table Def.
MIT6.S081-2020-Lab: page tables
Valishment的博客
08-02 782
继续上次的xv6实验，从做完第一个实验后，到现在已经过去很久了6.S081-Lab: Xv6 and Unix utilities 操作系统实验分享。中途只做完了系统调用，也没有写上笔记。 这次学习页表一章，从看书到看代码再到编写实验，花费了很多时间，遇到了很多坑，反反复复修改代码才得到正确的结果。 还是和以前一样，对操作系统有兴趣的千万不要错过这个实验。这次的实验会接触到很多内核知识，尤其是编写实验代码过程中，将页表理论知识化为实际的代码，别说有多舒服了。 分页可谓是操作系统中一个非常重要的思想，在操作系
6.s081 第四周实验 Lab pgtbl: Page tables
nulofa的博客
02-28 583
1. Print a page table 在vm.c中， 实现一个vmprint()函数来遍历页表并打印，可以仿照freewalk()函数来写。 记得在def.h 添加声明 void printwalk(pagetable_t pagetable, int level) { char* prefix; if (level == 2) prefix = ".."; else if (level == 1) prefix = ".. .."; else prefix = ".. .. .
MIT6.s081-2020 Lab3 Page Tables
weixin_44505310的博客
02-20 931
本系列内容涉及操作系统入门，通过对MIT6.s081-2020 中lab的巩固，辅之以课程，加深对操作系统的认识。本篇是关于lab 3:Page Tables
Linux字符设备驱动 -- regulator子系统
最新发布
xi_xix_i的博客
09-01 784
Linux驱动之Regulator子系统Linux 内核之电源篇(加载流程)regulator，翻译就是调节器。一些可以输出电流电压的设备可以使用该子系统。举个例子，一个PMIC有多路输出，每一路输出都可以给很多外设、芯片供电。那么每一路输出，我都可以认为他是一个regulator。
Linux下UDP编程
热土程序园，利他愉己~
08-28 2013
Linux下UDP编程 socket（套接字）本质上是一个抽象的概念，它是一组用于网络通信的 API，提供了一种统一的接口，使得应用程序可以通过网络进行通信。在不同的操作系统中，socket 的实现方式可能不同，但它们都遵循相同的规范和协议，可以实现跨平台的网络通信。
在linux 中如何将.c 文件转换为可执行文件
千千道的博客
08-29 1799
在 Linux 环境下进行 C 语言编程时，将.c文件转换为可执行文件是一个关键的步骤。这个过程涉及到使用编译器和一些相关的工具，本文将详细介绍在 Linux 系统中如何将.c文件转换为可执行文件的方法。
实时Linux性能监控脚本：周期性自动统计CPU、内存和IO使用情况
promise524的博客
08-30 999
Shell脚本实现每3秒钟监控系统的 CPU 占用率、内存使用情况、IO使用情况、每个 CPU 核心的占用率、CPU 占用率最高的前10个进程以及/opt目录的磁盘空间变化。
Lab3：完善借书流程与项目命名
Lab3需求文档详细阐述了在软件工程课程中的一项小组实验任务。实验的目标是完善借书流程功能，同时提升代码质量和项目管理。以下是文档中的关键知识点： 1. **实验目标**：实验的核心目标是基本实现用户图书借阅...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值