mit6.s081 - xv6建立虚拟地址映射

最新推荐文章于 2024-08-05 17:19:56 发布

zju_cxl

最新推荐文章于 2024-08-05 17:19:56 发布

阅读量120

点赞数

本文链接：https://blog.csdn.net/hrbust_cxl/article/details/131213050

版权

xv6通过页表实现虚拟地址到物理地址的映射，内核地址空间为所有进程共享，使用直接映射策略。kvminit和kvminithart函数初始化内核页表，包括直接映射的资源、trampoline页、内核栈等。每个进程有自己的用户地址空间，由exec创建，通过mappages函数建立虚拟和物理地址的关联。fork时，新进程复制父进程的页表内容来创建用户地址空间。

摘要由CSDN通过智能技术生成

核心问题：xv6虚拟地址空间到物理地址空间的映射是由页表实现的，那页表中的内容是怎么写入的？也即：xv6虚拟地址空间到物理地址空间的具体映射关系是如何建立的？

内核地址空间

在xv6的实现上，所有的进程的内核地址空间是共享的(也即，内核线程的页表都是一个)。

每个CPU初始化后采用同一个页表：

// start() jumps here in supervisor mode on all CPUs.
void
main()
{
  if(cpuid() == 0){
    kinit();         // physical page allocator
    kvminit();       // create kernel page table
    kvminithart();   // turn on paging
    procinit();      // process table
    // ...
    started = 1;
  } else {
    while(started == 0)
      ;
    __sync_synchronize();
    printf("hart %d starting\n", cpuid());
    kvminithart();    // turn on paging
    trapinithart();   // install kernel trap vector
    plicinithart();   // ask PLIC for device interrupts
  }

  scheduler();        
}

以下为函数kvminit 和 kvminithart 的具体实现(kernel/vm.c)：

// Initialize the one kernel_pagetable
void
kvminit(void)
{
  kernel_pagetable = kvmmake();
}

// Switch h/w page table register to the kernel's page table,
// and enable paging.
void
kvminithart()
{
  w_satp(MAKE_SATP(kernel_pagetable));
  sfence_vma();
}

初始化后的内核地址空间布局如下：

Figure-3.3-1

内核对RAM(和内存映射的设备寄存器)使用直接映射，也就是将这些资源映射到和它们物理地址相同的虚拟地址上。

有几个内核虚拟地址不是直接映射：

trampoline 页。用于trap机制，它被映射在虚拟地址空间的顶端；用户页表也有这个映射。一个物理页(存放 trampoline 代码)在内核的虚拟地址空间中被映射了两次：一次是在虚拟地址空间的顶部，一次是直接映射。
内核栈页。每个进程都有自己的内核栈，内核栈被映射到高地址处，所以 xv6 可以在它后面留下一个未映射的Guard Page。Guard Page的 PTE 是无效的(不设置 PTE_V 位)，这样如果内核栈溢出，很可能会引起异常，内核会报错。如果没有Guard Page，栈溢出时会覆盖其他内核内存，导致不正确的操作。

内核虚拟地址空间的创建代码如下：

// Make a direct-map page table for the kernel.
pagetable_t
kvmmake(void)
{
  pagetable_t kpgtbl;

  kpgtbl = (pagetable_t) kalloc();
  memset(kpgtbl, 0, PGSIZE);

  // uart registers
  kvmmap(kpgtbl, UART0, UART0, PGSIZE, PTE_R | PTE_W);

  // virtio mmio disk interface
  kvmmap(kpgtbl, VIRTIO0, VIRTIO0, PGSIZE, PTE_R | PTE_W);

  // PLIC
  kvmmap(kpgtbl, PLIC, PLIC, 0x400000, PTE_R | PTE_W);

  // map kernel text executable and read-only.
  kvmmap(kpgtbl, KERNBASE, KERNBASE, (uint64)etext-KERNBASE, PTE_R | PTE_X);

  // map kernel data and the physical RAM we'll make use of.
  kvmmap(kpgtbl, (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(kpgtbl, TRAMPOLINE, (uint64)trampoline, PGSIZE, PTE_R | PTE_X);

  // map kernel stacks
  proc_mapstacks(kpgtbl);
  
  return kpgtbl;
}

其中比较有意思的一个点，在于这个内核地址空间内还存在 NPROC 个内核栈，也就是说每个进程都有自己的内核栈。

// map kernel stacks beneath the trampoline,
// each surrounded by invalid guard pages.
#define KSTACK(p) (TRAMPOLINE - ((p)+1)* 2*PGSIZE)


// Allocate a page for each process's kernel stack.
// Map it high in memory, followed by an invalid
// guard page.
void
proc_mapstacks(pagetable_t kpgtbl) {
  struct proc *p;
  
  for(p = proc; p < &proc[NPROC]; p++) {
    char *pa = kalloc();
    if(pa == 0)
      panic("kalloc");
    uint64 va = KSTACK((int) (p - proc));
    kvmmap(kpgtbl, va, (uint64)pa, PGSIZE, PTE_R | PTE_W);
  }
}

其中 kvmmap 的实现如下，主要功能为遍历要map的虚拟地址空间，通过 walk 函数模拟MMU功能，然后将对应的PPN和标记写成PTE形式：

// add a mapping to the kernel page table.
// only used when booting.
// does not flush TLB or enable paging.
void
kvmmap(pagetable_t kpgtbl, uint64 va, uint64 pa, uint64 sz, int perm)
{
  if(mappages(kpgtbl, va, sz, pa, perm) != 0)
    panic("kvmmap");
}

// Create PTEs for virtual addresses starting at va that refer to
// physical addresses starting at pa. va and size might not
// be page-aligned. Returns 0 on success, -1 if walk() couldn't
// allocate a needed page-table page.
int
mappages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm)
{
  uint64 a, last;
  pte_t *pte;

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

其中的关键代码如下，将对应的PPN和FLAGS写入页表项：

`1`	`*pte = PA2PTE(pa) \| perm \| PTE_V;`

用户地址空间

每个进程都有一个用户页表，当 xv6 在进程间切换时，也会改变页表。

用户地址空间如下图：一个进程的用户内存从虚拟地址 0 开始，可以增长到 MAXVA(kernel/riscv.h:348)，原则上允许一个进程寻址 256GB 的内存。大多数进程不会使用整个用户地址空间；xv6 会将不使用的 PTE 的 PTE_V 位保持为清除状态。

Figure-3.4

`exec` 创建

xv的用户地址空间是通过 exec 创建init进程得到的，它读取储存在文件系统上的文件用来初始化一个地址空间的用户部分。

# Initial process that execs /init.
# This code runs in user space.

#include "syscall.h"

# exec(init, argv)
.globl start
start:
        la a0, init
        la a1, argv
        li a7, SYS_exec
        ecall

# for(;;) exit();
exit:
        li a7, SYS_exit
        ecall
        jal exit

# char init[] = "/init\0";
init:
  .string "/init\0"

# char *argv[] = { init, 0 };
.p2align 2
argv:
  .long init
  .long 0

exec 使用 proc_pagetable(kernel/exec.c:38)分配一个没有使用的页表，代码如下：这里同样采用 mappages 函数建立虚拟地址和物理地址的关系。建立了TRAMPOLINE 和 TRAPFRAME 的映射。

// Create a user page table for a given process,
// with no user memory, but with trampoline pages.
pagetable_t
proc_pagetable(struct proc *p)
{
  pagetable_t pagetable;

  // An empty page table.
  pagetable = uvmcreate();
  if(pagetable == 0)
    return 0;

  // map the trampoline code (for system call return)
  // at the highest user virtual address.
  // only the supervisor uses it, on the way
  // to/from user space, so not PTE_U.
  if(mappages(pagetable, TRAMPOLINE, PGSIZE,
              (uint64)trampoline, PTE_R | PTE_X) < 0){
    uvmfree(pagetable, 0);
    return 0;
  }

  // map the trapframe just below TRAMPOLINE, for trampoline.S.
  if(mappages(pagetable, TRAPFRAME, PGSIZE,
              (uint64)(p->trapframe), PTE_R | PTE_W) < 0){
    uvmunmap(pagetable, TRAMPOLINE, 1, 0);
    uvmfree(pagetable, 0);
    return 0;
  }

  return pagetable;
}

使用 uvmalloc(kernel/exec.c:52)为每一个 ELF 段分配内存
使用 loadseg(kernel/exec.c:10)加载每一个段到内存中。

exec 通过如下代码新建一个用户栈：

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

至此，用户地址空间就成型了。

`fork` 复制

如果是fork出来的进程，走页表拷贝复制现有进程的用户地址空间，代码如下：(kernel/proc.c@fork)

// Copy user memory from parent to child.
if(uvmcopy(p->pagetable, np->pagetable, p->sz) < 0){
  freeproc(np);
  release(&np->lock);
  return -1;
}

其中，uvmcopy 调用 kalloc 、memmove 、mappages 新建一个一样的用户地址空间。

// Given a parent process's page table, copy
// its memory into a child's page table.
// Copies both the page table and the
// physical memory.
// returns 0 on success, -1 on failure.
// frees any allocated pages on failure.
int
uvmcopy(pagetable_t old, pagetable_t new, uint64 sz)
{
  pte_t *pte;
  uint64 pa, i;
  uint flags;
  char *mem;

  for(i = 0; i < sz; i += PGSIZE){
    if((pte = walk(old, i, 0)) == 0)
      panic("uvmcopy: pte should exist");
    if((*pte & PTE_V) == 0)
      panic("uvmcopy: page not present");
    pa = PTE2PA(*pte);
    flags = PTE_FLAGS(*pte);
    if((mem = kalloc()) == 0)
      goto err;
    memmove(mem, (char*)pa, PGSIZE);
    if(mappages(new, i, PGSIZE, (uint64)mem, flags) != 0){
      kfree(mem);
      goto err;
    }
  }
  return 0;

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