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 
memcmp(const void * s1,const void * s2,size_t len)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  */
bcmp(const void * s1,const void * s2,size_t len)43 int bcmp(const void *s1, const void *s2, size_t len)
44 {
45 	return memcmp(s1, s2, len);
46 }
47 
strcmp(const char * str1,const char * str2)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 
strncmp(const char * cs,const char * ct,size_t count)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 
strnlen(const char * s,size_t maxlen)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 
atou(const char * s)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 
simple_guess_base(const char * cp)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  */
simple_strtoull(const char * cp,char ** endp,unsigned int base)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 
simple_strtol(const char * cp,char ** endp,unsigned int base)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  */
strlen(const char * s)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  */
strstr(const char * s1,const char * s2)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  */
strchr(const char * s,int c)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 
__div_u64_rem(u64 dividend,u32 divisor,u32 * remainder)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 
__div_u64(u64 dividend,u32 divisor)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 
_tolower(const char c)227 static inline char _tolower(const char c)
228 {
229 	return c | 0x20;
230 }
231 
_parse_integer_fixup_radix(const char * s,unsigned int * base)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  */
_parse_integer(const char * s,unsigned int base,unsigned long long * p)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 
_kstrtoull(const char * s,unsigned int base,unsigned long long * res)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  */
kstrtoull(const char * s,unsigned int base,unsigned long long * res)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 
_kstrtoul(const char * s,unsigned int base,unsigned long * res)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  */
boot_kstrtoul(const char * s,unsigned int base,unsigned long * res)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