Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696/* SPDX-License-Identifier: GPL-2.0 */#ifndef __LINUX_FIND_H_#define __LINUX_FIND_H_
#ifndef __LINUX_BITMAP_H#error only <linux/bitmap.h> can be included directly#endif
#include <linux/bitops.h>
unsigned long _find_next_bit(const unsigned long *addr1, unsigned long nbits, unsigned long start);unsigned long _find_next_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long nbits, unsigned long start);unsigned long _find_next_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long nbits, unsigned long start);unsigned long _find_next_or_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long nbits, unsigned long start);unsigned long _find_next_zero_bit(const unsigned long *addr, unsigned long nbits, unsigned long start);extern unsigned long _find_first_bit(const unsigned long *addr, unsigned long size);unsigned long __find_nth_bit(const unsigned long *addr, unsigned long size, unsigned long n);unsigned long __find_nth_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long n);unsigned long __find_nth_and_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, const unsigned long *addr3, unsigned long size, unsigned long n);extern unsigned long _find_first_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size);unsigned long _find_first_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size);unsigned long _find_first_and_and_bit(const unsigned long *addr1, const unsigned long *addr2, const unsigned long *addr3, unsigned long size);extern unsigned long _find_first_zero_bit(const unsigned long *addr, unsigned long size);extern unsigned long _find_last_bit(const unsigned long *addr, unsigned long size);
#ifdef __BIG_ENDIANunsigned long _find_first_zero_bit_le(const unsigned long *addr, unsigned long size);unsigned long _find_next_zero_bit_le(const unsigned long *addr, unsigned long size, unsigned long offset);unsigned long _find_next_bit_le(const unsigned long *addr, unsigned long size, unsigned long offset);#endif
unsigned long find_random_bit(const unsigned long *addr, unsigned long size);
#ifndef find_next_bit/** * find_next_bit - find the next set bit in a memory region * @addr: The address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number for the next set bit * If no bits are set, returns @size. */static __always_inlineunsigned long find_next_bit(const unsigned long *addr, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val;
if (unlikely(offset >= size)) return size;
val = *addr & GENMASK(size - 1, offset); return val ? __ffs(val) : size; }
return _find_next_bit(addr, size, offset);}#endif
#ifndef find_next_and_bit/** * find_next_and_bit - find the next set bit in both memory regions * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number for the next set bit * If no bits are set, returns @size. */static __always_inlineunsigned long find_next_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val;
if (unlikely(offset >= size)) return size;
val = *addr1 & *addr2 & GENMASK(size - 1, offset); return val ? __ffs(val) : size; }
return _find_next_and_bit(addr1, addr2, size, offset);}#endif
#ifndef find_next_andnot_bit/** * find_next_andnot_bit - find the next set bit in *addr1 excluding all the bits * in *addr2 * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number for the next set bit * If no bits are set, returns @size. */static __always_inlineunsigned long find_next_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val;
if (unlikely(offset >= size)) return size;
val = *addr1 & ~*addr2 & GENMASK(size - 1, offset); return val ? __ffs(val) : size; }
return _find_next_andnot_bit(addr1, addr2, size, offset);}#endif
#ifndef find_next_or_bit/** * find_next_or_bit - find the next set bit in either memory regions * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number for the next set bit * If no bits are set, returns @size. */static __always_inlineunsigned long find_next_or_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val;
if (unlikely(offset >= size)) return size;
val = (*addr1 | *addr2) & GENMASK(size - 1, offset); return val ? __ffs(val) : size; }
return _find_next_or_bit(addr1, addr2, size, offset);}#endif
#ifndef find_next_zero_bit/** * find_next_zero_bit - find the next cleared bit in a memory region * @addr: The address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number of the next zero bit * If no bits are zero, returns @size. */static __always_inlineunsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val;
if (unlikely(offset >= size)) return size;
val = *addr | ~GENMASK(size - 1, offset); return val == ~0UL ? size : ffz(val); }
return _find_next_zero_bit(addr, size, offset);}#endif
#ifndef find_first_bit/** * find_first_bit - find the first set bit in a memory region * @addr: The address to start the search at * @size: The maximum number of bits to search * * Returns the bit number of the first set bit. * If no bits are set, returns @size. */static __always_inlineunsigned long find_first_bit(const unsigned long *addr, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = *addr & GENMASK(size - 1, 0);
return val ? __ffs(val) : size; }
return _find_first_bit(addr, size);}#endif
/** * find_nth_bit - find N'th set bit in a memory region * @addr: The address to start the search at * @size: The maximum number of bits to search * @n: The number of set bit, which position is needed, counting from 0 * * The following is semantically equivalent: * idx = find_nth_bit(addr, size, 0); * idx = find_first_bit(addr, size); * * Returns the bit number of the N'th set bit. * If no such, returns >= @size. */static __always_inlineunsigned long find_nth_bit(const unsigned long *addr, unsigned long size, unsigned long n){ if (n >= size) return size;
if (small_const_nbits(size)) { unsigned long val = *addr & GENMASK(size - 1, 0);
return val ? fns(val, n) : size; }
return __find_nth_bit(addr, size, n);}
/** * find_nth_and_bit - find N'th set bit in 2 memory regions * @addr1: The 1st address to start the search at * @addr2: The 2nd address to start the search at * @size: The maximum number of bits to search * @n: The number of set bit, which position is needed, counting from 0 * * Returns the bit number of the N'th set bit. * If no such, returns >= @size. */static __always_inlineunsigned long find_nth_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long n){ if (n >= size) return size;
if (small_const_nbits(size)) { unsigned long val = *addr1 & *addr2 & GENMASK(size - 1, 0);
return val ? fns(val, n) : size; }
return __find_nth_and_bit(addr1, addr2, size, n);}
/** * find_nth_and_andnot_bit - find N'th set bit in 2 memory regions, * excluding those set in 3rd region * @addr1: The 1st address to start the search at * @addr2: The 2nd address to start the search at * @addr3: The 3rd address to start the search at * @size: The maximum number of bits to search * @n: The number of set bit, which position is needed, counting from 0 * * Returns the bit number of the N'th set bit. * If no such, returns >= @size. */static __always_inlineunsigned long find_nth_and_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, const unsigned long *addr3, unsigned long size, unsigned long n){ if (n >= size) return size;
if (small_const_nbits(size)) { unsigned long val = *addr1 & *addr2 & (~*addr3) & GENMASK(size - 1, 0);
return val ? fns(val, n) : size; }
return __find_nth_and_andnot_bit(addr1, addr2, addr3, size, n);}
#ifndef find_first_and_bit/** * find_first_and_bit - find the first set bit in both memory regions * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @size: The bitmap size in bits * * Returns the bit number for the next set bit * If no bits are set, returns @size. */static __always_inlineunsigned long find_first_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = *addr1 & *addr2 & GENMASK(size - 1, 0);
return val ? __ffs(val) : size; }
return _find_first_and_bit(addr1, addr2, size);}#endif
/** * find_first_andnot_bit - find the first bit set in 1st memory region and unset in 2nd * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @size: The bitmap size in bits * * Returns the bit number for the first set bit * If no bits are set, returns >= @size. */static __always_inlineunsigned long find_first_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = *addr1 & (~*addr2) & GENMASK(size - 1, 0);
return val ? __ffs(val) : size; }
return _find_first_andnot_bit(addr1, addr2, size);}
/** * find_first_and_and_bit - find the first set bit in 3 memory regions * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @addr3: The third address to base the search on * @size: The bitmap size in bits * * Returns the bit number for the first set bit * If no bits are set, returns @size. */static __always_inlineunsigned long find_first_and_and_bit(const unsigned long *addr1, const unsigned long *addr2, const unsigned long *addr3, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = *addr1 & *addr2 & *addr3 & GENMASK(size - 1, 0);
return val ? __ffs(val) : size; }
return _find_first_and_and_bit(addr1, addr2, addr3, size);}
#ifndef find_first_zero_bit/** * find_first_zero_bit - find the first cleared bit in a memory region * @addr: The address to start the search at * @size: The maximum number of bits to search * * Returns the bit number of the first cleared bit. * If no bits are zero, returns @size. */static __always_inlineunsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = *addr | ~GENMASK(size - 1, 0);
return val == ~0UL ? size : ffz(val); }
return _find_first_zero_bit(addr, size);}#endif
#ifndef find_last_bit/** * find_last_bit - find the last set bit in a memory region * @addr: The address to start the search at * @size: The number of bits to search * * Returns the bit number of the last set bit, or size. */static __always_inlineunsigned long find_last_bit(const unsigned long *addr, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = *addr & GENMASK(size - 1, 0);
return val ? __fls(val) : size; }
return _find_last_bit(addr, size);}#endif
/** * find_next_and_bit_wrap - find the next set bit in both memory regions * @addr1: The first address to base the search on * @addr2: The second address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number for the next set bit, or first set bit up to @offset * If no bits are set, returns @size. */static __always_inlineunsigned long find_next_and_bit_wrap(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long offset){ unsigned long bit = find_next_and_bit(addr1, addr2, size, offset);
if (bit < size || offset == 0) return bit;
bit = find_first_and_bit(addr1, addr2, offset); return bit < offset ? bit : size;}
/** * find_next_bit_wrap - find the next set bit in a memory region * @addr: The address to base the search on * @size: The bitmap size in bits * @offset: The bitnumber to start searching at * * Returns the bit number for the next set bit, or first set bit up to @offset * If no bits are set, returns @size. */static __always_inlineunsigned long find_next_bit_wrap(const unsigned long *addr, unsigned long size, unsigned long offset){ unsigned long bit = find_next_bit(addr, size, offset);
if (bit < size || offset == 0) return bit;
bit = find_first_bit(addr, offset); return bit < offset ? bit : size;}
/* * Helper for for_each_set_bit_wrap(). Make sure you're doing right thing * before using it alone. */static __always_inlineunsigned long __for_each_wrap(const unsigned long *bitmap, unsigned long size, unsigned long start, unsigned long n){ unsigned long bit;
/* If not wrapped around */ if (n > start) { /* and have a bit, just return it. */ bit = find_next_bit(bitmap, size, n); if (bit < size) return bit;
/* Otherwise, wrap around and ... */ n = 0; }
/* Search the other part. */ bit = find_next_bit(bitmap, start, n); return bit < start ? bit : size;}
/** * find_next_clump8 - find next 8-bit clump with set bits in a memory region * @clump: location to store copy of found clump * @addr: address to base the search on * @size: bitmap size in number of bits * @offset: bit offset at which to start searching * * Returns the bit offset for the next set clump; the found clump value is * copied to the location pointed by @clump. If no bits are set, returns @size. */extern unsigned long find_next_clump8(unsigned long *clump, const unsigned long *addr, unsigned long size, unsigned long offset);
#define find_first_clump8(clump, bits, size) \ find_next_clump8((clump), (bits), (size), 0)
#if defined(__LITTLE_ENDIAN)
static __always_inlineunsigned long find_next_zero_bit_le(const void *addr, unsigned long size, unsigned long offset){ return find_next_zero_bit(addr, size, offset);}
static __always_inlineunsigned long find_next_bit_le(const void *addr, unsigned long size, unsigned long offset){ return find_next_bit(addr, size, offset);}
static __always_inlineunsigned long find_first_zero_bit_le(const void *addr, unsigned long size){ return find_first_zero_bit(addr, size);}
#elif defined(__BIG_ENDIAN)
#ifndef find_next_zero_bit_lestatic __always_inlineunsigned long find_next_zero_bit_le(const void *addr, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val = *(const unsigned long *)addr;
if (unlikely(offset >= size)) return size;
val = swab(val) | ~GENMASK(size - 1, offset); return val == ~0UL ? size : ffz(val); }
return _find_next_zero_bit_le(addr, size, offset);}#endif
#ifndef find_first_zero_bit_lestatic __always_inlineunsigned long find_first_zero_bit_le(const void *addr, unsigned long size){ if (small_const_nbits(size)) { unsigned long val = swab(*(const unsigned long *)addr) | ~GENMASK(size - 1, 0);
return val == ~0UL ? size : ffz(val); }
return _find_first_zero_bit_le(addr, size);}#endif
#ifndef find_next_bit_lestatic __always_inlineunsigned long find_next_bit_le(const void *addr, unsigned long size, unsigned long offset){ if (small_const_nbits(size)) { unsigned long val = *(const unsigned long *)addr;
if (unlikely(offset >= size)) return size;
val = swab(val) & GENMASK(size - 1, offset); return val ? __ffs(val) : size; }
return _find_next_bit_le(addr, size, offset);}#endif
#else#error "Please fix <asm/byteorder.h>"#endif
#define for_each_set_bit(bit, addr, size) \ for ((bit) = 0; (bit) = find_next_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
#define for_each_and_bit(bit, addr1, addr2, size) \ for ((bit) = 0; \ (bit) = find_next_and_bit((addr1), (addr2), (size), (bit)), (bit) < (size);\ (bit)++)
#define for_each_andnot_bit(bit, addr1, addr2, size) \ for ((bit) = 0; \ (bit) = find_next_andnot_bit((addr1), (addr2), (size), (bit)), (bit) < (size);\ (bit)++)
#define for_each_or_bit(bit, addr1, addr2, size) \ for ((bit) = 0; \ (bit) = find_next_or_bit((addr1), (addr2), (size), (bit)), (bit) < (size);\ (bit)++)
/* same as for_each_set_bit() but use bit as value to start with */#define for_each_set_bit_from(bit, addr, size) \ for (; (bit) = find_next_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
#define for_each_clear_bit(bit, addr, size) \ for ((bit) = 0; \ (bit) = find_next_zero_bit((addr), (size), (bit)), (bit) < (size); \ (bit)++)
/* same as for_each_clear_bit() but use bit as value to start with */#define for_each_clear_bit_from(bit, addr, size) \ for (; (bit) = find_next_zero_bit((addr), (size), (bit)), (bit) < (size); (bit)++)
/** * 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) = 0; \ (b) = find_next_bit((addr), (size), b), \ (e) = find_next_zero_bit((addr), (size), (b) + 1), \ (b) < (size); \ (b) = (e) + 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) = (e) + 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) = 0; \ (b) = find_next_zero_bit((addr), (size), (b)), \ (e) = find_next_bit((addr), (size), (b) + 1), \ (b) < (size); \ (b) = (e) + 1)
/** * for_each_clear_bitrange_from - iterate over all unset bit ranges [b; e) * @b: bit offset of start of current bitrange (first unset bit); must be initialized * @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_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) = (e) + 1)
/** * for_each_set_bit_wrap - iterate over all set bits starting from @start, and * wrapping around the end of bitmap. * @bit: offset for current iteration * @addr: bitmap address to base the search on * @size: bitmap size in number of bits * @start: Starting bit for bitmap traversing, wrapping around the bitmap end */#define for_each_set_bit_wrap(bit, addr, size, start) \ for ((bit) = find_next_bit_wrap((addr), (size), (start)); \ (bit) < (size); \ (bit) = __for_each_wrap((addr), (size), (start), (bit) + 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 * @bits: bitmap address to base the search on * @size: bitmap size in number of bits */#define for_each_set_clump8(start, clump, bits, size) \ for ((start) = find_first_clump8(&(clump), (bits), (size)); \ (start) < (size); \ (start) = find_next_clump8(&(clump), (bits), (size), (start) + 8))
#endif /*__LINUX_FIND_H_ */