mm: Clean up the functional interface
authorBarret Rhoden <brho@cs.berkeley.edu>
Thu, 22 Mar 2018 16:26:20 +0000 (12:26 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 6 Apr 2018 19:23:01 +0000 (15:23 -0400)
I have a few changes to make, and there's no need for the rest of the
kernel to know about it.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/include/mm.h
kern/src/ktest/pb_ktests.c
kern/src/mm.c

index ccb2119..0080953 100644 (file)
@@ -69,19 +69,7 @@ static inline char *vmr_to_filename(struct vm_region *vmr)
        return foc_to_name(vmr->__vm_foc);
 }
 
-/* VM Region Management Functions.  For now, these just maintain themselves -
- * anything related to mapping needs to be done by the caller. */
 void vmr_init(void);
-struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len);
-struct vm_region *split_vmr(struct vm_region *vmr, uintptr_t va);
-int merge_vmr(struct vm_region *first, struct vm_region *second);
-struct vm_region *merge_me(struct vm_region *vmr);
-int grow_vmr(struct vm_region *vmr, uintptr_t va);
-int shrink_vmr(struct vm_region *vmr, uintptr_t va);
-void destroy_vmr(struct vm_region *vmr);
-struct vm_region *find_vmr(struct proc *p, uintptr_t va);
-struct vm_region *find_first_vmr(struct proc *p, uintptr_t va);
-void isolate_vmrs(struct proc *p, uintptr_t va, size_t len);
 void unmap_and_destroy_vmrs(struct proc *p);
 int duplicate_vmrs(struct proc *p, struct proc *new_p);
 void print_vmrs(struct proc *p);
index 2841e4c..c56839b 100644 (file)
@@ -949,154 +949,6 @@ bool test_ucq(void)
        return true;
 }
 
-/* rudimentary tests.  does the basics, create, merge, split, etc.  Feel free to
- * add more, esp for the error conditions and finding free slots.  This is also
- * a bit lazy with setting the caller's fields (perm, flags, etc). */
-// TODO: See if we could add more assertions, try to add more descriptive
-//       messages to assertions.
-bool test_vm_regions(void)
-{
-       #define MAX_VMR_TESTS 10
-       struct proc pr, *p = &pr;       /* too lazy to even create one */
-       int n = 0;
-       TAILQ_INIT(&p->vm_regions);
-
-       struct vmr_summary {
-               uintptr_t base;
-               uintptr_t end;
-       };
-       int check_vmrs(struct proc *p, struct vmr_summary *results, int len, int n)
-       {
-               int count = 0;
-               struct vm_region *vmr;
-               TAILQ_FOREACH(vmr, &p->vm_regions, vm_link) {
-                       if (count >= len) {
-                               printk("More vm_regions than expected\n");
-                               break;
-                       }
-                       if ((vmr->vm_base != results[count].base) ||
-                           (vmr->vm_end != results[count].end)) {
-                               printk("VM test case %d failed!\n", n);
-                               print_vmrs(p);
-                               return -1;
-                       }
-                       count++;
-               }
-               return count;
-       }
-       struct vm_region *vmrs[MAX_VMR_TESTS];
-       struct vmr_summary results[MAX_VMR_TESTS];
-
-       memset(results, 0, sizeof(results));
-       /* Make one */
-       vmrs[0] = create_vmr(p, 0x2000, 0x1000);
-       results[0].base = 0x2000;
-       results[0].end = 0x3000;
-       check_vmrs(p, results, 1, n++);
-       /* Grow it */
-       grow_vmr(vmrs[0], 0x4000);
-       results[0].base = 0x2000;
-       results[0].end = 0x4000;
-       check_vmrs(p, results, 1, n++);
-       /* Grow it poorly */
-       KT_ASSERT_M("It should pass bad grow test",
-                   (-1 == grow_vmr(vmrs[0], 0x3000)));
-       check_vmrs(p, results, 1, n++);
-       /* Make another right next to it */
-       vmrs[1] = create_vmr(p, 0x4000, 0x1000);
-       results[1].base = 0x4000;
-       results[1].end = 0x5000;
-       check_vmrs(p, results, 2, n++);
-       /* try to grow through it */
-       KT_ASSERT_M("It should pass bad grow test",
-                   (-1 == grow_vmr(vmrs[0], 0x5000)));
-       check_vmrs(p, results, 2, n++);
-       /* Merge them */
-       merge_vmr(vmrs[0], vmrs[1]);
-       results[0].end = 0x5000;
-       results[1].base = 0;
-       results[1].end = 0;
-       check_vmrs(p, results, 1, n++);
-       vmrs[1]= create_vmr(p, 0x6000, 0x4000);
-       results[1].base = 0x6000;
-       results[1].end = 0xa000;
-       check_vmrs(p, results, 2, n++);
-       /* try to merge unmergables (just testing ranges) */
-       KT_ASSERT_M("It should pass bad merge test",
-                   (-1 == merge_vmr(vmrs[0], vmrs[1])));
-       check_vmrs(p, results, 2, n++);
-       vmrs[2] = split_vmr(vmrs[1], 0x8000);
-       results[1].end = 0x8000;
-       results[2].base = 0x8000;
-       results[2].end = 0xa000;
-       check_vmrs(p, results, 3, n++);
-       /* destroy one */
-       destroy_vmr(vmrs[1]);
-       results[1].base = 0x8000;
-       results[1].end = 0xa000;
-       check_vmrs(p, results, 2, n++);
-       /* shrink */
-       shrink_vmr(vmrs[2], 0x9000);
-       results[1].base = 0x8000;
-       results[1].end = 0x9000;
-       check_vmrs(p, results, 2, n++); /* 10 */
-       KT_ASSERT_M("We should be able to find the right vmr",
-                   (vmrs[2] == find_vmr(p, 0x8500)));
-       KT_ASSERT_M("We should be able to find the right vmr",
-                   (vmrs[2] == find_first_vmr(p, 0x8500)));
-       KT_ASSERT_M("We should be able to find the right vmr",
-                   (vmrs[2] == find_first_vmr(p, 0x7500)));
-       KT_ASSERT_M("We shouldn't be able to find a vmr",
-                   !(find_first_vmr(p, 0x9500)));
-       /* grow up to another */
-       grow_vmr(vmrs[0], 0x8000);
-       results[0].end = 0x8000;
-       check_vmrs(p, results, 2, n++);
-       vmrs[0]->vm_prot = 88;
-       vmrs[2]->vm_prot = 77;
-       /* should be unmergeable due to perms */
-       KT_ASSERT_M("It should pass bad merge test",
-                   -1 == merge_vmr(vmrs[0], vmrs[2]));
-       check_vmrs(p, results, 2, n++);
-       /* should merge now */
-       vmrs[2]->vm_prot = 88;
-       merge_vmr(vmrs[0], vmrs[2]);
-       results[0].end = 0x9000;
-       check_vmrs(p, results, 1, n++);
-       destroy_vmr(vmrs[0]);
-       check_vmrs(p, results, 0, n++);
-       /* Check the automerge function */
-       vmrs[0] = create_vmr(p, 0x2000, 0x1000);
-       vmrs[1] = create_vmr(p, 0x3000, 0x1000);
-       vmrs[2] = create_vmr(p, 0x4000, 0x1000);
-       for (int i = 0; i < 3; i++) {
-               vmrs[i]->vm_prot = PROT_READ;
-               vmrs[i]->vm_flags = 0;
-               /* would like to test this, it's a pain for now */
-               if (vmr_has_file(vmrs[i]))
-                       vmrs[i]->__vm_foc->type = 0;
-       }
-       vmrs[0] = merge_me(vmrs[1]);
-       results[0].base = 0x2000;
-       results[0].end = 0x5000;
-       check_vmrs(p, results, 1, n++);
-       destroy_vmr(vmrs[0]);
-       check_vmrs(p, results, 0, n++);
-       /* Check unfixed creation requests */
-       vmrs[0] = create_vmr(p, 0x0000, 0x1000);
-       vmrs[1] = create_vmr(p, 0x0000, 0x1000);
-       vmrs[2] = create_vmr(p, 0x0000, 0x1000);
-       results[0].base = 0x0000;
-       results[0].end  = 0x1000;
-       results[1].base = 0x1000;
-       results[1].end  = 0x2000;
-       results[2].base = 0x2000;
-       results[2].end  = 0x3000;
-       check_vmrs(p, results, 3, n++);
-
-       return true;
-}
-
 bool test_radix_tree(void)
 {
        struct radix_tree real_tree = RADIX_INITIALIZER;
@@ -2214,7 +2066,6 @@ static struct ktest ktests[] = {
        KTEST_REG(circular_buffer,    CONFIG_TEST_circular_buffer),
        KTEST_REG(bcq,                CONFIG_TEST_bcq),
        KTEST_REG(ucq,                CONFIG_TEST_ucq),
-       KTEST_REG(vm_regions,         CONFIG_TEST_vm_regions),
        KTEST_REG(radix_tree,         CONFIG_TEST_radix_tree),
        KTEST_REG(random_fs,          CONFIG_TEST_random_fs),
        KTEST_REG(kthreads,           CONFIG_TEST_kthreads),
index 2a0320e..6601ba7 100644 (file)
@@ -250,7 +250,7 @@ void vmr_init(void)
  *
  * TODO: take a look at solari's vmem alloc.  And consider keeping these in a
  * tree of some sort for easier lookups. */
-struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
+static struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
 {
        struct vm_region *vmr = 0, *vm_i, *vm_next;
        uintptr_t gap_end;
@@ -306,7 +306,7 @@ struct vm_region *create_vmr(struct proc *p, uintptr_t va, size_t len)
 /* Split a VMR at va, returning the new VMR.  It is set up the same way, with
  * file offsets fixed accordingly.  'va' is the beginning of the new one, and
  * must be page aligned. */
-struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
+static struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
 {
        struct vm_region *new_vmr;
 
@@ -335,9 +335,21 @@ struct vm_region *split_vmr(struct vm_region *old_vmr, uintptr_t va)
        return new_vmr;
 }
 
+/* Called by the unmapper, just cleans up.  Whoever calls this will need to sort
+ * out the page table entries. */
+static void destroy_vmr(struct vm_region *vmr)
+{
+       if (vmr_has_file(vmr)) {
+               pm_remove_vmr(vmr_to_pm(vmr), vmr);
+               foc_decref(vmr->__vm_foc);
+       }
+       TAILQ_REMOVE(&vmr->vm_proc->vm_regions, vmr, vm_link);
+       kmem_cache_free(vmr_kcache, vmr);
+}
+
 /* Merges two vm regions.  For now, it will check to make sure they are the
  * same.  The second one will be destroyed. */
-int merge_vmr(struct vm_region *first, struct vm_region *second)
+static int merge_vmr(struct vm_region *first, struct vm_region *second)
 {
        assert(first->vm_proc == second->vm_proc);
        if ((first->vm_end != second->vm_base) ||
@@ -356,7 +368,7 @@ int merge_vmr(struct vm_region *first, struct vm_region *second)
 /* Attempts to merge vmr with adjacent VMRs, returning a ptr to be used for vmr.
  * It could be the same struct vmr, or possibly another one (usually lower in
  * the address space. */
-struct vm_region *merge_me(struct vm_region *vmr)
+static struct vm_region *merge_me(struct vm_region *vmr)
 {
        struct vm_region *vmr_temp;
        /* Merge will fail if it cannot do it.  If it succeeds, the second VMR is
@@ -373,7 +385,7 @@ struct vm_region *merge_me(struct vm_region *vmr)
 
 /* Grows the vm region up to (and not including) va.  Fails if another is in the
  * way, etc. */
-int grow_vmr(struct vm_region *vmr, uintptr_t va)
+static int grow_vmr(struct vm_region *vmr, uintptr_t va)
 {
        assert(!PGOFF(va));
        struct vm_region *next = TAILQ_NEXT(vmr, vm_link);
@@ -387,7 +399,7 @@ int grow_vmr(struct vm_region *vmr, uintptr_t va)
 
 /* Shrinks the vm region down to (and not including) va.  Whoever calls this
  * will need to sort out the page table entries. */
-int shrink_vmr(struct vm_region *vmr, uintptr_t va)
+static int shrink_vmr(struct vm_region *vmr, uintptr_t va)
 {
        assert(!PGOFF(va));
        if ((va < vmr->vm_base) || (va > vmr->vm_end))
@@ -396,21 +408,9 @@ int shrink_vmr(struct vm_region *vmr, uintptr_t va)
        return 0;
 }
 
-/* Called by the unmapper, just cleans up.  Whoever calls this will need to sort
- * out the page table entries. */
-void destroy_vmr(struct vm_region *vmr)
-{
-       if (vmr_has_file(vmr)) {
-               pm_remove_vmr(vmr_to_pm(vmr), vmr);
-               foc_decref(vmr->__vm_foc);
-       }
-       TAILQ_REMOVE(&vmr->vm_proc->vm_regions, vmr, vm_link);
-       kmem_cache_free(vmr_kcache, vmr);
-}
-
 /* Given a va and a proc (later an mm, possibly), returns the owning vmr, or 0
  * if there is none. */
-struct vm_region *find_vmr(struct proc *p, uintptr_t va)
+static struct vm_region *find_vmr(struct proc *p, uintptr_t va)
 {
        struct vm_region *vmr;
        /* ugly linear seach */
@@ -423,7 +423,7 @@ struct vm_region *find_vmr(struct proc *p, uintptr_t va)
 
 /* Finds the first vmr after va (including the one holding va), or 0 if there is
  * none. */
-struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
+static struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
 {
        struct vm_region *vmr;
        /* ugly linear seach */
@@ -438,7 +438,7 @@ struct vm_region *find_first_vmr(struct proc *p, uintptr_t va)
 
 /* Makes sure that no VMRs cross either the start or end of the given region
  * [va, va + len), splitting any VMRs that are on the endpoints. */
-void isolate_vmrs(struct proc *p, uintptr_t va, size_t len)
+static void isolate_vmrs(struct proc *p, uintptr_t va, size_t len)
 {
        struct vm_region *vmr;
        if ((vmr = find_vmr(p, va)))