lib/string.c

   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 #ifndef __HAVE_ARCH_STRNCASECMP
  31 /**
  32  * strncasecmp - Case insensitive, length-limited string comparison
  33  * @s1: One string
  34  * @s2: The other string
  35  * @len: the maximum number of characters to compare
  36  */
  37 int strncasecmp(const char *s1, const char *s2, size_t len)
  38 {
  39         /* Yes, Virginia, it had better be unsigned */
  40         unsigned char c1, c2;
  41
  42         if (!len)
  43                 return 0;
  44
  45         do {
  46                 c1 = *s1++;
  47                 c2 = *s2++;
  48                 if (!c1 || !c2)
  49                         break;
  50                 if (c1 == c2)
  51                         continue;
  52                 c1 = tolower(c1);
  53                 c2 = tolower(c2);
  54                 if (c1 != c2)
  55                         break;
  56         } while (--len);
  57         return (int)c1 - (int)c2;
  58 }
  59 EXPORT_SYMBOL(strncasecmp);
  60 #endif
  61
  62 #ifndef __HAVE_ARCH_STRCASECMP
  63 int strcasecmp(const char *s1, const char *s2)
  64 {
  65         int c1, c2;
  66
  67         do {
  68                 c1 = tolower(*s1++);
  69                 c2 = tolower(*s2++);
  70         } while (c1 == c2 && c1 != 0);
  71         return c1 - c2;
  72 }
  73 EXPORT_SYMBOL(strcasecmp);
  74 #endif
  75
  76 #ifndef __HAVE_ARCH_STRCPY
  77 /**
  78  * strcpy - Copy a %NUL terminated string
  79  * @dest: Where to copy the string to
  80  * @src: Where to copy the string from
  81  */
  82 #undef strcpy
  83 char *strcpy(char *dest, const char *src)
  84 {
  85         char *tmp = dest;
  86
  87         while ((*dest++ = *src++) != '\0')
  88                 /* nothing */;
  89         return tmp;
  90 }
  91 EXPORT_SYMBOL(strcpy);
  92 #endif
  93
  94 #ifndef __HAVE_ARCH_STRNCPY
  95 /**
  96  * strncpy - Copy a length-limited, C-string
  97  * @dest: Where to copy the string to
  98  * @src: Where to copy the string from
  99  * @count: The maximum number of bytes to copy
 100  *
 101  * The result is not %NUL-terminated if the source exceeds
 102  * @count bytes.
 103  *
 104  * In the case where the length of @src is less than  that  of
 105  * count, the remainder of @dest will be padded with %NUL.
 106  *
 107  */
 108 char *strncpy(char *dest, const char *src, size_t count)
 109 {
 110         char *tmp = dest;
 111
 112         while (count) {
 113                 if ((*tmp = *src) != 0)
 114                         src++;
 115                 tmp++;
 116                 count--;
 117         }
 118         return dest;
 119 }
 120 EXPORT_SYMBOL(strncpy);
 121 #endif
 122
 123 #ifndef __HAVE_ARCH_STRLCPY
 124 /**
 125  * strlcpy - Copy a C-string into a sized buffer
 126  * @dest: Where to copy the string to
 127  * @src: Where to copy the string from
 128  * @size: size of destination buffer
 129  *
 130  * Compatible with *BSD: the result is always a valid
 131  * NUL-terminated string that fits in the buffer (unless,
 132  * of course, the buffer size is zero). It does not pad
 133  * out the result like strncpy() does.
 134  */
 135 size_t strlcpy(char *dest, const char *src, size_t size)
 136 {
 137         size_t ret = strlen(src);
 138
 139         if (size) {
 140                 size_t len = (ret >= size) ? size - 1 : ret;
 141                 memcpy(dest, src, len);
 142                 dest[len] = '\0';
 143         }
 144         return ret;
 145 }
 146 EXPORT_SYMBOL(strlcpy);
 147 #endif
 148
 149 #ifndef __HAVE_ARCH_STRCAT
 150 /**
 151  * strcat - Append one %NUL-terminated string to another
 152  * @dest: The string to be appended to
 153  * @src: The string to append to it
 154  */
 155 #undef strcat
 156 char *strcat(char *dest, const char *src)
 157 {
 158         char *tmp = dest;
 159
 160         while (*dest)
 161                 dest++;
 162         while ((*dest++ = *src++) != '\0')
 163                 ;
 164         return tmp;
 165 }
 166 EXPORT_SYMBOL(strcat);
 167 #endif
 168
 169 #ifndef __HAVE_ARCH_STRNCAT
 170 /**
 171  * strncat - Append a length-limited, C-string to another
 172  * @dest: The string to be appended to
 173  * @src: The string to append to it
 174  * @count: The maximum numbers of bytes to copy
 175  *
 176  * Note that in contrast to strncpy(), strncat() ensures the result is
 177  * terminated.
 178  */
 179 char *strncat(char *dest, const char *src, size_t count)
 180 {
 181         char *tmp = dest;
 182
 183         if (count) {
 184                 while (*dest)
 185                         dest++;
 186                 while ((*dest++ = *src++) != 0) {
 187                         if (--count == 0) {
 188                                 *dest = '\0';
 189                                 break;
 190                         }
 191                 }
 192         }
 193         return tmp;
 194 }
 195 EXPORT_SYMBOL(strncat);
 196 #endif
 197
 198 #ifndef __HAVE_ARCH_STRLCAT
 199 /**
 200  * strlcat - Append a length-limited, C-string to another
 201  * @dest: The string to be appended to
 202  * @src: The string to append to it
 203  * @count: The size of the destination buffer.
 204  */
 205 size_t strlcat(char *dest, const char *src, size_t count)
 206 {
 207         size_t dsize = strlen(dest);
 208         size_t len = strlen(src);
 209         size_t res = dsize + len;
 210
 211         /* This would be a bug */
 212         BUG_ON(dsize >= count);
 213
 214         dest += dsize;
 215         count -= dsize;
 216         if (len >= count)
 217                 len = count-1;
 218         memcpy(dest, src, len);
 219         dest[len] = 0;
 220         return res;
 221 }
 222 EXPORT_SYMBOL(strlcat);
 223 #endif
 224
 225 #ifndef __HAVE_ARCH_STRCMP
 226 /**
 227  * strcmp - Compare two strings
 228  * @cs: One string
 229  * @ct: Another string
 230  */
 231 #undef strcmp
 232 int strcmp(const char *cs, const char *ct)
 233 {
 234         unsigned char c1, c2;
 235
 236         while (1) {
 237                 c1 = *cs++;
 238                 c2 = *ct++;
 239                 if (c1 != c2)
 240                         return c1 < c2 ? -1 : 1;
 241                 if (!c1)
 242                         break;
 243         }
 244         return 0;
 245 }
 246 EXPORT_SYMBOL(strcmp);
 247 #endif
 248
 249 #ifndef __HAVE_ARCH_STRNCMP
 250 /**
 251  * strncmp - Compare two length-limited strings
 252  * @cs: One string
 253  * @ct: Another string
 254  * @count: The maximum number of bytes to compare
 255  */
 256 int strncmp(const char *cs, const char *ct, size_t count)
 257 {
 258         unsigned char c1, c2;
 259
 260         while (count) {
 261                 c1 = *cs++;
 262                 c2 = *ct++;
 263                 if (c1 != c2)
 264                         return c1 < c2 ? -1 : 1;
 265                 if (!c1)
 266                         break;
 267                 count--;
 268         }
 269         return 0;
 270 }
 271 EXPORT_SYMBOL(strncmp);
 272 #endif
 273
 274 #ifndef __HAVE_ARCH_STRCHR
 275 /**
 276  * strchr - Find the first occurrence of a character in a string
 277  * @s: The string to be searched
 278  * @c: The character to search for
 279  */
 280 char *strchr(const char *s, int c)
 281 {
 282         for (; *s != (char)c; ++s)
 283                 if (*s == '\0')
 284                         return NULL;
 285         return (char *)s;
 286 }
 287 EXPORT_SYMBOL(strchr);
 288 #endif
 289
 290 #ifndef __HAVE_ARCH_STRCHRNUL
 291 /**
 292  * strchrnul - Find and return a character in a string, or end of string
 293  * @s: The string to be searched
 294  * @c: The character to search for
 295  *
 296  * Returns pointer to first occurrence of 'c' in s. If c is not found, then
 297  * return a pointer to the null byte at the end of s.
 298  */
 299 char *strchrnul(const char *s, int c)
 300 {
 301         while (*s && *s != (char)c)
 302                 s++;
 303         return (char *)s;
 304 }
 305 EXPORT_SYMBOL(strchrnul);
 306 #endif
 307
 308 #ifndef __HAVE_ARCH_STRRCHR
 309 /**
 310  * strrchr - Find the last occurrence of a character in a string
 311  * @s: The string to be searched
 312  * @c: The character to search for
 313  */
 314 char *strrchr(const char *s, int c)
 315 {
 316         const char *last = NULL;
 317         do {
 318                 if (*s == (char)c)
 319                         last = s;
 320         } while (*s++);
 321         return (char *)last;
 322 }
 323 EXPORT_SYMBOL(strrchr);
 324 #endif
 325
 326 #ifndef __HAVE_ARCH_STRNCHR
 327 /**
 328  * strnchr - Find a character in a length limited string
 329  * @s: The string to be searched
 330  * @count: The number of characters to be searched
 331  * @c: The character to search for
 332  */
 333 char *strnchr(const char *s, size_t count, int c)
 334 {
 335         for (; count-- && *s != '\0'; ++s)
 336                 if (*s == (char)c)
 337                         return (char *)s;
 338         return NULL;
 339 }
 340 EXPORT_SYMBOL(strnchr);
 341 #endif
 342
 343 /**
 344  * skip_spaces - Removes leading whitespace from @str.
 345  * @str: The string to be stripped.
 346  *
 347  * Returns a pointer to the first non-whitespace character in @str.
 348  */
 349 char *skip_spaces(const char *str)
 350 {
 351         while (isspace(*str))
 352                 ++str;
 353         return (char *)str;
 354 }
 355 EXPORT_SYMBOL(skip_spaces);
 356
 357 /**
 358  * strim - Removes leading and trailing whitespace from @s.
 359  * @s: The string to be stripped.
 360  *
 361  * Note that the first trailing whitespace is replaced with a %NUL-terminator
 362  * in the given string @s. Returns a pointer to the first non-whitespace
 363  * character in @s.
 364  */
 365 char *strim(char *s)
 366 {
 367         size_t size;
 368         char *end;
 369
 370         size = strlen(s);
 371         if (!size)
 372                 return s;
 373
 374         end = s + size - 1;
 375         while (end >= s && isspace(*end))
 376                 end--;
 377         *(end + 1) = '\0';
 378
 379         return skip_spaces(s);
 380 }
 381 EXPORT_SYMBOL(strim);
 382
 383 #ifndef __HAVE_ARCH_STRLEN
 384 /**
 385  * strlen - Find the length of a string
 386  * @s: The string to be sized
 387  */
 388 size_t strlen(const char *s)
 389 {
 390         const char *sc;
 391
 392         for (sc = s; *sc != '\0'; ++sc)
 393                 /* nothing */;
 394         return sc - s;
 395 }
 396 EXPORT_SYMBOL(strlen);
 397 #endif
 398
 399 #ifndef __HAVE_ARCH_STRNLEN
 400 /**
 401  * strnlen - Find the length of a length-limited string
 402  * @s: The string to be sized
 403  * @count: The maximum number of bytes to search
 404  */
 405 size_t strnlen(const char *s, size_t count)
 406 {
 407         const char *sc;
 408
 409         for (sc = s; count-- && *sc != '\0'; ++sc)
 410                 /* nothing */;
 411         return sc - s;
 412 }
 413 EXPORT_SYMBOL(strnlen);
 414 #endif
 415
 416 #ifndef __HAVE_ARCH_STRSPN
 417 /**
 418  * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
 419  * @s: The string to be searched
 420  * @accept: The string to search for
 421  */
 422 size_t strspn(const char *s, const char *accept)
 423 {
 424         const char *p;
 425         const char *a;
 426         size_t count = 0;
 427
 428         for (p = s; *p != '\0'; ++p) {
 429                 for (a = accept; *a != '\0'; ++a) {
 430                         if (*p == *a)
 431                                 break;
 432                 }
 433                 if (*a == '\0')
 434                         return count;
 435                 ++count;
 436         }
 437         return count;
 438 }
 439
 440 EXPORT_SYMBOL(strspn);
 441 #endif
 442
 443 #ifndef __HAVE_ARCH_STRCSPN
 444 /**
 445  * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
 446  * @s: The string to be searched
 447  * @reject: The string to avoid
 448  */
 449 size_t strcspn(const char *s, const char *reject)
 450 {
 451         const char *p;
 452         const char *r;
 453         size_t count = 0;
 454
 455         for (p = s; *p != '\0'; ++p) {
 456                 for (r = reject; *r != '\0'; ++r) {
 457                         if (*p == *r)
 458                                 return count;
 459                 }
 460                 ++count;
 461         }
 462         return count;
 463 }
 464 EXPORT_SYMBOL(strcspn);
 465 #endif
 466
 467 #ifndef __HAVE_ARCH_STRPBRK
 468 /**
 469  * strpbrk - Find the first occurrence of a set of characters
 470  * @cs: The string to be searched
 471  * @ct: The characters to search for
 472  */
 473 char *strpbrk(const char *cs, const char *ct)
 474 {
 475         const char *sc1, *sc2;
 476
 477         for (sc1 = cs; *sc1 != '\0'; ++sc1) {
 478                 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
 479                         if (*sc1 == *sc2)
 480                                 return (char *)sc1;
 481                 }
 482         }
 483         return NULL;
 484 }
 485 EXPORT_SYMBOL(strpbrk);
 486 #endif
 487
 488 #ifndef __HAVE_ARCH_STRSEP
 489 /**
 490  * strsep - Split a string into tokens
 491  * @s: The string to be searched
 492  * @ct: The characters to search for
 493  *
 494  * strsep() updates @s to point after the token, ready for the next call.
 495  *
 496  * It returns empty tokens, too, behaving exactly like the libc function
 497  * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
 498  * Same semantics, slimmer shape. ;)
 499  */
 500 char *strsep(char **s, const char *ct)
 501 {
 502         char *sbegin = *s;
 503         char *end;
 504
 505         if (sbegin == NULL)
 506                 return NULL;
 507
 508         end = strpbrk(sbegin, ct);
 509         if (end)
 510                 *end++ = '\0';
 511         *s = end;
 512         return sbegin;
 513 }
 514 EXPORT_SYMBOL(strsep);
 515 #endif
 516
 517 /**
 518  * sysfs_streq - return true if strings are equal, modulo trailing newline
 519  * @s1: one string
 520  * @s2: another string
 521  *
 522  * This routine returns true iff two strings are equal, treating both
 523  * NUL and newline-then-NUL as equivalent string terminations.  It's
 524  * geared for use with sysfs input strings, which generally terminate
 525  * with newlines but are compared against values without newlines.
 526  */
 527 bool sysfs_streq(const char *s1, const char *s2)
 528 {
 529         while (*s1 && *s1 == *s2) {
 530                 s1++;
 531                 s2++;
 532         }
 533
 534         if (*s1 == *s2)
 535                 return true;
 536         if (!*s1 && *s2 == '\n' && !s2[1])
 537                 return true;
 538         if (*s1 == '\n' && !s1[1] && !*s2)
 539                 return true;
 540         return false;
 541 }
 542 EXPORT_SYMBOL(sysfs_streq);
 543
 544 /**
 545  * strtobool - convert common user inputs into boolean values
 546  * @s: input string
 547  * @res: result
 548  *
 549  * This routine returns 0 iff the first character is one of 'Yy1Nn0'.
 550  * Otherwise it will return -EINVAL.  Value pointed to by res is
 551  * updated upon finding a match.
 552  */
 553 int strtobool(const char *s, bool *res)
 554 {
 555         switch (s[0]) {
 556         case 'y':
 557         case 'Y':
 558         case '1':
 559                 *res = true;
 560                 break;
 561         case 'n':
 562         case 'N':
 563         case '0':
 564                 *res = false;
 565                 break;
 566         default:
 567                 return -EINVAL;
 568         }
 569         return 0;
 570 }
 571 EXPORT_SYMBOL(strtobool);
 572
 573 #ifndef __HAVE_ARCH_MEMSET
 574 /**
 575  * memset - Fill a region of memory with the given value
 576  * @s: Pointer to the start of the area.
 577  * @c: The byte to fill the area with
 578  * @count: The size of the area.
 579  *
 580  * Do not use memset() to access IO space, use memset_io() instead.
 581  */
 582 void *memset(void *s, int c, size_t count)
 583 {
 584         char *xs = s;
 585
 586         while (count--)
 587                 *xs++ = c;
 588         return s;
 589 }
 590 EXPORT_SYMBOL(memset);
 591 #endif
 592
 593 /**
 594  * memzero_explicit - Fill a region of memory (e.g. sensitive
 595  *                    keying data) with 0s.
 596  * @s: Pointer to the start of the area.
 597  * @count: The size of the area.
 598  *
 599  * Note: usually using memset() is just fine (!), but in cases
 600  * where clearing out _local_ data at the end of a scope is
 601  * necessary, memzero_explicit() should be used instead in
 602  * order to prevent the compiler from optimising away zeroing.
 603  *
 604  * memzero_explicit() doesn't need an arch-specific version as
 605  * it just invokes the one of memset() implicitly.
 606  */
 607 void memzero_explicit(void *s, size_t count)
 608 {
 609         memset(s, 0, count);
 610         barrier_data(s);
 611 }
 612 EXPORT_SYMBOL(memzero_explicit);
 613
 614 #ifndef __HAVE_ARCH_MEMCPY
 615 /**
 616  * memcpy - Copy one area of memory to another
 617  * @dest: Where to copy to
 618  * @src: Where to copy from
 619  * @count: The size of the area.
 620  *
 621  * You should not use this function to access IO space, use memcpy_toio()
 622  * or memcpy_fromio() instead.
 623  */
 624 void *memcpy(void *dest, const void *src, size_t count)
 625 {
 626         char *tmp = dest;
 627         const char *s = src;
 628
 629         while (count--)
 630                 *tmp++ = *s++;
 631         return dest;
 632 }
 633 EXPORT_SYMBOL(memcpy);
 634 #endif
 635
 636 #ifndef __HAVE_ARCH_MEMMOVE
 637 /**
 638  * memmove - Copy one area of memory to another
 639  * @dest: Where to copy to
 640  * @src: Where to copy from
 641  * @count: The size of the area.
 642  *
 643  * Unlike memcpy(), memmove() copes with overlapping areas.
 644  */
 645 void *memmove(void *dest, const void *src, size_t count)
 646 {
 647         char *tmp;
 648         const char *s;
 649
 650         if (dest <= src) {
 651                 tmp = dest;
 652                 s = src;
 653                 while (count--)
 654                         *tmp++ = *s++;
 655         } else {
 656                 tmp = dest;
 657                 tmp += count;
 658                 s = src;
 659                 s += count;
 660                 while (count--)
 661                         *--tmp = *--s;
 662         }
 663         return dest;
 664 }
 665 EXPORT_SYMBOL(memmove);
 666 #endif
 667
 668 #ifndef __HAVE_ARCH_MEMCMP
 669 /**
 670  * memcmp - Compare two areas of memory
 671  * @cs: One area of memory
 672  * @ct: Another area of memory
 673  * @count: The size of the area.
 674  */
 675 #undef memcmp
 676 __visible int memcmp(const void *cs, const void *ct, size_t count)
 677 {
 678         const unsigned char *su1, *su2;
 679         int res = 0;
 680
 681         for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 682                 if ((res = *su1 - *su2) != 0)
 683                         break;
 684         return res;
 685 }
 686 EXPORT_SYMBOL(memcmp);
 687 #endif
 688
 689 #ifndef __HAVE_ARCH_MEMSCAN
 690 /**
 691  * memscan - Find a character in an area of memory.
 692  * @addr: The memory area
 693  * @c: The byte to search for
 694  * @size: The size of the area.
 695  *
 696  * returns the address of the first occurrence of @c, or 1 byte past
 697  * the area if @c is not found
 698  */
 699 void *memscan(void *addr, int c, size_t size)
 700 {
 701         unsigned char *p = addr;
 702
 703         while (size) {
 704                 if (*p == c)
 705                         return (void *)p;
 706                 p++;
 707                 size--;
 708         }
 709         return (void *)p;
 710 }
 711 EXPORT_SYMBOL(memscan);
 712 #endif
 713
 714 #ifndef __HAVE_ARCH_STRSTR
 715 /**
 716  * strstr - Find the first substring in a %NUL terminated string
 717  * @s1: The string to be searched
 718  * @s2: The string to search for
 719  */
 720 char *strstr(const char *s1, const char *s2)
 721 {
 722         size_t l1, l2;
 723
 724         l2 = strlen(s2);
 725         if (!l2)
 726                 return (char *)s1;
 727         l1 = strlen(s1);
 728         while (l1 >= l2) {
 729                 l1--;
 730                 if (!memcmp(s1, s2, l2))
 731                         return (char *)s1;
 732                 s1++;
 733         }
 734         return NULL;
 735 }
 736 EXPORT_SYMBOL(strstr);
 737 #endif
 738
 739 #ifndef __HAVE_ARCH_STRNSTR
 740 /**
 741  * strnstr - Find the first substring in a length-limited string
 742  * @s1: The string to be searched
 743  * @s2: The string to search for
 744  * @len: the maximum number of characters to search
 745  */
 746 char *strnstr(const char *s1, const char *s2, size_t len)
 747 {
 748         size_t l2;
 749
 750         l2 = strlen(s2);
 751         if (!l2)
 752                 return (char *)s1;
 753         while (len >= l2) {
 754                 len--;
 755                 if (!memcmp(s1, s2, l2))
 756                         return (char *)s1;
 757                 s1++;
 758         }
 759         return NULL;
 760 }
 761 EXPORT_SYMBOL(strnstr);
 762 #endif
 763
 764 #ifndef __HAVE_ARCH_MEMCHR
 765 /**
 766  * memchr - Find a character in an area of memory.
 767  * @s: The memory area
 768  * @c: The byte to search for
 769  * @n: The size of the area.
 770  *
 771  * returns the address of the first occurrence of @c, or %NULL
 772  * if @c is not found
 773  */
 774 void *memchr(const void *s, int c, size_t n)
 775 {
 776         const unsigned char *p = s;
 777         while (n-- != 0) {
 778                 if ((unsigned char)c == *p++) {
 779                         return (void *)(p - 1);
 780                 }
 781         }
 782         return NULL;
 783 }
 784 EXPORT_SYMBOL(memchr);
 785 #endif
 786
 787 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
 788 {
 789         while (bytes) {
 790                 if (*start != value)
 791                         return (void *)start;
 792                 start++;
 793                 bytes--;
 794         }
 795         return NULL;
 796 }
 797
 798 /**
 799  * memchr_inv - Find an unmatching character in an area of memory.
 800  * @start: The memory area
 801  * @c: Find a character other than c
 802  * @bytes: The size of the area.
 803  *
 804  * returns the address of the first character other than @c, or %NULL
 805  * if the whole buffer contains just @c.
 806  */
 807 void *memchr_inv(const void *start, int c, size_t bytes)
 808 {
 809         u8 value = c;
 810         u64 value64;
 811         unsigned int words, prefix;
 812
 813         if (bytes <= 16)
 814                 return check_bytes8(start, value, bytes);
 815
 816         value64 = value;
 817 #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
 818         value64 *= 0x0101010101010101;
 819 #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
 820         value64 *= 0x01010101;
 821         value64 |= value64 << 32;
 822 #else
 823         value64 |= value64 << 8;
 824         value64 |= value64 << 16;
 825         value64 |= value64 << 32;
 826 #endif
 827
 828         prefix = (unsigned long)start % 8;
 829         if (prefix) {
 830                 u8 *r;
 831
 832                 prefix = 8 - prefix;
 833                 r = check_bytes8(start, value, prefix);
 834                 if (r)
 835                         return r;
 836                 start += prefix;
 837                 bytes -= prefix;
 838         }
 839
 840         words = bytes / 8;
 841
 842         while (words) {
 843                 if (*(u64 *)start != value64)
 844                         return check_bytes8(start, value, 8);
 845                 start += 8;
 846                 words--;
 847         }
 848
 849         return check_bytes8(start, value, bytes % 8);
 850 }
 851 EXPORT_SYMBOL(memchr_inv);