LCOV - code coverage report
Current view: top level - lib - string.c (source / functions) Hit Total Coverage
Test: Real Lines: 175 230 76.1 %
Date: 2020-10-17 15:46:43 Functions: 1 34 2.9 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14