ipv6 sit: work around bogus gcc-8 -Wrestrict warning
[linux-2.6-microblaze.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  * 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 #ifndef __HAVE_ARCH_STRCAT
240 /**
241  * strcat - Append one %NUL-terminated string to another
242  * @dest: The string to be appended to
243  * @src: The string to append to it
244  */
245 #undef strcat
246 char *strcat(char *dest, const char *src)
247 {
248         char *tmp = dest;
249
250         while (*dest)
251                 dest++;
252         while ((*dest++ = *src++) != '\0')
253                 ;
254         return tmp;
255 }
256 EXPORT_SYMBOL(strcat);
257 #endif
258
259 #ifndef __HAVE_ARCH_STRNCAT
260 /**
261  * strncat - Append a length-limited, C-string to another
262  * @dest: The string to be appended to
263  * @src: The string to append to it
264  * @count: The maximum numbers of bytes to copy
265  *
266  * Note that in contrast to strncpy(), strncat() ensures the result is
267  * terminated.
268  */
269 char *strncat(char *dest, const char *src, size_t count)
270 {
271         char *tmp = dest;
272
273         if (count) {
274                 while (*dest)
275                         dest++;
276                 while ((*dest++ = *src++) != 0) {
277                         if (--count == 0) {
278                                 *dest = '\0';
279                                 break;
280                         }
281                 }
282         }
283         return tmp;
284 }
285 EXPORT_SYMBOL(strncat);
286 #endif
287
288 #ifndef __HAVE_ARCH_STRLCAT
289 /**
290  * strlcat - Append a length-limited, C-string to another
291  * @dest: The string to be appended to
292  * @src: The string to append to it
293  * @count: The size of the destination buffer.
294  */
295 size_t strlcat(char *dest, const char *src, size_t count)
296 {
297         size_t dsize = strlen(dest);
298         size_t len = strlen(src);
299         size_t res = dsize + len;
300
301         /* This would be a bug */
302         BUG_ON(dsize >= count);
303
304         dest += dsize;
305         count -= dsize;
306         if (len >= count)
307                 len = count-1;
308         memcpy(dest, src, len);
309         dest[len] = 0;
310         return res;
311 }
312 EXPORT_SYMBOL(strlcat);
313 #endif
314
315 #ifndef __HAVE_ARCH_STRCMP
316 /**
317  * strcmp - Compare two strings
318  * @cs: One string
319  * @ct: Another string
320  */
321 #undef strcmp
322 int strcmp(const char *cs, const char *ct)
323 {
324         unsigned char c1, c2;
325
326         while (1) {
327                 c1 = *cs++;
328                 c2 = *ct++;
329                 if (c1 != c2)
330                         return c1 < c2 ? -1 : 1;
331                 if (!c1)
332                         break;
333         }
334         return 0;
335 }
336 EXPORT_SYMBOL(strcmp);
337 #endif
338
339 #ifndef __HAVE_ARCH_STRNCMP
340 /**
341  * strncmp - Compare two length-limited strings
342  * @cs: One string
343  * @ct: Another string
344  * @count: The maximum number of bytes to compare
345  */
346 int strncmp(const char *cs, const char *ct, size_t count)
347 {
348         unsigned char c1, c2;
349
350         while (count) {
351                 c1 = *cs++;
352                 c2 = *ct++;
353                 if (c1 != c2)
354                         return c1 < c2 ? -1 : 1;
355                 if (!c1)
356                         break;
357                 count--;
358         }
359         return 0;
360 }
361 EXPORT_SYMBOL(strncmp);
362 #endif
363
364 #ifndef __HAVE_ARCH_STRCHR
365 /**
366  * strchr - Find the first occurrence of a character in a string
367  * @s: The string to be searched
368  * @c: The character to search for
369  */
370 char *strchr(const char *s, int c)
371 {
372         for (; *s != (char)c; ++s)
373                 if (*s == '\0')
374                         return NULL;
375         return (char *)s;
376 }
377 EXPORT_SYMBOL(strchr);
378 #endif
379
380 #ifndef __HAVE_ARCH_STRCHRNUL
381 /**
382  * strchrnul - Find and return a character in a string, or end of string
383  * @s: The string to be searched
384  * @c: The character to search for
385  *
386  * Returns pointer to first occurrence of 'c' in s. If c is not found, then
387  * return a pointer to the null byte at the end of s.
388  */
389 char *strchrnul(const char *s, int c)
390 {
391         while (*s && *s != (char)c)
392                 s++;
393         return (char *)s;
394 }
395 EXPORT_SYMBOL(strchrnul);
396 #endif
397
398 #ifndef __HAVE_ARCH_STRRCHR
399 /**
400  * strrchr - Find the last occurrence of a character in a string
401  * @s: The string to be searched
402  * @c: The character to search for
403  */
404 char *strrchr(const char *s, int c)
405 {
406         const char *last = NULL;
407         do {
408                 if (*s == (char)c)
409                         last = s;
410         } while (*s++);
411         return (char *)last;
412 }
413 EXPORT_SYMBOL(strrchr);
414 #endif
415
416 #ifndef __HAVE_ARCH_STRNCHR
417 /**
418  * strnchr - Find a character in a length limited string
419  * @s: The string to be searched
420  * @count: The number of characters to be searched
421  * @c: The character to search for
422  */
423 char *strnchr(const char *s, size_t count, int c)
424 {
425         for (; count-- && *s != '\0'; ++s)
426                 if (*s == (char)c)
427                         return (char *)s;
428         return NULL;
429 }
430 EXPORT_SYMBOL(strnchr);
431 #endif
432
433 /**
434  * skip_spaces - Removes leading whitespace from @str.
435  * @str: The string to be stripped.
436  *
437  * Returns a pointer to the first non-whitespace character in @str.
438  */
439 char *skip_spaces(const char *str)
440 {
441         while (isspace(*str))
442                 ++str;
443         return (char *)str;
444 }
445 EXPORT_SYMBOL(skip_spaces);
446
447 /**
448  * strim - Removes leading and trailing whitespace from @s.
449  * @s: The string to be stripped.
450  *
451  * Note that the first trailing whitespace is replaced with a %NUL-terminator
452  * in the given string @s. Returns a pointer to the first non-whitespace
453  * character in @s.
454  */
455 char *strim(char *s)
456 {
457         size_t size;
458         char *end;
459
460         size = strlen(s);
461         if (!size)
462                 return s;
463
464         end = s + size - 1;
465         while (end >= s && isspace(*end))
466                 end--;
467         *(end + 1) = '\0';
468
469         return skip_spaces(s);
470 }
471 EXPORT_SYMBOL(strim);
472
473 #ifndef __HAVE_ARCH_STRLEN
474 /**
475  * strlen - Find the length of a string
476  * @s: The string to be sized
477  */
478 size_t strlen(const char *s)
479 {
480         const char *sc;
481
482         for (sc = s; *sc != '\0'; ++sc)
483                 /* nothing */;
484         return sc - s;
485 }
486 EXPORT_SYMBOL(strlen);
487 #endif
488
489 #ifndef __HAVE_ARCH_STRNLEN
490 /**
491  * strnlen - Find the length of a length-limited string
492  * @s: The string to be sized
493  * @count: The maximum number of bytes to search
494  */
495 size_t strnlen(const char *s, size_t count)
496 {
497         const char *sc;
498
499         for (sc = s; count-- && *sc != '\0'; ++sc)
500                 /* nothing */;
501         return sc - s;
502 }
503 EXPORT_SYMBOL(strnlen);
504 #endif
505
506 #ifndef __HAVE_ARCH_STRSPN
507 /**
508  * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
509  * @s: The string to be searched
510  * @accept: The string to search for
511  */
512 size_t strspn(const char *s, const char *accept)
513 {
514         const char *p;
515         const char *a;
516         size_t count = 0;
517
518         for (p = s; *p != '\0'; ++p) {
519                 for (a = accept; *a != '\0'; ++a) {
520                         if (*p == *a)
521                                 break;
522                 }
523                 if (*a == '\0')
524                         return count;
525                 ++count;
526         }
527         return count;
528 }
529
530 EXPORT_SYMBOL(strspn);
531 #endif
532
533 #ifndef __HAVE_ARCH_STRCSPN
534 /**
535  * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
536  * @s: The string to be searched
537  * @reject: The string to avoid
538  */
539 size_t strcspn(const char *s, const char *reject)
540 {
541         const char *p;
542         const char *r;
543         size_t count = 0;
544
545         for (p = s; *p != '\0'; ++p) {
546                 for (r = reject; *r != '\0'; ++r) {
547                         if (*p == *r)
548                                 return count;
549                 }
550                 ++count;
551         }
552         return count;
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 /**
608  * sysfs_streq - return true if strings are equal, modulo trailing newline
609  * @s1: one string
610  * @s2: another string
611  *
612  * This routine returns true iff two strings are equal, treating both
613  * NUL and newline-then-NUL as equivalent string terminations.  It's
614  * geared for use with sysfs input strings, which generally terminate
615  * with newlines but are compared against values without newlines.
616  */
617 bool sysfs_streq(const char *s1, const char *s2)
618 {
619         while (*s1 && *s1 == *s2) {
620                 s1++;
621                 s2++;
622         }
623
624         if (*s1 == *s2)
625                 return true;
626         if (!*s1 && *s2 == '\n' && !s2[1])
627                 return true;
628         if (*s1 == '\n' && !s1[1] && !*s2)
629                 return true;
630         return false;
631 }
632 EXPORT_SYMBOL(sysfs_streq);
633
634 /**
635  * match_string - matches given string in an array
636  * @array:      array of strings
637  * @n:          number of strings in the array or -1 for NULL terminated arrays
638  * @string:     string to match with
639  *
640  * Return:
641  * index of a @string in the @array if matches, or %-EINVAL otherwise.
642  */
643 int match_string(const char * const *array, size_t n, const char *string)
644 {
645         int index;
646         const char *item;
647
648         for (index = 0; index < n; index++) {
649                 item = array[index];
650                 if (!item)
651                         break;
652                 if (!strcmp(item, string))
653                         return index;
654         }
655
656         return -EINVAL;
657 }
658 EXPORT_SYMBOL(match_string);
659
660 /**
661  * __sysfs_match_string - matches given string in an array
662  * @array: array of strings
663  * @n: number of strings in the array or -1 for NULL terminated arrays
664  * @str: string to match with
665  *
666  * Returns index of @str in the @array or -EINVAL, just like match_string().
667  * Uses sysfs_streq instead of strcmp for matching.
668  */
669 int __sysfs_match_string(const char * const *array, size_t n, const char *str)
670 {
671         const char *item;
672         int index;
673
674         for (index = 0; index < n; index++) {
675                 item = array[index];
676                 if (!item)
677                         break;
678                 if (sysfs_streq(item, str))
679                         return index;
680         }
681
682         return -EINVAL;
683 }
684 EXPORT_SYMBOL(__sysfs_match_string);
685
686 #ifndef __HAVE_ARCH_MEMSET
687 /**
688  * memset - Fill a region of memory with the given value
689  * @s: Pointer to the start of the area.
690  * @c: The byte to fill the area with
691  * @count: The size of the area.
692  *
693  * Do not use memset() to access IO space, use memset_io() instead.
694  */
695 void *memset(void *s, int c, size_t count)
696 {
697         char *xs = s;
698
699         while (count--)
700                 *xs++ = c;
701         return s;
702 }
703 EXPORT_SYMBOL(memset);
704 #endif
705
706 /**
707  * memzero_explicit - Fill a region of memory (e.g. sensitive
708  *                    keying data) with 0s.
709  * @s: Pointer to the start of the area.
710  * @count: The size of the area.
711  *
712  * Note: usually using memset() is just fine (!), but in cases
713  * where clearing out _local_ data at the end of a scope is
714  * necessary, memzero_explicit() should be used instead in
715  * order to prevent the compiler from optimising away zeroing.
716  *
717  * memzero_explicit() doesn't need an arch-specific version as
718  * it just invokes the one of memset() implicitly.
719  */
720 void memzero_explicit(void *s, size_t count)
721 {
722         memset(s, 0, count);
723         barrier_data(s);
724 }
725 EXPORT_SYMBOL(memzero_explicit);
726
727 #ifndef __HAVE_ARCH_MEMSET16
728 /**
729  * memset16() - Fill a memory area with a uint16_t
730  * @s: Pointer to the start of the area.
731  * @v: The value to fill the area with
732  * @count: The number of values to store
733  *
734  * Differs from memset() in that it fills with a uint16_t instead
735  * of a byte.  Remember that @count is the number of uint16_ts to
736  * store, not the number of bytes.
737  */
738 void *memset16(uint16_t *s, uint16_t v, size_t count)
739 {
740         uint16_t *xs = s;
741
742         while (count--)
743                 *xs++ = v;
744         return s;
745 }
746 EXPORT_SYMBOL(memset16);
747 #endif
748
749 #ifndef __HAVE_ARCH_MEMSET32
750 /**
751  * memset32() - Fill a memory area with a uint32_t
752  * @s: Pointer to the start of the area.
753  * @v: The value to fill the area with
754  * @count: The number of values to store
755  *
756  * Differs from memset() in that it fills with a uint32_t instead
757  * of a byte.  Remember that @count is the number of uint32_ts to
758  * store, not the number of bytes.
759  */
760 void *memset32(uint32_t *s, uint32_t v, size_t count)
761 {
762         uint32_t *xs = s;
763
764         while (count--)
765                 *xs++ = v;
766         return s;
767 }
768 EXPORT_SYMBOL(memset32);
769 #endif
770
771 #ifndef __HAVE_ARCH_MEMSET64
772 /**
773  * memset64() - Fill a memory area with a uint64_t
774  * @s: Pointer to the start of the area.
775  * @v: The value to fill the area with
776  * @count: The number of values to store
777  *
778  * Differs from memset() in that it fills with a uint64_t instead
779  * of a byte.  Remember that @count is the number of uint64_ts to
780  * store, not the number of bytes.
781  */
782 void *memset64(uint64_t *s, uint64_t v, size_t count)
783 {
784         uint64_t *xs = s;
785
786         while (count--)
787                 *xs++ = v;
788         return s;
789 }
790 EXPORT_SYMBOL(memset64);
791 #endif
792
793 #ifndef __HAVE_ARCH_MEMCPY
794 /**
795  * memcpy - Copy one area of memory to another
796  * @dest: Where to copy to
797  * @src: Where to copy from
798  * @count: The size of the area.
799  *
800  * You should not use this function to access IO space, use memcpy_toio()
801  * or memcpy_fromio() instead.
802  */
803 void *memcpy(void *dest, const void *src, size_t count)
804 {
805         char *tmp = dest;
806         const char *s = src;
807
808         while (count--)
809                 *tmp++ = *s++;
810         return dest;
811 }
812 EXPORT_SYMBOL(memcpy);
813 #endif
814
815 #ifndef __HAVE_ARCH_MEMMOVE
816 /**
817  * memmove - Copy one area of memory to another
818  * @dest: Where to copy to
819  * @src: Where to copy from
820  * @count: The size of the area.
821  *
822  * Unlike memcpy(), memmove() copes with overlapping areas.
823  */
824 void *memmove(void *dest, const void *src, size_t count)
825 {
826         char *tmp;
827         const char *s;
828
829         if (dest <= src) {
830                 tmp = dest;
831                 s = src;
832                 while (count--)
833                         *tmp++ = *s++;
834         } else {
835                 tmp = dest;
836                 tmp += count;
837                 s = src;
838                 s += count;
839                 while (count--)
840                         *--tmp = *--s;
841         }
842         return dest;
843 }
844 EXPORT_SYMBOL(memmove);
845 #endif
846
847 #ifndef __HAVE_ARCH_MEMCMP
848 /**
849  * memcmp - Compare two areas of memory
850  * @cs: One area of memory
851  * @ct: Another area of memory
852  * @count: The size of the area.
853  */
854 #undef memcmp
855 __visible int memcmp(const void *cs, const void *ct, size_t count)
856 {
857         const unsigned char *su1, *su2;
858         int res = 0;
859
860         for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
861                 if ((res = *su1 - *su2) != 0)
862                         break;
863         return res;
864 }
865 EXPORT_SYMBOL(memcmp);
866 #endif
867
868 #ifndef __HAVE_ARCH_MEMSCAN
869 /**
870  * memscan - Find a character in an area of memory.
871  * @addr: The memory area
872  * @c: The byte to search for
873  * @size: The size of the area.
874  *
875  * returns the address of the first occurrence of @c, or 1 byte past
876  * the area if @c is not found
877  */
878 void *memscan(void *addr, int c, size_t size)
879 {
880         unsigned char *p = addr;
881
882         while (size) {
883                 if (*p == c)
884                         return (void *)p;
885                 p++;
886                 size--;
887         }
888         return (void *)p;
889 }
890 EXPORT_SYMBOL(memscan);
891 #endif
892
893 #ifndef __HAVE_ARCH_STRSTR
894 /**
895  * strstr - Find the first substring in a %NUL terminated string
896  * @s1: The string to be searched
897  * @s2: The string to search for
898  */
899 char *strstr(const char *s1, const char *s2)
900 {
901         size_t l1, l2;
902
903         l2 = strlen(s2);
904         if (!l2)
905                 return (char *)s1;
906         l1 = strlen(s1);
907         while (l1 >= l2) {
908                 l1--;
909                 if (!memcmp(s1, s2, l2))
910                         return (char *)s1;
911                 s1++;
912         }
913         return NULL;
914 }
915 EXPORT_SYMBOL(strstr);
916 #endif
917
918 #ifndef __HAVE_ARCH_STRNSTR
919 /**
920  * strnstr - Find the first substring in a length-limited string
921  * @s1: The string to be searched
922  * @s2: The string to search for
923  * @len: the maximum number of characters to search
924  */
925 char *strnstr(const char *s1, const char *s2, size_t len)
926 {
927         size_t l2;
928
929         l2 = strlen(s2);
930         if (!l2)
931                 return (char *)s1;
932         while (len >= l2) {
933                 len--;
934                 if (!memcmp(s1, s2, l2))
935                         return (char *)s1;
936                 s1++;
937         }
938         return NULL;
939 }
940 EXPORT_SYMBOL(strnstr);
941 #endif
942
943 #ifndef __HAVE_ARCH_MEMCHR
944 /**
945  * memchr - Find a character in an area of memory.
946  * @s: The memory area
947  * @c: The byte to search for
948  * @n: The size of the area.
949  *
950  * returns the address of the first occurrence of @c, or %NULL
951  * if @c is not found
952  */
953 void *memchr(const void *s, int c, size_t n)
954 {
955         const unsigned char *p = s;
956         while (n-- != 0) {
957                 if ((unsigned char)c == *p++) {
958                         return (void *)(p - 1);
959                 }
960         }
961         return NULL;
962 }
963 EXPORT_SYMBOL(memchr);
964 #endif
965
966 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
967 {
968         while (bytes) {
969                 if (*start != value)
970                         return (void *)start;
971                 start++;
972                 bytes--;
973         }
974         return NULL;
975 }
976
977 /**
978  * memchr_inv - Find an unmatching character in an area of memory.
979  * @start: The memory area
980  * @c: Find a character other than c
981  * @bytes: The size of the area.
982  *
983  * returns the address of the first character other than @c, or %NULL
984  * if the whole buffer contains just @c.
985  */
986 void *memchr_inv(const void *start, int c, size_t bytes)
987 {
988         u8 value = c;
989         u64 value64;
990         unsigned int words, prefix;
991
992         if (bytes <= 16)
993                 return check_bytes8(start, value, bytes);
994
995         value64 = value;
996 #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
997         value64 *= 0x0101010101010101ULL;
998 #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
999         value64 *= 0x01010101;
1000         value64 |= value64 << 32;
1001 #else
1002         value64 |= value64 << 8;
1003         value64 |= value64 << 16;
1004         value64 |= value64 << 32;
1005 #endif
1006
1007         prefix = (unsigned long)start % 8;
1008         if (prefix) {
1009                 u8 *r;
1010
1011                 prefix = 8 - prefix;
1012                 r = check_bytes8(start, value, prefix);
1013                 if (r)
1014                         return r;
1015                 start += prefix;
1016                 bytes -= prefix;
1017         }
1018
1019         words = bytes / 8;
1020
1021         while (words) {
1022                 if (*(u64 *)start != value64)
1023                         return check_bytes8(start, value, 8);
1024                 start += 8;
1025                 words--;
1026         }
1027
1028         return check_bytes8(start, value, bytes % 8);
1029 }
1030 EXPORT_SYMBOL(memchr_inv);
1031
1032 /**
1033  * strreplace - Replace all occurrences of character in string.
1034  * @s: The string to operate on.
1035  * @old: The character being replaced.
1036  * @new: The character @old is replaced with.
1037  *
1038  * Returns pointer to the nul byte at the end of @s.
1039  */
1040 char *strreplace(char *s, char old, char new)
1041 {
1042         for (; *s; ++s)
1043                 if (*s == old)
1044                         *s = new;
1045         return s;
1046 }
1047 EXPORT_SYMBOL(strreplace);
1048
1049 void fortify_panic(const char *name)
1050 {
1051         pr_emerg("detected buffer overflow in %s\n", name);
1052         BUG();
1053 }
1054 EXPORT_SYMBOL(fortify_panic);