cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

bitmap.h (22105B)


      1/* SPDX-License-Identifier: GPL-2.0 */
      2#ifndef __LINUX_BITMAP_H
      3#define __LINUX_BITMAP_H
      4
      5#ifndef __ASSEMBLY__
      6
      7#include <linux/align.h>
      8#include <linux/bitops.h>
      9#include <linux/find.h>
     10#include <linux/limits.h>
     11#include <linux/string.h>
     12#include <linux/types.h>
     13
     14struct device;
     15
     16/*
     17 * bitmaps provide bit arrays that consume one or more unsigned
     18 * longs.  The bitmap interface and available operations are listed
     19 * here, in bitmap.h
     20 *
     21 * Function implementations generic to all architectures are in
     22 * lib/bitmap.c.  Functions implementations that are architecture
     23 * specific are in various include/asm-<arch>/bitops.h headers
     24 * and other arch/<arch> specific files.
     25 *
     26 * See lib/bitmap.c for more details.
     27 */
     28
     29/**
     30 * DOC: bitmap overview
     31 *
     32 * The available bitmap operations and their rough meaning in the
     33 * case that the bitmap is a single unsigned long are thus:
     34 *
     35 * The generated code is more efficient when nbits is known at
     36 * compile-time and at most BITS_PER_LONG.
     37 *
     38 * ::
     39 *
     40 *  bitmap_zero(dst, nbits)                     *dst = 0UL
     41 *  bitmap_fill(dst, nbits)                     *dst = ~0UL
     42 *  bitmap_copy(dst, src, nbits)                *dst = *src
     43 *  bitmap_and(dst, src1, src2, nbits)          *dst = *src1 & *src2
     44 *  bitmap_or(dst, src1, src2, nbits)           *dst = *src1 | *src2
     45 *  bitmap_xor(dst, src1, src2, nbits)          *dst = *src1 ^ *src2
     46 *  bitmap_andnot(dst, src1, src2, nbits)       *dst = *src1 & ~(*src2)
     47 *  bitmap_complement(dst, src, nbits)          *dst = ~(*src)
     48 *  bitmap_equal(src1, src2, nbits)             Are *src1 and *src2 equal?
     49 *  bitmap_intersects(src1, src2, nbits)        Do *src1 and *src2 overlap?
     50 *  bitmap_subset(src1, src2, nbits)            Is *src1 a subset of *src2?
     51 *  bitmap_empty(src, nbits)                    Are all bits zero in *src?
     52 *  bitmap_full(src, nbits)                     Are all bits set in *src?
     53 *  bitmap_weight(src, nbits)                   Hamming Weight: number set bits
     54 *  bitmap_set(dst, pos, nbits)                 Set specified bit area
     55 *  bitmap_clear(dst, pos, nbits)               Clear specified bit area
     56 *  bitmap_find_next_zero_area(buf, len, pos, n, mask)  Find bit free area
     57 *  bitmap_find_next_zero_area_off(buf, len, pos, n, mask, mask_off)  as above
     58 *  bitmap_shift_right(dst, src, n, nbits)      *dst = *src >> n
     59 *  bitmap_shift_left(dst, src, n, nbits)       *dst = *src << n
     60 *  bitmap_cut(dst, src, first, n, nbits)       Cut n bits from first, copy rest
     61 *  bitmap_replace(dst, old, new, mask, nbits)  *dst = (*old & ~(*mask)) | (*new & *mask)
     62 *  bitmap_remap(dst, src, old, new, nbits)     *dst = map(old, new)(src)
     63 *  bitmap_bitremap(oldbit, old, new, nbits)    newbit = map(old, new)(oldbit)
     64 *  bitmap_onto(dst, orig, relmap, nbits)       *dst = orig relative to relmap
     65 *  bitmap_fold(dst, orig, sz, nbits)           dst bits = orig bits mod sz
     66 *  bitmap_parse(buf, buflen, dst, nbits)       Parse bitmap dst from kernel buf
     67 *  bitmap_parse_user(ubuf, ulen, dst, nbits)   Parse bitmap dst from user buf
     68 *  bitmap_parselist(buf, dst, nbits)           Parse bitmap dst from kernel buf
     69 *  bitmap_parselist_user(buf, dst, nbits)      Parse bitmap dst from user buf
     70 *  bitmap_find_free_region(bitmap, bits, order)  Find and allocate bit region
     71 *  bitmap_release_region(bitmap, pos, order)   Free specified bit region
     72 *  bitmap_allocate_region(bitmap, pos, order)  Allocate specified bit region
     73 *  bitmap_from_arr32(dst, buf, nbits)          Copy nbits from u32[] buf to dst
     74 *  bitmap_to_arr32(buf, src, nbits)            Copy nbits from buf to u32[] dst
     75 *  bitmap_to_arr64(buf, src, nbits)            Copy nbits from buf to u64[] dst
     76 *  bitmap_to_arr64(buf, src, nbits)            Copy nbits from buf to u64[] dst
     77 *  bitmap_get_value8(map, start)               Get 8bit value from map at start
     78 *  bitmap_set_value8(map, value, start)        Set 8bit value to map at start
     79 *
     80 * Note, bitmap_zero() and bitmap_fill() operate over the region of
     81 * unsigned longs, that is, bits behind bitmap till the unsigned long
     82 * boundary will be zeroed or filled as well. Consider to use
     83 * bitmap_clear() or bitmap_set() to make explicit zeroing or filling
     84 * respectively.
     85 */
     86
     87/**
     88 * DOC: bitmap bitops
     89 *
     90 * Also the following operations in asm/bitops.h apply to bitmaps.::
     91 *
     92 *  set_bit(bit, addr)                  *addr |= bit
     93 *  clear_bit(bit, addr)                *addr &= ~bit
     94 *  change_bit(bit, addr)               *addr ^= bit
     95 *  test_bit(bit, addr)                 Is bit set in *addr?
     96 *  test_and_set_bit(bit, addr)         Set bit and return old value
     97 *  test_and_clear_bit(bit, addr)       Clear bit and return old value
     98 *  test_and_change_bit(bit, addr)      Change bit and return old value
     99 *  find_first_zero_bit(addr, nbits)    Position first zero bit in *addr
    100 *  find_first_bit(addr, nbits)         Position first set bit in *addr
    101 *  find_next_zero_bit(addr, nbits, bit)
    102 *                                      Position next zero bit in *addr >= bit
    103 *  find_next_bit(addr, nbits, bit)     Position next set bit in *addr >= bit
    104 *  find_next_and_bit(addr1, addr2, nbits, bit)
    105 *                                      Same as find_next_bit, but in
    106 *                                      (*addr1 & *addr2)
    107 *
    108 */
    109
    110/**
    111 * DOC: declare bitmap
    112 * The DECLARE_BITMAP(name,bits) macro, in linux/types.h, can be used
    113 * to declare an array named 'name' of just enough unsigned longs to
    114 * contain all bit positions from 0 to 'bits' - 1.
    115 */
    116
    117/*
    118 * Allocation and deallocation of bitmap.
    119 * Provided in lib/bitmap.c to avoid circular dependency.
    120 */
    121unsigned long *bitmap_alloc(unsigned int nbits, gfp_t flags);
    122unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags);
    123unsigned long *bitmap_alloc_node(unsigned int nbits, gfp_t flags, int node);
    124unsigned long *bitmap_zalloc_node(unsigned int nbits, gfp_t flags, int node);
    125void bitmap_free(const unsigned long *bitmap);
    126
    127/* Managed variants of the above. */
    128unsigned long *devm_bitmap_alloc(struct device *dev,
    129				 unsigned int nbits, gfp_t flags);
    130unsigned long *devm_bitmap_zalloc(struct device *dev,
    131				  unsigned int nbits, gfp_t flags);
    132
    133/*
    134 * lib/bitmap.c provides these functions:
    135 */
    136
    137bool __bitmap_equal(const unsigned long *bitmap1,
    138		    const unsigned long *bitmap2, unsigned int nbits);
    139bool __pure __bitmap_or_equal(const unsigned long *src1,
    140			      const unsigned long *src2,
    141			      const unsigned long *src3,
    142			      unsigned int nbits);
    143void __bitmap_complement(unsigned long *dst, const unsigned long *src,
    144			 unsigned int nbits);
    145void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
    146			  unsigned int shift, unsigned int nbits);
    147void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
    148			 unsigned int shift, unsigned int nbits);
    149void bitmap_cut(unsigned long *dst, const unsigned long *src,
    150		unsigned int first, unsigned int cut, unsigned int nbits);
    151int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
    152		 const unsigned long *bitmap2, unsigned int nbits);
    153void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
    154		 const unsigned long *bitmap2, unsigned int nbits);
    155void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
    156		  const unsigned long *bitmap2, unsigned int nbits);
    157int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
    158		    const unsigned long *bitmap2, unsigned int nbits);
    159void __bitmap_replace(unsigned long *dst,
    160		      const unsigned long *old, const unsigned long *new,
    161		      const unsigned long *mask, unsigned int nbits);
    162bool __bitmap_intersects(const unsigned long *bitmap1,
    163			 const unsigned long *bitmap2, unsigned int nbits);
    164bool __bitmap_subset(const unsigned long *bitmap1,
    165		     const unsigned long *bitmap2, unsigned int nbits);
    166int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);
    167void __bitmap_set(unsigned long *map, unsigned int start, int len);
    168void __bitmap_clear(unsigned long *map, unsigned int start, int len);
    169
    170unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
    171					     unsigned long size,
    172					     unsigned long start,
    173					     unsigned int nr,
    174					     unsigned long align_mask,
    175					     unsigned long align_offset);
    176
    177/**
    178 * bitmap_find_next_zero_area - find a contiguous aligned zero area
    179 * @map: The address to base the search on
    180 * @size: The bitmap size in bits
    181 * @start: The bitnumber to start searching at
    182 * @nr: The number of zeroed bits we're looking for
    183 * @align_mask: Alignment mask for zero area
    184 *
    185 * The @align_mask should be one less than a power of 2; the effect is that
    186 * the bit offset of all zero areas this function finds is multiples of that
    187 * power of 2. A @align_mask of 0 means no alignment is required.
    188 */
    189static inline unsigned long
    190bitmap_find_next_zero_area(unsigned long *map,
    191			   unsigned long size,
    192			   unsigned long start,
    193			   unsigned int nr,
    194			   unsigned long align_mask)
    195{
    196	return bitmap_find_next_zero_area_off(map, size, start, nr,
    197					      align_mask, 0);
    198}
    199
    200int bitmap_parse(const char *buf, unsigned int buflen,
    201			unsigned long *dst, int nbits);
    202int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,
    203			unsigned long *dst, int nbits);
    204int bitmap_parselist(const char *buf, unsigned long *maskp,
    205			int nmaskbits);
    206int bitmap_parselist_user(const char __user *ubuf, unsigned int ulen,
    207			unsigned long *dst, int nbits);
    208void bitmap_remap(unsigned long *dst, const unsigned long *src,
    209		const unsigned long *old, const unsigned long *new, unsigned int nbits);
    210int bitmap_bitremap(int oldbit,
    211		const unsigned long *old, const unsigned long *new, int bits);
    212void bitmap_onto(unsigned long *dst, const unsigned long *orig,
    213		const unsigned long *relmap, unsigned int bits);
    214void bitmap_fold(unsigned long *dst, const unsigned long *orig,
    215		unsigned int sz, unsigned int nbits);
    216int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
    217void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
    218int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
    219
    220#ifdef __BIG_ENDIAN
    221void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits);
    222#else
    223#define bitmap_copy_le bitmap_copy
    224#endif
    225unsigned int bitmap_ord_to_pos(const unsigned long *bitmap, unsigned int ord, unsigned int nbits);
    226int bitmap_print_to_pagebuf(bool list, char *buf,
    227				   const unsigned long *maskp, int nmaskbits);
    228
    229extern int bitmap_print_bitmask_to_buf(char *buf, const unsigned long *maskp,
    230				      int nmaskbits, loff_t off, size_t count);
    231
    232extern int bitmap_print_list_to_buf(char *buf, const unsigned long *maskp,
    233				      int nmaskbits, loff_t off, size_t count);
    234
    235#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
    236#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
    237
    238static inline void bitmap_zero(unsigned long *dst, unsigned int nbits)
    239{
    240	unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
    241	memset(dst, 0, len);
    242}
    243
    244static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
    245{
    246	unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
    247	memset(dst, 0xff, len);
    248}
    249
    250static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
    251			unsigned int nbits)
    252{
    253	unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
    254	memcpy(dst, src, len);
    255}
    256
    257/*
    258 * Copy bitmap and clear tail bits in last word.
    259 */
    260static inline void bitmap_copy_clear_tail(unsigned long *dst,
    261		const unsigned long *src, unsigned int nbits)
    262{
    263	bitmap_copy(dst, src, nbits);
    264	if (nbits % BITS_PER_LONG)
    265		dst[nbits / BITS_PER_LONG] &= BITMAP_LAST_WORD_MASK(nbits);
    266}
    267
    268/*
    269 * On 32-bit systems bitmaps are represented as u32 arrays internally. On LE64
    270 * machines the order of hi and lo parts of numbers match the bitmap structure.
    271 * In both cases conversion is not needed when copying data from/to arrays of
    272 * u32. But in LE64 case, typecast in bitmap_copy_clear_tail() may lead
    273 * to out-of-bound access. To avoid that, both LE and BE variants of 64-bit
    274 * architectures are not using bitmap_copy_clear_tail().
    275 */
    276#if BITS_PER_LONG == 64
    277void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf,
    278							unsigned int nbits);
    279void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap,
    280							unsigned int nbits);
    281#else
    282#define bitmap_from_arr32(bitmap, buf, nbits)			\
    283	bitmap_copy_clear_tail((unsigned long *) (bitmap),	\
    284			(const unsigned long *) (buf), (nbits))
    285#define bitmap_to_arr32(buf, bitmap, nbits)			\
    286	bitmap_copy_clear_tail((unsigned long *) (buf),		\
    287			(const unsigned long *) (bitmap), (nbits))
    288#endif
    289
    290/*
    291 * On 64-bit systems bitmaps are represented as u64 arrays internally. On LE32
    292 * machines the order of hi and lo parts of numbers match the bitmap structure.
    293 * In both cases conversion is not needed when copying data from/to arrays of
    294 * u64.
    295 */
    296#if (BITS_PER_LONG == 32) && defined(__BIG_ENDIAN)
    297void bitmap_from_arr64(unsigned long *bitmap, const u64 *buf, unsigned int nbits);
    298void bitmap_to_arr64(u64 *buf, const unsigned long *bitmap, unsigned int nbits);
    299#else
    300#define bitmap_from_arr64(bitmap, buf, nbits)			\
    301	bitmap_copy_clear_tail((unsigned long *)(bitmap), (const unsigned long *)(buf), (nbits))
    302#define bitmap_to_arr64(buf, bitmap, nbits)			\
    303	bitmap_copy_clear_tail((unsigned long *)(buf), (const unsigned long *)(bitmap), (nbits))
    304#endif
    305
    306static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
    307			const unsigned long *src2, unsigned int nbits)
    308{
    309	if (small_const_nbits(nbits))
    310		return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0;
    311	return __bitmap_and(dst, src1, src2, nbits);
    312}
    313
    314static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
    315			const unsigned long *src2, unsigned int nbits)
    316{
    317	if (small_const_nbits(nbits))
    318		*dst = *src1 | *src2;
    319	else
    320		__bitmap_or(dst, src1, src2, nbits);
    321}
    322
    323static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
    324			const unsigned long *src2, unsigned int nbits)
    325{
    326	if (small_const_nbits(nbits))
    327		*dst = *src1 ^ *src2;
    328	else
    329		__bitmap_xor(dst, src1, src2, nbits);
    330}
    331
    332static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
    333			const unsigned long *src2, unsigned int nbits)
    334{
    335	if (small_const_nbits(nbits))
    336		return (*dst = *src1 & ~(*src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
    337	return __bitmap_andnot(dst, src1, src2, nbits);
    338}
    339
    340static inline void bitmap_complement(unsigned long *dst, const unsigned long *src,
    341			unsigned int nbits)
    342{
    343	if (small_const_nbits(nbits))
    344		*dst = ~(*src);
    345	else
    346		__bitmap_complement(dst, src, nbits);
    347}
    348
    349#ifdef __LITTLE_ENDIAN
    350#define BITMAP_MEM_ALIGNMENT 8
    351#else
    352#define BITMAP_MEM_ALIGNMENT (8 * sizeof(unsigned long))
    353#endif
    354#define BITMAP_MEM_MASK (BITMAP_MEM_ALIGNMENT - 1)
    355
    356static inline bool bitmap_equal(const unsigned long *src1,
    357				const unsigned long *src2, unsigned int nbits)
    358{
    359	if (small_const_nbits(nbits))
    360		return !((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
    361	if (__builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
    362	    IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
    363		return !memcmp(src1, src2, nbits / 8);
    364	return __bitmap_equal(src1, src2, nbits);
    365}
    366
    367/**
    368 * bitmap_or_equal - Check whether the or of two bitmaps is equal to a third
    369 * @src1:	Pointer to bitmap 1
    370 * @src2:	Pointer to bitmap 2 will be or'ed with bitmap 1
    371 * @src3:	Pointer to bitmap 3. Compare to the result of *@src1 | *@src2
    372 * @nbits:	number of bits in each of these bitmaps
    373 *
    374 * Returns: True if (*@src1 | *@src2) == *@src3, false otherwise
    375 */
    376static inline bool bitmap_or_equal(const unsigned long *src1,
    377				   const unsigned long *src2,
    378				   const unsigned long *src3,
    379				   unsigned int nbits)
    380{
    381	if (!small_const_nbits(nbits))
    382		return __bitmap_or_equal(src1, src2, src3, nbits);
    383
    384	return !(((*src1 | *src2) ^ *src3) & BITMAP_LAST_WORD_MASK(nbits));
    385}
    386
    387static inline bool bitmap_intersects(const unsigned long *src1,
    388				     const unsigned long *src2,
    389				     unsigned int nbits)
    390{
    391	if (small_const_nbits(nbits))
    392		return ((*src1 & *src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
    393	else
    394		return __bitmap_intersects(src1, src2, nbits);
    395}
    396
    397static inline bool bitmap_subset(const unsigned long *src1,
    398				 const unsigned long *src2, unsigned int nbits)
    399{
    400	if (small_const_nbits(nbits))
    401		return ! ((*src1 & ~(*src2)) & BITMAP_LAST_WORD_MASK(nbits));
    402	else
    403		return __bitmap_subset(src1, src2, nbits);
    404}
    405
    406static inline bool bitmap_empty(const unsigned long *src, unsigned nbits)
    407{
    408	if (small_const_nbits(nbits))
    409		return ! (*src & BITMAP_LAST_WORD_MASK(nbits));
    410
    411	return find_first_bit(src, nbits) == nbits;
    412}
    413
    414static inline bool bitmap_full(const unsigned long *src, unsigned int nbits)
    415{
    416	if (small_const_nbits(nbits))
    417		return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));
    418
    419	return find_first_zero_bit(src, nbits) == nbits;
    420}
    421
    422static __always_inline int bitmap_weight(const unsigned long *src, unsigned int nbits)
    423{
    424	if (small_const_nbits(nbits))
    425		return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
    426	return __bitmap_weight(src, nbits);
    427}
    428
    429static __always_inline void bitmap_set(unsigned long *map, unsigned int start,
    430		unsigned int nbits)
    431{
    432	if (__builtin_constant_p(nbits) && nbits == 1)
    433		__set_bit(start, map);
    434	else if (__builtin_constant_p(start & BITMAP_MEM_MASK) &&
    435		 IS_ALIGNED(start, BITMAP_MEM_ALIGNMENT) &&
    436		 __builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
    437		 IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
    438		memset((char *)map + start / 8, 0xff, nbits / 8);
    439	else
    440		__bitmap_set(map, start, nbits);
    441}
    442
    443static __always_inline void bitmap_clear(unsigned long *map, unsigned int start,
    444		unsigned int nbits)
    445{
    446	if (__builtin_constant_p(nbits) && nbits == 1)
    447		__clear_bit(start, map);
    448	else if (__builtin_constant_p(start & BITMAP_MEM_MASK) &&
    449		 IS_ALIGNED(start, BITMAP_MEM_ALIGNMENT) &&
    450		 __builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
    451		 IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
    452		memset((char *)map + start / 8, 0, nbits / 8);
    453	else
    454		__bitmap_clear(map, start, nbits);
    455}
    456
    457static inline void bitmap_shift_right(unsigned long *dst, const unsigned long *src,
    458				unsigned int shift, unsigned int nbits)
    459{
    460	if (small_const_nbits(nbits))
    461		*dst = (*src & BITMAP_LAST_WORD_MASK(nbits)) >> shift;
    462	else
    463		__bitmap_shift_right(dst, src, shift, nbits);
    464}
    465
    466static inline void bitmap_shift_left(unsigned long *dst, const unsigned long *src,
    467				unsigned int shift, unsigned int nbits)
    468{
    469	if (small_const_nbits(nbits))
    470		*dst = (*src << shift) & BITMAP_LAST_WORD_MASK(nbits);
    471	else
    472		__bitmap_shift_left(dst, src, shift, nbits);
    473}
    474
    475static inline void bitmap_replace(unsigned long *dst,
    476				  const unsigned long *old,
    477				  const unsigned long *new,
    478				  const unsigned long *mask,
    479				  unsigned int nbits)
    480{
    481	if (small_const_nbits(nbits))
    482		*dst = (*old & ~(*mask)) | (*new & *mask);
    483	else
    484		__bitmap_replace(dst, old, new, mask, nbits);
    485}
    486
    487static inline void bitmap_next_set_region(unsigned long *bitmap,
    488					  unsigned int *rs, unsigned int *re,
    489					  unsigned int end)
    490{
    491	*rs = find_next_bit(bitmap, end, *rs);
    492	*re = find_next_zero_bit(bitmap, end, *rs + 1);
    493}
    494
    495/**
    496 * BITMAP_FROM_U64() - Represent u64 value in the format suitable for bitmap.
    497 * @n: u64 value
    498 *
    499 * Linux bitmaps are internally arrays of unsigned longs, i.e. 32-bit
    500 * integers in 32-bit environment, and 64-bit integers in 64-bit one.
    501 *
    502 * There are four combinations of endianness and length of the word in linux
    503 * ABIs: LE64, BE64, LE32 and BE32.
    504 *
    505 * On 64-bit kernels 64-bit LE and BE numbers are naturally ordered in
    506 * bitmaps and therefore don't require any special handling.
    507 *
    508 * On 32-bit kernels 32-bit LE ABI orders lo word of 64-bit number in memory
    509 * prior to hi, and 32-bit BE orders hi word prior to lo. The bitmap on the
    510 * other hand is represented as an array of 32-bit words and the position of
    511 * bit N may therefore be calculated as: word #(N/32) and bit #(N%32) in that
    512 * word.  For example, bit #42 is located at 10th position of 2nd word.
    513 * It matches 32-bit LE ABI, and we can simply let the compiler store 64-bit
    514 * values in memory as it usually does. But for BE we need to swap hi and lo
    515 * words manually.
    516 *
    517 * With all that, the macro BITMAP_FROM_U64() does explicit reordering of hi and
    518 * lo parts of u64.  For LE32 it does nothing, and for BE environment it swaps
    519 * hi and lo words, as is expected by bitmap.
    520 */
    521#if __BITS_PER_LONG == 64
    522#define BITMAP_FROM_U64(n) (n)
    523#else
    524#define BITMAP_FROM_U64(n) ((unsigned long) ((u64)(n) & ULONG_MAX)), \
    525				((unsigned long) ((u64)(n) >> 32))
    526#endif
    527
    528/**
    529 * bitmap_from_u64 - Check and swap words within u64.
    530 *  @mask: source bitmap
    531 *  @dst:  destination bitmap
    532 *
    533 * In 32-bit Big Endian kernel, when using ``(u32 *)(&val)[*]``
    534 * to read u64 mask, we will get the wrong word.
    535 * That is ``(u32 *)(&val)[0]`` gets the upper 32 bits,
    536 * but we expect the lower 32-bits of u64.
    537 */
    538static inline void bitmap_from_u64(unsigned long *dst, u64 mask)
    539{
    540	bitmap_from_arr64(dst, &mask, 64);
    541}
    542
    543/**
    544 * bitmap_get_value8 - get an 8-bit value within a memory region
    545 * @map: address to the bitmap memory region
    546 * @start: bit offset of the 8-bit value; must be a multiple of 8
    547 *
    548 * Returns the 8-bit value located at the @start bit offset within the @src
    549 * memory region.
    550 */
    551static inline unsigned long bitmap_get_value8(const unsigned long *map,
    552					      unsigned long start)
    553{
    554	const size_t index = BIT_WORD(start);
    555	const unsigned long offset = start % BITS_PER_LONG;
    556
    557	return (map[index] >> offset) & 0xFF;
    558}
    559
    560/**
    561 * bitmap_set_value8 - set an 8-bit value within a memory region
    562 * @map: address to the bitmap memory region
    563 * @value: the 8-bit value; values wider than 8 bits may clobber bitmap
    564 * @start: bit offset of the 8-bit value; must be a multiple of 8
    565 */
    566static inline void bitmap_set_value8(unsigned long *map, unsigned long value,
    567				     unsigned long start)
    568{
    569	const size_t index = BIT_WORD(start);
    570	const unsigned long offset = start % BITS_PER_LONG;
    571
    572	map[index] &= ~(0xFFUL << offset);
    573	map[index] |= value << offset;
    574}
    575
    576#endif /* __ASSEMBLY__ */
    577
    578#endif /* __LINUX_BITMAP_H */