misc: tegra-profiler: fix stopping the session
[linux-3.10.git] / lib / kstrtox.c
1 /*
2  * Convert integer string representation to an integer.
3  * If an integer doesn't fit into specified type, -E is returned.
4  *
5  * Integer starts with optional sign.
6  * kstrtou*() functions do not accept sign "-".
7  *
8  * Radix 0 means autodetection: leading "0x" implies radix 16,
9  * leading "0" implies radix 8, otherwise radix is 10.
10  * Autodetection hints work after optional sign, but not before.
11  *
12  * If -E is returned, result is not touched.
13  */
14 #include <linux/ctype.h>
15 #include <linux/errno.h>
16 #include <linux/kernel.h>
17 #include <linux/math64.h>
18 #include <linux/export.h>
19 #include <linux/types.h>
20 #include <asm/uaccess.h>
21 #include "kstrtox.h"
22
23 const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
24 {
25         if (*base == 0) {
26                 if (s[0] == '0') {
27                         if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
28                                 *base = 16;
29                         else
30                                 *base = 8;
31                 } else
32                         *base = 10;
33         }
34         if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
35                 s += 2;
36         return s;
37 }
38
39 /*
40  * Convert non-negative integer string representation in explicitly given radix
41  * to an integer.
42  * Return number of characters consumed maybe or-ed with overflow bit.
43  * If overflow occurs, result integer (incorrect) is still returned.
44  *
45  * Don't you dare use this function.
46  */
47 unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)
48 {
49         unsigned long long res;
50         unsigned int rv;
51         int overflow;
52
53         res = 0;
54         rv = 0;
55         overflow = 0;
56         while (*s) {
57                 unsigned int val;
58
59                 if ('0' <= *s && *s <= '9')
60                         val = *s - '0';
61                 else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
62                         val = _tolower(*s) - 'a' + 10;
63                 else
64                         break;
65
66                 if (val >= base)
67                         break;
68                 /*
69                  * Check for overflow only if we are within range of
70                  * it in the max base we support (16)
71                  */
72                 if (unlikely(res & (~0ull << 60))) {
73                         if (res > div_u64(ULLONG_MAX - val, base))
74                                 overflow = 1;
75                 }
76                 res = res * base + val;
77                 rv++;
78                 s++;
79         }
80         *p = res;
81         if (overflow)
82                 rv |= KSTRTOX_OVERFLOW;
83         return rv;
84 }
85
86 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
87 {
88         unsigned long long _res;
89         unsigned int rv;
90
91         s = _parse_integer_fixup_radix(s, &base);
92         rv = _parse_integer(s, base, &_res);
93         if (rv & KSTRTOX_OVERFLOW)
94                 return -ERANGE;
95         rv &= ~KSTRTOX_OVERFLOW;
96         if (rv == 0)
97                 return -EINVAL;
98         s += rv;
99         if (*s == '\n')
100                 s++;
101         if (*s)
102                 return -EINVAL;
103         *res = _res;
104         return 0;
105 }
106
107 /**
108  * kstrtoull - convert a string to an unsigned long long
109  * @s: The start of the string. The string must be null-terminated, and may also
110  *  include a single newline before its terminating null. The first character
111  *  may also be a plus sign, but not a minus sign.
112  * @base: The number base to use. The maximum supported base is 16. If base is
113  *  given as 0, then the base of the string is automatically detected with the
114  *  conventional semantics - If it begins with 0x the number will be parsed as a
115  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
116  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
117  * @res: Where to write the result of the conversion on success.
118  *
119  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
120  * Used as a replacement for the obsolete simple_strtoull. Return code must
121  * be checked.
122  */
123 int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
124 {
125         if (s[0] == '+')
126                 s++;
127         return _kstrtoull(s, base, res);
128 }
129 EXPORT_SYMBOL(kstrtoull);
130
131 /**
132  * kstrtoll - convert a string to a long long
133  * @s: The start of the string. The string must be null-terminated, and may also
134  *  include a single newline before its terminating null. The first character
135  *  may also be a plus sign or a minus sign.
136  * @base: The number base to use. The maximum supported base is 16. If base is
137  *  given as 0, then the base of the string is automatically detected with the
138  *  conventional semantics - If it begins with 0x the number will be parsed as a
139  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
140  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
141  * @res: Where to write the result of the conversion on success.
142  *
143  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
144  * Used as a replacement for the obsolete simple_strtoull. Return code must
145  * be checked.
146  */
147 int kstrtoll(const char *s, unsigned int base, long long *res)
148 {
149         unsigned long long tmp;
150         int rv;
151
152         if (s[0] == '-') {
153                 rv = _kstrtoull(s + 1, base, &tmp);
154                 if (rv < 0)
155                         return rv;
156                 if ((long long)(-tmp) >= 0)
157                         return -ERANGE;
158                 *res = -tmp;
159         } else {
160                 rv = kstrtoull(s, base, &tmp);
161                 if (rv < 0)
162                         return rv;
163                 if ((long long)tmp < 0)
164                         return -ERANGE;
165                 *res = tmp;
166         }
167         return 0;
168 }
169 EXPORT_SYMBOL(kstrtoll);
170
171 /* Internal, do not use. */
172 int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
173 {
174         unsigned long long tmp;
175         int rv;
176
177         rv = kstrtoull(s, base, &tmp);
178         if (rv < 0)
179                 return rv;
180         if (tmp != (unsigned long long)(unsigned long)tmp)
181                 return -ERANGE;
182         *res = tmp;
183         return 0;
184 }
185 EXPORT_SYMBOL(_kstrtoul);
186
187 /* Internal, do not use. */
188 int _kstrtol(const char *s, unsigned int base, long *res)
189 {
190         long long tmp;
191         int rv;
192
193         rv = kstrtoll(s, base, &tmp);
194         if (rv < 0)
195                 return rv;
196         if (tmp != (long long)(long)tmp)
197                 return -ERANGE;
198         *res = tmp;
199         return 0;
200 }
201 EXPORT_SYMBOL(_kstrtol);
202
203 /**
204  * kstrtouint - convert a string to an unsigned int
205  * @s: The start of the string. The string must be null-terminated, and may also
206  *  include a single newline before its terminating null. The first character
207  *  may also be a plus sign, but not a minus sign.
208  * @base: The number base to use. The maximum supported base is 16. If base is
209  *  given as 0, then the base of the string is automatically detected with the
210  *  conventional semantics - If it begins with 0x the number will be parsed as a
211  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
212  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
213  * @res: Where to write the result of the conversion on success.
214  *
215  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
216  * Used as a replacement for the obsolete simple_strtoull. Return code must
217  * be checked.
218  */
219 int kstrtouint(const char *s, unsigned int base, unsigned int *res)
220 {
221         unsigned long long tmp;
222         int rv;
223
224         rv = kstrtoull(s, base, &tmp);
225         if (rv < 0)
226                 return rv;
227         if (tmp != (unsigned long long)(unsigned int)tmp)
228                 return -ERANGE;
229         *res = tmp;
230         return 0;
231 }
232 EXPORT_SYMBOL(kstrtouint);
233
234 /**
235  * kstrtoint - convert a string to an int
236  * @s: The start of the string. The string must be null-terminated, and may also
237  *  include a single newline before its terminating null. The first character
238  *  may also be a plus sign or a minus sign.
239  * @base: The number base to use. The maximum supported base is 16. If base is
240  *  given as 0, then the base of the string is automatically detected with the
241  *  conventional semantics - If it begins with 0x the number will be parsed as a
242  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
243  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
244  * @res: Where to write the result of the conversion on success.
245  *
246  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
247  * Used as a replacement for the obsolete simple_strtoull. Return code must
248  * be checked.
249  */
250 int kstrtoint(const char *s, unsigned int base, int *res)
251 {
252         long long tmp;
253         int rv;
254
255         rv = kstrtoll(s, base, &tmp);
256         if (rv < 0)
257                 return rv;
258         if (tmp != (long long)(int)tmp)
259                 return -ERANGE;
260         *res = tmp;
261         return 0;
262 }
263 EXPORT_SYMBOL(kstrtoint);
264
265 int kstrtou16(const char *s, unsigned int base, u16 *res)
266 {
267         unsigned long long tmp;
268         int rv;
269
270         rv = kstrtoull(s, base, &tmp);
271         if (rv < 0)
272                 return rv;
273         if (tmp != (unsigned long long)(u16)tmp)
274                 return -ERANGE;
275         *res = tmp;
276         return 0;
277 }
278 EXPORT_SYMBOL(kstrtou16);
279
280 int kstrtos16(const char *s, unsigned int base, s16 *res)
281 {
282         long long tmp;
283         int rv;
284
285         rv = kstrtoll(s, base, &tmp);
286         if (rv < 0)
287                 return rv;
288         if (tmp != (long long)(s16)tmp)
289                 return -ERANGE;
290         *res = tmp;
291         return 0;
292 }
293 EXPORT_SYMBOL(kstrtos16);
294
295 int kstrtou8(const char *s, unsigned int base, u8 *res)
296 {
297         unsigned long long tmp;
298         int rv;
299
300         rv = kstrtoull(s, base, &tmp);
301         if (rv < 0)
302                 return rv;
303         if (tmp != (unsigned long long)(u8)tmp)
304                 return -ERANGE;
305         *res = tmp;
306         return 0;
307 }
308 EXPORT_SYMBOL(kstrtou8);
309
310 int kstrtos8(const char *s, unsigned int base, s8 *res)
311 {
312         long long tmp;
313         int rv;
314
315         rv = kstrtoll(s, base, &tmp);
316         if (rv < 0)
317                 return rv;
318         if (tmp != (long long)(s8)tmp)
319                 return -ERANGE;
320         *res = tmp;
321         return 0;
322 }
323 EXPORT_SYMBOL(kstrtos8);
324
325 #define kstrto_from_user(f, g, type)                                    \
326 int f(const char __user *s, size_t count, unsigned int base, type *res) \
327 {                                                                       \
328         /* sign, base 2 representation, newline, terminator */          \
329         char buf[1 + sizeof(type) * 8 + 1 + 1];                         \
330                                                                         \
331         count = min(count, sizeof(buf) - 1);                            \
332         if (copy_from_user(buf, s, count))                              \
333                 return -EFAULT;                                         \
334         buf[count] = '\0';                                              \
335         return g(buf, base, res);                                       \
336 }                                                                       \
337 EXPORT_SYMBOL(f)
338
339 kstrto_from_user(kstrtoull_from_user,   kstrtoull,      unsigned long long);
340 kstrto_from_user(kstrtoll_from_user,    kstrtoll,       long long);
341 kstrto_from_user(kstrtoul_from_user,    kstrtoul,       unsigned long);
342 kstrto_from_user(kstrtol_from_user,     kstrtol,        long);
343 kstrto_from_user(kstrtouint_from_user,  kstrtouint,     unsigned int);
344 kstrto_from_user(kstrtoint_from_user,   kstrtoint,      int);
345 kstrto_from_user(kstrtou16_from_user,   kstrtou16,      u16);
346 kstrto_from_user(kstrtos16_from_user,   kstrtos16,      s16);
347 kstrto_from_user(kstrtou8_from_user,    kstrtou8,       u8);
348 kstrto_from_user(kstrtos8_from_user,    kstrtos8,       s8);