Merge tag 'for-linus-6.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rw...
[platform/kernel/linux-starfive.git] / 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  * This file should be used only for "library" routines that may have
10  * alternative implementations on specific architectures (generally
11  * found in <asm-xx/string.h>), or get overloaded by FORTIFY_SOURCE.
12  * (Specifically, this file is built with __NO_FORTIFY.)
13  *
14  * Other helper functions should live in string_helpers.c.
15  */
16
17 #define __NO_FORTIFY
18 #include <linux/types.h>
19 #include <linux/string.h>
20 #include <linux/ctype.h>
21 #include <linux/kernel.h>
22 #include <linux/export.h>
23 #include <linux/bug.h>
24 #include <linux/errno.h>
25 #include <linux/slab.h>
26
27 #include <asm/unaligned.h>
28 #include <asm/byteorder.h>
29 #include <asm/word-at-a-time.h>
30 #include <asm/page.h>
31
32 #ifndef __HAVE_ARCH_STRNCASECMP
33 /**
34  * strncasecmp - Case insensitive, length-limited string comparison
35  * @s1: One string
36  * @s2: The other string
37  * @len: the maximum number of characters to compare
38  */
39 int strncasecmp(const char *s1, const char *s2, size_t len)
40 {
41         /* Yes, Virginia, it had better be unsigned */
42         unsigned char c1, c2;
43
44         if (!len)
45                 return 0;
46
47         do {
48                 c1 = *s1++;
49                 c2 = *s2++;
50                 if (!c1 || !c2)
51                         break;
52                 if (c1 == c2)
53                         continue;
54                 c1 = tolower(c1);
55                 c2 = tolower(c2);
56                 if (c1 != c2)
57                         break;
58         } while (--len);
59         return (int)c1 - (int)c2;
60 }
61 EXPORT_SYMBOL(strncasecmp);
62 #endif
63
64 #ifndef __HAVE_ARCH_STRCASECMP
65 int strcasecmp(const char *s1, const char *s2)
66 {
67         int c1, c2;
68
69         do {
70                 c1 = tolower(*s1++);
71                 c2 = tolower(*s2++);
72         } while (c1 == c2 && c1 != 0);
73         return c1 - c2;
74 }
75 EXPORT_SYMBOL(strcasecmp);
76 #endif
77
78 #ifndef __HAVE_ARCH_STRCPY
79 /**
80  * strcpy - Copy a %NUL terminated string
81  * @dest: Where to copy the string to
82  * @src: Where to copy the string from
83  */
84 char *strcpy(char *dest, const char *src)
85 {
86         char *tmp = dest;
87
88         while ((*dest++ = *src++) != '\0')
89                 /* nothing */;
90         return tmp;
91 }
92 EXPORT_SYMBOL(strcpy);
93 #endif
94
95 #ifndef __HAVE_ARCH_STRNCPY
96 /**
97  * strncpy - Copy a length-limited, C-string
98  * @dest: Where to copy the string to
99  * @src: Where to copy the string from
100  * @count: The maximum number of bytes to copy
101  *
102  * The result is not %NUL-terminated if the source exceeds
103  * @count bytes.
104  *
105  * In the case where the length of @src is less than  that  of
106  * count, the remainder of @dest will be padded with %NUL.
107  *
108  */
109 char *strncpy(char *dest, const char *src, size_t count)
110 {
111         char *tmp = dest;
112
113         while (count) {
114                 if ((*tmp = *src) != 0)
115                         src++;
116                 tmp++;
117                 count--;
118         }
119         return dest;
120 }
121 EXPORT_SYMBOL(strncpy);
122 #endif
123
124 #ifndef __HAVE_ARCH_STRLCPY
125 /**
126  * strlcpy - Copy a C-string into a sized buffer
127  * @dest: Where to copy the string to
128  * @src: Where to copy the string from
129  * @size: size of destination buffer
130  *
131  * Compatible with ``*BSD``: the result is always a valid
132  * NUL-terminated string that fits in the buffer (unless,
133  * of course, the buffer size is zero). It does not pad
134  * out the result like strncpy() does.
135  */
136 size_t strlcpy(char *dest, const char *src, size_t size)
137 {
138         size_t ret = strlen(src);
139
140         if (size) {
141                 size_t len = (ret >= size) ? size - 1 : ret;
142                 memcpy(dest, src, len);
143                 dest[len] = '\0';
144         }
145         return ret;
146 }
147 EXPORT_SYMBOL(strlcpy);
148 #endif
149
150 #ifndef __HAVE_ARCH_STRSCPY
151 /**
152  * strscpy - Copy a C-string into a sized buffer
153  * @dest: Where to copy the string to
154  * @src: Where to copy the string from
155  * @count: Size of destination buffer
156  *
157  * Copy the string, or as much of it as fits, into the dest buffer.  The
158  * behavior is undefined if the string buffers overlap.  The destination
159  * buffer is always NUL terminated, unless it's zero-sized.
160  *
161  * Preferred to strlcpy() since the API doesn't require reading memory
162  * from the src string beyond the specified "count" bytes, and since
163  * the return value is easier to error-check than strlcpy()'s.
164  * In addition, the implementation is robust to the string changing out
165  * from underneath it, unlike the current strlcpy() implementation.
166  *
167  * Preferred to strncpy() since it always returns a valid string, and
168  * doesn't unnecessarily force the tail of the destination buffer to be
169  * zeroed.  If zeroing is desired please use strscpy_pad().
170  *
171  * Returns:
172  * * The number of characters copied (not including the trailing %NUL)
173  * * -E2BIG if count is 0 or @src was truncated.
174  */
175 ssize_t strscpy(char *dest, const char *src, size_t count)
176 {
177         const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
178         size_t max = count;
179         long res = 0;
180
181         if (count == 0 || WARN_ON_ONCE(count > INT_MAX))
182                 return -E2BIG;
183
184 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
185         /*
186          * If src is unaligned, don't cross a page boundary,
187          * since we don't know if the next page is mapped.
188          */
189         if ((long)src & (sizeof(long) - 1)) {
190                 size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
191                 if (limit < max)
192                         max = limit;
193         }
194 #else
195         /* If src or dest is unaligned, don't do word-at-a-time. */
196         if (((long) dest | (long) src) & (sizeof(long) - 1))
197                 max = 0;
198 #endif
199
200         /*
201          * read_word_at_a_time() below may read uninitialized bytes after the
202          * trailing zero and use them in comparisons. Disable this optimization
203          * under KMSAN to prevent false positive reports.
204          */
205         if (IS_ENABLED(CONFIG_KMSAN))
206                 max = 0;
207
208         while (max >= sizeof(unsigned long)) {
209                 unsigned long c, data;
210
211                 c = read_word_at_a_time(src+res);
212                 if (has_zero(c, &data, &constants)) {
213                         data = prep_zero_mask(c, data, &constants);
214                         data = create_zero_mask(data);
215                         *(unsigned long *)(dest+res) = c & zero_bytemask(data);
216                         return res + find_zero(data);
217                 }
218                 *(unsigned long *)(dest+res) = c;
219                 res += sizeof(unsigned long);
220                 count -= sizeof(unsigned long);
221                 max -= sizeof(unsigned long);
222         }
223
224         while (count) {
225                 char c;
226
227                 c = src[res];
228                 dest[res] = c;
229                 if (!c)
230                         return res;
231                 res++;
232                 count--;
233         }
234
235         /* Hit buffer length without finding a NUL; force NUL-termination. */
236         if (res)
237                 dest[res-1] = '\0';
238
239         return -E2BIG;
240 }
241 EXPORT_SYMBOL(strscpy);
242 #endif
243
244 /**
245  * stpcpy - copy a string from src to dest returning a pointer to the new end
246  *          of dest, including src's %NUL-terminator. May overrun dest.
247  * @dest: pointer to end of string being copied into. Must be large enough
248  *        to receive copy.
249  * @src: pointer to the beginning of string being copied from. Must not overlap
250  *       dest.
251  *
252  * stpcpy differs from strcpy in a key way: the return value is a pointer
253  * to the new %NUL-terminating character in @dest. (For strcpy, the return
254  * value is a pointer to the start of @dest). This interface is considered
255  * unsafe as it doesn't perform bounds checking of the inputs. As such it's
256  * not recommended for usage. Instead, its definition is provided in case
257  * the compiler lowers other libcalls to stpcpy.
258  */
259 char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
260 char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
261 {
262         while ((*dest++ = *src++) != '\0')
263                 /* nothing */;
264         return --dest;
265 }
266 EXPORT_SYMBOL(stpcpy);
267
268 #ifndef __HAVE_ARCH_STRCAT
269 /**
270  * strcat - Append one %NUL-terminated string to another
271  * @dest: The string to be appended to
272  * @src: The string to append to it
273  */
274 char *strcat(char *dest, const char *src)
275 {
276         char *tmp = dest;
277
278         while (*dest)
279                 dest++;
280         while ((*dest++ = *src++) != '\0')
281                 ;
282         return tmp;
283 }
284 EXPORT_SYMBOL(strcat);
285 #endif
286
287 #ifndef __HAVE_ARCH_STRNCAT
288 /**
289  * strncat - 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 maximum numbers of bytes to copy
293  *
294  * Note that in contrast to strncpy(), strncat() ensures the result is
295  * terminated.
296  */
297 char *strncat(char *dest, const char *src, size_t count)
298 {
299         char *tmp = dest;
300
301         if (count) {
302                 while (*dest)
303                         dest++;
304                 while ((*dest++ = *src++) != 0) {
305                         if (--count == 0) {
306                                 *dest = '\0';
307                                 break;
308                         }
309                 }
310         }
311         return tmp;
312 }
313 EXPORT_SYMBOL(strncat);
314 #endif
315
316 #ifndef __HAVE_ARCH_STRLCAT
317 /**
318  * strlcat - Append a length-limited, C-string to another
319  * @dest: The string to be appended to
320  * @src: The string to append to it
321  * @count: The size of the destination buffer.
322  */
323 size_t strlcat(char *dest, const char *src, size_t count)
324 {
325         size_t dsize = strlen(dest);
326         size_t len = strlen(src);
327         size_t res = dsize + len;
328
329         /* This would be a bug */
330         BUG_ON(dsize >= count);
331
332         dest += dsize;
333         count -= dsize;
334         if (len >= count)
335                 len = count-1;
336         memcpy(dest, src, len);
337         dest[len] = 0;
338         return res;
339 }
340 EXPORT_SYMBOL(strlcat);
341 #endif
342
343 #ifndef __HAVE_ARCH_STRCMP
344 /**
345  * strcmp - Compare two strings
346  * @cs: One string
347  * @ct: Another string
348  */
349 int strcmp(const char *cs, const char *ct)
350 {
351         unsigned char c1, c2;
352
353         while (1) {
354                 c1 = *cs++;
355                 c2 = *ct++;
356                 if (c1 != c2)
357                         return c1 < c2 ? -1 : 1;
358                 if (!c1)
359                         break;
360         }
361         return 0;
362 }
363 EXPORT_SYMBOL(strcmp);
364 #endif
365
366 #ifndef __HAVE_ARCH_STRNCMP
367 /**
368  * strncmp - Compare two length-limited strings
369  * @cs: One string
370  * @ct: Another string
371  * @count: The maximum number of bytes to compare
372  */
373 int strncmp(const char *cs, const char *ct, size_t count)
374 {
375         unsigned char c1, c2;
376
377         while (count) {
378                 c1 = *cs++;
379                 c2 = *ct++;
380                 if (c1 != c2)
381                         return c1 < c2 ? -1 : 1;
382                 if (!c1)
383                         break;
384                 count--;
385         }
386         return 0;
387 }
388 EXPORT_SYMBOL(strncmp);
389 #endif
390
391 #ifndef __HAVE_ARCH_STRCHR
392 /**
393  * strchr - Find the first occurrence of a character in a string
394  * @s: The string to be searched
395  * @c: The character to search for
396  *
397  * Note that the %NUL-terminator is considered part of the string, and can
398  * be searched for.
399  */
400 char *strchr(const char *s, int c)
401 {
402         for (; *s != (char)c; ++s)
403                 if (*s == '\0')
404                         return NULL;
405         return (char *)s;
406 }
407 EXPORT_SYMBOL(strchr);
408 #endif
409
410 #ifndef __HAVE_ARCH_STRCHRNUL
411 /**
412  * strchrnul - Find and return a character in a string, or end of string
413  * @s: The string to be searched
414  * @c: The character to search for
415  *
416  * Returns pointer to first occurrence of 'c' in s. If c is not found, then
417  * return a pointer to the null byte at the end of s.
418  */
419 char *strchrnul(const char *s, int c)
420 {
421         while (*s && *s != (char)c)
422                 s++;
423         return (char *)s;
424 }
425 EXPORT_SYMBOL(strchrnul);
426 #endif
427
428 /**
429  * strnchrnul - Find and return a character in a length limited string,
430  * or end of string
431  * @s: The string to be searched
432  * @count: The number of characters to be searched
433  * @c: The character to search for
434  *
435  * Returns pointer to the first occurrence of 'c' in s. If c is not found,
436  * then return a pointer to the last character of the string.
437  */
438 char *strnchrnul(const char *s, size_t count, int c)
439 {
440         while (count-- && *s && *s != (char)c)
441                 s++;
442         return (char *)s;
443 }
444
445 #ifndef __HAVE_ARCH_STRRCHR
446 /**
447  * strrchr - Find the last occurrence of a character in a string
448  * @s: The string to be searched
449  * @c: The character to search for
450  */
451 char *strrchr(const char *s, int c)
452 {
453         const char *last = NULL;
454         do {
455                 if (*s == (char)c)
456                         last = s;
457         } while (*s++);
458         return (char *)last;
459 }
460 EXPORT_SYMBOL(strrchr);
461 #endif
462
463 #ifndef __HAVE_ARCH_STRNCHR
464 /**
465  * strnchr - Find a character in a length limited string
466  * @s: The string to be searched
467  * @count: The number of characters to be searched
468  * @c: The character to search for
469  *
470  * Note that the %NUL-terminator is considered part of the string, and can
471  * be searched for.
472  */
473 char *strnchr(const char *s, size_t count, int c)
474 {
475         while (count--) {
476                 if (*s == (char)c)
477                         return (char *)s;
478                 if (*s++ == '\0')
479                         break;
480         }
481         return NULL;
482 }
483 EXPORT_SYMBOL(strnchr);
484 #endif
485
486 #ifndef __HAVE_ARCH_STRLEN
487 /**
488  * strlen - Find the length of a string
489  * @s: The string to be sized
490  */
491 size_t strlen(const char *s)
492 {
493         const char *sc;
494
495         for (sc = s; *sc != '\0'; ++sc)
496                 /* nothing */;
497         return sc - s;
498 }
499 EXPORT_SYMBOL(strlen);
500 #endif
501
502 #ifndef __HAVE_ARCH_STRNLEN
503 /**
504  * strnlen - Find the length of a length-limited string
505  * @s: The string to be sized
506  * @count: The maximum number of bytes to search
507  */
508 size_t strnlen(const char *s, size_t count)
509 {
510         const char *sc;
511
512         for (sc = s; count-- && *sc != '\0'; ++sc)
513                 /* nothing */;
514         return sc - s;
515 }
516 EXPORT_SYMBOL(strnlen);
517 #endif
518
519 #ifndef __HAVE_ARCH_STRSPN
520 /**
521  * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
522  * @s: The string to be searched
523  * @accept: The string to search for
524  */
525 size_t strspn(const char *s, const char *accept)
526 {
527         const char *p;
528
529         for (p = s; *p != '\0'; ++p) {
530                 if (!strchr(accept, *p))
531                         break;
532         }
533         return p - s;
534 }
535 EXPORT_SYMBOL(strspn);
536 #endif
537
538 #ifndef __HAVE_ARCH_STRCSPN
539 /**
540  * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
541  * @s: The string to be searched
542  * @reject: The string to avoid
543  */
544 size_t strcspn(const char *s, const char *reject)
545 {
546         const char *p;
547
548         for (p = s; *p != '\0'; ++p) {
549                 if (strchr(reject, *p))
550                         break;
551         }
552         return p - s;
553 }
554 EXPORT_SYMBOL(strcspn);
555 #endif
556
557 #ifndef __HAVE_ARCH_STRPBRK
558 /**
559  * strpbrk - Find the first occurrence of a set of characters
560  * @cs: The string to be searched
561  * @ct: The characters to search for
562  */
563 char *strpbrk(const char *cs, const char *ct)
564 {
565         const char *sc1, *sc2;
566
567         for (sc1 = cs; *sc1 != '\0'; ++sc1) {
568                 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
569                         if (*sc1 == *sc2)
570                                 return (char *)sc1;
571                 }
572         }
573         return NULL;
574 }
575 EXPORT_SYMBOL(strpbrk);
576 #endif
577
578 #ifndef __HAVE_ARCH_STRSEP
579 /**
580  * strsep - Split a string into tokens
581  * @s: The string to be searched
582  * @ct: The characters to search for
583  *
584  * strsep() updates @s to point after the token, ready for the next call.
585  *
586  * It returns empty tokens, too, behaving exactly like the libc function
587  * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
588  * Same semantics, slimmer shape. ;)
589  */
590 char *strsep(char **s, const char *ct)
591 {
592         char *sbegin = *s;
593         char *end;
594
595         if (sbegin == NULL)
596                 return NULL;
597
598         end = strpbrk(sbegin, ct);
599         if (end)
600                 *end++ = '\0';
601         *s = end;
602         return sbegin;
603 }
604 EXPORT_SYMBOL(strsep);
605 #endif
606
607 #ifndef __HAVE_ARCH_MEMSET
608 /**
609  * memset - Fill a region of memory with the given value
610  * @s: Pointer to the start of the area.
611  * @c: The byte to fill the area with
612  * @count: The size of the area.
613  *
614  * Do not use memset() to access IO space, use memset_io() instead.
615  */
616 void *memset(void *s, int c, size_t count)
617 {
618         char *xs = s;
619
620         while (count--)
621                 *xs++ = c;
622         return s;
623 }
624 EXPORT_SYMBOL(memset);
625 #endif
626
627 #ifndef __HAVE_ARCH_MEMSET16
628 /**
629  * memset16() - Fill a memory area with a uint16_t
630  * @s: Pointer to the start of the area.
631  * @v: The value to fill the area with
632  * @count: The number of values to store
633  *
634  * Differs from memset() in that it fills with a uint16_t instead
635  * of a byte.  Remember that @count is the number of uint16_ts to
636  * store, not the number of bytes.
637  */
638 void *memset16(uint16_t *s, uint16_t v, size_t count)
639 {
640         uint16_t *xs = s;
641
642         while (count--)
643                 *xs++ = v;
644         return s;
645 }
646 EXPORT_SYMBOL(memset16);
647 #endif
648
649 #ifndef __HAVE_ARCH_MEMSET32
650 /**
651  * memset32() - Fill a memory area with a uint32_t
652  * @s: Pointer to the start of the area.
653  * @v: The value to fill the area with
654  * @count: The number of values to store
655  *
656  * Differs from memset() in that it fills with a uint32_t instead
657  * of a byte.  Remember that @count is the number of uint32_ts to
658  * store, not the number of bytes.
659  */
660 void *memset32(uint32_t *s, uint32_t v, size_t count)
661 {
662         uint32_t *xs = s;
663
664         while (count--)
665                 *xs++ = v;
666         return s;
667 }
668 EXPORT_SYMBOL(memset32);
669 #endif
670
671 #ifndef __HAVE_ARCH_MEMSET64
672 /**
673  * memset64() - Fill a memory area with a uint64_t
674  * @s: Pointer to the start of the area.
675  * @v: The value to fill the area with
676  * @count: The number of values to store
677  *
678  * Differs from memset() in that it fills with a uint64_t instead
679  * of a byte.  Remember that @count is the number of uint64_ts to
680  * store, not the number of bytes.
681  */
682 void *memset64(uint64_t *s, uint64_t v, size_t count)
683 {
684         uint64_t *xs = s;
685
686         while (count--)
687                 *xs++ = v;
688         return s;
689 }
690 EXPORT_SYMBOL(memset64);
691 #endif
692
693 #ifndef __HAVE_ARCH_MEMCPY
694 /**
695  * memcpy - Copy one area of memory to another
696  * @dest: Where to copy to
697  * @src: Where to copy from
698  * @count: The size of the area.
699  *
700  * You should not use this function to access IO space, use memcpy_toio()
701  * or memcpy_fromio() instead.
702  */
703 void *memcpy(void *dest, const void *src, size_t count)
704 {
705         char *tmp = dest;
706         const char *s = src;
707
708         while (count--)
709                 *tmp++ = *s++;
710         return dest;
711 }
712 EXPORT_SYMBOL(memcpy);
713 #endif
714
715 #ifndef __HAVE_ARCH_MEMMOVE
716 /**
717  * memmove - Copy one area of memory to another
718  * @dest: Where to copy to
719  * @src: Where to copy from
720  * @count: The size of the area.
721  *
722  * Unlike memcpy(), memmove() copes with overlapping areas.
723  */
724 void *memmove(void *dest, const void *src, size_t count)
725 {
726         char *tmp;
727         const char *s;
728
729         if (dest <= src) {
730                 tmp = dest;
731                 s = src;
732                 while (count--)
733                         *tmp++ = *s++;
734         } else {
735                 tmp = dest;
736                 tmp += count;
737                 s = src;
738                 s += count;
739                 while (count--)
740                         *--tmp = *--s;
741         }
742         return dest;
743 }
744 EXPORT_SYMBOL(memmove);
745 #endif
746
747 #ifndef __HAVE_ARCH_MEMCMP
748 /**
749  * memcmp - Compare two areas of memory
750  * @cs: One area of memory
751  * @ct: Another area of memory
752  * @count: The size of the area.
753  */
754 #undef memcmp
755 __visible int memcmp(const void *cs, const void *ct, size_t count)
756 {
757         const unsigned char *su1, *su2;
758         int res = 0;
759
760 #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
761         if (count >= sizeof(unsigned long)) {
762                 const unsigned long *u1 = cs;
763                 const unsigned long *u2 = ct;
764                 do {
765                         if (get_unaligned(u1) != get_unaligned(u2))
766                                 break;
767                         u1++;
768                         u2++;
769                         count -= sizeof(unsigned long);
770                 } while (count >= sizeof(unsigned long));
771                 cs = u1;
772                 ct = u2;
773         }
774 #endif
775         for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
776                 if ((res = *su1 - *su2) != 0)
777                         break;
778         return res;
779 }
780 EXPORT_SYMBOL(memcmp);
781 #endif
782
783 #ifndef __HAVE_ARCH_BCMP
784 /**
785  * bcmp - returns 0 if and only if the buffers have identical contents.
786  * @a: pointer to first buffer.
787  * @b: pointer to second buffer.
788  * @len: size of buffers.
789  *
790  * The sign or magnitude of a non-zero return value has no particular
791  * meaning, and architectures may implement their own more efficient bcmp(). So
792  * while this particular implementation is a simple (tail) call to memcmp, do
793  * not rely on anything but whether the return value is zero or non-zero.
794  */
795 int bcmp(const void *a, const void *b, size_t len)
796 {
797         return memcmp(a, b, len);
798 }
799 EXPORT_SYMBOL(bcmp);
800 #endif
801
802 #ifndef __HAVE_ARCH_MEMSCAN
803 /**
804  * memscan - Find a character in an area of memory.
805  * @addr: The memory area
806  * @c: The byte to search for
807  * @size: The size of the area.
808  *
809  * returns the address of the first occurrence of @c, or 1 byte past
810  * the area if @c is not found
811  */
812 void *memscan(void *addr, int c, size_t size)
813 {
814         unsigned char *p = addr;
815
816         while (size) {
817                 if (*p == (unsigned char)c)
818                         return (void *)p;
819                 p++;
820                 size--;
821         }
822         return (void *)p;
823 }
824 EXPORT_SYMBOL(memscan);
825 #endif
826
827 #ifndef __HAVE_ARCH_STRSTR
828 /**
829  * strstr - Find the first substring in a %NUL terminated string
830  * @s1: The string to be searched
831  * @s2: The string to search for
832  */
833 char *strstr(const char *s1, const char *s2)
834 {
835         size_t l1, l2;
836
837         l2 = strlen(s2);
838         if (!l2)
839                 return (char *)s1;
840         l1 = strlen(s1);
841         while (l1 >= l2) {
842                 l1--;
843                 if (!memcmp(s1, s2, l2))
844                         return (char *)s1;
845                 s1++;
846         }
847         return NULL;
848 }
849 EXPORT_SYMBOL(strstr);
850 #endif
851
852 #ifndef __HAVE_ARCH_STRNSTR
853 /**
854  * strnstr - Find the first substring in a length-limited string
855  * @s1: The string to be searched
856  * @s2: The string to search for
857  * @len: the maximum number of characters to search
858  */
859 char *strnstr(const char *s1, const char *s2, size_t len)
860 {
861         size_t l2;
862
863         l2 = strlen(s2);
864         if (!l2)
865                 return (char *)s1;
866         while (len >= l2) {
867                 len--;
868                 if (!memcmp(s1, s2, l2))
869                         return (char *)s1;
870                 s1++;
871         }
872         return NULL;
873 }
874 EXPORT_SYMBOL(strnstr);
875 #endif
876
877 #ifndef __HAVE_ARCH_MEMCHR
878 /**
879  * memchr - Find a character in an area of memory.
880  * @s: The memory area
881  * @c: The byte to search for
882  * @n: The size of the area.
883  *
884  * returns the address of the first occurrence of @c, or %NULL
885  * if @c is not found
886  */
887 void *memchr(const void *s, int c, size_t n)
888 {
889         const unsigned char *p = s;
890         while (n-- != 0) {
891                 if ((unsigned char)c == *p++) {
892                         return (void *)(p - 1);
893                 }
894         }
895         return NULL;
896 }
897 EXPORT_SYMBOL(memchr);
898 #endif
899
900 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
901 {
902         while (bytes) {
903                 if (*start != value)
904                         return (void *)start;
905                 start++;
906                 bytes--;
907         }
908         return NULL;
909 }
910
911 /**
912  * memchr_inv - Find an unmatching character in an area of memory.
913  * @start: The memory area
914  * @c: Find a character other than c
915  * @bytes: The size of the area.
916  *
917  * returns the address of the first character other than @c, or %NULL
918  * if the whole buffer contains just @c.
919  */
920 void *memchr_inv(const void *start, int c, size_t bytes)
921 {
922         u8 value = c;
923         u64 value64;
924         unsigned int words, prefix;
925
926         if (bytes <= 16)
927                 return check_bytes8(start, value, bytes);
928
929         value64 = value;
930 #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
931         value64 *= 0x0101010101010101ULL;
932 #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
933         value64 *= 0x01010101;
934         value64 |= value64 << 32;
935 #else
936         value64 |= value64 << 8;
937         value64 |= value64 << 16;
938         value64 |= value64 << 32;
939 #endif
940
941         prefix = (unsigned long)start % 8;
942         if (prefix) {
943                 u8 *r;
944
945                 prefix = 8 - prefix;
946                 r = check_bytes8(start, value, prefix);
947                 if (r)
948                         return r;
949                 start += prefix;
950                 bytes -= prefix;
951         }
952
953         words = bytes / 8;
954
955         while (words) {
956                 if (*(u64 *)start != value64)
957                         return check_bytes8(start, value, 8);
958                 start += 8;
959                 words--;
960         }
961
962         return check_bytes8(start, value, bytes % 8);
963 }
964 EXPORT_SYMBOL(memchr_inv);