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 | __builtin_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(addr: src+res); |
159 | if (has_zero(a: c, bits: &data, c: &constants)) { |
160 | data = prep_zero_mask(a: c, bits: data, c: &constants); |
161 | data = create_zero_mask(bits: data); |
162 | *(unsigned long *)(dest+res) = c & zero_bytemask(data); |
163 | return res + find_zero(mask: 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 | __builtin_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, bytes: 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, bytes: 8); |
874 | start += 8; |
875 | words--; |
876 | } |
877 | |
878 | return check_bytes8(start, value, bytes: bytes % 8); |
879 | } |
880 | EXPORT_SYMBOL(memchr_inv); |
881 | |