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(ch: *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(ch: 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(ch: *cp)) { |
131 | unsigned int value; |
132 | |
133 | value = isdigit(ch: *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: 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(s: s2); |
176 | if (!l2) |
177 | return (char *)s1; |
178 | l1 = strlen(s: s1); |
179 | while (l1 >= l2) { |
180 | l1--; |
181 | if (!memcmp(s1, s2, len: 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: &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(c: s[1]) == 'x' && isxdigit(ch: s[2])) |
237 | *base = 16; |
238 | else |
239 | *base = 8; |
240 | } else |
241 | *base = 10; |
242 | } |
243 | if (*base == 16 && s[0] == '0' && _tolower(c: 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, divisor: 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: &base); |
301 | rv = _parse_integer(s, base, p: &_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, res: &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 | * boot_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, res: (unsigned long long *)res); |
376 | else |
377 | return _kstrtoul(s, base, res); |
378 | } |
379 | |