linux-kernel - [PATCH v2] lib/bitmap.c: enhance bitmap syntax

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-ID: <1468737234-29232-1-git-send-email-noamca@mellanox.com>
Date:	Sun, 17 Jul 2016 09:33:54 +0300
From:	Noam Camus <noamca@...lanox.com>
To:	<decot@...glers.com>
CC:	<ben@...adent.org.uk>, <davem@...emloft.net>,
	<akpm@...ux-foundation.org>, <linux-kernel@...r.kernel.org>,
	Noam Camus <noamca@...lanox.com>
Subject: [PATCH v2] lib/bitmap.c: enhance bitmap syntax

From: Noam Camus <noamca@...lanox.com>

Today there are platforms with many CPUs (up to 4K).
Trying to boot only part of the CPUs may result in too long string.

For example lets take NPS platform that is part of arch/arc.
This platform have SMP system with 256 cores each with
16 HW threads (SMT machine) where HW thread appears as CPU to the kernel.
In this example there is total of 4K CPUs.
When one tries to boot only part of the HW threads from each core the
string representing the map may be long...
For example if for sake of performance we decided to boot only first half
of HW threads of each core the map will look like:
0-7,16-23,32,39,...,4080-4087

This patch introduce new syntax to accommodate with such use case.
I added an optional postfix to a range of CPUs which will choose
according to given modulo the desired range of reminders i.e.:
	<cpus range>%modulo=<range of reminders>

For example, above map can be described in new symtax like this:
0-4095%16=0-7

Note that this patch is backward compatible with current syntax.

Signed-off-by: Noam Camus <noamca@...lanox.com>
---
Change Log:
Fixed typo at below example:
"0-1023%256=0-2" turned into "0-1023%256=0-1"

Syntax need to be yet more eligible for such generic code, ideas are welcomed.
---
 lib/bitmap.c |   44 ++++++++++++++++++++++++++++++++++++++++----
 1 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/lib/bitmap.c b/lib/bitmap.c
index c66da50..bccfd87 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -496,6 +496,9 @@ EXPORT_SYMBOL(bitmap_print_to_pagebuf);
  * ranges.  Consecutively set bits are shown as two hyphen-separated
  * decimal numbers, the smallest and largest bit numbers set in
  * the range.
+ * Optionally each range can be postfixed to denote that only parts of it
+ * should be set. The parts are the range of reminders modulo some value.
+ * i.e. range%mod=rem_range e.g. 0-1023%256=0-1 ==> 0,1,256,257,512,513,768,769
  *
  * Returns 0 on success, -errno on invalid input strings.
  * Error values:
@@ -507,12 +510,14 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
 		int is_user, unsigned long *maskp,
 		int nmaskbits)
 {
-	unsigned a, b;
+	unsigned int a, b, old_a, old_b, mod_val, mod_a, mod_b;
 	int c, old_c, totaldigits, ndigits;
 	const char __user __force *ubuf = (const char __user __force *)buf;
 	int at_start, in_range;
 
 	totaldigits = c = 0;
+	old_a = old_b = 0;
+	mod_val = mod_a = mod_b = 0;
 	bitmap_zero(maskp, nmaskbits);
 	do {
 		at_start = 1;
@@ -547,6 +552,23 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
 			if ((totaldigits != ndigits) && isspace(old_c))
 				return -EINVAL;
 
+			if (c == '=') {
+				mod_val = a;
+				at_start = 1;
+				in_range = 0;
+				a = b = 0;
+				continue;
+			}
+
+			if (c == '%') {
+				old_a = a;
+				old_b = b;
+				at_start = 1;
+				in_range = 0;
+				a = b = 0;
+				continue;
+			}
+
 			if (c == '-') {
 				if (at_start || in_range)
 					return -EINVAL;
@@ -567,17 +589,31 @@ static int __bitmap_parselist(const char *buf, unsigned int buflen,
 		}
 		if (ndigits == totaldigits)
 			continue;
+		if (mod_val) {
+			mod_a = a;
+			mod_b = b;
+			a = old_a;
+			b = old_b;
+			old_a = old_b = 0;
+		}
 		/* if no digit is after '-', it's wrong*/
 		if (at_start && in_range)
 			return -EINVAL;
-		if (!(a <= b))
+		if (!(a <= b) || !(mod_a <= mod_b))
 			return -EINVAL;
-		if (b >= nmaskbits)
+		if (b >= nmaskbits || (mod_val && (mod_b >= mod_val)))
 			return -ERANGE;
 		while (a <= b) {
-			set_bit(a, maskp);
+			if (mod_val) {
+				unsigned int rem = a % mod_val;
+
+				if (rem >= mod_a && rem <= mod_b)
+					set_bit(a, maskp);
+			} else
+				set_bit(a, maskp);
 			a++;
 		}
+		mod_val = mod_a = mod_b = 0;
 	} while (buflen && c == ',');
 	return 0;
 }
-- 
1.7.1