123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379 |
- /*
- This file is taken from the Linux kernel and minimally adapted for use in userspace
- */
- /*
- * lib/bitmap.c
- * Helper functions for bitmap.h.
- *
- * This source code is licensed under the GNU General Public License,
- * Version 2. See the file COPYING for more details.
- */
- #include "config.h"
- #include <unistd.h>
- #include <errno.h>
- #include <stdio.h>
- #include <stdlib.h>
- #include <ctype.h>
- #include "bitmap.h"
- #include "non-atomic.h"
- /*
- * bitmaps provide an array of bits, implemented using an an
- * array of unsigned longs. The number of valid bits in a
- * given bitmap does _not_ need to be an exact multiple of
- * BITS_PER_LONG.
- *
- * The possible unused bits in the last, partially used word
- * of a bitmap are 'don't care'. The implementation makes
- * no particular effort to keep them zero. It ensures that
- * their value will not affect the results of any operation.
- * The bitmap operations that return Boolean (bitmap_empty,
- * for example) or scalar (bitmap_weight, for example) results
- * carefully filter out these unused bits from impacting their
- * results.
- *
- * These operations actually hold to a slightly stronger rule:
- * if you don't input any bitmaps to these ops that have some
- * unused bits set, then they won't output any set unused bits
- * in output bitmaps.
- *
- * The byte ordering of bitmaps is more natural on little
- * endian architectures. See the big-endian headers
- * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h
- * for the best explanations of this ordering.
- */
- int __bitmap_empty(const unsigned long *bitmap, int bits)
- {
- int k, lim = bits/BITS_PER_LONG;
- for (k = 0; k < lim; ++k)
- if (bitmap[k])
- return 0;
- if (bits % BITS_PER_LONG)
- if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
- return 0;
- return 1;
- }
- int __bitmap_full(const unsigned long *bitmap, int bits)
- {
- int k, lim = bits/BITS_PER_LONG;
- for (k = 0; k < lim; ++k)
- if (~bitmap[k])
- return 0;
- if (bits % BITS_PER_LONG)
- if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
- return 0;
- return 1;
- }
- int __bitmap_weight(const unsigned long *bitmap, int bits)
- {
- int k, w = 0, lim = bits/BITS_PER_LONG;
- for (k = 0; k < lim; k++)
- w += hweight_long(bitmap[k]);
- if (bits % BITS_PER_LONG)
- w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
- return w;
- }
- int __bitmap_equal(const unsigned long *bitmap1,
- const unsigned long *bitmap2, int bits)
- {
- int k, lim = bits/BITS_PER_LONG;
- for (k = 0; k < lim; ++k)
- if (bitmap1[k] != bitmap2[k])
- return 0;
- if (bits % BITS_PER_LONG)
- if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
- return 0;
- return 1;
- }
- void __bitmap_complement(unsigned long *dst, const unsigned long *src, int bits)
- {
- int k, lim = bits/BITS_PER_LONG;
- for (k = 0; k < lim; ++k)
- dst[k] = ~src[k];
- if (bits % BITS_PER_LONG)
- dst[k] = ~src[k] & BITMAP_LAST_WORD_MASK(bits);
- }
- /*
- * __bitmap_shift_right - logical right shift of the bits in a bitmap
- * @dst - destination bitmap
- * @src - source bitmap
- * @nbits - shift by this many bits
- * @bits - bitmap size, in bits
- *
- * Shifting right (dividing) means moving bits in the MS -> LS bit
- * direction. Zeros are fed into the vacated MS positions and the
- * LS bits shifted off the bottom are lost.
- */
- void __bitmap_shift_right(unsigned long *dst,
- const unsigned long *src, int shift, int bits)
- {
- int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
- int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
- unsigned long mask = (1UL << left) - 1;
- for (k = 0; off + k < lim; ++k) {
- unsigned long upper, lower;
- /*
- * If shift is not word aligned, take lower rem bits of
- * word above and make them the top rem bits of result.
- */
- if (!rem || off + k + 1 >= lim)
- upper = 0;
- else {
- upper = src[off + k + 1];
- if (off + k + 1 == lim - 1 && left)
- upper &= mask;
- }
- lower = src[off + k];
- if (left && off + k == lim - 1)
- lower &= mask;
- dst[k] = upper << (BITS_PER_LONG - rem) | lower >> rem;
- if (left && k == lim - 1)
- dst[k] &= mask;
- }
- if (off)
- memset(&dst[lim - off], 0, off*sizeof(unsigned long));
- }
- /*
- * __bitmap_shift_left - logical left shift of the bits in a bitmap
- * @dst - destination bitmap
- * @src - source bitmap
- * @nbits - shift by this many bits
- * @bits - bitmap size, in bits
- *
- * Shifting left (multiplying) means moving bits in the LS -> MS
- * direction. Zeros are fed into the vacated LS bit positions
- * and those MS bits shifted off the top are lost.
- */
- void __bitmap_shift_left(unsigned long *dst,
- const unsigned long *src, int shift, int bits)
- {
- int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
- int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
- for (k = lim - off - 1; k >= 0; --k) {
- unsigned long upper, lower;
- /*
- * If shift is not word aligned, take upper rem bits of
- * word below and make them the bottom rem bits of result.
- */
- if (rem && k > 0)
- lower = src[k - 1];
- else
- lower = 0;
- upper = src[k];
- if (left && k == lim - 1)
- upper &= (1UL << left) - 1;
- dst[k + off] = lower >> (BITS_PER_LONG - rem) | upper << rem;
- if (left && k + off == lim - 1)
- dst[k + off] &= (1UL << left) - 1;
- }
- if (off)
- memset(dst, 0, off*sizeof(unsigned long));
- }
- void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
- const unsigned long *bitmap2, int bits)
- {
- int k;
- int nr = BITS_TO_LONGS(bits);
- for (k = 0; k < nr; k++)
- dst[k] = bitmap1[k] & bitmap2[k];
- }
- void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
- const unsigned long *bitmap2, int bits)
- {
- int k;
- int nr = BITS_TO_LONGS(bits);
- for (k = 0; k < nr; k++)
- dst[k] = bitmap1[k] | bitmap2[k];
- }
- void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
- const unsigned long *bitmap2, int bits)
- {
- int k;
- int nr = BITS_TO_LONGS(bits);
- for (k = 0; k < nr; k++)
- dst[k] = bitmap1[k] ^ bitmap2[k];
- }
- void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
- const unsigned long *bitmap2, int bits)
- {
- int k;
- int nr = BITS_TO_LONGS(bits);
- for (k = 0; k < nr; k++)
- dst[k] = bitmap1[k] & ~bitmap2[k];
- }
- int __bitmap_intersects(const unsigned long *bitmap1,
- const unsigned long *bitmap2, int bits)
- {
- int k, lim = bits/BITS_PER_LONG;
- for (k = 0; k < lim; ++k)
- if (bitmap1[k] & bitmap2[k])
- return 1;
- if (bits % BITS_PER_LONG)
- if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
- return 1;
- return 0;
- }
- /*
- * Bitmap printing & parsing functions: first version by Bill Irwin,
- * second version by Paul Jackson, third by Joe Korty.
- */
- #define CHUNKSZ 32
- #define nbits_to_hold_value(val) fls(val)
- #define unhex(c) (isdigit(c) ? (c - '0') : (toupper(c) - 'A' + 10))
- #define BASEDEC 10 /* fancier cpuset lists input in decimal */
- /**
- * bitmap_scnprintf - convert bitmap to an ASCII hex string.
- * @buf: byte buffer into which string is placed
- * @buflen: reserved size of @buf, in bytes
- * @maskp: pointer to bitmap to convert
- * @nmaskbits: size of bitmap, in bits
- *
- * Exactly @nmaskbits bits are displayed. Hex digits are grouped into
- * comma-separated sets of eight digits per set.
- */
- int bitmap_scnprintf(char *buf, unsigned int buflen,
- const unsigned long *maskp, int nmaskbits)
- {
- int i, word, bit, len = 0;
- unsigned long val;
- const char *sep = "";
- int chunksz;
- uint32_t chunkmask;
- int first = 1;
- chunksz = nmaskbits & (CHUNKSZ - 1);
- if (chunksz == 0)
- chunksz = CHUNKSZ;
- i = ALIGN(nmaskbits, CHUNKSZ) - CHUNKSZ;
- for (; i >= 0; i -= CHUNKSZ) {
- chunkmask = ((1ULL << chunksz) - 1);
- word = i / BITS_PER_LONG;
- bit = i % BITS_PER_LONG;
- val = (maskp[word] >> bit) & chunkmask;
- if (val!=0 || !first || i==0) {
- len += snprintf(buf+len, buflen-len, "%s%0*lx", sep,
- (chunksz+3)/4, val);
- chunksz = CHUNKSZ;
- sep = ",";
- first = 0;
- }
- }
- return len;
- }
- /**
- * __bitmap_parse - convert an ASCII hex string into a bitmap.
- * @buf: pointer to buffer containing string.
- * @buflen: buffer size in bytes. If string is smaller than this
- * then it must be terminated with a \0.
- * @is_user: location of buffer, 0 indicates kernel space
- * @maskp: pointer to bitmap array that will contain result.
- * @nmaskbits: size of bitmap, in bits.
- *
- * Commas group hex digits into chunks. Each chunk defines exactly 32
- * bits of the resultant bitmask. No chunk may specify a value larger
- * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
- * then leading 0-bits are prepended. %-EINVAL is returned for illegal
- * characters and for grouping errors such as "1,,5", ",44", "," and "".
- * Leading and trailing whitespace accepted, but not embedded whitespace.
- */
- int __bitmap_parse(const char *buf, unsigned int buflen,
- int is_user __attribute((unused)), unsigned long *maskp,
- int nmaskbits)
- {
- int c, old_c, totaldigits, ndigits, nchunks, nbits;
- uint32_t chunk;
- bitmap_zero(maskp, nmaskbits);
- nchunks = nbits = totaldigits = c = 0;
- do {
- chunk = ndigits = 0;
- /* Get the next chunk of the bitmap */
- while (buflen) {
- old_c = c;
- c = *buf++;
- buflen--;
- if (isspace(c))
- continue;
- /*
- * If the last character was a space and the current
- * character isn't '\0', we've got embedded whitespace.
- * This is a no-no, so throw an error.
- */
- if (totaldigits && c && isspace(old_c))
- return 0;
- /* A '\0' or a ',' signal the end of the chunk */
- if (c == '\0' || c == ',')
- break;
- if (!isxdigit(c))
- return -EINVAL;
- /*
- * Make sure there are at least 4 free bits in 'chunk'.
- * If not, this hexdigit will overflow 'chunk', so
- * throw an error.
- */
- if (chunk & ~((1UL << (CHUNKSZ - 4)) - 1))
- return -EOVERFLOW;
- chunk = (chunk << 4) | unhex(c);
- ndigits++; totaldigits++;
- }
- if (ndigits == 0)
- return -EINVAL;
- if (nchunks == 0 && chunk == 0)
- continue;
- __bitmap_shift_left(maskp, maskp, CHUNKSZ, nmaskbits);
- *maskp |= chunk;
- nchunks++;
- nbits += (nchunks == 1) ? nbits_to_hold_value(chunk) : CHUNKSZ;
- if (nbits > nmaskbits)
- return -EOVERFLOW;
- } while (buflen && c == ',');
- return 0;
- }
|