Linux Audio

Check our new training course

Loading...
v5.14.15
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Helpers for formatting and printing strings
  4 *
  5 * Copyright 31 August 2008 James Bottomley
  6 * Copyright (C) 2013, Intel Corporation
  7 */
  8#include <linux/bug.h>
  9#include <linux/kernel.h>
 10#include <linux/math64.h>
 11#include <linux/export.h>
 12#include <linux/ctype.h>
 
 13#include <linux/errno.h>
 14#include <linux/fs.h>
 15#include <linux/limits.h>
 16#include <linux/mm.h>
 17#include <linux/slab.h>
 18#include <linux/string.h>
 19#include <linux/string_helpers.h>
 
 
 20
 21/**
 22 * string_get_size - get the size in the specified units
 23 * @size:	The size to be converted in blocks
 24 * @blk_size:	Size of the block (use 1 for size in bytes)
 25 * @units:	units to use (powers of 1000 or 1024)
 26 * @buf:	buffer to format to
 27 * @len:	length of buffer
 28 *
 29 * This function returns a string formatted to 3 significant figures
 30 * giving the size in the required units.  @buf should have room for
 31 * at least 9 bytes and will always be zero terminated.
 32 *
 
 
 33 */
 34void string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
 35		     char *buf, int len)
 36{
 
 37	static const char *const units_10[] = {
 38		"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"
 39	};
 40	static const char *const units_2[] = {
 41		"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"
 42	};
 43	static const char *const *const units_str[] = {
 44		[STRING_UNITS_10] = units_10,
 45		[STRING_UNITS_2] = units_2,
 46	};
 47	static const unsigned int divisor[] = {
 48		[STRING_UNITS_10] = 1000,
 49		[STRING_UNITS_2] = 1024,
 50	};
 51	static const unsigned int rounding[] = { 500, 50, 5 };
 52	int i = 0, j;
 53	u32 remainder = 0, sf_cap;
 54	char tmp[8];
 55	const char *unit;
 56
 57	tmp[0] = '\0';
 58
 59	if (blk_size == 0)
 60		size = 0;
 61	if (size == 0)
 62		goto out;
 63
 64	/* This is Napier's algorithm.  Reduce the original block size to
 65	 *
 66	 * coefficient * divisor[units]^i
 67	 *
 68	 * we do the reduction so both coefficients are just under 32 bits so
 69	 * that multiplying them together won't overflow 64 bits and we keep
 70	 * as much precision as possible in the numbers.
 71	 *
 72	 * Note: it's safe to throw away the remainders here because all the
 73	 * precision is in the coefficients.
 74	 */
 75	while (blk_size >> 32) {
 76		do_div(blk_size, divisor[units]);
 77		i++;
 78	}
 79
 80	while (size >> 32) {
 81		do_div(size, divisor[units]);
 82		i++;
 83	}
 84
 85	/* now perform the actual multiplication keeping i as the sum of the
 86	 * two logarithms */
 87	size *= blk_size;
 88
 89	/* and logarithmically reduce it until it's just under the divisor */
 90	while (size >= divisor[units]) {
 91		remainder = do_div(size, divisor[units]);
 92		i++;
 93	}
 94
 95	/* work out in j how many digits of precision we need from the
 96	 * remainder */
 97	sf_cap = size;
 98	for (j = 0; sf_cap*10 < 1000; j++)
 99		sf_cap *= 10;
100
101	if (units == STRING_UNITS_2) {
102		/* express the remainder as a decimal.  It's currently the
103		 * numerator of a fraction whose denominator is
104		 * divisor[units], which is 1 << 10 for STRING_UNITS_2 */
105		remainder *= 1000;
106		remainder >>= 10;
107	}
108
109	/* add a 5 to the digit below what will be printed to ensure
110	 * an arithmetical round up and carry it through to size */
111	remainder += rounding[j];
112	if (remainder >= 1000) {
113		remainder -= 1000;
114		size += 1;
115	}
116
117	if (j) {
118		snprintf(tmp, sizeof(tmp), ".%03u", remainder);
119		tmp[j+1] = '\0';
120	}
121
122 out:
123	if (i >= ARRAY_SIZE(units_2))
124		unit = "UNK";
125	else
126		unit = units_str[units][i];
127
128	snprintf(buf, len, "%u%s %s", (u32)size,
129		 tmp, unit);
 
 
130}
131EXPORT_SYMBOL(string_get_size);
132
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
133static bool unescape_space(char **src, char **dst)
134{
135	char *p = *dst, *q = *src;
136
137	switch (*q) {
138	case 'n':
139		*p = '\n';
140		break;
141	case 'r':
142		*p = '\r';
143		break;
144	case 't':
145		*p = '\t';
146		break;
147	case 'v':
148		*p = '\v';
149		break;
150	case 'f':
151		*p = '\f';
152		break;
153	default:
154		return false;
155	}
156	*dst += 1;
157	*src += 1;
158	return true;
159}
160
161static bool unescape_octal(char **src, char **dst)
162{
163	char *p = *dst, *q = *src;
164	u8 num;
165
166	if (isodigit(*q) == 0)
167		return false;
168
169	num = (*q++) & 7;
170	while (num < 32 && isodigit(*q) && (q - *src < 3)) {
171		num <<= 3;
172		num += (*q++) & 7;
173	}
174	*p = num;
175	*dst += 1;
176	*src = q;
177	return true;
178}
179
180static bool unescape_hex(char **src, char **dst)
181{
182	char *p = *dst, *q = *src;
183	int digit;
184	u8 num;
185
186	if (*q++ != 'x')
187		return false;
188
189	num = digit = hex_to_bin(*q++);
190	if (digit < 0)
191		return false;
192
193	digit = hex_to_bin(*q);
194	if (digit >= 0) {
195		q++;
196		num = (num << 4) | digit;
197	}
198	*p = num;
199	*dst += 1;
200	*src = q;
201	return true;
202}
203
204static bool unescape_special(char **src, char **dst)
205{
206	char *p = *dst, *q = *src;
207
208	switch (*q) {
209	case '\"':
210		*p = '\"';
211		break;
212	case '\\':
213		*p = '\\';
214		break;
215	case 'a':
216		*p = '\a';
217		break;
218	case 'e':
219		*p = '\e';
220		break;
221	default:
222		return false;
223	}
224	*dst += 1;
225	*src += 1;
226	return true;
227}
228
229/**
230 * string_unescape - unquote characters in the given string
231 * @src:	source buffer (escaped)
232 * @dst:	destination buffer (unescaped)
233 * @size:	size of the destination buffer (0 to unlimit)
234 * @flags:	combination of the flags.
235 *
236 * Description:
237 * The function unquotes characters in the given string.
238 *
239 * Because the size of the output will be the same as or less than the size of
240 * the input, the transformation may be performed in place.
241 *
242 * Caller must provide valid source and destination pointers. Be aware that
243 * destination buffer will always be NULL-terminated. Source string must be
244 * NULL-terminated as well.  The supported flags are::
245 *
246 *	UNESCAPE_SPACE:
247 *		'\f' - form feed
248 *		'\n' - new line
249 *		'\r' - carriage return
250 *		'\t' - horizontal tab
251 *		'\v' - vertical tab
252 *	UNESCAPE_OCTAL:
253 *		'\NNN' - byte with octal value NNN (1 to 3 digits)
254 *	UNESCAPE_HEX:
255 *		'\xHH' - byte with hexadecimal value HH (1 to 2 digits)
256 *	UNESCAPE_SPECIAL:
257 *		'\"' - double quote
258 *		'\\' - backslash
259 *		'\a' - alert (BEL)
260 *		'\e' - escape
261 *	UNESCAPE_ANY:
262 *		all previous together
263 *
264 * Return:
265 * The amount of the characters processed to the destination buffer excluding
266 * trailing '\0' is returned.
267 */
268int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
269{
270	char *out = dst;
271
 
 
 
272	while (*src && --size) {
273		if (src[0] == '\\' && src[1] != '\0' && size > 1) {
274			src++;
275			size--;
276
277			if (flags & UNESCAPE_SPACE &&
278					unescape_space(&src, &out))
279				continue;
280
281			if (flags & UNESCAPE_OCTAL &&
282					unescape_octal(&src, &out))
283				continue;
284
285			if (flags & UNESCAPE_HEX &&
286					unescape_hex(&src, &out))
287				continue;
288
289			if (flags & UNESCAPE_SPECIAL &&
290					unescape_special(&src, &out))
291				continue;
292
293			*out++ = '\\';
294		}
295		*out++ = *src++;
296	}
297	*out = '\0';
298
299	return out - dst;
300}
301EXPORT_SYMBOL(string_unescape);
302
303static bool escape_passthrough(unsigned char c, char **dst, char *end)
304{
305	char *out = *dst;
306
307	if (out < end)
308		*out = c;
309	*dst = out + 1;
310	return true;
311}
312
313static bool escape_space(unsigned char c, char **dst, char *end)
314{
315	char *out = *dst;
316	unsigned char to;
317
318	switch (c) {
319	case '\n':
320		to = 'n';
321		break;
322	case '\r':
323		to = 'r';
324		break;
325	case '\t':
326		to = 't';
327		break;
328	case '\v':
329		to = 'v';
330		break;
331	case '\f':
332		to = 'f';
333		break;
334	default:
335		return false;
336	}
337
338	if (out < end)
339		*out = '\\';
340	++out;
341	if (out < end)
342		*out = to;
343	++out;
344
345	*dst = out;
346	return true;
347}
348
349static bool escape_special(unsigned char c, char **dst, char *end)
350{
351	char *out = *dst;
352	unsigned char to;
353
354	switch (c) {
355	case '\\':
356		to = '\\';
357		break;
358	case '\a':
359		to = 'a';
360		break;
361	case '\e':
362		to = 'e';
363		break;
 
 
 
364	default:
365		return false;
366	}
367
368	if (out < end)
369		*out = '\\';
370	++out;
371	if (out < end)
372		*out = to;
373	++out;
374
375	*dst = out;
376	return true;
377}
378
379static bool escape_null(unsigned char c, char **dst, char *end)
380{
381	char *out = *dst;
382
383	if (c)
384		return false;
385
386	if (out < end)
387		*out = '\\';
388	++out;
389	if (out < end)
390		*out = '0';
391	++out;
392
393	*dst = out;
394	return true;
395}
396
397static bool escape_octal(unsigned char c, char **dst, char *end)
398{
399	char *out = *dst;
400
401	if (out < end)
402		*out = '\\';
403	++out;
404	if (out < end)
405		*out = ((c >> 6) & 0x07) + '0';
406	++out;
407	if (out < end)
408		*out = ((c >> 3) & 0x07) + '0';
409	++out;
410	if (out < end)
411		*out = ((c >> 0) & 0x07) + '0';
412	++out;
413
414	*dst = out;
415	return true;
416}
417
418static bool escape_hex(unsigned char c, char **dst, char *end)
419{
420	char *out = *dst;
421
422	if (out < end)
423		*out = '\\';
424	++out;
425	if (out < end)
426		*out = 'x';
427	++out;
428	if (out < end)
429		*out = hex_asc_hi(c);
430	++out;
431	if (out < end)
432		*out = hex_asc_lo(c);
433	++out;
434
435	*dst = out;
436	return true;
437}
438
439/**
440 * string_escape_mem - quote characters in the given memory buffer
441 * @src:	source buffer (unescaped)
442 * @isz:	source buffer size
443 * @dst:	destination buffer (escaped)
444 * @osz:	destination buffer size
445 * @flags:	combination of the flags
446 * @only:	NULL-terminated string containing characters used to limit
447 *		the selected escape class. If characters are included in @only
448 *		that would not normally be escaped by the classes selected
449 *		in @flags, they will be copied to @dst unescaped.
450 *
451 * Description:
452 * The process of escaping byte buffer includes several parts. They are applied
453 * in the following sequence.
454 *
455 *	1. The character is not matched to the one from @only string and thus
456 *	   must go as-is to the output.
457 *	2. The character is matched to the printable and ASCII classes, if asked,
458 *	   and in case of match it passes through to the output.
459 *	3. The character is matched to the printable or ASCII class, if asked,
460 *	   and in case of match it passes through to the output.
461 *	4. The character is checked if it falls into the class given by @flags.
462 *	   %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
463 *	   character. Note that they actually can't go together, otherwise
464 *	   %ESCAPE_HEX will be ignored.
465 *
466 * Caller must provide valid source and destination pointers. Be aware that
467 * destination buffer will not be NULL-terminated, thus caller have to append
468 * it if needs. The supported flags are::
469 *
470 *	%ESCAPE_SPACE: (special white space, not space itself)
471 *		'\f' - form feed
472 *		'\n' - new line
473 *		'\r' - carriage return
474 *		'\t' - horizontal tab
475 *		'\v' - vertical tab
476 *	%ESCAPE_SPECIAL:
 
477 *		'\\' - backslash
478 *		'\a' - alert (BEL)
479 *		'\e' - escape
480 *	%ESCAPE_NULL:
481 *		'\0' - null
482 *	%ESCAPE_OCTAL:
483 *		'\NNN' - byte with octal value NNN (3 digits)
484 *	%ESCAPE_ANY:
485 *		all previous together
486 *	%ESCAPE_NP:
487 *		escape only non-printable characters, checked by isprint()
488 *	%ESCAPE_ANY_NP:
489 *		all previous together
490 *	%ESCAPE_HEX:
491 *		'\xHH' - byte with hexadecimal value HH (2 digits)
492 *	%ESCAPE_NA:
493 *		escape only non-ascii characters, checked by isascii()
494 *	%ESCAPE_NAP:
495 *		escape only non-printable or non-ascii characters
496 *	%ESCAPE_APPEND:
497 *		append characters from @only to be escaped by the given classes
498 *
499 * %ESCAPE_APPEND would help to pass additional characters to the escaped, when
500 * one of %ESCAPE_NP, %ESCAPE_NA, or %ESCAPE_NAP is provided.
501 *
502 * One notable caveat, the %ESCAPE_NAP, %ESCAPE_NP and %ESCAPE_NA have the
503 * higher priority than the rest of the flags (%ESCAPE_NAP is the highest).
504 * It doesn't make much sense to use either of them without %ESCAPE_OCTAL
505 * or %ESCAPE_HEX, because they cover most of the other character classes.
506 * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to
507 * the above.
508 *
509 * Return:
510 * The total size of the escaped output that would be generated for
511 * the given input and flags. To check whether the output was
512 * truncated, compare the return value to osz. There is room left in
513 * dst for a '\0' terminator if and only if ret < osz.
514 */
515int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
516		      unsigned int flags, const char *only)
517{
518	char *p = dst;
519	char *end = p + osz;
520	bool is_dict = only && *only;
521	bool is_append = flags & ESCAPE_APPEND;
522
523	while (isz--) {
524		unsigned char c = *src++;
525		bool in_dict = is_dict && strchr(only, c);
526
527		/*
528		 * Apply rules in the following sequence:
529		 *	- the @only string is supplied and does not contain a
530		 *	  character under question
531		 *	- the character is printable and ASCII, when @flags has
532		 *	  %ESCAPE_NAP bit set
533		 *	- the character is printable, when @flags has
534		 *	  %ESCAPE_NP bit set
535		 *	- the character is ASCII, when @flags has
536		 *	  %ESCAPE_NA bit set
537		 *	- the character doesn't fall into a class of symbols
538		 *	  defined by given @flags
539		 * In these cases we just pass through a character to the
540		 * output buffer.
541		 *
542		 * When %ESCAPE_APPEND is passed, the characters from @only
543		 * have been excluded from the %ESCAPE_NAP, %ESCAPE_NP, and
544		 * %ESCAPE_NA cases.
545		 */
546		if (!(is_append || in_dict) && is_dict &&
547					  escape_passthrough(c, &p, end))
548			continue;
549
550		if (!(is_append && in_dict) && isascii(c) && isprint(c) &&
551		    flags & ESCAPE_NAP && escape_passthrough(c, &p, end))
552			continue;
553
554		if (!(is_append && in_dict) && isprint(c) &&
555		    flags & ESCAPE_NP && escape_passthrough(c, &p, end))
556			continue;
557
558		if (!(is_append && in_dict) && isascii(c) &&
559		    flags & ESCAPE_NA && escape_passthrough(c, &p, end))
560			continue;
561
562		if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
563			continue;
564
565		if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
566			continue;
567
568		if (flags & ESCAPE_NULL && escape_null(c, &p, end))
569			continue;
570
571		/* ESCAPE_OCTAL and ESCAPE_HEX always go last */
572		if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
573			continue;
574
575		if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
576			continue;
577
578		escape_passthrough(c, &p, end);
579	}
580
581	return p - dst;
582}
583EXPORT_SYMBOL(string_escape_mem);
584
585/*
586 * Return an allocated string that has been escaped of special characters
587 * and double quotes, making it safe to log in quotes.
588 */
589char *kstrdup_quotable(const char *src, gfp_t gfp)
590{
591	size_t slen, dlen;
592	char *dst;
593	const int flags = ESCAPE_HEX;
594	const char esc[] = "\f\n\r\t\v\a\e\\\"";
595
596	if (!src)
597		return NULL;
598	slen = strlen(src);
599
600	dlen = string_escape_mem(src, slen, NULL, 0, flags, esc);
601	dst = kmalloc(dlen + 1, gfp);
602	if (!dst)
603		return NULL;
604
605	WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen);
606	dst[dlen] = '\0';
607
608	return dst;
609}
610EXPORT_SYMBOL_GPL(kstrdup_quotable);
611
612/*
613 * Returns allocated NULL-terminated string containing process
614 * command line, with inter-argument NULLs replaced with spaces,
615 * and other special characters escaped.
616 */
617char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp)
618{
619	char *buffer, *quoted;
620	int i, res;
621
622	buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
623	if (!buffer)
624		return NULL;
625
626	res = get_cmdline(task, buffer, PAGE_SIZE - 1);
627	buffer[res] = '\0';
628
629	/* Collapse trailing NULLs, leave res pointing to last non-NULL. */
630	while (--res >= 0 && buffer[res] == '\0')
631		;
632
633	/* Replace inter-argument NULLs. */
634	for (i = 0; i <= res; i++)
635		if (buffer[i] == '\0')
636			buffer[i] = ' ';
637
638	/* Make sure result is printable. */
639	quoted = kstrdup_quotable(buffer, gfp);
640	kfree(buffer);
641	return quoted;
642}
643EXPORT_SYMBOL_GPL(kstrdup_quotable_cmdline);
644
645/*
646 * Returns allocated NULL-terminated string containing pathname,
647 * with special characters escaped, able to be safely logged. If
648 * there is an error, the leading character will be "<".
649 */
650char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
651{
652	char *temp, *pathname;
653
654	if (!file)
655		return kstrdup("<unknown>", gfp);
656
657	/* We add 11 spaces for ' (deleted)' to be appended */
658	temp = kmalloc(PATH_MAX + 11, GFP_KERNEL);
659	if (!temp)
660		return kstrdup("<no_memory>", gfp);
661
662	pathname = file_path(file, temp, PATH_MAX + 11);
663	if (IS_ERR(pathname))
664		pathname = kstrdup("<too_long>", gfp);
665	else
666		pathname = kstrdup_quotable(pathname, gfp);
667
668	kfree(temp);
669	return pathname;
670}
671EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
672
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
673/**
674 * kfree_strarray - free a number of dynamically allocated strings contained
675 *                  in an array and the array itself
676 *
677 * @array: Dynamically allocated array of strings to free.
678 * @n: Number of strings (starting from the beginning of the array) to free.
679 *
680 * Passing a non-NULL @array and @n == 0 as well as NULL @array are valid
681 * use-cases. If @array is NULL, the function does nothing.
682 */
683void kfree_strarray(char **array, size_t n)
684{
685	unsigned int i;
686
687	if (!array)
688		return;
689
690	for (i = 0; i < n; i++)
691		kfree(array[i]);
692	kfree(array);
693}
694EXPORT_SYMBOL_GPL(kfree_strarray);
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Helpers for formatting and printing strings
   4 *
   5 * Copyright 31 August 2008 James Bottomley
   6 * Copyright (C) 2013, Intel Corporation
   7 */
   8#include <linux/bug.h>
   9#include <linux/kernel.h>
  10#include <linux/math64.h>
  11#include <linux/export.h>
  12#include <linux/ctype.h>
  13#include <linux/device.h>
  14#include <linux/errno.h>
  15#include <linux/fs.h>
  16#include <linux/limits.h>
  17#include <linux/mm.h>
  18#include <linux/slab.h>
  19#include <linux/string.h>
  20#include <linux/string_helpers.h>
  21#include <kunit/test.h>
  22#include <kunit/test-bug.h>
  23
  24/**
  25 * string_get_size - get the size in the specified units
  26 * @size:	The size to be converted in blocks
  27 * @blk_size:	Size of the block (use 1 for size in bytes)
  28 * @units:	Units to use (powers of 1000 or 1024), whether to include space separator
  29 * @buf:	buffer to format to
  30 * @len:	length of buffer
  31 *
  32 * This function returns a string formatted to 3 significant figures
  33 * giving the size in the required units.  @buf should have room for
  34 * at least 9 bytes and will always be zero terminated.
  35 *
  36 * Return value: number of characters of output that would have been written
  37 * (which may be greater than len, if output was truncated).
  38 */
  39int string_get_size(u64 size, u64 blk_size, const enum string_size_units units,
  40		    char *buf, int len)
  41{
  42	enum string_size_units units_base = units & STRING_UNITS_MASK;
  43	static const char *const units_10[] = {
  44		"", "k", "M", "G", "T", "P", "E", "Z", "Y",
  45	};
  46	static const char *const units_2[] = {
  47		"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi",
  48	};
  49	static const char *const *const units_str[] = {
  50		[STRING_UNITS_10] = units_10,
  51		[STRING_UNITS_2] = units_2,
  52	};
  53	static const unsigned int divisor[] = {
  54		[STRING_UNITS_10] = 1000,
  55		[STRING_UNITS_2] = 1024,
  56	};
  57	static const unsigned int rounding[] = { 500, 50, 5 };
  58	int i = 0, j;
  59	u32 remainder = 0, sf_cap;
  60	char tmp[12];
  61	const char *unit;
  62
  63	tmp[0] = '\0';
  64
  65	if (blk_size == 0)
  66		size = 0;
  67	if (size == 0)
  68		goto out;
  69
  70	/* This is Napier's algorithm.  Reduce the original block size to
  71	 *
  72	 * coefficient * divisor[units_base]^i
  73	 *
  74	 * we do the reduction so both coefficients are just under 32 bits so
  75	 * that multiplying them together won't overflow 64 bits and we keep
  76	 * as much precision as possible in the numbers.
  77	 *
  78	 * Note: it's safe to throw away the remainders here because all the
  79	 * precision is in the coefficients.
  80	 */
  81	while (blk_size >> 32) {
  82		do_div(blk_size, divisor[units_base]);
  83		i++;
  84	}
  85
  86	while (size >> 32) {
  87		do_div(size, divisor[units_base]);
  88		i++;
  89	}
  90
  91	/* now perform the actual multiplication keeping i as the sum of the
  92	 * two logarithms */
  93	size *= blk_size;
  94
  95	/* and logarithmically reduce it until it's just under the divisor */
  96	while (size >= divisor[units_base]) {
  97		remainder = do_div(size, divisor[units_base]);
  98		i++;
  99	}
 100
 101	/* work out in j how many digits of precision we need from the
 102	 * remainder */
 103	sf_cap = size;
 104	for (j = 0; sf_cap*10 < 1000; j++)
 105		sf_cap *= 10;
 106
 107	if (units_base == STRING_UNITS_2) {
 108		/* express the remainder as a decimal.  It's currently the
 109		 * numerator of a fraction whose denominator is
 110		 * divisor[units_base], which is 1 << 10 for STRING_UNITS_2 */
 111		remainder *= 1000;
 112		remainder >>= 10;
 113	}
 114
 115	/* add a 5 to the digit below what will be printed to ensure
 116	 * an arithmetical round up and carry it through to size */
 117	remainder += rounding[j];
 118	if (remainder >= 1000) {
 119		remainder -= 1000;
 120		size += 1;
 121	}
 122
 123	if (j) {
 124		snprintf(tmp, sizeof(tmp), ".%03u", remainder);
 125		tmp[j+1] = '\0';
 126	}
 127
 128 out:
 129	if (i >= ARRAY_SIZE(units_2))
 130		unit = "UNK";
 131	else
 132		unit = units_str[units_base][i];
 133
 134	return snprintf(buf, len, "%u%s%s%s%s", (u32)size, tmp,
 135			(units & STRING_UNITS_NO_SPACE) ? "" : " ",
 136			unit,
 137			(units & STRING_UNITS_NO_BYTES) ? "" : "B");
 138}
 139EXPORT_SYMBOL(string_get_size);
 140
 141/**
 142 * parse_int_array_user - Split string into a sequence of integers
 143 * @from:	The user space buffer to read from
 144 * @count:	The maximum number of bytes to read
 145 * @array:	Returned pointer to sequence of integers
 146 *
 147 * On success @array is allocated and initialized with a sequence of
 148 * integers extracted from the @from plus an additional element that
 149 * begins the sequence and specifies the integers count.
 150 *
 151 * Caller takes responsibility for freeing @array when it is no longer
 152 * needed.
 153 */
 154int parse_int_array_user(const char __user *from, size_t count, int **array)
 155{
 156	int *ints, nints;
 157	char *buf;
 158	int ret = 0;
 159
 160	buf = memdup_user_nul(from, count);
 161	if (IS_ERR(buf))
 162		return PTR_ERR(buf);
 163
 164	get_options(buf, 0, &nints);
 165	if (!nints) {
 166		ret = -ENOENT;
 167		goto free_buf;
 168	}
 169
 170	ints = kcalloc(nints + 1, sizeof(*ints), GFP_KERNEL);
 171	if (!ints) {
 172		ret = -ENOMEM;
 173		goto free_buf;
 174	}
 175
 176	get_options(buf, nints + 1, ints);
 177	*array = ints;
 178
 179free_buf:
 180	kfree(buf);
 181	return ret;
 182}
 183EXPORT_SYMBOL(parse_int_array_user);
 184
 185static bool unescape_space(char **src, char **dst)
 186{
 187	char *p = *dst, *q = *src;
 188
 189	switch (*q) {
 190	case 'n':
 191		*p = '\n';
 192		break;
 193	case 'r':
 194		*p = '\r';
 195		break;
 196	case 't':
 197		*p = '\t';
 198		break;
 199	case 'v':
 200		*p = '\v';
 201		break;
 202	case 'f':
 203		*p = '\f';
 204		break;
 205	default:
 206		return false;
 207	}
 208	*dst += 1;
 209	*src += 1;
 210	return true;
 211}
 212
 213static bool unescape_octal(char **src, char **dst)
 214{
 215	char *p = *dst, *q = *src;
 216	u8 num;
 217
 218	if (isodigit(*q) == 0)
 219		return false;
 220
 221	num = (*q++) & 7;
 222	while (num < 32 && isodigit(*q) && (q - *src < 3)) {
 223		num <<= 3;
 224		num += (*q++) & 7;
 225	}
 226	*p = num;
 227	*dst += 1;
 228	*src = q;
 229	return true;
 230}
 231
 232static bool unescape_hex(char **src, char **dst)
 233{
 234	char *p = *dst, *q = *src;
 235	int digit;
 236	u8 num;
 237
 238	if (*q++ != 'x')
 239		return false;
 240
 241	num = digit = hex_to_bin(*q++);
 242	if (digit < 0)
 243		return false;
 244
 245	digit = hex_to_bin(*q);
 246	if (digit >= 0) {
 247		q++;
 248		num = (num << 4) | digit;
 249	}
 250	*p = num;
 251	*dst += 1;
 252	*src = q;
 253	return true;
 254}
 255
 256static bool unescape_special(char **src, char **dst)
 257{
 258	char *p = *dst, *q = *src;
 259
 260	switch (*q) {
 261	case '\"':
 262		*p = '\"';
 263		break;
 264	case '\\':
 265		*p = '\\';
 266		break;
 267	case 'a':
 268		*p = '\a';
 269		break;
 270	case 'e':
 271		*p = '\e';
 272		break;
 273	default:
 274		return false;
 275	}
 276	*dst += 1;
 277	*src += 1;
 278	return true;
 279}
 280
 281/**
 282 * string_unescape - unquote characters in the given string
 283 * @src:	source buffer (escaped)
 284 * @dst:	destination buffer (unescaped)
 285 * @size:	size of the destination buffer (0 to unlimit)
 286 * @flags:	combination of the flags.
 287 *
 288 * Description:
 289 * The function unquotes characters in the given string.
 290 *
 291 * Because the size of the output will be the same as or less than the size of
 292 * the input, the transformation may be performed in place.
 293 *
 294 * Caller must provide valid source and destination pointers. Be aware that
 295 * destination buffer will always be NULL-terminated. Source string must be
 296 * NULL-terminated as well.  The supported flags are::
 297 *
 298 *	UNESCAPE_SPACE:
 299 *		'\f' - form feed
 300 *		'\n' - new line
 301 *		'\r' - carriage return
 302 *		'\t' - horizontal tab
 303 *		'\v' - vertical tab
 304 *	UNESCAPE_OCTAL:
 305 *		'\NNN' - byte with octal value NNN (1 to 3 digits)
 306 *	UNESCAPE_HEX:
 307 *		'\xHH' - byte with hexadecimal value HH (1 to 2 digits)
 308 *	UNESCAPE_SPECIAL:
 309 *		'\"' - double quote
 310 *		'\\' - backslash
 311 *		'\a' - alert (BEL)
 312 *		'\e' - escape
 313 *	UNESCAPE_ANY:
 314 *		all previous together
 315 *
 316 * Return:
 317 * The amount of the characters processed to the destination buffer excluding
 318 * trailing '\0' is returned.
 319 */
 320int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
 321{
 322	char *out = dst;
 323
 324	if (!size)
 325		size = SIZE_MAX;
 326
 327	while (*src && --size) {
 328		if (src[0] == '\\' && src[1] != '\0' && size > 1) {
 329			src++;
 330			size--;
 331
 332			if (flags & UNESCAPE_SPACE &&
 333					unescape_space(&src, &out))
 334				continue;
 335
 336			if (flags & UNESCAPE_OCTAL &&
 337					unescape_octal(&src, &out))
 338				continue;
 339
 340			if (flags & UNESCAPE_HEX &&
 341					unescape_hex(&src, &out))
 342				continue;
 343
 344			if (flags & UNESCAPE_SPECIAL &&
 345					unescape_special(&src, &out))
 346				continue;
 347
 348			*out++ = '\\';
 349		}
 350		*out++ = *src++;
 351	}
 352	*out = '\0';
 353
 354	return out - dst;
 355}
 356EXPORT_SYMBOL(string_unescape);
 357
 358static bool escape_passthrough(unsigned char c, char **dst, char *end)
 359{
 360	char *out = *dst;
 361
 362	if (out < end)
 363		*out = c;
 364	*dst = out + 1;
 365	return true;
 366}
 367
 368static bool escape_space(unsigned char c, char **dst, char *end)
 369{
 370	char *out = *dst;
 371	unsigned char to;
 372
 373	switch (c) {
 374	case '\n':
 375		to = 'n';
 376		break;
 377	case '\r':
 378		to = 'r';
 379		break;
 380	case '\t':
 381		to = 't';
 382		break;
 383	case '\v':
 384		to = 'v';
 385		break;
 386	case '\f':
 387		to = 'f';
 388		break;
 389	default:
 390		return false;
 391	}
 392
 393	if (out < end)
 394		*out = '\\';
 395	++out;
 396	if (out < end)
 397		*out = to;
 398	++out;
 399
 400	*dst = out;
 401	return true;
 402}
 403
 404static bool escape_special(unsigned char c, char **dst, char *end)
 405{
 406	char *out = *dst;
 407	unsigned char to;
 408
 409	switch (c) {
 410	case '\\':
 411		to = '\\';
 412		break;
 413	case '\a':
 414		to = 'a';
 415		break;
 416	case '\e':
 417		to = 'e';
 418		break;
 419	case '"':
 420		to = '"';
 421		break;
 422	default:
 423		return false;
 424	}
 425
 426	if (out < end)
 427		*out = '\\';
 428	++out;
 429	if (out < end)
 430		*out = to;
 431	++out;
 432
 433	*dst = out;
 434	return true;
 435}
 436
 437static bool escape_null(unsigned char c, char **dst, char *end)
 438{
 439	char *out = *dst;
 440
 441	if (c)
 442		return false;
 443
 444	if (out < end)
 445		*out = '\\';
 446	++out;
 447	if (out < end)
 448		*out = '0';
 449	++out;
 450
 451	*dst = out;
 452	return true;
 453}
 454
 455static bool escape_octal(unsigned char c, char **dst, char *end)
 456{
 457	char *out = *dst;
 458
 459	if (out < end)
 460		*out = '\\';
 461	++out;
 462	if (out < end)
 463		*out = ((c >> 6) & 0x07) + '0';
 464	++out;
 465	if (out < end)
 466		*out = ((c >> 3) & 0x07) + '0';
 467	++out;
 468	if (out < end)
 469		*out = ((c >> 0) & 0x07) + '0';
 470	++out;
 471
 472	*dst = out;
 473	return true;
 474}
 475
 476static bool escape_hex(unsigned char c, char **dst, char *end)
 477{
 478	char *out = *dst;
 479
 480	if (out < end)
 481		*out = '\\';
 482	++out;
 483	if (out < end)
 484		*out = 'x';
 485	++out;
 486	if (out < end)
 487		*out = hex_asc_hi(c);
 488	++out;
 489	if (out < end)
 490		*out = hex_asc_lo(c);
 491	++out;
 492
 493	*dst = out;
 494	return true;
 495}
 496
 497/**
 498 * string_escape_mem - quote characters in the given memory buffer
 499 * @src:	source buffer (unescaped)
 500 * @isz:	source buffer size
 501 * @dst:	destination buffer (escaped)
 502 * @osz:	destination buffer size
 503 * @flags:	combination of the flags
 504 * @only:	NULL-terminated string containing characters used to limit
 505 *		the selected escape class. If characters are included in @only
 506 *		that would not normally be escaped by the classes selected
 507 *		in @flags, they will be copied to @dst unescaped.
 508 *
 509 * Description:
 510 * The process of escaping byte buffer includes several parts. They are applied
 511 * in the following sequence.
 512 *
 513 *	1. The character is not matched to the one from @only string and thus
 514 *	   must go as-is to the output.
 515 *	2. The character is matched to the printable and ASCII classes, if asked,
 516 *	   and in case of match it passes through to the output.
 517 *	3. The character is matched to the printable or ASCII class, if asked,
 518 *	   and in case of match it passes through to the output.
 519 *	4. The character is checked if it falls into the class given by @flags.
 520 *	   %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
 521 *	   character. Note that they actually can't go together, otherwise
 522 *	   %ESCAPE_HEX will be ignored.
 523 *
 524 * Caller must provide valid source and destination pointers. Be aware that
 525 * destination buffer will not be NULL-terminated, thus caller have to append
 526 * it if needs. The supported flags are::
 527 *
 528 *	%ESCAPE_SPACE: (special white space, not space itself)
 529 *		'\f' - form feed
 530 *		'\n' - new line
 531 *		'\r' - carriage return
 532 *		'\t' - horizontal tab
 533 *		'\v' - vertical tab
 534 *	%ESCAPE_SPECIAL:
 535 *		'\"' - double quote
 536 *		'\\' - backslash
 537 *		'\a' - alert (BEL)
 538 *		'\e' - escape
 539 *	%ESCAPE_NULL:
 540 *		'\0' - null
 541 *	%ESCAPE_OCTAL:
 542 *		'\NNN' - byte with octal value NNN (3 digits)
 543 *	%ESCAPE_ANY:
 544 *		all previous together
 545 *	%ESCAPE_NP:
 546 *		escape only non-printable characters, checked by isprint()
 547 *	%ESCAPE_ANY_NP:
 548 *		all previous together
 549 *	%ESCAPE_HEX:
 550 *		'\xHH' - byte with hexadecimal value HH (2 digits)
 551 *	%ESCAPE_NA:
 552 *		escape only non-ascii characters, checked by isascii()
 553 *	%ESCAPE_NAP:
 554 *		escape only non-printable or non-ascii characters
 555 *	%ESCAPE_APPEND:
 556 *		append characters from @only to be escaped by the given classes
 557 *
 558 * %ESCAPE_APPEND would help to pass additional characters to the escaped, when
 559 * one of %ESCAPE_NP, %ESCAPE_NA, or %ESCAPE_NAP is provided.
 560 *
 561 * One notable caveat, the %ESCAPE_NAP, %ESCAPE_NP and %ESCAPE_NA have the
 562 * higher priority than the rest of the flags (%ESCAPE_NAP is the highest).
 563 * It doesn't make much sense to use either of them without %ESCAPE_OCTAL
 564 * or %ESCAPE_HEX, because they cover most of the other character classes.
 565 * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to
 566 * the above.
 567 *
 568 * Return:
 569 * The total size of the escaped output that would be generated for
 570 * the given input and flags. To check whether the output was
 571 * truncated, compare the return value to osz. There is room left in
 572 * dst for a '\0' terminator if and only if ret < osz.
 573 */
 574int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
 575		      unsigned int flags, const char *only)
 576{
 577	char *p = dst;
 578	char *end = p + osz;
 579	bool is_dict = only && *only;
 580	bool is_append = flags & ESCAPE_APPEND;
 581
 582	while (isz--) {
 583		unsigned char c = *src++;
 584		bool in_dict = is_dict && strchr(only, c);
 585
 586		/*
 587		 * Apply rules in the following sequence:
 588		 *	- the @only string is supplied and does not contain a
 589		 *	  character under question
 590		 *	- the character is printable and ASCII, when @flags has
 591		 *	  %ESCAPE_NAP bit set
 592		 *	- the character is printable, when @flags has
 593		 *	  %ESCAPE_NP bit set
 594		 *	- the character is ASCII, when @flags has
 595		 *	  %ESCAPE_NA bit set
 596		 *	- the character doesn't fall into a class of symbols
 597		 *	  defined by given @flags
 598		 * In these cases we just pass through a character to the
 599		 * output buffer.
 600		 *
 601		 * When %ESCAPE_APPEND is passed, the characters from @only
 602		 * have been excluded from the %ESCAPE_NAP, %ESCAPE_NP, and
 603		 * %ESCAPE_NA cases.
 604		 */
 605		if (!(is_append || in_dict) && is_dict &&
 606					  escape_passthrough(c, &p, end))
 607			continue;
 608
 609		if (!(is_append && in_dict) && isascii(c) && isprint(c) &&
 610		    flags & ESCAPE_NAP && escape_passthrough(c, &p, end))
 611			continue;
 612
 613		if (!(is_append && in_dict) && isprint(c) &&
 614		    flags & ESCAPE_NP && escape_passthrough(c, &p, end))
 615			continue;
 616
 617		if (!(is_append && in_dict) && isascii(c) &&
 618		    flags & ESCAPE_NA && escape_passthrough(c, &p, end))
 619			continue;
 620
 621		if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
 622			continue;
 623
 624		if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
 625			continue;
 626
 627		if (flags & ESCAPE_NULL && escape_null(c, &p, end))
 628			continue;
 629
 630		/* ESCAPE_OCTAL and ESCAPE_HEX always go last */
 631		if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
 632			continue;
 633
 634		if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
 635			continue;
 636
 637		escape_passthrough(c, &p, end);
 638	}
 639
 640	return p - dst;
 641}
 642EXPORT_SYMBOL(string_escape_mem);
 643
 644/*
 645 * Return an allocated string that has been escaped of special characters
 646 * and double quotes, making it safe to log in quotes.
 647 */
 648char *kstrdup_quotable(const char *src, gfp_t gfp)
 649{
 650	size_t slen, dlen;
 651	char *dst;
 652	const int flags = ESCAPE_HEX;
 653	const char esc[] = "\f\n\r\t\v\a\e\\\"";
 654
 655	if (!src)
 656		return NULL;
 657	slen = strlen(src);
 658
 659	dlen = string_escape_mem(src, slen, NULL, 0, flags, esc);
 660	dst = kmalloc(dlen + 1, gfp);
 661	if (!dst)
 662		return NULL;
 663
 664	WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen);
 665	dst[dlen] = '\0';
 666
 667	return dst;
 668}
 669EXPORT_SYMBOL_GPL(kstrdup_quotable);
 670
 671/*
 672 * Returns allocated NULL-terminated string containing process
 673 * command line, with inter-argument NULLs replaced with spaces,
 674 * and other special characters escaped.
 675 */
 676char *kstrdup_quotable_cmdline(struct task_struct *task, gfp_t gfp)
 677{
 678	char *buffer, *quoted;
 679	int i, res;
 680
 681	buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
 682	if (!buffer)
 683		return NULL;
 684
 685	res = get_cmdline(task, buffer, PAGE_SIZE - 1);
 686	buffer[res] = '\0';
 687
 688	/* Collapse trailing NULLs, leave res pointing to last non-NULL. */
 689	while (--res >= 0 && buffer[res] == '\0')
 690		;
 691
 692	/* Replace inter-argument NULLs. */
 693	for (i = 0; i <= res; i++)
 694		if (buffer[i] == '\0')
 695			buffer[i] = ' ';
 696
 697	/* Make sure result is printable. */
 698	quoted = kstrdup_quotable(buffer, gfp);
 699	kfree(buffer);
 700	return quoted;
 701}
 702EXPORT_SYMBOL_GPL(kstrdup_quotable_cmdline);
 703
 704/*
 705 * Returns allocated NULL-terminated string containing pathname,
 706 * with special characters escaped, able to be safely logged. If
 707 * there is an error, the leading character will be "<".
 708 */
 709char *kstrdup_quotable_file(struct file *file, gfp_t gfp)
 710{
 711	char *temp, *pathname;
 712
 713	if (!file)
 714		return kstrdup("<unknown>", gfp);
 715
 716	/* We add 11 spaces for ' (deleted)' to be appended */
 717	temp = kmalloc(PATH_MAX + 11, GFP_KERNEL);
 718	if (!temp)
 719		return kstrdup("<no_memory>", gfp);
 720
 721	pathname = file_path(file, temp, PATH_MAX + 11);
 722	if (IS_ERR(pathname))
 723		pathname = kstrdup("<too_long>", gfp);
 724	else
 725		pathname = kstrdup_quotable(pathname, gfp);
 726
 727	kfree(temp);
 728	return pathname;
 729}
 730EXPORT_SYMBOL_GPL(kstrdup_quotable_file);
 731
 732/*
 733 * Returns duplicate string in which the @old characters are replaced by @new.
 734 */
 735char *kstrdup_and_replace(const char *src, char old, char new, gfp_t gfp)
 736{
 737	char *dst;
 738
 739	dst = kstrdup(src, gfp);
 740	if (!dst)
 741		return NULL;
 742
 743	return strreplace(dst, old, new);
 744}
 745EXPORT_SYMBOL_GPL(kstrdup_and_replace);
 746
 747/**
 748 * kasprintf_strarray - allocate and fill array of sequential strings
 749 * @gfp: flags for the slab allocator
 750 * @prefix: prefix to be used
 751 * @n: amount of lines to be allocated and filled
 752 *
 753 * Allocates and fills @n strings using pattern "%s-%zu", where prefix
 754 * is provided by caller. The caller is responsible to free them with
 755 * kfree_strarray() after use.
 756 *
 757 * Returns array of strings or NULL when memory can't be allocated.
 758 */
 759char **kasprintf_strarray(gfp_t gfp, const char *prefix, size_t n)
 760{
 761	char **names;
 762	size_t i;
 763
 764	names = kcalloc(n + 1, sizeof(char *), gfp);
 765	if (!names)
 766		return NULL;
 767
 768	for (i = 0; i < n; i++) {
 769		names[i] = kasprintf(gfp, "%s-%zu", prefix, i);
 770		if (!names[i]) {
 771			kfree_strarray(names, i);
 772			return NULL;
 773		}
 774	}
 775
 776	return names;
 777}
 778EXPORT_SYMBOL_GPL(kasprintf_strarray);
 779
 780/**
 781 * kfree_strarray - free a number of dynamically allocated strings contained
 782 *                  in an array and the array itself
 783 *
 784 * @array: Dynamically allocated array of strings to free.
 785 * @n: Number of strings (starting from the beginning of the array) to free.
 786 *
 787 * Passing a non-NULL @array and @n == 0 as well as NULL @array are valid
 788 * use-cases. If @array is NULL, the function does nothing.
 789 */
 790void kfree_strarray(char **array, size_t n)
 791{
 792	unsigned int i;
 793
 794	if (!array)
 795		return;
 796
 797	for (i = 0; i < n; i++)
 798		kfree(array[i]);
 799	kfree(array);
 800}
 801EXPORT_SYMBOL_GPL(kfree_strarray);
 802
 803struct strarray {
 804	char **array;
 805	size_t n;
 806};
 807
 808static void devm_kfree_strarray(struct device *dev, void *res)
 809{
 810	struct strarray *array = res;
 811
 812	kfree_strarray(array->array, array->n);
 813}
 814
 815char **devm_kasprintf_strarray(struct device *dev, const char *prefix, size_t n)
 816{
 817	struct strarray *ptr;
 818
 819	ptr = devres_alloc(devm_kfree_strarray, sizeof(*ptr), GFP_KERNEL);
 820	if (!ptr)
 821		return ERR_PTR(-ENOMEM);
 822
 823	ptr->array = kasprintf_strarray(GFP_KERNEL, prefix, n);
 824	if (!ptr->array) {
 825		devres_free(ptr);
 826		return ERR_PTR(-ENOMEM);
 827	}
 828
 829	ptr->n = n;
 830	devres_add(dev, ptr);
 831
 832	return ptr->array;
 833}
 834EXPORT_SYMBOL_GPL(devm_kasprintf_strarray);
 835
 836/**
 837 * skip_spaces - Removes leading whitespace from @str.
 838 * @str: The string to be stripped.
 839 *
 840 * Returns a pointer to the first non-whitespace character in @str.
 841 */
 842char *skip_spaces(const char *str)
 843{
 844	while (isspace(*str))
 845		++str;
 846	return (char *)str;
 847}
 848EXPORT_SYMBOL(skip_spaces);
 849
 850/**
 851 * strim - Removes leading and trailing whitespace from @s.
 852 * @s: The string to be stripped.
 853 *
 854 * Note that the first trailing whitespace is replaced with a %NUL-terminator
 855 * in the given string @s. Returns a pointer to the first non-whitespace
 856 * character in @s.
 857 */
 858char *strim(char *s)
 859{
 860	size_t size;
 861	char *end;
 862
 863	size = strlen(s);
 864	if (!size)
 865		return s;
 866
 867	end = s + size - 1;
 868	while (end >= s && isspace(*end))
 869		end--;
 870	*(end + 1) = '\0';
 871
 872	return skip_spaces(s);
 873}
 874EXPORT_SYMBOL(strim);
 875
 876/**
 877 * sysfs_streq - return true if strings are equal, modulo trailing newline
 878 * @s1: one string
 879 * @s2: another string
 880 *
 881 * This routine returns true iff two strings are equal, treating both
 882 * NUL and newline-then-NUL as equivalent string terminations.  It's
 883 * geared for use with sysfs input strings, which generally terminate
 884 * with newlines but are compared against values without newlines.
 885 */
 886bool sysfs_streq(const char *s1, const char *s2)
 887{
 888	while (*s1 && *s1 == *s2) {
 889		s1++;
 890		s2++;
 891	}
 892
 893	if (*s1 == *s2)
 894		return true;
 895	if (!*s1 && *s2 == '\n' && !s2[1])
 896		return true;
 897	if (*s1 == '\n' && !s1[1] && !*s2)
 898		return true;
 899	return false;
 900}
 901EXPORT_SYMBOL(sysfs_streq);
 902
 903/**
 904 * match_string - matches given string in an array
 905 * @array:	array of strings
 906 * @n:		number of strings in the array or -1 for NULL terminated arrays
 907 * @string:	string to match with
 908 *
 909 * This routine will look for a string in an array of strings up to the
 910 * n-th element in the array or until the first NULL element.
 911 *
 912 * Historically the value of -1 for @n, was used to search in arrays that
 913 * are NULL terminated. However, the function does not make a distinction
 914 * when finishing the search: either @n elements have been compared OR
 915 * the first NULL element was found.
 916 *
 917 * Return:
 918 * index of a @string in the @array if matches, or %-EINVAL otherwise.
 919 */
 920int match_string(const char * const *array, size_t n, const char *string)
 921{
 922	int index;
 923	const char *item;
 924
 925	for (index = 0; index < n; index++) {
 926		item = array[index];
 927		if (!item)
 928			break;
 929		if (!strcmp(item, string))
 930			return index;
 931	}
 932
 933	return -EINVAL;
 934}
 935EXPORT_SYMBOL(match_string);
 936
 937/**
 938 * __sysfs_match_string - matches given string in an array
 939 * @array: array of strings
 940 * @n: number of strings in the array or -1 for NULL terminated arrays
 941 * @str: string to match with
 942 *
 943 * Returns index of @str in the @array or -EINVAL, just like match_string().
 944 * Uses sysfs_streq instead of strcmp for matching.
 945 *
 946 * This routine will look for a string in an array of strings up to the
 947 * n-th element in the array or until the first NULL element.
 948 *
 949 * Historically the value of -1 for @n, was used to search in arrays that
 950 * are NULL terminated. However, the function does not make a distinction
 951 * when finishing the search: either @n elements have been compared OR
 952 * the first NULL element was found.
 953 */
 954int __sysfs_match_string(const char * const *array, size_t n, const char *str)
 955{
 956	const char *item;
 957	int index;
 958
 959	for (index = 0; index < n; index++) {
 960		item = array[index];
 961		if (!item)
 962			break;
 963		if (sysfs_streq(item, str))
 964			return index;
 965	}
 966
 967	return -EINVAL;
 968}
 969EXPORT_SYMBOL(__sysfs_match_string);
 970
 971/**
 972 * strreplace - Replace all occurrences of character in string.
 973 * @str: The string to operate on.
 974 * @old: The character being replaced.
 975 * @new: The character @old is replaced with.
 976 *
 977 * Replaces the each @old character with a @new one in the given string @str.
 978 *
 979 * Return: pointer to the string @str itself.
 980 */
 981char *strreplace(char *str, char old, char new)
 982{
 983	char *s = str;
 984
 985	for (; *s; ++s)
 986		if (*s == old)
 987			*s = new;
 988	return str;
 989}
 990EXPORT_SYMBOL(strreplace);
 991
 992/**
 993 * memcpy_and_pad - Copy one buffer to another with padding
 994 * @dest: Where to copy to
 995 * @dest_len: The destination buffer size
 996 * @src: Where to copy from
 997 * @count: The number of bytes to copy
 998 * @pad: Character to use for padding if space is left in destination.
 999 */
1000void memcpy_and_pad(void *dest, size_t dest_len, const void *src, size_t count,
1001		    int pad)
1002{
1003	if (dest_len > count) {
1004		memcpy(dest, src, count);
1005		memset(dest + count, pad,  dest_len - count);
1006	} else {
1007		memcpy(dest, src, dest_len);
1008	}
1009}
1010EXPORT_SYMBOL(memcpy_and_pad);
1011
1012#ifdef CONFIG_FORTIFY_SOURCE
1013/* These are placeholders for fortify compile-time warnings. */
1014void __read_overflow2_field(size_t avail, size_t wanted) { }
1015EXPORT_SYMBOL(__read_overflow2_field);
1016void __write_overflow_field(size_t avail, size_t wanted) { }
1017EXPORT_SYMBOL(__write_overflow_field);
1018
1019static const char * const fortify_func_name[] = {
1020#define MAKE_FORTIFY_FUNC_NAME(func)	[MAKE_FORTIFY_FUNC(func)] = #func
1021	EACH_FORTIFY_FUNC(MAKE_FORTIFY_FUNC_NAME)
1022#undef  MAKE_FORTIFY_FUNC_NAME
1023};
1024
1025void __fortify_report(const u8 reason, const size_t avail, const size_t size)
1026{
1027	const u8 func = FORTIFY_REASON_FUNC(reason);
1028	const bool write = FORTIFY_REASON_DIR(reason);
1029	const char *name;
1030
1031	name = fortify_func_name[umin(func, FORTIFY_FUNC_UNKNOWN)];
1032	WARN(1, "%s: detected buffer overflow: %zu byte %s of buffer size %zu\n",
1033		 name, size, str_read_write(!write), avail);
1034}
1035EXPORT_SYMBOL(__fortify_report);
1036
1037void __fortify_panic(const u8 reason, const size_t avail, const size_t size)
1038{
1039	__fortify_report(reason, avail, size);
1040	BUG();
1041}
1042EXPORT_SYMBOL(__fortify_panic);
1043#endif /* CONFIG_FORTIFY_SOURCE */