maple_tree: Change more to use ma_get_slots

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

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index c4e768ef7fcb5a6db5c9f9ee141b0d868dd11f22..b618acfb2e99cc7c3b3ee0a10e3482560d1195d1 100644 (file)
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -1708,9 +1708,10 @@ static inline struct maple_enode *mte_node_or_none(struct maple_enode *enode)
  */
 static inline void mast_topiary(struct maple_subtree_state *mast)
 {
-       unsigned char l_slot, r_slot, slot;
+       unsigned char l_off, r_off, offset;
        unsigned long l_index,  range_min, range_max;
        struct maple_enode *child;
+       void **slots;
 
        // The left node is consumed, so add to the free list.
        l_index = mast->orig_l->index;
@@ -1718,29 +1719,34 @@ static inline void mast_topiary(struct maple_subtree_state *mast)
        mas_node_walk(mast->orig_l, mte_node_type(mast->orig_l->node),
                      &range_min, &range_max);
        mast->orig_l->index = l_index;
-       l_slot = mas_offset(mast->orig_l);
-       r_slot = mas_offset(mast->orig_r);
+       l_off = mas_offset(mast->orig_l);
+       r_off = mas_offset(mast->orig_r);
        if (mast->orig_l->node == mast->orig_r->node) {
-               for (slot = l_slot + 1; slot < r_slot; slot++)
-                       mat_add(mast->destroy,
-                               mas_get_slot(mast->orig_l, slot));
+               slots = ma_get_slots(mte_to_node(mast->orig_l->node),
+                                    mte_node_type(mast->orig_l->node));
+               for (offset = l_off + 1; offset < r_off; offset++)
+                       mat_add(mast->destroy, slots[offset]);
                return;
        }
        /* mast->orig_r is different and consumed. */
        if (mte_is_leaf(mast->orig_r->node))
                return;
 
-       /* Now destroy l_slot + 1 -> end and 0 -> r_slot - 1 */
-       slot = l_slot + 1;
-       while (slot < mt_slot_count(mast->orig_l->node)) {
-               child = mas_get_slot(mast->orig_l, slot++);
+       /* Now destroy l_off + 1 -> end and 0 -> r_off - 1 */
+       offset = l_off + 1;
+       slots = ma_get_slots(mte_to_node(mast->orig_l->node),
+                            mte_node_type(mast->orig_l->node));
+       while (offset < mt_slot_count(mast->orig_l->node)) {
+               child = slots[offset++];
                if (!child)
                        break;
                mat_add(mast->destroy, child);
        }
 
-       for (slot = 0; slot < r_slot; slot++)
-               mat_add(mast->destroy, mas_get_slot(mast->orig_r, slot));
+       slots = ma_get_slots(mte_to_node(mast->orig_r->node),
+                            mte_node_type(mast->orig_r->node));
+       for (offset = 0; offset < r_off; offset++)
+               mat_add(mast->destroy, slots[offset]);
 }
 
 static inline void mast_rebalance_next(struct maple_subtree_state *mast,
@@ -3163,11 +3169,12 @@ static inline int mas_dead_node(struct ma_state *mas, unsigned long index);
 static inline void mas_prev_node(struct ma_state *mas, unsigned long limit)
 {
        unsigned long pivot, start_piv, min;
-       int slot = mas_offset(mas);
+       int offset = mas_offset(mas);
        struct maple_enode *mn;
        int level;
+       void **slots;
 
-       start_piv = mas_safe_pivot(mas, slot);
+       start_piv = mas_safe_pivot(mas, offset);
 restart_prev_node:
        level = 0;
        if (mte_is_root(mas->node) || mas->node == MAS_NONE)
@@ -3175,33 +3182,35 @@ restart_prev_node:
 
        while (1) {
 
-               slot = mte_parent_slot(mas->node);
+               offset = mte_parent_slot(mas->node);
                mas_ascend(mas);
                level++;
 
                if (mas_dead_node(mas, start_piv))
                        goto restart_prev_node;
 
-               if (!slot)
+               if (!offset)
                        goto ascend;
 
-               slot--;
+               offset--;
+               slots = ma_get_slots(mas_mn(mas), mte_node_type(mas->node));
                do {
-                       pivot = mas_safe_pivot(mas, slot);
+                       pivot = mas_safe_pivot(mas, offset);
 
-                       min = mas_safe_min(mas, slot);
+                       min = mas_safe_min(mas, offset);
                        if (pivot < limit)
                                goto no_entry;
 
-                       if (slot != 0 && pivot == 0)
+                       if (offset != 0 && pivot == 0)
                                break;
 
-                       mn = mas_get_slot(mas, slot);
+                       mn = rcu_dereference_check(slots[offset],
+                               lockdep_is_held(mas->tree->ma_lock));
                        if (!mn)
                                continue;
 
                        if (level == 1) {
-                               mas_set_offset(mas, slot);
+                               mas_set_offset(mas, offset);
                                mas->node = mn;
                                mas->max = pivot;
                                mas->min = min;
@@ -3214,8 +3223,10 @@ restart_prev_node:
                        mas->node = mn;
                        mas->max = pivot;
                        mas->min = min;
-                       slot = mas_data_end(mas) + 1;
-               } while (slot-- > 0);
+                       offset = mas_data_end(mas) + 1;
+                       slots = ma_get_slots(mas_mn(mas),
+                                            mte_node_type(mas->node));
+               } while (offset-- > 0);
 
 ascend:
                if (mte_is_root(mas->node))
@@ -5063,18 +5074,20 @@ void mas_validate_parent_slot(struct ma_state *mas)
        struct maple_enode *node;
        enum maple_type p_type = mas_parent_enum(mas, mas->node);
        unsigned char p_slot = mte_parent_slot(mas->node);
+       void **slots;
        int i;
 
        if (mte_is_root(mas->node))
                return;
 
        parent = mte_parent(mas->node);
+       slots = ma_get_slots(parent, p_type);
        MT_BUG_ON(mas->tree, mas_mn(mas) == parent);
 
        // Check prev/next parent slot for duplicate node entry
 
        for (i = 0; i < mt_slots[p_type]; i++) {
-               node = ma_get_slot(parent, i, p_type, mas->tree);
+               node = slots[i];
                if (i == p_slot) {
                        if (node != mas->node)
                                pr_err("parent %p[%u] does not have %p\n",
@@ -5091,6 +5104,7 @@ void mas_validate_parent_slot(struct ma_state *mas)
 void mas_validate_child_slot(struct ma_state *mas)
 {
        enum maple_type type = mte_node_type(mas->node);
+       void **slots = ma_get_slots(mte_to_node(mas->node), type);
        struct maple_enode *child;
        unsigned char i;
 
@@ -5098,7 +5112,7 @@ void mas_validate_child_slot(struct ma_state *mas)
                return;
 
        for (i = 0; i < mt_slots[type]; i++) {
-               child = mte_get_slot(mas->node, i, mas->tree);
+               child = slots[i];
                if (!child)
                        break;