initial implementation of memory mapped files

4 files changed, 163 insertions, 54 deletions

diff --git a/vm/mmap.c b/vm/mmap.c
new file mode 100644
index 0000000..9e7ae47
--- /dev/null
+++ b/vm/mmap.c
@@ -0,0 +1,116 @@
+#include <string.h>
+#include "filesys/file.h"
+#include "threads/thread.h"
+#include "threads/vaddr.h"
+#include "threads/malloc.h"
+#include "threads/palloc.h"
+#include "vm/mmap.h"
+#include "vm/page.h"
+
+static struct mmap_table_entry *mmap_table_get (struct mmap_table *table,
+    mapid_t mapid);
+
+/* initialize memory mapped files table */
+bool
+mmap_table_init (struct mmap_table *table)
+{
+  table->ids = palloc_get_page (PAL_ZERO);
+  if (table->ids == NULL)
+    return false;
+  table->id_cap  = PGSIZE / sizeof (table->ids[0]);
+  table->id_free = 0;
+  table->id_max  = -1;
+  return true;
+}
+
+/* frees the content of mmap table */
+void
+mmap_table_free (struct mmap_table *table)
+{
+  //TODO
+  palloc_free_page (table->ids);
+}
+
+/* inserts a new mmap entry in the mmap table
+   returns -1 if entry is invalid or already in the table */
+mapid_t
+mmap_table_insert (struct mmap_table *table, void *addr, struct file *file,
+    off_t len)
+{
+  off_t ofs = 0;
+  size_t page_read_bytes;
+  struct mmap_table_entry *mme;
+  mapid_t mapid;
+
+  /* no more entries left */
+  if (table->id_free >= table->id_cap)
+    return -1;
+
+  mme = malloc (sizeof *mme);
+  if (mme == NULL)
+    return -1;
+
+  mapid = table->id_free++;
+  mme->addr  = addr;
+  mme->file  = file;
+  table->ids[mapid] = mme;
+
+  /* create needed pages in page table */
+  while (len > 0)
+    {
+      page_read_bytes = (len < PGSIZE) ? len : PGSIZE;
+
+      if (!page_table_insert_segment (&thread_current ()->page_table, file, ofs,
+            addr, page_read_bytes, true))
+        return -1;
+
+      /* Advance. */
+      len  -= PGSIZE;
+      ofs  += page_read_bytes;
+      addr += PGSIZE;
+    }
+
+  /* update index of free/max mapid index */
+  if (mapid > table->id_max)
+    table->id_max = mapid;
+  while (table->ids[table->id_free] != NULL)
+  {
+    table->id_free++;
+    if (table->id_free >= table->id_cap)
+      break;
+  }
+
+  return mapid;
+}
+
+static struct mmap_table_entry *
+mmap_table_get (struct mmap_table *table, mapid_t mapid)
+{
+  if (mapid < 0 || mapid >= table->id_cap || !table->ids[mapid])
+    return NULL;
+  return table->ids[mapid];
+}
+
+bool
+mmap_table_remove (struct mmap_table *table, mapid_t mapid)
+{
+  struct mmap_table_entry *mme = mmap_table_get(table, mapid);
+  if (mme == NULL)
+    return false;
+
+  table->ids[mapid] = NULL;
+
+  //TODO
+
+  /* update index of free/max file descriptor index */
+  if (mapid < table->id_free)
+    table->id_free = mapid;
+  while (table->ids[table->id_max] == NULL)
+  {
+    table->id_max--;
+    if (table->id_max < 0)
+      break;
+  }
+
+  return true;
+}
diff --git a/vm/mmap.h b/vm/mmap.h
new file mode 100644
index 0000000..bee364e
--- /dev/null
+++ b/vm/mmap.h
@@ -0,0 +1,31 @@
+#ifndef VM_MMAP_H
+#define VM_MMAP_H
+
+#include <debug.h>
+#include "filesys/off_t.h"
+#include "lib/user/syscall.h"
+
+/* we use the same structure as fd_table thus the capacity is fixed to
+   1024 (PGSIZE/4) */
+struct mmap_table
+{
+  struct mmap_table_entry **ids;
+  int id_free;    /* lowest-index free */
+  int id_max;     /* highest-index used */
+  int id_cap;     /* mmap table capacity */
+};
+
+/* a single entry in the mmap table */
+struct mmap_table_entry
+{
+  void *addr;
+  struct file *file;
+};
+
+bool mmap_table_init (struct mmap_table *table);
+void mmap_table_free (struct mmap_table *table);
+mapid_t mmap_table_insert (struct mmap_table *table, void *addr,
+    struct file *file, off_t len);
+bool mmap_table_remove (struct mmap_table *table, mapid_t mapping);
+
+#endif
diff --git a/vm/page.c b/vm/page.c
index 336353e..2853497 100644
--- a/vm/page.c
+++ b/vm/page.c
@@ -2,6 +2,7 @@
 #include "filesys/file.h"
 #include "userprog/process.h"
 #include "threads/thread.h"
+#include "threads/vaddr.h"
 #include "threads/malloc.h"
 #include "threads/palloc.h"
 #include "vm/page.h"
@@ -11,8 +12,6 @@ static bool page_table_cmp_less (const struct hash_elem *a, const struct hash_el
     void *aux UNUSED);
 static void page_table_entry_free (struct hash_elem *e, void *aux UNUSED);
 static bool page_table_insert (struct hash *ht, struct page_table_entry *pte);
-static bool page_load_segment (struct page_table_entry *pte);
-static bool page_load_mmf (struct page_table_entry *pte);
 
 /* initialize page table structure */
 void
@@ -69,23 +68,20 @@ page_table_insert (struct hash *ht, struct page_table_entry *pte)
 /* inserts a new entry of type segment into the page table
    returns false if entry is invalid or already in the table */
 bool
-page_table_insert_segment (struct file *file, off_t ofs, uint8_t *upage,
-    uint32_t read_bytes, uint32_t zero_bytes, bool writable)
+page_table_insert_segment (struct hash *ht, struct file *file, off_t ofs,
+    uint8_t *upage, uint32_t read_bytes, bool writable)
 {
   struct page_table_entry *pte = malloc (sizeof *pte);
   if (pte == NULL)
     return false;
 
   pte->upage  = upage;
-  pte->type   = PAGE_SEGMENT;
   pte->loaded = false;
   pte->segment.file       = file;
   pte->segment.ofs        = ofs;
   pte->segment.read_bytes = read_bytes;
-  pte->segment.zero_bytes = zero_bytes;
   pte->segment.writable   = writable;
-
-  return page_table_insert (&thread_current ()->page_table, pte);
+  return page_table_insert (ht, pte);
 }
 
 /* fetch an entry from the page table. returns NULL if not found */
@@ -105,28 +101,11 @@ page_table_fetch (struct hash *ht, void *upage)
 bool
 page_load (struct page_table_entry *pte)
 {
+  struct segment *data;
   if (pte->loaded)
     return true;
 
-  switch (pte->type)
-    {
-      case PAGE_SEGMENT:
-        return page_load_segment (pte);
-      case PAGE_MEMORY_MAPPED_FILE:
-        return page_load_mmf (pte);
-      default:
-        ASSERT (false);
-        break;
-    }
-  return false;
-}
-
-/* load the segment data page */
-static bool
-page_load_segment (struct page_table_entry *pte)
-{
-  struct segment *data = &pte->segment;
-
+  data = &pte->segment;
   file_seek (data->file, data->ofs);
 
   /* Get a page of memory. */
@@ -141,7 +120,7 @@ page_load_segment (struct page_table_entry *pte)
       palloc_free_page (kpage);
       return false;
     }
-  memset (kpage + data->read_bytes, 0, data->zero_bytes);
+  memset (kpage + data->read_bytes, 0, PGSIZE - data->read_bytes);
 
   /* Add the page to the process's address space. */
   if (!process_install_page (pte->upage, kpage, data->writable))
@@ -153,11 +132,3 @@ page_load_segment (struct page_table_entry *pte)
   pte->loaded = true;
   return true;
 }
-
-/* load the memory mappged file page */
-static bool
-page_load_mmf (struct page_table_entry *pte)
-{
-  //TODO: implement
-  return false;
-}
diff --git a/vm/page.h b/vm/page.h
index 9cea048..da1398c 100644
--- a/vm/page.h
+++ b/vm/page.h
@@ -10,24 +10,15 @@ struct page_table_entry
 {
   void *upage;            /* virtual address of page */
   bool loaded;            /* indicates if page is loaded */
-  enum
-    {
-      PAGE_SEGMENT,
-      PAGE_MEMORY_MAPPED_FILE,
-    } type;               /* type of page */
 
-  union
+  /* structure needed for lazy loading of data segments and mmapped files */
+  struct segment
     {
-      /* structure needed for lazy loading of data segments */
-      struct segment
-        {
-          struct file *file;
-          off_t ofs;
-          uint32_t read_bytes;
-          uint32_t zero_bytes;
-          bool writable;
-        } segment;
-    };
+      struct file *file;
+      off_t ofs;
+      uint32_t read_bytes;
+      bool writable;
+    } segment;
 
   struct hash_elem elem;  /* Hash element. */
 };
@@ -35,8 +26,8 @@ struct page_table_entry
 void page_table_init (struct hash *ht);
 void page_table_free (struct hash *ht);
 struct page_table_entry *page_table_fetch (struct hash *ht, void *upage);
-bool page_table_insert_segment (struct file *file, off_t ofs, uint8_t *upage,
-    uint32_t read_bytes, uint32_t zero_bytes, bool writable);
+bool page_table_insert_segment (struct hash *ht, struct file *file, off_t ofs,
+    uint8_t *upage, uint32_t read_bytes, bool writable);
 bool page_load (struct page_table_entry *pte);
 
 #endif