Memory Mapped Files
In this section, you will implement memory-mapped pages. Unlike anonymous pages, memory-mapped pages are file-backed mappings. The contents in the page mirror data in some existing file. If a page fault occurs, a physical frame is immediately allocated and the contents are copied into the memory from the file. When memory-mapped pages are unmapped or swapped out, any change in the content is reflected in the file.
munmap System Call
munmap, which are the two system calls for memory
mapped files. Your VM system must load pages lazily in mmap regions and use the
mmaped file itself as a backing store for the mapping. You should implement and
do_munmap defined in
vm/file.c to implement these two
void *mmap (void *addr, size_t length, int writable, int fd, off_t offset);
lengthbytes the file open as
offsetbyte into the process's virtual address space at
addr. The entire file is mapped into consecutive virtual pages starting at
addr. If the length of the file is not a multiple of PGSIZE, then some bytes in the final mapped page "stick out" beyond the end of the file. Set these bytes to zero when the page is faulted in, and discard them when the page is written back to disk. If successful, this function returns the virtual address where the file is mapped. On failure, it must return NULL which is not a valid address to map a file.
A call to
mmap may fail if the file opened as fd has a length of zero bytes.
It must fail if addr is not page-aligned or if the range of pages mapped
overlaps any existing set of mapped pages, including the stack or pages mapped
at executable load time. In Linux, if
addr is NULL, the kernel finds an
appropriate address at which to create the mapping. For simplicity, you can just
attempt to mmap at the given
addr. Therefore, if
addr is 0, it must fail,
because some Pintos code assumes virtual page 0 is not mapped. Your mmap should
also fail when
length is zero. Finally, the file descriptors representing
console input and output are not mappable.
Memory-mapped pages should be also allocated in a lazy manner just like
anonymous pages. You can use
to make a page object.
void munmap (void *addr);
Unmaps the mapping for the specified address range
addr, which must be the virtual address returned by a previous call to mmap by the same process that has not yet been unmapped.
All mappings are implicitly unmapped when a process exits, whether via
by any other means. When a mapping is unmapped, whether implicitly or
explicitly, all pages written to by the process are written back to the file,
and pages not written must not be. The pages are then removed from the process's
list of virtual pages.
Closing or removing a file does not unmap any of its mappings. Once created, a
mapping is valid until
munmap is called or the process exits, following the
Unix convention. See Removing an Open File for more
information. You should use the
file_reopen function to obtain a separate and
independent reference to the file for each of its mappings.
If two or more processes map the same file, there is no requirement that they see consistent data. Unix handles this by making the two mappings share the same physical page, and the mmap system call also has an argument allowing the client to specify whether the page is shared or private (i.e. copy-on-write).
You may want to modify
according to your needs.
void vm_file_init (void);
Initializes the file-backed page subsystem. In this function, you can setup anything related to the file backed page.
bool file_backed_initializer (struct page *page, enum vm_type type, void *kva);
Initializes a file-backed page. The function first sets up the handlers for file-backed pages in
page->operations. You may want to update some information on the page struct, such as the file that is backing the memory.
static void file_backed_destroy (struct page *page);
Destroys the file backed page by closing the associated file. If the content is dirty, make sure you write back the changes into the file. You do not need to free the page struct in this function. The caller of
file_backed_destroyshould handle it.