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,
* @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;
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
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;
}
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--;
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;
}
/*
* 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);
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;
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);
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);
}