maple_tree: inline mas_spanning_rebalance_loop() into mas_wr_spanning_rebalance()

Just copy the code and replace count with height.  This is done to avoid
affecting other code paths into mas_spanning_rebalance_loop() for the next
change.

No functional change intended.

Link: https://lkml.kernel.org/r/20260130205935.2559335-14-Liam.Howlett@oracle.com
Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
Cc: Alice Ryhl <aliceryhl@google.com>
Cc: Andrew Ballance <andrewjballance@gmail.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Christian Kujau <lists@nerdbynature.de>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Cc: SeongJae Park <sj@kernel.org>
Cc: Sidhartha Kumar <sidhartha.kumar@oracle.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index 554fdffd6c5b9949f8397778ec7532c6a9485b18..a9b7e398c7dbd9227e03762789770a345e0cbdd7 100644 (file)
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -2862,6 +2862,13 @@ static void mas_spanning_rebalance(struct ma_state *mas,
 static noinline void mas_wr_spanning_rebalance(struct ma_state *mas,
                struct ma_wr_state *l_wr_mas, struct ma_wr_state *r_wr_mas)
 {
+
+       unsigned char split, mid_split;
+       unsigned char slot = 0;
+       unsigned char new_height = 0; /* used if node is a new root */
+       struct maple_enode *left = NULL, *middle = NULL, *right = NULL;
+       struct maple_enode *old_enode;
+
        struct maple_subtree_state mast;
        struct maple_big_node b_node;
        struct maple_copy cp;
@@ -2917,7 +2924,106 @@ static noinline void mas_wr_spanning_rebalance(struct ma_state *mas,
                mast_spanning_rebalance(&mast);
 
        height = mas_mt_height(mas) + 1;
-       mas_spanning_rebalance_loop(mas, &mast, height);
+
+       /*
+        * Each level of the tree is examined and balanced, pushing data to the left or
+        * right, or rebalancing against left or right nodes is employed to avoid
+        * rippling up the tree to limit the amount of churn.  Once a new sub-section of
+        * the tree is created, there may be a mix of new and old nodes.  The old nodes
+        * will have the incorrect parent pointers and currently be in two trees: the
+        * original tree and the partially new tree.  To remedy the parent pointers in
+        * the old tree, the new data is swapped into the active tree and a walk down
+        * the tree is performed and the parent pointers are updated.
+        * See mas_topiary_replace() for more information.
+        */
+       while (height--) {
+               mast.bn->b_end--;
+               mast.bn->type = mte_node_type(mast.orig_l->node);
+               split = mas_mab_to_node(mas, mast.bn, &left, &right, &middle,
+                                       &mid_split);
+               mast_set_split_parents(&mast, left, middle, right, split,
+                                      mid_split);
+               mast_cp_to_nodes(&mast, left, middle, right, split, mid_split);
+               new_height++;
+
+               /*
+                * Copy data from next level in the tree to mast.bn from next
+                * iteration
+                */
+               memset(mast.bn, 0, sizeof(struct maple_big_node));
+               mast.bn->type = mte_node_type(left);
+
+               /* Root already stored in l->node. */
+               if (mas_is_root_limits(mast.l))
+                       goto new_root;
+
+               mast_ascend(&mast);
+               mast_combine_cp_left(&mast);
+               mast.l->offset = mast.bn->b_end;
+               mab_set_b_end(mast.bn, mast.l, left);
+               mab_set_b_end(mast.bn, mast.m, middle);
+               mab_set_b_end(mast.bn, mast.r, right);
+
+               /* Copy anything necessary out of the right node. */
+               mast_combine_cp_right(&mast);
+               mast.orig_l->last = mast.orig_l->max;
+
+               if (mast_sufficient(&mast)) {
+                       if (mast_overflow(&mast))
+                               continue;
+
+                       if (mast.orig_l->node == mast.orig_r->node) {
+                              /*
+                               * The data in b_node should be stored in one
+                               * node and in the tree
+                               */
+                               slot = mast.l->offset;
+                               break;
+                       }
+
+                       continue;
+               }
+
+               /* May be a new root stored in mast.bn */
+               if (mas_is_root_limits(mast.orig_l))
+                       break;
+
+               mast_spanning_rebalance(&mast);
+
+               /* rebalancing from other nodes may require another loop. */
+               if (!height)
+                       height++;
+       }
+
+       mast.l->node = mt_mk_node(ma_mnode_ptr(mas_pop_node(mas)),
+                               mte_node_type(mast.orig_l->node));
+
+       mab_mas_cp(mast.bn, 0, mt_slots[mast.bn->type] - 1, mast.l, true);
+       new_height++;
+       mas_set_parent(mas, left, mast.l->node, slot);
+       if (middle)
+               mas_set_parent(mas, middle, mast.l->node, ++slot);
+
+       if (right)
+               mas_set_parent(mas, right, mast.l->node, ++slot);
+
+       if (mas_is_root_limits(mast.l)) {
+new_root:
+               mas_mn(mast.l)->parent = ma_parent_ptr(mas_tree_parent(mas));
+               while (!mte_is_root(mast.orig_l->node))
+                       mast_ascend(&mast);
+       } else {
+               mas_mn(mast.l)->parent = mas_mn(mast.orig_l)->parent;
+       }
+
+       old_enode = mast.orig_l->node;
+       mas->depth = mast.l->depth;
+       mas->node = mast.l->node;
+       mas->min = mast.l->min;
+       mas->max = mast.l->max;
+       mas->offset = mast.l->offset;
+       mas_wmb_replace(mas, old_enode, new_height);
+       mtree_range_walk(mas);
 }
 /*
  * mas_rebalance() - Rebalance a given node.