bitmap: unify find_bit operations

bitmap_for_each_{set,clear}_region() are similar to for_each_bit()
macros in include/linux/find.h, but interface and implementation
of them are different.

This patch adds for_each_bitrange() macros and drops unused
bitmap_*_region() API in sake of unification.

Signed-off-by: Yury Norov <yury.norov@gmail.com>
Tested-by: Wolfram Sang <wsa+renesas@sang-engineering.com>
Acked-by: Dennis Zhou <dennis@kernel.org>
Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # For MMC

diff --git a/drivers/mmc/host/renesas_sdhi_core.c b/drivers/mmc/host/renesas_sdhi_core.c
index f5b2684..6de30a2 100644 (file)
--- a/drivers/mmc/host/renesas_sdhi_core.c
+++ b/drivers/mmc/host/renesas_sdhi_core.c
@@ -628,7 +628,7 @@ static int renesas_sdhi_select_tuning(struct tmio_mmc_host *host)
         * is at least SH_MOBILE_SDHI_MIN_TAP_ROW probes long then use the
         * center index as the tap, otherwise bail out.
         */
-       bitmap_for_each_set_region(bitmap, rs, re, 0, taps_size) {
+       for_each_set_bitrange(rs, re, bitmap, taps_size) {
                if (re - rs > tap_cnt) {
                        tap_end = re;
                        tap_start = rs;

diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index ead4a15..7dba084 100644 (file)
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -55,12 +55,6 @@ struct device;
  *  bitmap_clear(dst, pos, nbits)               Clear specified bit area
  *  bitmap_find_next_zero_area(buf, len, pos, n, mask)  Find bit free area
  *  bitmap_find_next_zero_area_off(buf, len, pos, n, mask, mask_off)  as above
- *  bitmap_next_clear_region(map, &start, &end, nbits)  Find next clear region
- *  bitmap_next_set_region(map, &start, &end, nbits)  Find next set region
- *  bitmap_for_each_clear_region(map, rs, re, start, end)
- *                                             Iterate over all clear regions
- *  bitmap_for_each_set_region(map, rs, re, start, end)
- *                                             Iterate over all set regions
  *  bitmap_shift_right(dst, src, n, nbits)      *dst = *src >> n
  *  bitmap_shift_left(dst, src, n, nbits)       *dst = *src << n
  *  bitmap_cut(dst, src, first, n, nbits)       Cut n bits from first, copy rest
@@ -467,14 +461,6 @@ static inline void bitmap_replace(unsigned long *dst,
                __bitmap_replace(dst, old, new, mask, nbits);
 }
 
-static inline void bitmap_next_clear_region(unsigned long *bitmap,
-                                           unsigned int *rs, unsigned int *re,
-                                           unsigned int end)
-{
-       *rs = find_next_zero_bit(bitmap, end, *rs);
-       *re = find_next_bit(bitmap, end, *rs + 1);
-}
-
 static inline void bitmap_next_set_region(unsigned long *bitmap,
                                          unsigned int *rs, unsigned int *re,
                                          unsigned int end)
@@ -483,25 +469,6 @@ static inline void bitmap_next_set_region(unsigned long *bitmap,
        *re = find_next_zero_bit(bitmap, end, *rs + 1);
 }
 
-/*
- * Bitmap region iterators.  Iterates over the bitmap between [@start, @end).
- * @rs and @re should be integer variables and will be set to start and end
- * index of the current clear or set region.
- */
-#define bitmap_for_each_clear_region(bitmap, rs, re, start, end)            \
-       for ((rs) = (start),                                                 \
-            bitmap_next_clear_region((bitmap), &(rs), &(re), (end));        \
-            (rs) < (re);                                                    \
-            (rs) = (re) + 1,                                                \
-            bitmap_next_clear_region((bitmap), &(rs), &(re), (end)))
-
-#define bitmap_for_each_set_region(bitmap, rs, re, start, end)              \
-       for ((rs) = (start),                                                 \
-            bitmap_next_set_region((bitmap), &(rs), &(re), (end));          \
-            (rs) < (re);                                                    \
-            (rs) = (re) + 1,                                                \
-            bitmap_next_set_region((bitmap), &(rs), &(re), (end)))
-
 /**
  * BITMAP_FROM_U64() - Represent u64 value in the format suitable for bitmap.
  * @n: u64 value

diff --git a/include/linux/find.h b/include/linux/find.h
index ae9ed52..5bb6db2 100644 (file)
--- a/include/linux/find.h
+++ b/include/linux/find.h
@@ -302,6 +302,62 @@ unsigned long find_next_bit_le(const void *addr, unsigned
             (bit) = find_next_zero_bit((addr), (size), (bit) + 1))
 
 /**
+ * for_each_set_bitrange - iterate over all set bit ranges [b; e)
+ * @b: bit offset of start of current bitrange (first set bit)
+ * @e: bit offset of end of current bitrange (first unset bit)
+ * @addr: bitmap address to base the search on
+ * @size: bitmap size in number of bits
+ */
+#define for_each_set_bitrange(b, e, addr, size)                        \
+       for ((b) = find_next_bit((addr), (size), 0),            \
+            (e) = find_next_zero_bit((addr), (size), (b) + 1); \
+            (b) < (size);                                      \
+            (b) = find_next_bit((addr), (size), (e) + 1),      \
+            (e) = find_next_zero_bit((addr), (size), (b) + 1))
+
+/**
+ * for_each_set_bitrange_from - iterate over all set bit ranges [b; e)
+ * @b: bit offset of start of current bitrange (first set bit); must be initialized
+ * @e: bit offset of end of current bitrange (first unset bit)
+ * @addr: bitmap address to base the search on
+ * @size: bitmap size in number of bits
+ */
+#define for_each_set_bitrange_from(b, e, addr, size)           \
+       for ((b) = find_next_bit((addr), (size), (b)),          \
+            (e) = find_next_zero_bit((addr), (size), (b) + 1); \
+            (b) < (size);                                      \
+            (b) = find_next_bit((addr), (size), (e) + 1),      \
+            (e) = find_next_zero_bit((addr), (size), (b) + 1))
+
+/**
+ * for_each_clear_bitrange - iterate over all unset bit ranges [b; e)
+ * @b: bit offset of start of current bitrange (first unset bit)
+ * @e: bit offset of end of current bitrange (first set bit)
+ * @addr: bitmap address to base the search on
+ * @size: bitmap size in number of bits
+ */
+#define for_each_clear_bitrange(b, e, addr, size)              \
+       for ((b) = find_next_zero_bit((addr), (size), 0),       \
+            (e) = find_next_bit((addr), (size), (b) + 1);      \
+            (b) < (size);                                      \
+            (b) = find_next_zero_bit((addr), (size), (e) + 1), \
+            (e) = find_next_bit((addr), (size), (b) + 1))
+
+/**
+ * for_each_clear_bitrange_from - iterate over all unset bit ranges [b; e)
+ * @b: bit offset of start of current bitrange (first set bit); must be initialized
+ * @e: bit offset of end of current bitrange (first unset bit)
+ * @addr: bitmap address to base the search on
+ * @size: bitmap size in number of bits
+ */
+#define for_each_clear_bitrange_from(b, e, addr, size)         \
+       for ((b) = find_next_zero_bit((addr), (size), (b)),     \
+            (e) = find_next_bit((addr), (size), (b) + 1);      \
+            (b) < (size);                                      \
+            (b) = find_next_zero_bit((addr), (size), (e) + 1), \
+            (e) = find_next_bit((addr), (size), (b) + 1))
+
+/**
  * for_each_set_clump8 - iterate over bitmap for each 8-bit clump with set bits
  * @start: bit offset to start search and to store the current iteration offset
  * @clump: location to store copy of current 8-bit clump

diff --git a/mm/percpu.c b/mm/percpu.c
index 0c6f85c..293009c 100644 (file)
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -779,7 +779,7 @@ static void pcpu_block_refresh_hint(struct pcpu_chunk *chunk, int index)
 {
        struct pcpu_block_md *block = chunk->md_blocks + index;
        unsigned long *alloc_map = pcpu_index_alloc_map(chunk, index);
-       unsigned int rs, re, start;     /* region start, region end */
+       unsigned int start, end;        /* region start, region end */
 
        /* promote scan_hint to contig_hint */
        if (block->scan_hint) {
@@ -795,9 +795,8 @@ static void pcpu_block_refresh_hint(struct pcpu_chunk *chunk, int index)
        block->right_free = 0;
 
        /* iterate over free areas and update the contig hints */
-       bitmap_for_each_clear_region(alloc_map, rs, re, start,
-                                    PCPU_BITMAP_BLOCK_BITS)
-               pcpu_block_update(block, rs, re);
+       for_each_clear_bitrange_from(start, end, alloc_map, PCPU_BITMAP_BLOCK_BITS)
+               pcpu_block_update(block, start, end);
 }
 
 /**
@@ -1852,13 +1851,12 @@ area_found:
 
        /* populate if not all pages are already there */
        if (!is_atomic) {
-               unsigned int page_start, page_end, rs, re;
+               unsigned int page_end, rs, re;
 
-               page_start = PFN_DOWN(off);
+               rs = PFN_DOWN(off);
                page_end = PFN_UP(off + size);
 
-               bitmap_for_each_clear_region(chunk->populated, rs, re,
-                                            page_start, page_end) {
+               for_each_clear_bitrange_from(rs, re, chunk->populated, page_end) {
                        WARN_ON(chunk->immutable);
 
                        ret = pcpu_populate_chunk(chunk, rs, re, pcpu_gfp);
@@ -2014,8 +2012,7 @@ static void pcpu_balance_free(bool empty_only)
        list_for_each_entry_safe(chunk, next, &to_free, list) {
                unsigned int rs, re;
 
-               bitmap_for_each_set_region(chunk->populated, rs, re, 0,
-                                          chunk->nr_pages) {
+               for_each_set_bitrange(rs, re, chunk->populated, chunk->nr_pages) {
                        pcpu_depopulate_chunk(chunk, rs, re);
                        spin_lock_irq(&pcpu_lock);
                        pcpu_chunk_depopulated(chunk, rs, re);
@@ -2085,8 +2082,7 @@ retry_pop:
                        continue;
 
                /* @chunk can't go away while pcpu_alloc_mutex is held */
-               bitmap_for_each_clear_region(chunk->populated, rs, re, 0,
-                                            chunk->nr_pages) {
+               for_each_clear_bitrange(rs, re, chunk->populated, chunk->nr_pages) {
                        int nr = min_t(int, re - rs, nr_to_pop);
 
                        spin_unlock_irq(&pcpu_lock);