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#include <linux/slab.h>
  31
  32#include <asm/byteorder.h>
  33#include <asm/word-at-a-time.h>
  34#include <asm/page.h>
  35
  36#ifndef __HAVE_ARCH_STRNCASECMP
  37/**
  38 * strncasecmp - Case insensitive, length-limited string comparison
  39 * @s1: One string
  40 * @s2: The other string
  41 * @len: the maximum number of characters to compare
  42 */
  43int strncasecmp(const char *s1, const char *s2, size_t len)
  44{
  45	/* Yes, Virginia, it had better be unsigned */
  46	unsigned char c1, c2;
  47
  48	if (!len)
  49		return 0;
  50
  51	do {
  52		c1 = *s1++;
  53		c2 = *s2++;
  54		if (!c1 || !c2)
  55			break;
  56		if (c1 == c2)
  57			continue;
  58		c1 = tolower(c1);
  59		c2 = tolower(c2);
  60		if (c1 != c2)
  61			break;
  62	} while (--len);
  63	return (int)c1 - (int)c2;
  64}
  65EXPORT_SYMBOL(strncasecmp);
  66#endif
  67
  68#ifndef __HAVE_ARCH_STRCASECMP
  69int strcasecmp(const char *s1, const char *s2)
  70{
  71	int c1, c2;
  72
  73	do {
  74		c1 = tolower(*s1++);
  75		c2 = tolower(*s2++);
  76	} while (c1 == c2 && c1 != 0);
  77	return c1 - c2;
  78}
  79EXPORT_SYMBOL(strcasecmp);
  80#endif
  81
  82#ifndef __HAVE_ARCH_STRCPY
  83/**
  84 * strcpy - Copy a %NUL terminated string
  85 * @dest: Where to copy the string to
  86 * @src: Where to copy the string from
  87 */
  88char *strcpy(char *dest, const char *src)
  89{
  90	char *tmp = dest;
  91
  92	while ((*dest++ = *src++) != '\0')
  93		/* nothing */;
  94	return tmp;
  95}
  96EXPORT_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 */
 113char *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}
 125EXPORT_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 */
 140size_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}
 151EXPORT_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.  The
 162 * behavior is undefined if the string buffers overlap.  The destination
 163 * buffer is always NUL terminated, unless it's zero-sized.
 164 *
 165 * Preferred to strlcpy() since the API doesn't require reading memory
 166 * from the src string beyond the specified "count" bytes, and since
 167 * the return value is easier to error-check than strlcpy()'s.
 168 * In addition, the implementation is robust to the string changing out
 169 * from underneath it, unlike the current strlcpy() implementation.
 170 *
 171 * Preferred to strncpy() since it always returns a valid string, and
 172 * doesn't unnecessarily force the tail of the destination buffer to be
 173 * zeroed.  If zeroing is desired please use strscpy_pad().
 174 *
 175 * Returns:
 176 * * The number of characters copied (not including the trailing %NUL)
 177 * * -E2BIG if count is 0 or @src was truncated.
 178 */
 179ssize_t strscpy(char *dest, const char *src, size_t count)
 180{
 181	const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 182	size_t max = count;
 183	long res = 0;
 184
 185	if (count == 0 || WARN_ON_ONCE(count > INT_MAX))
 186		return -E2BIG;
 187
 188#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 189	/*
 190	 * If src is unaligned, don't cross a page boundary,
 191	 * since we don't know if the next page is mapped.
 192	 */
 193	if ((long)src & (sizeof(long) - 1)) {
 194		size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1));
 195		if (limit < max)
 196			max = limit;
 197	}
 198#else
 199	/* If src or dest is unaligned, don't do word-at-a-time. */
 200	if (((long) dest | (long) src) & (sizeof(long) - 1))
 201		max = 0;
 202#endif
 203
 204	while (max >= sizeof(unsigned long)) {
 205		unsigned long c, data;
 206
 207		c = read_word_at_a_time(src+res);
 208		if (has_zero(c, &data, &constants)) {
 209			data = prep_zero_mask(c, data, &constants);
 210			data = create_zero_mask(data);
 211			*(unsigned long *)(dest+res) = c & zero_bytemask(data);
 212			return res + find_zero(data);
 213		}
 214		*(unsigned long *)(dest+res) = c;
 215		res += sizeof(unsigned long);
 216		count -= sizeof(unsigned long);
 217		max -= sizeof(unsigned long);
 218	}
 219
 220	while (count) {
 221		char c;
 222
 223		c = src[res];
 224		dest[res] = c;
 225		if (!c)
 226			return res;
 227		res++;
 228		count--;
 229	}
 230
 231	/* Hit buffer length without finding a NUL; force NUL-termination. */
 232	if (res)
 233		dest[res-1] = '\0';
 234
 235	return -E2BIG;
 236}
 237EXPORT_SYMBOL(strscpy);
 238#endif
 239
 240/**
 241 * strscpy_pad() - Copy a C-string into a sized buffer
 242 * @dest: Where to copy the string to
 243 * @src: Where to copy the string from
 244 * @count: Size of destination buffer
 245 *
 246 * Copy the string, or as much of it as fits, into the dest buffer.  The
 247 * behavior is undefined if the string buffers overlap.  The destination
 248 * buffer is always %NUL terminated, unless it's zero-sized.
 249 *
 250 * If the source string is shorter than the destination buffer, zeros
 251 * the tail of the destination buffer.
 252 *
 253 * For full explanation of why you may want to consider using the
 254 * 'strscpy' functions please see the function docstring for strscpy().
 255 *
 256 * Returns:
 257 * * The number of characters copied (not including the trailing %NUL)
 258 * * -E2BIG if count is 0 or @src was truncated.
 259 */
 260ssize_t strscpy_pad(char *dest, const char *src, size_t count)
 261{
 262	ssize_t written;
 263
 264	written = strscpy(dest, src, count);
 265	if (written < 0 || written == count - 1)
 266		return written;
 267
 268	memset(dest + written + 1, 0, count - written - 1);
 269
 270	return written;
 271}
 272EXPORT_SYMBOL(strscpy_pad);
 273
 274/**
 275 * stpcpy - copy a string from src to dest returning a pointer to the new end
 276 *          of dest, including src's %NUL-terminator. May overrun dest.
 277 * @dest: pointer to end of string being copied into. Must be large enough
 278 *        to receive copy.
 279 * @src: pointer to the beginning of string being copied from. Must not overlap
 280 *       dest.
 281 *
 282 * stpcpy differs from strcpy in a key way: the return value is a pointer
 283 * to the new %NUL-terminating character in @dest. (For strcpy, the return
 284 * value is a pointer to the start of @dest). This interface is considered
 285 * unsafe as it doesn't perform bounds checking of the inputs. As such it's
 286 * not recommended for usage. Instead, its definition is provided in case
 287 * the compiler lowers other libcalls to stpcpy.
 288 */
 289char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
 290char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
 291{
 292	while ((*dest++ = *src++) != '\0')
 293		/* nothing */;
 294	return --dest;
 295}
 296EXPORT_SYMBOL(stpcpy);
 297
 298#ifndef __HAVE_ARCH_STRCAT
 299/**
 300 * strcat - Append one %NUL-terminated string to another
 301 * @dest: The string to be appended to
 302 * @src: The string to append to it
 303 */
 304char *strcat(char *dest, const char *src)
 305{
 306	char *tmp = dest;
 307
 308	while (*dest)
 309		dest++;
 310	while ((*dest++ = *src++) != '\0')
 311		;
 312	return tmp;
 313}
 314EXPORT_SYMBOL(strcat);
 315#endif
 316
 317#ifndef __HAVE_ARCH_STRNCAT
 318/**
 319 * strncat - Append a length-limited, C-string to another
 320 * @dest: The string to be appended to
 321 * @src: The string to append to it
 322 * @count: The maximum numbers of bytes to copy
 323 *
 324 * Note that in contrast to strncpy(), strncat() ensures the result is
 325 * terminated.
 326 */
 327char *strncat(char *dest, const char *src, size_t count)
 328{
 329	char *tmp = dest;
 330
 331	if (count) {
 332		while (*dest)
 333			dest++;
 334		while ((*dest++ = *src++) != 0) {
 335			if (--count == 0) {
 336				*dest = '\0';
 337				break;
 338			}
 339		}
 340	}
 341	return tmp;
 342}
 343EXPORT_SYMBOL(strncat);
 344#endif
 345
 346#ifndef __HAVE_ARCH_STRLCAT
 347/**
 348 * strlcat - Append a length-limited, C-string to another
 349 * @dest: The string to be appended to
 350 * @src: The string to append to it
 351 * @count: The size of the destination buffer.
 352 */
 353size_t strlcat(char *dest, const char *src, size_t count)
 354{
 355	size_t dsize = strlen(dest);
 356	size_t len = strlen(src);
 357	size_t res = dsize + len;
 358
 359	/* This would be a bug */
 360	BUG_ON(dsize >= count);
 361
 362	dest += dsize;
 363	count -= dsize;
 364	if (len >= count)
 365		len = count-1;
 366	memcpy(dest, src, len);
 367	dest[len] = 0;
 368	return res;
 369}
 370EXPORT_SYMBOL(strlcat);
 371#endif
 372
 373#ifndef __HAVE_ARCH_STRCMP
 374/**
 375 * strcmp - Compare two strings
 376 * @cs: One string
 377 * @ct: Another string
 378 */
 379int strcmp(const char *cs, const char *ct)
 380{
 381	unsigned char c1, c2;
 382
 383	while (1) {
 384		c1 = *cs++;
 385		c2 = *ct++;
 386		if (c1 != c2)
 387			return c1 < c2 ? -1 : 1;
 388		if (!c1)
 389			break;
 390	}
 391	return 0;
 392}
 393EXPORT_SYMBOL(strcmp);
 394#endif
 395
 396#ifndef __HAVE_ARCH_STRNCMP
 397/**
 398 * strncmp - Compare two length-limited strings
 399 * @cs: One string
 400 * @ct: Another string
 401 * @count: The maximum number of bytes to compare
 402 */
 403int strncmp(const char *cs, const char *ct, size_t count)
 404{
 405	unsigned char c1, c2;
 406
 407	while (count) {
 408		c1 = *cs++;
 409		c2 = *ct++;
 410		if (c1 != c2)
 411			return c1 < c2 ? -1 : 1;
 412		if (!c1)
 413			break;
 414		count--;
 415	}
 416	return 0;
 417}
 418EXPORT_SYMBOL(strncmp);
 419#endif
 420
 421#ifndef __HAVE_ARCH_STRCHR
 422/**
 423 * strchr - Find the first occurrence of a character in a string
 424 * @s: The string to be searched
 425 * @c: The character to search for
 426 *
 427 * Note that the %NUL-terminator is considered part of the string, and can
 428 * be searched for.
 429 */
 430char *strchr(const char *s, int c)
 431{
 432	for (; *s != (char)c; ++s)
 433		if (*s == '\0')
 434			return NULL;
 435	return (char *)s;
 436}
 437EXPORT_SYMBOL(strchr);
 438#endif
 439
 440#ifndef __HAVE_ARCH_STRCHRNUL
 441/**
 442 * strchrnul - Find and return a character in a string, or end of string
 443 * @s: The string to be searched
 444 * @c: The character to search for
 445 *
 446 * Returns pointer to first occurrence of 'c' in s. If c is not found, then
 447 * return a pointer to the null byte at the end of s.
 448 */
 449char *strchrnul(const char *s, int c)
 450{
 451	while (*s && *s != (char)c)
 452		s++;
 453	return (char *)s;
 454}
 455EXPORT_SYMBOL(strchrnul);
 456#endif
 457
 458/**
 459 * strnchrnul - Find and return a character in a length limited string,
 460 * or end of string
 461 * @s: The string to be searched
 462 * @count: The number of characters to be searched
 463 * @c: The character to search for
 464 *
 465 * Returns pointer to the first occurrence of 'c' in s. If c is not found,
 466 * then return a pointer to the last character of the string.
 467 */
 468char *strnchrnul(const char *s, size_t count, int c)
 469{
 470	while (count-- && *s && *s != (char)c)
 471		s++;
 472	return (char *)s;
 473}
 474
 475#ifndef __HAVE_ARCH_STRRCHR
 476/**
 477 * strrchr - Find the last occurrence of a character in a string
 478 * @s: The string to be searched
 479 * @c: The character to search for
 480 */
 481char *strrchr(const char *s, int c)
 482{
 483	const char *last = NULL;
 484	do {
 485		if (*s == (char)c)
 486			last = s;
 487	} while (*s++);
 488	return (char *)last;
 489}
 490EXPORT_SYMBOL(strrchr);
 491#endif
 492
 493#ifndef __HAVE_ARCH_STRNCHR
 494/**
 495 * strnchr - Find a character in a length limited string
 496 * @s: The string to be searched
 497 * @count: The number of characters to be searched
 498 * @c: The character to search for
 499 *
 500 * Note that the %NUL-terminator is considered part of the string, and can
 501 * be searched for.
 502 */
 503char *strnchr(const char *s, size_t count, int c)
 504{
 505	while (count--) {
 506		if (*s == (char)c)
 507			return (char *)s;
 508		if (*s++ == '\0')
 509			break;
 510	}
 511	return NULL;
 512}
 513EXPORT_SYMBOL(strnchr);
 514#endif
 515
 516/**
 517 * skip_spaces - Removes leading whitespace from @str.
 518 * @str: The string to be stripped.
 519 *
 520 * Returns a pointer to the first non-whitespace character in @str.
 521 */
 522char *skip_spaces(const char *str)
 523{
 524	while (isspace(*str))
 525		++str;
 526	return (char *)str;
 527}
 528EXPORT_SYMBOL(skip_spaces);
 529
 530/**
 531 * strim - Removes leading and trailing whitespace from @s.
 532 * @s: The string to be stripped.
 533 *
 534 * Note that the first trailing whitespace is replaced with a %NUL-terminator
 535 * in the given string @s. Returns a pointer to the first non-whitespace
 536 * character in @s.
 537 */
 538char *strim(char *s)
 539{
 540	size_t size;
 541	char *end;
 542
 543	size = strlen(s);
 544	if (!size)
 545		return s;
 546
 547	end = s + size - 1;
 548	while (end >= s && isspace(*end))
 549		end--;
 550	*(end + 1) = '\0';
 551
 552	return skip_spaces(s);
 553}
 554EXPORT_SYMBOL(strim);
 555
 556#ifndef __HAVE_ARCH_STRLEN
 557/**
 558 * strlen - Find the length of a string
 559 * @s: The string to be sized
 560 */
 561size_t strlen(const char *s)
 562{
 563	const char *sc;
 564
 565	for (sc = s; *sc != '\0'; ++sc)
 566		/* nothing */;
 567	return sc - s;
 568}
 569EXPORT_SYMBOL(strlen);
 570#endif
 571
 572#ifndef __HAVE_ARCH_STRNLEN
 573/**
 574 * strnlen - Find the length of a length-limited string
 575 * @s: The string to be sized
 576 * @count: The maximum number of bytes to search
 577 */
 578size_t strnlen(const char *s, size_t count)
 579{
 580	const char *sc;
 581
 582	for (sc = s; count-- && *sc != '\0'; ++sc)
 583		/* nothing */;
 584	return sc - s;
 585}
 586EXPORT_SYMBOL(strnlen);
 587#endif
 588
 589#ifndef __HAVE_ARCH_STRSPN
 590/**
 591 * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept
 592 * @s: The string to be searched
 593 * @accept: The string to search for
 594 */
 595size_t strspn(const char *s, const char *accept)
 596{
 597	const char *p;
 598	const char *a;
 599	size_t count = 0;
 600
 601	for (p = s; *p != '\0'; ++p) {
 602		for (a = accept; *a != '\0'; ++a) {
 603			if (*p == *a)
 604				break;
 605		}
 606		if (*a == '\0')
 607			return count;
 608		++count;
 609	}
 610	return count;
 611}
 612
 613EXPORT_SYMBOL(strspn);
 614#endif
 615
 616#ifndef __HAVE_ARCH_STRCSPN
 617/**
 618 * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject
 619 * @s: The string to be searched
 620 * @reject: The string to avoid
 621 */
 622size_t strcspn(const char *s, const char *reject)
 623{
 624	const char *p;
 625	const char *r;
 626	size_t count = 0;
 627
 628	for (p = s; *p != '\0'; ++p) {
 629		for (r = reject; *r != '\0'; ++r) {
 630			if (*p == *r)
 631				return count;
 632		}
 633		++count;
 634	}
 635	return count;
 636}
 637EXPORT_SYMBOL(strcspn);
 638#endif
 639
 640#ifndef __HAVE_ARCH_STRPBRK
 641/**
 642 * strpbrk - Find the first occurrence of a set of characters
 643 * @cs: The string to be searched
 644 * @ct: The characters to search for
 645 */
 646char *strpbrk(const char *cs, const char *ct)
 647{
 648	const char *sc1, *sc2;
 649
 650	for (sc1 = cs; *sc1 != '\0'; ++sc1) {
 651		for (sc2 = ct; *sc2 != '\0'; ++sc2) {
 652			if (*sc1 == *sc2)
 653				return (char *)sc1;
 654		}
 655	}
 656	return NULL;
 657}
 658EXPORT_SYMBOL(strpbrk);
 659#endif
 660
 661#ifndef __HAVE_ARCH_STRSEP
 662/**
 663 * strsep - Split a string into tokens
 664 * @s: The string to be searched
 665 * @ct: The characters to search for
 666 *
 667 * strsep() updates @s to point after the token, ready for the next call.
 668 *
 669 * It returns empty tokens, too, behaving exactly like the libc function
 670 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
 671 * Same semantics, slimmer shape. ;)
 672 */
 673char *strsep(char **s, const char *ct)
 674{
 675	char *sbegin = *s;
 676	char *end;
 677
 678	if (sbegin == NULL)
 679		return NULL;
 680
 681	end = strpbrk(sbegin, ct);
 682	if (end)
 683		*end++ = '\0';
 684	*s = end;
 685	return sbegin;
 686}
 687EXPORT_SYMBOL(strsep);
 688#endif
 689
 690/**
 691 * sysfs_streq - return true if strings are equal, modulo trailing newline
 692 * @s1: one string
 693 * @s2: another string
 694 *
 695 * This routine returns true iff two strings are equal, treating both
 696 * NUL and newline-then-NUL as equivalent string terminations.  It's
 697 * geared for use with sysfs input strings, which generally terminate
 698 * with newlines but are compared against values without newlines.
 699 */
 700bool sysfs_streq(const char *s1, const char *s2)
 701{
 702	while (*s1 && *s1 == *s2) {
 703		s1++;
 704		s2++;
 705	}
 706
 707	if (*s1 == *s2)
 708		return true;
 709	if (!*s1 && *s2 == '\n' && !s2[1])
 710		return true;
 711	if (*s1 == '\n' && !s1[1] && !*s2)
 712		return true;
 713	return false;
 714}
 715EXPORT_SYMBOL(sysfs_streq);
 716
 717/**
 718 * match_string - matches given string in an array
 719 * @array:	array of strings
 720 * @n:		number of strings in the array or -1 for NULL terminated arrays
 721 * @string:	string to match with
 722 *
 723 * This routine will look for a string in an array of strings up to the
 724 * n-th element in the array or until the first NULL element.
 725 *
 726 * Historically the value of -1 for @n, was used to search in arrays that
 727 * are NULL terminated. However, the function does not make a distinction
 728 * when finishing the search: either @n elements have been compared OR
 729 * the first NULL element was found.
 730 *
 731 * Return:
 732 * index of a @string in the @array if matches, or %-EINVAL otherwise.
 733 */
 734int match_string(const char * const *array, size_t n, const char *string)
 735{
 736	int index;
 737	const char *item;
 738
 739	for (index = 0; index < n; index++) {
 740		item = array[index];
 741		if (!item)
 742			break;
 743		if (!strcmp(item, string))
 744			return index;
 745	}
 746
 747	return -EINVAL;
 748}
 749EXPORT_SYMBOL(match_string);
 750
 751/**
 752 * __sysfs_match_string - matches given string in an array
 753 * @array: array of strings
 754 * @n: number of strings in the array or -1 for NULL terminated arrays
 755 * @str: string to match with
 756 *
 757 * Returns index of @str in the @array or -EINVAL, just like match_string().
 758 * Uses sysfs_streq instead of strcmp for matching.
 759 *
 760 * This routine will look for a string in an array of strings up to the
 761 * n-th element in the array or until the first NULL element.
 762 *
 763 * Historically the value of -1 for @n, was used to search in arrays that
 764 * are NULL terminated. However, the function does not make a distinction
 765 * when finishing the search: either @n elements have been compared OR
 766 * the first NULL element was found.
 767 */
 768int __sysfs_match_string(const char * const *array, size_t n, const char *str)
 769{
 770	const char *item;
 771	int index;
 772
 773	for (index = 0; index < n; index++) {
 774		item = array[index];
 775		if (!item)
 776			break;
 777		if (sysfs_streq(item, str))
 778			return index;
 779	}
 780
 781	return -EINVAL;
 782}
 783EXPORT_SYMBOL(__sysfs_match_string);
 784
 785#ifndef __HAVE_ARCH_MEMSET
 786/**
 787 * memset - Fill a region of memory with the given value
 788 * @s: Pointer to the start of the area.
 789 * @c: The byte to fill the area with
 790 * @count: The size of the area.
 791 *
 792 * Do not use memset() to access IO space, use memset_io() instead.
 793 */
 794void *memset(void *s, int c, size_t count)
 795{
 796	char *xs = s;
 797
 798	while (count--)
 799		*xs++ = c;
 800	return s;
 801}
 802EXPORT_SYMBOL(memset);
 803#endif
 804
 805#ifndef __HAVE_ARCH_MEMSET16
 806/**
 807 * memset16() - Fill a memory area with a uint16_t
 808 * @s: Pointer to the start of the area.
 809 * @v: The value to fill the area with
 810 * @count: The number of values to store
 811 *
 812 * Differs from memset() in that it fills with a uint16_t instead
 813 * of a byte.  Remember that @count is the number of uint16_ts to
 814 * store, not the number of bytes.
 815 */
 816void *memset16(uint16_t *s, uint16_t v, size_t count)
 817{
 818	uint16_t *xs = s;
 819
 820	while (count--)
 821		*xs++ = v;
 822	return s;
 823}
 824EXPORT_SYMBOL(memset16);
 825#endif
 826
 827#ifndef __HAVE_ARCH_MEMSET32
 828/**
 829 * memset32() - Fill a memory area with a uint32_t
 830 * @s: Pointer to the start of the area.
 831 * @v: The value to fill the area with
 832 * @count: The number of values to store
 833 *
 834 * Differs from memset() in that it fills with a uint32_t instead
 835 * of a byte.  Remember that @count is the number of uint32_ts to
 836 * store, not the number of bytes.
 837 */
 838void *memset32(uint32_t *s, uint32_t v, size_t count)
 839{
 840	uint32_t *xs = s;
 841
 842	while (count--)
 843		*xs++ = v;
 844	return s;
 845}
 846EXPORT_SYMBOL(memset32);
 847#endif
 848
 849#ifndef __HAVE_ARCH_MEMSET64
 850/**
 851 * memset64() - Fill a memory area with a uint64_t
 852 * @s: Pointer to the start of the area.
 853 * @v: The value to fill the area with
 854 * @count: The number of values to store
 855 *
 856 * Differs from memset() in that it fills with a uint64_t instead
 857 * of a byte.  Remember that @count is the number of uint64_ts to
 858 * store, not the number of bytes.
 859 */
 860void *memset64(uint64_t *s, uint64_t v, size_t count)
 861{
 862	uint64_t *xs = s;
 863
 864	while (count--)
 865		*xs++ = v;
 866	return s;
 867}
 868EXPORT_SYMBOL(memset64);
 869#endif
 870
 871#ifndef __HAVE_ARCH_MEMCPY
 872/**
 873 * memcpy - Copy one area of memory to another
 874 * @dest: Where to copy to
 875 * @src: Where to copy from
 876 * @count: The size of the area.
 877 *
 878 * You should not use this function to access IO space, use memcpy_toio()
 879 * or memcpy_fromio() instead.
 880 */
 881void *memcpy(void *dest, const void *src, size_t count)
 882{
 883	char *tmp = dest;
 884	const char *s = src;
 885
 886	while (count--)
 887		*tmp++ = *s++;
 888	return dest;
 889}
 890EXPORT_SYMBOL(memcpy);
 891#endif
 892
 893#ifndef __HAVE_ARCH_MEMMOVE
 894/**
 895 * memmove - Copy one area of memory to another
 896 * @dest: Where to copy to
 897 * @src: Where to copy from
 898 * @count: The size of the area.
 899 *
 900 * Unlike memcpy(), memmove() copes with overlapping areas.
 901 */
 902void *memmove(void *dest, const void *src, size_t count)
 903{
 904	char *tmp;
 905	const char *s;
 906
 907	if (dest <= src) {
 908		tmp = dest;
 909		s = src;
 910		while (count--)
 911			*tmp++ = *s++;
 912	} else {
 913		tmp = dest;
 914		tmp += count;
 915		s = src;
 916		s += count;
 917		while (count--)
 918			*--tmp = *--s;
 919	}
 920	return dest;
 921}
 922EXPORT_SYMBOL(memmove);
 923#endif
 924
 925#ifndef __HAVE_ARCH_MEMCMP
 926/**
 927 * memcmp - Compare two areas of memory
 928 * @cs: One area of memory
 929 * @ct: Another area of memory
 930 * @count: The size of the area.
 931 */
 932#undef memcmp
 933__visible int memcmp(const void *cs, const void *ct, size_t count)
 934{
 935	const unsigned char *su1, *su2;
 936	int res = 0;
 937
 938	for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 939		if ((res = *su1 - *su2) != 0)
 940			break;
 941	return res;
 942}
 943EXPORT_SYMBOL(memcmp);
 944#endif
 945
 946#ifndef __HAVE_ARCH_BCMP
 947/**
 948 * bcmp - returns 0 if and only if the buffers have identical contents.
 949 * @a: pointer to first buffer.
 950 * @b: pointer to second buffer.
 951 * @len: size of buffers.
 952 *
 953 * The sign or magnitude of a non-zero return value has no particular
 954 * meaning, and architectures may implement their own more efficient bcmp(). So
 955 * while this particular implementation is a simple (tail) call to memcmp, do
 956 * not rely on anything but whether the return value is zero or non-zero.
 957 */
 958int bcmp(const void *a, const void *b, size_t len)
 959{
 960	return memcmp(a, b, len);
 961}
 962EXPORT_SYMBOL(bcmp);
 963#endif
 964
 965#ifndef __HAVE_ARCH_MEMSCAN
 966/**
 967 * memscan - Find a character in an area of memory.
 968 * @addr: The memory area
 969 * @c: The byte to search for
 970 * @size: The size of the area.
 971 *
 972 * returns the address of the first occurrence of @c, or 1 byte past
 973 * the area if @c is not found
 974 */
 975void *memscan(void *addr, int c, size_t size)
 976{
 977	unsigned char *p = addr;
 978
 979	while (size) {
 980		if (*p == (unsigned char)c)
 981			return (void *)p;
 982		p++;
 983		size--;
 984	}
 985  	return (void *)p;
 986}
 987EXPORT_SYMBOL(memscan);
 988#endif
 989
 990#ifndef __HAVE_ARCH_STRSTR
 991/**
 992 * strstr - Find the first substring in a %NUL terminated string
 993 * @s1: The string to be searched
 994 * @s2: The string to search for
 995 */
 996char *strstr(const char *s1, const char *s2)
 997{
 998	size_t l1, l2;
 999
1000	l2 = strlen(s2);
1001	if (!l2)
1002		return (char *)s1;
1003	l1 = strlen(s1);
1004	while (l1 >= l2) {
1005		l1--;
1006		if (!memcmp(s1, s2, l2))
1007			return (char *)s1;
1008		s1++;
1009	}
1010	return NULL;
1011}
1012EXPORT_SYMBOL(strstr);
1013#endif
1014
1015#ifndef __HAVE_ARCH_STRNSTR
1016/**
1017 * strnstr - Find the first substring in a length-limited string
1018 * @s1: The string to be searched
1019 * @s2: The string to search for
1020 * @len: the maximum number of characters to search
1021 */
1022char *strnstr(const char *s1, const char *s2, size_t len)
1023{
1024	size_t l2;
1025
1026	l2 = strlen(s2);
1027	if (!l2)
1028		return (char *)s1;
1029	while (len >= l2) {
1030		len--;
1031		if (!memcmp(s1, s2, l2))
1032			return (char *)s1;
1033		s1++;
1034	}
1035	return NULL;
1036}
1037EXPORT_SYMBOL(strnstr);
1038#endif
1039
1040#ifndef __HAVE_ARCH_MEMCHR
1041/**
1042 * memchr - Find a character in an area of memory.
1043 * @s: The memory area
1044 * @c: The byte to search for
1045 * @n: The size of the area.
1046 *
1047 * returns the address of the first occurrence of @c, or %NULL
1048 * if @c is not found
1049 */
1050void *memchr(const void *s, int c, size_t n)
1051{
1052	const unsigned char *p = s;
1053	while (n-- != 0) {
1054        	if ((unsigned char)c == *p++) {
1055			return (void *)(p - 1);
1056		}
1057	}
1058	return NULL;
1059}
1060EXPORT_SYMBOL(memchr);
1061#endif
1062
1063static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
1064{
1065	while (bytes) {
1066		if (*start != value)
1067			return (void *)start;
1068		start++;
1069		bytes--;
1070	}
1071	return NULL;
1072}
1073
1074/**
1075 * memchr_inv - Find an unmatching character in an area of memory.
1076 * @start: The memory area
1077 * @c: Find a character other than c
1078 * @bytes: The size of the area.
1079 *
1080 * returns the address of the first character other than @c, or %NULL
1081 * if the whole buffer contains just @c.
1082 */
1083void *memchr_inv(const void *start, int c, size_t bytes)
1084{
1085	u8 value = c;
1086	u64 value64;
1087	unsigned int words, prefix;
1088
1089	if (bytes <= 16)
1090		return check_bytes8(start, value, bytes);
1091
1092	value64 = value;
1093#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64
1094	value64 *= 0x0101010101010101ULL;
1095#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER)
1096	value64 *= 0x01010101;
1097	value64 |= value64 << 32;
1098#else
1099	value64 |= value64 << 8;
1100	value64 |= value64 << 16;
1101	value64 |= value64 << 32;
1102#endif
1103
1104	prefix = (unsigned long)start % 8;
1105	if (prefix) {
1106		u8 *r;
1107
1108		prefix = 8 - prefix;
1109		r = check_bytes8(start, value, prefix);
1110		if (r)
1111			return r;
1112		start += prefix;
1113		bytes -= prefix;
1114	}
1115
1116	words = bytes / 8;
1117
1118	while (words) {
1119		if (*(u64 *)start != value64)
1120			return check_bytes8(start, value, 8);
1121		start += 8;
1122		words--;
1123	}
1124
1125	return check_bytes8(start, value, bytes % 8);
1126}
1127EXPORT_SYMBOL(memchr_inv);
1128
1129/**
1130 * strreplace - Replace all occurrences of character in string.
1131 * @s: The string to operate on.
1132 * @old: The character being replaced.
1133 * @new: The character @old is replaced with.
1134 *
1135 * Returns pointer to the nul byte at the end of @s.
1136 */
1137char *strreplace(char *s, char old, char new)
1138{
1139	for (; *s; ++s)
1140		if (*s == old)
1141			*s = new;
1142	return s;
1143}
1144EXPORT_SYMBOL(strreplace);
1145
1146void fortify_panic(const char *name)
1147{
1148	pr_emerg("detected buffer overflow in %s\n", name);
1149	BUG();
1150}
1151EXPORT_SYMBOL(fortify_panic);