include/linux/find.h

   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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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_ */