feat: implement proper destruction of pages, including for shared pages

src/vm/page.c

@@ -68,38 +68,51 @@ static void page_set_swap (struct thread *owner, uint32_t *pte,
 /* 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)
+bool
+page_insert_swapped (void *upage, void *kpage, struct list *owners)
 {
+  struct list_elem *e;
+  for (e = list_begin (owners); e != list_end (owners); e = list_next (e))
+    {
+      struct thread *owner = list_entry (e, struct frame_owner, elem)->owner;
+      uint32_t *pte = lookup_page (owner->pagedir, upage, false);
+      if (page_is_shared_pte (pte))
+        {
+          ASSERT (list_size (owners) == 1);
+          pagedir_clear_page (owner->pagedir, upage);
+          size_t swap_slot = swap_out (kpage);
+          return true;
+        }
+      ASSERT (list_size (owners) == 1);
 
-  /* 1. Initialize swapped page entry. */
-  struct page_entry *page = malloc(sizeof (struct page_entry));
-  if (page == NULL)
-    return NULL;
+      /* 1. Initialize swapped page entry. */
+      struct page_entry *page = malloc (sizeof (struct page_entry));
+      if (page == NULL)
+        return false;
 
-  page->upage = upage;
-  lock_init (&page->lock);
+      page->upage = upage;
+      lock_init (&page->lock);
 
-  /* Mark page as 'swapped' and flag the page directory as having
-     been modified *before* eviction begins to prevent the owner of the
-     victim page from accessing/modifying it mid-eviction. */
-  /* 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);
+      /* Mark page as 'swapped' and flag the page directory as having
+         been modified *before* eviction begins to prevent the owner of the
+         victim page from accessing/modifying it mid-eviction. */
+      /* TODO: We need to stop the process from destroying pagedir
+        mid-eviction, as this could render the page table entry invalid. */
+      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);
+      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);
+      pagedir_clear_page (owner->pagedir, upage);
 
-  size_t swap_slot = swap_out (kpage);
-  page_set_swap (owner, pte, swap_slot);
+      size_t swap_slot = swap_out (kpage);
+      page_set_swap (owner, pte, swap_slot);
 
-  lock_release (&page->lock);
-  return page;
+      lock_release (&page->lock);
+    }
+  return true;
 }
 
 /* Allocate and insert a new page entry into the user process thread's
@@ -190,8 +203,9 @@ page_load_file (struct page_entry *page)
                   }
                 page_flag_shared (t, page->upage, true);
               }
-          lock_release (&shared_file_pages_lock);
+          sfp->ref_count++;
           page->type = PAGE_SHARED;
+          lock_release (&shared_file_pages_lock);
           return true;
         }
     }
@@ -242,8 +256,8 @@ page_load_file (struct page_entry *page)
       sfp->ref_count = 1;
       hash_insert (&shared_file_pages, &sfp->elem);
       page_flag_shared (t, page->upage, true);
-      lock_release (&shared_file_pages_lock);
       page->type = PAGE_SHARED;
+      lock_release (&shared_file_pages_lock);
     }
 
   /* Mark the page as loaded successfully. */
@@ -255,7 +269,26 @@ page_load_file (struct page_entry *page)
 void
 page_cleanup (struct hash_elem *e, void *aux UNUSED)
 {
-  free (hash_entry (e, struct page_entry, elem));
+  struct page_entry *page = hash_entry (e, struct page_entry, elem);
+  if (page->type == PAGE_SHARED)
+    {
+      lock_acquire (&shared_file_pages_lock);
+      struct shared_file_page *sfp
+          = shared_file_page_get (page->file, page->upage);
+      ASSERT (sfp != NULL);
+      sfp->ref_count--;
+      if (sfp->ref_count == 0)
+        {
+          hash_delete (&shared_file_pages, &sfp->elem);
+          if (sfp->frame != NULL)
+            frame_free (sfp->frame);
+          else
+            swap_drop (sfp->swap_slot);
+          free (sfp);
+        }
+      lock_release (&shared_file_pages_lock);
+    }
+  free (page);
 }
 
 /* Flags the provided page table entry as representing a swapped out page. */
@@ -381,5 +414,13 @@ shared_file_page_less (const struct hash_elem *a_, const struct hash_elem *b_,
 static struct shared_file_page *
 shared_file_page_get (struct file *file, void *upage)
 {
-  return NULL;
+  struct shared_file_page fake_sfp;
+  fake_sfp.file = file;
+  fake_sfp.upage = upage;
+
+  struct hash_elem *e = hash_find (&shared_file_pages, &fake_sfp.elem);
+  if (e == NULL)
+    return NULL;
+
+  return hash_entry (e, struct shared_file_page, elem);
 }