Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * lib/bitmap.c
4 : : * Helper functions for bitmap.h.
5 : : */
6 : : #include <linux/export.h>
7 : : #include <linux/thread_info.h>
8 : : #include <linux/ctype.h>
9 : : #include <linux/errno.h>
10 : : #include <linux/bitmap.h>
11 : : #include <linux/bitops.h>
12 : : #include <linux/bug.h>
13 : : #include <linux/kernel.h>
14 : : #include <linux/mm.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/string.h>
17 : : #include <linux/uaccess.h>
18 : :
19 : : #include <asm/page.h>
20 : :
21 : : #include "kstrtox.h"
22 : :
23 : : /**
24 : : * DOC: bitmap introduction
25 : : *
26 : : * bitmaps provide an array of bits, implemented using an an
27 : : * array of unsigned longs. The number of valid bits in a
28 : : * given bitmap does _not_ need to be an exact multiple of
29 : : * BITS_PER_LONG.
30 : : *
31 : : * The possible unused bits in the last, partially used word
32 : : * of a bitmap are 'don't care'. The implementation makes
33 : : * no particular effort to keep them zero. It ensures that
34 : : * their value will not affect the results of any operation.
35 : : * The bitmap operations that return Boolean (bitmap_empty,
36 : : * for example) or scalar (bitmap_weight, for example) results
37 : : * carefully filter out these unused bits from impacting their
38 : : * results.
39 : : *
40 : : * The byte ordering of bitmaps is more natural on little
41 : : * endian architectures. See the big-endian headers
42 : : * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h
43 : : * for the best explanations of this ordering.
44 : : */
45 : :
46 : 0 : int __bitmap_equal(const unsigned long *bitmap1,
47 : : const unsigned long *bitmap2, unsigned int bits)
48 : : {
49 : 0 : unsigned int k, lim = bits/BITS_PER_LONG;
50 [ # # ]: 0 : for (k = 0; k < lim; ++k)
51 [ # # ]: 0 : if (bitmap1[k] != bitmap2[k])
52 : : return 0;
53 : :
54 [ # # ]: 0 : if (bits % BITS_PER_LONG)
55 [ # # ]: 0 : if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
56 : 0 : return 0;
57 : :
58 : : return 1;
59 : : }
60 : : EXPORT_SYMBOL(__bitmap_equal);
61 : :
62 : 0 : bool __bitmap_or_equal(const unsigned long *bitmap1,
63 : : const unsigned long *bitmap2,
64 : : const unsigned long *bitmap3,
65 : : unsigned int bits)
66 : : {
67 : 0 : unsigned int k, lim = bits / BITS_PER_LONG;
68 : 0 : unsigned long tmp;
69 : :
70 [ # # ]: 0 : for (k = 0; k < lim; ++k) {
71 [ # # ]: 0 : if ((bitmap1[k] | bitmap2[k]) != bitmap3[k])
72 : : return false;
73 : : }
74 : :
75 [ # # ]: 0 : if (!(bits % BITS_PER_LONG))
76 : : return true;
77 : :
78 : 0 : tmp = (bitmap1[k] | bitmap2[k]) ^ bitmap3[k];
79 : 0 : return (tmp & BITMAP_LAST_WORD_MASK(bits)) == 0;
80 : : }
81 : :
82 : 0 : void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)
83 : : {
84 : 0 : unsigned int k, lim = BITS_TO_LONGS(bits);
85 [ # # ]: 0 : for (k = 0; k < lim; ++k)
86 : 0 : dst[k] = ~src[k];
87 : 0 : }
88 : : EXPORT_SYMBOL(__bitmap_complement);
89 : :
90 : : /**
91 : : * __bitmap_shift_right - logical right shift of the bits in a bitmap
92 : : * @dst : destination bitmap
93 : : * @src : source bitmap
94 : : * @shift : shift by this many bits
95 : : * @nbits : bitmap size, in bits
96 : : *
97 : : * Shifting right (dividing) means moving bits in the MS -> LS bit
98 : : * direction. Zeros are fed into the vacated MS positions and the
99 : : * LS bits shifted off the bottom are lost.
100 : : */
101 : 0 : void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
102 : : unsigned shift, unsigned nbits)
103 : : {
104 : 0 : unsigned k, lim = BITS_TO_LONGS(nbits);
105 : 0 : unsigned off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
106 : 0 : unsigned long mask = BITMAP_LAST_WORD_MASK(nbits);
107 [ # # ]: 0 : for (k = 0; off + k < lim; ++k) {
108 : 0 : unsigned long upper, lower;
109 : :
110 : : /*
111 : : * If shift is not word aligned, take lower rem bits of
112 : : * word above and make them the top rem bits of result.
113 : : */
114 [ # # # # ]: 0 : if (!rem || off + k + 1 >= lim)
115 : : upper = 0;
116 : : else {
117 : 0 : upper = src[off + k + 1];
118 [ # # ]: 0 : if (off + k + 1 == lim - 1)
119 : 0 : upper &= mask;
120 : 0 : upper <<= (BITS_PER_LONG - rem);
121 : : }
122 : 0 : lower = src[off + k];
123 [ # # ]: 0 : if (off + k == lim - 1)
124 : 0 : lower &= mask;
125 : 0 : lower >>= rem;
126 : 0 : dst[k] = lower | upper;
127 : : }
128 [ # # ]: 0 : if (off)
129 : 0 : memset(&dst[lim - off], 0, off*sizeof(unsigned long));
130 : 0 : }
131 : : EXPORT_SYMBOL(__bitmap_shift_right);
132 : :
133 : :
134 : : /**
135 : : * __bitmap_shift_left - logical left shift of the bits in a bitmap
136 : : * @dst : destination bitmap
137 : : * @src : source bitmap
138 : : * @shift : shift by this many bits
139 : : * @nbits : bitmap size, in bits
140 : : *
141 : : * Shifting left (multiplying) means moving bits in the LS -> MS
142 : : * direction. Zeros are fed into the vacated LS bit positions
143 : : * and those MS bits shifted off the top are lost.
144 : : */
145 : :
146 : 0 : void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
147 : : unsigned int shift, unsigned int nbits)
148 : : {
149 : 0 : int k;
150 : 0 : unsigned int lim = BITS_TO_LONGS(nbits);
151 : 0 : unsigned int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
152 [ # # ]: 0 : for (k = lim - off - 1; k >= 0; --k) {
153 : 0 : unsigned long upper, lower;
154 : :
155 : : /*
156 : : * If shift is not word aligned, take upper rem bits of
157 : : * word below and make them the bottom rem bits of result.
158 : : */
159 [ # # ]: 0 : if (rem && k > 0)
160 : 0 : lower = src[k - 1] >> (BITS_PER_LONG - rem);
161 : : else
162 : : lower = 0;
163 : 0 : upper = src[k] << rem;
164 : 0 : dst[k + off] = lower | upper;
165 : : }
166 [ # # ]: 0 : if (off)
167 : 0 : memset(dst, 0, off*sizeof(unsigned long));
168 : 0 : }
169 : : EXPORT_SYMBOL(__bitmap_shift_left);
170 : :
171 : : /**
172 : : * bitmap_cut() - remove bit region from bitmap and right shift remaining bits
173 : : * @dst: destination bitmap, might overlap with src
174 : : * @src: source bitmap
175 : : * @first: start bit of region to be removed
176 : : * @cut: number of bits to remove
177 : : * @nbits: bitmap size, in bits
178 : : *
179 : : * Set the n-th bit of @dst iff the n-th bit of @src is set and
180 : : * n is less than @first, or the m-th bit of @src is set for any
181 : : * m such that @first <= n < nbits, and m = n + @cut.
182 : : *
183 : : * In pictures, example for a big-endian 32-bit architecture:
184 : : *
185 : : * @src:
186 : : * 31 63
187 : : * | |
188 : : * 10000000 11000001 11110010 00010101 10000000 11000001 01110010 00010101
189 : : * | | | |
190 : : * 16 14 0 32
191 : : *
192 : : * if @cut is 3, and @first is 14, bits 14-16 in @src are cut and @dst is:
193 : : *
194 : : * 31 63
195 : : * | |
196 : : * 10110000 00011000 00110010 00010101 00010000 00011000 00101110 01000010
197 : : * | | |
198 : : * 14 (bit 17 0 32
199 : : * from @src)
200 : : *
201 : : * Note that @dst and @src might overlap partially or entirely.
202 : : *
203 : : * This is implemented in the obvious way, with a shift and carry
204 : : * step for each moved bit. Optimisation is left as an exercise
205 : : * for the compiler.
206 : : */
207 : 0 : void bitmap_cut(unsigned long *dst, const unsigned long *src,
208 : : unsigned int first, unsigned int cut, unsigned int nbits)
209 : : {
210 : 0 : unsigned int len = BITS_TO_LONGS(nbits);
211 : 0 : unsigned long keep = 0, carry;
212 : 0 : int i;
213 : :
214 : 0 : memmove(dst, src, len * sizeof(*dst));
215 : :
216 [ # # ]: 0 : if (first % BITS_PER_LONG) {
217 : 0 : keep = src[first / BITS_PER_LONG] &
218 : 0 : (~0UL >> (BITS_PER_LONG - first % BITS_PER_LONG));
219 : : }
220 : :
221 [ # # ]: 0 : while (cut--) {
222 [ # # ]: 0 : for (i = first / BITS_PER_LONG; i < len; i++) {
223 [ # # ]: 0 : if (i < len - 1)
224 : 0 : carry = dst[i + 1] & 1UL;
225 : : else
226 : : carry = 0;
227 : :
228 : 0 : dst[i] = (dst[i] >> 1) | (carry << (BITS_PER_LONG - 1));
229 : : }
230 : : }
231 : :
232 : 0 : dst[first / BITS_PER_LONG] &= ~0UL << (first % BITS_PER_LONG);
233 : 0 : dst[first / BITS_PER_LONG] |= keep;
234 : 0 : }
235 : : EXPORT_SYMBOL(bitmap_cut);
236 : :
237 : 0 : int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
238 : : const unsigned long *bitmap2, unsigned int bits)
239 : : {
240 : 0 : unsigned int k;
241 : 0 : unsigned int lim = bits/BITS_PER_LONG;
242 : 0 : unsigned long result = 0;
243 : :
244 [ # # ]: 0 : for (k = 0; k < lim; k++)
245 : 0 : result |= (dst[k] = bitmap1[k] & bitmap2[k]);
246 [ # # ]: 0 : if (bits % BITS_PER_LONG)
247 : 0 : result |= (dst[k] = bitmap1[k] & bitmap2[k] &
248 : 0 : BITMAP_LAST_WORD_MASK(bits));
249 : 0 : return result != 0;
250 : : }
251 : : EXPORT_SYMBOL(__bitmap_and);
252 : :
253 : 176 : void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
254 : : const unsigned long *bitmap2, unsigned int bits)
255 : : {
256 : 176 : unsigned int k;
257 : 176 : unsigned int nr = BITS_TO_LONGS(bits);
258 : :
259 [ + + ]: 880 : for (k = 0; k < nr; k++)
260 : 704 : dst[k] = bitmap1[k] | bitmap2[k];
261 : 176 : }
262 : : EXPORT_SYMBOL(__bitmap_or);
263 : :
264 : 0 : void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
265 : : const unsigned long *bitmap2, unsigned int bits)
266 : : {
267 : 0 : unsigned int k;
268 : 0 : unsigned int nr = BITS_TO_LONGS(bits);
269 : :
270 [ # # ]: 0 : for (k = 0; k < nr; k++)
271 : 0 : dst[k] = bitmap1[k] ^ bitmap2[k];
272 : 0 : }
273 : : EXPORT_SYMBOL(__bitmap_xor);
274 : :
275 : 0 : int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
276 : : const unsigned long *bitmap2, unsigned int bits)
277 : : {
278 : 0 : unsigned int k;
279 : 0 : unsigned int lim = bits/BITS_PER_LONG;
280 : 0 : unsigned long result = 0;
281 : :
282 [ # # ]: 0 : for (k = 0; k < lim; k++)
283 : 0 : result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
284 [ # # ]: 0 : if (bits % BITS_PER_LONG)
285 : 0 : result |= (dst[k] = bitmap1[k] & ~bitmap2[k] &
286 : 0 : BITMAP_LAST_WORD_MASK(bits));
287 : 0 : return result != 0;
288 : : }
289 : : EXPORT_SYMBOL(__bitmap_andnot);
290 : :
291 : 0 : void __bitmap_replace(unsigned long *dst,
292 : : const unsigned long *old, const unsigned long *new,
293 : : const unsigned long *mask, unsigned int nbits)
294 : : {
295 : 0 : unsigned int k;
296 : 0 : unsigned int nr = BITS_TO_LONGS(nbits);
297 : :
298 [ # # ]: 0 : for (k = 0; k < nr; k++)
299 : 0 : dst[k] = (old[k] & ~mask[k]) | (new[k] & mask[k]);
300 : 0 : }
301 : : EXPORT_SYMBOL(__bitmap_replace);
302 : :
303 : 0 : int __bitmap_intersects(const unsigned long *bitmap1,
304 : : const unsigned long *bitmap2, unsigned int bits)
305 : : {
306 : 0 : unsigned int k, lim = bits/BITS_PER_LONG;
307 [ # # ]: 0 : for (k = 0; k < lim; ++k)
308 [ # # ]: 0 : if (bitmap1[k] & bitmap2[k])
309 : : return 1;
310 : :
311 [ # # ]: 0 : if (bits % BITS_PER_LONG)
312 [ # # ]: 0 : if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
313 : 0 : return 1;
314 : : return 0;
315 : : }
316 : : EXPORT_SYMBOL(__bitmap_intersects);
317 : :
318 : 363 : int __bitmap_subset(const unsigned long *bitmap1,
319 : : const unsigned long *bitmap2, unsigned int bits)
320 : : {
321 : 363 : unsigned int k, lim = bits/BITS_PER_LONG;
322 [ + + ]: 1914 : for (k = 0; k < lim; ++k)
323 [ + + ]: 1738 : if (bitmap1[k] & ~bitmap2[k])
324 : : return 0;
325 : :
326 [ + - ]: 176 : if (bits % BITS_PER_LONG)
327 [ - + ]: 176 : if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
328 : 0 : return 0;
329 : : return 1;
330 : : }
331 : : EXPORT_SYMBOL(__bitmap_subset);
332 : :
333 : 0 : int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)
334 : : {
335 : 0 : unsigned int k, lim = bits/BITS_PER_LONG;
336 : 0 : int w = 0;
337 : :
338 [ # # ]: 0 : for (k = 0; k < lim; k++)
339 [ # # ]: 0 : w += hweight_long(bitmap[k]);
340 : :
341 [ # # ]: 0 : if (bits % BITS_PER_LONG)
342 [ # # ]: 0 : w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
343 : :
344 : 0 : return w;
345 : : }
346 : : EXPORT_SYMBOL(__bitmap_weight);
347 : :
348 : 11132 : void __bitmap_set(unsigned long *map, unsigned int start, int len)
349 : : {
350 : 11132 : unsigned long *p = map + BIT_WORD(start);
351 : 11132 : const unsigned int size = start + len;
352 : 11132 : int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
353 : 11132 : unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
354 : :
355 [ + + ]: 13094 : while (len - bits_to_set >= 0) {
356 : 1962 : *p |= mask_to_set;
357 : 1962 : len -= bits_to_set;
358 : 1962 : bits_to_set = BITS_PER_LONG;
359 : 1962 : mask_to_set = ~0UL;
360 : 1962 : p++;
361 : : }
362 [ + + ]: 11132 : if (len) {
363 : 10271 : mask_to_set &= BITMAP_LAST_WORD_MASK(size);
364 : 10271 : *p |= mask_to_set;
365 : : }
366 : 11132 : }
367 : : EXPORT_SYMBOL(__bitmap_set);
368 : :
369 : 11836 : void __bitmap_clear(unsigned long *map, unsigned int start, int len)
370 : : {
371 : 11836 : unsigned long *p = map + BIT_WORD(start);
372 : 11836 : const unsigned int size = start + len;
373 : 11836 : int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
374 : 11836 : unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
375 : :
376 [ + + ]: 13448 : while (len - bits_to_clear >= 0) {
377 : 1612 : *p &= ~mask_to_clear;
378 : 1612 : len -= bits_to_clear;
379 : 1612 : bits_to_clear = BITS_PER_LONG;
380 : 1612 : mask_to_clear = ~0UL;
381 : 1612 : p++;
382 : : }
383 [ + + ]: 11836 : if (len) {
384 : 7915 : mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
385 : 7915 : *p &= ~mask_to_clear;
386 : : }
387 : 11836 : }
388 : : EXPORT_SYMBOL(__bitmap_clear);
389 : :
390 : : /**
391 : : * bitmap_find_next_zero_area_off - find a contiguous aligned zero area
392 : : * @map: The address to base the search on
393 : : * @size: The bitmap size in bits
394 : : * @start: The bitnumber to start searching at
395 : : * @nr: The number of zeroed bits we're looking for
396 : : * @align_mask: Alignment mask for zero area
397 : : * @align_offset: Alignment offset for zero area.
398 : : *
399 : : * The @align_mask should be one less than a power of 2; the effect is that
400 : : * the bit offset of all zero areas this function finds plus @align_offset
401 : : * is multiple of that power of 2.
402 : : */
403 : 88 : unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
404 : : unsigned long size,
405 : : unsigned long start,
406 : : unsigned int nr,
407 : : unsigned long align_mask,
408 : : unsigned long align_offset)
409 : : {
410 : 88 : unsigned long index, end, i;
411 : 88 : again:
412 : 88 : index = find_next_zero_bit(map, size, start);
413 : :
414 : : /* Align allocation */
415 : 88 : index = __ALIGN_MASK(index + align_offset, align_mask) - align_offset;
416 : :
417 : 88 : end = index + nr;
418 [ - + ]: 88 : if (end > size)
419 : 0 : return end;
420 : 88 : i = find_next_bit(map, end, index);
421 [ - + ]: 88 : if (i < end) {
422 : 0 : start = i + 1;
423 : 0 : goto again;
424 : : }
425 : : return index;
426 : : }
427 : : EXPORT_SYMBOL(bitmap_find_next_zero_area_off);
428 : :
429 : : /*
430 : : * Bitmap printing & parsing functions: first version by Nadia Yvette Chambers,
431 : : * second version by Paul Jackson, third by Joe Korty.
432 : : */
433 : :
434 : : /**
435 : : * bitmap_parse_user - convert an ASCII hex string in a user buffer into a bitmap
436 : : *
437 : : * @ubuf: pointer to user buffer containing string.
438 : : * @ulen: buffer size in bytes. If string is smaller than this
439 : : * then it must be terminated with a \0.
440 : : * @maskp: pointer to bitmap array that will contain result.
441 : : * @nmaskbits: size of bitmap, in bits.
442 : : */
443 : 0 : int bitmap_parse_user(const char __user *ubuf,
444 : : unsigned int ulen, unsigned long *maskp,
445 : : int nmaskbits)
446 : : {
447 : 0 : char *buf;
448 : 0 : int ret;
449 : :
450 : 0 : buf = memdup_user_nul(ubuf, ulen);
451 [ # # ]: 0 : if (IS_ERR(buf))
452 : 0 : return PTR_ERR(buf);
453 : :
454 : 0 : ret = bitmap_parse(buf, UINT_MAX, maskp, nmaskbits);
455 : :
456 : 0 : kfree(buf);
457 : 0 : return ret;
458 : : }
459 : : EXPORT_SYMBOL(bitmap_parse_user);
460 : :
461 : : /**
462 : : * bitmap_print_to_pagebuf - convert bitmap to list or hex format ASCII string
463 : : * @list: indicates whether the bitmap must be list
464 : : * @buf: page aligned buffer into which string is placed
465 : : * @maskp: pointer to bitmap to convert
466 : : * @nmaskbits: size of bitmap, in bits
467 : : *
468 : : * Output format is a comma-separated list of decimal numbers and
469 : : * ranges if list is specified or hex digits grouped into comma-separated
470 : : * sets of 8 digits/set. Returns the number of characters written to buf.
471 : : *
472 : : * It is assumed that @buf is a pointer into a PAGE_SIZE, page-aligned
473 : : * area and that sufficient storage remains at @buf to accommodate the
474 : : * bitmap_print_to_pagebuf() output. Returns the number of characters
475 : : * actually printed to @buf, excluding terminating '\0'.
476 : : */
477 : 22 : int bitmap_print_to_pagebuf(bool list, char *buf, const unsigned long *maskp,
478 : : int nmaskbits)
479 : : {
480 : 22 : ptrdiff_t len = PAGE_SIZE - offset_in_page(buf);
481 : :
482 [ + - ]: 22 : return list ? scnprintf(buf, len, "%*pbl\n", nmaskbits, maskp) :
483 : 0 : scnprintf(buf, len, "%*pb\n", nmaskbits, maskp);
484 : : }
485 : : EXPORT_SYMBOL(bitmap_print_to_pagebuf);
486 : :
487 : : /*
488 : : * Region 9-38:4/10 describes the following bitmap structure:
489 : : * 0 9 12 18 38
490 : : * .........****......****......****......
491 : : * ^ ^ ^ ^
492 : : * start off group_len end
493 : : */
494 : : struct region {
495 : : unsigned int start;
496 : : unsigned int off;
497 : : unsigned int group_len;
498 : : unsigned int end;
499 : : };
500 : :
501 : 0 : static int bitmap_set_region(const struct region *r,
502 : : unsigned long *bitmap, int nbits)
503 : : {
504 : 0 : unsigned int start;
505 : :
506 [ # # ]: 0 : if (r->end >= nbits)
507 : : return -ERANGE;
508 : :
509 [ # # ]: 0 : for (start = r->start; start <= r->end; start += r->group_len)
510 [ # # ]: 0 : bitmap_set(bitmap, start, min(r->end - start + 1, r->off));
511 : :
512 : : return 0;
513 : : }
514 : :
515 : 0 : static int bitmap_check_region(const struct region *r)
516 : : {
517 [ # # # # ]: 0 : if (r->start > r->end || r->group_len == 0 || r->off > r->group_len)
518 : 0 : return -EINVAL;
519 : :
520 : : return 0;
521 : : }
522 : :
523 : 0 : static const char *bitmap_getnum(const char *str, unsigned int *num)
524 : : {
525 : 0 : unsigned long long n;
526 : 0 : unsigned int len;
527 : :
528 : 0 : len = _parse_integer(str, 10, &n);
529 [ # # ]: 0 : if (!len)
530 : : return ERR_PTR(-EINVAL);
531 [ # # # # ]: 0 : if (len & KSTRTOX_OVERFLOW || n != (unsigned int)n)
532 : : return ERR_PTR(-EOVERFLOW);
533 : :
534 : 0 : *num = n;
535 : 0 : return str + len;
536 : : }
537 : :
538 : 0 : static inline bool end_of_str(char c)
539 : : {
540 : 0 : return c == '\0' || c == '\n';
541 : : }
542 : :
543 : 0 : static inline bool __end_of_region(char c)
544 : : {
545 [ # # # # : 0 : return isspace(c) || c == ',';
# # # # #
# ]
546 : : }
547 : :
548 : 0 : static inline bool end_of_region(char c)
549 : : {
550 [ # # # # : 0 : return __end_of_region(c) || end_of_str(c);
# # # # ]
551 : : }
552 : :
553 : : /*
554 : : * The format allows commas and whitespases at the beginning
555 : : * of the region.
556 : : */
557 : : static const char *bitmap_find_region(const char *str)
558 : : {
559 [ # # # # ]: 0 : while (__end_of_region(*str))
560 : 0 : str++;
561 : :
562 [ # # ]: 0 : return end_of_str(*str) ? NULL : str;
563 : : }
564 : :
565 : 0 : static const char *bitmap_find_region_reverse(const char *start, const char *end)
566 : : {
567 [ # # # # : 0 : while (start <= end && __end_of_region(*end))
# # ]
568 : 0 : end--;
569 : :
570 : 0 : return end;
571 : : }
572 : :
573 : 0 : static const char *bitmap_parse_region(const char *str, struct region *r)
574 : : {
575 : 0 : str = bitmap_getnum(str, &r->start);
576 [ # # ]: 0 : if (IS_ERR(str))
577 : : return str;
578 : :
579 [ # # # # ]: 0 : if (end_of_region(*str))
580 : 0 : goto no_end;
581 : :
582 [ # # ]: 0 : if (*str != '-')
583 : : return ERR_PTR(-EINVAL);
584 : :
585 : 0 : str = bitmap_getnum(str + 1, &r->end);
586 [ # # ]: 0 : if (IS_ERR(str))
587 : : return str;
588 : :
589 [ # # # # ]: 0 : if (end_of_region(*str))
590 : 0 : goto no_pattern;
591 : :
592 [ # # ]: 0 : if (*str != ':')
593 : : return ERR_PTR(-EINVAL);
594 : :
595 : 0 : str = bitmap_getnum(str + 1, &r->off);
596 [ # # ]: 0 : if (IS_ERR(str))
597 : : return str;
598 : :
599 [ # # ]: 0 : if (*str != '/')
600 : : return ERR_PTR(-EINVAL);
601 : :
602 : 0 : return bitmap_getnum(str + 1, &r->group_len);
603 : :
604 : : no_end:
605 : 0 : r->end = r->start;
606 : 0 : no_pattern:
607 : 0 : r->off = r->end + 1;
608 : 0 : r->group_len = r->end + 1;
609 : :
610 [ # # ]: 0 : return end_of_str(*str) ? NULL : str;
611 : : }
612 : :
613 : : /**
614 : : * bitmap_parselist - convert list format ASCII string to bitmap
615 : : * @buf: read user string from this buffer; must be terminated
616 : : * with a \0 or \n.
617 : : * @maskp: write resulting mask here
618 : : * @nmaskbits: number of bits in mask to be written
619 : : *
620 : : * Input format is a comma-separated list of decimal numbers and
621 : : * ranges. Consecutively set bits are shown as two hyphen-separated
622 : : * decimal numbers, the smallest and largest bit numbers set in
623 : : * the range.
624 : : * Optionally each range can be postfixed to denote that only parts of it
625 : : * should be set. The range will divided to groups of specific size.
626 : : * From each group will be used only defined amount of bits.
627 : : * Syntax: range:used_size/group_size
628 : : * Example: 0-1023:2/256 ==> 0,1,256,257,512,513,768,769
629 : : *
630 : : * Returns: 0 on success, -errno on invalid input strings. Error values:
631 : : *
632 : : * - ``-EINVAL``: wrong region format
633 : : * - ``-EINVAL``: invalid character in string
634 : : * - ``-ERANGE``: bit number specified too large for mask
635 : : * - ``-EOVERFLOW``: integer overflow in the input parameters
636 : : */
637 : 0 : int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits)
638 : : {
639 : 0 : struct region r;
640 : 0 : long ret;
641 : :
642 : 0 : bitmap_zero(maskp, nmaskbits);
643 : :
644 [ # # ]: 0 : while (buf) {
645 : : buf = bitmap_find_region(buf);
646 [ # # ]: 0 : if (buf == NULL)
647 : : return 0;
648 : :
649 : 0 : buf = bitmap_parse_region(buf, &r);
650 [ # # ]: 0 : if (IS_ERR(buf))
651 : 0 : return PTR_ERR(buf);
652 : :
653 [ # # ]: 0 : ret = bitmap_check_region(&r);
654 [ # # ]: 0 : if (ret)
655 : 0 : return ret;
656 : :
657 : 0 : ret = bitmap_set_region(&r, maskp, nmaskbits);
658 [ # # ]: 0 : if (ret)
659 : 0 : return ret;
660 : : }
661 : :
662 : : return 0;
663 : : }
664 : : EXPORT_SYMBOL(bitmap_parselist);
665 : :
666 : :
667 : : /**
668 : : * bitmap_parselist_user()
669 : : *
670 : : * @ubuf: pointer to user buffer containing string.
671 : : * @ulen: buffer size in bytes. If string is smaller than this
672 : : * then it must be terminated with a \0.
673 : : * @maskp: pointer to bitmap array that will contain result.
674 : : * @nmaskbits: size of bitmap, in bits.
675 : : *
676 : : * Wrapper for bitmap_parselist(), providing it with user buffer.
677 : : */
678 : 0 : int bitmap_parselist_user(const char __user *ubuf,
679 : : unsigned int ulen, unsigned long *maskp,
680 : : int nmaskbits)
681 : : {
682 : 0 : char *buf;
683 : 0 : int ret;
684 : :
685 : 0 : buf = memdup_user_nul(ubuf, ulen);
686 [ # # ]: 0 : if (IS_ERR(buf))
687 : 0 : return PTR_ERR(buf);
688 : :
689 : 0 : ret = bitmap_parselist(buf, maskp, nmaskbits);
690 : :
691 : 0 : kfree(buf);
692 : 0 : return ret;
693 : : }
694 : : EXPORT_SYMBOL(bitmap_parselist_user);
695 : :
696 : 0 : static const char *bitmap_get_x32_reverse(const char *start,
697 : : const char *end, u32 *num)
698 : : {
699 : 0 : u32 ret = 0;
700 : 0 : int c, i;
701 : :
702 [ # # ]: 0 : for (i = 0; i < 32; i += 4) {
703 : 0 : c = hex_to_bin(*end--);
704 [ # # ]: 0 : if (c < 0)
705 : : return ERR_PTR(-EINVAL);
706 : :
707 : 0 : ret |= c << i;
708 : :
709 [ # # # # : 0 : if (start > end || __end_of_region(*end))
# # ]
710 : 0 : goto out;
711 : : }
712 : :
713 [ # # ]: 0 : if (hex_to_bin(*end--) >= 0)
714 : : return ERR_PTR(-EOVERFLOW);
715 : 0 : out:
716 : 0 : *num = ret;
717 : 0 : return end;
718 : : }
719 : :
720 : : /**
721 : : * bitmap_parse - convert an ASCII hex string into a bitmap.
722 : : * @start: pointer to buffer containing string.
723 : : * @buflen: buffer size in bytes. If string is smaller than this
724 : : * then it must be terminated with a \0 or \n. In that case,
725 : : * UINT_MAX may be provided instead of string length.
726 : : * @maskp: pointer to bitmap array that will contain result.
727 : : * @nmaskbits: size of bitmap, in bits.
728 : : *
729 : : * Commas group hex digits into chunks. Each chunk defines exactly 32
730 : : * bits of the resultant bitmask. No chunk may specify a value larger
731 : : * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
732 : : * then leading 0-bits are prepended. %-EINVAL is returned for illegal
733 : : * characters. Grouping such as "1,,5", ",44", "," or "" is allowed.
734 : : * Leading, embedded and trailing whitespace accepted.
735 : : */
736 : 0 : int bitmap_parse(const char *start, unsigned int buflen,
737 : : unsigned long *maskp, int nmaskbits)
738 : : {
739 : 0 : const char *end = strnchrnul(start, buflen, '\n') - 1;
740 : 0 : int chunks = BITS_TO_U32(nmaskbits);
741 : 0 : u32 *bitmap = (u32 *)maskp;
742 : 0 : int unset_bit;
743 : :
744 : 0 : while (1) {
745 : 0 : end = bitmap_find_region_reverse(start, end);
746 [ # # ]: 0 : if (start > end)
747 : : break;
748 : :
749 [ # # ]: 0 : if (!chunks--)
750 : : return -EOVERFLOW;
751 : :
752 : 0 : end = bitmap_get_x32_reverse(start, end, bitmap++);
753 [ # # ]: 0 : if (IS_ERR(end))
754 : 0 : return PTR_ERR(end);
755 : : }
756 : :
757 : 0 : unset_bit = (BITS_TO_U32(nmaskbits) - chunks) * 32;
758 [ # # ]: 0 : if (unset_bit < nmaskbits) {
759 [ # # ]: 0 : bitmap_clear(maskp, unset_bit, nmaskbits - unset_bit);
760 : 0 : return 0;
761 : : }
762 : :
763 [ # # ]: 0 : if (find_next_bit(maskp, unset_bit, nmaskbits) != unset_bit)
764 : 0 : return -EOVERFLOW;
765 : :
766 : : return 0;
767 : : }
768 : : EXPORT_SYMBOL(bitmap_parse);
769 : :
770 : :
771 : : #ifdef CONFIG_NUMA
772 : : /**
773 : : * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
774 : : * @buf: pointer to a bitmap
775 : : * @pos: a bit position in @buf (0 <= @pos < @nbits)
776 : : * @nbits: number of valid bit positions in @buf
777 : : *
778 : : * Map the bit at position @pos in @buf (of length @nbits) to the
779 : : * ordinal of which set bit it is. If it is not set or if @pos
780 : : * is not a valid bit position, map to -1.
781 : : *
782 : : * If for example, just bits 4 through 7 are set in @buf, then @pos
783 : : * values 4 through 7 will get mapped to 0 through 3, respectively,
784 : : * and other @pos values will get mapped to -1. When @pos value 7
785 : : * gets mapped to (returns) @ord value 3 in this example, that means
786 : : * that bit 7 is the 3rd (starting with 0th) set bit in @buf.
787 : : *
788 : : * The bit positions 0 through @bits are valid positions in @buf.
789 : : */
790 : 0 : static int bitmap_pos_to_ord(const unsigned long *buf, unsigned int pos, unsigned int nbits)
791 : : {
792 [ # # # # ]: 0 : if (pos >= nbits || !test_bit(pos, buf))
793 : 0 : return -1;
794 : :
795 : 0 : return __bitmap_weight(buf, pos);
796 : : }
797 : :
798 : : /**
799 : : * bitmap_ord_to_pos - find position of n-th set bit in bitmap
800 : : * @buf: pointer to bitmap
801 : : * @ord: ordinal bit position (n-th set bit, n >= 0)
802 : : * @nbits: number of valid bit positions in @buf
803 : : *
804 : : * Map the ordinal offset of bit @ord in @buf to its position in @buf.
805 : : * Value of @ord should be in range 0 <= @ord < weight(buf). If @ord
806 : : * >= weight(buf), returns @nbits.
807 : : *
808 : : * If for example, just bits 4 through 7 are set in @buf, then @ord
809 : : * values 0 through 3 will get mapped to 4 through 7, respectively,
810 : : * and all other @ord values returns @nbits. When @ord value 3
811 : : * gets mapped to (returns) @pos value 7 in this example, that means
812 : : * that the 3rd set bit (starting with 0th) is at position 7 in @buf.
813 : : *
814 : : * The bit positions 0 through @nbits-1 are valid positions in @buf.
815 : : */
816 : 0 : unsigned int bitmap_ord_to_pos(const unsigned long *buf, unsigned int ord, unsigned int nbits)
817 : : {
818 : 0 : unsigned int pos;
819 : :
820 : 0 : for (pos = find_first_bit(buf, nbits);
821 [ # # ]: 0 : pos < nbits && ord;
822 : 0 : pos = find_next_bit(buf, nbits, pos + 1))
823 : 0 : ord--;
824 : :
825 : 0 : return pos;
826 : : }
827 : :
828 : : /**
829 : : * bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap
830 : : * @dst: remapped result
831 : : * @src: subset to be remapped
832 : : * @old: defines domain of map
833 : : * @new: defines range of map
834 : : * @nbits: number of bits in each of these bitmaps
835 : : *
836 : : * Let @old and @new define a mapping of bit positions, such that
837 : : * whatever position is held by the n-th set bit in @old is mapped
838 : : * to the n-th set bit in @new. In the more general case, allowing
839 : : * for the possibility that the weight 'w' of @new is less than the
840 : : * weight of @old, map the position of the n-th set bit in @old to
841 : : * the position of the m-th set bit in @new, where m == n % w.
842 : : *
843 : : * If either of the @old and @new bitmaps are empty, or if @src and
844 : : * @dst point to the same location, then this routine copies @src
845 : : * to @dst.
846 : : *
847 : : * The positions of unset bits in @old are mapped to themselves
848 : : * (the identify map).
849 : : *
850 : : * Apply the above specified mapping to @src, placing the result in
851 : : * @dst, clearing any bits previously set in @dst.
852 : : *
853 : : * For example, lets say that @old has bits 4 through 7 set, and
854 : : * @new has bits 12 through 15 set. This defines the mapping of bit
855 : : * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
856 : : * bit positions unchanged. So if say @src comes into this routine
857 : : * with bits 1, 5 and 7 set, then @dst should leave with bits 1,
858 : : * 13 and 15 set.
859 : : */
860 : 0 : void bitmap_remap(unsigned long *dst, const unsigned long *src,
861 : : const unsigned long *old, const unsigned long *new,
862 : : unsigned int nbits)
863 : : {
864 : 0 : unsigned int oldbit, w;
865 : :
866 [ # # ]: 0 : if (dst == src) /* following doesn't handle inplace remaps */
867 : : return;
868 [ # # ]: 0 : bitmap_zero(dst, nbits);
869 : :
870 [ # # ]: 0 : w = bitmap_weight(new, nbits);
871 [ # # ]: 0 : for_each_set_bit(oldbit, src, nbits) {
872 : 0 : int n = bitmap_pos_to_ord(old, oldbit, nbits);
873 : :
874 [ # # ]: 0 : if (n < 0 || w == 0)
875 : 0 : set_bit(oldbit, dst); /* identity map */
876 : : else
877 : 0 : set_bit(bitmap_ord_to_pos(new, n % w, nbits), dst);
878 : : }
879 : : }
880 : :
881 : : /**
882 : : * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit
883 : : * @oldbit: bit position to be mapped
884 : : * @old: defines domain of map
885 : : * @new: defines range of map
886 : : * @bits: number of bits in each of these bitmaps
887 : : *
888 : : * Let @old and @new define a mapping of bit positions, such that
889 : : * whatever position is held by the n-th set bit in @old is mapped
890 : : * to the n-th set bit in @new. In the more general case, allowing
891 : : * for the possibility that the weight 'w' of @new is less than the
892 : : * weight of @old, map the position of the n-th set bit in @old to
893 : : * the position of the m-th set bit in @new, where m == n % w.
894 : : *
895 : : * The positions of unset bits in @old are mapped to themselves
896 : : * (the identify map).
897 : : *
898 : : * Apply the above specified mapping to bit position @oldbit, returning
899 : : * the new bit position.
900 : : *
901 : : * For example, lets say that @old has bits 4 through 7 set, and
902 : : * @new has bits 12 through 15 set. This defines the mapping of bit
903 : : * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
904 : : * bit positions unchanged. So if say @oldbit is 5, then this routine
905 : : * returns 13.
906 : : */
907 : 0 : int bitmap_bitremap(int oldbit, const unsigned long *old,
908 : : const unsigned long *new, int bits)
909 : : {
910 [ # # ]: 0 : int w = bitmap_weight(new, bits);
911 : 0 : int n = bitmap_pos_to_ord(old, oldbit, bits);
912 [ # # ]: 0 : if (n < 0 || w == 0)
913 : : return oldbit;
914 : : else
915 : 0 : return bitmap_ord_to_pos(new, n % w, bits);
916 : : }
917 : :
918 : : /**
919 : : * bitmap_onto - translate one bitmap relative to another
920 : : * @dst: resulting translated bitmap
921 : : * @orig: original untranslated bitmap
922 : : * @relmap: bitmap relative to which translated
923 : : * @bits: number of bits in each of these bitmaps
924 : : *
925 : : * Set the n-th bit of @dst iff there exists some m such that the
926 : : * n-th bit of @relmap is set, the m-th bit of @orig is set, and
927 : : * the n-th bit of @relmap is also the m-th _set_ bit of @relmap.
928 : : * (If you understood the previous sentence the first time your
929 : : * read it, you're overqualified for your current job.)
930 : : *
931 : : * In other words, @orig is mapped onto (surjectively) @dst,
932 : : * using the map { <n, m> | the n-th bit of @relmap is the
933 : : * m-th set bit of @relmap }.
934 : : *
935 : : * Any set bits in @orig above bit number W, where W is the
936 : : * weight of (number of set bits in) @relmap are mapped nowhere.
937 : : * In particular, if for all bits m set in @orig, m >= W, then
938 : : * @dst will end up empty. In situations where the possibility
939 : : * of such an empty result is not desired, one way to avoid it is
940 : : * to use the bitmap_fold() operator, below, to first fold the
941 : : * @orig bitmap over itself so that all its set bits x are in the
942 : : * range 0 <= x < W. The bitmap_fold() operator does this by
943 : : * setting the bit (m % W) in @dst, for each bit (m) set in @orig.
944 : : *
945 : : * Example [1] for bitmap_onto():
946 : : * Let's say @relmap has bits 30-39 set, and @orig has bits
947 : : * 1, 3, 5, 7, 9 and 11 set. Then on return from this routine,
948 : : * @dst will have bits 31, 33, 35, 37 and 39 set.
949 : : *
950 : : * When bit 0 is set in @orig, it means turn on the bit in
951 : : * @dst corresponding to whatever is the first bit (if any)
952 : : * that is turned on in @relmap. Since bit 0 was off in the
953 : : * above example, we leave off that bit (bit 30) in @dst.
954 : : *
955 : : * When bit 1 is set in @orig (as in the above example), it
956 : : * means turn on the bit in @dst corresponding to whatever
957 : : * is the second bit that is turned on in @relmap. The second
958 : : * bit in @relmap that was turned on in the above example was
959 : : * bit 31, so we turned on bit 31 in @dst.
960 : : *
961 : : * Similarly, we turned on bits 33, 35, 37 and 39 in @dst,
962 : : * because they were the 4th, 6th, 8th and 10th set bits
963 : : * set in @relmap, and the 4th, 6th, 8th and 10th bits of
964 : : * @orig (i.e. bits 3, 5, 7 and 9) were also set.
965 : : *
966 : : * When bit 11 is set in @orig, it means turn on the bit in
967 : : * @dst corresponding to whatever is the twelfth bit that is
968 : : * turned on in @relmap. In the above example, there were
969 : : * only ten bits turned on in @relmap (30..39), so that bit
970 : : * 11 was set in @orig had no affect on @dst.
971 : : *
972 : : * Example [2] for bitmap_fold() + bitmap_onto():
973 : : * Let's say @relmap has these ten bits set::
974 : : *
975 : : * 40 41 42 43 45 48 53 61 74 95
976 : : *
977 : : * (for the curious, that's 40 plus the first ten terms of the
978 : : * Fibonacci sequence.)
979 : : *
980 : : * Further lets say we use the following code, invoking
981 : : * bitmap_fold() then bitmap_onto, as suggested above to
982 : : * avoid the possibility of an empty @dst result::
983 : : *
984 : : * unsigned long *tmp; // a temporary bitmap's bits
985 : : *
986 : : * bitmap_fold(tmp, orig, bitmap_weight(relmap, bits), bits);
987 : : * bitmap_onto(dst, tmp, relmap, bits);
988 : : *
989 : : * Then this table shows what various values of @dst would be, for
990 : : * various @orig's. I list the zero-based positions of each set bit.
991 : : * The tmp column shows the intermediate result, as computed by
992 : : * using bitmap_fold() to fold the @orig bitmap modulo ten
993 : : * (the weight of @relmap):
994 : : *
995 : : * =============== ============== =================
996 : : * @orig tmp @dst
997 : : * 0 0 40
998 : : * 1 1 41
999 : : * 9 9 95
1000 : : * 10 0 40 [#f1]_
1001 : : * 1 3 5 7 1 3 5 7 41 43 48 61
1002 : : * 0 1 2 3 4 0 1 2 3 4 40 41 42 43 45
1003 : : * 0 9 18 27 0 9 8 7 40 61 74 95
1004 : : * 0 10 20 30 0 40
1005 : : * 0 11 22 33 0 1 2 3 40 41 42 43
1006 : : * 0 12 24 36 0 2 4 6 40 42 45 53
1007 : : * 78 102 211 1 2 8 41 42 74 [#f1]_
1008 : : * =============== ============== =================
1009 : : *
1010 : : * .. [#f1]
1011 : : *
1012 : : * For these marked lines, if we hadn't first done bitmap_fold()
1013 : : * into tmp, then the @dst result would have been empty.
1014 : : *
1015 : : * If either of @orig or @relmap is empty (no set bits), then @dst
1016 : : * will be returned empty.
1017 : : *
1018 : : * If (as explained above) the only set bits in @orig are in positions
1019 : : * m where m >= W, (where W is the weight of @relmap) then @dst will
1020 : : * once again be returned empty.
1021 : : *
1022 : : * All bits in @dst not set by the above rule are cleared.
1023 : : */
1024 : 0 : void bitmap_onto(unsigned long *dst, const unsigned long *orig,
1025 : : const unsigned long *relmap, unsigned int bits)
1026 : : {
1027 : 0 : unsigned int n, m; /* same meaning as in above comment */
1028 : :
1029 [ # # ]: 0 : if (dst == orig) /* following doesn't handle inplace mappings */
1030 : : return;
1031 : 0 : bitmap_zero(dst, bits);
1032 : :
1033 : : /*
1034 : : * The following code is a more efficient, but less
1035 : : * obvious, equivalent to the loop:
1036 : : * for (m = 0; m < bitmap_weight(relmap, bits); m++) {
1037 : : * n = bitmap_ord_to_pos(orig, m, bits);
1038 : : * if (test_bit(m, orig))
1039 : : * set_bit(n, dst);
1040 : : * }
1041 : : */
1042 : :
1043 : 0 : m = 0;
1044 [ # # ]: 0 : for_each_set_bit(n, relmap, bits) {
1045 : : /* m == bitmap_pos_to_ord(relmap, n, bits) */
1046 [ # # ]: 0 : if (test_bit(m, orig))
1047 : 0 : set_bit(n, dst);
1048 : 0 : m++;
1049 : : }
1050 : : }
1051 : :
1052 : : /**
1053 : : * bitmap_fold - fold larger bitmap into smaller, modulo specified size
1054 : : * @dst: resulting smaller bitmap
1055 : : * @orig: original larger bitmap
1056 : : * @sz: specified size
1057 : : * @nbits: number of bits in each of these bitmaps
1058 : : *
1059 : : * For each bit oldbit in @orig, set bit oldbit mod @sz in @dst.
1060 : : * Clear all other bits in @dst. See further the comment and
1061 : : * Example [2] for bitmap_onto() for why and how to use this.
1062 : : */
1063 : 0 : void bitmap_fold(unsigned long *dst, const unsigned long *orig,
1064 : : unsigned int sz, unsigned int nbits)
1065 : : {
1066 : 0 : unsigned int oldbit;
1067 : :
1068 [ # # ]: 0 : if (dst == orig) /* following doesn't handle inplace mappings */
1069 : : return;
1070 : 0 : bitmap_zero(dst, nbits);
1071 : :
1072 [ # # ]: 0 : for_each_set_bit(oldbit, orig, nbits)
1073 : 0 : set_bit(oldbit % sz, dst);
1074 : : }
1075 : : #endif /* CONFIG_NUMA */
1076 : :
1077 : : /*
1078 : : * Common code for bitmap_*_region() routines.
1079 : : * bitmap: array of unsigned longs corresponding to the bitmap
1080 : : * pos: the beginning of the region
1081 : : * order: region size (log base 2 of number of bits)
1082 : : * reg_op: operation(s) to perform on that region of bitmap
1083 : : *
1084 : : * Can set, verify and/or release a region of bits in a bitmap,
1085 : : * depending on which combination of REG_OP_* flag bits is set.
1086 : : *
1087 : : * A region of a bitmap is a sequence of bits in the bitmap, of
1088 : : * some size '1 << order' (a power of two), aligned to that same
1089 : : * '1 << order' power of two.
1090 : : *
1091 : : * Returns 1 if REG_OP_ISFREE succeeds (region is all zero bits).
1092 : : * Returns 0 in all other cases and reg_ops.
1093 : : */
1094 : :
1095 : : enum {
1096 : : REG_OP_ISFREE, /* true if region is all zero bits */
1097 : : REG_OP_ALLOC, /* set all bits in region */
1098 : : REG_OP_RELEASE, /* clear all bits in region */
1099 : : };
1100 : :
1101 : 0 : static int __reg_op(unsigned long *bitmap, unsigned int pos, int order, int reg_op)
1102 : : {
1103 : 0 : int nbits_reg; /* number of bits in region */
1104 : 0 : int index; /* index first long of region in bitmap */
1105 : 0 : int offset; /* bit offset region in bitmap[index] */
1106 : 0 : int nlongs_reg; /* num longs spanned by region in bitmap */
1107 : 0 : int nbitsinlong; /* num bits of region in each spanned long */
1108 : 0 : unsigned long mask; /* bitmask for one long of region */
1109 : 0 : int i; /* scans bitmap by longs */
1110 : 0 : int ret = 0; /* return value */
1111 : :
1112 : : /*
1113 : : * Either nlongs_reg == 1 (for small orders that fit in one long)
1114 : : * or (offset == 0 && mask == ~0UL) (for larger multiword orders.)
1115 : : */
1116 : 0 : nbits_reg = 1 << order;
1117 : 0 : index = pos / BITS_PER_LONG;
1118 : 0 : offset = pos - (index * BITS_PER_LONG);
1119 : 0 : nlongs_reg = BITS_TO_LONGS(nbits_reg);
1120 : 0 : nbitsinlong = min(nbits_reg, BITS_PER_LONG);
1121 : :
1122 : : /*
1123 : : * Can't do "mask = (1UL << nbitsinlong) - 1", as that
1124 : : * overflows if nbitsinlong == BITS_PER_LONG.
1125 : : */
1126 : 0 : mask = (1UL << (nbitsinlong - 1));
1127 : 0 : mask += mask - 1;
1128 : 0 : mask <<= offset;
1129 : :
1130 [ # # # # ]: 0 : switch (reg_op) {
1131 : : case REG_OP_ISFREE:
1132 [ # # ]: 0 : for (i = 0; i < nlongs_reg; i++) {
1133 [ # # ]: 0 : if (bitmap[index + i] & mask)
1134 : 0 : goto done;
1135 : : }
1136 : : ret = 1; /* all bits in region free (zero) */
1137 : : break;
1138 : :
1139 : : case REG_OP_ALLOC:
1140 [ # # # # ]: 0 : for (i = 0; i < nlongs_reg; i++)
1141 : 0 : bitmap[index + i] |= mask;
1142 : : break;
1143 : :
1144 : : case REG_OP_RELEASE:
1145 [ # # ]: 0 : for (i = 0; i < nlongs_reg; i++)
1146 : 0 : bitmap[index + i] &= ~mask;
1147 : : break;
1148 : : }
1149 : 0 : done:
1150 : 0 : return ret;
1151 : : }
1152 : :
1153 : : /**
1154 : : * bitmap_find_free_region - find a contiguous aligned mem region
1155 : : * @bitmap: array of unsigned longs corresponding to the bitmap
1156 : : * @bits: number of bits in the bitmap
1157 : : * @order: region size (log base 2 of number of bits) to find
1158 : : *
1159 : : * Find a region of free (zero) bits in a @bitmap of @bits bits and
1160 : : * allocate them (set them to one). Only consider regions of length
1161 : : * a power (@order) of two, aligned to that power of two, which
1162 : : * makes the search algorithm much faster.
1163 : : *
1164 : : * Return the bit offset in bitmap of the allocated region,
1165 : : * or -errno on failure.
1166 : : */
1167 : 0 : int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order)
1168 : : {
1169 : 0 : unsigned int pos, end; /* scans bitmap by regions of size order */
1170 : :
1171 [ # # ]: 0 : for (pos = 0 ; (end = pos + (1U << order)) <= bits; pos = end) {
1172 [ # # ]: 0 : if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
1173 : 0 : continue;
1174 : 0 : __reg_op(bitmap, pos, order, REG_OP_ALLOC);
1175 : 0 : return pos;
1176 : : }
1177 : : return -ENOMEM;
1178 : : }
1179 : : EXPORT_SYMBOL(bitmap_find_free_region);
1180 : :
1181 : : /**
1182 : : * bitmap_release_region - release allocated bitmap region
1183 : : * @bitmap: array of unsigned longs corresponding to the bitmap
1184 : : * @pos: beginning of bit region to release
1185 : : * @order: region size (log base 2 of number of bits) to release
1186 : : *
1187 : : * This is the complement to __bitmap_find_free_region() and releases
1188 : : * the found region (by clearing it in the bitmap).
1189 : : *
1190 : : * No return value.
1191 : : */
1192 : 0 : void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order)
1193 : : {
1194 : 0 : __reg_op(bitmap, pos, order, REG_OP_RELEASE);
1195 : 0 : }
1196 : : EXPORT_SYMBOL(bitmap_release_region);
1197 : :
1198 : : /**
1199 : : * bitmap_allocate_region - allocate bitmap region
1200 : : * @bitmap: array of unsigned longs corresponding to the bitmap
1201 : : * @pos: beginning of bit region to allocate
1202 : : * @order: region size (log base 2 of number of bits) to allocate
1203 : : *
1204 : : * Allocate (set bits in) a specified region of a bitmap.
1205 : : *
1206 : : * Return 0 on success, or %-EBUSY if specified region wasn't
1207 : : * free (not all bits were zero).
1208 : : */
1209 : 0 : int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order)
1210 : : {
1211 [ # # ]: 0 : if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
1212 : : return -EBUSY;
1213 : 0 : return __reg_op(bitmap, pos, order, REG_OP_ALLOC);
1214 : : }
1215 : : EXPORT_SYMBOL(bitmap_allocate_region);
1216 : :
1217 : : /**
1218 : : * bitmap_copy_le - copy a bitmap, putting the bits into little-endian order.
1219 : : * @dst: destination buffer
1220 : : * @src: bitmap to copy
1221 : : * @nbits: number of bits in the bitmap
1222 : : *
1223 : : * Require nbits % BITS_PER_LONG == 0.
1224 : : */
1225 : : #ifdef __BIG_ENDIAN
1226 : : void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits)
1227 : : {
1228 : : unsigned int i;
1229 : :
1230 : : for (i = 0; i < nbits/BITS_PER_LONG; i++) {
1231 : : if (BITS_PER_LONG == 64)
1232 : : dst[i] = cpu_to_le64(src[i]);
1233 : : else
1234 : : dst[i] = cpu_to_le32(src[i]);
1235 : : }
1236 : : }
1237 : : EXPORT_SYMBOL(bitmap_copy_le);
1238 : : #endif
1239 : :
1240 : 0 : unsigned long *bitmap_alloc(unsigned int nbits, gfp_t flags)
1241 : : {
1242 : 0 : return kmalloc_array(BITS_TO_LONGS(nbits), sizeof(unsigned long),
1243 : : flags);
1244 : : }
1245 : : EXPORT_SYMBOL(bitmap_alloc);
1246 : :
1247 : 0 : unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags)
1248 : : {
1249 : 0 : return bitmap_alloc(nbits, flags | __GFP_ZERO);
1250 : : }
1251 : : EXPORT_SYMBOL(bitmap_zalloc);
1252 : :
1253 : 1056 : void bitmap_free(const unsigned long *bitmap)
1254 : : {
1255 : 1056 : kfree(bitmap);
1256 : 1056 : }
1257 : : EXPORT_SYMBOL(bitmap_free);
1258 : :
1259 : : #if BITS_PER_LONG == 64
1260 : : /**
1261 : : * bitmap_from_arr32 - copy the contents of u32 array of bits to bitmap
1262 : : * @bitmap: array of unsigned longs, the destination bitmap
1263 : : * @buf: array of u32 (in host byte order), the source bitmap
1264 : : * @nbits: number of bits in @bitmap
1265 : : */
1266 : 0 : void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf, unsigned int nbits)
1267 : : {
1268 : 0 : unsigned int i, halfwords;
1269 : :
1270 : 0 : halfwords = DIV_ROUND_UP(nbits, 32);
1271 [ # # ]: 0 : for (i = 0; i < halfwords; i++) {
1272 : 0 : bitmap[i/2] = (unsigned long) buf[i];
1273 [ # # ]: 0 : if (++i < halfwords)
1274 : 0 : bitmap[i/2] |= ((unsigned long) buf[i]) << 32;
1275 : : }
1276 : :
1277 : : /* Clear tail bits in last word beyond nbits. */
1278 [ # # ]: 0 : if (nbits % BITS_PER_LONG)
1279 : 0 : bitmap[(halfwords - 1) / 2] &= BITMAP_LAST_WORD_MASK(nbits);
1280 : 0 : }
1281 : : EXPORT_SYMBOL(bitmap_from_arr32);
1282 : :
1283 : : /**
1284 : : * bitmap_to_arr32 - copy the contents of bitmap to a u32 array of bits
1285 : : * @buf: array of u32 (in host byte order), the dest bitmap
1286 : : * @bitmap: array of unsigned longs, the source bitmap
1287 : : * @nbits: number of bits in @bitmap
1288 : : */
1289 : 0 : void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap, unsigned int nbits)
1290 : : {
1291 : 0 : unsigned int i, halfwords;
1292 : :
1293 : 0 : halfwords = DIV_ROUND_UP(nbits, 32);
1294 [ # # ]: 0 : for (i = 0; i < halfwords; i++) {
1295 : 0 : buf[i] = (u32) (bitmap[i/2] & UINT_MAX);
1296 [ # # ]: 0 : if (++i < halfwords)
1297 : 0 : buf[i] = (u32) (bitmap[i/2] >> 32);
1298 : : }
1299 : :
1300 : : /* Clear tail bits in last element of array beyond nbits. */
1301 [ # # ]: 0 : if (nbits % BITS_PER_LONG)
1302 : 0 : buf[halfwords - 1] &= (u32) (UINT_MAX >> ((-nbits) & 31));
1303 : 0 : }
1304 : : EXPORT_SYMBOL(bitmap_to_arr32);
1305 : :
1306 : : #endif
|
