Root/
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); |
349 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9