fix: SPT never removes entries until process termination or special case

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/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 {