1 /* 2 * linux/lib/string.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 /* 8 * stupid library routines.. The optimized versions should generally be found 9 * as inline code in <asm-xx/string.h> 10 * 11 * These are buggy as well.. 12 * 13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de> 14 * - Added strsep() which will replace strtok() soon (because strsep() is 15 * reentrant and should be faster). Use only strsep() in new code, please. 16 * 17 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>, 18 * Matthew Hawkins <matt@mh.dropbear.id.au> 19 * - Kissed strtok() goodbye 20 */ 21 22 #include <linux/types.h> 23 #include <linux/string.h> 24 #include <linux/ctype.h> 25 #include <linux/kernel.h> 26 #include <linux/export.h> 27 #include <linux/bug.h> 28 #include <linux/errno.h> 29 30 #include <asm/byteorder.h> 31 #include <asm/word-at-a-time.h> 32 #include <asm/page.h> 33 34 #ifndef __HAVE_ARCH_STRNCASECMP 35 /** 36 * strncasecmp - Case insensitive, length-limited string comparison 37 * @s1: One string 38 * @s2: The other string 39 * @len: the maximum number of characters to compare 40 */ 41 int strncasecmp(const char *s1, const char *s2, size_t len) 42 { 43 /* Yes, Virginia, it had better be unsigned */ 44 unsigned char c1, c2; 45 46 if (!len) 47 return 0; 48 49 do { 50 c1 = *s1++; 51 c2 = *s2++; 52 if (!c1 || !c2) 53 break; 54 if (c1 == c2) 55 continue; 56 c1 = tolower(c1); 57 c2 = tolower(c2); 58 if (c1 != c2) 59 break; 60 } while (--len); 61 return (int)c1 - (int)c2; 62 } 63 EXPORT_SYMBOL(strncasecmp); 64 #endif 65 66 #ifndef __HAVE_ARCH_STRCASECMP 67 int strcasecmp(const char *s1, const char *s2) 68 { 69 int c1, c2; 70 71 do { 72 c1 = tolower(*s1++); 73 c2 = tolower(*s2++); 74 } while (c1 == c2 && c1 != 0); 75 return c1 - c2; 76 } 77 EXPORT_SYMBOL(strcasecmp); 78 #endif 79 80 #ifndef __HAVE_ARCH_STRCPY 81 /** 82 * strcpy - Copy a %NUL terminated string 83 * @dest: Where to copy the string to 84 * @src: Where to copy the string from 85 */ 86 #undef strcpy 87 char *strcpy(char *dest, const char *src) 88 { 89 char *tmp = dest; 90 91 while ((*dest++ = *src++) != '\0') 92 /* nothing */; 93 return tmp; 94 } 95 EXPORT_SYMBOL(strcpy); 96 #endif 97 98 #ifndef __HAVE_ARCH_STRNCPY 99 /** 100 * strncpy - Copy a length-limited, C-string 101 * @dest: Where to copy the string to 102 * @src: Where to copy the string from 103 * @count: The maximum number of bytes to copy 104 * 105 * The result is not %NUL-terminated if the source exceeds 106 * @count bytes. 107 * 108 * In the case where the length of @src is less than that of 109 * count, the remainder of @dest will be padded with %NUL. 110 * 111 */ 112 char *strncpy(char *dest, const char *src, size_t count) 113 { 114 char *tmp = dest; 115 116 while (count) { 117 if ((*tmp = *src) != 0) 118 src++; 119 tmp++; 120 count--; 121 } 122 return dest; 123 } 124 EXPORT_SYMBOL(strncpy); 125 #endif 126 127 #ifndef __HAVE_ARCH_STRLCPY 128 /** 129 * strlcpy - Copy a C-string into a sized buffer 130 * @dest: Where to copy the string to 131 * @src: Where to copy the string from 132 * @size: size of destination buffer 133 * 134 * Compatible with ``*BSD``: the result is always a valid 135 * NUL-terminated string that fits in the buffer (unless, 136 * of course, the buffer size is zero). It does not pad 137 * out the result like strncpy() does. 138 */ 139 size_t strlcpy(char *dest, const char *src, size_t size) 140 { 141 size_t ret = strlen(src); 142 143 if (size) { 144 size_t len = (ret >= size) ? size - 1 : ret; 145 memcpy(dest, src, len); 146 dest[len] = '\0'; 147 } 148 return ret; 149 } 150 EXPORT_SYMBOL(strlcpy); 151 #endif 152 153 #ifndef __HAVE_ARCH_STRSCPY 154 /** 155 * strscpy - Copy a C-string into a sized buffer 156 * @dest: Where to copy the string to 157 * @src: Where to copy the string from 158 * @count: Size of destination buffer 159 * 160 * Copy the string, or as much of it as fits, into the dest buffer. 161 * The routine returns the number of characters copied (not including 162 * the trailing NUL) or -E2BIG if the destination buffer wasn't big enough. 163 * The behavior is undefined if the string buffers overlap. 164 * The destination buffer is always NUL terminated, unless it's zero-sized. 165 * 166 * Preferred to strlcpy() since the API doesn't require reading memory 167 * from the src string beyond the specified "count" bytes, and since 168 * the return value is easier to error-check than strlcpy()'s. 169 * In addition, the implementation is robust to the string changing out 170 * from underneath it, unlike the current strlcpy() implementation. 171 * 172 * Preferred to strncpy() since it always returns a valid string, and 173 * doesn't unnecessarily force the tail of the destination buffer to be 174 * zeroed. If the zeroing is desired, it's likely cleaner to use strscpy() 175 * with an overflow test, then just memset() the tail of the dest buffer. 176 */ 177 ssize_t strscpy(char *dest, const char *src, size_t count) 178 { 179 const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS; 180 size_t max = count; 181 long res = 0; 182 183 if (count == 0) 184 return -E2BIG; 185 186 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 187 /* 188 * If src is unaligned, don't cross a page boundary, 189 * since we don't know if the next page is mapped. 190 */ 191 if ((long)src & (sizeof(long) - 1)) { 192 size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1)); 193 if (limit < max) 194 max = limit; 195 } 196 #else 197 /* If src or dest is unaligned, don't do word-at-a-time. */ 198 if (((long) dest | (long) src) & (sizeof(long) - 1)) 199 max = 0; 200 #endif 201 202 while (max >= sizeof(unsigned long)) { 203 unsigned long c, data; 204 205 c = *(unsigned long *)(src+res); 206 if (has_zero(c, &data, &constants)) { 207 data = prep_zero_mask(c, data, &constants); 208 data = create_zero_mask(data); 209 *(unsigned long *)(dest+res) = c & zero_bytemask(data); 210 return res + find_zero(data); 211 } 212 *(unsigned long *)(dest+res) = c; 213 res += sizeof(unsigned long); 214 count -= sizeof(unsigned long); 215 max -= sizeof(unsigned long); 216 } 217 218 while (count) { 219 char c; 220 221 c = src[res]; 222 dest[res] = c; 223 if (!c) 224 return res; 225 res++; 226 count--; 227 } 228 229 /* Hit buffer length without finding a NUL; force NUL-termination. */ 230 if (res) 231 dest[res-1] = '\0'; 232 233 return -E2BIG; 234 } 235 EXPORT_SYMBOL(strscpy); 236 #endif 237 238 #ifndef __HAVE_ARCH_STRCAT 239 /** 240 * strcat - Append one %NUL-terminated string to another 241 * @dest: The string to be appended to 242 * @src: The string to append to it 243 */ 244 #undef strcat 245 char *strcat(char *dest, const char *src) 246 { 247 char *tmp = dest; 248 249 while (*dest) 250 dest++; 251 while ((*dest++ = *src++) != '\0') 252 ; 253 return tmp; 254 } 255 EXPORT_SYMBOL(strcat); 256 #endif 257 258 #ifndef __HAVE_ARCH_STRNCAT 259 /** 260 * strncat - Append a length-limited, C-string to another 261 * @dest: The string to be appended to 262 * @src: The string to append to it 263 * @count: The maximum numbers of bytes to copy 264 * 265 * Note that in contrast to strncpy(), strncat() ensures the result is 266 * terminated. 267 */ 268 char *strncat(char *dest, const char *src, size_t count) 269 { 270 char *tmp = dest; 271 272 if (count) { 273 while (*dest) 274 dest++; 275 while ((*dest++ = *src++) != 0) { 276 if (--count == 0) { 277 *dest = '\0'; 278 break; 279 } 280 } 281 } 282 return tmp; 283 } 284 EXPORT_SYMBOL(strncat); 285 #endif 286 287 #ifndef __HAVE_ARCH_STRLCAT 288 /** 289 * strlcat - Append a length-limited, C-string to another 290 * @dest: The string to be appended to 291 * @src: The string to append to it 292 * @count: The size of the destination buffer. 293 */ 294 size_t strlcat(char *dest, const char *src, size_t count) 295 { 296 size_t dsize = strlen(dest); 297 size_t len = strlen(src); 298 size_t res = dsize + len; 299 300 /* This would be a bug */ 301 BUG_ON(dsize >= count); 302 303 dest += dsize; 304 count -= dsize; 305 if (len >= count) 306 len = count-1; 307 memcpy(dest, src, len); 308 dest[len] = 0; 309 return res; 310 } 311 EXPORT_SYMBOL(strlcat); 312 #endif 313 314 #ifndef __HAVE_ARCH_STRCMP 315 /** 316 * strcmp - Compare two strings 317 * @cs: One string 318 * @ct: Another string 319 */ 320 #undef strcmp 321 int strcmp(const char *cs, const char *ct) 322 { 323 unsigned char c1, c2; 324 325 while (1) { 326 c1 = *cs++; 327 c2 = *ct++; 328 if (c1 != c2) 329 return c1 < c2 ? -1 : 1; 330 if (!c1) 331 break; 332 } 333 return 0; 334 } 335 EXPORT_SYMBOL(strcmp); 336 #endif 337 338 #ifndef __HAVE_ARCH_STRNCMP 339 /** 340 * strncmp - Compare two length-limited strings 341 * @cs: One string 342 * @ct: Another string 343 * @count: The maximum number of bytes to compare 344 */ 345 int strncmp(const char *cs, const char *ct, size_t count) 346 { 347 unsigned char c1, c2; 348 349 while (count) { 350 c1 = *cs++; 351 c2 = *ct++; 352 if (c1 != c2) 353 return c1 < c2 ? -1 : 1; 354 if (!c1) 355 break; 356 count--; 357 } 358 return 0; 359 } 360 EXPORT_SYMBOL(strncmp); 361 #endif 362 363 #ifndef __HAVE_ARCH_STRCHR 364 /** 365 * strchr - Find the first occurrence of a character in a string 366 * @s: The string to be searched 367 * @c: The character to search for 368 */ 369 char *strchr(const char *s, int c) 370 { 371 for (; *s != (char)c; ++s) 372 if (*s == '\0') 373 return NULL; 374 return (char *)s; 375 } 376 EXPORT_SYMBOL(strchr); 377 #endif 378 379 #ifndef __HAVE_ARCH_STRCHRNUL 380 /** 381 * strchrnul - Find and return a character in a string, or end of string 382 * @s: The string to be searched 383 * @c: The character to search for 384 * 385 * Returns pointer to first occurrence of 'c' in s. If c is not found, then 386 * return a pointer to the null byte at the end of s. 387 */ 388 char *strchrnul(const char *s, int c) 389 { 390 while (*s && *s != (char)c) 391 s++; 392 return (char *)s; 393 } 394 EXPORT_SYMBOL(strchrnul); 395 #endif 396 397 #ifndef __HAVE_ARCH_STRRCHR 398 /** 399 * strrchr - Find the last occurrence of a character in a string 400 * @s: The string to be searched 401 * @c: The character to search for 402 */ 403 char *strrchr(const char *s, int c) 404 { 405 const char *last = NULL; 406 do { 407 if (*s == (char)c) 408 last = s; 409 } while (*s++); 410 return (char *)last; 411 } 412 EXPORT_SYMBOL(strrchr); 413 #endif 414 415 #ifndef __HAVE_ARCH_STRNCHR 416 /** 417 * strnchr - Find a character in a length limited string 418 * @s: The string to be searched 419 * @count: The number of characters to be searched 420 * @c: The character to search for 421 */ 422 char *strnchr(const char *s, size_t count, int c) 423 { 424 for (; count-- && *s != '\0'; ++s) 425 if (*s == (char)c) 426 return (char *)s; 427 return NULL; 428 } 429 EXPORT_SYMBOL(strnchr); 430 #endif 431 432 /** 433 * skip_spaces - Removes leading whitespace from @str. 434 * @str: The string to be stripped. 435 * 436 * Returns a pointer to the first non-whitespace character in @str. 437 */ 438 char *skip_spaces(const char *str) 439 { 440 while (isspace(*str)) 441 ++str; 442 return (char *)str; 443 } 444 EXPORT_SYMBOL(skip_spaces); 445 446 /** 447 * strim - Removes leading and trailing whitespace from @s. 448 * @s: The string to be stripped. 449 * 450 * Note that the first trailing whitespace is replaced with a %NUL-terminator 451 * in the given string @s. Returns a pointer to the first non-whitespace 452 * character in @s. 453 */ 454 char *strim(char *s) 455 { 456 size_t size; 457 char *end; 458 459 size = strlen(s); 460 if (!size) 461 return s; 462 463 end = s + size - 1; 464 while (end >= s && isspace(*end)) 465 end--; 466 *(end + 1) = '\0'; 467 468 return skip_spaces(s); 469 } 470 EXPORT_SYMBOL(strim); 471 472 #ifndef __HAVE_ARCH_STRLEN 473 /** 474 * strlen - Find the length of a string 475 * @s: The string to be sized 476 */ 477 size_t strlen(const char *s) 478 { 479 const char *sc; 480 481 for (sc = s; *sc != '\0'; ++sc) 482 /* nothing */; 483 return sc - s; 484 } 485 EXPORT_SYMBOL(strlen); 486 #endif 487 488 #ifndef __HAVE_ARCH_STRNLEN 489 /** 490 * strnlen - Find the length of a length-limited string 491 * @s: The string to be sized 492 * @count: The maximum number of bytes to search 493 */ 494 size_t strnlen(const char *s, size_t count) 495 { 496 const char *sc; 497 498 for (sc = s; count-- && *sc != '\0'; ++sc) 499 /* nothing */; 500 return sc - s; 501 } 502 EXPORT_SYMBOL(strnlen); 503 #endif 504 505 #ifndef __HAVE_ARCH_STRSPN 506 /** 507 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept 508 * @s: The string to be searched 509 * @accept: The string to search for 510 */ 511 size_t strspn(const char *s, const char *accept) 512 { 513 const char *p; 514 const char *a; 515 size_t count = 0; 516 517 for (p = s; *p != '\0'; ++p) { 518 for (a = accept; *a != '\0'; ++a) { 519 if (*p == *a) 520 break; 521 } 522 if (*a == '\0') 523 return count; 524 ++count; 525 } 526 return count; 527 } 528 529 EXPORT_SYMBOL(strspn); 530 #endif 531 532 #ifndef __HAVE_ARCH_STRCSPN 533 /** 534 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject 535 * @s: The string to be searched 536 * @reject: The string to avoid 537 */ 538 size_t strcspn(const char *s, const char *reject) 539 { 540 const char *p; 541 const char *r; 542 size_t count = 0; 543 544 for (p = s; *p != '\0'; ++p) { 545 for (r = reject; *r != '\0'; ++r) { 546 if (*p == *r) 547 return count; 548 } 549 ++count; 550 } 551 return count; 552 } 553 EXPORT_SYMBOL(strcspn); 554 #endif 555 556 #ifndef __HAVE_ARCH_STRPBRK 557 /** 558 * strpbrk - Find the first occurrence of a set of characters 559 * @cs: The string to be searched 560 * @ct: The characters to search for 561 */ 562 char *strpbrk(const char *cs, const char *ct) 563 { 564 const char *sc1, *sc2; 565 566 for (sc1 = cs; *sc1 != '\0'; ++sc1) { 567 for (sc2 = ct; *sc2 != '\0'; ++sc2) { 568 if (*sc1 == *sc2) 569 return (char *)sc1; 570 } 571 } 572 return NULL; 573 } 574 EXPORT_SYMBOL(strpbrk); 575 #endif 576 577 #ifndef __HAVE_ARCH_STRSEP 578 /** 579 * strsep - Split a string into tokens 580 * @s: The string to be searched 581 * @ct: The characters to search for 582 * 583 * strsep() updates @s to point after the token, ready for the next call. 584 * 585 * It returns empty tokens, too, behaving exactly like the libc function 586 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. 587 * Same semantics, slimmer shape. ;) 588 */ 589 char *strsep(char **s, const char *ct) 590 { 591 char *sbegin = *s; 592 char *end; 593 594 if (sbegin == NULL) 595 return NULL; 596 597 end = strpbrk(sbegin, ct); 598 if (end) 599 *end++ = '\0'; 600 *s = end; 601 return sbegin; 602 } 603 EXPORT_SYMBOL(strsep); 604 #endif 605 606 /** 607 * sysfs_streq - return true if strings are equal, modulo trailing newline 608 * @s1: one string 609 * @s2: another string 610 * 611 * This routine returns true iff two strings are equal, treating both 612 * NUL and newline-then-NUL as equivalent string terminations. It's 613 * geared for use with sysfs input strings, which generally terminate 614 * with newlines but are compared against values without newlines. 615 */ 616 bool sysfs_streq(const char *s1, const char *s2) 617 { 618 while (*s1 && *s1 == *s2) { 619 s1++; 620 s2++; 621 } 622 623 if (*s1 == *s2) 624 return true; 625 if (!*s1 && *s2 == '\n' && !s2[1]) 626 return true; 627 if (*s1 == '\n' && !s1[1] && !*s2) 628 return true; 629 return false; 630 } 631 EXPORT_SYMBOL(sysfs_streq); 632 633 /** 634 * match_string - matches given string in an array 635 * @array: array of strings 636 * @n: number of strings in the array or -1 for NULL terminated arrays 637 * @string: string to match with 638 * 639 * Return: 640 * index of a @string in the @array if matches, or %-EINVAL otherwise. 641 */ 642 int match_string(const char * const *array, size_t n, const char *string) 643 { 644 int index; 645 const char *item; 646 647 for (index = 0; index < n; index++) { 648 item = array[index]; 649 if (!item) 650 break; 651 if (!strcmp(item, string)) 652 return index; 653 } 654 655 return -EINVAL; 656 } 657 EXPORT_SYMBOL(match_string); 658 659 /** 660 * __sysfs_match_string - matches given string in an array 661 * @array: array of strings 662 * @n: number of strings in the array or -1 for NULL terminated arrays 663 * @str: string to match with 664 * 665 * Returns index of @str in the @array or -EINVAL, just like match_string(). 666 * Uses sysfs_streq instead of strcmp for matching. 667 */ 668 int __sysfs_match_string(const char * const *array, size_t n, const char *str) 669 { 670 const char *item; 671 int index; 672 673 for (index = 0; index < n; index++) { 674 item = array[index]; 675 if (!item) 676 break; 677 if (sysfs_streq(item, str)) 678 return index; 679 } 680 681 return -EINVAL; 682 } 683 EXPORT_SYMBOL(__sysfs_match_string); 684 685 #ifndef __HAVE_ARCH_MEMSET 686 /** 687 * memset - Fill a region of memory with the given value 688 * @s: Pointer to the start of the area. 689 * @c: The byte to fill the area with 690 * @count: The size of the area. 691 * 692 * Do not use memset() to access IO space, use memset_io() instead. 693 */ 694 void *memset(void *s, int c, size_t count) 695 { 696 char *xs = s; 697 698 while (count--) 699 *xs++ = c; 700 return s; 701 } 702 EXPORT_SYMBOL(memset); 703 #endif 704 705 /** 706 * memzero_explicit - Fill a region of memory (e.g. sensitive 707 * keying data) with 0s. 708 * @s: Pointer to the start of the area. 709 * @count: The size of the area. 710 * 711 * Note: usually using memset() is just fine (!), but in cases 712 * where clearing out _local_ data at the end of a scope is 713 * necessary, memzero_explicit() should be used instead in 714 * order to prevent the compiler from optimising away zeroing. 715 * 716 * memzero_explicit() doesn't need an arch-specific version as 717 * it just invokes the one of memset() implicitly. 718 */ 719 void memzero_explicit(void *s, size_t count) 720 { 721 memset(s, 0, count); 722 barrier_data(s); 723 } 724 EXPORT_SYMBOL(memzero_explicit); 725 726 #ifndef __HAVE_ARCH_MEMSET16 727 /** 728 * memset16() - Fill a memory area with a uint16_t 729 * @s: Pointer to the start of the area. 730 * @v: The value to fill the area with 731 * @count: The number of values to store 732 * 733 * Differs from memset() in that it fills with a uint16_t instead 734 * of a byte. Remember that @count is the number of uint16_ts to 735 * store, not the number of bytes. 736 */ 737 void *memset16(uint16_t *s, uint16_t v, size_t count) 738 { 739 uint16_t *xs = s; 740 741 while (count--) 742 *xs++ = v; 743 return s; 744 } 745 EXPORT_SYMBOL(memset16); 746 #endif 747 748 #ifndef __HAVE_ARCH_MEMSET32 749 /** 750 * memset32() - Fill a memory area with a uint32_t 751 * @s: Pointer to the start of the area. 752 * @v: The value to fill the area with 753 * @count: The number of values to store 754 * 755 * Differs from memset() in that it fills with a uint32_t instead 756 * of a byte. Remember that @count is the number of uint32_ts to 757 * store, not the number of bytes. 758 */ 759 void *memset32(uint32_t *s, uint32_t v, size_t count) 760 { 761 uint32_t *xs = s; 762 763 while (count--) 764 *xs++ = v; 765 return s; 766 } 767 EXPORT_SYMBOL(memset32); 768 #endif 769 770 #ifndef __HAVE_ARCH_MEMSET64 771 /** 772 * memset64() - Fill a memory area with a uint64_t 773 * @s: Pointer to the start of the area. 774 * @v: The value to fill the area with 775 * @count: The number of values to store 776 * 777 * Differs from memset() in that it fills with a uint64_t instead 778 * of a byte. Remember that @count is the number of uint64_ts to 779 * store, not the number of bytes. 780 */ 781 void *memset64(uint64_t *s, uint64_t v, size_t count) 782 { 783 uint64_t *xs = s; 784 785 while (count--) 786 *xs++ = v; 787 return s; 788 } 789 EXPORT_SYMBOL(memset64); 790 #endif 791 792 #ifndef __HAVE_ARCH_MEMCPY 793 /** 794 * memcpy - Copy one area of memory to another 795 * @dest: Where to copy to 796 * @src: Where to copy from 797 * @count: The size of the area. 798 * 799 * You should not use this function to access IO space, use memcpy_toio() 800 * or memcpy_fromio() instead. 801 */ 802 void *memcpy(void *dest, const void *src, size_t count) 803 { 804 char *tmp = dest; 805 const char *s = src; 806 807 while (count--) 808 *tmp++ = *s++; 809 return dest; 810 } 811 EXPORT_SYMBOL(memcpy); 812 #endif 813 814 #ifndef __HAVE_ARCH_MEMMOVE 815 /** 816 * memmove - Copy one area of memory to another 817 * @dest: Where to copy to 818 * @src: Where to copy from 819 * @count: The size of the area. 820 * 821 * Unlike memcpy(), memmove() copes with overlapping areas. 822 */ 823 void *memmove(void *dest, const void *src, size_t count) 824 { 825 char *tmp; 826 const char *s; 827 828 if (dest <= src) { 829 tmp = dest; 830 s = src; 831 while (count--) 832 *tmp++ = *s++; 833 } else { 834 tmp = dest; 835 tmp += count; 836 s = src; 837 s += count; 838 while (count--) 839 *--tmp = *--s; 840 } 841 return dest; 842 } 843 EXPORT_SYMBOL(memmove); 844 #endif 845 846 #ifndef __HAVE_ARCH_MEMCMP 847 /** 848 * memcmp - Compare two areas of memory 849 * @cs: One area of memory 850 * @ct: Another area of memory 851 * @count: The size of the area. 852 */ 853 #undef memcmp 854 __visible int memcmp(const void *cs, const void *ct, size_t count) 855 { 856 const unsigned char *su1, *su2; 857 int res = 0; 858 859 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) 860 if ((res = *su1 - *su2) != 0) 861 break; 862 return res; 863 } 864 EXPORT_SYMBOL(memcmp); 865 #endif 866 867 #ifndef __HAVE_ARCH_MEMSCAN 868 /** 869 * memscan - Find a character in an area of memory. 870 * @addr: The memory area 871 * @c: The byte to search for 872 * @size: The size of the area. 873 * 874 * returns the address of the first occurrence of @c, or 1 byte past 875 * the area if @c is not found 876 */ 877 void *memscan(void *addr, int c, size_t size) 878 { 879 unsigned char *p = addr; 880 881 while (size) { 882 if (*p == c) 883 return (void *)p; 884 p++; 885 size--; 886 } 887 return (void *)p; 888 } 889 EXPORT_SYMBOL(memscan); 890 #endif 891 892 #ifndef __HAVE_ARCH_STRSTR 893 /** 894 * strstr - Find the first substring in a %NUL terminated string 895 * @s1: The string to be searched 896 * @s2: The string to search for 897 */ 898 char *strstr(const char *s1, const char *s2) 899 { 900 size_t l1, l2; 901 902 l2 = strlen(s2); 903 if (!l2) 904 return (char *)s1; 905 l1 = strlen(s1); 906 while (l1 >= l2) { 907 l1--; 908 if (!memcmp(s1, s2, l2)) 909 return (char *)s1; 910 s1++; 911 } 912 return NULL; 913 } 914 EXPORT_SYMBOL(strstr); 915 #endif 916 917 #ifndef __HAVE_ARCH_STRNSTR 918 /** 919 * strnstr - Find the first substring in a length-limited string 920 * @s1: The string to be searched 921 * @s2: The string to search for 922 * @len: the maximum number of characters to search 923 */ 924 char *strnstr(const char *s1, const char *s2, size_t len) 925 { 926 size_t l2; 927 928 l2 = strlen(s2); 929 if (!l2) 930 return (char *)s1; 931 while (len >= l2) { 932 len--; 933 if (!memcmp(s1, s2, l2)) 934 return (char *)s1; 935 s1++; 936 } 937 return NULL; 938 } 939 EXPORT_SYMBOL(strnstr); 940 #endif 941 942 #ifndef __HAVE_ARCH_MEMCHR 943 /** 944 * memchr - Find a character in an area of memory. 945 * @s: The memory area 946 * @c: The byte to search for 947 * @n: The size of the area. 948 * 949 * returns the address of the first occurrence of @c, or %NULL 950 * if @c is not found 951 */ 952 void *memchr(const void *s, int c, size_t n) 953 { 954 const unsigned char *p = s; 955 while (n-- != 0) { 956 if ((unsigned char)c == *p++) { 957 return (void *)(p - 1); 958 } 959 } 960 return NULL; 961 } 962 EXPORT_SYMBOL(memchr); 963 #endif 964 965 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes) 966 { 967 while (bytes) { 968 if (*start != value) 969 return (void *)start; 970 start++; 971 bytes--; 972 } 973 return NULL; 974 } 975 976 /** 977 * memchr_inv - Find an unmatching character in an area of memory. 978 * @start: The memory area 979 * @c: Find a character other than c 980 * @bytes: The size of the area. 981 * 982 * returns the address of the first character other than @c, or %NULL 983 * if the whole buffer contains just @c. 984 */ 985 void *memchr_inv(const void *start, int c, size_t bytes) 986 { 987 u8 value = c; 988 u64 value64; 989 unsigned int words, prefix; 990 991 if (bytes <= 16) 992 return check_bytes8(start, value, bytes); 993 994 value64 = value; 995 #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 996 value64 *= 0x0101010101010101ULL; 997 #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) 998 value64 *= 0x01010101; 999 value64 |= value64 << 32; 1000 #else 1001 value64 |= value64 << 8; 1002 value64 |= value64 << 16; 1003 value64 |= value64 << 32; 1004 #endif 1005 1006 prefix = (unsigned long)start % 8; 1007 if (prefix) { 1008 u8 *r; 1009 1010 prefix = 8 - prefix; 1011 r = check_bytes8(start, value, prefix); 1012 if (r) 1013 return r; 1014 start += prefix; 1015 bytes -= prefix; 1016 } 1017 1018 words = bytes / 8; 1019 1020 while (words) { 1021 if (*(u64 *)start != value64) 1022 return check_bytes8(start, value, 8); 1023 start += 8; 1024 words--; 1025 } 1026 1027 return check_bytes8(start, value, bytes % 8); 1028 } 1029 EXPORT_SYMBOL(memchr_inv); 1030 1031 /** 1032 * strreplace - Replace all occurrences of character in string. 1033 * @s: The string to operate on. 1034 * @old: The character being replaced. 1035 * @new: The character @old is replaced with. 1036 * 1037 * Returns pointer to the nul byte at the end of @s. 1038 */ 1039 char *strreplace(char *s, char old, char new) 1040 { 1041 for (; *s; ++s) 1042 if (*s == old) 1043 *s = new; 1044 return s; 1045 } 1046 EXPORT_SYMBOL(strreplace); 1047 1048 void fortify_panic(const char *name) 1049 { 1050 pr_emerg("detected buffer overflow in %s\n", name); 1051 BUG(); 1052 } 1053 EXPORT_SYMBOL(fortify_panic); 1054 1055 #ifdef CONFIG_STRING_SELFTEST 1056 #include <linux/slab.h> 1057 #include <linux/module.h> 1058 1059 static __init int memset16_selftest(void) 1060 { 1061 unsigned i, j, k; 1062 u16 v, *p; 1063 1064 p = kmalloc(256 * 2 * 2, GFP_KERNEL); 1065 if (!p) 1066 return -1; 1067 1068 for (i = 0; i < 256; i++) { 1069 for (j = 0; j < 256; j++) { 1070 memset(p, 0xa1, 256 * 2 * sizeof(v)); 1071 memset16(p + i, 0xb1b2, j); 1072 for (k = 0; k < 512; k++) { 1073 v = p[k]; 1074 if (k < i) { 1075 if (v != 0xa1a1) 1076 goto fail; 1077 } else if (k < i + j) { 1078 if (v != 0xb1b2) 1079 goto fail; 1080 } else { 1081 if (v != 0xa1a1) 1082 goto fail; 1083 } 1084 } 1085 } 1086 } 1087 1088 fail: 1089 kfree(p); 1090 if (i < 256) 1091 return (i << 24) | (j << 16) | k; 1092 return 0; 1093 } 1094 1095 static __init int memset32_selftest(void) 1096 { 1097 unsigned i, j, k; 1098 u32 v, *p; 1099 1100 p = kmalloc(256 * 2 * 4, GFP_KERNEL); 1101 if (!p) 1102 return -1; 1103 1104 for (i = 0; i < 256; i++) { 1105 for (j = 0; j < 256; j++) { 1106 memset(p, 0xa1, 256 * 2 * sizeof(v)); 1107 memset32(p + i, 0xb1b2b3b4, j); 1108 for (k = 0; k < 512; k++) { 1109 v = p[k]; 1110 if (k < i) { 1111 if (v != 0xa1a1a1a1) 1112 goto fail; 1113 } else if (k < i + j) { 1114 if (v != 0xb1b2b3b4) 1115 goto fail; 1116 } else { 1117 if (v != 0xa1a1a1a1) 1118 goto fail; 1119 } 1120 } 1121 } 1122 } 1123 1124 fail: 1125 kfree(p); 1126 if (i < 256) 1127 return (i << 24) | (j << 16) | k; 1128 return 0; 1129 } 1130 1131 static __init int memset64_selftest(void) 1132 { 1133 unsigned i, j, k; 1134 u64 v, *p; 1135 1136 p = kmalloc(256 * 2 * 8, GFP_KERNEL); 1137 if (!p) 1138 return -1; 1139 1140 for (i = 0; i < 256; i++) { 1141 for (j = 0; j < 256; j++) { 1142 memset(p, 0xa1, 256 * 2 * sizeof(v)); 1143 memset64(p + i, 0xb1b2b3b4b5b6b7b8ULL, j); 1144 for (k = 0; k < 512; k++) { 1145 v = p[k]; 1146 if (k < i) { 1147 if (v != 0xa1a1a1a1a1a1a1a1ULL) 1148 goto fail; 1149 } else if (k < i + j) { 1150 if (v != 0xb1b2b3b4b5b6b7b8ULL) 1151 goto fail; 1152 } else { 1153 if (v != 0xa1a1a1a1a1a1a1a1ULL) 1154 goto fail; 1155 } 1156 } 1157 } 1158 } 1159 1160 fail: 1161 kfree(p); 1162 if (i < 256) 1163 return (i << 24) | (j << 16) | k; 1164 return 0; 1165 } 1166 1167 static __init int string_selftest_init(void) 1168 { 1169 int test, subtest; 1170 1171 test = 1; 1172 subtest = memset16_selftest(); 1173 if (subtest) 1174 goto fail; 1175 1176 test = 2; 1177 subtest = memset32_selftest(); 1178 if (subtest) 1179 goto fail; 1180 1181 test = 3; 1182 subtest = memset64_selftest(); 1183 if (subtest) 1184 goto fail; 1185 1186 pr_info("String selftests succeeded\n"); 1187 return 0; 1188 fail: 1189 pr_crit("String selftest failure %d.%08x\n", test, subtest); 1190 return 0; 1191 } 1192 1193 module_init(string_selftest_init); 1194 #endif /* CONFIG_STRING_SELFTEST */ 1195