1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __LINUX_FIND_H_
3 #define __LINUX_FIND_H_
4 
5 #ifndef __LINUX_BITMAP_H
6 #error only <linux/bitmap.h> can be included directly
7 #endif
8 
9 #include <linux/bitops.h>
10 
11 unsigned long _find_next_bit(const unsigned long *addr1, unsigned long nbits,
12 				unsigned long start);
13 unsigned long _find_next_and_bit(const unsigned long *addr1, const unsigned long *addr2,
14 					unsigned long nbits, unsigned long start);
15 unsigned long _find_next_andnot_bit(const unsigned long *addr1, const unsigned long *addr2,
16 					unsigned long nbits, unsigned long start);
17 unsigned long _find_next_or_bit(const unsigned long *addr1, const unsigned long *addr2,
18 					unsigned long nbits, unsigned long start);
19 unsigned long _find_next_zero_bit(const unsigned long *addr, unsigned long nbits,
20 					 unsigned long start);
21 extern unsigned long _find_first_bit(const unsigned long *addr, unsigned long size);
22 unsigned long __find_nth_bit(const unsigned long *addr, unsigned long size, unsigned long n);
23 unsigned long __find_nth_and_bit(const unsigned long *addr1, const unsigned long *addr2,
24 				unsigned long size, unsigned long n);
25 unsigned long __find_nth_andnot_bit(const unsigned long *addr1, const unsigned long *addr2,
26 					unsigned long size, unsigned long n);
27 unsigned long __find_nth_and_andnot_bit(const unsigned long *addr1, const unsigned long *addr2,
28 					const unsigned long *addr3, unsigned long size,
29 					unsigned long n);
30 extern unsigned long _find_first_and_bit(const unsigned long *addr1,
31 					 const unsigned long *addr2, unsigned long size);
32 extern unsigned long _find_first_zero_bit(const unsigned long *addr, unsigned long size);
33 extern unsigned long _find_last_bit(const unsigned long *addr, unsigned long size);
34 
35 #ifdef __BIG_ENDIAN
36 unsigned long _find_first_zero_bit_le(const unsigned long *addr, unsigned long size);
37 unsigned long _find_next_zero_bit_le(const  unsigned long *addr, unsigned
38 					long size, unsigned long offset);
39 unsigned long _find_next_bit_le(const unsigned long *addr, unsigned
40 				long size, unsigned long offset);
41 #endif
42 
43 #ifndef find_next_bit
44 /**
45  * find_next_bit - find the next set bit in a memory region
46  * @addr: The address to base the search on
47  * @size: The bitmap size in bits
48  * @offset: The bitnumber to start searching at
49  *
50  * Returns the bit number for the next set bit
51  * If no bits are set, returns @size.
52  */
53 static inline
find_next_bit(const unsigned long * addr,unsigned long size,unsigned long offset)54 unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
55 			    unsigned long offset)
56 {
57 	if (small_const_nbits(size)) {
58 		unsigned long val;
59 
60 		if (unlikely(offset >= size))
61 			return size;
62 
63 		val = *addr & GENMASK(size - 1, offset);
64 		return val ? __ffs(val) : size;
65 	}
66 
67 	return _find_next_bit(addr, size, offset);
68 }
69 #endif
70 
71 #ifndef find_next_and_bit
72 /**
73  * find_next_and_bit - find the next set bit in both memory regions
74  * @addr1: The first address to base the search on
75  * @addr2: The second address to base the search on
76  * @size: The bitmap size in bits
77  * @offset: The bitnumber to start searching at
78  *
79  * Returns the bit number for the next set bit
80  * If no bits are set, returns @size.
81  */
82 static inline
find_next_and_bit(const unsigned long * addr1,const unsigned long * addr2,unsigned long size,unsigned long offset)83 unsigned long find_next_and_bit(const unsigned long *addr1,
84 		const unsigned long *addr2, unsigned long size,
85 		unsigned long offset)
86 {
87 	if (small_const_nbits(size)) {
88 		unsigned long val;
89 
90 		if (unlikely(offset >= size))
91 			return size;
92 
93 		val = *addr1 & *addr2 & GENMASK(size - 1, offset);
94 		return val ? __ffs(val) : size;
95 	}
96 
97 	return _find_next_and_bit(addr1, addr2, size, offset);
98 }
99 #endif
100 
101 #ifndef find_next_andnot_bit
102 /**
103  * find_next_andnot_bit - find the next set bit in *addr1 excluding all the bits
104  *                        in *addr2
105  * @addr1: The first address to base the search on
106  * @addr2: The second address to base the search on
107  * @size: The bitmap size in bits
108  * @offset: The bitnumber to start searching at
109  *
110  * Returns the bit number for the next set bit
111  * If no bits are set, returns @size.
112  */
113 static inline
find_next_andnot_bit(const unsigned long * addr1,const unsigned long * addr2,unsigned long size,unsigned long offset)114 unsigned long find_next_andnot_bit(const unsigned long *addr1,
115 		const unsigned long *addr2, unsigned long size,
116 		unsigned long offset)
117 {
118 	if (small_const_nbits(size)) {
119 		unsigned long val;
120 
121 		if (unlikely(offset >= size))
122 			return size;
123 
124 		val = *addr1 & ~*addr2 & GENMASK(size - 1, offset);
125 		return val ? __ffs(val) : size;
126 	}
127 
128 	return _find_next_andnot_bit(addr1, addr2, size, offset);
129 }
130 #endif
131 
132 #ifndef find_next_or_bit
133 /**
134  * find_next_or_bit - find the next set bit in either memory regions
135  * @addr1: The first address to base the search on
136  * @addr2: The second address to base the search on
137  * @size: The bitmap size in bits
138  * @offset: The bitnumber to start searching at
139  *
140  * Returns the bit number for the next set bit
141  * If no bits are set, returns @size.
142  */
143 static inline
find_next_or_bit(const unsigned long * addr1,const unsigned long * addr2,unsigned long size,unsigned long offset)144 unsigned long find_next_or_bit(const unsigned long *addr1,
145 		const unsigned long *addr2, unsigned long size,
146 		unsigned long offset)
147 {
148 	if (small_const_nbits(size)) {
149 		unsigned long val;
150 
151 		if (unlikely(offset >= size))
152 			return size;
153 
154 		val = (*addr1 | *addr2) & GENMASK(size - 1, offset);
155 		return val ? __ffs(val) : size;
156 	}
157 
158 	return _find_next_or_bit(addr1, addr2, size, offset);
159 }
160 #endif
161 
162 #ifndef find_next_zero_bit
163 /**
164  * find_next_zero_bit - find the next cleared bit in a memory region
165  * @addr: The address to base the search on
166  * @size: The bitmap size in bits
167  * @offset: The bitnumber to start searching at
168  *
169  * Returns the bit number of the next zero bit
170  * If no bits are zero, returns @size.
171  */
172 static inline
find_next_zero_bit(const unsigned long * addr,unsigned long size,unsigned long offset)173 unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
174 				 unsigned long offset)
175 {
176 	if (small_const_nbits(size)) {
177 		unsigned long val;
178 
179 		if (unlikely(offset >= size))
180 			return size;
181 
182 		val = *addr | ~GENMASK(size - 1, offset);
183 		return val == ~0UL ? size : ffz(val);
184 	}
185 
186 	return _find_next_zero_bit(addr, size, offset);
187 }
188 #endif
189 
190 #ifndef find_first_bit
191 /**
192  * find_first_bit - find the first set bit in a memory region
193  * @addr: The address to start the search at
194  * @size: The maximum number of bits to search
195  *
196  * Returns the bit number of the first set bit.
197  * If no bits are set, returns @size.
198  */
199 static inline
find_first_bit(const unsigned long * addr,unsigned long size)200 unsigned long find_first_bit(const unsigned long *addr, unsigned long size)
201 {
202 	if (small_const_nbits(size)) {
203 		unsigned long val = *addr & GENMASK(size - 1, 0);
204 
205 		return val ? __ffs(val) : size;
206 	}
207 
208 	return _find_first_bit(addr, size);
209 }
210 #endif
211 
212 /**
213  * find_nth_bit - find N'th set bit in a memory region
214  * @addr: The address to start the search at
215  * @size: The maximum number of bits to search
216  * @n: The number of set bit, which position is needed, counting from 0
217  *
218  * The following is semantically equivalent:
219  *	 idx = find_nth_bit(addr, size, 0);
220  *	 idx = find_first_bit(addr, size);
221  *
222  * Returns the bit number of the N'th set bit.
223  * If no such, returns @size.
224  */
225 static inline
find_nth_bit(const unsigned long * addr,unsigned long size,unsigned long n)226 unsigned long find_nth_bit(const unsigned long *addr, unsigned long size, unsigned long n)
227 {
228 	if (n >= size)
229 		return size;
230 
231 	if (small_const_nbits(size)) {
232 		unsigned long val =  *addr & GENMASK(size - 1, 0);
233 
234 		return val ? fns(val, n) : size;
235 	}
236 
237 	return __find_nth_bit(addr, size, n);
238 }
239 
240 /**
241  * find_nth_and_bit - find N'th set bit in 2 memory regions
242  * @addr1: The 1st address to start the search at
243  * @addr2: The 2nd address to start the search at
244  * @size: The maximum number of bits to search
245  * @n: The number of set bit, which position is needed, counting from 0
246  *
247  * Returns the bit number of the N'th set bit.
248  * If no such, returns @size.
249  */
250 static inline
find_nth_and_bit(const unsigned long * addr1,const unsigned long * addr2,unsigned long size,unsigned long n)251 unsigned long find_nth_and_bit(const unsigned long *addr1, const unsigned long *addr2,
252 				unsigned long size, unsigned long n)
253 {
254 	if (n >= size)
255 		return size;
256 
257 	if (small_const_nbits(size)) {
258 		unsigned long val =  *addr1 & *addr2 & GENMASK(size - 1, 0);
259 
260 		return val ? fns(val, n) : size;
261 	}
262 
263 	return __find_nth_and_bit(addr1, addr2, size, n);
264 }
265 
266 /**
267  * find_nth_andnot_bit - find N'th set bit in 2 memory regions,
268  *			 flipping bits in 2nd region
269  * @addr1: The 1st address to start the search at
270  * @addr2: The 2nd address to start the search at
271  * @size: The maximum number of bits to search
272  * @n: The number of set bit, which position is needed, counting from 0
273  *
274  * Returns the bit number of the N'th set bit.
275  * If no such, returns @size.
276  */
277 static inline
find_nth_andnot_bit(const unsigned long * addr1,const unsigned long * addr2,unsigned long size,unsigned long n)278 unsigned long find_nth_andnot_bit(const unsigned long *addr1, const unsigned long *addr2,
279 				unsigned long size, unsigned long n)
280 {
281 	if (n >= size)
282 		return size;
283 
284 	if (small_const_nbits(size)) {
285 		unsigned long val =  *addr1 & (~*addr2) & GENMASK(size - 1, 0);
286 
287 		return val ? fns(val, n) : size;
288 	}
289 
290 	return __find_nth_andnot_bit(addr1, addr2, size, n);
291 }
292 
293 /**
294  * find_nth_and_andnot_bit - find N'th set bit in 2 memory regions,
295  *			     excluding those set in 3rd region
296  * @addr1: The 1st address to start the search at
297  * @addr2: The 2nd address to start the search at
298  * @addr3: The 3rd address to start the search at
299  * @size: The maximum number of bits to search
300  * @n: The number of set bit, which position is needed, counting from 0
301  *
302  * Returns the bit number of the N'th set bit.
303  * If no such, returns @size.
304  */
305 static __always_inline
find_nth_and_andnot_bit(const unsigned long * addr1,const unsigned long * addr2,const unsigned long * addr3,unsigned long size,unsigned long n)306 unsigned long find_nth_and_andnot_bit(const unsigned long *addr1,
307 					const unsigned long *addr2,
308 					const unsigned long *addr3,
309 					unsigned long size, unsigned long n)
310 {
311 	if (n >= size)
312 		return size;
313 
314 	if (small_const_nbits(size)) {
315 		unsigned long val =  *addr1 & *addr2 & (~*addr3) & GENMASK(size - 1, 0);
316 
317 		return val ? fns(val, n) : size;
318 	}
319 
320 	return __find_nth_and_andnot_bit(addr1, addr2, addr3, size, n);
321 }
322 
323 #ifndef find_first_and_bit
324 /**
325  * find_first_and_bit - find the first set bit in both memory regions
326  * @addr1: The first address to base the search on
327  * @addr2: The second address to base the search on
328  * @size: The bitmap size in bits
329  *
330  * Returns the bit number for the next set bit
331  * If no bits are set, returns @size.
332  */
333 static inline
find_first_and_bit(const unsigned long * addr1,const unsigned long * addr2,unsigned long size)334 unsigned long find_first_and_bit(const unsigned long *addr1,
335 				 const unsigned long *addr2,
336 				 unsigned long size)
337 {
338 	if (small_const_nbits(size)) {
339 		unsigned long val = *addr1 & *addr2 & GENMASK(size - 1, 0);
340 
341 		return val ? __ffs(val) : size;
342 	}
343 
344 	return _find_first_and_bit(addr1, addr2, size);
345 }
346 #endif
347 
348 #ifndef find_first_zero_bit
349 /**
350  * find_first_zero_bit - find the first cleared bit in a memory region
351  * @addr: The address to start the search at
352  * @size: The maximum number of bits to search
353  *
354  * Returns the bit number of the first cleared bit.
355  * If no bits are zero, returns @size.
356  */
357 static inline
find_first_zero_bit(const unsigned long * addr,unsigned long size)358 unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
359 {
360 	if (small_const_nbits(size)) {
361 		unsigned long val = *addr | ~GENMASK(size - 1, 0);
362 
363 		return val == ~0UL ? size : ffz(val);
364 	}
365 
366 	return _find_first_zero_bit(addr, size);
367 }
368 #endif
369 
370 #ifndef find_last_bit
371 /**
372  * find_last_bit - find the last set bit in a memory region
373  * @addr: The address to start the search at
374  * @size: The number of bits to search
375  *
376  * Returns the bit number of the last set bit, or size.
377  */
378 static inline
find_last_bit(const unsigned long * addr,unsigned long size)379 unsigned long find_last_bit(const unsigned long *addr, unsigned long size)
380 {
381 	if (small_const_nbits(size)) {
382 		unsigned long val = *addr & GENMASK(size - 1, 0);
383 
384 		return val ? __fls(val) : size;
385 	}
386 
387 	return _find_last_bit(addr, size);
388 }
389 #endif
390 
391 /**
392  * find_next_and_bit_wrap - find the next set bit in both memory regions
393  * @addr1: The first address to base the search on
394  * @addr2: The second address to base the search on
395  * @size: The bitmap size in bits
396  * @offset: The bitnumber to start searching at
397  *
398  * Returns the bit number for the next set bit, or first set bit up to @offset
399  * If no bits are set, returns @size.
400  */
401 static inline
find_next_and_bit_wrap(const unsigned long * addr1,const unsigned long * addr2,unsigned long size,unsigned long offset)402 unsigned long find_next_and_bit_wrap(const unsigned long *addr1,
403 					const unsigned long *addr2,
404 					unsigned long size, unsigned long offset)
405 {
406 	unsigned long bit = find_next_and_bit(addr1, addr2, size, offset);
407 
408 	if (bit < size)
409 		return bit;
410 
411 	bit = find_first_and_bit(addr1, addr2, offset);
412 	return bit < offset ? bit : size;
413 }
414 
415 /**
416  * find_next_bit_wrap - find the next set bit in both memory regions
417  * @addr: The first address to base the search on
418  * @size: The bitmap size in bits
419  * @offset: The bitnumber to start searching at
420  *
421  * Returns the bit number for the next set bit, or first set bit up to @offset
422  * If no bits are set, returns @size.
423  */
424 static inline
find_next_bit_wrap(const unsigned long * addr,unsigned long size,unsigned long offset)425 unsigned long find_next_bit_wrap(const unsigned long *addr,
426 					unsigned long size, unsigned long offset)
427 {
428 	unsigned long bit = find_next_bit(addr, size, offset);
429 
430 	if (bit < size)
431 		return bit;
432 
433 	bit = find_first_bit(addr, offset);
434 	return bit < offset ? bit : size;
435 }
436 
437 /*
438  * Helper for for_each_set_bit_wrap(). Make sure you're doing right thing
439  * before using it alone.
440  */
441 static inline
__for_each_wrap(const unsigned long * bitmap,unsigned long size,unsigned long start,unsigned long n)442 unsigned long __for_each_wrap(const unsigned long *bitmap, unsigned long size,
443 				 unsigned long start, unsigned long n)
444 {
445 	unsigned long bit;
446 
447 	/* If not wrapped around */
448 	if (n > start) {
449 		/* and have a bit, just return it. */
450 		bit = find_next_bit(bitmap, size, n);
451 		if (bit < size)
452 			return bit;
453 
454 		/* Otherwise, wrap around and ... */
455 		n = 0;
456 	}
457 
458 	/* Search the other part. */
459 	bit = find_next_bit(bitmap, start, n);
460 	return bit < start ? bit : size;
461 }
462 
463 /**
464  * find_next_clump8 - find next 8-bit clump with set bits in a memory region
465  * @clump: location to store copy of found clump
466  * @addr: address to base the search on
467  * @size: bitmap size in number of bits
468  * @offset: bit offset at which to start searching
469  *
470  * Returns the bit offset for the next set clump; the found clump value is
471  * copied to the location pointed by @clump. If no bits are set, returns @size.
472  */
473 extern unsigned long find_next_clump8(unsigned long *clump,
474 				      const unsigned long *addr,
475 				      unsigned long size, unsigned long offset);
476 
477 #define find_first_clump8(clump, bits, size) \
478 	find_next_clump8((clump), (bits), (size), 0)
479 
480 #if defined(__LITTLE_ENDIAN)
481 
find_next_zero_bit_le(const void * addr,unsigned long size,unsigned long offset)482 static inline unsigned long find_next_zero_bit_le(const void *addr,
483 		unsigned long size, unsigned long offset)
484 {
485 	return find_next_zero_bit(addr, size, offset);
486 }
487 
find_next_bit_le(const void * addr,unsigned long size,unsigned long offset)488 static inline unsigned long find_next_bit_le(const void *addr,
489 		unsigned long size, unsigned long offset)
490 {
491 	return find_next_bit(addr, size, offset);
492 }
493 
find_first_zero_bit_le(const void * addr,unsigned long size)494 static inline unsigned long find_first_zero_bit_le(const void *addr,
495 		unsigned long size)
496 {
497 	return find_first_zero_bit(addr, size);
498 }
499 
500 #elif defined(__BIG_ENDIAN)
501 
502 #ifndef find_next_zero_bit_le
503 static inline
find_next_zero_bit_le(const void * addr,unsigned long size,unsigned long offset)504 unsigned long find_next_zero_bit_le(const void *addr, unsigned
505 		long size, unsigned long offset)
506 {
507 	if (small_const_nbits(size)) {
508 		unsigned long val = *(const unsigned long *)addr;
509 
510 		if (unlikely(offset >= size))
511 			return size;
512 
513 		val = swab(val) | ~GENMASK(size - 1, offset);
514 		return val == ~0UL ? size : ffz(val);
515 	}
516 
517 	return _find_next_zero_bit_le(addr, size, offset);
518 }
519 #endif
520 
521 #ifndef find_first_zero_bit_le
522 static inline
find_first_zero_bit_le(const void * addr,unsigned long size)523 unsigned long find_first_zero_bit_le(const void *addr, unsigned long size)
524 {
525 	if (small_const_nbits(size)) {
526 		unsigned long val = swab(*(const unsigned long *)addr) | ~GENMASK(size - 1, 0);
527 
528 		return val == ~0UL ? size : ffz(val);
529 	}
530 
531 	return _find_first_zero_bit_le(addr, size);
532 }
533 #endif
534 
535 #ifndef find_next_bit_le
536 static inline
find_next_bit_le(const void * addr,unsigned long size,unsigned long offset)537 unsigned long find_next_bit_le(const void *addr, unsigned
538 		long size, unsigned long offset)
539 {
540 	if (small_const_nbits(size)) {
541 		unsigned long val = *(const unsigned long *)addr;
542 
543 		if (unlikely(offset >= size))
544 			return size;
545 
546 		val = swab(val) & GENMASK(size - 1, offset);
547 		return val ? __ffs(val) : size;
548 	}
549 
550 	return _find_next_bit_le(addr, size, offset);
551 }
552 #endif
553 
554 #else
555 #error "Please fix <asm/byteorder.h>"
556 #endif
557 
558 #define for_each_set_bit(bit, addr, size) \
559 	for ((bit) = 0; (bit) = find_next_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
560 
561 #define for_each_and_bit(bit, addr1, addr2, size) \
562 	for ((bit) = 0;									\
563 	     (bit) = find_next_and_bit((addr1), (addr2), (size), (bit)), (bit) < (size);\
564 	     (bit)++)
565 
566 #define for_each_andnot_bit(bit, addr1, addr2, size) \
567 	for ((bit) = 0;									\
568 	     (bit) = find_next_andnot_bit((addr1), (addr2), (size), (bit)), (bit) < (size);\
569 	     (bit)++)
570 
571 #define for_each_or_bit(bit, addr1, addr2, size) \
572 	for ((bit) = 0;									\
573 	     (bit) = find_next_or_bit((addr1), (addr2), (size), (bit)), (bit) < (size);\
574 	     (bit)++)
575 
576 /* same as for_each_set_bit() but use bit as value to start with */
577 #define for_each_set_bit_from(bit, addr, size) \
578 	for (; (bit) = find_next_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
579 
580 #define for_each_clear_bit(bit, addr, size) \
581 	for ((bit) = 0;									\
582 	     (bit) = find_next_zero_bit((addr), (size), (bit)), (bit) < (size);		\
583 	     (bit)++)
584 
585 /* same as for_each_clear_bit() but use bit as value to start with */
586 #define for_each_clear_bit_from(bit, addr, size) \
587 	for (; (bit) = find_next_zero_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
588 
589 /**
590  * for_each_set_bitrange - iterate over all set bit ranges [b; e)
591  * @b: bit offset of start of current bitrange (first set bit)
592  * @e: bit offset of end of current bitrange (first unset bit)
593  * @addr: bitmap address to base the search on
594  * @size: bitmap size in number of bits
595  */
596 #define for_each_set_bitrange(b, e, addr, size)			\
597 	for ((b) = 0;						\
598 	     (b) = find_next_bit((addr), (size), b),		\
599 	     (e) = find_next_zero_bit((addr), (size), (b) + 1),	\
600 	     (b) < (size);					\
601 	     (b) = (e) + 1)
602 
603 /**
604  * for_each_set_bitrange_from - iterate over all set bit ranges [b; e)
605  * @b: bit offset of start of current bitrange (first set bit); must be initialized
606  * @e: bit offset of end of current bitrange (first unset bit)
607  * @addr: bitmap address to base the search on
608  * @size: bitmap size in number of bits
609  */
610 #define for_each_set_bitrange_from(b, e, addr, size)		\
611 	for (;							\
612 	     (b) = find_next_bit((addr), (size), (b)),		\
613 	     (e) = find_next_zero_bit((addr), (size), (b) + 1),	\
614 	     (b) < (size);					\
615 	     (b) = (e) + 1)
616 
617 /**
618  * for_each_clear_bitrange - iterate over all unset bit ranges [b; e)
619  * @b: bit offset of start of current bitrange (first unset bit)
620  * @e: bit offset of end of current bitrange (first set bit)
621  * @addr: bitmap address to base the search on
622  * @size: bitmap size in number of bits
623  */
624 #define for_each_clear_bitrange(b, e, addr, size)		\
625 	for ((b) = 0;						\
626 	     (b) = find_next_zero_bit((addr), (size), (b)),	\
627 	     (e) = find_next_bit((addr), (size), (b) + 1),	\
628 	     (b) < (size);					\
629 	     (b) = (e) + 1)
630 
631 /**
632  * for_each_clear_bitrange_from - iterate over all unset bit ranges [b; e)
633  * @b: bit offset of start of current bitrange (first set bit); must be initialized
634  * @e: bit offset of end of current bitrange (first unset bit)
635  * @addr: bitmap address to base the search on
636  * @size: bitmap size in number of bits
637  */
638 #define for_each_clear_bitrange_from(b, e, addr, size)		\
639 	for (;							\
640 	     (b) = find_next_zero_bit((addr), (size), (b)),	\
641 	     (e) = find_next_bit((addr), (size), (b) + 1),	\
642 	     (b) < (size);					\
643 	     (b) = (e) + 1)
644 
645 /**
646  * for_each_set_bit_wrap - iterate over all set bits starting from @start, and
647  * wrapping around the end of bitmap.
648  * @bit: offset for current iteration
649  * @addr: bitmap address to base the search on
650  * @size: bitmap size in number of bits
651  * @start: Starting bit for bitmap traversing, wrapping around the bitmap end
652  */
653 #define for_each_set_bit_wrap(bit, addr, size, start) \
654 	for ((bit) = find_next_bit_wrap((addr), (size), (start));		\
655 	     (bit) < (size);							\
656 	     (bit) = __for_each_wrap((addr), (size), (start), (bit) + 1))
657 
658 /**
659  * for_each_set_clump8 - iterate over bitmap for each 8-bit clump with set bits
660  * @start: bit offset to start search and to store the current iteration offset
661  * @clump: location to store copy of current 8-bit clump
662  * @bits: bitmap address to base the search on
663  * @size: bitmap size in number of bits
664  */
665 #define for_each_set_clump8(start, clump, bits, size) \
666 	for ((start) = find_first_clump8(&(clump), (bits), (size)); \
667 	     (start) < (size); \
668 	     (start) = find_next_clump8(&(clump), (bits), (size), (start) + 8))
669 
670 #endif /*__LINUX_FIND_H_ */
671