Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Convert integer string representation to an integer. |
| 4 | * If an integer doesn't fit into specified type, -E is returned. |
| 5 | * |
| 6 | * Integer starts with optional sign. |
| 7 | * kstrtou*() functions do not accept sign "-". |
| 8 | * |
| 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. |
| 12 | * |
| 13 | * If -E is returned, result is not touched. |
| 14 | */ |
| 15 | #include <linux/ctype.h> |
| 16 | #include <linux/errno.h> |
Paul Gortmaker | 8bc3bcc | 2011-11-16 21:29:17 -0500 | [diff] [blame] | 17 | #include <linux/export.h> |
Andy Shevchenko | 4c52729 | 2021-06-30 18:56:10 -0700 | [diff] [blame] | 18 | #include <linux/kstrtox.h> |
| 19 | #include <linux/math64.h> |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 20 | #include <linux/types.h> |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 21 | #include <linux/uaccess.h> |
Andy Shevchenko | 4c52729 | 2021-06-30 18:56:10 -0700 | [diff] [blame] | 22 | |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 23 | #include "kstrtox.h" |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 24 | |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 25 | noinline |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 26 | const char *_parse_integer_fixup_radix(const char *s, unsigned int *base) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 27 | { |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 28 | if (*base == 0) { |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 29 | if (s[0] == '0') { |
| 30 | if (_tolower(s[1]) == 'x' && isxdigit(s[2])) |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 31 | *base = 16; |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 32 | else |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 33 | *base = 8; |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 34 | } else |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 35 | *base = 10; |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 36 | } |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 37 | if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x') |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 38 | s += 2; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 39 | return s; |
| 40 | } |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 41 | |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 42 | /* |
| 43 | * Convert non-negative integer string representation in explicitly given radix |
Richard Fitzgerald | 900fdc4 | 2021-05-14 17:12:04 +0100 | [diff] [blame] | 44 | * to an integer. A maximum of max_chars characters will be converted. |
| 45 | * |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 46 | * Return number of characters consumed maybe or-ed with overflow bit. |
| 47 | * If overflow occurs, result integer (incorrect) is still returned. |
| 48 | * |
| 49 | * Don't you dare use this function. |
| 50 | */ |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 51 | noinline |
Richard Fitzgerald | 900fdc4 | 2021-05-14 17:12:04 +0100 | [diff] [blame] | 52 | unsigned int _parse_integer_limit(const char *s, unsigned int base, unsigned long long *p, |
| 53 | size_t max_chars) |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 54 | { |
David Howells | 690d137 | 2012-02-09 15:48:20 +0000 | [diff] [blame] | 55 | unsigned long long res; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 56 | unsigned int rv; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 57 | |
David Howells | 690d137 | 2012-02-09 15:48:20 +0000 | [diff] [blame] | 58 | res = 0; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 59 | rv = 0; |
Richard Fitzgerald | 900fdc4 | 2021-05-14 17:12:04 +0100 | [diff] [blame] | 60 | while (max_chars--) { |
Alexey Dobriyan | be5f3c7 | 2017-07-10 15:51:41 -0700 | [diff] [blame] | 61 | unsigned int c = *s; |
Andy Shevchenko | 3d0b713 | 2023-08-17 17:59:19 +0300 | [diff] [blame] | 62 | unsigned int lc = _tolower(c); |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 63 | unsigned int val; |
| 64 | |
Alexey Dobriyan | be5f3c7 | 2017-07-10 15:51:41 -0700 | [diff] [blame] | 65 | if ('0' <= c && c <= '9') |
| 66 | val = c - '0'; |
| 67 | else if ('a' <= lc && lc <= 'f') |
| 68 | val = lc - 'a' + 10; |
Alexey Dobriyan | 78be959 | 2011-04-14 15:22:02 -0700 | [diff] [blame] | 69 | else |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 70 | break; |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 71 | |
| 72 | if (val >= base) |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 73 | break; |
David Howells | 690d137 | 2012-02-09 15:48:20 +0000 | [diff] [blame] | 74 | /* |
| 75 | * Check for overflow only if we are within range of |
| 76 | * it in the max base we support (16) |
| 77 | */ |
| 78 | if (unlikely(res & (~0ull << 60))) { |
| 79 | if (res > div_u64(ULLONG_MAX - val, base)) |
Alexey Dobriyan | 8cfd56d | 2016-10-11 13:51:32 -0700 | [diff] [blame] | 80 | rv |= KSTRTOX_OVERFLOW; |
David Howells | 690d137 | 2012-02-09 15:48:20 +0000 | [diff] [blame] | 81 | } |
| 82 | res = res * base + val; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 83 | rv++; |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 84 | s++; |
| 85 | } |
David Howells | 690d137 | 2012-02-09 15:48:20 +0000 | [diff] [blame] | 86 | *p = res; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 87 | return rv; |
| 88 | } |
| 89 | |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 90 | noinline |
Richard Fitzgerald | 900fdc4 | 2021-05-14 17:12:04 +0100 | [diff] [blame] | 91 | unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p) |
| 92 | { |
| 93 | return _parse_integer_limit(s, base, p, INT_MAX); |
| 94 | } |
| 95 | |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 96 | static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res) |
| 97 | { |
| 98 | unsigned long long _res; |
| 99 | unsigned int rv; |
| 100 | |
| 101 | s = _parse_integer_fixup_radix(s, &base); |
| 102 | rv = _parse_integer(s, base, &_res); |
| 103 | if (rv & KSTRTOX_OVERFLOW) |
| 104 | return -ERANGE; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 105 | if (rv == 0) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 106 | return -EINVAL; |
Alexey Dobriyan | 1dff46d | 2011-10-31 17:12:28 -0700 | [diff] [blame] | 107 | s += rv; |
| 108 | if (*s == '\n') |
| 109 | s++; |
| 110 | if (*s) |
| 111 | return -EINVAL; |
| 112 | *res = _res; |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 113 | return 0; |
| 114 | } |
| 115 | |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 116 | /** |
| 117 | * kstrtoull - convert a string to an unsigned long long |
| 118 | * @s: The start of the string. The string must be null-terminated, and may also |
| 119 | * include a single newline before its terminating null. The first character |
| 120 | * may also be a plus sign, but not a minus sign. |
| 121 | * @base: The number base to use. The maximum supported base is 16. If base is |
| 122 | * given as 0, then the base of the string is automatically detected with the |
| 123 | * conventional semantics - If it begins with 0x the number will be parsed as a |
| 124 | * hexadecimal (case insensitive), if it otherwise begins with 0, it will be |
| 125 | * parsed as an octal number. Otherwise it will be parsed as a decimal. |
| 126 | * @res: Where to write the result of the conversion on success. |
| 127 | * |
| 128 | * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. |
Kars Mulder | ef0f268 | 2020-08-11 18:34:56 -0700 | [diff] [blame] | 129 | * Preferred over simple_strtoull(). Return code must be checked. |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 130 | */ |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 131 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 132 | int kstrtoull(const char *s, unsigned int base, unsigned long long *res) |
| 133 | { |
| 134 | if (s[0] == '+') |
| 135 | s++; |
| 136 | return _kstrtoull(s, base, res); |
| 137 | } |
| 138 | EXPORT_SYMBOL(kstrtoull); |
| 139 | |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 140 | /** |
| 141 | * kstrtoll - convert a string to a long long |
| 142 | * @s: The start of the string. The string must be null-terminated, and may also |
| 143 | * include a single newline before its terminating null. The first character |
| 144 | * may also be a plus sign or a minus sign. |
| 145 | * @base: The number base to use. The maximum supported base is 16. If base is |
| 146 | * given as 0, then the base of the string is automatically detected with the |
| 147 | * conventional semantics - If it begins with 0x the number will be parsed as a |
| 148 | * hexadecimal (case insensitive), if it otherwise begins with 0, it will be |
| 149 | * parsed as an octal number. Otherwise it will be parsed as a decimal. |
| 150 | * @res: Where to write the result of the conversion on success. |
| 151 | * |
| 152 | * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. |
Kars Mulder | ef0f268 | 2020-08-11 18:34:56 -0700 | [diff] [blame] | 153 | * Preferred over simple_strtoll(). Return code must be checked. |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 154 | */ |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 155 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 156 | int kstrtoll(const char *s, unsigned int base, long long *res) |
| 157 | { |
| 158 | unsigned long long tmp; |
| 159 | int rv; |
| 160 | |
| 161 | if (s[0] == '-') { |
| 162 | rv = _kstrtoull(s + 1, base, &tmp); |
| 163 | if (rv < 0) |
| 164 | return rv; |
Alexey Dobriyan | 2d2e471 | 2015-09-09 15:36:17 -0700 | [diff] [blame] | 165 | if ((long long)-tmp > 0) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 166 | return -ERANGE; |
| 167 | *res = -tmp; |
| 168 | } else { |
| 169 | rv = kstrtoull(s, base, &tmp); |
| 170 | if (rv < 0) |
| 171 | return rv; |
| 172 | if ((long long)tmp < 0) |
| 173 | return -ERANGE; |
| 174 | *res = tmp; |
| 175 | } |
| 176 | return 0; |
| 177 | } |
| 178 | EXPORT_SYMBOL(kstrtoll); |
| 179 | |
| 180 | /* Internal, do not use. */ |
| 181 | int _kstrtoul(const char *s, unsigned int base, unsigned long *res) |
| 182 | { |
| 183 | unsigned long long tmp; |
| 184 | int rv; |
| 185 | |
| 186 | rv = kstrtoull(s, base, &tmp); |
| 187 | if (rv < 0) |
| 188 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 189 | if (tmp != (unsigned long)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 190 | return -ERANGE; |
| 191 | *res = tmp; |
| 192 | return 0; |
| 193 | } |
| 194 | EXPORT_SYMBOL(_kstrtoul); |
| 195 | |
| 196 | /* Internal, do not use. */ |
| 197 | int _kstrtol(const char *s, unsigned int base, long *res) |
| 198 | { |
| 199 | long long tmp; |
| 200 | int rv; |
| 201 | |
| 202 | rv = kstrtoll(s, base, &tmp); |
| 203 | if (rv < 0) |
| 204 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 205 | if (tmp != (long)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 206 | return -ERANGE; |
| 207 | *res = tmp; |
| 208 | return 0; |
| 209 | } |
| 210 | EXPORT_SYMBOL(_kstrtol); |
| 211 | |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 212 | /** |
| 213 | * kstrtouint - convert a string to an unsigned int |
| 214 | * @s: The start of the string. The string must be null-terminated, and may also |
| 215 | * include a single newline before its terminating null. The first character |
| 216 | * may also be a plus sign, but not a minus sign. |
| 217 | * @base: The number base to use. The maximum supported base is 16. If base is |
| 218 | * given as 0, then the base of the string is automatically detected with the |
| 219 | * conventional semantics - If it begins with 0x the number will be parsed as a |
| 220 | * hexadecimal (case insensitive), if it otherwise begins with 0, it will be |
| 221 | * parsed as an octal number. Otherwise it will be parsed as a decimal. |
| 222 | * @res: Where to write the result of the conversion on success. |
| 223 | * |
| 224 | * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. |
Kars Mulder | ef0f268 | 2020-08-11 18:34:56 -0700 | [diff] [blame] | 225 | * Preferred over simple_strtoul(). Return code must be checked. |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 226 | */ |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 227 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 228 | int kstrtouint(const char *s, unsigned int base, unsigned int *res) |
| 229 | { |
| 230 | unsigned long long tmp; |
| 231 | int rv; |
| 232 | |
| 233 | rv = kstrtoull(s, base, &tmp); |
| 234 | if (rv < 0) |
| 235 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 236 | if (tmp != (unsigned int)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 237 | return -ERANGE; |
| 238 | *res = tmp; |
| 239 | return 0; |
| 240 | } |
| 241 | EXPORT_SYMBOL(kstrtouint); |
| 242 | |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 243 | /** |
| 244 | * kstrtoint - convert a string to an int |
| 245 | * @s: The start of the string. The string must be null-terminated, and may also |
| 246 | * include a single newline before its terminating null. The first character |
| 247 | * may also be a plus sign or a minus sign. |
| 248 | * @base: The number base to use. The maximum supported base is 16. If base is |
| 249 | * given as 0, then the base of the string is automatically detected with the |
| 250 | * conventional semantics - If it begins with 0x the number will be parsed as a |
| 251 | * hexadecimal (case insensitive), if it otherwise begins with 0, it will be |
| 252 | * parsed as an octal number. Otherwise it will be parsed as a decimal. |
| 253 | * @res: Where to write the result of the conversion on success. |
| 254 | * |
| 255 | * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. |
Kars Mulder | ef0f268 | 2020-08-11 18:34:56 -0700 | [diff] [blame] | 256 | * Preferred over simple_strtol(). Return code must be checked. |
Eldad Zack | 4c925d6 | 2012-12-17 16:03:04 -0800 | [diff] [blame] | 257 | */ |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 258 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 259 | int kstrtoint(const char *s, unsigned int base, int *res) |
| 260 | { |
| 261 | long long tmp; |
| 262 | int rv; |
| 263 | |
| 264 | rv = kstrtoll(s, base, &tmp); |
| 265 | if (rv < 0) |
| 266 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 267 | if (tmp != (int)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 268 | return -ERANGE; |
| 269 | *res = tmp; |
| 270 | return 0; |
| 271 | } |
| 272 | EXPORT_SYMBOL(kstrtoint); |
| 273 | |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 274 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 275 | int kstrtou16(const char *s, unsigned int base, u16 *res) |
| 276 | { |
| 277 | unsigned long long tmp; |
| 278 | int rv; |
| 279 | |
| 280 | rv = kstrtoull(s, base, &tmp); |
| 281 | if (rv < 0) |
| 282 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 283 | if (tmp != (u16)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 284 | return -ERANGE; |
| 285 | *res = tmp; |
| 286 | return 0; |
| 287 | } |
| 288 | EXPORT_SYMBOL(kstrtou16); |
| 289 | |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 290 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 291 | int kstrtos16(const char *s, unsigned int base, s16 *res) |
| 292 | { |
| 293 | long long tmp; |
| 294 | int rv; |
| 295 | |
| 296 | rv = kstrtoll(s, base, &tmp); |
| 297 | if (rv < 0) |
| 298 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 299 | if (tmp != (s16)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 300 | return -ERANGE; |
| 301 | *res = tmp; |
| 302 | return 0; |
| 303 | } |
| 304 | EXPORT_SYMBOL(kstrtos16); |
| 305 | |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 306 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 307 | int kstrtou8(const char *s, unsigned int base, u8 *res) |
| 308 | { |
| 309 | unsigned long long tmp; |
| 310 | int rv; |
| 311 | |
| 312 | rv = kstrtoull(s, base, &tmp); |
| 313 | if (rv < 0) |
| 314 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 315 | if (tmp != (u8)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 316 | return -ERANGE; |
| 317 | *res = tmp; |
| 318 | return 0; |
| 319 | } |
| 320 | EXPORT_SYMBOL(kstrtou8); |
| 321 | |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 322 | noinline |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 323 | int kstrtos8(const char *s, unsigned int base, s8 *res) |
| 324 | { |
| 325 | long long tmp; |
| 326 | int rv; |
| 327 | |
| 328 | rv = kstrtoll(s, base, &tmp); |
| 329 | if (rv < 0) |
| 330 | return rv; |
Alexey Dobriyan | 048e513 | 2018-10-30 15:05:46 -0700 | [diff] [blame] | 331 | if (tmp != (s8)tmp) |
Alexey Dobriyan | 33ee3b2 | 2011-03-22 16:34:40 -0700 | [diff] [blame] | 332 | return -ERANGE; |
| 333 | *res = tmp; |
| 334 | return 0; |
| 335 | } |
| 336 | EXPORT_SYMBOL(kstrtos8); |
Alexey Dobriyan | c196e32 | 2011-05-24 17:13:31 -0700 | [diff] [blame] | 337 | |
Kees Cook | ef95159 | 2016-03-17 14:22:50 -0700 | [diff] [blame] | 338 | /** |
| 339 | * kstrtobool - convert common user inputs into boolean values |
| 340 | * @s: input string |
| 341 | * @res: result |
| 342 | * |
Jagdish Gediya | 0d6ea3a | 2022-05-12 20:22:59 -0700 | [diff] [blame] | 343 | * This routine returns 0 iff the first character is one of 'YyTt1NnFf0', or |
Kees Cook | a81a5a1 | 2016-03-17 14:22:57 -0700 | [diff] [blame] | 344 | * [oO][NnFf] for "on" and "off". Otherwise it will return -EINVAL. Value |
| 345 | * pointed to by res is updated upon finding a match. |
Kees Cook | ef95159 | 2016-03-17 14:22:50 -0700 | [diff] [blame] | 346 | */ |
Alexey Dobriyan | 70ac699 | 2022-01-19 18:08:53 -0800 | [diff] [blame] | 347 | noinline |
Kees Cook | ef95159 | 2016-03-17 14:22:50 -0700 | [diff] [blame] | 348 | int kstrtobool(const char *s, bool *res) |
| 349 | { |
| 350 | if (!s) |
| 351 | return -EINVAL; |
| 352 | |
| 353 | switch (s[0]) { |
| 354 | case 'y': |
| 355 | case 'Y': |
Jagdish Gediya | 0d6ea3a | 2022-05-12 20:22:59 -0700 | [diff] [blame] | 356 | case 't': |
| 357 | case 'T': |
Kees Cook | ef95159 | 2016-03-17 14:22:50 -0700 | [diff] [blame] | 358 | case '1': |
| 359 | *res = true; |
| 360 | return 0; |
| 361 | case 'n': |
| 362 | case 'N': |
Jagdish Gediya | 0d6ea3a | 2022-05-12 20:22:59 -0700 | [diff] [blame] | 363 | case 'f': |
| 364 | case 'F': |
Kees Cook | ef95159 | 2016-03-17 14:22:50 -0700 | [diff] [blame] | 365 | case '0': |
| 366 | *res = false; |
| 367 | return 0; |
Kees Cook | a81a5a1 | 2016-03-17 14:22:57 -0700 | [diff] [blame] | 368 | case 'o': |
| 369 | case 'O': |
| 370 | switch (s[1]) { |
| 371 | case 'n': |
| 372 | case 'N': |
| 373 | *res = true; |
| 374 | return 0; |
| 375 | case 'f': |
| 376 | case 'F': |
| 377 | *res = false; |
| 378 | return 0; |
| 379 | default: |
| 380 | break; |
| 381 | } |
Gustavo A. R. Silva | 36f9ff9 | 2020-11-19 07:11:44 -0600 | [diff] [blame] | 382 | break; |
Kees Cook | ef95159 | 2016-03-17 14:22:50 -0700 | [diff] [blame] | 383 | default: |
| 384 | break; |
| 385 | } |
| 386 | |
| 387 | return -EINVAL; |
| 388 | } |
| 389 | EXPORT_SYMBOL(kstrtobool); |
| 390 | |
| 391 | /* |
| 392 | * Since "base" would be a nonsense argument, this open-codes the |
| 393 | * _from_user helper instead of using the helper macro below. |
| 394 | */ |
| 395 | int kstrtobool_from_user(const char __user *s, size_t count, bool *res) |
| 396 | { |
| 397 | /* Longest string needed to differentiate, newline, terminator */ |
| 398 | char buf[4]; |
| 399 | |
| 400 | count = min(count, sizeof(buf) - 1); |
| 401 | if (copy_from_user(buf, s, count)) |
| 402 | return -EFAULT; |
| 403 | buf[count] = '\0'; |
| 404 | return kstrtobool(buf, res); |
| 405 | } |
| 406 | EXPORT_SYMBOL(kstrtobool_from_user); |
| 407 | |
Alexey Dobriyan | c196e32 | 2011-05-24 17:13:31 -0700 | [diff] [blame] | 408 | #define kstrto_from_user(f, g, type) \ |
| 409 | int f(const char __user *s, size_t count, unsigned int base, type *res) \ |
| 410 | { \ |
| 411 | /* sign, base 2 representation, newline, terminator */ \ |
| 412 | char buf[1 + sizeof(type) * 8 + 1 + 1]; \ |
| 413 | \ |
| 414 | count = min(count, sizeof(buf) - 1); \ |
| 415 | if (copy_from_user(buf, s, count)) \ |
| 416 | return -EFAULT; \ |
| 417 | buf[count] = '\0'; \ |
| 418 | return g(buf, base, res); \ |
| 419 | } \ |
| 420 | EXPORT_SYMBOL(f) |
| 421 | |
| 422 | kstrto_from_user(kstrtoull_from_user, kstrtoull, unsigned long long); |
| 423 | kstrto_from_user(kstrtoll_from_user, kstrtoll, long long); |
| 424 | kstrto_from_user(kstrtoul_from_user, kstrtoul, unsigned long); |
| 425 | kstrto_from_user(kstrtol_from_user, kstrtol, long); |
| 426 | kstrto_from_user(kstrtouint_from_user, kstrtouint, unsigned int); |
| 427 | kstrto_from_user(kstrtoint_from_user, kstrtoint, int); |
| 428 | kstrto_from_user(kstrtou16_from_user, kstrtou16, u16); |
| 429 | kstrto_from_user(kstrtos16_from_user, kstrtos16, s16); |
| 430 | kstrto_from_user(kstrtou8_from_user, kstrtou8, u8); |
| 431 | kstrto_from_user(kstrtos8_from_user, kstrtos8, s8); |