Update frame: When evicting an mmapped file page, write it back to the file if it is dirty

src/userprog/exception.c

@@ -271,9 +271,7 @@ fetch_page (void *upage, bool write)
     size_t swap_slot = page_get_swap (t, upage);
     swap_in (kpage, swap_slot);
 
-    hash_delete (&thread_current ()->pages, &page->elem);
     lock_release (&page->lock);
-    page_cleanup (&page->elem, NULL);
 
     bool writeable = pagedir_is_writable (t->pagedir, upage);
 
@@ -293,11 +291,6 @@ fetch_page (void *upage, bool write)
     case PAGE_MMAP:
     case PAGE_FILE:
       success = page_load_file (page, page->writable);
-      if (success && page->type == PAGE_FILE)
-        {
-          hash_delete (&thread_current ()->pages, &page->elem);
-          page_cleanup (&page->elem, NULL);
-        }
       break;
     default:
       return false;

src/vm/frame.c

@@ -2,12 +2,13 @@
 #include <hash.h>
 #include <list.h>
 #include <string.h>
-
 #include "frame.h"
 #include "page.h"
+#include "filesys/file.h"
 #include "threads/malloc.h"
 #include "threads/vaddr.h"
 #include "userprog/pagedir.h"
+#include "userprog/syscall.h"
 #include "threads/synch.h"
 
 /* Hash table that maps every active frame's kernel virtual address
@@ -91,8 +92,25 @@ frame_alloc (enum palloc_flags flags, void *upage, struct thread *owner)
       struct frame_metadata *victim = get_victim ();
       ASSERT (victim != NULL); /* get_victim () should never return null. */
 
-      /* 2. Swap out victim into disk. */
+      /* 2. Handle victim page writing based on its type. */
-      page_insert_swapped (victim->upage, victim->frame, victim->owner);
+      struct page_entry *victim_page = page_get (victim->upage);
+      if (victim_page != NULL && victim_page->type == PAGE_MMAP)
+        {
+          /* If it was a memory-mapped file page, we just write it back
+             to the file if it was dirty. */
+          if (pagedir_is_dirty(owner->pagedir, victim->upage))
+            {
+              lock_acquire (&filesys_lock);
+              file_write_at (victim_page->file, victim->upage,
+                             victim_page->read_bytes, victim_page->offset);
+              lock_release (&filesys_lock);
+            }
+
+        }
+      else
+        /* Otherwise, insert the page into swap. */
+        page_insert_swapped (victim->upage, victim->frame, victim->owner);
+
 
       /* If zero flag is set, zero out the victim page. */
       if (flags & PAL_ZERO)

src/vm/page.c

@@ -39,20 +39,24 @@ static void page_flag_swap (uint32_t *pte, bool set);
 static void page_set_swap (struct thread *owner, uint32_t *pte,
                            size_t swap_slot);
 
+// TODO: Deal with NULL malloc returns
 /* Swap out 'owner' process's 'upage' stored at 'kpage'. Then, allocate and
    insert a new page entry into the user process thread's SPT representing
    this swapped out page. */
 struct page_entry *
 page_insert_swapped (void *upage, void *kpage, struct thread *owner)
 {
-
   /* 1. Initialize swapped page entry. */
-  struct page_entry *page = malloc(sizeof (struct page_entry));
+  struct page_entry *page = page_get (upage);
   if (page == NULL)
-    return NULL;
+    {
-
+      page = malloc (sizeof (struct page_entry));
-  page->upage = upage;
+      if (page == NULL)
-  lock_init (&page->lock);
+        return NULL;
+      page->upage = upage;
+      lock_init (&page->lock);
+      hash_insert (&owner->pages, &page->elem);
+    }
 
   /* Mark page as 'swapped' and flag the page directory as having
      been modified *before* eviction begins to prevent the owner of the
@@ -60,13 +64,9 @@ page_insert_swapped (void *upage, void *kpage, struct thread *owner)
   /* TODO: We need to stop the process from destroying pagedir mid-eviction,
     as this could render the page table entry invalid. */
   uint32_t *pte = lookup_page (owner->pagedir, upage, false);
-  ASSERT (pte != NULL);
 
   page_flag_swap (pte, true);
   lock_acquire (&page->lock);
-  struct hash_elem *elem = hash_insert (&owner->pages, &page->elem);
-  ASSERT(elem == NULL);
-
   pagedir_clear_page (owner->pagedir, upage);
 
   size_t swap_slot = swap_out (kpage);
@@ -94,6 +94,7 @@ page_insert_file (struct file *file, off_t ofs, void *upage,
   page->read_bytes = read_bytes;
   page->zero_bytes = zero_bytes;
   page->writable = writable;
+  lock_init (&page->lock);
 
   hash_insert (&thread_current ()->pages, &page->elem);
   return page;

src/vm/page.h

@@ -7,8 +7,7 @@
 
 enum page_type {
   PAGE_FILE,
-  PAGE_MMAP,
+  PAGE_MMAP
-  PAGE_EMPTY
 };
 
 struct page_entry {