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 int strcmp(const char *str1, const char *str2) 41 { 42 const unsigned char *s1 = (const unsigned char *)str1; 43 const unsigned char *s2 = (const unsigned char *)str2; 44 int delta = 0; 45 46 while (*s1 || *s2) { 47 delta = *s1 - *s2; 48 if (delta) 49 return delta; 50 s1++; 51 s2++; 52 } 53 return 0; 54 } 55 56 int strncmp(const char *cs, const char *ct, size_t count) 57 { 58 unsigned char c1, c2; 59 60 while (count) { 61 c1 = *cs++; 62 c2 = *ct++; 63 if (c1 != c2) 64 return c1 < c2 ? -1 : 1; 65 if (!c1) 66 break; 67 count--; 68 } 69 return 0; 70 } 71 72 size_t strnlen(const char *s, size_t maxlen) 73 { 74 const char *es = s; 75 while (*es && maxlen) { 76 es++; 77 maxlen--; 78 } 79 80 return (es - s); 81 } 82 83 unsigned int atou(const char *s) 84 { 85 unsigned int i = 0; 86 while (isdigit(*s)) 87 i = i * 10 + (*s++ - '0'); 88 return i; 89 } 90 91 /* Works only for digits and letters, but small and fast */ 92 #define TOLOWER(x) ((x) | 0x20) 93 94 static unsigned int simple_guess_base(const char *cp) 95 { 96 if (cp[0] == '0') { 97 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2])) 98 return 16; 99 else 100 return 8; 101 } else { 102 return 10; 103 } 104 } 105 106 /** 107 * simple_strtoull - convert a string to an unsigned long long 108 * @cp: The start of the string 109 * @endp: A pointer to the end of the parsed string will be placed here 110 * @base: The number base to use 111 */ 112 113 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base) 114 { 115 unsigned long long result = 0; 116 117 if (!base) 118 base = simple_guess_base(cp); 119 120 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x') 121 cp += 2; 122 123 while (isxdigit(*cp)) { 124 unsigned int value; 125 126 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10; 127 if (value >= base) 128 break; 129 result = result * base + value; 130 cp++; 131 } 132 if (endp) 133 *endp = (char *)cp; 134 135 return result; 136 } 137 138 long simple_strtol(const char *cp, char **endp, unsigned int base) 139 { 140 if (*cp == '-') 141 return -simple_strtoull(cp + 1, endp, base); 142 143 return simple_strtoull(cp, endp, base); 144 } 145 146 /** 147 * strlen - Find the length of a string 148 * @s: The string to be sized 149 */ 150 size_t strlen(const char *s) 151 { 152 const char *sc; 153 154 for (sc = s; *sc != '\0'; ++sc) 155 /* nothing */; 156 return sc - s; 157 } 158 159 /** 160 * strstr - Find the first substring in a %NUL terminated string 161 * @s1: The string to be searched 162 * @s2: The string to search for 163 */ 164 char *strstr(const char *s1, const char *s2) 165 { 166 size_t l1, l2; 167 168 l2 = strlen(s2); 169 if (!l2) 170 return (char *)s1; 171 l1 = strlen(s1); 172 while (l1 >= l2) { 173 l1--; 174 if (!memcmp(s1, s2, l2)) 175 return (char *)s1; 176 s1++; 177 } 178 return NULL; 179 } 180 181 /** 182 * strchr - Find the first occurrence of the character c in the string s. 183 * @s: the string to be searched 184 * @c: the character to search for 185 */ 186 char *strchr(const char *s, int c) 187 { 188 while (*s != (char)c) 189 if (*s++ == '\0') 190 return NULL; 191 return (char *)s; 192 } 193 194 static inline u64 __div_u64_rem(u64 dividend, u32 divisor, u32 *remainder) 195 { 196 union { 197 u64 v64; 198 u32 v32[2]; 199 } d = { dividend }; 200 u32 upper; 201 202 upper = d.v32[1]; 203 d.v32[1] = 0; 204 if (upper >= divisor) { 205 d.v32[1] = upper / divisor; 206 upper %= divisor; 207 } 208 asm ("divl %2" : "=a" (d.v32[0]), "=d" (*remainder) : 209 "rm" (divisor), "0" (d.v32[0]), "1" (upper)); 210 return d.v64; 211 } 212 213 static inline u64 __div_u64(u64 dividend, u32 divisor) 214 { 215 u32 remainder; 216 217 return __div_u64_rem(dividend, divisor, &remainder); 218 } 219 220 static inline char _tolower(const char c) 221 { 222 return c | 0x20; 223 } 224 225 static const char *_parse_integer_fixup_radix(const char *s, unsigned int *base) 226 { 227 if (*base == 0) { 228 if (s[0] == '0') { 229 if (_tolower(s[1]) == 'x' && isxdigit(s[2])) 230 *base = 16; 231 else 232 *base = 8; 233 } else 234 *base = 10; 235 } 236 if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x') 237 s += 2; 238 return s; 239 } 240 241 /* 242 * Convert non-negative integer string representation in explicitly given radix 243 * to an integer. 244 * Return number of characters consumed maybe or-ed with overflow bit. 245 * If overflow occurs, result integer (incorrect) is still returned. 246 * 247 * Don't you dare use this function. 248 */ 249 static unsigned int _parse_integer(const char *s, 250 unsigned int base, 251 unsigned long long *p) 252 { 253 unsigned long long res; 254 unsigned int rv; 255 256 res = 0; 257 rv = 0; 258 while (1) { 259 unsigned int c = *s; 260 unsigned int lc = c | 0x20; /* don't tolower() this line */ 261 unsigned int val; 262 263 if ('0' <= c && c <= '9') 264 val = c - '0'; 265 else if ('a' <= lc && lc <= 'f') 266 val = lc - 'a' + 10; 267 else 268 break; 269 270 if (val >= base) 271 break; 272 /* 273 * Check for overflow only if we are within range of 274 * it in the max base we support (16) 275 */ 276 if (unlikely(res & (~0ull << 60))) { 277 if (res > __div_u64(ULLONG_MAX - val, base)) 278 rv |= KSTRTOX_OVERFLOW; 279 } 280 res = res * base + val; 281 rv++; 282 s++; 283 } 284 *p = res; 285 return rv; 286 } 287 288 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res) 289 { 290 unsigned long long _res; 291 unsigned int rv; 292 293 s = _parse_integer_fixup_radix(s, &base); 294 rv = _parse_integer(s, base, &_res); 295 if (rv & KSTRTOX_OVERFLOW) 296 return -ERANGE; 297 if (rv == 0) 298 return -EINVAL; 299 s += rv; 300 if (*s == '\n') 301 s++; 302 if (*s) 303 return -EINVAL; 304 *res = _res; 305 return 0; 306 } 307 308 /** 309 * kstrtoull - convert a string to an unsigned long long 310 * @s: The start of the string. The string must be null-terminated, and may also 311 * include a single newline before its terminating null. The first character 312 * may also be a plus sign, but not a minus sign. 313 * @base: The number base to use. The maximum supported base is 16. If base is 314 * given as 0, then the base of the string is automatically detected with the 315 * conventional semantics - If it begins with 0x the number will be parsed as a 316 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be 317 * parsed as an octal number. Otherwise it will be parsed as a decimal. 318 * @res: Where to write the result of the conversion on success. 319 * 320 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. 321 * Used as a replacement for the obsolete simple_strtoull. Return code must 322 * be checked. 323 */ 324 int kstrtoull(const char *s, unsigned int base, unsigned long long *res) 325 { 326 if (s[0] == '+') 327 s++; 328 return _kstrtoull(s, base, res); 329 } 330