sbitmap: rewrite sbitmap_find_bit_in_index to reduce repeat code

Rewrite sbitmap_find_bit_in_index as following:
1. Rename sbitmap_find_bit_in_index to sbitmap_find_bit_in_word
2. Accept "struct sbitmap_word *" directly instead of accepting
"struct sbitmap *" and "int index" to get "struct sbitmap_word *".
3. Accept depth/shallow_depth and wrap for __sbitmap_get_word from caller
to support need of both __sbitmap_get_shallow and __sbitmap_get.

With helper function sbitmap_find_bit_in_word, we can remove repeat
code in __sbitmap_get_shallow to find bit considring deferred clear.

Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: Kemeng Shi <shikemeng@huaweicloud.com>
Link: https://lore.kernel.org/r/20230116205059.3821738-4-shikemeng@huaweicloud.com
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/lib/sbitmap.c b/lib/sbitmap.c
index eb45a2d..27cfcc3 100644 (file)
--- a/lib/sbitmap.c
+++ b/lib/sbitmap.c
@@ -167,15 +167,16 @@ static int __sbitmap_get_word(unsigned long *word, unsigned long depth,
        return nr;
 }
 
-static int sbitmap_find_bit_in_index(struct sbitmap *sb, int index,
-                                    unsigned int alloc_hint)
+static int sbitmap_find_bit_in_word(struct sbitmap_word *map,
+                                   unsigned int depth,
+                                   unsigned int alloc_hint,
+                                   bool wrap)
 {
-       struct sbitmap_word *map = &sb->map[index];
        int nr;
 
        do {
-               nr = __sbitmap_get_word(&map->word, __map_depth(sb, index),
-                                       alloc_hint, !sb->round_robin);
+               nr = __sbitmap_get_word(&map->word, depth,
+                                       alloc_hint, wrap);
                if (nr != -1)
                        break;
                if (!sbitmap_deferred_clear(map))
@@ -203,7 +204,9 @@ static int __sbitmap_get(struct sbitmap *sb, unsigned int alloc_hint)
                alloc_hint = 0;
 
        for (i = 0; i < sb->map_nr; i++) {
-               nr = sbitmap_find_bit_in_index(sb, index, alloc_hint);
+               nr = sbitmap_find_bit_in_word(&sb->map[index],
+                                             __map_depth(sb, index),
+                                             alloc_hint, !sb->round_robin);
                if (nr != -1) {
                        nr += index << sb->shift;
                        break;
@@ -246,20 +249,17 @@ static int __sbitmap_get_shallow(struct sbitmap *sb,
        alloc_hint = SB_NR_TO_BIT(sb, alloc_hint);
 
        for (i = 0; i < sb->map_nr; i++) {
-again:
-               nr = __sbitmap_get_word(&sb->map[index].word,
-                                       min_t(unsigned int,
-                                             __map_depth(sb, index),
-                                             shallow_depth),
-                                       alloc_hint, true);
+               nr = sbitmap_find_bit_in_word(&sb->map[index],
+                                             min_t(unsigned int,
+                                                   __map_depth(sb, index),
+                                                   shallow_depth),
+                                             alloc_hint, true);
+
                if (nr != -1) {
                        nr += index << sb->shift;
                        break;
                }
 
-               if (sbitmap_deferred_clear(&sb->map[index]))
-                       goto again;
-
                /* Jump to next index. */
                alloc_hint = 0;
                if (++index >= sb->map_nr)