LCOV - code coverage report
Current view: top level - include/linux - bitmap.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef __LINUX_BITMAP_H
       2             : #define __LINUX_BITMAP_H
       3             : 
       4             : #ifndef __ASSEMBLY__
       5             : 
       6             : #include <linux/types.h>
       7             : #include <linux/bitops.h>
       8             : #include <linux/string.h>
       9             : #include <linux/kernel.h>
      10             : 
      11             : /*
      12             :  * bitmaps provide bit arrays that consume one or more unsigned
      13             :  * longs.  The bitmap interface and available operations are listed
      14             :  * here, in bitmap.h
      15             :  *
      16             :  * Function implementations generic to all architectures are in
      17             :  * lib/bitmap.c.  Functions implementations that are architecture
      18             :  * specific are in various include/asm-<arch>/bitops.h headers
      19             :  * and other arch/<arch> specific files.
      20             :  *
      21             :  * See lib/bitmap.c for more details.
      22             :  */
      23             : 
      24             : /*
      25             :  * The available bitmap operations and their rough meaning in the
      26             :  * case that the bitmap is a single unsigned long are thus:
      27             :  *
      28             :  * Note that nbits should be always a compile time evaluable constant.
      29             :  * Otherwise many inlines will generate horrible code.
      30             :  *
      31             :  * bitmap_zero(dst, nbits)                      *dst = 0UL
      32             :  * bitmap_fill(dst, nbits)                      *dst = ~0UL
      33             :  * bitmap_copy(dst, src, nbits)                 *dst = *src
      34             :  * bitmap_and(dst, src1, src2, nbits)           *dst = *src1 & *src2
      35             :  * bitmap_or(dst, src1, src2, nbits)            *dst = *src1 | *src2
      36             :  * bitmap_xor(dst, src1, src2, nbits)           *dst = *src1 ^ *src2
      37             :  * bitmap_andnot(dst, src1, src2, nbits)        *dst = *src1 & ~(*src2)
      38             :  * bitmap_complement(dst, src, nbits)           *dst = ~(*src)
      39             :  * bitmap_equal(src1, src2, nbits)              Are *src1 and *src2 equal?
      40             :  * bitmap_intersects(src1, src2, nbits)         Do *src1 and *src2 overlap?
      41             :  * bitmap_subset(src1, src2, nbits)             Is *src1 a subset of *src2?
      42             :  * bitmap_empty(src, nbits)                     Are all bits zero in *src?
      43             :  * bitmap_full(src, nbits)                      Are all bits set in *src?
      44             :  * bitmap_weight(src, nbits)                    Hamming Weight: number set bits
      45             :  * bitmap_set(dst, pos, nbits)                  Set specified bit area
      46             :  * bitmap_clear(dst, pos, nbits)                Clear specified bit area
      47             :  * bitmap_find_next_zero_area(buf, len, pos, n, mask)   Find bit free area
      48             :  * bitmap_shift_right(dst, src, n, nbits)       *dst = *src >> n
      49             :  * bitmap_shift_left(dst, src, n, nbits)        *dst = *src << n
      50             :  * bitmap_remap(dst, src, old, new, nbits)      *dst = map(old, new)(src)
      51             :  * bitmap_bitremap(oldbit, old, new, nbits)     newbit = map(old, new)(oldbit)
      52             :  * bitmap_onto(dst, orig, relmap, nbits)        *dst = orig relative to relmap
      53             :  * bitmap_fold(dst, orig, sz, nbits)            dst bits = orig bits mod sz
      54             :  * bitmap_scnprintf(buf, len, src, nbits)       Print bitmap src to buf
      55             :  * bitmap_parse(buf, buflen, dst, nbits)        Parse bitmap dst from kernel buf
      56             :  * bitmap_parse_user(ubuf, ulen, dst, nbits)    Parse bitmap dst from user buf
      57             :  * bitmap_scnlistprintf(buf, len, src, nbits)   Print bitmap src as list to buf
      58             :  * bitmap_parselist(buf, dst, nbits)            Parse bitmap dst from list
      59             :  * bitmap_find_free_region(bitmap, bits, order) Find and allocate bit region
      60             :  * bitmap_release_region(bitmap, pos, order)    Free specified bit region
      61             :  * bitmap_allocate_region(bitmap, pos, order)   Allocate specified bit region
      62             :  */
      63             : 
      64             : /*
      65             :  * Also the following operations in asm/bitops.h apply to bitmaps.
      66             :  *
      67             :  * set_bit(bit, addr)                   *addr |= bit
      68             :  * clear_bit(bit, addr)                 *addr &= ~bit
      69             :  * change_bit(bit, addr)                *addr ^= bit
      70             :  * test_bit(bit, addr)                  Is bit set in *addr?
      71             :  * test_and_set_bit(bit, addr)          Set bit and return old value
      72             :  * test_and_clear_bit(bit, addr)        Clear bit and return old value
      73             :  * test_and_change_bit(bit, addr)       Change bit and return old value
      74             :  * find_first_zero_bit(addr, nbits)     Position first zero bit in *addr
      75             :  * find_first_bit(addr, nbits)          Position first set bit in *addr
      76             :  * find_next_zero_bit(addr, nbits, bit) Position next zero bit in *addr >= bit
      77             :  * find_next_bit(addr, nbits, bit)      Position next set bit in *addr >= bit
      78             :  */
      79             : 
      80             : /*
      81             :  * The DECLARE_BITMAP(name,bits) macro, in linux/types.h, can be used
      82             :  * to declare an array named 'name' of just enough unsigned longs to
      83             :  * contain all bit positions from 0 to 'bits' - 1.
      84             :  */
      85             : 
      86             : /*
      87             :  * lib/bitmap.c provides these functions:
      88             :  */
      89             : 
      90             : extern int __bitmap_empty(const unsigned long *bitmap, int bits);
      91             : extern int __bitmap_full(const unsigned long *bitmap, int bits);
      92             : extern int __bitmap_equal(const unsigned long *bitmap1,
      93             :                         const unsigned long *bitmap2, int bits);
      94             : extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
      95             :                         int bits);
      96             : extern void __bitmap_shift_right(unsigned long *dst,
      97             :                         const unsigned long *src, int shift, int bits);
      98             : extern void __bitmap_shift_left(unsigned long *dst,
      99             :                         const unsigned long *src, int shift, int bits);
     100             : extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
     101             :                         const unsigned long *bitmap2, int bits);
     102             : extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
     103             :                         const unsigned long *bitmap2, int bits);
     104             : extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
     105             :                         const unsigned long *bitmap2, int bits);
     106             : extern int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
     107             :                         const unsigned long *bitmap2, int bits);
     108             : extern int __bitmap_intersects(const unsigned long *bitmap1,
     109             :                         const unsigned long *bitmap2, int bits);
     110             : extern int __bitmap_subset(const unsigned long *bitmap1,
     111             :                         const unsigned long *bitmap2, int bits);
     112             : extern int __bitmap_weight(const unsigned long *bitmap, int bits);
     113             : 
     114             : extern void bitmap_set(unsigned long *map, int i, int len);
     115             : extern void bitmap_clear(unsigned long *map, int start, int nr);
     116             : extern unsigned long bitmap_find_next_zero_area(unsigned long *map,
     117             :                                          unsigned long size,
     118             :                                          unsigned long start,
     119             :                                          unsigned int nr,
     120             :                                          unsigned long align_mask);
     121             : 
     122             : extern int bitmap_scnprintf(char *buf, unsigned int len,
     123             :                         const unsigned long *src, int nbits);
     124             : extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
     125             :                         unsigned long *dst, int nbits);
     126             : extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,
     127             :                         unsigned long *dst, int nbits);
     128             : extern int bitmap_scnlistprintf(char *buf, unsigned int len,
     129             :                         const unsigned long *src, int nbits);
     130             : extern int bitmap_parselist(const char *buf, unsigned long *maskp,
     131             :                         int nmaskbits);
     132             : extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
     133             :                 const unsigned long *old, const unsigned long *new, int bits);
     134             : extern int bitmap_bitremap(int oldbit,
     135             :                 const unsigned long *old, const unsigned long *new, int bits);
     136             : extern void bitmap_onto(unsigned long *dst, const unsigned long *orig,
     137             :                 const unsigned long *relmap, int bits);
     138             : extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
     139             :                 int sz, int bits);
     140             : extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
     141             : extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
     142             : extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
     143             : extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
     144             : 
     145             : #define BITMAP_LAST_WORD_MASK(nbits)                                    \
     146             : (                                                                       \
     147             :         ((nbits) % BITS_PER_LONG) ?                                     \
     148             :                 (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL         \
     149             : )
     150             : 
     151             : #define small_const_nbits(nbits) \
     152             :         (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
     153             : 
     154             : static inline void bitmap_zero(unsigned long *dst, int nbits)
     155             : {
     156             :         if (small_const_nbits(nbits))
     157             :                 *dst = 0UL;
     158             :         else {
     159             :                 int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
     160             :                 memset(dst, 0, len);
     161             :         }
     162             : }
     163             : 
     164             : static inline void bitmap_fill(unsigned long *dst, int nbits)
     165             : {
     166             :         size_t nlongs = BITS_TO_LONGS(nbits);
     167             :         if (!small_const_nbits(nbits)) {
     168             :                 int len = (nlongs - 1) * sizeof(unsigned long);
     169             :                 memset(dst, 0xff,  len);
     170             :         }
     171             :         dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);
     172             : }
     173             : 
     174             : static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
     175             :                         int nbits)
     176             : {
     177             :         if (small_const_nbits(nbits))
     178             :                 *dst = *src;
     179             :         else {
     180             :                 int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
     181             :                 memcpy(dst, src, len);
     182             :         }
     183             : }
     184             : 
     185             : static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
     186             :                         const unsigned long *src2, int nbits)
     187             : {
     188             :         if (small_const_nbits(nbits))
     189             :                 return (*dst = *src1 & *src2) != 0;
     190             :         return __bitmap_and(dst, src1, src2, nbits);
     191             : }
     192             : 
     193             : static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
     194             :                         const unsigned long *src2, int nbits)
     195             : {
     196             :         if (small_const_nbits(nbits))
     197             :                 *dst = *src1 | *src2;
     198             :         else
     199             :                 __bitmap_or(dst, src1, src2, nbits);
     200             : }
     201             : 
     202             : static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
     203             :                         const unsigned long *src2, int nbits)
     204             : {
     205             :         if (small_const_nbits(nbits))
     206             :                 *dst = *src1 ^ *src2;
     207             :         else
     208             :                 __bitmap_xor(dst, src1, src2, nbits);
     209             : }
     210             : 
     211             : static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
     212             :                         const unsigned long *src2, int nbits)
     213             : {
     214             :         if (small_const_nbits(nbits))
     215             :                 return (*dst = *src1 & ~(*src2)) != 0;
     216             :         return __bitmap_andnot(dst, src1, src2, nbits);
     217             : }
     218             : 
     219             : static inline void bitmap_complement(unsigned long *dst, const unsigned long *src,
     220             :                         int nbits)
     221             : {
     222             :         if (small_const_nbits(nbits))
     223             :                 *dst = ~(*src) & BITMAP_LAST_WORD_MASK(nbits);
     224             :         else
     225             :                 __bitmap_complement(dst, src, nbits);
     226             : }
     227             : 
     228             : static inline int bitmap_equal(const unsigned long *src1,
     229             :                         const unsigned long *src2, int nbits)
     230             : {
     231             :         if (small_const_nbits(nbits))
     232             :                 return ! ((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
     233             :         else
     234             :                 return __bitmap_equal(src1, src2, nbits);
     235             : }
     236             : 
     237             : static inline int bitmap_intersects(const unsigned long *src1,
     238             :                         const unsigned long *src2, int nbits)
     239             : {
     240             :         if (small_const_nbits(nbits))
     241             :                 return ((*src1 & *src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
     242             :         else
     243             :                 return __bitmap_intersects(src1, src2, nbits);
     244             : }
     245             : 
     246             : static inline int bitmap_subset(const unsigned long *src1,
     247             :                         const unsigned long *src2, int nbits)
     248             : {
     249             :         if (small_const_nbits(nbits))
     250             :                 return ! ((*src1 & ~(*src2)) & BITMAP_LAST_WORD_MASK(nbits));
     251             :         else
     252             :                 return __bitmap_subset(src1, src2, nbits);
     253             : }
     254             : 
     255             : static inline int bitmap_empty(const unsigned long *src, int nbits)
     256             : {
     257             :         if (small_const_nbits(nbits))
     258             :                 return ! (*src & BITMAP_LAST_WORD_MASK(nbits));
     259             :         else
     260             :                 return __bitmap_empty(src, nbits);
     261             : }
     262             : 
     263             : static inline int bitmap_full(const unsigned long *src, int nbits)
     264             : {
     265             :         if (small_const_nbits(nbits))
     266             :                 return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));
     267             :         else
     268             :                 return __bitmap_full(src, nbits);
     269             : }
     270             : 
     271             : static inline int bitmap_weight(const unsigned long *src, int nbits)
     272             : {
     273             :         if (small_const_nbits(nbits))
     274             :                 return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
     275             :         return __bitmap_weight(src, nbits);
     276             : }
     277             : 
     278             : static inline void bitmap_shift_right(unsigned long *dst,
     279             :                         const unsigned long *src, int n, int nbits)
     280             : {
     281             :         if (small_const_nbits(nbits))
     282             :                 *dst = *src >> n;
     283             :         else
     284             :                 __bitmap_shift_right(dst, src, n, nbits);
     285             : }
     286             : 
     287             : static inline void bitmap_shift_left(unsigned long *dst,
     288             :                         const unsigned long *src, int n, int nbits)
     289             : {
     290             :         if (small_const_nbits(nbits))
     291             :                 *dst = (*src << n) & BITMAP_LAST_WORD_MASK(nbits);
     292             :         else
     293             :                 __bitmap_shift_left(dst, src, n, nbits);
     294             : }
     295             : 
     296             : static inline int bitmap_parse(const char *buf, unsigned int buflen,
     297             :                         unsigned long *maskp, int nmaskbits)
     298             : {
     299             :         return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
     300             : }
     301           1 : 
     302             : #endif /* __ASSEMBLY__ */
     303             : 
     304             : #endif /* __LINUX_BITMAP_H */

Generated by: LCOV version 1.10