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