Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Paul Gortmaker | 8bc3bcc | 2011-11-16 21:29:17 -0500 | [diff] [blame] | 26 | #include <linux/kernel.h> |
| 27 | #include <linux/export.h> |
Paul Gortmaker | 50af5ea | 2012-01-20 18:35:53 -0500 | [diff] [blame] | 28 | #include <linux/bug.h> |
Paul Gortmaker | 8bc3bcc | 2011-11-16 21:29:17 -0500 | [diff] [blame] | 29 | #include <linux/errno.h> |
Alexander Shishkin | ce76d93 | 2018-10-05 15:43:05 +0300 | [diff] [blame] | 30 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 32 | #include <asm/byteorder.h> |
| 33 | #include <asm/word-at-a-time.h> |
| 34 | #include <asm/page.h> |
| 35 | |
Rasmus Villemoes | cd514e7 | 2014-10-13 15:54:25 -0700 | [diff] [blame] | 36 | #ifndef __HAVE_ARCH_STRNCASECMP |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | /** |
Rasmus Villemoes | cd514e7 | 2014-10-13 15:54:25 -0700 | [diff] [blame] | 38 | * strncasecmp - Case insensitive, length-limited string comparison |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | * @s1: One string |
| 40 | * @s2: The other string |
| 41 | * @len: the maximum number of characters to compare |
| 42 | */ |
Rasmus Villemoes | cd514e7 | 2014-10-13 15:54:25 -0700 | [diff] [blame] | 43 | int strncasecmp(const char *s1, const char *s2, size_t len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | { |
| 45 | /* Yes, Virginia, it had better be unsigned */ |
| 46 | unsigned char c1, c2; |
| 47 | |
André Goddard Rosa | a11d2b6 | 2010-03-05 13:43:11 -0800 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | return (int)c1 - (int)c2; |
| 64 | } |
Rasmus Villemoes | cd514e7 | 2014-10-13 15:54:25 -0700 | [diff] [blame] | 65 | EXPORT_SYMBOL(strncasecmp); |
| 66 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | |
David S. Miller | ded220b | 2007-03-29 01:18:42 -0700 | [diff] [blame] | 68 | #ifndef __HAVE_ARCH_STRCASECMP |
| 69 | int 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 | } |
| 79 | EXPORT_SYMBOL(strcasecmp); |
| 80 | #endif |
| 81 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Paolo 'Blaisorblade' Giarrusso | 0c28130 | 2005-05-05 16:15:17 -0700 | [diff] [blame] | 88 | #undef strcpy |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 89 | char *strcpy(char *dest, const char *src) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | { |
| 91 | char *tmp = dest; |
| 92 | |
| 93 | while ((*dest++ = *src++) != '\0') |
| 94 | /* nothing */; |
| 95 | return tmp; |
| 96 | } |
| 97 | EXPORT_SYMBOL(strcpy); |
| 98 | #endif |
| 99 | |
| 100 | #ifndef __HAVE_ARCH_STRNCPY |
| 101 | /** |
Dan Carpenter | 0046dd9 | 2014-06-04 16:11:47 -0700 | [diff] [blame] | 102 | * strncpy - Copy a length-limited, C-string |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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. |
walter harms | 2527952 | 2005-05-05 16:16:20 -0700 | [diff] [blame] | 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 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 114 | char *strncpy(char *dest, const char *src, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | { |
| 116 | char *tmp = dest; |
| 117 | |
| 118 | while (count) { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 119 | if ((*tmp = *src) != 0) |
| 120 | src++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | tmp++; |
| 122 | count--; |
| 123 | } |
| 124 | return dest; |
| 125 | } |
| 126 | EXPORT_SYMBOL(strncpy); |
| 127 | #endif |
| 128 | |
| 129 | #ifndef __HAVE_ARCH_STRLCPY |
| 130 | /** |
Dan Carpenter | 0046dd9 | 2014-06-04 16:11:47 -0700 | [diff] [blame] | 131 | * strlcpy - Copy a C-string into a sized buffer |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | * @dest: Where to copy the string to |
| 133 | * @src: Where to copy the string from |
| 134 | * @size: size of destination buffer |
| 135 | * |
mchehab@s-opensource.com | 0e056eb | 2017-03-30 17:11:36 -0300 | [diff] [blame] | 136 | * Compatible with ``*BSD``: the result is always a valid |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | size_t strlcpy(char *dest, const char *src, size_t size) |
| 142 | { |
| 143 | size_t ret = strlen(src); |
| 144 | |
| 145 | if (size) { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 146 | size_t len = (ret >= size) ? size - 1 : ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | memcpy(dest, src, len); |
| 148 | dest[len] = '\0'; |
| 149 | } |
| 150 | return ret; |
| 151 | } |
| 152 | EXPORT_SYMBOL(strlcpy); |
| 153 | #endif |
| 154 | |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 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 | * |
Tobin C. Harding | 458a3bf | 2019-04-05 12:58:58 +1100 | [diff] [blame] | 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. |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 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 |
Tobin C. Harding | 458a3bf | 2019-04-05 12:58:58 +1100 | [diff] [blame] | 174 | * zeroed. If zeroing is desired please use strscpy_pad(). |
| 175 | * |
Joe Perches | 917cda2 | 2019-09-25 16:46:13 -0700 | [diff] [blame] | 176 | * Returns: |
| 177 | * * The number of characters copied (not including the trailing %NUL) |
| 178 | * * -E2BIG if count is 0 or @src was truncated. |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 179 | */ |
| 180 | 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 | |
Kees Cook | 9a15646 | 2019-09-25 16:46:20 -0700 | [diff] [blame] | 186 | if (count == 0 || WARN_ON_ONCE(count > INT_MAX)) |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 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 | if ((long)src & (sizeof(long) - 1)) { |
| 195 | size_t limit = PAGE_SIZE - ((long)src & (PAGE_SIZE - 1)); |
| 196 | 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 | while (max >= sizeof(unsigned long)) { |
| 206 | unsigned long c, data; |
| 207 | |
Andrey Ryabinin | 1a3241f | 2018-02-01 21:00:50 +0300 | [diff] [blame] | 208 | c = read_word_at_a_time(src+res); |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 209 | if (has_zero(c, &data, &constants)) { |
| 210 | data = prep_zero_mask(c, data, &constants); |
| 211 | data = create_zero_mask(data); |
Chris Metcalf | 990486c | 2015-10-06 12:37:41 -0400 | [diff] [blame] | 212 | *(unsigned long *)(dest+res) = c & zero_bytemask(data); |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 213 | return res + find_zero(data); |
| 214 | } |
Chris Metcalf | 990486c | 2015-10-06 12:37:41 -0400 | [diff] [blame] | 215 | *(unsigned long *)(dest+res) = c; |
Chris Metcalf | 30035e4 | 2015-04-29 12:52:04 -0400 | [diff] [blame] | 216 | res += sizeof(unsigned long); |
| 217 | count -= sizeof(unsigned long); |
| 218 | max -= sizeof(unsigned long); |
| 219 | } |
| 220 | |
| 221 | while (count) { |
| 222 | char c; |
| 223 | |
| 224 | c = src[res]; |
| 225 | dest[res] = c; |
| 226 | if (!c) |
| 227 | return res; |
| 228 | res++; |
| 229 | count--; |
| 230 | } |
| 231 | |
| 232 | /* Hit buffer length without finding a NUL; force NUL-termination. */ |
| 233 | if (res) |
| 234 | dest[res-1] = '\0'; |
| 235 | |
| 236 | return -E2BIG; |
| 237 | } |
| 238 | EXPORT_SYMBOL(strscpy); |
| 239 | #endif |
| 240 | |
Tobin C. Harding | 458a3bf | 2019-04-05 12:58:58 +1100 | [diff] [blame] | 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 | * |
Joe Perches | 917cda2 | 2019-09-25 16:46:13 -0700 | [diff] [blame] | 257 | * Returns: |
| 258 | * * The number of characters copied (not including the trailing %NUL) |
| 259 | * * -E2BIG if count is 0 or @src was truncated. |
Tobin C. Harding | 458a3bf | 2019-04-05 12:58:58 +1100 | [diff] [blame] | 260 | */ |
| 261 | ssize_t strscpy_pad(char *dest, const char *src, size_t count) |
| 262 | { |
| 263 | ssize_t written; |
| 264 | |
| 265 | written = strscpy(dest, src, count); |
| 266 | if (written < 0 || written == count - 1) |
| 267 | return written; |
| 268 | |
| 269 | memset(dest + written + 1, 0, count - written - 1); |
| 270 | |
| 271 | return written; |
| 272 | } |
| 273 | EXPORT_SYMBOL(strscpy_pad); |
| 274 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Paolo 'Blaisorblade' Giarrusso | 0c28130 | 2005-05-05 16:15:17 -0700 | [diff] [blame] | 281 | #undef strcat |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 282 | char *strcat(char *dest, const char *src) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | { |
| 284 | char *tmp = dest; |
| 285 | |
| 286 | while (*dest) |
| 287 | dest++; |
| 288 | while ((*dest++ = *src++) != '\0') |
| 289 | ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | return tmp; |
| 291 | } |
| 292 | EXPORT_SYMBOL(strcat); |
| 293 | #endif |
| 294 | |
| 295 | #ifndef __HAVE_ARCH_STRNCAT |
| 296 | /** |
Dan Carpenter | 0046dd9 | 2014-06-04 16:11:47 -0700 | [diff] [blame] | 297 | * strncat - Append a length-limited, C-string to another |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | * |
Robert P. J. Day | 72fd4a3 | 2007-02-10 01:45:59 -0800 | [diff] [blame] | 302 | * Note that in contrast to strncpy(), strncat() ensures the result is |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | * terminated. |
| 304 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 305 | char *strncat(char *dest, const char *src, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | { |
| 307 | char *tmp = dest; |
| 308 | |
| 309 | if (count) { |
| 310 | while (*dest) |
| 311 | dest++; |
| 312 | while ((*dest++ = *src++) != 0) { |
| 313 | if (--count == 0) { |
| 314 | *dest = '\0'; |
| 315 | break; |
| 316 | } |
| 317 | } |
| 318 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | return tmp; |
| 320 | } |
| 321 | EXPORT_SYMBOL(strncat); |
| 322 | #endif |
| 323 | |
| 324 | #ifndef __HAVE_ARCH_STRLCAT |
| 325 | /** |
Dan Carpenter | 0046dd9 | 2014-06-04 16:11:47 -0700 | [diff] [blame] | 326 | * strlcat - Append a length-limited, C-string to another |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | 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 | size_t res = dsize + len; |
| 336 | |
| 337 | /* This would be a bug */ |
| 338 | BUG_ON(dsize >= count); |
| 339 | |
| 340 | dest += dsize; |
| 341 | count -= dsize; |
| 342 | if (len >= count) |
| 343 | len = count-1; |
| 344 | memcpy(dest, src, len); |
| 345 | dest[len] = 0; |
| 346 | 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 | */ |
Paolo 'Blaisorblade' Giarrusso | 0c28130 | 2005-05-05 16:15:17 -0700 | [diff] [blame] | 357 | #undef strcmp |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 358 | int strcmp(const char *cs, const char *ct) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | { |
Linus Torvalds | a414f01 | 2009-11-18 22:31:52 +0100 | [diff] [blame] | 360 | unsigned char c1, c2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | |
| 362 | while (1) { |
Linus Torvalds | a414f01 | 2009-11-18 22:31:52 +0100 | [diff] [blame] | 363 | c1 = *cs++; |
| 364 | c2 = *ct++; |
| 365 | if (c1 != c2) |
| 366 | return c1 < c2 ? -1 : 1; |
| 367 | if (!c1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | break; |
| 369 | } |
Linus Torvalds | a414f01 | 2009-11-18 22:31:52 +0100 | [diff] [blame] | 370 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 382 | int strncmp(const char *cs, const char *ct, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | { |
Linus Torvalds | a414f01 | 2009-11-18 22:31:52 +0100 | [diff] [blame] | 384 | unsigned char c1, c2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | |
| 386 | while (count) { |
Linus Torvalds | a414f01 | 2009-11-18 22:31:52 +0100 | [diff] [blame] | 387 | c1 = *cs++; |
| 388 | c2 = *ct++; |
| 389 | if (c1 != c2) |
| 390 | return c1 < c2 ? -1 : 1; |
| 391 | if (!c1) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | break; |
| 393 | count--; |
| 394 | } |
Linus Torvalds | a414f01 | 2009-11-18 22:31:52 +0100 | [diff] [blame] | 395 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Peter Rosin | b097571 | 2019-07-16 16:27:15 -0700 | [diff] [blame] | 405 | * |
| 406 | * Note that the %NUL-terminator is considered part of the string, and can |
| 407 | * be searched for. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 408 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 409 | char *strchr(const char *s, int c) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 411 | for (; *s != (char)c; ++s) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | if (*s == '\0') |
| 413 | return NULL; |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 414 | return (char *)s; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | } |
| 416 | EXPORT_SYMBOL(strchr); |
| 417 | #endif |
| 418 | |
Grant Likely | 11d200e | 2014-03-14 17:00:14 +0000 | [diff] [blame] | 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 | char *strchrnul(const char *s, int c) |
| 429 | { |
| 430 | while (*s && *s != (char)c) |
| 431 | s++; |
| 432 | return (char *)s; |
| 433 | } |
| 434 | EXPORT_SYMBOL(strchrnul); |
| 435 | #endif |
| 436 | |
Yury Norov | 0bee0ce | 2020-02-03 17:37:20 -0800 | [diff] [blame] | 437 | /** |
| 438 | * strnchrnul - Find and return a character in a length limited string, |
| 439 | * or end of string |
| 440 | * @s: The string to be searched |
| 441 | * @count: The number of characters to be searched |
| 442 | * @c: The character to search for |
| 443 | * |
| 444 | * Returns pointer to the first occurrence of 'c' in s. If c is not found, |
| 445 | * then return a pointer to the last character of the string. |
| 446 | */ |
| 447 | char *strnchrnul(const char *s, size_t count, int c) |
| 448 | { |
| 449 | while (count-- && *s && *s != (char)c) |
| 450 | s++; |
| 451 | return (char *)s; |
| 452 | } |
| 453 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | #ifndef __HAVE_ARCH_STRRCHR |
| 455 | /** |
| 456 | * strrchr - Find the last occurrence of a character in a string |
| 457 | * @s: The string to be searched |
| 458 | * @c: The character to search for |
| 459 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 460 | char *strrchr(const char *s, int c) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | { |
Rasmus Villemoes | 8da53d4 | 2015-02-13 14:36:44 -0800 | [diff] [blame] | 462 | const char *last = NULL; |
| 463 | do { |
| 464 | if (*s == (char)c) |
| 465 | last = s; |
| 466 | } while (*s++); |
| 467 | return (char *)last; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | } |
| 469 | EXPORT_SYMBOL(strrchr); |
| 470 | #endif |
| 471 | |
| 472 | #ifndef __HAVE_ARCH_STRNCHR |
| 473 | /** |
| 474 | * strnchr - Find a character in a length limited string |
| 475 | * @s: The string to be searched |
| 476 | * @count: The number of characters to be searched |
| 477 | * @c: The character to search for |
Peter Rosin | b097571 | 2019-07-16 16:27:15 -0700 | [diff] [blame] | 478 | * |
| 479 | * Note that the %NUL-terminator is considered part of the string, and can |
| 480 | * be searched for. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 481 | */ |
| 482 | char *strnchr(const char *s, size_t count, int c) |
| 483 | { |
Peter Rosin | b097571 | 2019-07-16 16:27:15 -0700 | [diff] [blame] | 484 | while (count--) { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 485 | if (*s == (char)c) |
| 486 | return (char *)s; |
Peter Rosin | b097571 | 2019-07-16 16:27:15 -0700 | [diff] [blame] | 487 | if (*s++ == '\0') |
| 488 | break; |
| 489 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | return NULL; |
| 491 | } |
| 492 | EXPORT_SYMBOL(strnchr); |
| 493 | #endif |
| 494 | |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 495 | /** |
Randy Dunlap | a6cd13f | 2009-12-21 14:37:22 -0800 | [diff] [blame] | 496 | * skip_spaces - Removes leading whitespace from @str. |
| 497 | * @str: The string to be stripped. |
André Goddard Rosa | f653398 | 2009-12-14 18:01:04 -0800 | [diff] [blame] | 498 | * |
Randy Dunlap | a6cd13f | 2009-12-21 14:37:22 -0800 | [diff] [blame] | 499 | * Returns a pointer to the first non-whitespace character in @str. |
André Goddard Rosa | f653398 | 2009-12-14 18:01:04 -0800 | [diff] [blame] | 500 | */ |
| 501 | char *skip_spaces(const char *str) |
| 502 | { |
| 503 | while (isspace(*str)) |
| 504 | ++str; |
| 505 | return (char *)str; |
| 506 | } |
| 507 | EXPORT_SYMBOL(skip_spaces); |
| 508 | |
| 509 | /** |
KOSAKI Motohiro | ca54cb8 | 2009-12-14 18:01:15 -0800 | [diff] [blame] | 510 | * strim - Removes leading and trailing whitespace from @s. |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 511 | * @s: The string to be stripped. |
| 512 | * |
| 513 | * Note that the first trailing whitespace is replaced with a %NUL-terminator |
| 514 | * in the given string @s. Returns a pointer to the first non-whitespace |
| 515 | * character in @s. |
| 516 | */ |
KOSAKI Motohiro | ca54cb8 | 2009-12-14 18:01:15 -0800 | [diff] [blame] | 517 | char *strim(char *s) |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 518 | { |
| 519 | size_t size; |
| 520 | char *end; |
| 521 | |
| 522 | size = strlen(s); |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 523 | if (!size) |
| 524 | return s; |
| 525 | |
| 526 | end = s + size - 1; |
Michael Holzheu | 6e6d9fa | 2006-10-28 10:38:47 -0700 | [diff] [blame] | 527 | while (end >= s && isspace(*end)) |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 528 | end--; |
| 529 | *(end + 1) = '\0'; |
| 530 | |
Michael Holzheu | 66f6958 | 2011-10-31 17:12:37 -0700 | [diff] [blame] | 531 | return skip_spaces(s); |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 532 | } |
KOSAKI Motohiro | ca54cb8 | 2009-12-14 18:01:15 -0800 | [diff] [blame] | 533 | EXPORT_SYMBOL(strim); |
Pekka Enberg | 481fad4 | 2006-06-23 02:05:44 -0700 | [diff] [blame] | 534 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | #ifndef __HAVE_ARCH_STRLEN |
| 536 | /** |
| 537 | * strlen - Find the length of a string |
| 538 | * @s: The string to be sized |
| 539 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 540 | size_t strlen(const char *s) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | { |
| 542 | const char *sc; |
| 543 | |
| 544 | for (sc = s; *sc != '\0'; ++sc) |
| 545 | /* nothing */; |
| 546 | return sc - s; |
| 547 | } |
| 548 | EXPORT_SYMBOL(strlen); |
| 549 | #endif |
| 550 | |
| 551 | #ifndef __HAVE_ARCH_STRNLEN |
| 552 | /** |
| 553 | * strnlen - Find the length of a length-limited string |
| 554 | * @s: The string to be sized |
| 555 | * @count: The maximum number of bytes to search |
| 556 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 557 | size_t strnlen(const char *s, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 558 | { |
| 559 | const char *sc; |
| 560 | |
| 561 | for (sc = s; count-- && *sc != '\0'; ++sc) |
| 562 | /* nothing */; |
| 563 | return sc - s; |
| 564 | } |
| 565 | EXPORT_SYMBOL(strnlen); |
| 566 | #endif |
| 567 | |
| 568 | #ifndef __HAVE_ARCH_STRSPN |
| 569 | /** |
Robert P. J. Day | 72fd4a3 | 2007-02-10 01:45:59 -0800 | [diff] [blame] | 570 | * strspn - Calculate the length of the initial substring of @s which only contain letters in @accept |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 571 | * @s: The string to be searched |
| 572 | * @accept: The string to search for |
| 573 | */ |
| 574 | size_t strspn(const char *s, const char *accept) |
| 575 | { |
| 576 | const char *p; |
| 577 | const char *a; |
| 578 | size_t count = 0; |
| 579 | |
| 580 | for (p = s; *p != '\0'; ++p) { |
| 581 | for (a = accept; *a != '\0'; ++a) { |
| 582 | if (*p == *a) |
| 583 | break; |
| 584 | } |
| 585 | if (*a == '\0') |
| 586 | return count; |
| 587 | ++count; |
| 588 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 589 | return count; |
| 590 | } |
| 591 | |
| 592 | EXPORT_SYMBOL(strspn); |
| 593 | #endif |
| 594 | |
Kyle McMartin | 8833d32 | 2006-04-10 22:53:57 -0700 | [diff] [blame] | 595 | #ifndef __HAVE_ARCH_STRCSPN |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 596 | /** |
Robert P. J. Day | 72fd4a3 | 2007-02-10 01:45:59 -0800 | [diff] [blame] | 597 | * strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 598 | * @s: The string to be searched |
| 599 | * @reject: The string to avoid |
| 600 | */ |
| 601 | size_t strcspn(const char *s, const char *reject) |
| 602 | { |
| 603 | const char *p; |
| 604 | const char *r; |
| 605 | size_t count = 0; |
| 606 | |
| 607 | for (p = s; *p != '\0'; ++p) { |
| 608 | for (r = reject; *r != '\0'; ++r) { |
| 609 | if (*p == *r) |
| 610 | return count; |
| 611 | } |
| 612 | ++count; |
| 613 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 614 | return count; |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 615 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 616 | EXPORT_SYMBOL(strcspn); |
Kyle McMartin | 8833d32 | 2006-04-10 22:53:57 -0700 | [diff] [blame] | 617 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 618 | |
| 619 | #ifndef __HAVE_ARCH_STRPBRK |
| 620 | /** |
| 621 | * strpbrk - Find the first occurrence of a set of characters |
| 622 | * @cs: The string to be searched |
| 623 | * @ct: The characters to search for |
| 624 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 625 | char *strpbrk(const char *cs, const char *ct) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 626 | { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 627 | const char *sc1, *sc2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 628 | |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 629 | for (sc1 = cs; *sc1 != '\0'; ++sc1) { |
| 630 | for (sc2 = ct; *sc2 != '\0'; ++sc2) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 631 | if (*sc1 == *sc2) |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 632 | return (char *)sc1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 633 | } |
| 634 | } |
| 635 | return NULL; |
| 636 | } |
Kyle McMartin | 894b577 | 2006-04-10 22:53:56 -0700 | [diff] [blame] | 637 | EXPORT_SYMBOL(strpbrk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 638 | #endif |
| 639 | |
| 640 | #ifndef __HAVE_ARCH_STRSEP |
| 641 | /** |
| 642 | * strsep - Split a string into tokens |
| 643 | * @s: The string to be searched |
| 644 | * @ct: The characters to search for |
| 645 | * |
| 646 | * strsep() updates @s to point after the token, ready for the next call. |
| 647 | * |
| 648 | * It returns empty tokens, too, behaving exactly like the libc function |
| 649 | * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. |
| 650 | * Same semantics, slimmer shape. ;) |
| 651 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 652 | char *strsep(char **s, const char *ct) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 653 | { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 654 | char *sbegin = *s; |
| 655 | char *end; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 656 | |
| 657 | if (sbegin == NULL) |
| 658 | return NULL; |
| 659 | |
| 660 | end = strpbrk(sbegin, ct); |
| 661 | if (end) |
| 662 | *end++ = '\0'; |
| 663 | *s = end; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 664 | return sbegin; |
| 665 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 666 | EXPORT_SYMBOL(strsep); |
| 667 | #endif |
| 668 | |
David Brownell | 34990cf | 2008-05-01 04:34:42 -0700 | [diff] [blame] | 669 | /** |
| 670 | * sysfs_streq - return true if strings are equal, modulo trailing newline |
| 671 | * @s1: one string |
| 672 | * @s2: another string |
| 673 | * |
| 674 | * This routine returns true iff two strings are equal, treating both |
| 675 | * NUL and newline-then-NUL as equivalent string terminations. It's |
| 676 | * geared for use with sysfs input strings, which generally terminate |
| 677 | * with newlines but are compared against values without newlines. |
| 678 | */ |
| 679 | bool sysfs_streq(const char *s1, const char *s2) |
| 680 | { |
| 681 | while (*s1 && *s1 == *s2) { |
| 682 | s1++; |
| 683 | s2++; |
| 684 | } |
| 685 | |
| 686 | if (*s1 == *s2) |
| 687 | return true; |
| 688 | if (!*s1 && *s2 == '\n' && !s2[1]) |
| 689 | return true; |
| 690 | if (*s1 == '\n' && !s1[1] && !*s2) |
| 691 | return true; |
| 692 | return false; |
| 693 | } |
| 694 | EXPORT_SYMBOL(sysfs_streq); |
| 695 | |
Jonathan Cameron | d0f1fed | 2011-04-19 12:43:45 +0100 | [diff] [blame] | 696 | /** |
Andy Shevchenko | 56b0608 | 2016-03-17 14:22:14 -0700 | [diff] [blame] | 697 | * match_string - matches given string in an array |
| 698 | * @array: array of strings |
| 699 | * @n: number of strings in the array or -1 for NULL terminated arrays |
| 700 | * @string: string to match with |
| 701 | * |
Alexandru Ardelean | c11d3fa | 2020-02-20 20:04:21 -0800 | [diff] [blame] | 702 | * This routine will look for a string in an array of strings up to the |
| 703 | * n-th element in the array or until the first NULL element. |
| 704 | * |
| 705 | * Historically the value of -1 for @n, was used to search in arrays that |
| 706 | * are NULL terminated. However, the function does not make a distinction |
| 707 | * when finishing the search: either @n elements have been compared OR |
| 708 | * the first NULL element was found. |
| 709 | * |
Andy Shevchenko | 56b0608 | 2016-03-17 14:22:14 -0700 | [diff] [blame] | 710 | * Return: |
| 711 | * index of a @string in the @array if matches, or %-EINVAL otherwise. |
| 712 | */ |
| 713 | int match_string(const char * const *array, size_t n, const char *string) |
| 714 | { |
| 715 | int index; |
| 716 | const char *item; |
| 717 | |
| 718 | for (index = 0; index < n; index++) { |
| 719 | item = array[index]; |
| 720 | if (!item) |
| 721 | break; |
| 722 | if (!strcmp(item, string)) |
| 723 | return index; |
| 724 | } |
| 725 | |
| 726 | return -EINVAL; |
| 727 | } |
| 728 | EXPORT_SYMBOL(match_string); |
| 729 | |
Heikki Krogerus | e1fe7b6 | 2017-03-21 13:56:46 +0200 | [diff] [blame] | 730 | /** |
| 731 | * __sysfs_match_string - matches given string in an array |
| 732 | * @array: array of strings |
| 733 | * @n: number of strings in the array or -1 for NULL terminated arrays |
| 734 | * @str: string to match with |
| 735 | * |
| 736 | * Returns index of @str in the @array or -EINVAL, just like match_string(). |
| 737 | * Uses sysfs_streq instead of strcmp for matching. |
Alexandru Ardelean | c11d3fa | 2020-02-20 20:04:21 -0800 | [diff] [blame] | 738 | * |
| 739 | * This routine will look for a string in an array of strings up to the |
| 740 | * n-th element in the array or until the first NULL element. |
| 741 | * |
| 742 | * Historically the value of -1 for @n, was used to search in arrays that |
| 743 | * are NULL terminated. However, the function does not make a distinction |
| 744 | * when finishing the search: either @n elements have been compared OR |
| 745 | * the first NULL element was found. |
Heikki Krogerus | e1fe7b6 | 2017-03-21 13:56:46 +0200 | [diff] [blame] | 746 | */ |
| 747 | int __sysfs_match_string(const char * const *array, size_t n, const char *str) |
| 748 | { |
| 749 | const char *item; |
| 750 | int index; |
| 751 | |
| 752 | for (index = 0; index < n; index++) { |
| 753 | item = array[index]; |
| 754 | if (!item) |
| 755 | break; |
| 756 | if (sysfs_streq(item, str)) |
| 757 | return index; |
| 758 | } |
| 759 | |
| 760 | return -EINVAL; |
| 761 | } |
| 762 | EXPORT_SYMBOL(__sysfs_match_string); |
| 763 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 764 | #ifndef __HAVE_ARCH_MEMSET |
| 765 | /** |
| 766 | * memset - Fill a region of memory with the given value |
| 767 | * @s: Pointer to the start of the area. |
| 768 | * @c: The byte to fill the area with |
| 769 | * @count: The size of the area. |
| 770 | * |
| 771 | * Do not use memset() to access IO space, use memset_io() instead. |
| 772 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 773 | void *memset(void *s, int c, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 774 | { |
Jesper Juhl | 850b924 | 2005-10-30 15:02:13 -0800 | [diff] [blame] | 775 | char *xs = s; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 776 | |
| 777 | while (count--) |
| 778 | *xs++ = c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 779 | return s; |
| 780 | } |
| 781 | EXPORT_SYMBOL(memset); |
| 782 | #endif |
| 783 | |
Matthew Wilcox | 3b3c4ba | 2017-09-08 16:13:48 -0700 | [diff] [blame] | 784 | #ifndef __HAVE_ARCH_MEMSET16 |
| 785 | /** |
| 786 | * memset16() - Fill a memory area with a uint16_t |
| 787 | * @s: Pointer to the start of the area. |
| 788 | * @v: The value to fill the area with |
| 789 | * @count: The number of values to store |
| 790 | * |
| 791 | * Differs from memset() in that it fills with a uint16_t instead |
| 792 | * of a byte. Remember that @count is the number of uint16_ts to |
| 793 | * store, not the number of bytes. |
| 794 | */ |
| 795 | void *memset16(uint16_t *s, uint16_t v, size_t count) |
| 796 | { |
| 797 | uint16_t *xs = s; |
| 798 | |
| 799 | while (count--) |
| 800 | *xs++ = v; |
| 801 | return s; |
| 802 | } |
| 803 | EXPORT_SYMBOL(memset16); |
| 804 | #endif |
| 805 | |
| 806 | #ifndef __HAVE_ARCH_MEMSET32 |
| 807 | /** |
| 808 | * memset32() - Fill a memory area with a uint32_t |
| 809 | * @s: Pointer to the start of the area. |
| 810 | * @v: The value to fill the area with |
| 811 | * @count: The number of values to store |
| 812 | * |
| 813 | * Differs from memset() in that it fills with a uint32_t instead |
| 814 | * of a byte. Remember that @count is the number of uint32_ts to |
| 815 | * store, not the number of bytes. |
| 816 | */ |
| 817 | void *memset32(uint32_t *s, uint32_t v, size_t count) |
| 818 | { |
| 819 | uint32_t *xs = s; |
| 820 | |
| 821 | while (count--) |
| 822 | *xs++ = v; |
| 823 | return s; |
| 824 | } |
| 825 | EXPORT_SYMBOL(memset32); |
| 826 | #endif |
| 827 | |
| 828 | #ifndef __HAVE_ARCH_MEMSET64 |
| 829 | /** |
| 830 | * memset64() - Fill a memory area with a uint64_t |
| 831 | * @s: Pointer to the start of the area. |
| 832 | * @v: The value to fill the area with |
| 833 | * @count: The number of values to store |
| 834 | * |
| 835 | * Differs from memset() in that it fills with a uint64_t instead |
| 836 | * of a byte. Remember that @count is the number of uint64_ts to |
| 837 | * store, not the number of bytes. |
| 838 | */ |
| 839 | void *memset64(uint64_t *s, uint64_t v, size_t count) |
| 840 | { |
| 841 | uint64_t *xs = s; |
| 842 | |
| 843 | while (count--) |
| 844 | *xs++ = v; |
| 845 | return s; |
| 846 | } |
| 847 | EXPORT_SYMBOL(memset64); |
| 848 | #endif |
| 849 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 850 | #ifndef __HAVE_ARCH_MEMCPY |
| 851 | /** |
| 852 | * memcpy - Copy one area of memory to another |
| 853 | * @dest: Where to copy to |
| 854 | * @src: Where to copy from |
| 855 | * @count: The size of the area. |
| 856 | * |
| 857 | * You should not use this function to access IO space, use memcpy_toio() |
| 858 | * or memcpy_fromio() instead. |
| 859 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 860 | void *memcpy(void *dest, const void *src, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 861 | { |
Jesper Juhl | 850b924 | 2005-10-30 15:02:13 -0800 | [diff] [blame] | 862 | char *tmp = dest; |
Jan-Benedict Glaw | 4c416ab | 2006-04-10 22:54:09 -0700 | [diff] [blame] | 863 | const char *s = src; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 864 | |
| 865 | while (count--) |
| 866 | *tmp++ = *s++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 867 | return dest; |
| 868 | } |
| 869 | EXPORT_SYMBOL(memcpy); |
| 870 | #endif |
| 871 | |
| 872 | #ifndef __HAVE_ARCH_MEMMOVE |
| 873 | /** |
| 874 | * memmove - Copy one area of memory to another |
| 875 | * @dest: Where to copy to |
| 876 | * @src: Where to copy from |
| 877 | * @count: The size of the area. |
| 878 | * |
| 879 | * Unlike memcpy(), memmove() copes with overlapping areas. |
| 880 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 881 | void *memmove(void *dest, const void *src, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 882 | { |
Paul Jackson | 82da2c3 | 2005-10-30 15:03:19 -0800 | [diff] [blame] | 883 | char *tmp; |
| 884 | const char *s; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 885 | |
| 886 | if (dest <= src) { |
Jesper Juhl | 850b924 | 2005-10-30 15:02:13 -0800 | [diff] [blame] | 887 | tmp = dest; |
| 888 | s = src; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 889 | while (count--) |
| 890 | *tmp++ = *s++; |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 891 | } else { |
Jesper Juhl | 850b924 | 2005-10-30 15:02:13 -0800 | [diff] [blame] | 892 | tmp = dest; |
| 893 | tmp += count; |
| 894 | s = src; |
| 895 | s += count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 896 | while (count--) |
| 897 | *--tmp = *--s; |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 898 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 899 | return dest; |
| 900 | } |
| 901 | EXPORT_SYMBOL(memmove); |
| 902 | #endif |
| 903 | |
| 904 | #ifndef __HAVE_ARCH_MEMCMP |
| 905 | /** |
| 906 | * memcmp - Compare two areas of memory |
| 907 | * @cs: One area of memory |
| 908 | * @ct: Another area of memory |
| 909 | * @count: The size of the area. |
| 910 | */ |
Paolo 'Blaisorblade' Giarrusso | 0c28130 | 2005-05-05 16:15:17 -0700 | [diff] [blame] | 911 | #undef memcmp |
Andi Kleen | a7330c9 | 2014-02-08 08:52:06 +0100 | [diff] [blame] | 912 | __visible int memcmp(const void *cs, const void *ct, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 913 | { |
| 914 | const unsigned char *su1, *su2; |
| 915 | int res = 0; |
| 916 | |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 917 | for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 918 | if ((res = *su1 - *su2) != 0) |
| 919 | break; |
| 920 | return res; |
| 921 | } |
| 922 | EXPORT_SYMBOL(memcmp); |
| 923 | #endif |
| 924 | |
Nick Desaulniers | 5f074f3 | 2019-04-05 18:38:45 -0700 | [diff] [blame] | 925 | #ifndef __HAVE_ARCH_BCMP |
| 926 | /** |
| 927 | * bcmp - returns 0 if and only if the buffers have identical contents. |
| 928 | * @a: pointer to first buffer. |
| 929 | * @b: pointer to second buffer. |
| 930 | * @len: size of buffers. |
| 931 | * |
| 932 | * The sign or magnitude of a non-zero return value has no particular |
| 933 | * meaning, and architectures may implement their own more efficient bcmp(). So |
| 934 | * while this particular implementation is a simple (tail) call to memcmp, do |
| 935 | * not rely on anything but whether the return value is zero or non-zero. |
| 936 | */ |
| 937 | #undef bcmp |
| 938 | int bcmp(const void *a, const void *b, size_t len) |
| 939 | { |
| 940 | return memcmp(a, b, len); |
| 941 | } |
| 942 | EXPORT_SYMBOL(bcmp); |
| 943 | #endif |
| 944 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 945 | #ifndef __HAVE_ARCH_MEMSCAN |
| 946 | /** |
| 947 | * memscan - Find a character in an area of memory. |
| 948 | * @addr: The memory area |
| 949 | * @c: The byte to search for |
| 950 | * @size: The size of the area. |
| 951 | * |
| 952 | * returns the address of the first occurrence of @c, or 1 byte past |
| 953 | * the area if @c is not found |
| 954 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 955 | void *memscan(void *addr, int c, size_t size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 956 | { |
Jesper Juhl | 850b924 | 2005-10-30 15:02:13 -0800 | [diff] [blame] | 957 | unsigned char *p = addr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 958 | |
| 959 | while (size) { |
| 960 | if (*p == c) |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 961 | return (void *)p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 962 | p++; |
| 963 | size--; |
| 964 | } |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 965 | return (void *)p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 966 | } |
| 967 | EXPORT_SYMBOL(memscan); |
| 968 | #endif |
| 969 | |
| 970 | #ifndef __HAVE_ARCH_STRSTR |
| 971 | /** |
| 972 | * strstr - Find the first substring in a %NUL terminated string |
| 973 | * @s1: The string to be searched |
| 974 | * @s2: The string to search for |
| 975 | */ |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 976 | char *strstr(const char *s1, const char *s2) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 977 | { |
Li Zefan | d5f1fb5 | 2010-01-14 10:53:55 +0800 | [diff] [blame] | 978 | size_t l1, l2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 979 | |
| 980 | l2 = strlen(s2); |
| 981 | if (!l2) |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 982 | return (char *)s1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 983 | l1 = strlen(s1); |
| 984 | while (l1 >= l2) { |
| 985 | l1--; |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 986 | if (!memcmp(s1, s2, l2)) |
| 987 | return (char *)s1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 988 | s1++; |
| 989 | } |
| 990 | return NULL; |
| 991 | } |
| 992 | EXPORT_SYMBOL(strstr); |
| 993 | #endif |
| 994 | |
Li Zefan | d5f1fb5 | 2010-01-14 10:53:55 +0800 | [diff] [blame] | 995 | #ifndef __HAVE_ARCH_STRNSTR |
| 996 | /** |
| 997 | * strnstr - Find the first substring in a length-limited string |
| 998 | * @s1: The string to be searched |
| 999 | * @s2: The string to search for |
| 1000 | * @len: the maximum number of characters to search |
| 1001 | */ |
| 1002 | char *strnstr(const char *s1, const char *s2, size_t len) |
| 1003 | { |
André Goddard Rosa | d6a2eed | 2010-03-05 13:43:12 -0800 | [diff] [blame] | 1004 | size_t l2; |
Li Zefan | d5f1fb5 | 2010-01-14 10:53:55 +0800 | [diff] [blame] | 1005 | |
| 1006 | l2 = strlen(s2); |
| 1007 | if (!l2) |
| 1008 | return (char *)s1; |
André Goddard Rosa | d6a2eed | 2010-03-05 13:43:12 -0800 | [diff] [blame] | 1009 | while (len >= l2) { |
| 1010 | len--; |
Li Zefan | d5f1fb5 | 2010-01-14 10:53:55 +0800 | [diff] [blame] | 1011 | if (!memcmp(s1, s2, l2)) |
| 1012 | return (char *)s1; |
| 1013 | s1++; |
| 1014 | } |
| 1015 | return NULL; |
| 1016 | } |
| 1017 | EXPORT_SYMBOL(strnstr); |
| 1018 | #endif |
| 1019 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1020 | #ifndef __HAVE_ARCH_MEMCHR |
| 1021 | /** |
| 1022 | * memchr - Find a character in an area of memory. |
| 1023 | * @s: The memory area |
| 1024 | * @c: The byte to search for |
| 1025 | * @n: The size of the area. |
| 1026 | * |
| 1027 | * returns the address of the first occurrence of @c, or %NULL |
| 1028 | * if @c is not found |
| 1029 | */ |
| 1030 | void *memchr(const void *s, int c, size_t n) |
| 1031 | { |
| 1032 | const unsigned char *p = s; |
| 1033 | while (n-- != 0) { |
| 1034 | if ((unsigned char)c == *p++) { |
Jesper Juhl | 51a0f0f | 2005-10-30 15:02:11 -0800 | [diff] [blame] | 1035 | return (void *)(p - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1036 | } |
| 1037 | } |
| 1038 | return NULL; |
| 1039 | } |
| 1040 | EXPORT_SYMBOL(memchr); |
| 1041 | #endif |
Akinobu Mita | 79824820 | 2011-10-31 17:08:07 -0700 | [diff] [blame] | 1042 | |
| 1043 | static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes) |
| 1044 | { |
| 1045 | while (bytes) { |
| 1046 | if (*start != value) |
| 1047 | return (void *)start; |
| 1048 | start++; |
| 1049 | bytes--; |
| 1050 | } |
| 1051 | return NULL; |
| 1052 | } |
| 1053 | |
| 1054 | /** |
| 1055 | * memchr_inv - Find an unmatching character in an area of memory. |
| 1056 | * @start: The memory area |
| 1057 | * @c: Find a character other than c |
| 1058 | * @bytes: The size of the area. |
| 1059 | * |
| 1060 | * returns the address of the first character other than @c, or %NULL |
| 1061 | * if the whole buffer contains just @c. |
| 1062 | */ |
| 1063 | void *memchr_inv(const void *start, int c, size_t bytes) |
| 1064 | { |
| 1065 | u8 value = c; |
| 1066 | u64 value64; |
| 1067 | unsigned int words, prefix; |
| 1068 | |
| 1069 | if (bytes <= 16) |
| 1070 | return check_bytes8(start, value, bytes); |
| 1071 | |
Akinobu Mita | f43804b | 2012-03-23 15:02:14 -0700 | [diff] [blame] | 1072 | value64 = value; |
Linus Torvalds | 72d9310 | 2014-09-13 11:14:53 -0700 | [diff] [blame] | 1073 | #if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 |
Andy Shevchenko | 3368e8f | 2015-11-10 14:45:14 -0800 | [diff] [blame] | 1074 | value64 *= 0x0101010101010101ULL; |
Linus Torvalds | 72d9310 | 2014-09-13 11:14:53 -0700 | [diff] [blame] | 1075 | #elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) |
Akinobu Mita | f43804b | 2012-03-23 15:02:14 -0700 | [diff] [blame] | 1076 | value64 *= 0x01010101; |
| 1077 | value64 |= value64 << 32; |
| 1078 | #else |
| 1079 | value64 |= value64 << 8; |
| 1080 | value64 |= value64 << 16; |
| 1081 | value64 |= value64 << 32; |
| 1082 | #endif |
Akinobu Mita | 79824820 | 2011-10-31 17:08:07 -0700 | [diff] [blame] | 1083 | |
Akinobu Mita | f43804b | 2012-03-23 15:02:14 -0700 | [diff] [blame] | 1084 | prefix = (unsigned long)start % 8; |
Akinobu Mita | 79824820 | 2011-10-31 17:08:07 -0700 | [diff] [blame] | 1085 | if (prefix) { |
Akinobu Mita | f43804b | 2012-03-23 15:02:14 -0700 | [diff] [blame] | 1086 | u8 *r; |
| 1087 | |
| 1088 | prefix = 8 - prefix; |
| 1089 | r = check_bytes8(start, value, prefix); |
Akinobu Mita | 79824820 | 2011-10-31 17:08:07 -0700 | [diff] [blame] | 1090 | if (r) |
| 1091 | return r; |
| 1092 | start += prefix; |
| 1093 | bytes -= prefix; |
| 1094 | } |
| 1095 | |
| 1096 | words = bytes / 8; |
| 1097 | |
| 1098 | while (words) { |
| 1099 | if (*(u64 *)start != value64) |
| 1100 | return check_bytes8(start, value, 8); |
| 1101 | start += 8; |
| 1102 | words--; |
| 1103 | } |
| 1104 | |
| 1105 | return check_bytes8(start, value, bytes % 8); |
| 1106 | } |
| 1107 | EXPORT_SYMBOL(memchr_inv); |
Rasmus Villemoes | 94df290 | 2015-06-25 15:02:22 -0700 | [diff] [blame] | 1108 | |
| 1109 | /** |
| 1110 | * strreplace - Replace all occurrences of character in string. |
| 1111 | * @s: The string to operate on. |
| 1112 | * @old: The character being replaced. |
| 1113 | * @new: The character @old is replaced with. |
| 1114 | * |
| 1115 | * Returns pointer to the nul byte at the end of @s. |
| 1116 | */ |
| 1117 | char *strreplace(char *s, char old, char new) |
| 1118 | { |
| 1119 | for (; *s; ++s) |
| 1120 | if (*s == old) |
| 1121 | *s = new; |
| 1122 | return s; |
| 1123 | } |
| 1124 | EXPORT_SYMBOL(strreplace); |
Daniel Micay | 6974f0c | 2017-07-12 14:36:10 -0700 | [diff] [blame] | 1125 | |
| 1126 | void fortify_panic(const char *name) |
| 1127 | { |
| 1128 | pr_emerg("detected buffer overflow in %s\n", name); |
| 1129 | BUG(); |
| 1130 | } |
| 1131 | EXPORT_SYMBOL(fortify_panic); |