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