1 // SPDX-License-Identifier: GPL-2.0-only 2 /* -*- linux-c -*- ------------------------------------------------------- * 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * Copyright 2007 rPath, Inc. - All Rights Reserved 6 * 7 * ----------------------------------------------------------------------- */ 8 9 /* 10 * Very basic string functions 11 */ 12 13 #include <linux/types.h> 14 #include <linux/compiler.h> 15 #include <linux/errno.h> 16 #include <linux/limits.h> 17 #include <asm/asm.h> 18 #include "ctype.h" 19 #include "string.h" 20 21 #define KSTRTOX_OVERFLOW (1U << 31) 22 23 /* 24 * Undef these macros so that the functions that we provide 25 * here will have the correct names regardless of how string.h 26 * may have chosen to #define them. 27 */ 28 #undef memcpy 29 #undef memset 30 #undef memcmp 31 32 int memcmp(const void *s1, const void *s2, size_t len) 33 { 34 bool diff; 35 asm("repe; cmpsb" CC_SET(nz) 36 : CC_OUT(nz) (diff), "+D" (s1), "+S" (s2), "+c" (len)); 37 return diff; 38 } 39 40 /* 41 * Clang may lower `memcmp == 0` to `bcmp == 0`. 42 */ 43 int bcmp(const void *s1, const void *s2, size_t len) 44 { 45 return memcmp(s1, s2, len); 46 } 47 48 int strcmp(const char *str1, const char *str2) 49 { 50 const unsigned char *s1 = (const unsigned char *)str1; 51 const unsigned char *s2 = (const unsigned char *)str2; 52 int delta = 0; 53 54 while (*s1 || *s2) { 55 delta = *s1 - *s2; 56 if (delta) 57 return delta; 58 s1++; 59 s2++; 60 } 61 return 0; 62 } 63 64 int strncmp(const char *cs, const char *ct, size_t count) 65 { 66 unsigned char c1, c2; 67 68 while (count) { 69 c1 = *cs++; 70 c2 = *ct++; 71 if (c1 != c2) 72 return c1 < c2 ? -1 : 1; 73 if (!c1) 74 break; 75 count--; 76 } 77 return 0; 78 } 79 80 size_t strnlen(const char *s, size_t maxlen) 81 { 82 const char *es = s; 83 while (*es && maxlen) { 84 es++; 85 maxlen--; 86 } 87 88 return (es - s); 89 } 90 91 unsigned int atou(const char *s) 92 { 93 unsigned int i = 0; 94 while (isdigit(*s)) 95 i = i * 10 + (*s++ - '0'); 96 return i; 97 } 98 99 /* Works only for digits and letters, but small and fast */ 100 #define TOLOWER(x) ((x) | 0x20) 101 102 static unsigned int simple_guess_base(const char *cp) 103 { 104 if (cp[0] == '0') { 105 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2])) 106 return 16; 107 else 108 return 8; 109 } else { 110 return 10; 111 } 112 } 113 114 /** 115 * simple_strtoull - convert a string to an unsigned long long 116 * @cp: The start of the string 117 * @endp: A pointer to the end of the parsed string will be placed here 118 * @base: The number base to use 119 */ 120 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base) 121 { 122 unsigned long long result = 0; 123 124 if (!base) 125 base = simple_guess_base(cp); 126 127 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x') 128 cp += 2; 129 130 while (isxdigit(*cp)) { 131 unsigned int value; 132 133 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10; 134 if (value >= base) 135 break; 136 result = result * base + value; 137 cp++; 138 } 139 if (endp) 140 *endp = (char *)cp; 141 142 return result; 143 } 144 145 long simple_strtol(const char *cp, char **endp, unsigned int base) 146 { 147 if (*cp == '-') 148 return -simple_strtoull(cp + 1, endp, base); 149 150 return simple_strtoull(cp, endp, base); 151 } 152 153 /** 154 * strlen - Find the length of a string 155 * @s: The string to be sized 156 */ 157 size_t strlen(const char *s) 158 { 159 const char *sc; 160 161 for (sc = s; *sc != '\0'; ++sc) 162 /* nothing */; 163 return sc - s; 164 } 165 166 /** 167 * strstr - Find the first substring in a %NUL terminated string 168 * @s1: The string to be searched 169 * @s2: The string to search for 170 */ 171 char *strstr(const char *s1, const char *s2) 172 { 173 size_t l1, l2; 174 175 l2 = strlen(s2); 176 if (!l2) 177 return (char *)s1; 178 l1 = strlen(s1); 179 while (l1 >= l2) { 180 l1--; 181 if (!memcmp(s1, s2, l2)) 182 return (char *)s1; 183 s1++; 184 } 185 return NULL; 186 } 187 188 /** 189 * strchr - Find the first occurrence of the character c in the string s. 190 * @s: the string to be searched 191 * @c: the character to search for 192 */ 193 char *strchr(const char *s, int c) 194 { 195 while (*s != (char)c) 196 if (*s++ == '\0') 197 return NULL; 198 return (char *)s; 199 } 200 201 static inline u64 __div_u64_rem(u64 dividend, u32 divisor, u32 *remainder) 202 { 203 union { 204 u64 v64; 205 u32 v32[2]; 206 } d = { dividend }; 207 u32 upper; 208 209 upper = d.v32[1]; 210 d.v32[1] = 0; 211 if (upper >= divisor) { 212 d.v32[1] = upper / divisor; 213 upper %= divisor; 214 } 215 asm ("divl %2" : "=a" (d.v32[0]), "=d" (*remainder) : 216 "rm" (divisor), "0" (d.v32[0]), "1" (upper)); 217 return d.v64; 218 } 219 220 static inline u64 __div_u64(u64 dividend, u32 divisor) 221 { 222 u32 remainder; 223 224 return __div_u64_rem(dividend, divisor, &remainder); 225 } 226 227 static inline char _tolower(const char c) 228 { 229 return c | 0x20; 230 } 231 232 static const char *_parse_integer_fixup_radix(const char *s, unsigned int *base) 233 { 234 if (*base == 0) { 235 if (s[0] == '0') { 236 if (_tolower(s[1]) == 'x' && isxdigit(s[2])) 237 *base = 16; 238 else 239 *base = 8; 240 } else 241 *base = 10; 242 } 243 if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x') 244 s += 2; 245 return s; 246 } 247 248 /* 249 * Convert non-negative integer string representation in explicitly given radix 250 * to an integer. 251 * Return number of characters consumed maybe or-ed with overflow bit. 252 * If overflow occurs, result integer (incorrect) is still returned. 253 * 254 * Don't you dare use this function. 255 */ 256 static unsigned int _parse_integer(const char *s, 257 unsigned int base, 258 unsigned long long *p) 259 { 260 unsigned long long res; 261 unsigned int rv; 262 263 res = 0; 264 rv = 0; 265 while (1) { 266 unsigned int c = *s; 267 unsigned int lc = c | 0x20; /* don't tolower() this line */ 268 unsigned int val; 269 270 if ('0' <= c && c <= '9') 271 val = c - '0'; 272 else if ('a' <= lc && lc <= 'f') 273 val = lc - 'a' + 10; 274 else 275 break; 276 277 if (val >= base) 278 break; 279 /* 280 * Check for overflow only if we are within range of 281 * it in the max base we support (16) 282 */ 283 if (unlikely(res & (~0ull << 60))) { 284 if (res > __div_u64(ULLONG_MAX - val, base)) 285 rv |= KSTRTOX_OVERFLOW; 286 } 287 res = res * base + val; 288 rv++; 289 s++; 290 } 291 *p = res; 292 return rv; 293 } 294 295 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res) 296 { 297 unsigned long long _res; 298 unsigned int rv; 299 300 s = _parse_integer_fixup_radix(s, &base); 301 rv = _parse_integer(s, base, &_res); 302 if (rv & KSTRTOX_OVERFLOW) 303 return -ERANGE; 304 if (rv == 0) 305 return -EINVAL; 306 s += rv; 307 if (*s == '\n') 308 s++; 309 if (*s) 310 return -EINVAL; 311 *res = _res; 312 return 0; 313 } 314 315 /** 316 * kstrtoull - convert a string to an unsigned long long 317 * @s: The start of the string. The string must be null-terminated, and may also 318 * include a single newline before its terminating null. The first character 319 * may also be a plus sign, but not a minus sign. 320 * @base: The number base to use. The maximum supported base is 16. If base is 321 * given as 0, then the base of the string is automatically detected with the 322 * conventional semantics - If it begins with 0x the number will be parsed as a 323 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be 324 * parsed as an octal number. Otherwise it will be parsed as a decimal. 325 * @res: Where to write the result of the conversion on success. 326 * 327 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. 328 * Used as a replacement for the obsolete simple_strtoull. Return code must 329 * be checked. 330 */ 331 int kstrtoull(const char *s, unsigned int base, unsigned long long *res) 332 { 333 if (s[0] == '+') 334 s++; 335 return _kstrtoull(s, base, res); 336 } 337 338 static int _kstrtoul(const char *s, unsigned int base, unsigned long *res) 339 { 340 unsigned long long tmp; 341 int rv; 342 343 rv = kstrtoull(s, base, &tmp); 344 if (rv < 0) 345 return rv; 346 if (tmp != (unsigned long)tmp) 347 return -ERANGE; 348 *res = tmp; 349 return 0; 350 } 351 352 /** 353 * kstrtoul - convert a string to an unsigned long 354 * @s: The start of the string. The string must be null-terminated, and may also 355 * include a single newline before its terminating null. The first character 356 * may also be a plus sign, but not a minus sign. 357 * @base: The number base to use. The maximum supported base is 16. If base is 358 * given as 0, then the base of the string is automatically detected with the 359 * conventional semantics - If it begins with 0x the number will be parsed as a 360 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be 361 * parsed as an octal number. Otherwise it will be parsed as a decimal. 362 * @res: Where to write the result of the conversion on success. 363 * 364 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. 365 * Used as a replacement for the simple_strtoull. 366 */ 367 int boot_kstrtoul(const char *s, unsigned int base, unsigned long *res) 368 { 369 /* 370 * We want to shortcut function call, but 371 * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0. 372 */ 373 if (sizeof(unsigned long) == sizeof(unsigned long long) && 374 __alignof__(unsigned long) == __alignof__(unsigned long long)) 375 return kstrtoull(s, base, (unsigned long long *)res); 376 else 377 return _kstrtoul(s, base, res); 378 } 379