Commit ec288a2c authored by Yury Norov's avatar Yury Norov
Browse files

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: default avatarYury Norov <yury.norov@gmail.com>
Tested-by: default avatarWolfram Sang <wsa+renesas@sang-engineering.com>
Acked-by: default avatarDennis Zhou <dennis@kernel.org>
Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # For MMC
parent 801a5736

drivers/mmc/host/renesas_sdhi_core.c

+1 −1
Original line number Diff line number Diff line
@@ -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;

include/linux/bitmap.h

+0 −33
Original line number Diff line number Diff line
@@ -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

include/linux/find.h

+56 −0
Original line number Diff line number Diff line
@@ -301,6 +301,62 @@ unsigned long find_next_bit_le(const void *addr, unsigned 
	     (bit) < (size);					\

	     (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

mm/percpu.c

+8 −12
Original line number Diff line number Diff line
@@ -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 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved, 


	/* 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 @@ static void pcpu_balance_populated(void) 
			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);