Commit f0b7f8ad authored by Andy Shevchenko's avatar Andy Shevchenko Committed by Kees Cook
Browse files

lib/string_helpers: Add flags param to string_get_size() 



The new flags parameter allows controlling
 - Whether or not the units suffix is separated by a space, for
   compatibility with sort -h
 - Whether or not to append a B suffix - we're not always printing
   bytes.

Co-developed-by: default avatarKent Overstreet <kent.overstreet@linux.dev>
Signed-off-by: default avatarKent Overstreet <kent.overstreet@linux.dev>
Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Reviewed-by: default avatarKent Overstreet <kent.overstreet@linux.dev>
Link: https://lore.kernel.org/r/20240229205345.93902-1-andriy.shevchenko@linux.intel.com


Signed-off-by: default avatarKees Cook <keescook@chromium.org>
parent aaa87363

include/linux/string_helpers.h

+7 −3
Original line number Diff line number Diff line
@@ -17,14 +17,18 @@ static inline bool string_is_terminated(const char *s, int len) 
	return memchr(s, '\0', len) ? true : false;

}



/* Descriptions of the types of units to

 * print in */

/* Descriptions of the types of units to print in */

enum string_size_units {

	STRING_UNITS_10,	/* use powers of 10^3 (standard SI) */

	STRING_UNITS_2,		/* use binary powers of 2^10 */

	STRING_UNITS_MASK	= BIT(0),



	/* Modifiers */

	STRING_UNITS_NO_SPACE	= BIT(30),

	STRING_UNITS_NO_BYTES	= BIT(31),

};



int string_get_size(u64 size, u64 blk_size, enum string_size_units units,

int string_get_size(u64 size, u64 blk_size, const enum string_size_units units,

		    char *buf, int len);



int parse_int_array_user(const char __user *from, size_t count, int **array);

lib/string_helpers.c

+16 −13
Original line number Diff line number Diff line
@@ -25,7 +25,7 @@ 
 * string_get_size - get the size in the specified units

 * @size:	The size to be converted in blocks

 * @blk_size:	Size of the block (use 1 for size in bytes)

 * @units:	units to use (powers of 1000 or 1024)

 * @units:	Units to use (powers of 1000 or 1024), whether to include space separator

 * @buf:	buffer to format to

 * @len:	length of buffer

 *
@@ -39,11 +39,12 @@ 
int string_get_size(u64 size, u64 blk_size, const enum string_size_units units,

		    char *buf, int len)

{

	enum string_size_units units_base = units & STRING_UNITS_MASK;

	static const char *const units_10[] = {

		"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"

		"", "k", "M", "G", "T", "P", "E", "Z", "Y",

	};

	static const char *const units_2[] = {

		"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"

		"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi",

	};

	static const char *const *const units_str[] = {

		[STRING_UNITS_10] = units_10,
@@ -68,7 +69,7 @@ int string_get_size(u64 size, u64 blk_size, const enum string_size_units units, 


	/* This is Napier's algorithm.  Reduce the original block size to

	 *

	 * coefficient * divisor[units]^i

	 * coefficient * divisor[units_base]^i

	 *

	 * we do the reduction so both coefficients are just under 32 bits so

	 * that multiplying them together won't overflow 64 bits and we keep
@@ -78,12 +79,12 @@ int string_get_size(u64 size, u64 blk_size, const enum string_size_units units, 
	 * precision is in the coefficients.

	 */

	while (blk_size >> 32) {

		do_div(blk_size, divisor[units]);

		do_div(blk_size, divisor[units_base]);

		i++;

	}



	while (size >> 32) {

		do_div(size, divisor[units]);

		do_div(size, divisor[units_base]);

		i++;

	}
@@ -92,8 +93,8 @@ int string_get_size(u64 size, u64 blk_size, const enum string_size_units units, 
	size *= blk_size;



	/* and logarithmically reduce it until it's just under the divisor */

	while (size >= divisor[units]) {

		remainder = do_div(size, divisor[units]);

	while (size >= divisor[units_base]) {

		remainder = do_div(size, divisor[units_base]);

		i++;

	}
@@ -103,10 +104,10 @@ int string_get_size(u64 size, u64 blk_size, const enum string_size_units units, 
	for (j = 0; sf_cap*10 < 1000; j++)

		sf_cap *= 10;



	if (units == STRING_UNITS_2) {

	if (units_base == STRING_UNITS_2) {

		/* express the remainder as a decimal.  It's currently the

		 * numerator of a fraction whose denominator is

		 * divisor[units], which is 1 << 10 for STRING_UNITS_2 */

		 * divisor[units_base], which is 1 << 10 for STRING_UNITS_2 */

		remainder *= 1000;

		remainder >>= 10;

	}
@@ -128,10 +129,12 @@ int string_get_size(u64 size, u64 blk_size, const enum string_size_units units, 
	if (i >= ARRAY_SIZE(units_2))

		unit = "UNK";

	else

		unit = units_str[units][i];

		unit = units_str[units_base][i];



	return snprintf(buf, len, "%u%s %s", (u32)size,

			tmp, unit);

	return snprintf(buf, len, "%u%s%s%s%s", (u32)size, tmp,

			(units & STRING_UNITS_NO_SPACE) ? "" : " ",

			unit,

			(units & STRING_UNITS_NO_BYTES) ? "" : "B");

}

EXPORT_SYMBOL(string_get_size);

lib/test-string_helpers.c

+54 −9
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/array_size.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/slab.h>
@@ -500,21 +501,65 @@ static __init void test_string_get_size_check(const char *units, 
	pr_warn("expected: '%s', got '%s'\n", exp, res);

}



static __init void __test_string_get_size(const u64 size, const u64 blk_size,

static __init void __strchrcut(char *dst, const char *src, const char *cut)

{

	const char *from = src;

	size_t len;



	do {

		len = strcspn(from, cut);

		memcpy(dst, from, len);

		dst += len;

		from += len;

	} while (*from++);

	*dst = '\0';

}



static __init void __test_string_get_size_one(const u64 size, const u64 blk_size,

					      const char *exp_result10,

					  const char *exp_result2)

					      const char *exp_result2,

					      enum string_size_units units,

					      const char *cut)

{

	char buf10[string_get_size_maxbuf];

	char buf2[string_get_size_maxbuf];

	char exp10[string_get_size_maxbuf];

	char exp2[string_get_size_maxbuf];

	char prefix10[64];

	char prefix2[64];



	sprintf(prefix10, "STRING_UNITS_10 [%s]", cut);

	sprintf(prefix2, "STRING_UNITS_2 [%s]", cut);



	string_get_size(size, blk_size, STRING_UNITS_10, buf10, sizeof(buf10));

	string_get_size(size, blk_size, STRING_UNITS_2, buf2, sizeof(buf2));

	__strchrcut(exp10, exp_result10, cut);

	__strchrcut(exp2, exp_result2, cut);



	test_string_get_size_check("STRING_UNITS_10", exp_result10, buf10,

				   size, blk_size);

	string_get_size(size, blk_size, STRING_UNITS_10 | units, buf10, sizeof(buf10));

	string_get_size(size, blk_size, STRING_UNITS_2 | units, buf2, sizeof(buf2));



	test_string_get_size_check(prefix10, exp10, buf10, size, blk_size);

	test_string_get_size_check(prefix2, exp2, buf2, size, blk_size);

}



static __init void __test_string_get_size(const u64 size, const u64 blk_size,

					  const char *exp_result10,

					  const char *exp_result2)

{

	struct {

		enum string_size_units units;

		const char *cut;

	} get_size_test_cases[] = {

		{ 0, "" },

		{ STRING_UNITS_NO_SPACE, " " },

		{ STRING_UNITS_NO_SPACE | STRING_UNITS_NO_BYTES, " B" },

		{ STRING_UNITS_NO_BYTES, "B" },

	};

	int i;



	test_string_get_size_check("STRING_UNITS_2", exp_result2, buf2,

				   size, blk_size);

	for (i = 0; i < ARRAY_SIZE(get_size_test_cases); i++)

		__test_string_get_size_one(size, blk_size, exp_result10, exp_result2,

					   get_size_test_cases[i].units,

					   get_size_test_cases[i].cut);

}



static __init void test_string_get_size(void)