From df77220b0ab1e67be02940a630cbf2688b0de299 Mon Sep 17 00:00:00 2001 From: "Liam R. Howlett" Date: Fri, 4 Sep 2020 15:33:46 -0400 Subject: [PATCH] maple_tree: Rename functions and variables Signed-off-by: Liam R. Howlett --- lib/maple_tree.c | 150 ++++++++++++++++++++++++----------------------- 1 file changed, 76 insertions(+), 74 deletions(-) diff --git a/lib/maple_tree.c b/lib/maple_tree.c index a010d1f8fc29..b2e85da24db8 100644 --- a/lib/maple_tree.c +++ b/lib/maple_tree.c @@ -472,32 +472,32 @@ static inline void mas_set_offset(struct ma_state *mas, int slot) } static inline unsigned long ma_get_pivot(const struct maple_node *mn, - unsigned char slot, enum maple_type type) + unsigned char piv, enum maple_type type) { switch (type) { case maple_arange_64: - return mn->ma64.pivot[slot]; + return mn->ma64.pivot[piv]; case maple_range_64: case maple_leaf_64: - return mn->mr64.pivot[slot]; + return mn->mr64.pivot[piv]; case maple_sparse_6: return mn->ms6.pivot; case maple_sparse_9: - return mn->ms9.pivot[slot]; + return mn->ms9.pivot[piv]; case maple_sparse_16: - return mn->ms16.pivot[slot]; + return mn->ms16.pivot[piv]; case maple_sparse_21: - return mn->ms21.pivot[slot]; + return mn->ms21.pivot[piv]; case maple_sparse_32: - return mn->ms32.pivot[slot]; + return mn->ms32.pivot[piv]; case maple_sparse_64: - return mn->ms64.pivot[slot]; + return mn->ms64.pivot[piv]; case maple_range_16: case maple_leaf_16: - return mn->mr16.pivot[slot]; + return mn->mr16.pivot[piv]; case maple_range_32: case maple_leaf_32: - return mn->mr32.pivot[slot]; + return mn->mr32.pivot[piv]; case maple_dense: default: return 0; @@ -505,96 +505,98 @@ static inline unsigned long ma_get_pivot(const struct maple_node *mn, } static inline unsigned long _mte_get_pivot(const struct maple_enode *mn, - unsigned char slot, enum maple_type type) + unsigned char piv, enum maple_type type) { - return ma_get_pivot(mte_to_node(mn), slot, type); + return ma_get_pivot(mte_to_node(mn), piv, type); } static inline unsigned long mte_get_pivot(const struct maple_enode *mn, - unsigned char slot) + unsigned char piv) { - return _mte_get_pivot(mn, slot, mte_node_type(mn)); + return _mte_get_pivot(mn, piv, mte_node_type(mn)); } -static inline unsigned long _mas_get_safe_pivot(const struct ma_state *mas, - unsigned char slot, enum maple_type type) +static inline unsigned long _mas_safe_pivot(const struct ma_state *mas, + unsigned char piv, enum maple_type type) { - if (slot >= mt_pivots[type]) + if (piv >= mt_pivots[type]) return mas->max; - return _mte_get_pivot(mas->node, slot, type); + return _mte_get_pivot(mas->node, piv, type); } /* - * mas_get_safe_pivot() - Return the pivot or the mas->max. + * mas_safe_pivot() - Return the pivot or the mas->max. + * @mas: The maple state. + * @piv: the pivot location. * - * Return: The pivot (including mas->max for the final slot) + * Return: The pivot (including mas->max for the final piv) */ -static inline unsigned long mas_get_safe_pivot(const struct ma_state *mas, - unsigned char slot) +static inline unsigned long mas_safe_pivot(const struct ma_state *mas, + unsigned char piv) { enum maple_type type = mte_node_type(mas->node); - return _mas_get_safe_pivot(mas, slot, type); + return _mas_safe_pivot(mas, piv, type); } -static inline unsigned long mas_get_safe_lower_bound(struct ma_state *mas, - unsigned char slot) +static inline unsigned long mas_safe_min(struct ma_state *mas, + unsigned char piv) { - if (!slot) + if (!piv) return mas->min; - return mas_get_safe_pivot(mas, slot - 1) + 1; + return mas_safe_pivot(mas, piv - 1) + 1; } -static inline void ma_set_pivot(struct maple_node *mn, unsigned char slot, +static inline void ma_set_pivot(struct maple_node *mn, unsigned char piv, enum maple_type type, unsigned long val) { - BUG_ON(slot >= mt_pivots[type]); + BUG_ON(piv >= mt_pivots[type]); switch (type) { default: case maple_range_64: case maple_leaf_64: - (&mn->mr64)->pivot[slot] = val; + (&mn->mr64)->pivot[piv] = val; break; case maple_arange_64: - (&mn->ma64)->pivot[slot] = val; + (&mn->ma64)->pivot[piv] = val; case maple_dense: break; case maple_sparse_6: (&mn->ms6)->pivot = val; break; case maple_sparse_9: - (&mn->ms9)->pivot[slot] = val; + (&mn->ms9)->pivot[piv] = val; break; case maple_sparse_16: - (&mn->ms16)->pivot[slot] = val; + (&mn->ms16)->pivot[piv] = val; break; case maple_sparse_21: - (&mn->ms21)->pivot[slot] = val; + (&mn->ms21)->pivot[piv] = val; break; case maple_sparse_32: - (&mn->ms32)->pivot[slot] = val; + (&mn->ms32)->pivot[piv] = val; break; case maple_sparse_64: - (&mn->ms64)->pivot[slot] = val; + (&mn->ms64)->pivot[piv] = val; break; case maple_range_16: case maple_leaf_16: - (&mn->mr16)->pivot[slot] = val; + (&mn->mr16)->pivot[piv] = val; break; case maple_range_32: case maple_leaf_32: - (&mn->mr32)->pivot[slot] = val; + (&mn->mr32)->pivot[piv] = val; break; } } -static inline void mte_set_pivot(struct maple_enode *mn, unsigned char slot, +static inline void mte_set_pivot(struct maple_enode *mn, unsigned char piv, unsigned long val) { - return ma_set_pivot(mte_to_node(mn), slot, mte_node_type(mn), val); + return ma_set_pivot(mte_to_node(mn), piv, mte_node_type(mn), val); } static inline void __rcu **ma_get_slots(struct maple_node *mn, @@ -828,8 +830,8 @@ static inline void mas_descend(struct ma_state *mas) unsigned char slot = mas_offset(mas); if (slot) - mas->min = mas_get_safe_pivot(mas, slot - 1) + 1; - mas->max = mas_get_safe_pivot(mas, slot); + mas->min = mas_safe_pivot(mas, slot - 1) + 1; + mas->max = mas_safe_pivot(mas, slot); mas->node = mas_get_rcu_slot(mas, mas_offset(mas)); } @@ -1132,7 +1134,7 @@ static inline unsigned char mas_data_end(const struct ma_state *mas) unsigned long piv = mas->min; while (slot < mt_slots[type]) { - piv = _mas_get_safe_pivot(mas, slot, type); + piv = _mas_safe_pivot(mas, slot, type); if (piv >= mas->max) break; slot++; @@ -1173,7 +1175,7 @@ static inline unsigned long mas_leaf_max_gap(struct ma_state *mas) pstart = mas->min; for (i = 0; i < mt_slots[mt]; i++) { - pend = mas_get_safe_pivot(mas, i); + pend = mas_safe_pivot(mas, i); if (!pend && i) pend = mas->max; @@ -1298,7 +1300,7 @@ static inline unsigned long mas_first_node(struct ma_state *mas, while (++slot < count) { struct maple_enode *mn; - pivot = mas_get_safe_pivot(mas, slot); + pivot = mas_safe_pivot(mas, slot); if (pivot > limit) goto no_entry; @@ -1346,7 +1348,7 @@ static inline unsigned long mas_first_entry(struct ma_state *mas, mas_first_node(mas, limit); if (mas_is_none(mas)) return limit; - return mas_get_safe_pivot(mas, + return mas_safe_pivot(mas, mas_offset(mas)); } @@ -1576,7 +1578,7 @@ static inline void mas_mab_cp(struct ma_state *mas, unsigned char mas_start, b_node->gap[j] = mte_get_gap(mas->node, i); if (i < mt_pivot_count(mas->node)) - b_node->pivot[j] = mas_get_safe_pivot(mas, i); + b_node->pivot[j] = mas_safe_pivot(mas, i); else b_node->pivot[j] = mas->max; @@ -1704,7 +1706,7 @@ static inline unsigned char mas_store_b_node(struct ma_state *mas, b_node->pivot[b_end] = mas->last; // Handle range overlap end. - piv = mas_get_safe_pivot(mas, slot); + piv = mas_safe_pivot(mas, slot); if (piv > mas->last) { b_node->slot[++b_end] = contents; if (!contents) @@ -1719,7 +1721,7 @@ static inline unsigned char mas_store_b_node(struct ma_state *mas, // Handle range overwrites do { - piv = mas_get_safe_pivot(mas, ++slot); + piv = mas_safe_pivot(mas, ++slot); } while ((piv <= mas->last) && (slot <= end)); // Copy end data to the end of the node. @@ -2856,7 +2858,7 @@ static inline bool mas_node_walk(struct ma_state *mas, enum maple_type type, switch (type) { default: for (i = mas_offset(mas); i < mt_slots[type]; i++) { - pivot = _mas_get_safe_pivot(mas, i, type); + pivot = _mas_safe_pivot(mas, i, type); if (!pivot && i) { if (mas->max < mas->index) { @@ -2966,11 +2968,11 @@ static inline unsigned char mas_extend_null(struct ma_state *l_mas, unsigned char r_slot = mas_offset(r_mas); unsigned char cp_r_slot = r_slot; void *content = mas_get_rcu_slot(l_mas, l_slot); - unsigned long range_max = mas_get_safe_pivot(r_mas, r_slot); + unsigned long range_max = mas_safe_pivot(r_mas, r_slot); unsigned long range_min = l_mas->min; if (l_slot) - range_min = mas_get_safe_pivot(l_mas, l_slot - 1) + 1; + range_min = mas_safe_pivot(l_mas, l_slot - 1) + 1; if (!content) l_mas->index = range_min; @@ -2978,7 +2980,7 @@ static inline unsigned char mas_extend_null(struct ma_state *l_mas, if ((l_mas->index == range_min) && l_slot && !mas_get_rcu_slot(l_mas, l_slot - 1)) { if (l_slot > 1) - l_mas->index = mas_get_safe_pivot(l_mas, l_slot - 2) + 1; + l_mas->index = mas_safe_pivot(l_mas, l_slot - 2) + 1; else l_mas->index = l_mas->min; mas_set_offset(l_mas, l_slot - 1); @@ -2992,7 +2994,7 @@ static inline unsigned char mas_extend_null(struct ma_state *l_mas, if (r_mas->last == range_max && r_mas->last < r_mas->max && !mas_get_rcu_slot(r_mas, r_slot + 1)) { - r_mas->last = mas_get_safe_pivot(r_mas, r_slot + 1); + r_mas->last = mas_safe_pivot(r_mas, r_slot + 1); cp_r_slot++; } @@ -3250,7 +3252,7 @@ static inline void mas_prev_node(struct ma_state *mas, unsigned long limit) struct maple_enode *mn; int level; - start_piv = mas_get_safe_pivot(mas, slot); + start_piv = mas_safe_pivot(mas, slot); restart_prev_node: level = 0; if (mte_is_root(mas->node) || mas->node == MAS_NONE) @@ -3270,9 +3272,9 @@ restart_prev_node: slot--; do { - pivot = mas_get_safe_pivot(mas, slot); + pivot = mas_safe_pivot(mas, slot); - min = mas_get_safe_lower_bound(mas, slot); + min = mas_safe_min(mas, slot); if (pivot < limit) goto no_entry; @@ -3335,7 +3337,7 @@ restart_next_node: mn = mas->node; slot = mas_offset(mas); - start_piv = mas_get_safe_pivot(mas, slot); + start_piv = mas_safe_pivot(mas, slot); level++; mas_ascend(mas); @@ -3343,9 +3345,9 @@ restart_next_node: goto restart_next_node; count = mt_slot_count(mas->node); - prev_piv = mas_get_safe_pivot(mas, slot); + prev_piv = mas_safe_pivot(mas, slot); while (++slot < count) { - unsigned long pivot = mas_get_safe_pivot(mas, slot); + unsigned long pivot = mas_safe_pivot(mas, slot); if (prev_piv > max) goto no_entry; @@ -3403,7 +3405,7 @@ static inline bool mas_prev_nentry(struct ma_state *mas, unsigned long limit, slot--; do { - pivot = mas_get_safe_pivot(mas, slot); + pivot = mas_safe_pivot(mas, slot); if (pivot < limit) return false; @@ -3433,10 +3435,10 @@ static inline bool mas_next_nentry(struct ma_state *mas, unsigned long max, unsigned char count = mt_slot_count(mas->node); void *entry; - r_start = mas_get_safe_lower_bound(mas, slot); + r_start = mas_safe_min(mas, slot); while (slot < count) { - pivot = mas_get_safe_pivot(mas, slot); + pivot = mas_safe_pivot(mas, slot); if (pivot > mas->max) // possibly a retry. goto no_entry; @@ -3603,7 +3605,7 @@ static inline void *_mas_prev(struct ma_state *mas, unsigned long limit) mas->last = max; slot = mas_offset(mas); - mas->index = mas_get_safe_lower_bound(mas, slot); + mas->index = mas_safe_min(mas, slot); return mas_get_rcu_slot(mas, mas_offset(mas)); } @@ -3648,12 +3650,12 @@ static inline bool _mas_rev_awalk(struct ma_state *mas, unsigned long size) unsigned long gap = 0; bool found = false; - max = _mas_get_safe_pivot(mas, slot, type); + max = _mas_safe_pivot(mas, slot, type); switch (type) { case maple_leaf_64: default: do { - min = mas_get_safe_lower_bound(mas, slot); + min = mas_safe_min(mas, slot); /* last is below this range */ if (mas->last < min) goto next_slot; @@ -3711,7 +3713,7 @@ next_slot: mas->node = next; slot = mas_data_end(mas); - max = mas_get_safe_pivot(mas, slot); + max = mas_safe_pivot(mas, slot); } mas_set_offset(mas, slot); @@ -3736,9 +3738,9 @@ static inline bool _mas_awalk(struct ma_state *mas, unsigned long size) slot = mas_offset(mas); fallthrough; case maple_leaf_64: - min = mas_get_safe_lower_bound(mas, slot); + min = mas_safe_min(mas, slot); for (; slot <= pivot_cnt; slot++) { - pivot = _mas_get_safe_pivot(mas, slot, type); + pivot = _mas_safe_pivot(mas, slot, type); if (slot && !pivot) break; @@ -3994,8 +3996,8 @@ static int mas_fill_gap(struct ma_state *mas, void *entry, unsigned char slot, * calculation, so fix the ma_state here */ mas_ascend(mas); - mas->max = mas_get_safe_pivot(mas, pslot); - mas->min = mas_get_safe_lower_bound(mas, pslot); + mas->max = mas_safe_pivot(mas, pslot); + mas->min = mas_safe_min(mas, pslot); mas->node = mn; mas_set_offset(mas, slot); _mas_store(mas, entry, false); @@ -4012,7 +4014,7 @@ void mas_set_fwd_index(struct ma_state *mas, unsigned long size) min = mte_get_pivot(mas->node, slot - 1) + 1; mas->min = min; - mas->max = mas_get_safe_pivot(mas, slot); + mas->max = mas_safe_pivot(mas, slot); if (mas->index < min) mas->index = min; @@ -5070,7 +5072,7 @@ void mas_validate_gaps(struct ma_state *mas) } for (i = 0; i < mt_slot_count(mte); i++) { - p_end = mas_get_safe_pivot(mas, i); + p_end = mas_safe_pivot(mas, i); if (!p_end && i) p_end = mas->max; @@ -5206,7 +5208,7 @@ void mas_validate_limits(struct ma_state *mas) return; // all limits are fine here. for (i = 0; i < mt_slot_count(mas->node); i++) { - unsigned long piv = mas_get_safe_pivot(mas, i); + unsigned long piv = mas_safe_pivot(mas, i); if (!piv) break; -- 2.50.1