forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c 
 kernel/lib/bitmap.c
....@@ -1,29 +1,31 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * lib/bitmap.c
34  * Helper functions for bitmap.h.
4
- *
5
- * This source code is licensed under the GNU General Public License,
6
- * Version 2.  See the file COPYING for more details.
75  */
8
-#include <linux/export.h>
9
-#include <linux/thread_info.h>
10
-#include <linux/ctype.h>
11
-#include <linux/errno.h>
6
+
127 #include <linux/bitmap.h>
138 #include <linux/bitops.h>
149 #include <linux/bug.h>
10
+#include <linux/ctype.h>
11
+#include <linux/device.h>
12
+#include <linux/errno.h>
13
+#include <linux/export.h>
1514 #include <linux/kernel.h>
1615 #include <linux/mm.h>
1716 #include <linux/slab.h>
1817 #include <linux/string.h>
18
+#include <linux/thread_info.h>
1919 #include <linux/uaccess.h>
2020 
2121 #include <asm/page.h>
2222 
23
+#include "kstrtox.h"
24
+
2325 /**
2426  * DOC: bitmap introduction
2527  *
26
- * bitmaps provide an array of bits, implemented using an an
28
+ * bitmaps provide an array of bits, implemented using an
2729  * array of unsigned longs.  The number of valid bits in a
2830  * given bitmap does _not_ need to be an exact multiple of
2931  * BITS_PER_LONG.
....@@ -36,11 +38,6 @@
3638  * for example) or scalar (bitmap_weight, for example) results
3739  * carefully filter out these unused bits from impacting their
3840  * results.
39
- *
40
- * These operations actually hold to a slightly stronger rule:
41
- * if you don't input any bitmaps to these ops that have some
42
- * unused bits set, then they won't output any set unused bits
43
- * in output bitmaps.
4441  *
4542  * The byte ordering of bitmaps is more natural on little
4643  * endian architectures.  See the big-endian headers
....@@ -63,6 +60,26 @@
6360 	return 1;
6461 }
6562 EXPORT_SYMBOL(__bitmap_equal);
63
+
64
+bool __bitmap_or_equal(const unsigned long *bitmap1,
65
+		       const unsigned long *bitmap2,
66
+		       const unsigned long *bitmap3,
67
+		       unsigned int bits)
68
+{
69
+	unsigned int k, lim = bits / BITS_PER_LONG;
70
+	unsigned long tmp;
71
+
72
+	for (k = 0; k < lim; ++k) {
73
+		if ((bitmap1[k] | bitmap2[k]) != bitmap3[k])
74
+			return false;
75
+	}
76
+
77
+	if (!(bits % BITS_PER_LONG))
78
+		return true;
79
+
80
+	tmp = (bitmap1[k] | bitmap2[k]) ^ bitmap3[k];
81
+	return (tmp & BITMAP_LAST_WORD_MASK(bits)) == 0;
82
+}
6683 
6784 void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)
6885 {
....@@ -153,6 +170,73 @@
153170 }
154171 EXPORT_SYMBOL(__bitmap_shift_left);
155172 
173
+/**
174
+ * bitmap_cut() - remove bit region from bitmap and right shift remaining bits
175
+ * @dst: destination bitmap, might overlap with src
176
+ * @src: source bitmap
177
+ * @first: start bit of region to be removed
178
+ * @cut: number of bits to remove
179
+ * @nbits: bitmap size, in bits
180
+ *
181
+ * Set the n-th bit of @dst iff the n-th bit of @src is set and
182
+ * n is less than @first, or the m-th bit of @src is set for any
183
+ * m such that @first <= n < nbits, and m = n + @cut.
184
+ *
185
+ * In pictures, example for a big-endian 32-bit architecture:
186
+ *
187
+ * The @src bitmap is::
188
+ *
189
+ *   31                                   63
190
+ *   |                                    |
191
+ *   10000000 11000001 11110010 00010101  10000000 11000001 01110010 00010101
192
+ *                   |  |              |                                    |
193
+ *                  16  14             0                                   32
194
+ *
195
+ * if @cut is 3, and @first is 14, bits 14-16 in @src are cut and @dst is::
196
+ *
197
+ *   31                                   63
198
+ *   |                                    |
199
+ *   10110000 00011000 00110010 00010101  00010000 00011000 00101110 01000010
200
+ *                      |              |                                    |
201
+ *                      14 (bit 17     0                                   32
202
+ *                          from @src)
203
+ *
204
+ * Note that @dst and @src might overlap partially or entirely.
205
+ *
206
+ * This is implemented in the obvious way, with a shift and carry
207
+ * step for each moved bit. Optimisation is left as an exercise
208
+ * for the compiler.
209
+ */
210
+void bitmap_cut(unsigned long *dst, const unsigned long *src,
211
+		unsigned int first, unsigned int cut, unsigned int nbits)
212
+{
213
+	unsigned int len = BITS_TO_LONGS(nbits);
214
+	unsigned long keep = 0, carry;
215
+	int i;
216
+
217
+	if (first % BITS_PER_LONG) {
218
+		keep = src[first / BITS_PER_LONG] &
219
+		       (~0UL >> (BITS_PER_LONG - first % BITS_PER_LONG));
220
+	}
221
+
222
+	memmove(dst, src, len * sizeof(*dst));
223
+
224
+	while (cut--) {
225
+		for (i = first / BITS_PER_LONG; i < len; i++) {
226
+			if (i < len - 1)
227
+				carry = dst[i + 1] & 1UL;
228
+			else
229
+				carry = 0;
230
+
231
+			dst[i] = (dst[i] >> 1) | (carry << (BITS_PER_LONG - 1));
232
+		}
233
+	}
234
+
235
+	dst[first / BITS_PER_LONG] &= ~0UL << (first % BITS_PER_LONG);
236
+	dst[first / BITS_PER_LONG] |= keep;
237
+}
238
+EXPORT_SYMBOL(bitmap_cut);
239
+
156240 int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
157241 				const unsigned long *bitmap2, unsigned int bits)
158242 {
....@@ -206,6 +290,18 @@
206290 	return result != 0;
207291 }
208292 EXPORT_SYMBOL(__bitmap_andnot);
293
+
294
+void __bitmap_replace(unsigned long *dst,
295
+		      const unsigned long *old, const unsigned long *new,
296
+		      const unsigned long *mask, unsigned int nbits)
297
+{
298
+	unsigned int k;
299
+	unsigned int nr = BITS_TO_LONGS(nbits);
300
+
301
+	for (k = 0; k < nr; k++)
302
+		dst[k] = (old[k] & ~mask[k]) | (new[k] & mask[k]);
303
+}
304
+EXPORT_SYMBOL(__bitmap_replace);
209305 
210306 int __bitmap_intersects(const unsigned long *bitmap1,
211307 			const unsigned long *bitmap2, unsigned int bits)
....@@ -338,97 +434,6 @@
338434  * second version by Paul Jackson, third by Joe Korty.
339435  */
340436 
341
-#define CHUNKSZ				32
342
-#define nbits_to_hold_value(val)	fls(val)
343
-#define BASEDEC 10		/* fancier cpuset lists input in decimal */
344
-
345
-/**
346
- * __bitmap_parse - convert an ASCII hex string into a bitmap.
347
- * @buf: pointer to buffer containing string.
348
- * @buflen: buffer size in bytes.  If string is smaller than this
349
- *    then it must be terminated with a \0.
350
- * @is_user: location of buffer, 0 indicates kernel space
351
- * @maskp: pointer to bitmap array that will contain result.
352
- * @nmaskbits: size of bitmap, in bits.
353
- *
354
- * Commas group hex digits into chunks.  Each chunk defines exactly 32
355
- * bits of the resultant bitmask.  No chunk may specify a value larger
356
- * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
357
- * then leading 0-bits are prepended.  %-EINVAL is returned for illegal
358
- * characters and for grouping errors such as "1,,5", ",44", "," and "".
359
- * Leading and trailing whitespace accepted, but not embedded whitespace.
360
- */
361
-int __bitmap_parse(const char *buf, unsigned int buflen,
362
-		int is_user, unsigned long *maskp,
363
-		int nmaskbits)
364
-{
365
-	int c, old_c, totaldigits, ndigits, nchunks, nbits;
366
-	u32 chunk;
367
-	const char __user __force *ubuf = (const char __user __force *)buf;
368
-
369
-	bitmap_zero(maskp, nmaskbits);
370
-
371
-	nchunks = nbits = totaldigits = c = 0;
372
-	do {
373
-		chunk = 0;
374
-		ndigits = totaldigits;
375
-
376
-		/* Get the next chunk of the bitmap */
377
-		while (buflen) {
378
-			old_c = c;
379
-			if (is_user) {
380
-				if (__get_user(c, ubuf++))
381
-					return -EFAULT;
382
-			}
383
-			else
384
-				c = *buf++;
385
-			buflen--;
386
-			if (isspace(c))
387
-				continue;
388
-
389
-			/*
390
-			 * If the last character was a space and the current
391
-			 * character isn't '\0', we've got embedded whitespace.
392
-			 * This is a no-no, so throw an error.
393
-			 */
394
-			if (totaldigits && c && isspace(old_c))
395
-				return -EINVAL;
396
-
397
-			/* A '\0' or a ',' signal the end of the chunk */
398
-			if (c == '\0' || c == ',')
399
-				break;
400
-
401
-			if (!isxdigit(c))
402
-				return -EINVAL;
403
-
404
-			/*
405
-			 * Make sure there are at least 4 free bits in 'chunk'.
406
-			 * If not, this hexdigit will overflow 'chunk', so
407
-			 * throw an error.
408
-			 */
409
-			if (chunk & ~((1UL << (CHUNKSZ - 4)) - 1))
410
-				return -EOVERFLOW;
411
-
412
-			chunk = (chunk << 4) | hex_to_bin(c);
413
-			totaldigits++;
414
-		}
415
-		if (ndigits == totaldigits)
416
-			return -EINVAL;
417
-		if (nchunks == 0 && chunk == 0)
418
-			continue;
419
-
420
-		__bitmap_shift_left(maskp, maskp, CHUNKSZ, nmaskbits);
421
-		*maskp |= chunk;
422
-		nchunks++;
423
-		nbits += (nchunks == 1) ? nbits_to_hold_value(chunk) : CHUNKSZ;
424
-		if (nbits > nmaskbits)
425
-			return -EOVERFLOW;
426
-	} while (buflen && c == ',');
427
-
428
-	return 0;
429
-}
430
-EXPORT_SYMBOL(__bitmap_parse);
431
-
432437 /**
433438  * bitmap_parse_user - convert an ASCII hex string in a user buffer into a bitmap
434439  *
....@@ -437,22 +442,22 @@
437442  *    then it must be terminated with a \0.
438443  * @maskp: pointer to bitmap array that will contain result.
439444  * @nmaskbits: size of bitmap, in bits.
440
- *
441
- * Wrapper for __bitmap_parse(), providing it with user buffer.
442
- *
443
- * We cannot have this as an inline function in bitmap.h because it needs
444
- * linux/uaccess.h to get the access_ok() declaration and this causes
445
- * cyclic dependencies.
446445  */
447446 int bitmap_parse_user(const char __user *ubuf,
448447 			unsigned int ulen, unsigned long *maskp,
449448 			int nmaskbits)
450449 {
451
-	if (!access_ok(VERIFY_READ, ubuf, ulen))
452
-		return -EFAULT;
453
-	return __bitmap_parse((const char __force *)ubuf,
454
-				ulen, 1, maskp, nmaskbits);
450
+	char *buf;
451
+	int ret;
455452 
453
+	buf = memdup_user_nul(ubuf, ulen);
454
+	if (IS_ERR(buf))
455
+		return PTR_ERR(buf);
456
+
457
+	ret = bitmap_parse(buf, UINT_MAX, maskp, nmaskbits);
458
+
459
+	kfree(buf);
460
+	return ret;
456461 }
457462 EXPORT_SYMBOL(bitmap_parse_user);
458463 
....@@ -476,21 +481,142 @@
476481 			    int nmaskbits)
477482 {
478483 	ptrdiff_t len = PAGE_SIZE - offset_in_page(buf);
479
-	int n = 0;
480484 
481
-	if (len > 1)
482
-		n = list ? scnprintf(buf, len, "%*pbl\n", nmaskbits, maskp) :
483
-			   scnprintf(buf, len, "%*pb\n", nmaskbits, maskp);
484
-	return n;
485
+	return list ? scnprintf(buf, len, "%*pbl\n", nmaskbits, maskp) :
486
+		      scnprintf(buf, len, "%*pb\n", nmaskbits, maskp);
485487 }
486488 EXPORT_SYMBOL(bitmap_print_to_pagebuf);
487489 
490
+/*
491
+ * Region 9-38:4/10 describes the following bitmap structure:
492
+ * 0	   9  12    18			38
493
+ * .........****......****......****......
494
+ *	    ^  ^     ^			 ^
495
+ *      start  off   group_len	       end
496
+ */
497
+struct region {
498
+	unsigned int start;
499
+	unsigned int off;
500
+	unsigned int group_len;
501
+	unsigned int end;
502
+};
503
+
504
+static int bitmap_set_region(const struct region *r,
505
+				unsigned long *bitmap, int nbits)
506
+{
507
+	unsigned int start;
508
+
509
+	if (r->end >= nbits)
510
+		return -ERANGE;
511
+
512
+	for (start = r->start; start <= r->end; start += r->group_len)
513
+		bitmap_set(bitmap, start, min(r->end - start + 1, r->off));
514
+
515
+	return 0;
516
+}
517
+
518
+static int bitmap_check_region(const struct region *r)
519
+{
520
+	if (r->start > r->end || r->group_len == 0 || r->off > r->group_len)
521
+		return -EINVAL;
522
+
523
+	return 0;
524
+}
525
+
526
+static const char *bitmap_getnum(const char *str, unsigned int *num)
527
+{
528
+	unsigned long long n;
529
+	unsigned int len;
530
+
531
+	len = _parse_integer(str, 10, &n);
532
+	if (!len)
533
+		return ERR_PTR(-EINVAL);
534
+	if (len & KSTRTOX_OVERFLOW || n != (unsigned int)n)
535
+		return ERR_PTR(-EOVERFLOW);
536
+
537
+	*num = n;
538
+	return str + len;
539
+}
540
+
541
+static inline bool end_of_str(char c)
542
+{
543
+	return c == '\0' || c == '\n';
544
+}
545
+
546
+static inline bool __end_of_region(char c)
547
+{
548
+	return isspace(c) || c == ',';
549
+}
550
+
551
+static inline bool end_of_region(char c)
552
+{
553
+	return __end_of_region(c) || end_of_str(c);
554
+}
555
+
556
+/*
557
+ * The format allows commas and whitespaces at the beginning
558
+ * of the region.
559
+ */
560
+static const char *bitmap_find_region(const char *str)
561
+{
562
+	while (__end_of_region(*str))
563
+		str++;
564
+
565
+	return end_of_str(*str) ? NULL : str;
566
+}
567
+
568
+static const char *bitmap_find_region_reverse(const char *start, const char *end)
569
+{
570
+	while (start <= end && __end_of_region(*end))
571
+		end--;
572
+
573
+	return end;
574
+}
575
+
576
+static const char *bitmap_parse_region(const char *str, struct region *r)
577
+{
578
+	str = bitmap_getnum(str, &r->start);
579
+	if (IS_ERR(str))
580
+		return str;
581
+
582
+	if (end_of_region(*str))
583
+		goto no_end;
584
+
585
+	if (*str != '-')
586
+		return ERR_PTR(-EINVAL);
587
+
588
+	str = bitmap_getnum(str + 1, &r->end);
589
+	if (IS_ERR(str))
590
+		return str;
591
+
592
+	if (end_of_region(*str))
593
+		goto no_pattern;
594
+
595
+	if (*str != ':')
596
+		return ERR_PTR(-EINVAL);
597
+
598
+	str = bitmap_getnum(str + 1, &r->off);
599
+	if (IS_ERR(str))
600
+		return str;
601
+
602
+	if (*str != '/')
603
+		return ERR_PTR(-EINVAL);
604
+
605
+	return bitmap_getnum(str + 1, &r->group_len);
606
+
607
+no_end:
608
+	r->end = r->start;
609
+no_pattern:
610
+	r->off = r->end + 1;
611
+	r->group_len = r->end + 1;
612
+
613
+	return end_of_str(*str) ? NULL : str;
614
+}
615
+
488616 /**
489
- * __bitmap_parselist - convert list format ASCII string to bitmap
490
- * @buf: read nul-terminated user string from this buffer
491
- * @buflen: buffer size in bytes.  If string is smaller than this
492
- *    then it must be terminated with a \0.
493
- * @is_user: location of buffer, 0 indicates kernel space
617
+ * bitmap_parselist - convert list format ASCII string to bitmap
618
+ * @buf: read user string from this buffer; must be terminated
619
+ *    with a \0 or \n.
494620  * @maskp: write resulting mask here
495621  * @nmaskbits: number of bits in mask to be written
496622  *
....@@ -506,126 +632,37 @@
506632  *
507633  * Returns: 0 on success, -errno on invalid input strings. Error values:
508634  *
509
- *   - ``-EINVAL``: second number in range smaller than first
635
+ *   - ``-EINVAL``: wrong region format
510636  *   - ``-EINVAL``: invalid character in string
511637  *   - ``-ERANGE``: bit number specified too large for mask
638
+ *   - ``-EOVERFLOW``: integer overflow in the input parameters
512639  */
513
-static int __bitmap_parselist(const char *buf, unsigned int buflen,
514
-		int is_user, unsigned long *maskp,
515
-		int nmaskbits)
640
+int bitmap_parselist(const char *buf, unsigned long *maskp, int nmaskbits)
516641 {
517
-	unsigned int a, b, old_a, old_b;
518
-	unsigned int group_size, used_size, off;
519
-	int c, old_c, totaldigits, ndigits;
520
-	const char __user __force *ubuf = (const char __user __force *)buf;
521
-	int at_start, in_range, in_partial_range;
642
+	struct region r;
643
+	long ret;
522644 
523
-	totaldigits = c = 0;
524
-	old_a = old_b = 0;
525
-	group_size = used_size = 0;
526645 	bitmap_zero(maskp, nmaskbits);
527
-	do {
528
-		at_start = 1;
529
-		in_range = 0;
530
-		in_partial_range = 0;
531
-		a = b = 0;
532
-		ndigits = totaldigits;
533646 
534
-		/* Get the next cpu# or a range of cpu#'s */
535
-		while (buflen) {
536
-			old_c = c;
537
-			if (is_user) {
538
-				if (__get_user(c, ubuf++))
539
-					return -EFAULT;
540
-			} else
541
-				c = *buf++;
542
-			buflen--;
543
-			if (isspace(c))
544
-				continue;
647
+	while (buf) {
648
+		buf = bitmap_find_region(buf);
649
+		if (buf == NULL)
650
+			return 0;
545651 
546
-			/* A '\0' or a ',' signal the end of a cpu# or range */
547
-			if (c == '\0' || c == ',')
548
-				break;
549
-			/*
550
-			* whitespaces between digits are not allowed,
551
-			* but it's ok if whitespaces are on head or tail.
552
-			* when old_c is whilespace,
553
-			* if totaldigits == ndigits, whitespace is on head.
554
-			* if whitespace is on tail, it should not run here.
555
-			* as c was ',' or '\0',
556
-			* the last code line has broken the current loop.
557
-			*/
558
-			if ((totaldigits != ndigits) && isspace(old_c))
559
-				return -EINVAL;
652
+		buf = bitmap_parse_region(buf, &r);
653
+		if (IS_ERR(buf))
654
+			return PTR_ERR(buf);
560655 
561
-			if (c == '/') {
562
-				used_size = a;
563
-				at_start = 1;
564
-				in_range = 0;
565
-				a = b = 0;
566
-				continue;
567
-			}
656
+		ret = bitmap_check_region(&r);
657
+		if (ret)
658
+			return ret;
568659 
569
-			if (c == ':') {
570
-				old_a = a;
571
-				old_b = b;
572
-				at_start = 1;
573
-				in_range = 0;
574
-				in_partial_range = 1;
575
-				a = b = 0;
576
-				continue;
577
-			}
660
+		ret = bitmap_set_region(&r, maskp, nmaskbits);
661
+		if (ret)
662
+			return ret;
663
+	}
578664 
579
-			if (c == '-') {
580
-				if (at_start || in_range)
581
-					return -EINVAL;
582
-				b = 0;
583
-				in_range = 1;
584
-				at_start = 1;
585
-				continue;
586
-			}
587
-
588
-			if (!isdigit(c))
589
-				return -EINVAL;
590
-
591
-			b = b * 10 + (c - '0');
592
-			if (!in_range)
593
-				a = b;
594
-			at_start = 0;
595
-			totaldigits++;
596
-		}
597
-		if (ndigits == totaldigits)
598
-			continue;
599
-		if (in_partial_range) {
600
-			group_size = a;
601
-			a = old_a;
602
-			b = old_b;
603
-			old_a = old_b = 0;
604
-		} else {
605
-			used_size = group_size = b - a + 1;
606
-		}
607
-		/* if no digit is after '-', it's wrong*/
608
-		if (at_start && in_range)
609
-			return -EINVAL;
610
-		if (!(a <= b) || group_size == 0 || !(used_size <= group_size))
611
-			return -EINVAL;
612
-		if (b >= nmaskbits)
613
-			return -ERANGE;
614
-		while (a <= b) {
615
-			off = min(b - a + 1, used_size);
616
-			bitmap_set(maskp, a, off);
617
-			a += group_size;
618
-		}
619
-	} while (buflen && c == ',');
620665 	return 0;
621
-}
622
-
623
-int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
624
-{
625
-	char *nl  = strchrnul(bp, '\n');
626
-	int len = nl - bp;
627
-
628
-	return __bitmap_parselist(bp, len, 0, maskp, nmaskbits);
629666 }
630667 EXPORT_SYMBOL(bitmap_parselist);
631668 
....@@ -640,23 +677,106 @@
640677  * @nmaskbits: size of bitmap, in bits.
641678  *
642679  * Wrapper for bitmap_parselist(), providing it with user buffer.
643
- *
644
- * We cannot have this as an inline function in bitmap.h because it needs
645
- * linux/uaccess.h to get the access_ok() declaration and this causes
646
- * cyclic dependencies.
647680  */
648681 int bitmap_parselist_user(const char __user *ubuf,
649682 			unsigned int ulen, unsigned long *maskp,
650683 			int nmaskbits)
651684 {
652
-	if (!access_ok(VERIFY_READ, ubuf, ulen))
653
-		return -EFAULT;
654
-	return __bitmap_parselist((const char __force *)ubuf,
655
-					ulen, 1, maskp, nmaskbits);
685
+	char *buf;
686
+	int ret;
687
+
688
+	buf = memdup_user_nul(ubuf, ulen);
689
+	if (IS_ERR(buf))
690
+		return PTR_ERR(buf);
691
+
692
+	ret = bitmap_parselist(buf, maskp, nmaskbits);
693
+
694
+	kfree(buf);
695
+	return ret;
656696 }
657697 EXPORT_SYMBOL(bitmap_parselist_user);
658698 
699
+static const char *bitmap_get_x32_reverse(const char *start,
700
+					const char *end, u32 *num)
701
+{
702
+	u32 ret = 0;
703
+	int c, i;
659704 
705
+	for (i = 0; i < 32; i += 4) {
706
+		c = hex_to_bin(*end--);
707
+		if (c < 0)
708
+			return ERR_PTR(-EINVAL);
709
+
710
+		ret |= c << i;
711
+
712
+		if (start > end || __end_of_region(*end))
713
+			goto out;
714
+	}
715
+
716
+	if (hex_to_bin(*end--) >= 0)
717
+		return ERR_PTR(-EOVERFLOW);
718
+out:
719
+	*num = ret;
720
+	return end;
721
+}
722
+
723
+/**
724
+ * bitmap_parse - convert an ASCII hex string into a bitmap.
725
+ * @start: pointer to buffer containing string.
726
+ * @buflen: buffer size in bytes.  If string is smaller than this
727
+ *    then it must be terminated with a \0 or \n. In that case,
728
+ *    UINT_MAX may be provided instead of string length.
729
+ * @maskp: pointer to bitmap array that will contain result.
730
+ * @nmaskbits: size of bitmap, in bits.
731
+ *
732
+ * Commas group hex digits into chunks.  Each chunk defines exactly 32
733
+ * bits of the resultant bitmask.  No chunk may specify a value larger
734
+ * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
735
+ * then leading 0-bits are prepended.  %-EINVAL is returned for illegal
736
+ * characters. Grouping such as "1,,5", ",44", "," or "" is allowed.
737
+ * Leading, embedded and trailing whitespace accepted.
738
+ */
739
+int bitmap_parse(const char *start, unsigned int buflen,
740
+		unsigned long *maskp, int nmaskbits)
741
+{
742
+	const char *end = strnchrnul(start, buflen, '\n') - 1;
743
+	int chunks = BITS_TO_U32(nmaskbits);
744
+	u32 *bitmap = (u32 *)maskp;
745
+	int unset_bit;
746
+	int chunk;
747
+
748
+	for (chunk = 0; ; chunk++) {
749
+		end = bitmap_find_region_reverse(start, end);
750
+		if (start > end)
751
+			break;
752
+
753
+		if (!chunks--)
754
+			return -EOVERFLOW;
755
+
756
+#if defined(CONFIG_64BIT) && defined(__BIG_ENDIAN)
757
+		end = bitmap_get_x32_reverse(start, end, &bitmap[chunk ^ 1]);
758
+#else
759
+		end = bitmap_get_x32_reverse(start, end, &bitmap[chunk]);
760
+#endif
761
+		if (IS_ERR(end))
762
+			return PTR_ERR(end);
763
+	}
764
+
765
+	unset_bit = (BITS_TO_U32(nmaskbits) - chunks) * 32;
766
+	if (unset_bit < nmaskbits) {
767
+		bitmap_clear(maskp, unset_bit, nmaskbits - unset_bit);
768
+		return 0;
769
+	}
770
+
771
+	if (find_next_bit(maskp, unset_bit, nmaskbits) != unset_bit)
772
+		return -EOVERFLOW;
773
+
774
+	return 0;
775
+}
776
+EXPORT_SYMBOL(bitmap_parse);
777
+
778
+
779
+#ifdef CONFIG_NUMA
660780 /**
661781  * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
662782  *	@buf: pointer to a bitmap
....@@ -765,7 +885,6 @@
765885 			set_bit(bitmap_ord_to_pos(new, n % w, nbits), dst);
766886 	}
767887 }
768
-EXPORT_SYMBOL(bitmap_remap);
769888 
770889 /**
771890  * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit
....@@ -803,7 +922,6 @@
803922 	else
804923 		return bitmap_ord_to_pos(new, n % w, bits);
805924 }
806
-EXPORT_SYMBOL(bitmap_bitremap);
807925 
808926 /**
809927  * bitmap_onto - translate one bitmap relative to another
....@@ -938,7 +1056,6 @@
9381056 		m++;
9391057 	}
9401058 }
941
-EXPORT_SYMBOL(bitmap_onto);
9421059 
9431060 /**
9441061  * bitmap_fold - fold larger bitmap into smaller, modulo specified size
....@@ -963,7 +1080,7 @@
9631080 	for_each_set_bit(oldbit, orig, nbits)
9641081 		set_bit(oldbit % sz, dst);
9651082 }
966
-EXPORT_SYMBOL(bitmap_fold);
1083
+#endif /* CONFIG_NUMA */
9671084 
9681085 /*
9691086  * Common code for bitmap_*_region() routines.
....@@ -1147,6 +1264,38 @@
11471264 }
11481265 EXPORT_SYMBOL(bitmap_free);
11491266 
1267
+static void devm_bitmap_free(void *data)
1268
+{
1269
+	unsigned long *bitmap = data;
1270
+
1271
+	bitmap_free(bitmap);
1272
+}
1273
+
1274
+unsigned long *devm_bitmap_alloc(struct device *dev,
1275
+				 unsigned int nbits, gfp_t flags)
1276
+{
1277
+	unsigned long *bitmap;
1278
+	int ret;
1279
+
1280
+	bitmap = bitmap_alloc(nbits, flags);
1281
+	if (!bitmap)
1282
+		return NULL;
1283
+
1284
+	ret = devm_add_action_or_reset(dev, devm_bitmap_free, bitmap);
1285
+	if (ret)
1286
+		return NULL;
1287
+
1288
+	return bitmap;
1289
+}
1290
+EXPORT_SYMBOL_GPL(devm_bitmap_alloc);
1291
+
1292
+unsigned long *devm_bitmap_zalloc(struct device *dev,
1293
+				  unsigned int nbits, gfp_t flags)
1294
+{
1295
+	return devm_bitmap_alloc(dev, nbits, flags | __GFP_ZERO);
1296
+}
1297
+EXPORT_SYMBOL_GPL(devm_bitmap_zalloc);
1298
+
11501299 #if BITS_PER_LONG == 64
11511300 /**
11521301  * bitmap_from_arr32 - copy the contents of u32 array of bits to bitmap