1044 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Helpers for formatting and printing strings4 *5 * Copyright 31 August 2008 James Bottomley6 * Copyright (C) 2013, Intel Corporation7 */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 units26 * @size: The size to be converted in blocks27 * @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 separator29 * @buf: buffer to format to30 * @len: length of buffer31 *32 * This function returns a string formatted to 3 significant figures33 * giving the size in the required units. @buf should have room for34 * at least 9 bytes and will always be zero terminated.35 *36 * Return value: number of characters of output that would have been written37 * (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[8];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 to71 *72 * coefficient * divisor[units_base]^i73 *74 * we do the reduction so both coefficients are just under 32 bits so75 * that multiplying them together won't overflow 64 bits and we keep76 * as much precision as possible in the numbers.77 *78 * Note: it's safe to throw away the remainders here because all the79 * 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 the92 * 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 the102 * 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 the109 * numerator of a fraction whose denominator is110 * 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 ensure116 * 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 else132 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 integers143 * @from: The user space buffer to read from144 * @count: The maximum number of bytes to read145 * @array: Returned pointer to sequence of integers146 *147 * On success @array is allocated and initialized with a sequence of148 * integers extracted from the @from plus an additional element that149 * begins the sequence and specifies the integers count.150 *151 * Caller takes responsibility for freeing @array when it is no longer152 * 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 string283 * @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 of292 * the input, the transformation may be performed in place.293 *294 * Caller must provide valid source and destination pointers. Be aware that295 * destination buffer will always be NULL-terminated. Source string must be296 * NULL-terminated as well. The supported flags are::297 *298 * UNESCAPE_SPACE:299 * '\f' - form feed300 * '\n' - new line301 * '\r' - carriage return302 * '\t' - horizontal tab303 * '\v' - vertical tab304 * 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 quote310 * '\\' - backslash311 * '\a' - alert (BEL)312 * '\e' - escape313 * UNESCAPE_ANY:314 * all previous together315 *316 * Return:317 * The amount of the characters processed to the destination buffer excluding318 * 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 buffer499 * @src: source buffer (unescaped)500 * @isz: source buffer size501 * @dst: destination buffer (escaped)502 * @osz: destination buffer size503 * @flags: combination of the flags504 * @only: NULL-terminated string containing characters used to limit505 * the selected escape class. If characters are included in @only506 * that would not normally be escaped by the classes selected507 * in @flags, they will be copied to @dst unescaped.508 *509 * Description:510 * The process of escaping byte buffer includes several parts. They are applied511 * in the following sequence.512 *513 * 1. The character is not matched to the one from @only string and thus514 * 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 any521 * character. Note that they actually can't go together, otherwise522 * %ESCAPE_HEX will be ignored.523 *524 * Caller must provide valid source and destination pointers. Be aware that525 * destination buffer will not be NULL-terminated, thus caller have to append526 * it if needs. The supported flags are::527 *528 * %ESCAPE_SPACE: (special white space, not space itself)529 * '\f' - form feed530 * '\n' - new line531 * '\r' - carriage return532 * '\t' - horizontal tab533 * '\v' - vertical tab534 * %ESCAPE_SPECIAL:535 * '\"' - double quote536 * '\\' - backslash537 * '\a' - alert (BEL)538 * '\e' - escape539 * %ESCAPE_NULL:540 * '\0' - null541 * %ESCAPE_OCTAL:542 * '\NNN' - byte with octal value NNN (3 digits)543 * %ESCAPE_ANY:544 * all previous together545 * %ESCAPE_NP:546 * escape only non-printable characters, checked by isprint()547 * %ESCAPE_ANY_NP:548 * all previous together549 * %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 characters555 * %ESCAPE_APPEND:556 * append characters from @only to be escaped by the given classes557 *558 * %ESCAPE_APPEND would help to pass additional characters to the escaped, when559 * 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 the562 * 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_OCTAL564 * or %ESCAPE_HEX, because they cover most of the other character classes.565 * %ESCAPE_NAP can utilize %ESCAPE_SPACE or %ESCAPE_SPECIAL in addition to566 * the above.567 *568 * Return:569 * The total size of the escaped output that would be generated for570 * the given input and flags. To check whether the output was571 * truncated, compare the return value to osz. There is room left in572 * 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 a589 * character under question590 * - the character is printable and ASCII, when @flags has591 * %ESCAPE_NAP bit set592 * - the character is printable, when @flags has593 * %ESCAPE_NP bit set594 * - the character is ASCII, when @flags has595 * %ESCAPE_NA bit set596 * - the character doesn't fall into a class of symbols597 * defined by given @flags598 * In these cases we just pass through a character to the599 * output buffer.600 *601 * When %ESCAPE_APPEND is passed, the characters from @only602 * have been excluded from the %ESCAPE_NAP, %ESCAPE_NP, and603 * %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 characters646 * 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 process673 * 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. If707 * 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 else725 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 strings749 * @gfp: flags for the slab allocator750 * @prefix: prefix to be used751 * @n: amount of lines to be allocated and filled752 *753 * Allocates and fills @n strings using pattern "%s-%zu", where prefix754 * is provided by caller. The caller is responsible to free them with755 * 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 contained782 * in an array and the array itself783 *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 valid788 * 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-terminator855 * in the given string @s. Returns a pointer to the first non-whitespace856 * 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 newline878 * @s1: one string879 * @s2: another string880 *881 * This routine returns true iff two strings are equal, treating both882 * NUL and newline-then-NUL as equivalent string terminations. It's883 * geared for use with sysfs input strings, which generally terminate884 * 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 array905 * @array: array of strings906 * @n: number of strings in the array or -1 for NULL terminated arrays907 * @string: string to match with908 *909 * This routine will look for a string in an array of strings up to the910 * 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 that913 * are NULL terminated. However, the function does not make a distinction914 * when finishing the search: either @n elements have been compared OR915 * 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 array939 * @array: array of strings940 * @n: number of strings in the array or -1 for NULL terminated arrays941 * @str: string to match with942 *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 the947 * 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 that950 * are NULL terminated. However, the function does not make a distinction951 * when finishing the search: either @n elements have been compared OR952 * 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 padding994 * @dest: Where to copy to995 * @dest_len: The destination buffer size996 * @src: Where to copy from997 * @count: The number of bytes to copy998 * @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_SOURCE1013/* 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)] = #func1021 EACH_FORTIFY_FUNC(MAKE_FORTIFY_FUNC_NAME)1022#undef MAKE_FORTIFY_FUNC_NAME1023};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 */1044