Page fault（异常）

差不太多先生

已于 2023-03-04 16:45:30 修改

阅读量1.7k

点赞数

分类专栏： MIT 6.S081 文章标签： linux risc-v windows 深度学习人工智能 Powered by 金山文档

于 2023-03-03 18:43:32 首次发布

本文链接：https://blog.csdn.net/qq_52353238/article/details/129325538

版权

MIT 6.S081 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

copy-on-write fork

(1). 修改uvmcopy。每次创建子进程，便会调用此函数为子进程分配物理内存。改为不为子进程分配内存，而是使父子进程共享内存，但禁用PTE_W，同时标记PTE_cow，记得调用kaddrefcnt增加引用计数

(2). 在**kernel/riscv.h**中选取PTE中的保留位定义标记一个页面是否为COW Fork页面的标志位

// 记录应用了COW策略后fork的页面
#define PTE_F (1L << 8)

(3). 在**kalloc.c**中进行如下修改

定义引用计数的全局变量ref，其中包含了一个自旋锁和一个引用计数数组，由于ref是全局变量，会被自动初始化为全0。

这里使用自旋锁是考虑到这种情况：进程P1和P2共用内存M，M引用计数为2，此时CPU1要执行fork产生P1的子进程，CPU2要终止P2，那么假设两个CPU同时读取引用计数为2，执行完成后CPU1中保存的引用计数为3，CPU2保存的计数为1，那么后赋值的语句会覆盖掉先赋值的语句，从而产生错误

struct ref_stru {
  struct spinlock lock;
  int cnt[PHYSTOP / PGSIZE];  // 引用计数
} ref;

在kinit中初始化ref的自旋锁

修改kalloc和kfree函数，在kalloc中初始化内存引用计数为1，在kfree函数中对内存引用计数减1，如果引用计数为0时才真正删除

(4). 在**trap.c**中进行如下修改

在usertrap()函数中，判断page fault产生类型是否是由于写入内存错误。如果是，判断PTE的cow位是否被标志，如果是，则读取内存引用计数，如果为1，说明只有当前进程引用了该物理内存（其他进程此前已经被分配到了其他物理页面），就只需要改变PTE使能PTE_W；否则就分配物理页面，并将原来的内存引用计数减1

uint64 cowalloc(pagetable_t pagetable, uint64 va)
{
	pte_t *pte;
	uint64 pa;
  char* mem;

	if(cowpage(pagetable, va) == 0)
		return -1;

	pte = walk(pagetable, va, 0);  //子进程的页表pte
  pa = PTE2PA(*pte); //共用的物理地址

  //flags = PTE_FLAGS(*pte);
	
	// 清除PTE_V，否则在mappagges中会判定为remap
    if(krefcnt((char*)pa) == 1) {
    // 只剩一个进程对此物理地址存在引用
    // 则直接修改对应的PTE即可
    *pte |= PTE_W;
    *pte &= ~PTE_cow;
    return pa;
  } else {
    // 多个进程对物理内存存在引用
    // 需要分配新的页面，并拷贝旧页面的内容
    mem = kalloc();
    if(mem == 0)
      return 0;

    // 复制旧页面内容到新页
    memmove(mem, (char*)pa, PGSIZE);

    // 清除PTE_V，否则在mappagges中会判定为remap
    *pte &= ~PTE_V;

    // 为新页面添加映射
    if(mappages(pagetable, va, PGSIZE, (uint64)mem, (PTE_FLAGS(*pte) | PTE_W) & ~PTE_cow) != 0) {
      kfree(mem);
      *pte |= PTE_V;
      return 0;
    }

    // 将原来的物理内存引用计数减1
    kfree((char*)PGROUNDDOWN(pa));
    return (uint64)mem;
  }
}

(5). 在copyout（由内核copy到用户空间）中处理相同的情况，如果是COW页面，需要

也需要重新为子进程分配内存

mmap系统调用

void *mmap(void *addr, int length, int prot, int flags, int fd, int off);
int munmap(void *addr, int length);

/*addr:映射到的虚拟地址， 
  length：需要映射的字节数，可能和文件大小不相等，
  prot：表示映射到的内存的权限为PROT_READ还是PROT_WRITE。
  flag：可以是MAP_SHARED或MAP_PRIVATE，如果是前者就需要将内存中修改的相应部分写回文件中。
  fd： 需要映射的已打开的文件描述符。
*/

#define MAXVMA 16
struct vma {
  int valid;                // whether the vma is valid
  uint64 addr;              // starting virtual address of vma
  int len;                  // length of vma, unit: bytes
  int prot;                 // permission
  int flags;                // flag
  struct file *f;           // pointer to mapped file
  int off;                  // offset of the valid mapped address
  int valid_len;            // length of the valid mapped address
};

实现系统调用函数

先不分配物理内存，只是找到空闲的vma，初始化vma。

使用COW机制分配真实内存。

uint64 
sys_mmap(void)
{
  int length, prot, flags, fd;
  struct file *f;
  if (argint(1, &length)<0 || argint(2, &prot)<0 || argint(3, &flags)<0 || argfd(4, &fd, &f)<0) {
    return -1;
  }
  if (!f->writable && (prot & PROT_WRITE) && (flags & MAP_SHARED)) return -1; // to assert that readonly file could not be opened with PROT_WRITE && MAP_SHARED flags
  struct proc *p = myproc();
  struct vma *pvma = p->procvma;
    //查找空闲的vma
  for (int i = 0; i < MAXVMA; i++) {
    if(pvma[i].valid == 0) {  
      pvma[i].addr = p->sz;  //进程地址空间的最上方，mmap起始虚拟地址，addr+len为结束地址
      pvma[i].f = filedup(f);  // increment the refcount for f
      pvma[i].flags = flags;
      pvma[i].len = PGROUNDUP(length);  //映射的文件字节长度
      pvma[i].prot = prot;
      pvma[i].valid = 1; 
      pvma[i].off = 0;
      pvma[i].valid_len = pvma[i].len;
      p->sz += pvma[i].len; //更新进程已使用地址空间，预分配
      return pvma[i].addr;
    }
  }
  return -1;
}

出发page fault进入trap时，先判断由于访问虚拟地址引发trap的va是否合法（在vma管理的mmap地址范围内）分配内存，映射到虚拟内存。，将对应的文件内容用放入刚分配的（物理）内存中。

else if (r_scause() == 13 || r_scause() == 15) {
    uint64 va = r_stval();
    if (va < p->trapframe->sp || va >= p->sz) {
      goto exception;
    }
    struct vma *pvma = p->procvma;
    va = PGROUNDDOWN(va);

    for (int i = 0; i < MAXVMA; i++) {
      if (pvma[i].valid && va >= pvma[i].addr + pvma[i].off && va < pvma[i].addr + pvma[i].off + pvma[i].valid_len) {  
        // allocate one page in the physical memory
        char *mem = kalloc();
        if (mem == 0) goto exception;
        memset(mem, 0, PGSIZE);
        int flag = (pvma[i].prot << 1) | PTE_U; // PTE_R == 2 and PROT_READ == 1
        if (mappages(p->pagetable, va, PGSIZE, (uint64)mem, flag) != 0) {
          kfree(mem);
          goto exception;
        }   
        int off = va - pvma[i].addr;
        ilock(pvma[i].f->ip);
        readi(pvma[i].f->ip, 1, va, off, PGSIZE);
        iunlock(pvma[i].f->ip);
        break;
      }
    }
  }

sys_munmap函数

首先需要找到对应的vma，然后根据unmap的大小和起点的不同进行讨论。如果是从vma有效部分的起点开始，当整个vma都被unmap掉时，需要标记这个打开的文件被关闭（但是现在还不能关闭，因为后面可能需要写回硬盘中的文件）。如果是从中间部分开始，则直接unmap一直到结尾

然后判断是否是MAP_SHARED，如果是就需要从内存写回磁盘原文件

sys_munmap(void)
{
  uint64 addr;
  int length;
  if (argaddr(0, &addr) < 0 || argint(1, &length) < 0) {
    return -1;
  }
  struct proc *p = myproc();
  struct vma *pvma = p->procvma;
  int close = 0;
  // find the corresponding vma
  for (int i = 0; i < MAXVA; i++) {
    if (pvma[i].valid && addr >= pvma[i].addr && addr < pvma[i].addr + pvma[i].len) {
      addr = PGROUNDDOWN(addr);
      if (addr == pvma[i].addr + pvma[i].off) {
        // starting at begin of the valid address of vma
        if (length >= pvma[i].valid_len) {
          // whole vma is unmmaped
          pvma[i].valid = 0;
          length = pvma[i].valid_len;
          close = 1;
          p->sz -= pvma[i].len;
        } else {
          pvma[i].off += length;
          pvma[i].valid_len -= length;
        }
      } else {
        // starting at middle, should unmap until the end
        length = pvma[i].addr + pvma[i].off + pvma[i].valid_len - addr;
        pvma[i].valid_len -= length;
      }
      if (pvma[i].flags & MAP_SHARED) {
        // write the page back to the file
        if (_filewrite(pvma[i].f, addr, length, addr - pvma[i].addr) == -1) return -1; 
      }
      uvmunmap(p->pagetable, addr, PGROUNDUP(length)/PGSIZE, 0);  //取消内存映射
      if (close) fileclose(pvma[i].f);
      return 0;
    }
  }
  return -1;
}

用到了log机制

/* f：文件指针
    addr：umap的地址
    n： umap的长度
    off： 从addr到vma起始地址的偏移
    */
int
_filewrite(struct file *f, uint64 addr, int n, uint off) {
  int r, ret = 0;

  if(f->writable == 0)
    return -1;

  if(f->type == FD_PIPE){
    ret = pipewrite(f->pipe, addr, n);
  } else if(f->type == FD_DEVICE){
    if(f->major < 0 || f->major >= NDEV || !devsw[f->major].write)
      return -1;
    ret = devsw[f->major].write(1, addr, n);
  } else if(f->type == FD_INODE){
    // write a few blocks at a time to avoid exceeding
    // the maximum log transaction size, including
    // i-node, indirect block, allocation blocks,
    // and 2 blocks of slop for non-aligned writes.
    // this really belongs lower down, since writei()
    // might be writing a device like the console.
    int max = ((MAXOPBLOCKS-1-1-2) / 2) * BSIZE; //一次写回的最大长度
    int i = 0;
    while(i < n){
      int n1 = n - i;
      if(n1 > max)
        n1 = max;
   
      begin_op();
      ilock(f->ip);
      if ((r = writei(f->ip, 1, addr + i, off, n1)) > 0)
        off += r;
      iunlock(f->ip);
      end_op();

      if(r != n1){
        // error from writei
        break;
      }
      i += r;
    }
    // ret = (i == n ? n : -1);
  } else {
    panic("filewrite");
  }
  return ret;
}

问题：释放内存处，

发现物理内存的释放必须是整页整页的释放，而之前munmap指定的addr可能正处于页中间，此时该页整体不应该被释放（或者是地址下移，凑够整页，再释放）

将uvmunmap改成vmaunmap

// Remove n BYTES (not pages) of vma mappings starting from va. va must be
// page-aligned. The mappings NEED NOT exist.
// Also free the physical memory and write back vma data to disk if necessary.
void
vmaunmap(pagetable_t pagetable, uint64 va, uint64 nbytes, struct vma *v)
{
  uint64 a;
  pte_t *pte;

  // printf("unmapping %d bytes from %p\n",nbytes, va);

  // borrowed from "uvmunmap"
  for(a = va; a < va + nbytes; a += PGSIZE){
    if((pte = walk(pagetable, a, 0)) == 0)
      panic("sys_munmap: walk");
    if(PTE_FLAGS(*pte) == PTE_V)
      panic("sys_munmap: not a leaf");
    if(*pte & PTE_V){
      uint64 pa = PTE2PA(*pte);
      if((*pte & PTE_D) && (v->flags & MAP_SHARED)) { // dirty, need to write back to disk
        begin_op();
        ilock(v->f->ip);
        uint64 aoff = a - v->vastart; // offset relative to the start of memory range
        if(aoff % PFSIZE != 0) { // if the first page is not a full 4k page
          向下多删一段，凑够整页
        } else if(aoff + PGSIZE > v->sz){  // if the last page is not a full 4k page
          向下多删一段，凑够整页
        } else { // full 4k pages
          writei(v->f->ip, 0, pa, v->offset + aoff, PGSIZE);
        }
        iunlock(v->f->ip);
        end_op();
      }
      kfree((void*)pa);
      *pte = 0;
    }
  }
}

差不太多先生

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Page fault（异常）

假设现在是子进程在执行store指令，那么我们会分配一个新的物理内存page，然后将page fault相关的物理内存page拷贝到新分配的物理内存page中，并将新分配的物理内存page映射到子进程。这里使用自旋锁是考虑到这种情况：进程P1和P2共用内存M，M引用计数为2，此时CPU1要执行fork产生P1的子进程，CPU2要终止P2，那么假设两个CPU同时读取引用计数为2，执行完成后CPU1中保存的引用计数为3，CPU2保存的计数为1，那么后赋值的语句会覆盖掉先赋值的语句，从而产生错误。
复制链接

扫一扫