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