(undone) MIT6.S081 2023 学习笔记 (Day11: LAB10 mmap)

url: https://pdos.csail.mit.edu/6.1810/2023/labs/mmap.html

---

任务0：讲义如下 (完成)

mmap和munmap系统调用允许UNIX程序对其地址空间进行精细控制。它们可用于进程间共享内存、将文件映射到进程地址空间，并作为用户级页面错误处理方案的一部分，例如课程中讨论的垃圾回收算法。在本实验中，您将向xv6添加mmap和munmap功能，重点关注内存映射文件。

The manual page (run man 2 mmap) shows this declaration for mmap:

void *mmap(void *addr, size_t len, int prot, int flags,int fd, off_t offset);

mmap 可以通过多种方式调用，但本实验仅需要实现与文件内存映射相关的部分功能。您可以假设 addr 始终为零，这意味着内核应自行决定文件的映射虚拟地址。mmap 会返回该地址，如果失败则返回 0xffffffffffffffff。len 是要映射的字节数，它可能与文件长度不同。prot 表示内存是否应映射为可读、可写和/或可执行；您可以假设 prot 是 PROT_READ 或 PROT_WRITE 或两者兼具。flags 可以是 MAP_SHARED（表示对映射内存的修改应写回文件）或 MAP_PRIVATE（表示不应写回文件），无需实现其他标志位。fd 是要映射的文件的打开文件描述符。您可以假设 offset 为零（即文件中的映射起始位置）。

即使映射相同 MAP_SHARED 文件的进程不共享物理页，也是允许的。

munmap 的手册页（运行 man 2 munmap）显示其声明如下：

int munmap(void *addr, size_t len);

munmap 应移除指定地址范围内的内存映射。如果进程修改了该内存区域且映射方式为 MAP_SHARED，则需先将修改内容写回文件。munmap 可能仅解除部分 mmap 映射区域，但可以假设其操作范围仅限于：从起始位置解除、从末尾解除，或解除整个区域（而不会在区域中间“打洞”解除部分映射）。

你需要实现足够的 mmap 和 munmap 功能，以确保 mmaptest 测试程序能够正常运行。如果 mmaptest 没有用到某个 mmap 的特性，你就不需要实现该特性。

When you’re done, you should see this output:

$ mmaptest
mmap_test starting
test mmap f
test mmap f: OK
test mmap private
test mmap private: OK
test mmap read-only
test mmap read-only: OK
test mmap read/write
test mmap read/write: OK
test mmap dirty
test mmap dirty: OK
test not-mapped unmap
test not-mapped unmap: OK
test mmap two files
test mmap two files: OK
mmap_test: ALL OK
fork_test starting
fork_test OK
mmaptest: all tests succeeded
$ usertests -q
usertests starting
...
ALL TESTS PASSED
$ 

以下是一些提示：

• 首先，将 _mmaptest 添加到 UPROGS 中，并添加 mmap 和 munmap 系统调用，以便编译 user/mmaptest.c。目前，只需从 mmap 和 munmap 返回错误。我们在 kernel/fcntl.h 中为您定义了 PROT_READ 等。运行 mmaptest，它将在第一个 mmap 调用失败。
• 在页面错误处理时懒加载页表。也就是说，mmap 不应分配物理内存或读取文件。相反，在 usertrap 中（或由 usertrap 调用的页面错误处理代码中）执行此操作，就像写时复制实验一样。懒加载的原因是为了确保对大文件的 mmap 快速，并且对大于物理内存的文件的 mmap 成为可能。
• 跟踪每个进程 mmap 映射的内容。定义一个与“应用程序的虚拟内存”讲座中描述的 VMA（虚拟内存区域）相对应的结构。这应该记录由 mmap 创建的虚拟内存范围的地址、长度、权限、文件等。由于 xv6 内核中没有内核内存分配器，因此可以声明一个固定大小的 VMA 数组，并根据需要从中分配。大小为 16 应该足够。
• 实现 mmap：在进程的地址空间中找到一个未使用的区域来映射文件，并将一个 VMA 添加到进程的映射区域表中。VMA 应该包含一个指向被映射文件的 struct file 的指针；mmap 应该增加文件的引用计数，以便在文件关闭时结构不会消失（提示：参见 filedup）。运行 mmaptest：第一个 mmap 应该成功，但是对 mmap-ed 内存的第一次访问将导致页面错误并杀死 mmaptest。
• 添加代码以使 mmap-ed 区域的页面错误分配一个物理页面的内存，将相关文件的 4096 字节读取到该页面，并将其映射到用户地址空间。使用 readi 读取文件，该文件需要一个偏移参数来读取文件（但是您将不得不锁定/解锁传递给 readi 的 inode）。不要忘记正确设置页面的权限。运行 mmaptest；它应该到达第一个 munmap。
• 实现 munmap：找到地址范围的 VMA 并取消映射指定的页面（提示：使用 uvmunmap）。如果 munmap 删除了之前 mmap 的所有页面，则应该减少相应 struct file 的引用计数。如果取消映射的页面已被修改并且文件被映射为 MAP_SHARED，则应将页面写回文件。查看 filewrite 以获取灵感。
• 理想情况下，您的实现只会写回程序实际修改的 MAP_SHARED 页面。RISC-V PTE 中的脏位（D）指示页面是否已被写入。但是，mmaptest 不会检查未修改的页面是否没有被写回；因此，您可以不查看 D 位就写回页面。
• 修改 exit 以取消映射进程的映射区域，就像调用了 munmap 一样。运行 mmaptest；mmap_test 应该通过，但可能不是 fork_test。
• 修改 fork 以确保子进程具有与父进程相同的映射区域。不要忘记增加 VMA 的 struct file 的引用计数。在子进程的页面错误处理程序中，分配一个新的物理页面而不是与父进程共享页面是可以的。后者会更酷，但需要更多的实现工作。运行 mmaptest；它应该通过 mmap_test 和 fork_test。

运行 usertests -q 以确保一切仍然正常工作。

---

任务1：解析 mmaptest 源码 (完成)

先修改 Makefile，运行 make qemu

结果如下：

可以看到报错没有 mmap 和 munmap 两个系统调用。

先来看 mmaptest.c 源码:

main 函数，测试分为 mmap_test 和 fork_test 两部分

int
main(int argc, char *argv[])
{mmap_test();fork_test();printf("mmaptest: all tests succeeded\n");exit(0);
}

makefile 函数，创建文件 f，里面含有 1.5 个内存页的 A

//
// create a file to be mapped, containing
// 1.5 pages of 'A' and half a page of zeros.
//
void
makefile(const char *f)
{int i;// n = 一个内存页能映射的块数int n = PGSIZE/BSIZE;// 删除文件 funlink(f);// 创建文件 fint fd = open(f, O_WRONLY | O_CREATE);if (fd == -1)err("open");// 设置内存 buf 为全 Amemset(buf, 'A', BSIZE);// write 1.5 page，即文件 f 拥有 1.5 个内存页的 Afor (i = 0; i < n + n/2; i++) {if (write(fd, buf, BSIZE) != BSIZE)err("write 0 makefile");}// 关闭文件if (close(fd) == -1)err("close");
}

_v1 用来验证映射的内存为 1.5 页 A 和 0.5 页 0

//
// check the content of the two mapped pages.
//
void
_v1(char *p)
{// 循环遍历两个页的所有字节，1.5个页为 A，0.5 个页为 0int i;for (i = 0; i < PGSIZE*2; i++) {if (i < PGSIZE + (PGSIZE/2)) {if (p[i] != 'A') {printf("mismatch at %d, wanted 'A', got 0x%x\n", i, p[i]);err("v1 mismatch (1)");}} else {if (p[i] != 0) {printf("mismatch at %d, wanted zero, got 0x%x\n", i, p[i]);err("v1 mismatch (2)");}}}
}

接下来看 mmap_test 源码：
做了以下测试：
1.检测 mmap 是否起作用，能否把文件内容映射到进程内存
2.检测 PROT_WRITE 是否可用
… （直接看源码里的注释吧，一共7个测试）

void
mmap_test(void)
{int fd;int i;const char * const f = "mmap.dur";printf("mmap_test starting\n");testname = "mmap_test";//// create a file with known content, map it into memory, check that// the mapped memory has the same bytes as originally written to the// file.//// 创建文件 f，内含 1.5 个内存页的 A 和 0.5 个内存页的 0makefile(f);if ((fd = open(f, O_RDONLY)) == -1)err("open (1)");printf("test mmap f\n");//// this call to mmap() asks the kernel to map the content// of open file fd into the address space. the first// 0 argument indicates that the kernel should choose the// virtual address. the second argument indicates how many// bytes to map. the third argument indicates that the// mapped memory should be read-only. the fourth argument// indicates that, if the process modifies the mapped memory,// that the modifications should not be written back to// the file nor shared with other processes mapping the// same file (of course in this case updates are prohibited// due to PROT_READ). the fifth argument is the file descriptor// of the file to be mapped. the last argument is the starting// offset in the file.//// void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);// addr: 建议的映射起始地址，通常设为 NULL 让内核自动选择// length: 要映射的区域长度// prot: 内存保护标志，可以是以下值的组合：//   PROT_READ: 可读//   PROT_WRITE: 可写//   PROT_EXEC: 可执行//   PROT_NONE: 不可访问// flags: 映射类型和选项，常用值：//   MAP_SHARED: 共享映射，修改会写回文件//   MAP_PRIVATE: 私有映射，修改不会影响原文件(会读取文件上的内容，但不会修改原文件，也不会同步其它进程的更新)//   MAP_ANONYMOUS: 匿名映射，不与文件关联//   MAP_FIXED: 强制使用指定的地址// fd: 文件描述符，匿名映射时设为 -1// offset: 文件偏移量，通常为 0// 返回值://   成功时返回映射区域的起始地址，失败返回 MAP_FAILED ((void *)-1)// 映射的进程内存起始地址由内核选择，映射长度为两个页，内存只读，私有映射，映射文件 f，偏移量为0char *p = mmap(0, PGSIZE*2, PROT_READ, MAP_PRIVATE, fd, 0);if (p == MAP_FAILED)err("mmap (1)");// 验证映射内存是否为 1.5 页A 和 0.5 页 0_v1(p);// int munmap(void *addr, size_t length); // 用于解除内存映射// addr: 映射区域的起始地址// length: 要解除映射的区域长度// 返回值//   成功返回 0，失败返回 -1// 解除刚才的映射if (munmap(p, PGSIZE*2) == -1)err("munmap (1)");printf("test mmap f: OK\n");printf("test mmap private\n");// should be able to map file opened read-only with private writable// mapping// 一样的映射，只是映射的内存的操作权限变成可读可写 (一个只读打开的文件应该能使用 mmap PRIVATE 创建可写的内存)p = mmap(0, PGSIZE*2, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);if (p == MAP_FAILED)err("mmap (2)");if (close(fd) == -1)err("close (1)");// 验证映射内容是否正确_v1(p);// 对映射内存修改for (i = 0; i < PGSIZE*2; i++)p[i] = 'Z';if (munmap(p, PGSIZE*2) == -1)err("munmap (2)");printf("test mmap private: OK\n");printf("test mmap read-only\n");// 如果是只读打开这个文件，那么 mmap 不允许 PROT_WRITE 和 MAP_SHARED 同时存在// check that mmap doesn't allow read/write mapping of a// file opened read-only.if ((fd = open(f, O_RDONLY)) == -1)err("open (2)");p = mmap(0, PGSIZE*3, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (p != MAP_FAILED)err("mmap (3)");if (close(fd) == -1)err("close (2)");printf("test mmap read-only: OK\n");printf("test mmap read/write\n");// 检测：如果文件是可读可写打开的，那么就可以让 mmap 能读写它// 注意：这里 mmap 映射了三页// check that mmap does allow read/write mapping of a// file opened read/write.if ((fd = open(f, O_RDWR)) == -1)err("open (3)");p = mmap(0, PGSIZE*3, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);if (p == MAP_FAILED)err("mmap (4)");if (close(fd) == -1)err("close (3)");// check that the mapping still works after close(fd)._v1(p);// write the mapped memory.for (i = 0; i < PGSIZE*2; i++)p[i] = 'Z';// unmap just the first two of three pages of mapped memory.if (munmap(p, PGSIZE*2) == -1)err("munmap (3)");printf("test mmap read/write: OK\n");printf("test mmap dirty\n");// 检查上一次测试的写入是否生效// check that the writes to the mapped memory were// written to the file.if ((fd = open(f, O_RDWR)) == -1)err("open (4)");for (i = 0; i < PGSIZE + (PGSIZE/2); i++){char b;if (read(fd, &b, 1) != 1)err("read (1)");if (b != 'Z')err("file does not contain modifications");}if (close(fd) == -1)err("close (4)");printf("test mmap dirty: OK\n");printf("test not-mapped unmap\n");// unmap the rest of the mapped memory.// 检测是否能分多次 unmap 去解除一次 mmap 的映射if (munmap(p+PGSIZE*2, PGSIZE) == -1)err("munmap (4)");printf("test not-mapped unmap: OK\n");printf("test mmap two files\n");// 检测是否能同时映射两个文件//// mmap two files at the same time.//int fd1;if((fd1 = open("mmap1", O_RDWR|O_CREATE)) < 0)err("open (5)");if(write(fd1, "12345", 5) != 5)err("write (1)");char *p1 = mmap(0, PGSIZE, PROT_READ, MAP_PRIVATE, fd1, 0);if(p1 == MAP_FAILED)err("mmap (5)");if (close(fd1) == -1)err("close (5)");if (unlink("mmap1") == -1)err("unlink (1)");int fd2;if((fd2 = open("mmap2", O_RDWR|O_CREATE)) < 0)err("open (6)");if(write(fd2, "67890", 5) != 5)err("write (2)");char *p2 = mmap(0, PGSIZE, PROT_READ, MAP_PRIVATE, fd2, 0);if(p2 == MAP_FAILED)err("mmap (6)");if (close(fd2) == -1)err("close (6)");if (unlink("mmap2") == -1)err("unlink (2)");if(memcmp(p1, "12345", 5) != 0)err("mmap1 mismatch");if(memcmp(p2, "67890", 5) != 0)err("mmap2 mismatch");if (munmap(p1, PGSIZE) == -1)err("munmap (5)");if(memcmp(p2, "67890", 5) != 0)err("mmap2 mismatch (2)");if (munmap(p2, PGSIZE) == -1)err("munmap (6)");printf("test mmap two files: OK\n");printf("mmap_test: ALL OK\n");
}

fork_test 源码如下：
在测试父子进程都调用 mmap 和 unmmap 时的影响

//
// mmap a file, then fork.
// check that the child sees the mapped file.
//
void
fork_test(void)
{int fd;int pid;const char * const f = "mmap.dur";printf("fork_test starting\n");testname = "fork_test";// 创建文件 f，映射文件两次 p1 p2// mmap the file twice.makefile(f);if ((fd = open(f, O_RDONLY)) == -1)err("open (7)");if (unlink(f) == -1)err("unlink (3)");char *p1 = mmap(0, PGSIZE*2, PROT_READ, MAP_SHARED, fd, 0);if (p1 == MAP_FAILED)err("mmap (7)");char *p2 = mmap(0, PGSIZE*2, PROT_READ, MAP_SHARED, fd, 0);if (p2 == MAP_FAILED)err("mmap (8)");// read just 2nd page.if(*(p1+PGSIZE) != 'A')err("fork mismatch (1)");// 子进程取消掉 p1 的映射if((pid = fork()) < 0)err("fork");if (pid == 0) {_v1(p1);if (munmap(p1, PGSIZE) == -1) // just the first pageerr("munmap (7)");exit(0); // tell the parent that the mapping looks OK.}// 等待子进程结束int status = -1;wait(&status);if(status != 0){printf("fork_test failed\n");exit(1);}// 检查 p1 p2 指向的映射内存里的内容是否不变// check that the parent's mappings are still there._v1(p1);_v1(p2);printf("fork_test OK\n");
}

---

任务2：完成作业 (doing)

TODO: here

---