Lab10: mmap

本实验是实现一个内存映射文件的功能，将文件映射到内存中，从而在与文件交互时减少磁盘操作。

(1). 根据提示1，首先是配置mmap和munmap系统调用，此前已进行过多次类似流程，不再赘述。在kernel/fcntl.h中定义了宏，只有在定义了LAB_MMAP时这些宏才生效，而LAB_MMAP是在编译时在命令行通过gcc的-D参数定义的

  1. void* mmap(void* addr, int length, int prot, int flags, int fd, int offset);
  2. int munmap(void* addr, int length);

(2). 根据提示3，定义VMA结构体，并添加到进程结构体中

  1. #define NVMA 16
  2. // 虚拟内存区域结构体
  3. struct vm_area {
  4.   int used;           // 是否已被使用
  5.   uint64 addr;        // 起始地址
  6.   int len;            // 长度
  7.   int prot;           // 权限
  8.   int flags;          // 标志位
  9.   int vfd;            // 对应的文件描述符
  10.   struct file* vfile; // 对应文件
  11.   int offset;         // 文件偏移，本实验中一直为0
  12. };
  14. struct proc {
  15.   ...
  16.   struct vm_area vma[NVMA];    // 虚拟内存区域
  17. }

(3). 在allocproc中将vma数组初始化为全0

  1. static struct proc*
  2. allocproc(void)
  3. {
  4.   ...
  6. found:
  7.   ...
  9.   memset(&p->vma, 0, sizeof(p->vma));
  10.   return p;
  11. }

(4). 根据提示2、3、4，参考lazy实验中的分配方法（将当前p->sz作为分配的虚拟起始地址，但不实际分配物理页面），此函数写在sysfile.c中就可以使用静态函数argfd同时解析文件描述符和struct file

  1. uint64
  2. sys_mmap(void) {
  3.   uint64 addr;
  4.   int length;
  5.   int prot;
  6.   int flags;
  7.   int vfd;
  8.   struct file* vfile;
  9.   int offset;
  10.   uint64 err = 0xffffffffffffffff;
  12.   // 获取系统调用参数
  13.   if(argaddr(0, &addr) < 0 || argint(1, &length) < 0 || argint(2, &prot) < 0 ||
  14.     argint(3, &flags) < 0 || argfd(4, &vfd, &vfile) < 0 || argint(5, &offset) < 0)
  15.     return err;
  17.   // 实验提示中假定addr和offset为0，简化程序可能发生的情况
  18.   if(addr != 0 || offset != 0 || length < 0)
  19.     return err;
  21.   // 文件不可写则不允许拥有PROT_WRITE权限时映射为MAP_SHARED
  22.   if(vfile->writable == 0 && (prot & PROT_WRITE) != 0 && flags == MAP_SHARED)
  23.     return err;
  25.   struct proc* p = myproc();
  26.   // 没有足够的虚拟地址空间
  27.   if(p->sz + length > MAXVA)
  28.     return err;
  30.   // 遍历查找未使用的VMA结构体
  31.   for(int i = 0; i < NVMA; ++i) {
  32.     if(p->vma[i].used == 0) {
  33.       p->vma[i].used = 1;
  34.       p->vma[i].addr = p->sz;
  35.       p->vma[i].len = length;
  36.       p->vma[i].flags = flags;
  37.       p->vma[i].prot = prot;
  38.       p->vma[i].vfile = vfile;
  39.       p->vma[i].vfd = vfd;
  40.       p->vma[i].offset = offset;
  42.       // 增加文件的引用计数
  43.       filedup(vfile);
  45.       p->sz += length;
  46.       return p->vma[i].addr;
  47.     }
  48.   }
  50.   return err;
  51. }

(5). 根据提示5，此时访问对应的页面就会产生页面错误，需要在usertrap中进行处理，主要完成三项工作：分配物理页面，读取文件内容，添加映射关系

  1. void
  2. usertrap(void)
  3. {
  4.   ...
  5.   if(cause == 8) {
  6.     ...
  7.   } else if((which_dev = devintr()) != 0){
  8.     // ok
  9.   } else if(cause == 13 || cause == 15) {
  10. #ifdef LAB_MMAP
  11.     // 读取产生页面故障的虚拟地址，并判断是否位于有效区间
  12.     uint64 fault_va = r_stval();
  13.     if(PGROUNDUP(p->trapframe->sp) - 1 < fault_va && fault_va < p->sz) {
  14.       if(mmap_handler(r_stval(), cause) != 0) p->killed = 1;
  15.     } else
  16.       p->killed = 1;
  17. #endif
  18.   } else {
  19.     ...
  20.   }
  22.   ...
  23. }
  25. /**
  26.  * @brief mmap_handler 处理mmap惰性分配导致的页面错误
  27.  * @param va 页面故障虚拟地址
  28.  * @param cause 页面故障原因
  29.  * @return 0成功，-1失败
  30.  */
  31. int mmap_handler(int va, int cause) {
  32.   int i;
  33.   struct proc* p = myproc();
  34.   // 根据地址查找属于哪一个VMA
  35.   for(i = 0; i < NVMA; ++i) {
  36.     if(p->vma[i].used && p->vma[i].addr <= va && va <= p->vma[i].addr + p->vma[i].len - 1) {
  37.       break;
  38.     }
  39.   }
  40.   if(i == NVMA)
  41.     return -1;
  43.   int pte_flags = PTE_U;
  44.   if(p->vma[i].prot & PROT_READ) pte_flags |= PTE_R;
  45.   if(p->vma[i].prot & PROT_WRITE) pte_flags |= PTE_W;
  46.   if(p->vma[i].prot & PROT_EXEC) pte_flags |= PTE_X;
  49.   struct file* vf = p->vma[i].vfile;
  50.   // 读导致的页面错误
  51.   if(cause == 13 && vf->readable == 0) return -1;
  52.   // 写导致的页面错误
  53.   if(cause == 15 && vf->writable == 0) return -1;
  55.   void* pa = kalloc();
  56.   if(pa == 0)
  57.     return -1;
  58.   memset(pa, 0, PGSIZE);
  60.   // 读取文件内容
  61.   ilock(vf->ip);
  62.   // 计算当前页面读取文件的偏移量，实验中p->vma[i].offset总是0
  63.   // 要按顺序读读取，例如内存页面A,B和文件块a,b
  64.   // 则A读取a，B读取b，而不能A读取b，B读取a
  65.   int offset = p->vma[i].offset + PGROUNDDOWN(va - p->vma[i].addr);
  66.   int readbytes = readi(vf->ip, 0, (uint64)pa, offset, PGSIZE);
  67.   // 什么都没有读到
  68.   if(readbytes == 0) {
  69.     iunlock(vf->ip);
  70.     kfree(pa);
  71.     return -1;
  72.   }
  73.   iunlock(vf->ip);
  75.   // 添加页面映射
  76.   if(mappages(p->pagetable, PGROUNDDOWN(va), PGSIZE, (uint64)pa, pte_flags) != 0) {
  77.     kfree(pa);
  78.     return -1;
  79.   }
  81.   return 0;
  82. }

(6). 根据提示6实现munmap，且提示7中说明无需查看脏位就可写回

  1. uint64
  2. sys_munmap(void) {
  3.   uint64 addr;
  4.   int length;
  5.   if(argaddr(0, &addr) < 0 || argint(1, &length) < 0)
  6.     return -1;
  8.   int i;
  9.   struct proc* p = myproc();
  10.   for(i = 0; i < NVMA; ++i) {
  11.     if(p->vma[i].used && p->vma[i].len >= length) {
  12.       // 根据提示，munmap的地址范围只能是
  13.       // 1. 起始位置
  14.       if(p->vma[i].addr == addr) {
  15.         p->vma[i].addr += length;
  16.         p->vma[i].len -= length;
  17.         break;
  18.       }
  19.       // 2. 结束位置
  20.       if(addr + length == p->vma[i].addr + p->vma[i].len) {
  21.         p->vma[i].len -= length;
  22.         break;
  23.       }
  24.     }
  25.   }
  26.   if(i == NVMA)
  27.     return -1;
  29.   // 将MAP_SHARED页面写回文件系统
  30.   if(p->vma[i].flags == MAP_SHARED && (p->vma[i].prot & PROT_WRITE) != 0) {
  31.     filewrite(p->vma[i].vfile, addr, length);
  32.   }
  34.   // 判断此页面是否存在映射
  35.   uvmunmap(p->pagetable, addr, length / PGSIZE, 1);
  38.   // 当前VMA中全部映射都被取消
  39.   if(p->vma[i].len == 0) {
  40.     fileclose(p->vma[i].vfile);
  41.     p->vma[i].used = 0;
  42.   }
  44.   return 0;
  45. }

(7). 回忆lazy实验中，如果对惰性分配的页面调用了uvmunmap，或者子进程在fork中调用uvmcopy复制了父进程惰性分配的页面都会导致panic，因此需要修改uvmunmap和uvmcopy检查PTE_V后不再panic

  1. if((*pte & PTE_V) == 0)
  2.   continue;

(8). 根据提示8修改exit，将进程的已映射区域取消映射

  1. void
  2. exit(int status)
  3. {
  4.   // Close all open files.
  5.   for(int fd = 0; fd < NOFILE; fd++){
  6.     ...
  7.   }
  9.   // 将进程的已映射区域取消映射
  10.   for(int i = 0; i < NVMA; ++i) {
  11.     if(p->vma[i].used) {
  12.       if(p->vma[i].flags == MAP_SHARED && (p->vma[i].prot & PROT_WRITE) != 0) {
  13.         filewrite(p->vma[i].vfile, p->vma[i].addr, p->vma[i].len);
  14.       }
  15.       fileclose(p->vma[i].vfile);
  16.       uvmunmap(p->pagetable, p->vma[i].addr, p->vma[i].len / PGSIZE, 1);
  17.       p->vma[i].used = 0;
  18.     }
  19.   }
  21.   begin_op();
  22.   iput(p->cwd);
  23.   end_op();
  24.   ...
  25. }

(9). 根据提示9，修改fork，复制父进程的VMA并增加文件引用计数

  1. int
  2. fork(void)
  3. {
  4.  // increment reference counts on open file descriptors.
  5.   for(i = 0; i < NOFILE; i++)
  6.     ...
  7.   ...
  9.   // 复制父进程的VMA
  10.   for(i = 0; i < NVMA; ++i) {
  11.     if(p->vma[i].used) {
  12.       memmove(&np->vma[i], &p->vma[i], sizeof(p->vma[i]));
  13.       filedup(p->vma[i].vfile);
  14.     }
  15.   }
  17.   safestrcpy(np->name, p->name, sizeof(p->name));
  19.   ...
  20. }