finished conversion
authorLiam R. Howlett <Liam.Howlett@oracle.com>
Thu, 10 Apr 2025 18:34:08 +0000 (14:34 -0400)
committerLiam R. Howlett <Liam.Howlett@oracle.com>
Thu, 10 Apr 2025 18:34:08 +0000 (14:34 -0400)
Signed-off-by: Liam R. Howlett <Liam.Howlett@oracle.com>
lib/maple_tree.c

index d917744dc36a58c083e5562deca82963020e1642..4b2cbb155d54b0cf9a9b19d7d68232e495b8f2f3 100644 (file)
@@ -3798,9 +3798,8 @@ struct split_data {
        unsigned char insert;   /* Insert location of destination */
        unsigned char new_end;  /* Total data  */
        unsigned char src_ins_end;
-       struct ma_node_state *state;
+       unsigned char len;
        struct ma_node_state states[5];
-       int len;
 };
 
 static inline void mas_wr_converged(struct ma_node_info *src,
@@ -3854,17 +3853,15 @@ static inline void mas_wr_converged(struct ma_node_info *src,
  * @state: The maple node state array
  * @i: The number of existing states
  */
-static int mt_wr_split_data(struct ma_node_info *src,
+static void mt_wr_split_data(struct ma_node_info *src,
                struct ma_node_info *left, struct ma_node_info *right,
-               struct ma_node_part *ma_part,
-               struct ma_node_state *state, int i,
-               struct split_data *sd)
+               struct ma_node_part *ma_part, struct split_data *sd)
 {
        unsigned char insert_end;
        unsigned char node_off, part_off;
        struct ma_node_info *to;
+       struct ma_node_state *state;
 
-       i = sd->len;
 
        /* Offset into the destination data where the insert ends */
        insert_end = sd->insert + ma_part->size - 1;
@@ -3874,15 +3871,16 @@ static int mt_wr_split_data(struct ma_node_info *src,
        do {
                unsigned char copied = 0;
 
+               state = &sd->states[sd->len];
                if (sd->offset >= sd->insert && sd->offset <= insert_end) {
                        copied = min(ma_part->size - part_off, sd->space);
-                       state[i].part = ma_part;
-                       mns_mni_init(&state[i], to, part_off, copied);
-                       state[i].use_part = true;
+                       state->part = ma_part;
+                       mns_mni_init(state, to, part_off, copied);
+                       state->use_part = true;
                        part_off += copied;
                        node_off = sd->src_ins_end + 1;
                } else {
-                       state[i].info = src;
+                       state->info = src;
                        if (sd->offset < insert_end) {
                                /*
                                 * First part of node, may split across node
@@ -3893,7 +3891,7 @@ static int mt_wr_split_data(struct ma_node_info *src,
                                copied = min(sd->space, (src->end - node_off + 1));
                        }
                        BUG_ON(copied == 0);
-                       mns_mni_init(&state[i], to, node_off, copied);
+                       mns_mni_init(state, to, node_off, copied);
                        node_off += copied;
                }
 
@@ -3901,10 +3899,10 @@ static int mt_wr_split_data(struct ma_node_info *src,
                sd->space -= copied;
                if ((to == left) && (sd->offset >= sd->split)) {
                        if (ma_is_leaf(src->type) &&
-                           mns_ends_in_null(&state[i])) {
-                               if (!state[i].use_part && sd->offset != sd->insert) {
+                           mns_ends_in_null(state)) {
+                               if (!state->use_part && sd->offset != sd->insert) {
                                        /* Setting up a copy from a normal node */
-                                       state[i].size++;
+                                       state->size++;
                                        sd->split++;
                                        sd->offset++;
                                        sd->space--;
@@ -3913,25 +3911,23 @@ static int mt_wr_split_data(struct ma_node_info *src,
                                        sd->split--;
                                        sd->offset--;
                                        sd->space++;
-                                       if (state[i].use_part) {
+                                       if (state->use_part) {
                                                part_off--;
                                        } else {
                                                node_off--;
                                        }
-                                       if (state[i].size == 1)
-                                               i--;
+                                       if (state->size == 1)
+                                               sd->len--;
                                        else
-                                               state[i].size--;
+                                               state->size--;
                                }
                        }
                        sd->space = mt_slots[right->type];
                        to = right;
                        sd->split = 255;
                }
-               i++;
+               sd->len++;
        } while (node_off <= src->end);
-       sd->len = i;
-       return i;
 }
 
 /*
@@ -4026,8 +4022,7 @@ try_right:
         * There can also be a split between nodes that may happen at these
         * boundaries, or elsewhere.
         */
-       mt_wr_split_data(src, left, right, ma_part,
-                            sd->states, sd->len, sd);
+       mt_wr_split_data(src, left, right, ma_part, sd);
        if (left_store) {
                sd->states[sd->len].info = &src2;
                mns_mni_init(&sd->states[sd->len], right, 0, src2.end + 1);
@@ -4227,8 +4222,6 @@ static void mas_wr_rebalance(struct ma_wr_state *wr_mas)
 static void mas_wr_split(struct ma_wr_state *wr_mas)
 {
        struct ma_state *mas = wr_mas->mas;
-       struct ma_node_state state[4];
-       unsigned char i = 0;
        struct ma_node_info src, parent, left, right;
        struct ma_node_part part;
        struct split_data sd;
@@ -4264,11 +4257,9 @@ static void mas_wr_split(struct ma_wr_state *wr_mas)
        sd.insert = mas->offset;
        sd.space = sd.split;
        sd.offset = 0;
-       sd.state = state;
 
-       i = mt_wr_split_data(&src, &left, &right, &part,
-                            state, 0, &sd);
-       mns_assemble(state, i);
+       mt_wr_split_data(&src, &left, &right, &part, &sd);
+       mns_assemble(sd.states, sd.len);
        mni_finalise(&left);
        mni_finalise(&right);
 
@@ -4299,9 +4290,8 @@ static void mas_wr_split(struct ma_wr_state *wr_mas)
                sd.space = sd.split;
                sd.offset = 0;
 
-               i = mt_wr_split_data(&src, &left, &right, &part,
-                                    state, 0, &sd);
-               mns_assemble(state, i);
+               mt_wr_split_data(&src, &left, &right, &part, &sd);
+               mns_assemble(sd.states, sd.len);
                mni_finalise(&left);
                mni_finalise(&right);
        }