Back to home page

LXR

 
 

    


0001 /*
0002  * lib/bitmap.c
0003  * Helper functions for bitmap.h.
0004  *
0005  * This source code is licensed under the GNU General Public License,
0006  * Version 2.  See the file COPYING for more details.
0007  */
0008 #include <linux/export.h>
0009 #include <linux/thread_info.h>
0010 #include <linux/ctype.h>
0011 #include <linux/errno.h>
0012 #include <linux/bitmap.h>
0013 #include <linux/bitops.h>
0014 #include <linux/bug.h>
0015 #include <linux/kernel.h>
0016 #include <linux/string.h>
0017 #include <linux/uaccess.h>
0018 
0019 #include <asm/page.h>
0020 
0021 /*
0022  * bitmaps provide an array of bits, implemented using an an
0023  * array of unsigned longs.  The number of valid bits in a
0024  * given bitmap does _not_ need to be an exact multiple of
0025  * BITS_PER_LONG.
0026  *
0027  * The possible unused bits in the last, partially used word
0028  * of a bitmap are 'don't care'.  The implementation makes
0029  * no particular effort to keep them zero.  It ensures that
0030  * their value will not affect the results of any operation.
0031  * The bitmap operations that return Boolean (bitmap_empty,
0032  * for example) or scalar (bitmap_weight, for example) results
0033  * carefully filter out these unused bits from impacting their
0034  * results.
0035  *
0036  * These operations actually hold to a slightly stronger rule:
0037  * if you don't input any bitmaps to these ops that have some
0038  * unused bits set, then they won't output any set unused bits
0039  * in output bitmaps.
0040  *
0041  * The byte ordering of bitmaps is more natural on little
0042  * endian architectures.  See the big-endian headers
0043  * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h
0044  * for the best explanations of this ordering.
0045  */
0046 
0047 int __bitmap_equal(const unsigned long *bitmap1,
0048         const unsigned long *bitmap2, unsigned int bits)
0049 {
0050     unsigned int k, lim = bits/BITS_PER_LONG;
0051     for (k = 0; k < lim; ++k)
0052         if (bitmap1[k] != bitmap2[k])
0053             return 0;
0054 
0055     if (bits % BITS_PER_LONG)
0056         if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
0057             return 0;
0058 
0059     return 1;
0060 }
0061 EXPORT_SYMBOL(__bitmap_equal);
0062 
0063 void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)
0064 {
0065     unsigned int k, lim = bits/BITS_PER_LONG;
0066     for (k = 0; k < lim; ++k)
0067         dst[k] = ~src[k];
0068 
0069     if (bits % BITS_PER_LONG)
0070         dst[k] = ~src[k];
0071 }
0072 EXPORT_SYMBOL(__bitmap_complement);
0073 
0074 /**
0075  * __bitmap_shift_right - logical right shift of the bits in a bitmap
0076  *   @dst : destination bitmap
0077  *   @src : source bitmap
0078  *   @shift : shift by this many bits
0079  *   @nbits : bitmap size, in bits
0080  *
0081  * Shifting right (dividing) means moving bits in the MS -> LS bit
0082  * direction.  Zeros are fed into the vacated MS positions and the
0083  * LS bits shifted off the bottom are lost.
0084  */
0085 void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
0086             unsigned shift, unsigned nbits)
0087 {
0088     unsigned k, lim = BITS_TO_LONGS(nbits);
0089     unsigned off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
0090     unsigned long mask = BITMAP_LAST_WORD_MASK(nbits);
0091     for (k = 0; off + k < lim; ++k) {
0092         unsigned long upper, lower;
0093 
0094         /*
0095          * If shift is not word aligned, take lower rem bits of
0096          * word above and make them the top rem bits of result.
0097          */
0098         if (!rem || off + k + 1 >= lim)
0099             upper = 0;
0100         else {
0101             upper = src[off + k + 1];
0102             if (off + k + 1 == lim - 1)
0103                 upper &= mask;
0104             upper <<= (BITS_PER_LONG - rem);
0105         }
0106         lower = src[off + k];
0107         if (off + k == lim - 1)
0108             lower &= mask;
0109         lower >>= rem;
0110         dst[k] = lower | upper;
0111     }
0112     if (off)
0113         memset(&dst[lim - off], 0, off*sizeof(unsigned long));
0114 }
0115 EXPORT_SYMBOL(__bitmap_shift_right);
0116 
0117 
0118 /**
0119  * __bitmap_shift_left - logical left shift of the bits in a bitmap
0120  *   @dst : destination bitmap
0121  *   @src : source bitmap
0122  *   @shift : shift by this many bits
0123  *   @nbits : bitmap size, in bits
0124  *
0125  * Shifting left (multiplying) means moving bits in the LS -> MS
0126  * direction.  Zeros are fed into the vacated LS bit positions
0127  * and those MS bits shifted off the top are lost.
0128  */
0129 
0130 void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
0131             unsigned int shift, unsigned int nbits)
0132 {
0133     int k;
0134     unsigned int lim = BITS_TO_LONGS(nbits);
0135     unsigned int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
0136     for (k = lim - off - 1; k >= 0; --k) {
0137         unsigned long upper, lower;
0138 
0139         /*
0140          * If shift is not word aligned, take upper rem bits of
0141          * word below and make them the bottom rem bits of result.
0142          */
0143         if (rem && k > 0)
0144             lower = src[k - 1] >> (BITS_PER_LONG - rem);
0145         else
0146             lower = 0;
0147         upper = src[k] << rem;
0148         dst[k + off] = lower | upper;
0149     }
0150     if (off)
0151         memset(dst, 0, off*sizeof(unsigned long));
0152 }
0153 EXPORT_SYMBOL(__bitmap_shift_left);
0154 
0155 int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
0156                 const unsigned long *bitmap2, unsigned int bits)
0157 {
0158     unsigned int k;
0159     unsigned int lim = bits/BITS_PER_LONG;
0160     unsigned long result = 0;
0161 
0162     for (k = 0; k < lim; k++)
0163         result |= (dst[k] = bitmap1[k] & bitmap2[k]);
0164     if (bits % BITS_PER_LONG)
0165         result |= (dst[k] = bitmap1[k] & bitmap2[k] &
0166                BITMAP_LAST_WORD_MASK(bits));
0167     return result != 0;
0168 }
0169 EXPORT_SYMBOL(__bitmap_and);
0170 
0171 void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
0172                 const unsigned long *bitmap2, unsigned int bits)
0173 {
0174     unsigned int k;
0175     unsigned int nr = BITS_TO_LONGS(bits);
0176 
0177     for (k = 0; k < nr; k++)
0178         dst[k] = bitmap1[k] | bitmap2[k];
0179 }
0180 EXPORT_SYMBOL(__bitmap_or);
0181 
0182 void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
0183                 const unsigned long *bitmap2, unsigned int bits)
0184 {
0185     unsigned int k;
0186     unsigned int nr = BITS_TO_LONGS(bits);
0187 
0188     for (k = 0; k < nr; k++)
0189         dst[k] = bitmap1[k] ^ bitmap2[k];
0190 }
0191 EXPORT_SYMBOL(__bitmap_xor);
0192 
0193 int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
0194                 const unsigned long *bitmap2, unsigned int bits)
0195 {
0196     unsigned int k;
0197     unsigned int lim = bits/BITS_PER_LONG;
0198     unsigned long result = 0;
0199 
0200     for (k = 0; k < lim; k++)
0201         result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
0202     if (bits % BITS_PER_LONG)
0203         result |= (dst[k] = bitmap1[k] & ~bitmap2[k] &
0204                BITMAP_LAST_WORD_MASK(bits));
0205     return result != 0;
0206 }
0207 EXPORT_SYMBOL(__bitmap_andnot);
0208 
0209 int __bitmap_intersects(const unsigned long *bitmap1,
0210             const unsigned long *bitmap2, unsigned int bits)
0211 {
0212     unsigned int k, lim = bits/BITS_PER_LONG;
0213     for (k = 0; k < lim; ++k)
0214         if (bitmap1[k] & bitmap2[k])
0215             return 1;
0216 
0217     if (bits % BITS_PER_LONG)
0218         if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
0219             return 1;
0220     return 0;
0221 }
0222 EXPORT_SYMBOL(__bitmap_intersects);
0223 
0224 int __bitmap_subset(const unsigned long *bitmap1,
0225             const unsigned long *bitmap2, unsigned int bits)
0226 {
0227     unsigned int k, lim = bits/BITS_PER_LONG;
0228     for (k = 0; k < lim; ++k)
0229         if (bitmap1[k] & ~bitmap2[k])
0230             return 0;
0231 
0232     if (bits % BITS_PER_LONG)
0233         if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
0234             return 0;
0235     return 1;
0236 }
0237 EXPORT_SYMBOL(__bitmap_subset);
0238 
0239 int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)
0240 {
0241     unsigned int k, lim = bits/BITS_PER_LONG;
0242     int w = 0;
0243 
0244     for (k = 0; k < lim; k++)
0245         w += hweight_long(bitmap[k]);
0246 
0247     if (bits % BITS_PER_LONG)
0248         w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
0249 
0250     return w;
0251 }
0252 EXPORT_SYMBOL(__bitmap_weight);
0253 
0254 void bitmap_set(unsigned long *map, unsigned int start, int len)
0255 {
0256     unsigned long *p = map + BIT_WORD(start);
0257     const unsigned int size = start + len;
0258     int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
0259     unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
0260 
0261     while (len - bits_to_set >= 0) {
0262         *p |= mask_to_set;
0263         len -= bits_to_set;
0264         bits_to_set = BITS_PER_LONG;
0265         mask_to_set = ~0UL;
0266         p++;
0267     }
0268     if (len) {
0269         mask_to_set &= BITMAP_LAST_WORD_MASK(size);
0270         *p |= mask_to_set;
0271     }
0272 }
0273 EXPORT_SYMBOL(bitmap_set);
0274 
0275 void bitmap_clear(unsigned long *map, unsigned int start, int len)
0276 {
0277     unsigned long *p = map + BIT_WORD(start);
0278     const unsigned int size = start + len;
0279     int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
0280     unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
0281 
0282     while (len - bits_to_clear >= 0) {
0283         *p &= ~mask_to_clear;
0284         len -= bits_to_clear;
0285         bits_to_clear = BITS_PER_LONG;
0286         mask_to_clear = ~0UL;
0287         p++;
0288     }
0289     if (len) {
0290         mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
0291         *p &= ~mask_to_clear;
0292     }
0293 }
0294 EXPORT_SYMBOL(bitmap_clear);
0295 
0296 /**
0297  * bitmap_find_next_zero_area_off - find a contiguous aligned zero area
0298  * @map: The address to base the search on
0299  * @size: The bitmap size in bits
0300  * @start: The bitnumber to start searching at
0301  * @nr: The number of zeroed bits we're looking for
0302  * @align_mask: Alignment mask for zero area
0303  * @align_offset: Alignment offset for zero area.
0304  *
0305  * The @align_mask should be one less than a power of 2; the effect is that
0306  * the bit offset of all zero areas this function finds plus @align_offset
0307  * is multiple of that power of 2.
0308  */
0309 unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
0310                          unsigned long size,
0311                          unsigned long start,
0312                          unsigned int nr,
0313                          unsigned long align_mask,
0314                          unsigned long align_offset)
0315 {
0316     unsigned long index, end, i;
0317 again:
0318     index = find_next_zero_bit(map, size, start);
0319 
0320     /* Align allocation */
0321     index = __ALIGN_MASK(index + align_offset, align_mask) - align_offset;
0322 
0323     end = index + nr;
0324     if (end > size)
0325         return end;
0326     i = find_next_bit(map, end, index);
0327     if (i < end) {
0328         start = i + 1;
0329         goto again;
0330     }
0331     return index;
0332 }
0333 EXPORT_SYMBOL(bitmap_find_next_zero_area_off);
0334 
0335 /*
0336  * Bitmap printing & parsing functions: first version by Nadia Yvette Chambers,
0337  * second version by Paul Jackson, third by Joe Korty.
0338  */
0339 
0340 #define CHUNKSZ             32
0341 #define nbits_to_hold_value(val)    fls(val)
0342 #define BASEDEC 10      /* fancier cpuset lists input in decimal */
0343 
0344 /**
0345  * __bitmap_parse - convert an ASCII hex string into a bitmap.
0346  * @buf: pointer to buffer containing string.
0347  * @buflen: buffer size in bytes.  If string is smaller than this
0348  *    then it must be terminated with a \0.
0349  * @is_user: location of buffer, 0 indicates kernel space
0350  * @maskp: pointer to bitmap array that will contain result.
0351  * @nmaskbits: size of bitmap, in bits.
0352  *
0353  * Commas group hex digits into chunks.  Each chunk defines exactly 32
0354  * bits of the resultant bitmask.  No chunk may specify a value larger
0355  * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
0356  * then leading 0-bits are prepended.  %-EINVAL is returned for illegal
0357  * characters and for grouping errors such as "1,,5", ",44", "," and "".
0358  * Leading and trailing whitespace accepted, but not embedded whitespace.
0359  */
0360 int __bitmap_parse(const char *buf, unsigned int buflen,
0361         int is_user, unsigned long *maskp,
0362         int nmaskbits)
0363 {
0364     int c, old_c, totaldigits, ndigits, nchunks, nbits;
0365     u32 chunk;
0366     const char __user __force *ubuf = (const char __user __force *)buf;
0367 
0368     bitmap_zero(maskp, nmaskbits);
0369 
0370     nchunks = nbits = totaldigits = c = 0;
0371     do {
0372         chunk = 0;
0373         ndigits = totaldigits;
0374 
0375         /* Get the next chunk of the bitmap */
0376         while (buflen) {
0377             old_c = c;
0378             if (is_user) {
0379                 if (__get_user(c, ubuf++))
0380                     return -EFAULT;
0381             }
0382             else
0383                 c = *buf++;
0384             buflen--;
0385             if (isspace(c))
0386                 continue;
0387 
0388             /*
0389              * If the last character was a space and the current
0390              * character isn't '\0', we've got embedded whitespace.
0391              * This is a no-no, so throw an error.
0392              */
0393             if (totaldigits && c && isspace(old_c))
0394                 return -EINVAL;
0395 
0396             /* A '\0' or a ',' signal the end of the chunk */
0397             if (c == '\0' || c == ',')
0398                 break;
0399 
0400             if (!isxdigit(c))
0401                 return -EINVAL;
0402 
0403             /*
0404              * Make sure there are at least 4 free bits in 'chunk'.
0405              * If not, this hexdigit will overflow 'chunk', so
0406              * throw an error.
0407              */
0408             if (chunk & ~((1UL << (CHUNKSZ - 4)) - 1))
0409                 return -EOVERFLOW;
0410 
0411             chunk = (chunk << 4) | hex_to_bin(c);
0412             totaldigits++;
0413         }
0414         if (ndigits == totaldigits)
0415             return -EINVAL;
0416         if (nchunks == 0 && chunk == 0)
0417             continue;
0418 
0419         __bitmap_shift_left(maskp, maskp, CHUNKSZ, nmaskbits);
0420         *maskp |= chunk;
0421         nchunks++;
0422         nbits += (nchunks == 1) ? nbits_to_hold_value(chunk) : CHUNKSZ;
0423         if (nbits > nmaskbits)
0424             return -EOVERFLOW;
0425     } while (buflen && c == ',');
0426 
0427     return 0;
0428 }
0429 EXPORT_SYMBOL(__bitmap_parse);
0430 
0431 /**
0432  * bitmap_parse_user - convert an ASCII hex string in a user buffer into a bitmap
0433  *
0434  * @ubuf: pointer to user buffer containing string.
0435  * @ulen: buffer size in bytes.  If string is smaller than this
0436  *    then it must be terminated with a \0.
0437  * @maskp: pointer to bitmap array that will contain result.
0438  * @nmaskbits: size of bitmap, in bits.
0439  *
0440  * Wrapper for __bitmap_parse(), providing it with user buffer.
0441  *
0442  * We cannot have this as an inline function in bitmap.h because it needs
0443  * linux/uaccess.h to get the access_ok() declaration and this causes
0444  * cyclic dependencies.
0445  */
0446 int bitmap_parse_user(const char __user *ubuf,
0447             unsigned int ulen, unsigned long *maskp,
0448             int nmaskbits)
0449 {
0450     if (!access_ok(VERIFY_READ, ubuf, ulen))
0451         return -EFAULT;
0452     return __bitmap_parse((const char __force *)ubuf,
0453                 ulen, 1, maskp, nmaskbits);
0454 
0455 }
0456 EXPORT_SYMBOL(bitmap_parse_user);
0457 
0458 /**
0459  * bitmap_print_to_pagebuf - convert bitmap to list or hex format ASCII string
0460  * @list: indicates whether the bitmap must be list
0461  * @buf: page aligned buffer into which string is placed
0462  * @maskp: pointer to bitmap to convert
0463  * @nmaskbits: size of bitmap, in bits
0464  *
0465  * Output format is a comma-separated list of decimal numbers and
0466  * ranges if list is specified or hex digits grouped into comma-separated
0467  * sets of 8 digits/set. Returns the number of characters written to buf.
0468  *
0469  * It is assumed that @buf is a pointer into a PAGE_SIZE area and that
0470  * sufficient storage remains at @buf to accommodate the
0471  * bitmap_print_to_pagebuf() output.
0472  */
0473 int bitmap_print_to_pagebuf(bool list, char *buf, const unsigned long *maskp,
0474                 int nmaskbits)
0475 {
0476     ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
0477     int n = 0;
0478 
0479     if (len > 1)
0480         n = list ? scnprintf(buf, len, "%*pbl\n", nmaskbits, maskp) :
0481                scnprintf(buf, len, "%*pb\n", nmaskbits, maskp);
0482     return n;
0483 }
0484 EXPORT_SYMBOL(bitmap_print_to_pagebuf);
0485 
0486 /**
0487  * __bitmap_parselist - convert list format ASCII string to bitmap
0488  * @buf: read nul-terminated user string from this buffer
0489  * @buflen: buffer size in bytes.  If string is smaller than this
0490  *    then it must be terminated with a \0.
0491  * @is_user: location of buffer, 0 indicates kernel space
0492  * @maskp: write resulting mask here
0493  * @nmaskbits: number of bits in mask to be written
0494  *
0495  * Input format is a comma-separated list of decimal numbers and
0496  * ranges.  Consecutively set bits are shown as two hyphen-separated
0497  * decimal numbers, the smallest and largest bit numbers set in
0498  * the range.
0499  * Optionally each range can be postfixed to denote that only parts of it
0500  * should be set. The range will divided to groups of specific size.
0501  * From each group will be used only defined amount of bits.
0502  * Syntax: range:used_size/group_size
0503  * Example: 0-1023:2/256 ==> 0,1,256,257,512,513,768,769
0504  *
0505  * Returns 0 on success, -errno on invalid input strings.
0506  * Error values:
0507  *    %-EINVAL: second number in range smaller than first
0508  *    %-EINVAL: invalid character in string
0509  *    %-ERANGE: bit number specified too large for mask
0510  */
0511 static int __bitmap_parselist(const char *buf, unsigned int buflen,
0512         int is_user, unsigned long *maskp,
0513         int nmaskbits)
0514 {
0515     unsigned int a, b, old_a, old_b;
0516     unsigned int group_size, used_size;
0517     int c, old_c, totaldigits, ndigits;
0518     const char __user __force *ubuf = (const char __user __force *)buf;
0519     int at_start, in_range, in_partial_range;
0520 
0521     totaldigits = c = 0;
0522     old_a = old_b = 0;
0523     group_size = used_size = 0;
0524     bitmap_zero(maskp, nmaskbits);
0525     do {
0526         at_start = 1;
0527         in_range = 0;
0528         in_partial_range = 0;
0529         a = b = 0;
0530         ndigits = totaldigits;
0531 
0532         /* Get the next cpu# or a range of cpu#'s */
0533         while (buflen) {
0534             old_c = c;
0535             if (is_user) {
0536                 if (__get_user(c, ubuf++))
0537                     return -EFAULT;
0538             } else
0539                 c = *buf++;
0540             buflen--;
0541             if (isspace(c))
0542                 continue;
0543 
0544             /* A '\0' or a ',' signal the end of a cpu# or range */
0545             if (c == '\0' || c == ',')
0546                 break;
0547             /*
0548             * whitespaces between digits are not allowed,
0549             * but it's ok if whitespaces are on head or tail.
0550             * when old_c is whilespace,
0551             * if totaldigits == ndigits, whitespace is on head.
0552             * if whitespace is on tail, it should not run here.
0553             * as c was ',' or '\0',
0554             * the last code line has broken the current loop.
0555             */
0556             if ((totaldigits != ndigits) && isspace(old_c))
0557                 return -EINVAL;
0558 
0559             if (c == '/') {
0560                 used_size = a;
0561                 at_start = 1;
0562                 in_range = 0;
0563                 a = b = 0;
0564                 continue;
0565             }
0566 
0567             if (c == ':') {
0568                 old_a = a;
0569                 old_b = b;
0570                 at_start = 1;
0571                 in_range = 0;
0572                 in_partial_range = 1;
0573                 a = b = 0;
0574                 continue;
0575             }
0576 
0577             if (c == '-') {
0578                 if (at_start || in_range)
0579                     return -EINVAL;
0580                 b = 0;
0581                 in_range = 1;
0582                 at_start = 1;
0583                 continue;
0584             }
0585 
0586             if (!isdigit(c))
0587                 return -EINVAL;
0588 
0589             b = b * 10 + (c - '0');
0590             if (!in_range)
0591                 a = b;
0592             at_start = 0;
0593             totaldigits++;
0594         }
0595         if (ndigits == totaldigits)
0596             continue;
0597         if (in_partial_range) {
0598             group_size = a;
0599             a = old_a;
0600             b = old_b;
0601             old_a = old_b = 0;
0602         }
0603         /* if no digit is after '-', it's wrong*/
0604         if (at_start && in_range)
0605             return -EINVAL;
0606         if (!(a <= b) || !(used_size <= group_size))
0607             return -EINVAL;
0608         if (b >= nmaskbits)
0609             return -ERANGE;
0610         while (a <= b) {
0611             if (in_partial_range) {
0612                 static int pos_in_group = 1;
0613 
0614                 if (pos_in_group <= used_size)
0615                     set_bit(a, maskp);
0616 
0617                 if (a == b || ++pos_in_group > group_size)
0618                     pos_in_group = 1;
0619             } else
0620                 set_bit(a, maskp);
0621             a++;
0622         }
0623     } while (buflen && c == ',');
0624     return 0;
0625 }
0626 
0627 int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
0628 {
0629     char *nl  = strchrnul(bp, '\n');
0630     int len = nl - bp;
0631 
0632     return __bitmap_parselist(bp, len, 0, maskp, nmaskbits);
0633 }
0634 EXPORT_SYMBOL(bitmap_parselist);
0635 
0636 
0637 /**
0638  * bitmap_parselist_user()
0639  *
0640  * @ubuf: pointer to user buffer containing string.
0641  * @ulen: buffer size in bytes.  If string is smaller than this
0642  *    then it must be terminated with a \0.
0643  * @maskp: pointer to bitmap array that will contain result.
0644  * @nmaskbits: size of bitmap, in bits.
0645  *
0646  * Wrapper for bitmap_parselist(), providing it with user buffer.
0647  *
0648  * We cannot have this as an inline function in bitmap.h because it needs
0649  * linux/uaccess.h to get the access_ok() declaration and this causes
0650  * cyclic dependencies.
0651  */
0652 int bitmap_parselist_user(const char __user *ubuf,
0653             unsigned int ulen, unsigned long *maskp,
0654             int nmaskbits)
0655 {
0656     if (!access_ok(VERIFY_READ, ubuf, ulen))
0657         return -EFAULT;
0658     return __bitmap_parselist((const char __force *)ubuf,
0659                     ulen, 1, maskp, nmaskbits);
0660 }
0661 EXPORT_SYMBOL(bitmap_parselist_user);
0662 
0663 
0664 /**
0665  * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
0666  *  @buf: pointer to a bitmap
0667  *  @pos: a bit position in @buf (0 <= @pos < @nbits)
0668  *  @nbits: number of valid bit positions in @buf
0669  *
0670  * Map the bit at position @pos in @buf (of length @nbits) to the
0671  * ordinal of which set bit it is.  If it is not set or if @pos
0672  * is not a valid bit position, map to -1.
0673  *
0674  * If for example, just bits 4 through 7 are set in @buf, then @pos
0675  * values 4 through 7 will get mapped to 0 through 3, respectively,
0676  * and other @pos values will get mapped to -1.  When @pos value 7
0677  * gets mapped to (returns) @ord value 3 in this example, that means
0678  * that bit 7 is the 3rd (starting with 0th) set bit in @buf.
0679  *
0680  * The bit positions 0 through @bits are valid positions in @buf.
0681  */
0682 static int bitmap_pos_to_ord(const unsigned long *buf, unsigned int pos, unsigned int nbits)
0683 {
0684     if (pos >= nbits || !test_bit(pos, buf))
0685         return -1;
0686 
0687     return __bitmap_weight(buf, pos);
0688 }
0689 
0690 /**
0691  * bitmap_ord_to_pos - find position of n-th set bit in bitmap
0692  *  @buf: pointer to bitmap
0693  *  @ord: ordinal bit position (n-th set bit, n >= 0)
0694  *  @nbits: number of valid bit positions in @buf
0695  *
0696  * Map the ordinal offset of bit @ord in @buf to its position in @buf.
0697  * Value of @ord should be in range 0 <= @ord < weight(buf). If @ord
0698  * >= weight(buf), returns @nbits.
0699  *
0700  * If for example, just bits 4 through 7 are set in @buf, then @ord
0701  * values 0 through 3 will get mapped to 4 through 7, respectively,
0702  * and all other @ord values returns @nbits.  When @ord value 3
0703  * gets mapped to (returns) @pos value 7 in this example, that means
0704  * that the 3rd set bit (starting with 0th) is at position 7 in @buf.
0705  *
0706  * The bit positions 0 through @nbits-1 are valid positions in @buf.
0707  */
0708 unsigned int bitmap_ord_to_pos(const unsigned long *buf, unsigned int ord, unsigned int nbits)
0709 {
0710     unsigned int pos;
0711 
0712     for (pos = find_first_bit(buf, nbits);
0713          pos < nbits && ord;
0714          pos = find_next_bit(buf, nbits, pos + 1))
0715         ord--;
0716 
0717     return pos;
0718 }
0719 
0720 /**
0721  * bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap
0722  *  @dst: remapped result
0723  *  @src: subset to be remapped
0724  *  @old: defines domain of map
0725  *  @new: defines range of map
0726  *  @nbits: number of bits in each of these bitmaps
0727  *
0728  * Let @old and @new define a mapping of bit positions, such that
0729  * whatever position is held by the n-th set bit in @old is mapped
0730  * to the n-th set bit in @new.  In the more general case, allowing
0731  * for the possibility that the weight 'w' of @new is less than the
0732  * weight of @old, map the position of the n-th set bit in @old to
0733  * the position of the m-th set bit in @new, where m == n % w.
0734  *
0735  * If either of the @old and @new bitmaps are empty, or if @src and
0736  * @dst point to the same location, then this routine copies @src
0737  * to @dst.
0738  *
0739  * The positions of unset bits in @old are mapped to themselves
0740  * (the identify map).
0741  *
0742  * Apply the above specified mapping to @src, placing the result in
0743  * @dst, clearing any bits previously set in @dst.
0744  *
0745  * For example, lets say that @old has bits 4 through 7 set, and
0746  * @new has bits 12 through 15 set.  This defines the mapping of bit
0747  * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
0748  * bit positions unchanged.  So if say @src comes into this routine
0749  * with bits 1, 5 and 7 set, then @dst should leave with bits 1,
0750  * 13 and 15 set.
0751  */
0752 void bitmap_remap(unsigned long *dst, const unsigned long *src,
0753         const unsigned long *old, const unsigned long *new,
0754         unsigned int nbits)
0755 {
0756     unsigned int oldbit, w;
0757 
0758     if (dst == src)     /* following doesn't handle inplace remaps */
0759         return;
0760     bitmap_zero(dst, nbits);
0761 
0762     w = bitmap_weight(new, nbits);
0763     for_each_set_bit(oldbit, src, nbits) {
0764         int n = bitmap_pos_to_ord(old, oldbit, nbits);
0765 
0766         if (n < 0 || w == 0)
0767             set_bit(oldbit, dst);   /* identity map */
0768         else
0769             set_bit(bitmap_ord_to_pos(new, n % w, nbits), dst);
0770     }
0771 }
0772 EXPORT_SYMBOL(bitmap_remap);
0773 
0774 /**
0775  * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit
0776  *  @oldbit: bit position to be mapped
0777  *  @old: defines domain of map
0778  *  @new: defines range of map
0779  *  @bits: number of bits in each of these bitmaps
0780  *
0781  * Let @old and @new define a mapping of bit positions, such that
0782  * whatever position is held by the n-th set bit in @old is mapped
0783  * to the n-th set bit in @new.  In the more general case, allowing
0784  * for the possibility that the weight 'w' of @new is less than the
0785  * weight of @old, map the position of the n-th set bit in @old to
0786  * the position of the m-th set bit in @new, where m == n % w.
0787  *
0788  * The positions of unset bits in @old are mapped to themselves
0789  * (the identify map).
0790  *
0791  * Apply the above specified mapping to bit position @oldbit, returning
0792  * the new bit position.
0793  *
0794  * For example, lets say that @old has bits 4 through 7 set, and
0795  * @new has bits 12 through 15 set.  This defines the mapping of bit
0796  * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
0797  * bit positions unchanged.  So if say @oldbit is 5, then this routine
0798  * returns 13.
0799  */
0800 int bitmap_bitremap(int oldbit, const unsigned long *old,
0801                 const unsigned long *new, int bits)
0802 {
0803     int w = bitmap_weight(new, bits);
0804     int n = bitmap_pos_to_ord(old, oldbit, bits);
0805     if (n < 0 || w == 0)
0806         return oldbit;
0807     else
0808         return bitmap_ord_to_pos(new, n % w, bits);
0809 }
0810 EXPORT_SYMBOL(bitmap_bitremap);
0811 
0812 /**
0813  * bitmap_onto - translate one bitmap relative to another
0814  *  @dst: resulting translated bitmap
0815  *  @orig: original untranslated bitmap
0816  *  @relmap: bitmap relative to which translated
0817  *  @bits: number of bits in each of these bitmaps
0818  *
0819  * Set the n-th bit of @dst iff there exists some m such that the
0820  * n-th bit of @relmap is set, the m-th bit of @orig is set, and
0821  * the n-th bit of @relmap is also the m-th _set_ bit of @relmap.
0822  * (If you understood the previous sentence the first time your
0823  * read it, you're overqualified for your current job.)
0824  *
0825  * In other words, @orig is mapped onto (surjectively) @dst,
0826  * using the map { <n, m> | the n-th bit of @relmap is the
0827  * m-th set bit of @relmap }.
0828  *
0829  * Any set bits in @orig above bit number W, where W is the
0830  * weight of (number of set bits in) @relmap are mapped nowhere.
0831  * In particular, if for all bits m set in @orig, m >= W, then
0832  * @dst will end up empty.  In situations where the possibility
0833  * of such an empty result is not desired, one way to avoid it is
0834  * to use the bitmap_fold() operator, below, to first fold the
0835  * @orig bitmap over itself so that all its set bits x are in the
0836  * range 0 <= x < W.  The bitmap_fold() operator does this by
0837  * setting the bit (m % W) in @dst, for each bit (m) set in @orig.
0838  *
0839  * Example [1] for bitmap_onto():
0840  *  Let's say @relmap has bits 30-39 set, and @orig has bits
0841  *  1, 3, 5, 7, 9 and 11 set.  Then on return from this routine,
0842  *  @dst will have bits 31, 33, 35, 37 and 39 set.
0843  *
0844  *  When bit 0 is set in @orig, it means turn on the bit in
0845  *  @dst corresponding to whatever is the first bit (if any)
0846  *  that is turned on in @relmap.  Since bit 0 was off in the
0847  *  above example, we leave off that bit (bit 30) in @dst.
0848  *
0849  *  When bit 1 is set in @orig (as in the above example), it
0850  *  means turn on the bit in @dst corresponding to whatever
0851  *  is the second bit that is turned on in @relmap.  The second
0852  *  bit in @relmap that was turned on in the above example was
0853  *  bit 31, so we turned on bit 31 in @dst.
0854  *
0855  *  Similarly, we turned on bits 33, 35, 37 and 39 in @dst,
0856  *  because they were the 4th, 6th, 8th and 10th set bits
0857  *  set in @relmap, and the 4th, 6th, 8th and 10th bits of
0858  *  @orig (i.e. bits 3, 5, 7 and 9) were also set.
0859  *
0860  *  When bit 11 is set in @orig, it means turn on the bit in
0861  *  @dst corresponding to whatever is the twelfth bit that is
0862  *  turned on in @relmap.  In the above example, there were
0863  *  only ten bits turned on in @relmap (30..39), so that bit
0864  *  11 was set in @orig had no affect on @dst.
0865  *
0866  * Example [2] for bitmap_fold() + bitmap_onto():
0867  *  Let's say @relmap has these ten bits set:
0868  *      40 41 42 43 45 48 53 61 74 95
0869  *  (for the curious, that's 40 plus the first ten terms of the
0870  *  Fibonacci sequence.)
0871  *
0872  *  Further lets say we use the following code, invoking
0873  *  bitmap_fold() then bitmap_onto, as suggested above to
0874  *  avoid the possibility of an empty @dst result:
0875  *
0876  *  unsigned long *tmp; // a temporary bitmap's bits
0877  *
0878  *  bitmap_fold(tmp, orig, bitmap_weight(relmap, bits), bits);
0879  *  bitmap_onto(dst, tmp, relmap, bits);
0880  *
0881  *  Then this table shows what various values of @dst would be, for
0882  *  various @orig's.  I list the zero-based positions of each set bit.
0883  *  The tmp column shows the intermediate result, as computed by
0884  *  using bitmap_fold() to fold the @orig bitmap modulo ten
0885  *  (the weight of @relmap).
0886  *
0887  *      @orig           tmp            @dst
0888  *      0                0             40
0889  *      1                1             41
0890  *      9                9             95
0891  *      10               0             40 (*)
0892  *      1 3 5 7          1 3 5 7       41 43 48 61
0893  *      0 1 2 3 4        0 1 2 3 4     40 41 42 43 45
0894  *      0 9 18 27        0 9 8 7       40 61 74 95
0895  *      0 10 20 30       0             40
0896  *      0 11 22 33       0 1 2 3       40 41 42 43
0897  *      0 12 24 36       0 2 4 6       40 42 45 53
0898  *      78 102 211       1 2 8         41 42 74 (*)
0899  *
0900  * (*) For these marked lines, if we hadn't first done bitmap_fold()
0901  *     into tmp, then the @dst result would have been empty.
0902  *
0903  * If either of @orig or @relmap is empty (no set bits), then @dst
0904  * will be returned empty.
0905  *
0906  * If (as explained above) the only set bits in @orig are in positions
0907  * m where m >= W, (where W is the weight of @relmap) then @dst will
0908  * once again be returned empty.
0909  *
0910  * All bits in @dst not set by the above rule are cleared.
0911  */
0912 void bitmap_onto(unsigned long *dst, const unsigned long *orig,
0913             const unsigned long *relmap, unsigned int bits)
0914 {
0915     unsigned int n, m;  /* same meaning as in above comment */
0916 
0917     if (dst == orig)    /* following doesn't handle inplace mappings */
0918         return;
0919     bitmap_zero(dst, bits);
0920 
0921     /*
0922      * The following code is a more efficient, but less
0923      * obvious, equivalent to the loop:
0924      *  for (m = 0; m < bitmap_weight(relmap, bits); m++) {
0925      *      n = bitmap_ord_to_pos(orig, m, bits);
0926      *      if (test_bit(m, orig))
0927      *          set_bit(n, dst);
0928      *  }
0929      */
0930 
0931     m = 0;
0932     for_each_set_bit(n, relmap, bits) {
0933         /* m == bitmap_pos_to_ord(relmap, n, bits) */
0934         if (test_bit(m, orig))
0935             set_bit(n, dst);
0936         m++;
0937     }
0938 }
0939 EXPORT_SYMBOL(bitmap_onto);
0940 
0941 /**
0942  * bitmap_fold - fold larger bitmap into smaller, modulo specified size
0943  *  @dst: resulting smaller bitmap
0944  *  @orig: original larger bitmap
0945  *  @sz: specified size
0946  *  @nbits: number of bits in each of these bitmaps
0947  *
0948  * For each bit oldbit in @orig, set bit oldbit mod @sz in @dst.
0949  * Clear all other bits in @dst.  See further the comment and
0950  * Example [2] for bitmap_onto() for why and how to use this.
0951  */
0952 void bitmap_fold(unsigned long *dst, const unsigned long *orig,
0953             unsigned int sz, unsigned int nbits)
0954 {
0955     unsigned int oldbit;
0956 
0957     if (dst == orig)    /* following doesn't handle inplace mappings */
0958         return;
0959     bitmap_zero(dst, nbits);
0960 
0961     for_each_set_bit(oldbit, orig, nbits)
0962         set_bit(oldbit % sz, dst);
0963 }
0964 EXPORT_SYMBOL(bitmap_fold);
0965 
0966 /*
0967  * Common code for bitmap_*_region() routines.
0968  *  bitmap: array of unsigned longs corresponding to the bitmap
0969  *  pos: the beginning of the region
0970  *  order: region size (log base 2 of number of bits)
0971  *  reg_op: operation(s) to perform on that region of bitmap
0972  *
0973  * Can set, verify and/or release a region of bits in a bitmap,
0974  * depending on which combination of REG_OP_* flag bits is set.
0975  *
0976  * A region of a bitmap is a sequence of bits in the bitmap, of
0977  * some size '1 << order' (a power of two), aligned to that same
0978  * '1 << order' power of two.
0979  *
0980  * Returns 1 if REG_OP_ISFREE succeeds (region is all zero bits).
0981  * Returns 0 in all other cases and reg_ops.
0982  */
0983 
0984 enum {
0985     REG_OP_ISFREE,      /* true if region is all zero bits */
0986     REG_OP_ALLOC,       /* set all bits in region */
0987     REG_OP_RELEASE,     /* clear all bits in region */
0988 };
0989 
0990 static int __reg_op(unsigned long *bitmap, unsigned int pos, int order, int reg_op)
0991 {
0992     int nbits_reg;      /* number of bits in region */
0993     int index;      /* index first long of region in bitmap */
0994     int offset;     /* bit offset region in bitmap[index] */
0995     int nlongs_reg;     /* num longs spanned by region in bitmap */
0996     int nbitsinlong;    /* num bits of region in each spanned long */
0997     unsigned long mask; /* bitmask for one long of region */
0998     int i;          /* scans bitmap by longs */
0999     int ret = 0;        /* return value */
1000 
1001     /*
1002      * Either nlongs_reg == 1 (for small orders that fit in one long)
1003      * or (offset == 0 && mask == ~0UL) (for larger multiword orders.)
1004      */
1005     nbits_reg = 1 << order;
1006     index = pos / BITS_PER_LONG;
1007     offset = pos - (index * BITS_PER_LONG);
1008     nlongs_reg = BITS_TO_LONGS(nbits_reg);
1009     nbitsinlong = min(nbits_reg,  BITS_PER_LONG);
1010 
1011     /*
1012      * Can't do "mask = (1UL << nbitsinlong) - 1", as that
1013      * overflows if nbitsinlong == BITS_PER_LONG.
1014      */
1015     mask = (1UL << (nbitsinlong - 1));
1016     mask += mask - 1;
1017     mask <<= offset;
1018 
1019     switch (reg_op) {
1020     case REG_OP_ISFREE:
1021         for (i = 0; i < nlongs_reg; i++) {
1022             if (bitmap[index + i] & mask)
1023                 goto done;
1024         }
1025         ret = 1;    /* all bits in region free (zero) */
1026         break;
1027 
1028     case REG_OP_ALLOC:
1029         for (i = 0; i < nlongs_reg; i++)
1030             bitmap[index + i] |= mask;
1031         break;
1032 
1033     case REG_OP_RELEASE:
1034         for (i = 0; i < nlongs_reg; i++)
1035             bitmap[index + i] &= ~mask;
1036         break;
1037     }
1038 done:
1039     return ret;
1040 }
1041 
1042 /**
1043  * bitmap_find_free_region - find a contiguous aligned mem region
1044  *  @bitmap: array of unsigned longs corresponding to the bitmap
1045  *  @bits: number of bits in the bitmap
1046  *  @order: region size (log base 2 of number of bits) to find
1047  *
1048  * Find a region of free (zero) bits in a @bitmap of @bits bits and
1049  * allocate them (set them to one).  Only consider regions of length
1050  * a power (@order) of two, aligned to that power of two, which
1051  * makes the search algorithm much faster.
1052  *
1053  * Return the bit offset in bitmap of the allocated region,
1054  * or -errno on failure.
1055  */
1056 int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order)
1057 {
1058     unsigned int pos, end;      /* scans bitmap by regions of size order */
1059 
1060     for (pos = 0 ; (end = pos + (1U << order)) <= bits; pos = end) {
1061         if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
1062             continue;
1063         __reg_op(bitmap, pos, order, REG_OP_ALLOC);
1064         return pos;
1065     }
1066     return -ENOMEM;
1067 }
1068 EXPORT_SYMBOL(bitmap_find_free_region);
1069 
1070 /**
1071  * bitmap_release_region - release allocated bitmap region
1072  *  @bitmap: array of unsigned longs corresponding to the bitmap
1073  *  @pos: beginning of bit region to release
1074  *  @order: region size (log base 2 of number of bits) to release
1075  *
1076  * This is the complement to __bitmap_find_free_region() and releases
1077  * the found region (by clearing it in the bitmap).
1078  *
1079  * No return value.
1080  */
1081 void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order)
1082 {
1083     __reg_op(bitmap, pos, order, REG_OP_RELEASE);
1084 }
1085 EXPORT_SYMBOL(bitmap_release_region);
1086 
1087 /**
1088  * bitmap_allocate_region - allocate bitmap region
1089  *  @bitmap: array of unsigned longs corresponding to the bitmap
1090  *  @pos: beginning of bit region to allocate
1091  *  @order: region size (log base 2 of number of bits) to allocate
1092  *
1093  * Allocate (set bits in) a specified region of a bitmap.
1094  *
1095  * Return 0 on success, or %-EBUSY if specified region wasn't
1096  * free (not all bits were zero).
1097  */
1098 int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order)
1099 {
1100     if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
1101         return -EBUSY;
1102     return __reg_op(bitmap, pos, order, REG_OP_ALLOC);
1103 }
1104 EXPORT_SYMBOL(bitmap_allocate_region);
1105 
1106 /**
1107  * bitmap_from_u32array - copy the contents of a u32 array of bits to bitmap
1108  *  @bitmap: array of unsigned longs, the destination bitmap, non NULL
1109  *  @nbits: number of bits in @bitmap
1110  *  @buf: array of u32 (in host byte order), the source bitmap, non NULL
1111  *  @nwords: number of u32 words in @buf
1112  *
1113  * copy min(nbits, 32*nwords) bits from @buf to @bitmap, remaining
1114  * bits between nword and nbits in @bitmap (if any) are cleared. In
1115  * last word of @bitmap, the bits beyond nbits (if any) are kept
1116  * unchanged.
1117  *
1118  * Return the number of bits effectively copied.
1119  */
1120 unsigned int
1121 bitmap_from_u32array(unsigned long *bitmap, unsigned int nbits,
1122              const u32 *buf, unsigned int nwords)
1123 {
1124     unsigned int dst_idx, src_idx;
1125 
1126     for (src_idx = dst_idx = 0; dst_idx < BITS_TO_LONGS(nbits); ++dst_idx) {
1127         unsigned long part = 0;
1128 
1129         if (src_idx < nwords)
1130             part = buf[src_idx++];
1131 
1132 #if BITS_PER_LONG == 64
1133         if (src_idx < nwords)
1134             part |= ((unsigned long) buf[src_idx++]) << 32;
1135 #endif
1136 
1137         if (dst_idx < nbits/BITS_PER_LONG)
1138             bitmap[dst_idx] = part;
1139         else {
1140             unsigned long mask = BITMAP_LAST_WORD_MASK(nbits);
1141 
1142             bitmap[dst_idx] = (bitmap[dst_idx] & ~mask)
1143                 | (part & mask);
1144         }
1145     }
1146 
1147     return min_t(unsigned int, nbits, 32*nwords);
1148 }
1149 EXPORT_SYMBOL(bitmap_from_u32array);
1150 
1151 /**
1152  * bitmap_to_u32array - copy the contents of bitmap to a u32 array of bits
1153  *  @buf: array of u32 (in host byte order), the dest bitmap, non NULL
1154  *  @nwords: number of u32 words in @buf
1155  *  @bitmap: array of unsigned longs, the source bitmap, non NULL
1156  *  @nbits: number of bits in @bitmap
1157  *
1158  * copy min(nbits, 32*nwords) bits from @bitmap to @buf. Remaining
1159  * bits after nbits in @buf (if any) are cleared.
1160  *
1161  * Return the number of bits effectively copied.
1162  */
1163 unsigned int
1164 bitmap_to_u32array(u32 *buf, unsigned int nwords,
1165            const unsigned long *bitmap, unsigned int nbits)
1166 {
1167     unsigned int dst_idx = 0, src_idx = 0;
1168 
1169     while (dst_idx < nwords) {
1170         unsigned long part = 0;
1171 
1172         if (src_idx < BITS_TO_LONGS(nbits)) {
1173             part = bitmap[src_idx];
1174             if (src_idx >= nbits/BITS_PER_LONG)
1175                 part &= BITMAP_LAST_WORD_MASK(nbits);
1176             src_idx++;
1177         }
1178 
1179         buf[dst_idx++] = part & 0xffffffffUL;
1180 
1181 #if BITS_PER_LONG == 64
1182         if (dst_idx < nwords) {
1183             part >>= 32;
1184             buf[dst_idx++] = part & 0xffffffffUL;
1185         }
1186 #endif
1187     }
1188 
1189     return min_t(unsigned int, nbits, 32*nwords);
1190 }
1191 EXPORT_SYMBOL(bitmap_to_u32array);
1192 
1193 /**
1194  * bitmap_copy_le - copy a bitmap, putting the bits into little-endian order.
1195  * @dst:   destination buffer
1196  * @src:   bitmap to copy
1197  * @nbits: number of bits in the bitmap
1198  *
1199  * Require nbits % BITS_PER_LONG == 0.
1200  */
1201 #ifdef __BIG_ENDIAN
1202 void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits)
1203 {
1204     unsigned int i;
1205 
1206     for (i = 0; i < nbits/BITS_PER_LONG; i++) {
1207         if (BITS_PER_LONG == 64)
1208             dst[i] = cpu_to_le64(src[i]);
1209         else
1210             dst[i] = cpu_to_le32(src[i]);
1211     }
1212 }
1213 EXPORT_SYMBOL(bitmap_copy_le);
1214 #endif