1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
35
36
37
38
39int strncasecmp(const char *s1, const char *s2, size_t len)
40{
41
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}
61EXPORT_SYMBOL(strncasecmp);
62#endif
63
64#ifndef __HAVE_ARCH_STRCASECMP
65int 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}
75EXPORT_SYMBOL(strcasecmp);
76#endif
77
78#ifndef __HAVE_ARCH_STRCPY
79
80
81
82
83
84char *strcpy(char *dest, const char *src)
85{
86 char *tmp = dest;
87
88 while ((*dest++ = *src++) != '\0')
89 ;
90 return tmp;
91}
92EXPORT_SYMBOL(strcpy);
93#endif
94
95#ifndef __HAVE_ARCH_STRNCPY
96
97
98
99
100
101
102
103
104
105
106
107
108
109char *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}
121EXPORT_SYMBOL(strncpy);
122#endif
123
124#ifndef __HAVE_ARCH_STRLCPY
125
126
127
128
129
130
131
132
133
134
135
136size_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}
147EXPORT_SYMBOL(strlcpy);
148#endif
149
150#ifndef __HAVE_ARCH_STRSCPY
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175ssize_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
187
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
196 if (((long) dest | (long) src) & (sizeof(long) - 1))
197 max = 0;
198#endif
199
200 while (max >= sizeof(unsigned long)) {
201 unsigned long c, data;
202
203 c = read_word_at_a_time(src+res);
204 if (has_zero(c, &data, &constants)) {
205 data = prep_zero_mask(c, data, &constants);
206 data = create_zero_mask(data);
207 *(unsigned long *)(dest+res) = c & zero_bytemask(data);
208 return res + find_zero(data);
209 }
210 *(unsigned long *)(dest+res) = c;
211 res += sizeof(unsigned long);
212 count -= sizeof(unsigned long);
213 max -= sizeof(unsigned long);
214 }
215
216 while (count) {
217 char c;
218
219 c = src[res];
220 dest[res] = c;
221 if (!c)
222 return res;
223 res++;
224 count--;
225 }
226
227
228 if (res)
229 dest[res-1] = '\0';
230
231 return -E2BIG;
232}
233EXPORT_SYMBOL(strscpy);
234#endif
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
252char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
253{
254 while ((*dest++ = *src++) != '\0')
255 ;
256 return --dest;
257}
258EXPORT_SYMBOL(stpcpy);
259
260#ifndef __HAVE_ARCH_STRCAT
261
262
263
264
265
266char *strcat(char *dest, const char *src)
267{
268 char *tmp = dest;
269
270 while (*dest)
271 dest++;
272 while ((*dest++ = *src++) != '\0')
273 ;
274 return tmp;
275}
276EXPORT_SYMBOL(strcat);
277#endif
278
279#ifndef __HAVE_ARCH_STRNCAT
280
281
282
283
284
285
286
287
288
289char *strncat(char *dest, const char *src, size_t count)
290{
291 char *tmp = dest;
292
293 if (count) {
294 while (*dest)
295 dest++;
296 while ((*dest++ = *src++) != 0) {
297 if (--count == 0) {
298 *dest = '\0';
299 break;
300 }
301 }
302 }
303 return tmp;
304}
305EXPORT_SYMBOL(strncat);
306#endif
307
308#ifndef __HAVE_ARCH_STRLCAT
309
310
311
312
313
314
315size_t strlcat(char *dest, const char *src, size_t count)
316{
317 size_t dsize = strlen(dest);
318 size_t len = strlen(src);
319 size_t res = dsize + len;
320
321
322 BUG_ON(dsize >= count);
323
324 dest += dsize;
325 count -= dsize;
326 if (len >= count)
327 len = count-1;
328 memcpy(dest, src, len);
329 dest[len] = 0;
330 return res;
331}
332EXPORT_SYMBOL(strlcat);
333#endif
334
335#ifndef __HAVE_ARCH_STRCMP
336
337
338
339
340
341int strcmp(const char *cs, const char *ct)
342{
343 unsigned char c1, c2;
344
345 while (1) {
346 c1 = *cs++;
347 c2 = *ct++;
348 if (c1 != c2)
349 return c1 < c2 ? -1 : 1;
350 if (!c1)
351 break;
352 }
353 return 0;
354}
355EXPORT_SYMBOL(strcmp);
356#endif
357
358#ifndef __HAVE_ARCH_STRNCMP
359
360
361
362
363
364
365int strncmp(const char *cs, const char *ct, size_t count)
366{
367 unsigned char c1, c2;
368
369 while (count) {
370 c1 = *cs++;
371 c2 = *ct++;
372 if (c1 != c2)
373 return c1 < c2 ? -1 : 1;
374 if (!c1)
375 break;
376 count--;
377 }
378 return 0;
379}
380EXPORT_SYMBOL(strncmp);
381#endif
382
383#ifndef __HAVE_ARCH_STRCHR
384
385
386
387
388
389
390
391
392char *strchr(const char *s, int c)
393{
394 for (; *s != (char)c; ++s)
395 if (*s == '\0')
396 return NULL;
397 return (char *)s;
398}
399EXPORT_SYMBOL(strchr);
400#endif
401
402#ifndef __HAVE_ARCH_STRCHRNUL
403
404
405
406
407
408
409
410
411char *strchrnul(const char *s, int c)
412{
413 while (*s && *s != (char)c)
414 s++;
415 return (char *)s;
416}
417EXPORT_SYMBOL(strchrnul);
418#endif
419
420
421
422
423
424
425
426
427
428
429
430char *strnchrnul(const char *s, size_t count, int c)
431{
432 while (count-- && *s && *s != (char)c)
433 s++;
434 return (char *)s;
435}
436
437#ifndef __HAVE_ARCH_STRRCHR
438
439
440
441
442
443char *strrchr(const char *s, int c)
444{
445 const char *last = NULL;
446 do {
447 if (*s == (char)c)
448 last = s;
449 } while (*s++);
450 return (char *)last;
451}
452EXPORT_SYMBOL(strrchr);
453#endif
454
455#ifndef __HAVE_ARCH_STRNCHR
456
457
458
459
460
461
462
463
464
465char *strnchr(const char *s, size_t count, int c)
466{
467 while (count--) {
468 if (*s == (char)c)
469 return (char *)s;
470 if (*s++ == '\0')
471 break;
472 }
473 return NULL;
474}
475EXPORT_SYMBOL(strnchr);
476#endif
477
478#ifndef __HAVE_ARCH_STRLEN
479
480
481
482
483size_t strlen(const char *s)
484{
485 const char *sc;
486
487 for (sc = s; *sc != '\0'; ++sc)
488 ;
489 return sc - s;
490}
491EXPORT_SYMBOL(strlen);
492#endif
493
494#ifndef __HAVE_ARCH_STRNLEN
495
496
497
498
499
500size_t strnlen(const char *s, size_t count)
501{
502 const char *sc;
503
504 for (sc = s; count-- && *sc != '\0'; ++sc)
505 ;
506 return sc - s;
507}
508EXPORT_SYMBOL(strnlen);
509#endif
510
511#ifndef __HAVE_ARCH_STRSPN
512
513
514
515
516
517size_t strspn(const char *s, const char *accept)
518{
519 const char *p;
520 const char *a;
521 size_t count = 0;
522
523 for (p = s; *p != '\0'; ++p) {
524 for (a = accept; *a != '\0'; ++a) {
525 if (*p == *a)
526 break;
527 }
528 if (*a == '\0')
529 return count;
530 ++count;
531 }
532 return count;
533}
534
535EXPORT_SYMBOL(strspn);
536#endif
537
538#ifndef __HAVE_ARCH_STRCSPN
539
540
541
542
543
544size_t strcspn(const char *s, const char *reject)
545{
546 const char *p;
547 const char *r;
548 size_t count = 0;
549
550 for (p = s; *p != '\0'; ++p) {
551 for (r = reject; *r != '\0'; ++r) {
552 if (*p == *r)
553 return count;
554 }
555 ++count;
556 }
557 return count;
558}
559EXPORT_SYMBOL(strcspn);
560#endif
561
562#ifndef __HAVE_ARCH_STRPBRK
563
564
565
566
567
568char *strpbrk(const char *cs, const char *ct)
569{
570 const char *sc1, *sc2;
571
572 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
573 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
574 if (*sc1 == *sc2)
575 return (char *)sc1;
576 }
577 }
578 return NULL;
579}
580EXPORT_SYMBOL(strpbrk);
581#endif
582
583#ifndef __HAVE_ARCH_STRSEP
584
585
586
587
588
589
590
591
592
593
594
595char *strsep(char **s, const char *ct)
596{
597 char *sbegin = *s;
598 char *end;
599
600 if (sbegin == NULL)
601 return NULL;
602
603 end = strpbrk(sbegin, ct);
604 if (end)
605 *end++ = '\0';
606 *s = end;
607 return sbegin;
608}
609EXPORT_SYMBOL(strsep);
610#endif
611
612#ifndef __HAVE_ARCH_MEMSET
613
614
615
616
617
618
619
620
621void *memset(void *s, int c, size_t count)
622{
623 char *xs = s;
624
625 while (count--)
626 *xs++ = c;
627 return s;
628}
629EXPORT_SYMBOL(memset);
630#endif
631
632#ifndef __HAVE_ARCH_MEMSET16
633
634
635
636
637
638
639
640
641
642
643void *memset16(uint16_t *s, uint16_t v, size_t count)
644{
645 uint16_t *xs = s;
646
647 while (count--)
648 *xs++ = v;
649 return s;
650}
651EXPORT_SYMBOL(memset16);
652#endif
653
654#ifndef __HAVE_ARCH_MEMSET32
655
656
657
658
659
660
661
662
663
664
665void *memset32(uint32_t *s, uint32_t v, size_t count)
666{
667 uint32_t *xs = s;
668
669 while (count--)
670 *xs++ = v;
671 return s;
672}
673EXPORT_SYMBOL(memset32);
674#endif
675
676#ifndef __HAVE_ARCH_MEMSET64
677
678
679
680
681
682
683
684
685
686
687void *memset64(uint64_t *s, uint64_t v, size_t count)
688{
689 uint64_t *xs = s;
690
691 while (count--)
692 *xs++ = v;
693 return s;
694}
695EXPORT_SYMBOL(memset64);
696#endif
697
698#ifndef __HAVE_ARCH_MEMCPY
699
700
701
702
703
704
705
706
707
708void *memcpy(void *dest, const void *src, size_t count)
709{
710 char *tmp = dest;
711 const char *s = src;
712
713 while (count--)
714 *tmp++ = *s++;
715 return dest;
716}
717EXPORT_SYMBOL(memcpy);
718#endif
719
720#ifndef __HAVE_ARCH_MEMMOVE
721
722
723
724
725
726
727
728
729void *memmove(void *dest, const void *src, size_t count)
730{
731 char *tmp;
732 const char *s;
733
734 if (dest <= src) {
735 tmp = dest;
736 s = src;
737 while (count--)
738 *tmp++ = *s++;
739 } else {
740 tmp = dest;
741 tmp += count;
742 s = src;
743 s += count;
744 while (count--)
745 *--tmp = *--s;
746 }
747 return dest;
748}
749EXPORT_SYMBOL(memmove);
750#endif
751
752#ifndef __HAVE_ARCH_MEMCMP
753
754
755
756
757
758
759#undef memcmp
760__visible int memcmp(const void *cs, const void *ct, size_t count)
761{
762 const unsigned char *su1, *su2;
763 int res = 0;
764
765#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
766 if (count >= sizeof(unsigned long)) {
767 const unsigned long *u1 = cs;
768 const unsigned long *u2 = ct;
769 do {
770 if (get_unaligned(u1) != get_unaligned(u2))
771 break;
772 u1++;
773 u2++;
774 count -= sizeof(unsigned long);
775 } while (count >= sizeof(unsigned long));
776 cs = u1;
777 ct = u2;
778 }
779#endif
780 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
781 if ((res = *su1 - *su2) != 0)
782 break;
783 return res;
784}
785EXPORT_SYMBOL(memcmp);
786#endif
787
788#ifndef __HAVE_ARCH_BCMP
789
790
791
792
793
794
795
796
797
798
799
800int bcmp(const void *a, const void *b, size_t len)
801{
802 return memcmp(a, b, len);
803}
804EXPORT_SYMBOL(bcmp);
805#endif
806
807#ifndef __HAVE_ARCH_MEMSCAN
808
809
810
811
812
813
814
815
816
817void *memscan(void *addr, int c, size_t size)
818{
819 unsigned char *p = addr;
820
821 while (size) {
822 if (*p == (unsigned char)c)
823 return (void *)p;
824 p++;
825 size--;
826 }
827 return (void *)p;
828}
829EXPORT_SYMBOL(memscan);
830#endif
831
832#ifndef __HAVE_ARCH_STRSTR
833
834
835
836
837
838char *strstr(const char *s1, const char *s2)
839{
840 size_t l1, l2;
841
842 l2 = strlen(s2);
843 if (!l2)
844 return (char *)s1;
845 l1 = strlen(s1);
846 while (l1 >= l2) {
847 l1--;
848 if (!memcmp(s1, s2, l2))
849 return (char *)s1;
850 s1++;
851 }
852 return NULL;
853}
854EXPORT_SYMBOL(strstr);
855#endif
856
857#ifndef __HAVE_ARCH_STRNSTR
858
859
860
861
862
863
864char *strnstr(const char *s1, const char *s2, size_t len)
865{
866 size_t l2;
867
868 l2 = strlen(s2);
869 if (!l2)
870 return (char *)s1;
871 while (len >= l2) {
872 len--;
873 if (!memcmp(s1, s2, l2))
874 return (char *)s1;
875 s1++;
876 }
877 return NULL;
878}
879EXPORT_SYMBOL(strnstr);
880#endif
881
882#ifndef __HAVE_ARCH_MEMCHR
883
884
885
886
887
888
889
890
891
892void *memchr(const void *s, int c, size_t n)
893{
894 const unsigned char *p = s;
895 while (n-- != 0) {
896 if ((unsigned char)c == *p++) {
897 return (void *)(p - 1);
898 }
899 }
900 return NULL;
901}
902EXPORT_SYMBOL(memchr);
903#endif
904
905static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
906{
907 while (bytes) {
908 if (*start != value)
909 return (void *)start;
910 start++;
911 bytes--;
912 }
913 return NULL;
914}
915
916
917
918
919
920
921
922
923
924
925void *memchr_inv(const void *start, int c, size_t bytes)
926{
927 u8 value = c;
928 u64 value64;
929 unsigned int words, prefix;
930
931 if (bytes <= 16)
932 return check_bytes8(start, value, bytes);
933
934 value64 = value;
935#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
936 value64 *= 0x0101010101010101ULL;
937#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
938 value64 *= 0x01010101;
939 value64 |= value64 << 32;
940#else
941 value64 |= value64 << 8;
942 value64 |= value64 << 16;
943 value64 |= value64 << 32;
944#endif
945
946 prefix = (unsigned long)start % 8;
947 if (prefix) {
948 u8 *r;
949
950 prefix = 8 - prefix;
951 r = check_bytes8(start, value, prefix);
952 if (r)
953 return r;
954 start += prefix;
955 bytes -= prefix;
956 }
957
958 words = bytes / 8;
959
960 while (words) {
961 if (*(u64 *)start != value64)
962 return check_bytes8(start, value, 8);
963 start += 8;
964 words--;
965 }
966
967 return check_bytes8(start, value, bytes % 8);
968}
969EXPORT_SYMBOL(memchr_inv);
970