weenix

6 files changed, 1077 insertions, 41 deletions

diff --git a/kernel/vm/anon.c b/kernel/vm/anon.c
index 4a92fc9..a433395 100644
--- a/kernel/vm/anon.c
+++ b/kernel/vm/anon.c
@@ -27,7 +27,8 @@ static mobj_ops_t anon_mobj_ops = {.get_pframe = NULL,
  */
 void anon_init()
 {
-    NOT_YET_IMPLEMENTED("VM: anon_init");
+    // NOT_YET_IMPLEMENTED("VM: anon_init");
+    anon_allocator = slab_allocator_create("anon", sizeof(mobj_t));
 }
 
 /*
@@ -36,8 +37,17 @@ void anon_init()
  */
 mobj_t *anon_create()
 {
-    NOT_YET_IMPLEMENTED("VM: anon_create");
-    return NULL;
+    // NOT_YET_IMPLEMENTED("VM: anon_create");
+    // make a new mobj
+    mobj_t *mobj = (mobj_t *)slab_obj_alloc(anon_allocator);
+    // initialize the mobj
+    if (mobj)
+    {
+        mobj_init(mobj, MOBJ_ANON, &anon_mobj_ops);
+        mobj_lock(mobj);
+        return mobj;
+    }
+    panic("MINE anon_create: slab_obj_alloc failed");
 }
 
 /* 
@@ -46,7 +56,15 @@ mobj_t *anon_create()
  */
 static long anon_fill_pframe(mobj_t *o, pframe_t *pf)
 {
-    NOT_YET_IMPLEMENTED("VM: anon_fill_pframe");
+    // NOT_YET_IMPLEMENTED("VM: anon_fill_pframe");
+
+    // set the pframe's mobj to the given mobj
+    // pf->pf_addr = o;
+    // // set the pframe's flags to dirty
+    // pf->pf_dirty = 1;
+
+    memset(pf->pf_addr, 0, PAGE_SIZE);
+
     return 0;
 }
 
@@ -61,5 +79,10 @@ static long anon_flush_pframe(mobj_t *o, pframe_t *pf) { return 0; }
  */
 static void anon_destructor(mobj_t *o)
 {
-    NOT_YET_IMPLEMENTED("VM: anon_destructor");
+    // NOT_YET_IMPLEMENTED("VM: anon_destructor");
+    // call the default destructor
+    mobj_default_destructor(o);
+
+    // free the mobj
+    slab_obj_free(anon_allocator, o);
 }
diff --git a/kernel/vm/brk.c b/kernel/vm/brk.c
index 46d6fc2..69a315f 100644
--- a/kernel/vm/brk.c
+++ b/kernel/vm/brk.c
@@ -53,6 +53,105 @@
  */
 long do_brk(void *addr, void **ret)
 {
-    NOT_YET_IMPLEMENTED("VM: do_brk");
+    // NOT_YET_IMPLEMENTED("VM: do_brk");
+
+    // If addr is NULL, return the current break
+    if (addr == NULL) 
+    {
+        *ret = curproc->p_brk;
+        return 0;
+    }
+
+    // Check if the address is within the valid range
+    if ((uintptr_t)addr > USER_MEM_HIGH)
+    {
+        return -ENOMEM;
+    }
+
+    // Check if the address is within the valid range
+    if (addr < curproc->p_start_brk)
+    {
+        return -ENOMEM;
+    }
+
+    // Check if the address is the same as the current break
+    // if (addr == curproc->p_brk)
+    // {
+    //     *ret = curproc->p_brk;
+    //     return 0;
+    // }
+
+    // Check if the address is page aligned
+    uintptr_t addr_page_aligned = ADDR_TO_PN(PAGE_ALIGN_UP(addr));
+    uintptr_t p_brk_page_aligned = ADDR_TO_PN(PAGE_ALIGN_UP(curproc->p_brk));
+    uintptr_t p_start_brk_page_aligned = ADDR_TO_PN(PAGE_ALIGN_UP(curproc->p_start_brk));
+
+    // Lookup the vmarea that represents the heap
+    vmarea_t *heap_vmarea = vmmap_lookup(curproc->p_vmmap, p_start_brk_page_aligned);
+
+    // Check if the address is the same as the current break
+    // If so, set rets and end here
+    if (addr_page_aligned == p_brk_page_aligned)
+    {
+        curproc->p_brk = addr;
+        *ret = addr;
+        return 0;
+    }
+
+    // Check the three cases, whether the heap needs to be created, modified or shrinked
+    if (heap_vmarea == NULL)
+    {
+        // Create the heap
+        long ret = vmmap_is_range_empty(curproc->p_vmmap, p_start_brk_page_aligned, addr_page_aligned - p_brk_page_aligned);
+        if (!ret)
+        {
+            // On fail, return -ENOMEM
+            return -ENOMEM;
+        }
+
+        // Map the heap
+        int flags = MAP_PRIVATE | MAP_ANON;
+        int prot = PROT_READ | PROT_WRITE;
+        ret = vmmap_map(
+            curproc->p_vmmap, NULL, 
+            p_start_brk_page_aligned, 
+            addr_page_aligned - p_start_brk_page_aligned, 
+            prot, flags, 
+            0, 
+            VMMAP_DIR_LOHI, &heap_vmarea
+        );
+        if (ret < 0)
+        {
+            // On fail, return ret
+            return ret;
+        }
+    }
+    else if (addr_page_aligned < p_brk_page_aligned)
+    {
+        // Shrink the heap
+        long ret = vmmap_remove(curproc->p_vmmap, addr_page_aligned, p_brk_page_aligned - addr_page_aligned);
+        if (ret < 0)
+        {
+            // On fail, return ret
+            return ret;
+        }
+    }
+    else
+    {
+        // Modify the heap
+        long ret = vmmap_is_range_empty(curproc->p_vmmap, p_brk_page_aligned, addr_page_aligned - p_brk_page_aligned);
+        if (!ret)
+        {
+            // On fail, return -ENOMEM
+            return -ENOMEM;
+        }
+        // Update the heap
+        heap_vmarea->vma_end = addr_page_aligned;
+    }
+
+    
+    // Update rets & return 0 on success
+    curproc->p_brk = addr;
+    *ret = addr;
     return 0;
 }
diff --git a/kernel/vm/mmap.c b/kernel/vm/mmap.c
index 082149b..78aa3b5 100644
--- a/kernel/vm/mmap.c
+++ b/kernel/vm/mmap.c
@@ -55,8 +55,134 @@
 long do_mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off,
              void **ret)
 {
-    NOT_YET_IMPLEMENTED("VM: do_mmap");
-    return -1;
+    // NOT_YET_IMPLEMENTED("VM: do_mmap");
+
+    // check if addr is page aligned when MAP_FIXED is specified
+    if (PAGE_ALIGNED(addr) == 0 && (flags & MAP_FIXED))
+    {
+        return -EINVAL;
+    }
+
+    // check if MAP_FIXED is specified and addr is out of range of the user address space
+    if ((flags & MAP_FIXED) && ((uintptr_t)addr < USER_MEM_LOW || (uintptr_t)addr + len > USER_MEM_HIGH))
+    {
+        return -EINVAL;
+    }
+
+    // check if len is not zero (len is an unsigned value, so it is always positive)
+    if (len == 0)
+    {
+        return -EINVAL;
+    }
+
+    // check if offset is positive and aligned
+    if (off < 0 || PAGE_ALIGNED(off) == 0)
+    {
+        return -EINVAL;
+    }
+
+    // check if flags do not contain MAP_PRIVATE or MAP_SHARED
+    if ((flags & MAP_PRIVATE) == 0 && (flags & MAP_SHARED) == 0)
+    {
+        return -EINVAL;
+    }
+
+    // check if fd is not a valid file descriptor and MAP_ANON was not set
+    if (fd < 0 && (flags & MAP_ANON) == 0)
+    {
+        return -EBADF;
+    }
+
+    // check if a file mapping was requested, but fd is not open for reading
+    // file error checking is done in if statement below
+    file_t *file = NULL;
+    if (fd >= 0 && (flags & MAP_ANON) == 0)
+    {
+        // get the file and check if it is valid
+        file = fget(fd);
+        if (file == NULL)
+        {
+            return -EBADF;
+        }
+
+        // ENODEV CHECKS
+
+        // check if the file's vnode's mmap operation doesn't exist
+        if (file->f_vnode->vn_ops == NULL || file->f_vnode->vn_ops->mmap == NULL)
+        {
+            fput(&file);
+            return -ENODEV;
+        }
+
+        // ACCESS CHECKS
+
+        // check if thef FMODE_READ flag is not set
+        if ((file->f_mode & FMODE_READ) == 0)
+        {
+            fput(&file);
+            return -EACCES;
+        }
+        
+        // check if append mode is set and PROT_WRITE is set
+        if ((prot & PROT_WRITE) && (file->f_mode & FMODE_APPEND))
+        {
+            fput(&file);
+            return -EACCES;
+        }
+
+        // check if MAP_SHARED was requested and PROT_WRITE is set, but fd is not open in read/write (O_RDWR) mode
+        if ((flags & MAP_SHARED) && (prot & PROT_WRITE) && (file->f_mode & FMODE_READ) == 0)
+        {
+            fput(&file);
+            return -EACCES;
+        }
+
+        // check if PROT_WRITE is set, but the file has FMODE_APPEND specified
+        if ((prot & PROT_WRITE) && (file->f_mode & FMODE_APPEND))
+        {
+            fput(&file);
+            return -EACCES;
+        }
+
+        fput(&file);
+    }
+
+
+    // Now that error checking is done, we can proceed with the mapping
+    vmarea_t *vma = NULL;
+    long err = vmmap_map(
+        curproc->p_vmmap, 
+        file ? file->f_vnode : NULL,
+        ADDR_TO_PN(PAGE_ALIGN_DOWN(addr)),
+        ADDR_TO_PN(PAGE_ALIGN_UP((uintptr_t)addr + len)) - ADDR_TO_PN(PAGE_ALIGN_DOWN(addr)), 
+        prot, 
+        flags, 
+        off, 
+        VMMAP_DIR_HILO,
+        &vma
+    );
+
+    // check if vmmap_map() failed
+    if (err < 0)
+    {
+        return err;
+    }
+
+    // set ret if it was provided
+    void *start = PN_TO_ADDR(vma->vma_start);
+    if (ret)
+    {
+        *ret = start;
+    }
+
+    // flush the TLB
+    tlb_flush_range(
+        (uintptr_t) start,
+        PAGE_SIZE * (vma->vma_end - vma->vma_start)
+    );
+
+    // return 0 on success
+    return 0;
 }
 
 /*
@@ -78,6 +204,37 @@ long do_mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off,
  */
 long do_munmap(void *addr, size_t len)
 {
-    NOT_YET_IMPLEMENTED("VM: do_munmap");
-    return -1;
+    // NOT_YET_IMPLEMENTED("VM: do_munmap");
+
+    // Check if addr is page aligned
+    if (PAGE_ALIGNED(addr) == 0)
+    {
+        return -EINVAL;
+    }
+
+    // Check if len is in bounds
+    if (len > USER_MEM_HIGH)
+    {
+        return -EINVAL;
+    }
+
+    // Check if the addr is out of range of the user address space
+    if ((uintptr_t)addr < USER_MEM_LOW || (uintptr_t)addr + len > USER_MEM_HIGH)
+    {
+        return -EINVAL;
+    }
+
+    // Check if len is 0
+    if (len == 0)
+    {
+        return -EINVAL;
+    }
+
+    // Remove the mapping
+    long ret = vmmap_remove(
+        curproc->p_vmmap, 
+        ADDR_TO_PN(addr), 
+        ADDR_TO_PN(PAGE_ALIGN_UP((uintptr_t)addr + len))
+    );
+    return ret;
 }
\ No newline at end of file
diff --git a/kernel/vm/pagefault.c b/kernel/vm/pagefault.c
index 764ce85..2e0c92d 100644
--- a/kernel/vm/pagefault.c
+++ b/kernel/vm/pagefault.c
@@ -49,5 +49,78 @@ void handle_pagefault(uintptr_t vaddr, uintptr_t cause)
 {
     dbg(DBG_VM, "vaddr = 0x%p (0x%p), cause = %lu\n", (void *)vaddr,
         PAGE_ALIGN_DOWN(vaddr), cause);
-    NOT_YET_IMPLEMENTED("VM: handle_pagefault");
+    // NOT_YET_IMPLEMENTED("VM: handle_pagefault");
+
+    // 1) Find the vmarea that contains vaddr, if it exists.
+    // check that the vaddr is valid
+    if (vaddr < USER_MEM_LOW || vaddr > USER_MEM_HIGH)
+    {
+        do_exit(EFAULT);
+    }
+    // lookup the vmarea for this addr
+    vmarea_t *vma = vmmap_lookup(curproc->p_vmmap, ADDR_TO_PN(vaddr));
+    if (vma == NULL)
+    {
+        do_exit(EFAULT);
+    }
+
+    // 2) Check the vmarea's protections (see the vmarea_t struct) against the 'cause'
+    // error out if the fault has cause write and we don't have write permission in the area
+    if ((cause & FAULT_WRITE) && !(vma->vma_prot & PROT_WRITE))
+    {
+        do_exit(EFAULT);
+    }
+    // error out if the fault has cause exec and we don't have exec permission in the area
+    if ((cause & FAULT_EXEC) && !(vma->vma_prot & PROT_EXEC))
+    {
+        do_exit(EFAULT);
+    }
+    // error out if we don't have read permission in the area
+    if (!(vma->vma_prot & PROT_READ))
+    {
+        do_exit(EFAULT);
+    }
+    // error our if we don't have any permission in the area
+    if (vma->vma_prot == PROT_NONE)
+    {
+        do_exit(EFAULT);
+    }
+
+    // 3) Obtain the corresponding pframe from the vmarea's mobj.
+    pframe_t *pf;
+    mobj_lock(vma->vma_obj);
+    int ret = mobj_get_pframe(
+        vma->vma_obj, 
+        vma->vma_off + (ADDR_TO_PN(vaddr) - vma->vma_start), 
+        cause & FAULT_WRITE ? 1 : 0,
+        &pf
+    );
+    mobj_unlock(vma->vma_obj);
+    if (ret < 0)
+    {
+        do_exit(EFAULT);
+    }
+
+    // 4) Finally, set up a call to pt_map to insert a new mapping into the appropriate pagetable
+    int pdflags = PT_PRESENT | PT_WRITE | PT_USER;
+    int ptflags = PT_PRESENT | PT_USER;
+    if (cause & FAULT_WRITE)
+    {
+        ptflags |= PT_WRITE;
+    }
+
+    int err = pt_map(
+        curproc->p_pml4, 
+        pt_virt_to_phys((uintptr_t) pf->pf_addr), 
+        (uintptr_t) PAGE_ALIGN_DOWN(vaddr),
+        pdflags, 
+        ptflags
+    );
+    if (err < 0)
+    {
+        do_exit(EFAULT);
+    }
+
+    // 5) Flush the TLB
+    tlb_flush((uintptr_t) PAGE_ALIGN_DOWN(vaddr));
 }
diff --git a/kernel/vm/shadow.c b/kernel/vm/shadow.c
index 312b32e..91b1fce 100644
--- a/kernel/vm/shadow.c
+++ b/kernel/vm/shadow.c
@@ -41,7 +41,8 @@ static mobj_ops_t shadow_mobj_ops = {.get_pframe = shadow_get_pframe,
  */
 void shadow_init()
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_init");
+    // NOT_YET_IMPLEMENTED("VM: shadow_init");
+    shadow_allocator = slab_allocator_create("shadow", sizeof(mobj_shadow_t));
 }
 
 /*
@@ -60,8 +61,37 @@ void shadow_init()
  */
 mobj_t *shadow_create(mobj_t *shadowed)
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_create");
-    return NULL;
+    // NOT_YET_IMPLEMENTED("VM: shadow_create");
+
+    // create a new shadow object
+    mobj_shadow_t *so = (mobj_shadow_t *)slab_obj_alloc(shadow_allocator);
+    if (!so)
+    {
+        return NULL;
+    }
+
+    // initialize the mobj_shadow_t
+    
+    // set the bottom_mobj based on the two cases
+    if (shadowed->mo_type == MOBJ_SHADOW)
+    {
+        so->bottom_mobj = MOBJ_TO_SO(so->shadowed)->bottom_mobj;
+    }
+    else
+    {
+        so->bottom_mobj = shadowed;
+    }
+    // init the other fields
+    so->shadowed = shadowed;
+    mobj_init(&so->mobj, MOBJ_SHADOW, &shadow_mobj_ops);
+    mobj_ref(so->shadowed);
+    mobj_ref(so->bottom_mobj);
+
+    // lock the shadow object
+    mobj_lock(&so->mobj);
+
+    // return the shadow object
+    return &so->mobj;
 }
 
 /*
@@ -80,7 +110,52 @@ mobj_t *shadow_create(mobj_t *shadowed)
  */
 void shadow_collapse(mobj_t *o)
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_collapse");
+    // NOT_YET_IMPLEMENTED("VM: shadow_collapse");
+
+    // get the mobj_shadow_t and it's mobj
+    mobj_shadow_t *so = MOBJ_TO_SO(o);
+    mobj_t *iter = so->shadowed;
+    // iterate through the shadow chain
+    while (iter && so->shadowed->mo_type == MOBJ_SHADOW)
+    {
+        // check to see if the refcount is not 1. if so, continue to next shadowed object
+        if (so->shadowed->mo_refcount != 1)
+        {
+            iter = so->shadowed;
+            continue;
+        }
+        // else, go over the shadowed object's pframes
+
+        // iterate through the pframes
+        mobj_lock(&so->shadowed);
+        list_iterate(&so->shadowed->mo_pframes, pframe, pframe_t, pf_link)
+        {
+            // get the pframe from the shadow object
+            pframe_t *spf = NULL;
+
+            mobj_lock(iter); // lock before getting the pframe
+            mobj_find_pframe(o, pframe->pf_pagenum, &spf);
+            mobj_unlock(iter);
+
+            // check if the pframe is not in the shadow object when migrating
+            if (spf == NULL)
+            {
+                // if not, remove the pframe from the shadowed object 
+                // and insert it into out iterated shadow object
+                list_remove(&pframe->pf_link);
+                list_insert_tail(&iter->mo_pframes, &pframe->pf_link);
+            }
+            else
+            {
+                // if it is, release the pframe we found
+                pframe_release(&spf);
+            }
+        }
+
+        // put locked the shadowed object after iterating through it
+        mobj_put_locked(&so->shadowed);
+        // FIXME: this is probably wrong
+    }
 }
 
 /*
@@ -111,8 +186,47 @@ void shadow_collapse(mobj_t *o)
 static long shadow_get_pframe(mobj_t *o, size_t pagenum, long forwrite,
                               pframe_t **pfp)
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_get_pframe");
-    return 0;
+    // NOT_YET_IMPLEMENTED("VM: shadow_get_pframe");
+
+    // if forwrite is set, use mobj_default_get_pframe
+    if (forwrite)
+    {
+        return mobj_default_get_pframe(o, pagenum, forwrite, pfp);
+    }
+
+    // else, check if the object already contains the desired frame
+    pframe_t *pf = NULL;
+    mobj_find_pframe(o, pagenum, &pf);
+    if (pf)
+    {
+        // if it does, return the pframe
+        *pfp = pf;
+        return 0;
+    }
+
+    // iterate through the shadow chain to find the nearest shadow mobj that has the frame
+    mobj_shadow_t *so = MOBJ_TO_SO(o);
+    mobj_t *iter = so->shadowed;
+    while (iter && iter->mo_type == MOBJ_SHADOW)
+    {
+        mobj_lock(iter);
+        mobj_find_pframe(o, pagenum, &pf);
+        mobj_unlock(iter);
+        if (pf)
+        {
+            *pfp = pf;
+            return 0;
+        }
+        // update the iterator
+        iter = MOBJ_TO_SO(iter)->shadowed;
+    }
+
+    // if no shadow objects have the page, call mobj_get_pframe() to get the page from the bottom object
+    // at this point, iter is the bottom object
+    mobj_lock(iter);
+    long ret = mobj_get_pframe(iter, pagenum, forwrite, pfp);
+    mobj_unlock(iter);
+    return ret;
 }
 
 /*
@@ -138,8 +252,47 @@ static long shadow_get_pframe(mobj_t *o, size_t pagenum, long forwrite,
  */
 static long shadow_fill_pframe(mobj_t *o, pframe_t *pf)
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_fill_pframe");
-    return -1;
+    // NOT_YET_IMPLEMENTED("VM: shadow_fill_pframe");
+
+    // get the mobj_shadow_t
+    mobj_shadow_t *so = MOBJ_TO_SO(o);
+    // iterate over the shadow chain
+    mobj_t *iter = so->shadowed;
+    while (iter && iter->mo_type == MOBJ_SHADOW)
+    {
+        // get the pframe from the shadow object
+        pframe_t *spf = NULL;
+        mobj_lock(iter);
+        mobj_find_pframe(o, pf->pf_pagenum, &spf);
+        mobj_unlock(iter);
+
+        // if the pframe is found, copy the contents into pf 
+        // then release the pframe
+        if (spf)
+        {
+            memcpy(pf->pf_addr, spf->pf_addr, PAGE_SIZE);
+            pframe_release(&spf);
+            return 0;
+        }
+
+        // update the iterator
+        iter = MOBJ_TO_SO(iter)->shadowed;
+    }
+
+    // if none of the shadow objects have a copy of the frame, use mobj_get_pframe on the bottom object
+    pframe_t *spf = NULL;
+    mobj_lock(iter);
+    long ret = mobj_get_pframe(iter, pf->pf_pagenum, 0, &spf);
+    mobj_unlock(iter);
+    // check if the operation was sucessful, memcpy the contents into pf
+    // and release the pframe
+    if (ret == 0)
+    {
+        memcpy(pf->pf_addr, pf->pf_addr, PAGE_SIZE);
+        pframe_release(&spf);
+    }
+
+    return ret;
 }
 
 /*
@@ -153,8 +306,8 @@ static long shadow_fill_pframe(mobj_t *o, pframe_t *pf)
  */
 static long shadow_flush_pframe(mobj_t *o, pframe_t *pf)
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_flush_pframe");
-    return -1;
+    // NOT_YET_IMPLEMENTED("VM: shadow_flush_pframe");
+    return 0;
 }
 
 /*
@@ -169,5 +322,18 @@ static long shadow_flush_pframe(mobj_t *o, pframe_t *pf)
  */
 static void shadow_destructor(mobj_t *o)
 {
-    NOT_YET_IMPLEMENTED("VM: shadow_destructor");
+    // NOT_YET_IMPLEMENTED("VM: shadow_destructor");
+
+    // get the mobj_shadow_t
+    mobj_shadow_t *so = MOBJ_TO_SO(o);
+
+    // call the default destructor
+    mobj_default_destructor(o);
+
+    // put the shadow and bottom_mobj
+    mobj_put(&so->shadowed);
+    mobj_put(&so->bottom_mobj);
+
+    // free the slab
+    slab_obj_free(shadow_allocator, so);
 }
diff --git a/kernel/vm/vmmap.c b/kernel/vm/vmmap.c
index 0e2dad6..fd99c55 100644
--- a/kernel/vm/vmmap.c
+++ b/kernel/vm/vmmap.c
@@ -16,6 +16,7 @@
 #include "mm/mm.h"
 #include "mm/mman.h"
 #include "mm/slab.h"
+#include "mm/tlb.h"
 
 static slab_allocator_t *vmmap_allocator;
 static slab_allocator_t *vmarea_allocator;
@@ -32,8 +33,27 @@ void vmmap_init(void)
  */
 vmarea_t *vmarea_alloc(void)
 {
-    NOT_YET_IMPLEMENTED("VM: vmarea_alloc");
-    return NULL;
+    // NOT_YET_IMPLEMENTED("VM: vmarea_alloc");
+
+    // Allocate a new vmarea
+    vmarea_t *new_vmarea = (vmarea_t *)slab_obj_alloc(vmarea_allocator);
+    if (new_vmarea == NULL)
+    {
+        return NULL;
+    }
+
+    // Initialize the fields of the vmarea
+    new_vmarea->vma_start = 0;
+    new_vmarea->vma_end = 0;
+    new_vmarea->vma_off = 0;
+    new_vmarea->vma_prot = 0;
+    new_vmarea->vma_flags = 0;
+    new_vmarea->vma_obj = NULL;
+    new_vmarea->vma_obj = NULL;
+    list_link_init(&new_vmarea->vma_plink);
+
+    // Return the new vmarea
+    return new_vmarea;
 }
 
 /*
@@ -42,7 +62,22 @@ vmarea_t *vmarea_alloc(void)
  */
 void vmarea_free(vmarea_t *vma)
 {
-    NOT_YET_IMPLEMENTED("VM: vmarea_free");
+    // NOT_YET_IMPLEMENTED("VM: vmarea_free");
+
+    // Remove the vmarea from any lists it may be on
+    if (list_link_is_linked(&vma->vma_plink))
+    {
+        list_remove(&vma->vma_plink);
+    }
+
+    // Put the vma_obj if it exists
+    if (vma->vma_obj != NULL)
+    {
+        mobj_put(&vma->vma_obj);
+    }
+
+    // Free the vmarea
+    slab_obj_free(vmarea_allocator, vma);
 }
 
 /*
@@ -50,8 +85,20 @@ void vmarea_free(vmarea_t *vma)
  */
 vmmap_t *vmmap_create(void)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_create");
-    return NULL;
+    // NOT_YET_IMPLEMENTED("VM: vmmap_create");
+
+    // Allocate a new vmmap
+    vmmap_t *new_vmmap = (vmmap_t *)slab_obj_alloc(vmmap_allocator);
+    if (new_vmmap == NULL)
+    {
+        return NULL;
+    }
+
+    // Initialize the fields of the vmmap
+    list_init(&new_vmmap->vmm_list);
+    new_vmmap->vmm_proc = curproc;
+
+    return new_vmmap;
 }
 
 /*
@@ -60,7 +107,22 @@ vmmap_t *vmmap_create(void)
  */
 void vmmap_destroy(vmmap_t **mapp)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_destroy");
+    // NOT_YET_IMPLEMENTED("VM: vmmap_destroy");
+
+    vmmap_t *map = *mapp;
+
+    // Iterate through the list of vmareas and free each one
+    list_iterate(&(map)->vmm_list, vma, vmarea_t, vma_plink)
+    {
+        list_remove(&vma->vma_plink);
+        vmarea_free(vma);
+    }
+
+    // Free the map
+    slab_obj_free(vmmap_allocator, map);
+
+    // Set the map to NULL
+    *mapp = NULL;
 }
 
 /*
@@ -70,7 +132,22 @@ void vmmap_destroy(vmmap_t **mapp)
  */
 void vmmap_insert(vmmap_t *map, vmarea_t *new_vma)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_insert*");
+    // NOT_YET_IMPLEMENTED("VM: vmmap_insert*");
+
+    // iterate over the list of vmareas
+    list_iterate(&map->vmm_list, vma, vmarea_t, vma_plink)
+    {
+        // if the new vmarea is after the current vmarea
+        if (vma->vma_start > new_vma->vma_end)
+        {
+            // insert the new vmarea before the current vmarea
+            list_insert_before(&vma->vma_plink, &new_vma->vma_plink);
+            return;
+        }
+    }
+
+    // insert this map to the tail
+    list_insert_tail(&map->vmm_list, &new_vma->vma_plink);
 }
 
 /*
@@ -90,7 +167,51 @@ void vmmap_insert(vmmap_t *map, vmarea_t *new_vma)
  */
 ssize_t vmmap_find_range(vmmap_t *map, size_t npages, int dir)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_find_range");
+    // NOT_YET_IMPLEMENTED("VM: vmmap_find_range");
+
+    // case 1: dir is VMMAP_DIR_LOHI
+    if (dir == VMMAP_DIR_LOHI)
+    {
+        // iterate over the page numbers
+        size_t vfn = ADDR_TO_PN(USER_MEM_LOW);
+        while (vfn <= ADDR_TO_PN(USER_MEM_HIGH) - npages)
+        {
+            // Lookup the vmarea for this page number
+            vmarea_t *vma = vmmap_lookup(map, vfn);
+
+            // if the vmarea is NULL, return the page number
+            if (vma == NULL)
+            {
+                return vfn;
+            }
+
+            // if the vmarea is not NULL, set the page number to the end of the vmarea
+            vfn = vma->vma_end;
+        }
+    }
+
+    // case 2: dir is VMMAP_DIR_HILO
+    else if (dir == VMMAP_DIR_HILO)
+    {
+        // iterate over the page numbers
+        size_t vfn = ADDR_TO_PN(USER_MEM_HIGH) - npages;
+        while (vfn >= ADDR_TO_PN(USER_MEM_LOW))
+        {
+            // Lookup the vmarea for this page number
+            vmarea_t *vma = vmmap_lookup(map, vfn);
+
+            // if the vmarea is NULL, return the page number
+            if (vma == NULL)
+            {
+                return vfn;
+            }
+
+            // if the vmarea is not NULL, set the page number to the start of the vmarea
+            vfn = vma->vma_start - npages;
+        }
+    }
+
+    // if no range exists, return -1
     return -1;
 }
 
@@ -100,7 +221,19 @@ ssize_t vmmap_find_range(vmmap_t *map, size_t npages, int dir)
  */
 vmarea_t *vmmap_lookup(vmmap_t *map, size_t vfn)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_lookup");
+    // NOT_YET_IMPLEMENTED("VM: vmmap_lookup");
+
+    // iterate over the list of vmareas
+    list_iterate(&map->vmm_list, vma, vmarea_t, vma_plink)
+    {
+        // if the vfn lies within the range of the current vmarea
+        if (vfn >= vma->vma_start && vfn < vma->vma_end)
+        {
+            return vma;
+        }
+    }
+
+    // if the page is unmapped, return NULL
     return NULL;
 }
 
@@ -140,8 +273,83 @@ void vmmap_collapse(vmmap_t *map)
  */
 vmmap_t *vmmap_clone(vmmap_t *map)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_clone");
-    return NULL;
+    // NOT_YET_IMPLEMENTED("VM: vmmap_clone");
+
+    // Create a new vmmap
+    vmmap_t *new_vmmap = vmmap_create();
+    if (new_vmmap == NULL)
+    {
+        return NULL;
+    }
+
+    // Iterate over the list of vmareas
+    list_iterate(&map->vmm_list, vma, vmarea_t, vma_plink)
+    {
+        // Create a new vmarea
+        vmarea_t *new_vmarea = vmarea_alloc();
+        if (new_vmarea == NULL)
+        {
+            vmmap_destroy(&new_vmmap);
+            return NULL;
+        }
+
+        // Clone the fields of the vmarea
+        new_vmarea->vma_start = vma->vma_start;
+        new_vmarea->vma_end = vma->vma_end;
+        new_vmarea->vma_off = vma->vma_off;
+        new_vmarea->vma_prot = vma->vma_prot;
+        new_vmarea->vma_flags = vma->vma_flags;
+
+        // If the vmarea is share-mapped
+        if (vma->vma_flags & MAP_SHARED)
+        {
+            new_vmarea->vma_obj = vma->vma_obj;
+            mobj_ref(new_vmarea->vma_obj);
+        }
+
+        // If the vmarea is not share-mapped
+        else
+        {
+            // Create two shadow objects
+            mobj_lock(vma->vma_obj);
+            mobj_t *shadow_obj_map = shadow_create(vma->vma_obj);
+            mobj_unlock(vma->vma_obj);
+
+            mobj_unlock(shadow_obj_map); // unlock the map before use
+            if (shadow_obj_map == NULL)
+            {
+                vmarea_free(new_vmarea);
+                vmmap_destroy(&new_vmmap);
+                return NULL;
+            }
+
+            mobj_lock(vma->vma_obj);
+            mobj_t *shadow_obj_new = shadow_create(vma->vma_obj);
+            mobj_unlock(vma->vma_obj);
+
+            mobj_unlock(shadow_obj_new); // unlock the new before use
+            if (shadow_obj_new == NULL)
+            {
+                mobj_put(&shadow_obj_map);
+                vmarea_free(new_vmarea);
+                vmmap_destroy(&new_vmmap);
+                return NULL;
+            }
+
+            // Put the original vma_obj
+            mobj_put(&vma->vma_obj);
+
+            // Insert the shadow objects into their respective vmareas
+            new_vmarea->vma_obj = shadow_obj_new;
+            vma->vma_obj = shadow_obj_map;
+        }
+
+        // Insert the new vmarea into the new vmmap
+        vmmap_insert(new_vmmap, new_vmarea);
+    }
+
+    // Return the new vmmap
+    return new_vmmap;
 }
 
 /*
@@ -182,8 +390,98 @@ vmmap_t *vmmap_clone(vmmap_t *map)
 long vmmap_map(vmmap_t *map, vnode_t *file, size_t lopage, size_t npages,
                int prot, int flags, off_t off, int dir, vmarea_t **new_vma)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_map");
-    return -1;
+    // NOT_YET_IMPLEMENTED("VM: vmmap_map");
+
+    // Create a new vmarea
+    // see if lopage is 0. if so, use vmmap_find_range() to get a valid range
+    if (lopage == 0)
+    {
+        lopage = vmmap_find_range(map, npages, dir);
+        if (lopage == -1)
+        {
+            return -ENOMEM;
+        }
+    }
+
+    // Alloc the new vmarea
+    vmarea_t *new_vmarea = vmarea_alloc();
+    if (new_vmarea == NULL)
+    {
+        return -ENOMEM;
+    }
+    // Set the fields of the new vmarea
+    new_vmarea->vma_start = lopage;
+    new_vmarea->vma_end = lopage + npages;
+    new_vmarea->vma_off = ADDR_TO_PN(off);
+    new_vmarea->vma_prot = prot;
+    new_vmarea->vma_flags = flags;
+    new_vmarea->vma_vmmap = map;
+    new_vmarea->vma_obj = NULL;
+
+    // If file is NULL, create an anon object
+    if (file == NULL)
+    {
+        new_vmarea->vma_obj = anon_create();
+        mobj_unlock(new_vmarea->vma_obj); // unlock the anon object before use
+        if (new_vmarea->vma_obj == NULL)
+        {
+            vmarea_free(new_vmarea);
+            return -ENOMEM;
+        }
+    }
+    else 
+    {
+        // If file is non-NULL, use the vnode's mmap operation to get the mobj
+        long ret = file->vn_ops->mmap(file, &new_vmarea->vma_obj);
+        if (ret < 0)
+        {
+            // on fail, free the new vmarea and return the error
+            vmarea_free(new_vmarea);
+            return ret;
+        }
+    }
+
+    // If MAP_PRIVATE is specified, set up a shadow object
+    if (flags & MAP_PRIVATE)
+    {
+        mobj_lock(new_vmarea->vma_obj);
+        mobj_t *shadow_obj = shadow_create(new_vmarea->vma_obj);
+        mobj_unlock(new_vmarea->vma_obj);
+        mobj_unlock(shadow_obj); // unlock the shadow object before use
+        if (shadow_obj == NULL)
+        {
+            vmarea_free(new_vmarea);
+            return -ENOMEM;
+        }
+        new_vmarea->vma_obj = shadow_obj;
+    }
+
+    // If MAP_FIXED is specified and the given range overlaps with any preexisting mappings, remove the preexisting mappings
+    if (lopage != 0 && (flags & MAP_FIXED))
+    {
+        long ret = vmmap_remove(map, lopage, npages);
+        if (ret < 0)
+        {
+            vmarea_free(new_vmarea);
+            // remove/put the shadow/annon object if it exists
+            if (new_vmarea->vma_obj)
+            {
+                mobj_put(&new_vmarea->vma_obj); // FIXME: is this correct!
+            }
+
+            return ret;
+        }
+    }
+
+    // Insert the new vmarea into the map
+    vmmap_insert(map, new_vmarea);
+
+    // set ret val and return 0
+    if (new_vma)
+    {
+        *new_vma = new_vmarea;
+    }
+    return 0;
 }
 
 /*
@@ -219,8 +517,107 @@ long vmmap_map(vmmap_t *map, vnode_t *file, size_t lopage, size_t npages,
  */
 long vmmap_remove(vmmap_t *map, size_t lopage, size_t npages)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_remove");
-    return -1;
+    // NOT_YET_IMPLEMENTED("VM: vmmap_remove");
+
+    // Iterate over the list of vmareas
+    list_iterate(&map->vmm_list, vma, vmarea_t, vma_plink)
+    {
+        // if the vmarea is completely inside the region to be unmapped
+        if (vma->vma_start < lopage && vma->vma_end > lopage + npages)
+        {
+            // split the old vmarea into two vmareas
+            vmarea_t *new_vmarea = vmarea_alloc();
+            if (new_vmarea == NULL)
+            {
+                return -ENOMEM;
+            }
+
+            // Set the fields of the new vmarea
+            new_vmarea->vma_start = lopage + npages;
+            new_vmarea->vma_end = vma->vma_end;
+            new_vmarea->vma_off = vma->vma_off + (new_vmarea->vma_start - vma->vma_start);
+            new_vmarea->vma_prot = vma->vma_prot;
+            new_vmarea->vma_flags = vma->vma_flags;
+            new_vmarea->vma_vmmap = map;
+            new_vmarea->vma_obj = vma->vma_obj;
+            // increment the refcount of the object associated with the vmarea
+            mobj_ref(new_vmarea->vma_obj);
+
+            // Shorten the length of the old vmarea
+            vma->vma_end = lopage;
+
+            // Insert the new vmarea into the map
+            vmmap_insert(map, new_vmarea);
+
+            // call pt_unmap_range() and tlb_flush_range() to clean the pagetables and TLB
+            pt_unmap_range(
+                map->vmm_proc->p_pml4,
+                PN_TO_ADDR(lopage),
+                PN_TO_ADDR(lopage + npages)
+            );
+            tlb_flush_range(
+                map->vmm_proc->p_pml4, 
+                PN_TO_ADDR(lopage + npages) - PN_TO_ADDR(lopage)
+            );
+        }
+
+        // if the region overlaps the end of the vmarea
+        else if (vma->vma_start < lopage && vma->vma_end > lopage && vma->vma_end <= lopage + npages)
+        {
+            // shorten the length of the mapping
+            vma->vma_end = lopage;
+            // call pt_unmap_range() and tlb_flush_range() to clean the pagetables and TLB
+            pt_unmap_range(
+                map->vmm_proc->p_pml4,
+                PN_TO_ADDR(lopage),
+                PN_TO_ADDR(lopage + npages)
+            );
+            tlb_flush_range(
+                map->vmm_proc->p_pml4,
+                PN_TO_ADDR(lopage + npages) - PN_TO_ADDR(lopage)
+            );
+        }
+
+        // if the region overlaps the beginning of the vmarea
+        else if (vma->vma_start >= lopage && vma->vma_end > lopage + npages && vma->vma_start < lopage + npages)
+        {
+            // move the beginning of the mapping and shorten its length
+            vma->vma_off += (lopage + npages - vma->vma_start);
+            vma->vma_start = lopage + npages;
+
+            // call pt_unmap_range() and tlb_flush_range() to clean the pagetables and TLB
+            pt_unmap_range(
+                map->vmm_proc->p_pml4,
+                PN_TO_ADDR(lopage),
+                PN_TO_ADDR(lopage + npages)
+            );
+            tlb_flush_range(
+                map->vmm_proc->p_pml4,
+                PN_TO_ADDR(lopage + npages) - PN_TO_ADDR(lopage)
+            );
+        }
+
+        // if the region completely contains the vmarea
+        else if (vma->vma_start >= lopage && vma->vma_end <= lopage + npages)
+        {
+            // remove the vmarea from the list
+            list_remove(&vma->vma_plink);
+            vmarea_free(vma);
+
+            // call pt_unmap_range() and tlb_flush_range() to clean the pagetables and TLB
+            pt_unmap_range(
+                map->vmm_proc->p_pml4,
+                PN_TO_ADDR(lopage),
+                PN_TO_ADDR(lopage + npages)
+            );
+            tlb_flush_range(
+                map->vmm_proc->p_pml4, 
+                PN_TO_ADDR(lopage + npages) - PN_TO_ADDR(lopage)
+            );
+        }
+    }
+
+    return 0;
 }
 
 /*
@@ -229,8 +626,29 @@ long vmmap_remove(vmmap_t *map, size_t lopage, size_t npages)
  */
 long vmmap_is_range_empty(vmmap_t *map, size_t startvfn, size_t npages)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_is_range_empty");
-    return 0;
+    // NOT_YET_IMPLEMENTED("VM: vmmap_is_range_empty");
+
+    // Iterate over the list of vmareas
+    list_iterate(&map->vmm_list, vma, vmarea_t, vma_plink)
+    {
+        // if the range completely contains the vmarea
+        if (vma->vma_start <= startvfn && vma->vma_end >= startvfn + npages)
+        {
+            return 0;
+        }
+        // if the start of the vmarea is greater than or equal to the start of the range
+        if (vma->vma_start < startvfn + npages && vma->vma_start >= startvfn)
+        {
+            return 0;
+        }
+        // check if the end of the vmarea is greater than the start of the range
+        if (vma->vma_end > startvfn && vma->vma_end <= startvfn + npages)
+        {
+            return 0;
+        }
+    }
+
+    return 1;
 }
 
 /*
@@ -250,7 +668,55 @@ long vmmap_is_range_empty(vmmap_t *map, size_t startvfn, size_t npages)
  */
 long vmmap_read(vmmap_t *map, const void *vaddr, void *buf, size_t count)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_read");
+    // NOT_YET_IMPLEMENTED("VM: vmmap_read");
+
+    // Iterate over the page numbers
+    size_t vfn = ADDR_TO_PN(vaddr);
+    size_t end_vfn = ADDR_TO_PN(vaddr + count);
+    size_t bytes_read = 0;
+    while (vfn < end_vfn)
+    {
+        // Lookup the vmarea for this page number
+        vmarea_t *vma = vmmap_lookup(map, vfn);
+        if (vma == NULL)
+        {
+            return -EFAULT;
+        }
+
+        // Find the pframe for this page number
+        pframe_t *pf;
+        mobj_lock(vma->vma_obj);
+        long ret = mobj_get_pframe(vma->vma_obj, vfn - vma->vma_start + vma->vma_off, 0, &pf);
+        mobj_unlock(vma->vma_obj);
+        if (ret < 0)
+        {
+            return ret;
+        }
+
+        // Read from the pframe and copy it into buf
+        void *cursor = (void *)(bytes_read + vaddr);
+        size_t bytes_this_iteration = MIN(PAGE_SIZE - PAGE_OFFSET(cursor), count - bytes_read);
+        memcpy(
+            buf + bytes_read,
+            (void *)pf->pf_addr + PAGE_OFFSET(cursor),
+            bytes_this_iteration
+        );
+
+        // Unlock the pframe
+        pframe_release(&pf);
+
+        // Increment the bytes read
+        bytes_read += bytes_this_iteration;
+
+        // check if we have read enough
+        if (bytes_read >= count)
+        {
+            return 0;
+        }
+
+        // Increment the page number
+        vfn++;
+    }
     return 0;
 }
 
@@ -272,7 +738,59 @@ long vmmap_read(vmmap_t *map, const void *vaddr, void *buf, size_t count)
  */
 long vmmap_write(vmmap_t *map, void *vaddr, const void *buf, size_t count)
 {
-    NOT_YET_IMPLEMENTED("VM: vmmap_write");
+    // NOT_YET_IMPLEMENTED("VM: vmmap_write");
+
+    // Iterate over the page numbers
+    size_t vfn = ADDR_TO_PN(vaddr);
+    size_t end_vfn = ADDR_TO_PN(vaddr + count);
+    size_t bytes_written = 0;
+    while(vfn < end_vfn)
+    {
+        // Lookup the vmarea for this page number
+        vmarea_t *vma = vmmap_lookup(map, vfn);
+        if (vma == NULL)
+        {
+            return -EFAULT;
+        }
+
+        // Find the pframe for this page number
+        pframe_t *pf;
+        mobj_lock(vma->vma_obj);
+        long ret = mobj_get_pframe(vma->vma_obj, vfn - vma->vma_start + vma->vma_off, 1, &pf);
+        mobj_unlock(vma->vma_obj);
+        if (ret < 0)
+        {
+            return ret;
+        }
+
+        // Write to the pframe, copying data from buf
+        void *cursor = (void *)(bytes_written + vaddr);
+        size_t bytes_this_iteration = MIN(PAGE_SIZE - PAGE_OFFSET(cursor), count - bytes_written);
+        memcpy(
+            (void *)pf->pf_addr + PAGE_OFFSET(cursor),
+            buf + bytes_written,
+            bytes_this_iteration
+        );
+
+        // Dirty the page
+        pf->pf_dirty = 1;
+
+        // Unlock the pframe
+        pframe_release(&pf);
+
+        // Increment the bytes written
+        bytes_written += bytes_this_iteration;
+
+        // check if we have written enough
+        if (bytes_written >= count)
+        {
+            return 0;
+        }
+
+        // Increment the page number
+        vfn++;
+    }
+
     return 0;
 }