MIT6.s081 lab10 mmap 总结

最新推荐文章于 2024-07-20 09:08:34 发布
最新推荐文章于 2024-07-20 09:08:34 发布
阅读量230 收藏
点赞数
分类专栏： mit6.s081 文章标签： linux c语言 vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51260846/article/details/129876596
版权

时间及结果

总耗时: 6h27min

解析

系统调用原型

本次lab要求实现mmap和munmap系统调用，系统调用原型如下:

// xv6中没有定义size_t和off_t，故修改为uint64
void *mmap(void *addr, uint64 length, int prot, int flags,
           int fd, uint64 offset);
int munmap(void *addr, uint64 length);
// addr: 指定的虚拟地址，此lab中默认为0，即由内核决定映射的虚拟地址；
// length: 映射的字节数；
// prot: 可选 PROT_READ PROT_WRITE，用以表明映射部分的读写权限；
// flags: MAP_SHARED表示映射内存的修改要写回文件，MAP_PRIVATE则无需写回；
// fd: 要映射的文件；
// offset: 文件的偏移量

// mmap系统调用将文件fd从offset开始的length字节映射到虚拟地址addr处
// munmap系统调用取消虚拟地址addr开始的length字节的文件映射

思路

首先需要定义VMA数据结构来保存一段文件映射的相关信息:

// kernel/proc.h
#define MAXMMAP 16
struct VMA{
  uint64 addr;
  uint64 length;
  int prot;
  int flags;
  struct file *f;
  uint64 offset;
  int used; // 1 说明该VMA在使用中；0 说明空闲
  struct spinlock lock;
};
// 在struct proc中新增VMA数组，支持MAXMMAP个元素
// struct VMA proc_VMA[MAXMMAP];

该数据结构的初始化时机和释放时机与进程proc结构的其它项相同:

// kernel/proc.c: allocproc()
for(int i = 0; i < MAXMMAP; i++) {
  p->proc_VMA[i].addr = 0;
  p->proc_VMA[i].f = 0;
  p->proc_VMA[i].flags = 0;
  p->proc_VMA[i].length = 0;
  p->proc_VMA[i].offset = 0;
  p->proc_VMA[i].prot = 0;
  p->proc_VMA[i].used = 0;
}

// kernel/proc.c: freeproc()
for (int i = 0; i < MAXMMAP; i++) {
  p->proc_VMA[i].addr = 0;
  p->proc_VMA[i].f = 0;
  p->proc_VMA[i].flags = 0;
  p->proc_VMA[i].length = 0;
  p->proc_VMA[i].offset = 0;
  p->proc_VMA[i].prot = 0;
  p->proc_VMA[i].used = 0;
}

添加系统调用的过程可以参照前面的lab，此处只记录系统调用的实现。

对于mmap系统调用，可以参考lazy allocation中的sbrk系统调用，仅增加myproc()->sz，不实际分配物理内存，而是在缺页故障的处理中分配物理页。

此处实现的mmap系统调用是直接从堆区获取虚拟内存来存放文件映射部分，而没有像linux那样单独划给文件映射区一片内存。

// kernel/sysfile.c
uint64 sys_mmap(void) {
  uint64 addr, length, offset;
  int prot, flags, fd, i;
  struct proc *p = myproc();
  struct file *f;
  // 获取系统调用参数
  if(argaddr(0, &addr) < 0 || argaddr(1, &length) < 0 || argaddr(5, &offset) < 0) {
    return -1;
  }
  if(argint(2, &prot) < 0 || argint(3, &flags) < 0 || argint(4, &fd) < 0) {
    return -1;
  }
  if(addr != 0) {
    panic("sys_mmap: addr just can be 0 in my mmap");
  }

  acquire(&p->lock);
  // 如果flags指定映射区的修改要写回文件
  // 那么该文件的读写权限和prot参数指定的读写权限必须相容
  if(flags & MAP_SHARED) {
    if(p->ofile[fd]->readable == 0 && (prot & PROT_READ)) {
      release(&p->lock);
      return -1;
    }
    if(p->ofile[fd]->writable == 0 && (prot & PROT_WRITE)) {
      release(&p->lock);
      return -1;
    }
  }

  // 仅增加p->sz，等缺页故障时再实际分配物理页
  addr = p->sz;
  p->sz += length;
  f = filedup(p->ofile[fd]);  // 注意要增加文件的引用

  // 找到一个空闲VMA用来存放文件映射的相关信息
  for(i = 0; i < MAXMMAP; i++) {
    if(p->proc_VMA[i].used == 0) {
      p->proc_VMA[i].addr = addr;
      p->proc_VMA[i].f = f;
      p->proc_VMA[i].flags = flags;
      p->proc_VMA[i].length = length;
      p->proc_VMA[i].offset = offset;
      p->proc_VMA[i].prot = prot;
      p->proc_VMA[i].used = 1;
      break;
    }
  }
  if(i == MAXMMAP) {
    panic("no free VMA for mmap");
  }
  release(&p->lock);
  return addr;
}

接下来需要考虑在缺页故障中为文件映射实际分配物理内存，定义isMmap()函数用来判断一个地址是否是文件映射的页，定义handleMmap()函数为一个地址实际分配物理页并写入相关文件数据

// kernel/trap.c
/**
 * @description: 判断传入的地址是否是文件映射的地址
 * @param {uint64} addr 虚拟地址
 * @return {*} 返回VMA编号，可以从myproc()->proc_VMA中获取相应VMA
 *             返回-1说明该地址不是文件映射的地址
 */
int isMmap(uint64 addr) {
  struct proc *p = myproc();
  uint64 begin, end;
  // 遍历当前进程的每个使用中的VMA，找到包含地址addr的那个
  for(int i = 0; i < MAXMMAP; i++) {
    if(p->proc_VMA[i].used) {
      begin = p->proc_VMA[i].addr;
      end = p->proc_VMA[i].addr + p->proc_VMA[i].length;
      if(p->proc_VMA[i].used == 1 && (addr >=  begin && addr < end)) {
        return i;
      }
    }
  }
  return -1;
}

/**
 * @description:  为文件映射的一页分配物理页
 * @param {uint64} addr 文件映射的一个虚拟地址
 * @param {int} index 这个文件映射对应的VMA编号，是isMmap的返回值
 * @return {*}
 */
void handleMmap(uint64 addr, int index) {
  struct proc *p = myproc();
  uint64 pa = (uint64)kalloc();
  int perm = 0, prot, off;
  struct inode *ip;
  if(pa == 0) { // 物理页不够
    panic("handleMmap: no pa");
  } else {
    memset((void*)pa, 0, PGSIZE);

    // 将文件数据读入物理页
    ip = p->proc_VMA[index].f->ip;
    off = p->proc_VMA[index].offset + (PGROUNDDOWN(addr) - p->proc_VMA[index].addr);
    ilock(ip);
    begin_op();
    readi(ip, 0, pa, off, PGSIZE);
    end_op();
    iunlock(ip);

    // 设置PTE权限
    prot = p->proc_VMA[index].prot;
    if(prot & PROT_READ) {
      perm |= PTE_R;
    }
    if(prot & PROT_WRITE) {
      perm |= PTE_W;
    }
    if(prot & PROT_EXEC) {
      perm |= PTE_X;
    }
    perm |= PTE_U;

    // 设置虚拟地址和物理地址的映射
    if((mappages(p->pagetable, PGROUNDDOWN(addr), PGSIZE, pa, perm)) < 0) {
      panic("handleMmap: mappages f");
    }
  }
}

像lazy allocation那样，在usertrap()中处理缺页故障；并且在uvmunmap()和uvmcopy()中跳过处理未定义或未分配的页表项，在walkaddr中为文件映射分配物理页

// kernel/trap.c: usertrap()
else if(scause == 13 || scause == 15) {
  int index;
  // 是mmap则分配物理页
  if((index = isMmap(r_stval())) >= 0) { 
    handleMmap(r_stval(), index);
  } else { // 不是mmap则说明访问了未使用的页，应该杀死进程
    printf("is no mmap\n");
    printf("usertrap(): unexpected scause %p pid=%d\n", r_scause(), p->pid);
    printf("            sepc=%p stval=%p\n", r_sepc(), r_stval());
    p->killed = 1;
  }
} 

// kernel/vm.c: uvmunmap()
if((pte = walk(pagetable, a, 0)) == 0)
  continue;
  // panic("uvmunmap: walk");
if((*pte & PTE_V) == 0)
  continue;
  // panic("uvmunmap: not mapped");

// kernel/vm.c: uvmcopy()
if((pte = walk(old, i, 0)) == 0)
  continue;
  // panic("uvmcopy: pte should exist");
if((*pte & PTE_V) == 0)
  continue;
  // panic("uvmcopy: page not present");

// kernel/vm.c: walkaddr()
if(pte == 0 || (*pte & PTE_V) == 0) {
  int index;
  if((index = isMmap(va)) >= 0) {
    handleMmap(va, index);
  } else {
    return 0;
  }
}

至此，mmap部分就完成了。

munmap系统调用取消一个文件映射的部分或全部，并将设置了MAP_SHARED的文件映射写回文件中

// kernel/sysfile.c
/**
 * @description: 将从addr开始的length取消文件映射
 * @param {uint64} addr 虚拟地址
 * @param {uint64} length 字节数
 * @return {*}
 */
uint64 munmap(uint64 addr, uint64 length) {
  struct proc *p = myproc();
  int i;
  uint64 begin = 0, end = 0;
  // 查找包含地址addr的文件映射所对应的VMA
  for(i = 0; i < MAXMMAP; i++) {
    if(p->proc_VMA[i].used) {
      begin = p->proc_VMA[i].addr;
      end = p->proc_VMA[i].addr + p->proc_VMA[i].length;
      if(addr >= begin && addr < end) {
        break;
      }
    }
  }
  if (addr < begin || addr >= end) {
    panic("sys_munmap: addr not mmap");
  }
  // flags设置了MAP_SHARED的文件映射应该写回文件中
  if(p->proc_VMA[i].flags & MAP_SHARED) {
    for(uint64 index = PGROUNDDOWN(addr); index != PGROUNDUP(addr + length); index += PGSIZE) {
      pte_t *pte = walk(p->pagetable, index, 0);
      // 未分配物理页的文件映射应该跳过
      if(pte == 0 || (*pte & PTE_V) == 0) {
        continue;
      }
      begin_op();
      if(writei(p->proc_VMA[i].f->ip, 1, index, p->proc_VMA[i].offset + (index - addr), PGSIZE) < 0) {
        panic("sys_munmap: write");
      }
      end_op();
    } 
  }
  // 在页表上取消对应映射区域的PTE
  uvmunmap(p->pagetable, PGROUNDDOWN(addr), (PGROUNDUP(addr + length) - PGROUNDDOWN(addr)) / PGSIZE, 1);
  // 进行munmap的地址从该文件映射的开头开始
  if(addr == begin) {
    if(addr + length == end) { // 说明munmap的地址范围覆盖了该文件映射的全部，应该释放相应VMA，并减少文件引用
      p->proc_VMA[i].used = 0;
      struct file *f = p->proc_VMA[i].f;
      fileclose(f);
      return 0;
    } else { // 说明munmap的地址范围只有该文件映射的前半部分
      p->proc_VMA[i].addr = addr + length;
      p->proc_VMA[i].length -= length;
      p->proc_VMA[i].offset += length;
    }
  } else { // 进行munmap的地址从该文件映射的中间开始，一直到结尾(题目提示此时munmap的地址范围一定会在该文件映射的最后结束)
    p->proc_VMA[i].length -= length;
  }

  return 0;
}

uint64 sys_munmap(void) {
  uint64 addr;
  uint64 length;
  if(argaddr(0, &addr) < 0 || argaddr(1, &length) < 0) {
    return -1;
  }
  return munmap(addr, length);
}

至此，munmap系统调用也实现了。

还需要再处理一下exit()和fork()。

exit()函数中需要对该进程的全部文件映射进行munmap

// kernel/proc.c: exit()
for(int i = 0; i < MAXMMAP; i++) {
  if(p->proc_VMA[i].used) {
    // 偷懒直接调用了sys_munmap用的munmap函数
    munmap(p->proc_VMA[i].addr, p->proc_VMA[i].length);
  }
}

fork函数应该让子进程继承父进程的VMA和相应的文件映射，注意文件引用要加1。

文件映射的PTE会在uvmcopy()中继承。

for(int i = 0; i < MAXMMAP; i++) {
  np->proc_VMA[i] = p->proc_VMA[i];
  if(np->proc_VMA[i].f) filedup(np->proc_VMA[i].f);
}

至此，即可通过mmaptest和usertests。

陆加壹的数据
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MIT6.S081学习总结-lab10:mmap
laplacebh的博客
07-09 1315
lab10 实现mmap 介绍 mmap和munmap系统调用允许UNIX程序对它们的地址空间进行详细的控制。它们可以用于在进程之间共享内存，将文件映射到进程地址空间，以及作为用户级页面错误方案的一部分，比如在讲座中讨论的垃圾收集算法。在本实验中，您将向xv6添加mmap和munmap，重点关注内存映射文件。 void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); mmap可以通过多种方
[MIT 6.S081] Lab 10: mmap
LostUnravel的博客
11-20 2940
Lab 10: mmap Lab Guidance: https://pdos.csail.mit.edu/6.828/2020/labs/mmap.html Lab Code: https://github.com/VastRock-Huang/xv6-labs-2020/tree/mmap mmap (hard) 要点 实现只考虑内存映射文件的 mmap 和 munmap 系统调用. mmap 参数 addr 一直为 0, 由内核决定映射文件的虚拟地址. mmap 参数 flags 只考虑 MAP
「实验记录」MIT 6.S081 Lab10 mmap
士全的CSDN，用心连载，欢迎关注
02-23 553
MIT 6.S081 Lab10 mmap 主要从虚拟内存的另一用法：文件映射的角度出发，完成 mmap 机制的设计与实现
MIT 6.S081 lab 10：Mmap
weixin_43174477的博客
08-12 836
Lab: mmap mmap和munmap系统调用允许UNIX程序对地址空间进行细节控制。这可以被用来在多进程之间分享内存，把文件映射到进程地址空间，还有作为一部分用户层页错方案，比如在讲座中谈到的垃圾回收算法。在这个实验中，你将会给xv6添加mmap和munmap到xv6，关注于内存映射文件。 mmap能够用于很多场景，但是这个实验只需要实现文件内存映射的相关特性即可。你可以假设addr一直是0，意味着内核应当决定在什么虚拟地址映射这个文件。如果失败，mmap会返回 0xffffffffffffffff。
6.S081-Lab1 总结笔记（0基础向）
edadada的博客
08-25 2834
6.S081总结笔记目标：按照11个lab的顺序，整理所涉及到的知识
xv6-labs-2020:MIT 6.S081 2020秋季操作系统
03-30
xv6-riscv-lab MIT 6.S081 / 2020年秋季实验室 进度 Lab1 Lab2 Lab3 Lab4陷阱 Lab5延迟分配 Lab6写时复制 Lab7多线程 Lab8锁 Lab9文件系统 Lab10 mmap Lab11网络驱动程序 文件 Lab1 Lab2 Lab3
com.tencent.weishi.mmap3
05-24
com.tencent.weishi.mmap3
JUC2019.6V1.5.mmap
05-17
JUC2019.6V1.5.mmap
SpringCloud第2季2020.3.2.mmap
06-04
2020最新版SpringCloud(H版&alibaba)框架开发教程完整版脑图，包含有完整大纲和详细的备注信息
SpringCloud 第二季2020.03.05.mmap
07-23
SpringCloud 第二季2020.03.05.mmap
MIT6.S081学习总结-lab6:Copy-On-Write Fork
laplacebh的博客
06-30 996
lab6 也是虚拟内存的一种应用，主要实现fork时的写时复制copy-on-write功能。 问题 xv6中的fork()系统调用将所有父进程的用户空间内存复制到子进程中。如果父进程用户空间很大，复制可能需要很长时间。更糟糕的是，这种复制工作经常被浪费;例如，子进程中的fork()后跟exec()将导致子进程丢弃复制的内存，可能根本就没有使用复制来的很大一部分内存。另一方面，如果父类和子类都使用一个页面，而其中一方或双方都编写该页面，则确实需要一个副本。 解决方法 写时拷贝(COW) fork()的目标是
Mit 6.S081 mmap
RolleX的博客
07-13 134
虚拟内存的初衷是为了增加隔离性，如进程A在物理内存addr64处存放一个变量i，进程B在物理内存addr128存放一个变量j。这会一切正常，但如果进程A在后续中在addr128又存放一个变量k，这时就乱了。进程A操纵了进程B的地址，把进程B的变量覆盖了。这就是因为没有隔离性造成的。所以虚拟内存的就是。
python：mmap --- 内存映射文件支持
点点关注不迷路
03-09 406
python：mmap --- 内存映射文件支持
Linux -软件安装
z2331198564653的博客
07-18 884
项目开发好需要部署，而项目本身可能依赖其他软件。这时在部署项目时就需要安装依赖的软件。比如: jdk mysql tomcat redis rabbitmq es等。
Linux中的环境变量
qhy850716的博客
07-17 575
我们思考这样一个问题：指令也是可执行程序，我们写好的编译好的c语言也是程序，为什么我们在执行c语言程序时要./a.out带上当前路径，而ls这种指令就不要带路径呢？这就是环境变量PATH的作用，Linux中存在一些全局设置，表明命令行解释器应该去哪个路径下寻找可执行程序。系统中的很多配置在我们登录Linux时就已经被加载到bash中了，也就是内存。
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
最新发布
gzx233的博客
07-20 860
Shell脚本的使用
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 977
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
Linux 权限
includemainprinf的博客
07-18 679
在Linux操作系统中，权限管理是一个至关重要的概念，它确保了系统的安全性和稳定性。同时可以在工作中，设置对象的权限，就算我们很多人使用一台服务器，我们也可以让别人看不到我们文件的内容，或者让别人无法对自己的文件进行操作！
mit6.828hw12mmap
09-10
对于MIT 6.828课程的hw12，它是关于内存映射（mmap）的。内存映射是一种通过将文件映射到进程的地址空间来实现文件与内存之间数据共享的技术。在该作业中，你可能需要实现一些与内存映射相关的功能或解决一些相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值