fix: synchronise destruction of page directories with frame table

.gitlab-ci.yml

@@ -38,3 +38,4 @@ test_vm:
   extends: .pintos_tests
   variables:
     DIR: vm
+    IGNORE: (tests/vm/pt-grow-stack|tests/vm/pt-grow-pusha|tests/vm/pt-big-stk-obj|tests/vm/pt-overflowstk|tests/vm/pt-write-code2|tests/vm/pt-grow-stk-sc|tests/vm/page-linear|tests/vm/page-parallel|tests/vm/page-merge-seq|tests/vm/page-merge-par|tests/vm/page-merge-stk|tests/vm/page-merge-mm|tests/vm/mmap-over-stk)

src/userprog/exception.c

@@ -289,7 +289,7 @@ fetch_page (void *upage, bool write)
   bool success = false;
   switch (page->type) {
     case PAGE_MMAP:
-    case PAGE_EXECUTABLE:
+    case PAGE_FILE:
     case PAGE_SHARED:
       success = page_load_file (page);
       break;

src/userprog/pagedir.c

@@ -6,6 +6,7 @@
 #include "threads/init.h"
 #include "threads/pte.h"
 #include "threads/palloc.h"
+#include "threads/synch.h"
 #include "vm/frame.h"
 #include "vm/page.h"
 
@@ -35,6 +36,7 @@ pagedir_destroy (uint32_t *pd)
     return;
 
   ASSERT (pd != init_page_dir);
+  lock_acquire (&lru_lock);
   for (pde = pd; pde < pd + pd_no (PHYS_BASE); pde++)
     if (*pde & PTE_P) 
       {
@@ -53,6 +55,7 @@ pagedir_destroy (uint32_t *pd)
         palloc_free_page (pt);
       }
   palloc_free_page (pd);
+  lock_release (&lru_lock);
 }
 
 /* Returns the address of the page table entry for virtual

src/userprog/process.c

@@ -715,7 +715,7 @@ load_segment (struct file *file, off_t ofs, uint8_t *upage,
 
       /* Add the page metadata to the SPT to be lazy loaded later on */
       if (page_insert_file (file, ofs, upage, page_read_bytes, page_zero_bytes,
-                            writable, PAGE_EXECUTABLE) == NULL)
+                            writable, PAGE_FILE) == NULL)
         return false;
 
       /* Advance. */

src/userprog/syscall.c

@@ -461,9 +461,10 @@ syscall_mmap (int fd, void *addr)
   /* Check and ensure that there is enough space in the user virtual memory to
      hold the entire file. */
   for (off_t ofs = 0; ofs < file_size; ofs += PGSIZE)
+    {
       if (page_get (thread_current (), addr + ofs) != NULL)
         return MMAP_FAILURE;
-
+    }
 
   /* Map the file data into the user virtual memory starting from addr. */
   for (off_t ofs = 0; ofs < file_size; ofs += PGSIZE)
@@ -472,7 +473,7 @@ syscall_mmap (int fd, void *addr)
       off_t zero_bytes = PGSIZE - read_bytes;
 
       if (page_insert_file (file, ofs, addr + ofs, read_bytes, zero_bytes, true,
-                            PAGE_MMAP) == NULL)
+                       PAGE_FILE) == NULL)
         return MMAP_FAILURE;
     }
 
@@ -481,6 +482,7 @@ syscall_mmap (int fd, void *addr)
   if (mmap == NULL)
       return MMAP_FAILURE;
 
+
   return mmap->mapping;
 }
 

src/vm/frame.c

@@ -40,8 +40,8 @@ struct frame_metadata
                                      within 'frame_table', whose key is the 
                                      kernel virtual address of the frame. */
      struct list_elem list_elem;  /* Tracks the position of the frame metadata
-                                     within 'lru_list', so a victim can be
+                                     in either the 'active' or 'inactive' list,
-                                     chosen for eviction. */
+                                     so a victim can be chosen for eviction. */
   };
 
 hash_hash_func frame_metadata_hash;
@@ -63,7 +63,7 @@ frame_init (void)
   hash_init (&frame_table, frame_metadata_hash, frame_metadata_less, NULL);
 
   list_init (&lru_list);
-  lock_init (&ftable_lock);
+  lock_init (&lru_lock);
 }
 
 /* TODO: Consider synchronisation more closely (i.e. just for hash
@@ -79,7 +79,7 @@ frame_alloc (enum palloc_flags flags, void *upage, struct thread *owner)
   struct frame_metadata *frame_metadata;
   flags |= PAL_USER;
 
-  lock_acquire (&ftable_lock);
+  lock_acquire (&lru_lock);
   void *frame = palloc_get_page (flags);
 
   /* If a frame couldn't be allocated we must be out of main memory. Thus,
@@ -122,7 +122,7 @@ frame_alloc (enum palloc_flags flags, void *upage, struct thread *owner)
         memset (victim->frame, 0, PGSIZE);
 
       /* 3. Indicate that the new frame's metadata will be stored
-            inside the same structure that stored the victim's metadata.frame.c
+            inside the same structure that stored the victim's metadata.
             As both the new frame and the victim frame share the same kernel
             virtual address, the hash map need not be updated, and neither
             the list_elem value as both share the same lru_list position. */
@@ -133,7 +133,7 @@ frame_alloc (enum palloc_flags flags, void *upage, struct thread *owner)
      we must update the frame table with a new entry, and grow lru_list. */
   else
     {
-      /* Must own ftable_lock here, as otherwise there is a race condition
+      /* Must own lru_lock here, as otherwise there is a race condition
          with next_victim either being NULL or uninitialized. */
       frame_metadata = malloc (sizeof (struct frame_metadata));
       if (frame_metadata == NULL)
@@ -165,7 +165,7 @@ frame_alloc (enum palloc_flags flags, void *upage, struct thread *owner)
   list_push_back (&frame_metadata->owners, &frame_owner->elem);
   frame_metadata->upage = upage;
   frame_metadata->pinned = false;
-  lock_release (&ftable_lock);
+  lock_release (&lru_lock);
   return frame_metadata->frame;
 }
 
@@ -173,28 +173,28 @@ void
 frame_pin (void *frame)
 {
   ASSERT (frame != NULL);
-  lock_acquire (&ftable_lock);
+  lock_acquire (&lru_lock);
   struct frame_metadata *frame_metadata = frame_metadata_get (frame);
   if (frame_metadata == NULL)
     PANIC ("Attempted to pin a frame at an unallocated kernel address '%p'\n",
            frame);
 
   frame_metadata->pinned = true;
-  lock_release (&ftable_lock);
+  lock_release (&lru_lock);
 }
   
 void
 frame_unpin (void *frame)
 {
   ASSERT (frame != NULL);
-  lock_acquire (&ftable_lock);
+  lock_acquire (&lru_lock);
   struct frame_metadata *frame_metadata = frame_metadata_get (frame);
   if (frame_metadata == NULL)
     PANIC ("Attempted to unpin a frame at an unallocated kernel address '%p'\n",
            frame);
 
   frame_metadata->pinned = false;
-  lock_release (&ftable_lock);
+  lock_release (&lru_lock);
 }
 
 /* Attempt to deallocate a frame for a user process by removing it from the
@@ -209,8 +209,13 @@ frame_free (void *frame)
              "but this address is not allocated!\n",
              frame);
 
+    bool lock_held = lock_held_by_current_thread (&lru_lock);
+
     free_owners (&frame_metadata->owners);
-    lock_acquire (&ftable_lock);
+
+    if (!lock_held)
+      lock_acquire (&lru_lock);
+
     hash_delete (&frame_table, &frame_metadata->hash_elem);
     list_remove (&frame_metadata->list_elem);
 
@@ -224,7 +229,9 @@ frame_free (void *frame)
         else
           next_victim = lru_next (next_victim);
       }
-    lock_release (&ftable_lock);
+
+    if (!lock_held)
+      lock_release (&lru_lock);
 
     free (frame_metadata);
     palloc_free_page (frame);
@@ -287,8 +294,9 @@ frame_metadata_find (void *frame)
   return hash_entry (e, struct frame_metadata, hash_elem);
 }
 
+/* TODO: Account for page aliases when checking accessed bit. */
 /* A pre-condition for calling this function is that the calling thread
-   owns ftable_lock and that lru_list is non-empty. */
+   owns lru_lock and that lru_list is non-empty. */
 static struct frame_metadata *
 get_victim (void)
   {

src/vm/frame.h

@@ -11,9 +11,8 @@ struct frame_owner
 };
 
 /* Synchronisation variables. */
-/* Protects access to the frame table and its related components. */
+/* Protects access to 'lru_list'. */
-struct lock ftable_lock;
+struct lock lru_lock;
-
 void frame_init (void);
 
 void *frame_alloc (enum palloc_flags, void *, struct thread *);

src/vm/page.c

@@ -198,8 +198,12 @@ page_load_file (struct page_entry *page)
                   lock_release (&shared_file_pages_lock);
                   return false;
                 }
+              /* First time adding the shared page, so add thread as owner. */
+              if (page->type != PAGE_SHARED)
+                {
                   frame_owner_insert (sfp->frame, t);
                 }
+            }
             /* Shared page is in swap. Load it. */
             else
               {

src/vm/page.h

@@ -7,8 +7,9 @@
 
 enum page_type
 {
-  PAGE_EXECUTABLE,
+  PAGE_FILE,
   PAGE_MMAP,
+  PAGE_EMPTY,
   PAGE_SHARED
 };
 
@@ -34,18 +35,13 @@ struct page_entry
 
 struct shared_file_page
 {
-  struct file *file; /* The shared file page's source file, used for indexing
+  struct file *file;
-                        the table. */
+  void *upage;
-  void *upage; /* The shared page's upage which is the same across all process
+  void *frame;
-                  using it. Used for indexing the table. */
+  size_t swap_slot;
-  void *frame; /* Set to the frame address of the page when it is in memory.
+  int ref_count;
-                  Set to NULL when the page is in swap. */
-  size_t swap_slot; /* Set to the swap_slot of the shared paged if it is
-                      currently in swap. Should not be used when frame is not
-                      NULL.*/
-  int ref_count; /* Number of processes that are using this shared page. */
 
-  struct hash_elem elem; /* AN elem for the hash table. */
+  struct hash_elem elem;
 };
 
 bool init_pages (struct hash *pages);