maple_tree: Zero stack struct

Signed-off-by: Liam R. Howlett <Liam.Howlett@Oracle.com>

diff --git a/lib/test_maple_tree.c b/lib/test_maple_tree.c
index 4f58df24107514530befb780ee244cd4c4e3f553..5a8e6f37accf35eb392219d04e6eae62583d5832 100644 (file)
--- a/lib/test_maple_tree.c
+++ b/lib/test_maple_tree.c
@@ -17,9 +17,7 @@ int mtree_insert_index(struct maple_tree *mt, unsigned long index, gfp_t gfp)
 
 static void mtree_erase_index(struct maple_tree *mt, unsigned long index)
 {
-       printk("\t\terase %lu\n", index);
        MT_BUG_ON(mt, mtree_erase(mt, index) != xa_mk_value(index & LONG_MAX));
-       printk("\t\tload %lu\n", index);
        MT_BUG_ON(mt, mtree_load(mt, index) != NULL);
 }
 
@@ -63,9 +61,6 @@ static noinline void check_mtree_alloc_range(struct maple_tree *mt,
        MT_BUG_ON(mt, ret != eret);
        if (ret)
                return;
-       if (result != expected) {
-               printk("Result is %lu\n", result);
-       }
 
        MT_BUG_ON(mt, result != expected);
 }
@@ -91,7 +86,6 @@ static noinline void check_load(struct maple_tree *mt, unsigned long index,
 {
        void *ret = mtree_test_load(mt, index);
 
-       printk("load %lu ret %p != %p\n", index, ret, ptr);
        MT_BUG_ON(mt, ret != ptr);
 }
 
@@ -356,7 +350,6 @@ static noinline void check_lb_not_empty(struct maple_tree *mt)
 
        i = huge;
        while (i > 4096) {
-               mt_dump(mt);
                check_insert(mt, i, (void *) i);
                for (j = huge; j >= i; j /= 2) {
                        check_load(mt, j-1, NULL);
@@ -559,8 +552,6 @@ static noinline void check_find(struct maple_tree *mt)
        entry = mas_prev(&mas, 0);
        index = mas.index;
        last = mas.last;
-       printk("Expected %lu-%lu=> %p\n", index, last, entry);
-       mt_dump(mt);
 
        // Erase the last entry.
        mas_reset(&mas);
@@ -570,17 +561,10 @@ static noinline void check_find(struct maple_tree *mt)
 
        // Get the previous value from MAS_START
        mas_reset(&mas);
-       printk("non mas index set to %lu\n", index);
-       printk("index set to %lu\n", mas.index);
        entry2 = mas_prev(&mas, 0);
-       printk("index set to %lu\n", mas.index);
 
        // Check results.
-       printk("Obtained %lu-%lu=> %p\n", mas.index, mas.last, entry2);
-       printk("entry %p %p\n" ,entry, entry2);
        MT_BUG_ON(mt, entry != entry2);
-       printk("index %lu != %lu\n", index, mas.index);
-       printk("last %lu != %lu\n", last, mas.last);
        MT_BUG_ON(mt, index != mas.index);
        MT_BUG_ON(mt, last != mas.last);
        mas_unlock(&mas);
@@ -615,22 +599,17 @@ static noinline void check_find_2(struct maple_tree *mt)
        }
 
        for (i = 0; i < 256; i++) {
-               mt_dump(mt);
-               printk("\t\tErase %lu\n", i);
                mtree_erase_index(mt, i);
-               printk("\t\tDONE %lu\n\n", i);
                j = i + 1;
                mas_set(&mas, 0);
                rcu_read_lock();
                mas_for_each(&mas, entry, ULONG_MAX) {
                        if (mas_retry(&mas, entry))
                                continue;
-                       printk("Checking %lu\n", j);
                        MT_BUG_ON(mt, entry != xa_mk_value(j));
                        j++;
                }
                rcu_read_unlock();
-               printk("Checking %lu = 256\n", j);
                MT_BUG_ON(mt, j != 256);
        }
 
@@ -863,20 +842,11 @@ static noinline void check_erase_testset(struct maple_tree *mt)
        // Shrinking tree test.
        //
 
-       printk("\tStarting Shrinking with this:\n");
-       mt_dump(mt);
-       for (int i = 13; i < ARRAY_SIZE(set); i++) {
-               printk("\tInserting %lu\n", set[i]);
+       for (int i = 13; i < ARRAY_SIZE(set); i++)
                erase_check_insert(mt, i);
-               mt_dump(mt);
-       }
 
-       printk("\tStarting shrink with this:\n");
-       mt_dump(mt);
        mt_set_non_kernel(99);
        for (int i = 18; i < ARRAY_SIZE(set); i++) {
-               printk("\tErase %lu\n", set[i]);
-               mt_dump(mt);
                erase_check_erase(mt, i);
                for (int j = 0; j < ARRAY_SIZE(set); j++) {
                        if (j < 18 || j > i)
@@ -887,8 +857,6 @@ static noinline void check_erase_testset(struct maple_tree *mt)
        }
        mt_set_non_kernel(35);
        for (int i = 0; i < 18; i++) {
-               mt_dump(mt);
-               printk("\tCheck erase of %lu\n", set[i]);
                erase_check_erase(mt, i);
                for (int j = 0; j < ARRAY_SIZE(set); j++) {
                        if (j < 18 && j > i)
@@ -923,30 +891,23 @@ static noinline void check_erase2_testset(struct maple_tree *mt,
                unsigned long e_min, e_max;
                MA_STATE(mas_start, mt, set[i+1], set[i+1]);
                MA_STATE(mas_end, mt, set[i+2]-1, set[i+2]-1);
-               printk("%s: %s %lu - %lu\n", __func__,
-                               set[i] == STORE ? "store" : "erase",
-                               set[i+1], set[i+2]-1);
+               //printk("%s: %s %lu - %lu\n", __func__,
+               //              set[i] == STORE ? "store" : "erase",
+               //              set[i+1], set[i+2]-1);
 
                s_entry = mas_range_load(&mas_start, &s_min, &s_max);
                e_entry = mas_range_load(&mas_end, &e_min, &e_max);
-               printk("start %lu-%lu => %p\n", s_min, s_max, s_entry);
-               printk("end   %lu-%lu => %p\n", e_min, e_max, e_entry);
 
                switch(set[i]) {
                case STORE:
-                       printk("entry_cnt = %d\n", entry_cnt);
                        if ((s_min == e_min) && (s_max == e_max)) {
-                               printk("starts and ends in the same range\n");
                                if (!entry_cnt)
                                        entry_cnt++;
                                else if (!mt_is_empty(s_entry)) {
-                                       printk("not empty\n");
                                        if (e_max > mas_end.last) {
-                                               printk("Add for end\n");
                                                entry_cnt++;
                                        }
                                        if (s_min < mas_start.index) {
-                                               printk("Add for start\n");
                                                entry_cnt++;
                                        }
                                } else {
@@ -967,20 +928,16 @@ static noinline void check_erase2_testset(struct maple_tree *mt,
                                while (!mas_is_none(&mas_start) &&
                                       (mas_start.last != e_max) ) {
                                        if (s_entry) {
-                                               printk("inc\n");
                                                cnt++;
                                        }
                                        s_entry = mas_next(&mas_start,
                                                        set[i+2] - 1);
                                }
-                               printk("decrement by %d\n", cnt - 1);
                                entry_cnt = entry_cnt - cnt + 1;
                        }
 
-                       printk("Storing now\n");
                        erase_check_store_range(mt, set, i + 1,
                                        xa_mk_value(set[i+1]));
-                       printk("\nentry_cnt = %d\n", entry_cnt);
                        break;
                case ERASE:
                        check_erase(mt, set[i+1], xa_mk_value(set[i+1]));
@@ -991,29 +948,25 @@ static noinline void check_erase2_testset(struct maple_tree *mt,
                check = 0;
                addr = 0;
                mt_for_each(mt, foo, addr, ULONG_MAX) {
-                       printk("%d %ld\n", check, addr - 1);
                        check++;
                        if (check > entry_cnt)
                                break;
                }
 
-               printk("mt_for_each %d == entry_cnt %d\n", check, entry_cnt);
                MT_BUG_ON(mt, check != entry_cnt);
 
                check = 0;
                mas_reset(&mas);
                mas.index = 0;
+               rcu_read_lock();
                mas_for_each(&mas, foo, ULONG_MAX) {
                        if (mas_retry(&mas, foo))
                                continue;
                        check++;
-                       printk("%d: %lu-%lu -> %p\n", check, mas.index, mas.last, foo);
                        if (check > entry_cnt)
                                break;
                }
-               printk("mas_for_each check = %d entry_cnt %d\n", check,
-                               entry_cnt);
-               mt_dump(mas.tree);
+               rcu_read_unlock();
 
                MT_BUG_ON(mt, check != entry_cnt);
 
@@ -1686,6 +1639,7 @@ STORE, 47708488642560, 47708488646656,
                if (mas_retry(&mas, entry))
                        continue;
        }
+       rcu_read_unlock();
        mtree_destroy(mt);
 
        mtree_init(mt, 0);
@@ -1703,10 +1657,8 @@ STORE, 47708488642560, 47708488646656,
 
        mtree_init(mt, 0);
        check_erase2_testset(mt, set8, ARRAY_SIZE(set8));
-       mt_dump(mt);
        mtree_destroy(mt);
 
-       rcu_read_unlock();
 }
 static noinline void check_alloc_rev_range(struct maple_tree *mt)
 {
@@ -1807,7 +1759,7 @@ static noinline void check_alloc_rev_range(struct maple_tree *mt)
 
        for (i = 0; i < range_cnt; i += 2) {
                //                      Inclusive    , Inclusive (with the -1)
-               printk("\tInsert %lu-%lu\n", range[i] >> 12, (range[i + 1] >> 12) - 1);
+               // printk("\tInsert %lu-%lu\n", range[i] >> 12, (range[i + 1] >> 12) - 1);
                check_insert_range(mt, range[i] >> 12, (range[i + 1] >> 12) - 1,
                                xa_mk_value(range[i] >> 12), 0);
                mt_validate(mt);
@@ -1938,12 +1890,10 @@ static noinline void check_alloc_range(struct maple_tree *mt)
        int req_range_cnt = ARRAY_SIZE(req_range);
 
        for (i = 0; i < range_cnt; i += 2) {
-               mt_dump(mt);
-               printk("\tInsert %lu-%lu\n", range[i] >> 12, (range[i + 1] >> 12) - 1);
+               //printk("\tInsert %lu-%lu\n", range[i] >> 12, (range[i + 1] >> 12) - 1);
                check_insert_range(mt, range[i] >> 12, (range[i + 1] >> 12) - 1,
                                xa_mk_value(range[i] >> 12), 0);
                mt_validate(mt);
-               mt_dump(mt);
        }
 
 
@@ -1958,12 +1908,13 @@ static noinline void check_alloc_range(struct maple_tree *mt)
                mas_reset(&mas);
        }
        for (i = 0; i < req_range_cnt; i += 5) {
-               mt_dump(mt);
+               /*
                printk("\tTest %d: %lu-%lu size %lu expected %lu\n", i/5,
                                req_range[i]   >> 12,
                                req_range[i + 1]   >> 12,
                                req_range[i + 2]   >> 12,
                                req_range[i + 3]   >> 12);
+                               */
                check_mtree_alloc_range(mt,
                                req_range[i]   >> 12, // start
                                req_range[i+1] >> 12, // end
@@ -2141,15 +2092,9 @@ static int maple_tree_seed(void)
 
        mtree_init(&tree, 0);
        /* Test inserting into a NULL hole. */
-       mt_dump(&tree);
        check_insert(&tree, set[5], ptr);       // insert 1001 -> ptr
-       mt_dump(&tree);
-       printk("insert 1003\n");
        check_insert(&tree, set[7], &tree);       // insert 1003 -> &tree
-       mt_dump(&tree);
        check_insert(&tree, set[6], ptr);       // insert 1002 -> ptr
-       mt_dump(&tree);
-       printk("Loading\n");
        check_load(&tree, set[5], ptr);         // See if 1001 -> ptr
        check_load(&tree, set[6], ptr);         // See if 1002 -> ptr
        check_load(&tree, set[7], &tree);       // See if 1003 -> &tree