compiles, ship it.

The copy and pasting of code does not work out without an overall plan

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

diff --git a/lib/maple_tree.c b/lib/maple_tree.c
index 9a4307923f5ac8a2c6ecffb4b36fdbc9d26e3854..e70e863b4c27cb1e08a52f9fd28343f3ce4489e5 100644 (file)
--- a/lib/maple_tree.c
+++ b/lib/maple_tree.c
@@ -4057,7 +4057,10 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
 {
        struct ma_state *mas;
        struct ma_state tmp_mas;
-       struct ma_node_info src2, parent, new_parent;
+       struct ma_node_info parent, new_parent;
+       struct ma_node_info src, src2, left, right;
+       struct split_data sd;
+       struct ma_node_part part;
        unsigned char max, height;
        bool left_store = false;
 
@@ -4078,11 +4081,11 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
        tmp_mas = *mas;
        while (height--) {
                mas_wr_ascend_init(&tmp_mas, &parent);
-               max = mt_slots[src->type] - 1;
-               if (ma_is_leaf(src->type))
+               max = mt_slots[src.type] - 1;
+               if (ma_is_leaf(src.type))
                        max--;
 
-               src->end = mas->end;
+               src.end = mas->end;
                if (parent.insert_off != mas->end) {
                        /* Right sibling exists, rebalance against right */
                        tmp_mas.offset = parent.insert_off + 1;
@@ -4090,7 +4093,7 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
                        mni_mas_init(&src2, &tmp_mas);
                        mni_set_end(&src2);
                        left_store = true;
-                       sd->insert = mas->offset;
+                       sd.insert = mas->offset;
                } else {
                        /* Rebalance against left sibling */
                        tmp_mas.offset--;
@@ -4098,15 +4101,15 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
                        mni_mas_init(&src2, &tmp_mas);
                        mni_node_init(&right, mas_pop_node(mas), wr_mas->type);
                        parent.insert_off--;
-                       sd->insert = mas->offset + src2.end + 1;
+                       sd.insert = mas->offset + src2.end + 1;
                }
 
-               sd->new_end += src2.end + 1;
+               sd.new_end += src2.end + 1;
                mni_node_init(&left, mas_pop_node(mas), wr_mas->type);
-               if (sd->new_end > 2 * mt_min_slots[src.type]) {
+               if (sd.new_end > 2 * mt_min_slots[src.type]) {
                        printk("Rebalance\n");
                        mni_node_init(&right, mas_pop_node(mas), wr_mas->type);
-                       sd->split = mas_wr_rebalance_calc(sd->new_end,
+                       sd.split = mas_wr_rebalance_calc(sd.new_end,
                                                          src2.type);
                        /*
                         * Rebalance between nodes is possible, so the
@@ -4116,17 +4119,17 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
                        /* Taken from mas_wr_try_rebalance */
                        if (left_store)  {
                                /* Left pushes data right. */
-                               sd->insert = mas->offset;
-                               sd->space = sd->split;
-                               sd->offset = 0;
+                               sd.insert = mas->offset;
+                               sd.space = sd.split;
+                               sd.offset = 0;
                        } else {
                                /* Right pushes data left */
-                               sd->insert = mas->offset + src2.end + 1;
-                               sd->offset = src2.end + 1;
-                               sd->space = sd->split - src2.end;
-                               sd->states[sd->len].info = &src2;
-                               mns_mni_init(&sd->states[sd->len], left, 0, src2.end + 1);
-                               sd->len++;
+                               sd.insert = mas->offset + src2.end + 1;
+                               sd.offset = src2.end + 1;
+                               sd.space = sd.split - src2.end;
+                               sd.states[sd.len].info = &src2;
+                               mns_mni_init(&sd.states[sd.len], &left, 0, src2.end + 1);
+                               sd.len++;
                        }
 
                        /*
@@ -4134,23 +4137,23 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
                         * There can also be a split between nodes that may happen at these
                         * boundaries, or elsewhere.
                         */
-                       mt_wr_split_data(src, left, right, part, sd);
+                       mt_wr_split_data(&src, &left, &right, &part, &sd);
                        if (left_store) {
-                               sd->states[sd->len].info = &src2;
-                               mns_mni_init(&sd->states[sd->len], right, 0, src2.end + 1);
-                               sd->len++;
+                               sd.states[sd.len].info = &src2;
+                               mns_mni_init(&sd.states[sd.len], &right, 0, src2.end + 1);
+                               sd.len++;
                        }
 
-                       mns_assemble(sd->states, sd->len);
-                       mni_finalise(left);
-                       mni_finalise(right);
-                       mni_node_part_init(part, left, right);
-                       part->skip = 2;
+                       mns_assemble(sd.states, sd.len);
+                       mni_finalise(&left);
+                       mni_finalise(&right);
+                       mni_node_part_init(&part, &left, &right);
+                       part.skip = 2;
                        mas_ascend(mas);
                        mas->end = parent.end;
                        mas->offset = parent.insert_off;
-                       mas_wr_converged(&parent, &new_parent, part, mas, sd);
-                       src->enode = parent.enode;
+                       mas_wr_converged(&parent, &new_parent, &part, mas, &sd);
+                       src.enode = parent.enode;
                        mas->node = new_parent.enode;
                        /* FIXME: make another function */
                        /* We can stop rebalancing here */
@@ -4160,28 +4163,28 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
                         * Absorb all the data from two nodes, which may need
                         * more rebalancing
                         */
-                       sd->split = sd->new_end + 2; /* No split */
+                       sd.split = sd.new_end + 2; /* No split */
 
                        if (!left_store) {
-                               sd->states[sd->len].info = &src2;
-                               mns_mni_init(&sd->states[sd->len], left, 0, src2.end + 1);
-                               sd->len++;
+                               sd.states[sd.len].info = &src2;
+                               mns_mni_init(&sd.states[sd.len], &left, 0, src2.end + 1);
+                               sd.len++;
                        }
-                       mt_wr_split_data(src, left, NULL, part, sd);
+                       mt_wr_split_data(&src, &left, NULL, &part, &sd);
 
                        if (left_store) {
-                               sd->states[sd->len].info = &src2;
-                               mns_mni_init(&sd->states[sd->len], left, 0, src2.end + 1);
-                               sd->len++;
+                               sd.states[sd.len].info = &src2;
+                               mns_mni_init(&sd.states[sd.len], &left, 0, src2.end + 1);
+                               sd.len++;
                        }
 
-                       mns_assemble(sd->states, sd->len);
-                       mni_finalise(left);
+                       mns_assemble(sd.states, sd.len);
+                       mni_finalise(&left);
                        if (ma_is_root(parent.node) && parent.end == 1) {
                                /* New root */
                        }
                        if (parent.end > mt_min_slots[parent.type]) {
-                               mni_node_part_init(part, left, NULL);
+                               mni_node_part_init(&part, &left, NULL);
                                break;
                        }
                }
@@ -4190,8 +4193,8 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
        mas_ascend(mas);
        mas->end = parent.end - 1;
        mas->offset = parent.insert_off;
-       mas_wr_converged(&parent, &new_parent, part, mas, sd);
-       src->enode = parent.enode;
+       mas_wr_converged(&parent, &new_parent, &part, mas, &sd);
+       src.enode = parent.enode;
        mas->node = new_parent.enode;
 replace_node:
        mas_wmb_replace(mas, src.enode);
@@ -5157,8 +5160,8 @@ static inline void mas_wr_store_entry(struct ma_wr_state *wr_mas)
                mas_wr_split(wr_mas);
                break;
        case wr_rebalance:
-               mas_wr_bnode(wr_mas);
-               //mas_wr_rebalance(wr_mas);
+               //mas_wr_bnode(wr_mas);
+               mas_wr_rebalance(wr_mas);
                break;
        case wr_exact_fit:
                rcu_assign_pointer(wr_mas->slots[mas->offset], wr_mas->entry);