kmemleak: Select DEBUG_FS unconditionally in DEBUG_KMEMLEAK
[linux-2.6.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/module.h>
19 #include <linux/types.h>
20
21 static inline char _tolower(const char c)
22 {
23         return c | 0x20;
24 }
25
26 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
27 {
28         unsigned long long acc;
29         int ok;
30
31         if (base == 0) {
32                 if (s[0] == '0') {
33                         if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
34                                 base = 16;
35                         else
36                                 base = 8;
37                 } else
38                         base = 10;
39         }
40         if (base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
41                 s += 2;
42
43         acc = 0;
44         ok = 0;
45         while (*s) {
46                 unsigned int val;
47
48                 if ('0' <= *s && *s <= '9')
49                         val = *s - '0';
50                 else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
51                         val = _tolower(*s) - 'a' + 10;
52                 else if (*s == '\n' && *(s + 1) == '\0')
53                         break;
54                 else
55                         return -EINVAL;
56
57                 if (val >= base)
58                         return -EINVAL;
59                 if (acc > div_u64(ULLONG_MAX - val, base))
60                         return -ERANGE;
61                 acc = acc * base + val;
62                 ok = 1;
63
64                 s++;
65         }
66         if (!ok)
67                 return -EINVAL;
68         *res = acc;
69         return 0;
70 }
71
72 int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
73 {
74         if (s[0] == '+')
75                 s++;
76         return _kstrtoull(s, base, res);
77 }
78 EXPORT_SYMBOL(kstrtoull);
79
80 int kstrtoll(const char *s, unsigned int base, long long *res)
81 {
82         unsigned long long tmp;
83         int rv;
84
85         if (s[0] == '-') {
86                 rv = _kstrtoull(s + 1, base, &tmp);
87                 if (rv < 0)
88                         return rv;
89                 if ((long long)(-tmp) >= 0)
90                         return -ERANGE;
91                 *res = -tmp;
92         } else {
93                 rv = kstrtoull(s, base, &tmp);
94                 if (rv < 0)
95                         return rv;
96                 if ((long long)tmp < 0)
97                         return -ERANGE;
98                 *res = tmp;
99         }
100         return 0;
101 }
102 EXPORT_SYMBOL(kstrtoll);
103
104 /* Internal, do not use. */
105 int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
106 {
107         unsigned long long tmp;
108         int rv;
109
110         rv = kstrtoull(s, base, &tmp);
111         if (rv < 0)
112                 return rv;
113         if (tmp != (unsigned long long)(unsigned long)tmp)
114                 return -ERANGE;
115         *res = tmp;
116         return 0;
117 }
118 EXPORT_SYMBOL(_kstrtoul);
119
120 /* Internal, do not use. */
121 int _kstrtol(const char *s, unsigned int base, long *res)
122 {
123         long long tmp;
124         int rv;
125
126         rv = kstrtoll(s, base, &tmp);
127         if (rv < 0)
128                 return rv;
129         if (tmp != (long long)(long)tmp)
130                 return -ERANGE;
131         *res = tmp;
132         return 0;
133 }
134 EXPORT_SYMBOL(_kstrtol);
135
136 int kstrtouint(const char *s, unsigned int base, unsigned int *res)
137 {
138         unsigned long long tmp;
139         int rv;
140
141         rv = kstrtoull(s, base, &tmp);
142         if (rv < 0)
143                 return rv;
144         if (tmp != (unsigned long long)(unsigned int)tmp)
145                 return -ERANGE;
146         *res = tmp;
147         return 0;
148 }
149 EXPORT_SYMBOL(kstrtouint);
150
151 int kstrtoint(const char *s, unsigned int base, int *res)
152 {
153         long long tmp;
154         int rv;
155
156         rv = kstrtoll(s, base, &tmp);
157         if (rv < 0)
158                 return rv;
159         if (tmp != (long long)(int)tmp)
160                 return -ERANGE;
161         *res = tmp;
162         return 0;
163 }
164 EXPORT_SYMBOL(kstrtoint);
165
166 int kstrtou16(const char *s, unsigned int base, u16 *res)
167 {
168         unsigned long long tmp;
169         int rv;
170
171         rv = kstrtoull(s, base, &tmp);
172         if (rv < 0)
173                 return rv;
174         if (tmp != (unsigned long long)(u16)tmp)
175                 return -ERANGE;
176         *res = tmp;
177         return 0;
178 }
179 EXPORT_SYMBOL(kstrtou16);
180
181 int kstrtos16(const char *s, unsigned int base, s16 *res)
182 {
183         long long tmp;
184         int rv;
185
186         rv = kstrtoll(s, base, &tmp);
187         if (rv < 0)
188                 return rv;
189         if (tmp != (long long)(s16)tmp)
190                 return -ERANGE;
191         *res = tmp;
192         return 0;
193 }
194 EXPORT_SYMBOL(kstrtos16);
195
196 int kstrtou8(const char *s, unsigned int base, u8 *res)
197 {
198         unsigned long long tmp;
199         int rv;
200
201         rv = kstrtoull(s, base, &tmp);
202         if (rv < 0)
203                 return rv;
204         if (tmp != (unsigned long long)(u8)tmp)
205                 return -ERANGE;
206         *res = tmp;
207         return 0;
208 }
209 EXPORT_SYMBOL(kstrtou8);
210
211 int kstrtos8(const char *s, unsigned int base, s8 *res)
212 {
213         long long tmp;
214         int rv;
215
216         rv = kstrtoll(s, base, &tmp);
217         if (rv < 0)
218                 return rv;
219         if (tmp != (long long)(s8)tmp)
220                 return -ERANGE;
221         *res = tmp;
222         return 0;
223 }
224 EXPORT_SYMBOL(kstrtos8);