lib/string.c

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