1 // SPDX-License-Identifier: GPL-2.0
3 * Convert integer string representation to an integer.
4 * If an integer doesn't fit into specified type, -E is returned.
6 * Integer starts with optional sign.
7 * kstrtou*() functions do not accept sign "-".
9 * Radix 0 means autodetection: leading "0x" implies radix 16,
10 * leading "0" implies radix 8, otherwise radix is 10.
11 * Autodetection hints work after optional sign, but not before.
13 * If -E is returned, result is not touched.
15 #include <linux/ctype.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
18 #include <linux/math64.h>
19 #include <linux/export.h>
20 #include <linux/types.h>
21 #include <linux/uaccess.h>
24 const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
28 if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
35 if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
41 * Convert non-negative integer string representation in explicitly given radix
42 * to an integer. A maximum of max_chars characters will be converted.
44 * Return number of characters consumed maybe or-ed with overflow bit.
45 * If overflow occurs, result integer (incorrect) is still returned.
47 * Don't you dare use this function.
49 unsigned int _parse_integer_limit(const char *s, unsigned int base, unsigned long long *p,
52 unsigned long long res;
59 unsigned int lc = c | 0x20; /* don't tolower() this line */
62 if ('0' <= c && c <= '9')
64 else if ('a' <= lc && lc <= 'f')
72 * Check for overflow only if we are within range of
73 * it in the max base we support (16)
75 if (unlikely(res & (~0ull << 60))) {
76 if (res > div_u64(ULLONG_MAX - val, base))
77 rv |= KSTRTOX_OVERFLOW;
79 res = res * base + val;
87 unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)
89 return _parse_integer_limit(s, base, p, INT_MAX);
92 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
94 unsigned long long _res;
97 s = _parse_integer_fixup_radix(s, &base);
98 rv = _parse_integer(s, base, &_res);
99 if (rv & KSTRTOX_OVERFLOW)
113 * kstrtoull - convert a string to an unsigned long long
114 * @s: The start of the string. The string must be null-terminated, and may also
115 * include a single newline before its terminating null. The first character
116 * may also be a plus sign, but not a minus sign.
117 * @base: The number base to use. The maximum supported base is 16. If base is
118 * given as 0, then the base of the string is automatically detected with the
119 * conventional semantics - If it begins with 0x the number will be parsed as a
120 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
121 * parsed as an octal number. Otherwise it will be parsed as a decimal.
122 * @res: Where to write the result of the conversion on success.
124 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
125 * Preferred over simple_strtoull(). Return code must be checked.
127 int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
131 return _kstrtoull(s, base, res);
133 EXPORT_SYMBOL(kstrtoull);
136 * kstrtoll - convert a string to a long long
137 * @s: The start of the string. The string must be null-terminated, and may also
138 * include a single newline before its terminating null. The first character
139 * may also be a plus sign or a minus sign.
140 * @base: The number base to use. The maximum supported base is 16. If base is
141 * given as 0, then the base of the string is automatically detected with the
142 * conventional semantics - If it begins with 0x the number will be parsed as a
143 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
144 * parsed as an octal number. Otherwise it will be parsed as a decimal.
145 * @res: Where to write the result of the conversion on success.
147 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
148 * Preferred over simple_strtoll(). Return code must be checked.
150 int kstrtoll(const char *s, unsigned int base, long long *res)
152 unsigned long long tmp;
156 rv = _kstrtoull(s + 1, base, &tmp);
159 if ((long long)-tmp > 0)
163 rv = kstrtoull(s, base, &tmp);
166 if ((long long)tmp < 0)
172 EXPORT_SYMBOL(kstrtoll);
174 /* Internal, do not use. */
175 int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
177 unsigned long long tmp;
180 rv = kstrtoull(s, base, &tmp);
183 if (tmp != (unsigned long)tmp)
188 EXPORT_SYMBOL(_kstrtoul);
190 /* Internal, do not use. */
191 int _kstrtol(const char *s, unsigned int base, long *res)
196 rv = kstrtoll(s, base, &tmp);
199 if (tmp != (long)tmp)
204 EXPORT_SYMBOL(_kstrtol);
207 * kstrtouint - convert a string to an unsigned int
208 * @s: The start of the string. The string must be null-terminated, and may also
209 * include a single newline before its terminating null. The first character
210 * may also be a plus sign, but not a minus sign.
211 * @base: The number base to use. The maximum supported base is 16. If base is
212 * given as 0, then the base of the string is automatically detected with the
213 * conventional semantics - If it begins with 0x the number will be parsed as a
214 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
215 * parsed as an octal number. Otherwise it will be parsed as a decimal.
216 * @res: Where to write the result of the conversion on success.
218 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
219 * Preferred over simple_strtoul(). Return code must be checked.
221 int kstrtouint(const char *s, unsigned int base, unsigned int *res)
223 unsigned long long tmp;
226 rv = kstrtoull(s, base, &tmp);
229 if (tmp != (unsigned int)tmp)
234 EXPORT_SYMBOL(kstrtouint);
237 * kstrtoint - convert a string to an int
238 * @s: The start of the string. The string must be null-terminated, and may also
239 * include a single newline before its terminating null. The first character
240 * may also be a plus sign or a minus sign.
241 * @base: The number base to use. The maximum supported base is 16. If base is
242 * given as 0, then the base of the string is automatically detected with the
243 * conventional semantics - If it begins with 0x the number will be parsed as a
244 * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
245 * parsed as an octal number. Otherwise it will be parsed as a decimal.
246 * @res: Where to write the result of the conversion on success.
248 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
249 * Preferred over simple_strtol(). Return code must be checked.
251 int kstrtoint(const char *s, unsigned int base, int *res)
256 rv = kstrtoll(s, base, &tmp);
264 EXPORT_SYMBOL(kstrtoint);
266 int kstrtou16(const char *s, unsigned int base, u16 *res)
268 unsigned long long tmp;
271 rv = kstrtoull(s, base, &tmp);
279 EXPORT_SYMBOL(kstrtou16);
281 int kstrtos16(const char *s, unsigned int base, s16 *res)
286 rv = kstrtoll(s, base, &tmp);
294 EXPORT_SYMBOL(kstrtos16);
296 int kstrtou8(const char *s, unsigned int base, u8 *res)
298 unsigned long long tmp;
301 rv = kstrtoull(s, base, &tmp);
309 EXPORT_SYMBOL(kstrtou8);
311 int kstrtos8(const char *s, unsigned int base, s8 *res)
316 rv = kstrtoll(s, base, &tmp);
324 EXPORT_SYMBOL(kstrtos8);
327 * kstrtobool - convert common user inputs into boolean values
331 * This routine returns 0 iff the first character is one of 'Yy1Nn0', or
332 * [oO][NnFf] for "on" and "off". Otherwise it will return -EINVAL. Value
333 * pointed to by res is updated upon finding a match.
335 int kstrtobool(const char *s, bool *res)
372 EXPORT_SYMBOL(kstrtobool);
375 * Since "base" would be a nonsense argument, this open-codes the
376 * _from_user helper instead of using the helper macro below.
378 int kstrtobool_from_user(const char __user *s, size_t count, bool *res)
380 /* Longest string needed to differentiate, newline, terminator */
383 count = min(count, sizeof(buf) - 1);
384 if (copy_from_user(buf, s, count))
387 return kstrtobool(buf, res);
389 EXPORT_SYMBOL(kstrtobool_from_user);
391 #define kstrto_from_user(f, g, type) \
392 int f(const char __user *s, size_t count, unsigned int base, type *res) \
394 /* sign, base 2 representation, newline, terminator */ \
395 char buf[1 + sizeof(type) * 8 + 1 + 1]; \
397 count = min(count, sizeof(buf) - 1); \
398 if (copy_from_user(buf, s, count)) \
401 return g(buf, base, res); \
405 kstrto_from_user(kstrtoull_from_user, kstrtoull, unsigned long long);
406 kstrto_from_user(kstrtoll_from_user, kstrtoll, long long);
407 kstrto_from_user(kstrtoul_from_user, kstrtoul, unsigned long);
408 kstrto_from_user(kstrtol_from_user, kstrtol, long);
409 kstrto_from_user(kstrtouint_from_user, kstrtouint, unsigned int);
410 kstrto_from_user(kstrtoint_from_user, kstrtoint, int);
411 kstrto_from_user(kstrtou16_from_user, kstrtou16, u16);
412 kstrto_from_user(kstrtos16_from_user, kstrtos16, s16);
413 kstrto_from_user(kstrtou8_from_user, kstrtou8, u8);
414 kstrto_from_user(kstrtos8_from_user, kstrtos8, s8);