blob: 46d34b0b74a873290b0cd9fcfff6c19561c91de4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/lib/vsprintf.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8/*
9 * Wirzenius wrote this portably, Torvalds fucked it up :-)
10 */
11
André Goddard Rosa7b9186f2009-12-14 18:00:57 -080012/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
14 * - changed to provide snprintf and vsnprintf functions
15 * So Feb 1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>
16 * - scnprintf and vscnprintf
17 */
18
19#include <stdarg.h>
20#include <linux/module.h>
21#include <linux/types.h>
22#include <linux/string.h>
23#include <linux/ctype.h>
24#include <linux/kernel.h>
Linus Torvalds0fe1ef22008-07-06 16:43:12 -070025#include <linux/kallsyms.h>
26#include <linux/uaccess.h>
Linus Torvalds332d2e72008-10-20 15:07:34 +110027#include <linux/ioport.h>
Joe Perches8a27f7c2009-08-17 12:29:44 +000028#include <net/addrconf.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Tim Schmielau4e57b682005-10-30 15:03:48 -080030#include <asm/page.h> /* for PAGE_SIZE */
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <asm/div64.h>
James Bottomleydeac93d2008-09-03 20:43:36 -050032#include <asm/sections.h> /* for dereference_function_descriptor() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Denys Vlasenko9b706ae2008-02-09 23:24:09 +010034/* Works only for digits and letters, but small and fast */
35#define TOLOWER(x) ((x) | 0x20)
36
Harvey Harrisonaa46a632008-10-16 13:40:34 -070037static unsigned int simple_guess_base(const char *cp)
38{
39 if (cp[0] == '0') {
40 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
41 return 16;
42 else
43 return 8;
44 } else {
45 return 10;
46 }
47}
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 * simple_strtoull - convert a string to an unsigned long long
51 * @cp: The start of the string
52 * @endp: A pointer to the end of the parsed string will be placed here
53 * @base: The number base to use
54 */
Harvey Harrison22d27052008-10-16 13:40:35 -070055unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
Harvey Harrisonaa46a632008-10-16 13:40:34 -070057 unsigned long long result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Harvey Harrisonaa46a632008-10-16 13:40:34 -070059 if (!base)
60 base = simple_guess_base(cp);
61
62 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
63 cp += 2;
64
65 while (isxdigit(*cp)) {
66 unsigned int value;
67
68 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
69 if (value >= base)
70 break;
71 result = result * base + value;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 cp++;
73 }
74 if (endp)
75 *endp = (char *)cp;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -080076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return result;
78}
Linus Torvalds1da177e2005-04-16 15:20:36 -070079EXPORT_SYMBOL(simple_strtoull);
80
81/**
André Goddard Rosa922ac252009-12-14 18:01:01 -080082 * simple_strtoul - convert a string to an unsigned long
83 * @cp: The start of the string
84 * @endp: A pointer to the end of the parsed string will be placed here
85 * @base: The number base to use
86 */
87unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
88{
89 return simple_strtoull(cp, endp, base);
90}
91EXPORT_SYMBOL(simple_strtoul);
92
93/**
94 * simple_strtol - convert a string to a signed long
95 * @cp: The start of the string
96 * @endp: A pointer to the end of the parsed string will be placed here
97 * @base: The number base to use
98 */
99long simple_strtol(const char *cp, char **endp, unsigned int base)
100{
101 if (*cp == '-')
102 return -simple_strtoul(cp + 1, endp, base);
103
104 return simple_strtoul(cp, endp, base);
105}
106EXPORT_SYMBOL(simple_strtol);
107
108/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 * simple_strtoll - convert a string to a signed long long
110 * @cp: The start of the string
111 * @endp: A pointer to the end of the parsed string will be placed here
112 * @base: The number base to use
113 */
Harvey Harrison22d27052008-10-16 13:40:35 -0700114long long simple_strtoll(const char *cp, char **endp, unsigned int base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115{
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800116 if (*cp == '-')
Harvey Harrison22d27052008-10-16 13:40:35 -0700117 return -simple_strtoull(cp + 1, endp, base);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800118
Harvey Harrison22d27052008-10-16 13:40:35 -0700119 return simple_strtoull(cp, endp, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120}
Hans Verkuil98d5ce02010-04-23 13:18:04 -0400121EXPORT_SYMBOL(simple_strtoll);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Yi Yang06b2a762008-02-08 04:21:57 -0800123/**
124 * strict_strtoul - convert a string to an unsigned long strictly
125 * @cp: The string to be converted
126 * @base: The number base to use
127 * @res: The converted result value
128 *
129 * strict_strtoul converts a string to an unsigned long only if the
130 * string is really an unsigned long string, any string containing
131 * any invalid char at the tail will be rejected and -EINVAL is returned,
132 * only a newline char at the tail is acceptible because people generally
133 * change a module parameter in the following way:
134 *
135 * echo 1024 > /sys/module/e1000/parameters/copybreak
136 *
137 * echo will append a newline to the tail.
138 *
139 * It returns 0 if conversion is successful and *res is set to the converted
140 * value, otherwise it returns -EINVAL and *res is set to 0.
141 *
142 * simple_strtoul just ignores the successive invalid characters and
143 * return the converted value of prefix part of the string.
144 */
Harvey Harrison9d85db22008-10-16 13:40:35 -0700145int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
146{
147 char *tail;
148 unsigned long val;
149 size_t len;
150
151 *res = 0;
152 len = strlen(cp);
153 if (len == 0)
154 return -EINVAL;
155
156 val = simple_strtoul(cp, &tail, base);
Pavel Macheke899aa82009-01-06 14:40:53 -0800157 if (tail == cp)
158 return -EINVAL;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800159
Harvey Harrison9d85db22008-10-16 13:40:35 -0700160 if ((*tail == '\0') ||
161 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
162 *res = val;
163 return 0;
164 }
165
166 return -EINVAL;
167}
168EXPORT_SYMBOL(strict_strtoul);
Yi Yang06b2a762008-02-08 04:21:57 -0800169
170/**
171 * strict_strtol - convert a string to a long strictly
172 * @cp: The string to be converted
173 * @base: The number base to use
174 * @res: The converted result value
175 *
176 * strict_strtol is similiar to strict_strtoul, but it allows the first
177 * character of a string is '-'.
178 *
179 * It returns 0 if conversion is successful and *res is set to the converted
180 * value, otherwise it returns -EINVAL and *res is set to 0.
181 */
Harvey Harrison9d85db22008-10-16 13:40:35 -0700182int strict_strtol(const char *cp, unsigned int base, long *res)
183{
184 int ret;
185 if (*cp == '-') {
186 ret = strict_strtoul(cp + 1, base, (unsigned long *)res);
187 if (!ret)
188 *res = -(*res);
189 } else {
190 ret = strict_strtoul(cp, base, (unsigned long *)res);
191 }
192
193 return ret;
194}
195EXPORT_SYMBOL(strict_strtol);
Yi Yang06b2a762008-02-08 04:21:57 -0800196
197/**
198 * strict_strtoull - convert a string to an unsigned long long strictly
199 * @cp: The string to be converted
200 * @base: The number base to use
201 * @res: The converted result value
202 *
203 * strict_strtoull converts a string to an unsigned long long only if the
204 * string is really an unsigned long long string, any string containing
205 * any invalid char at the tail will be rejected and -EINVAL is returned,
206 * only a newline char at the tail is acceptible because people generally
207 * change a module parameter in the following way:
208 *
209 * echo 1024 > /sys/module/e1000/parameters/copybreak
210 *
211 * echo will append a newline to the tail of the string.
212 *
213 * It returns 0 if conversion is successful and *res is set to the converted
214 * value, otherwise it returns -EINVAL and *res is set to 0.
215 *
216 * simple_strtoull just ignores the successive invalid characters and
217 * return the converted value of prefix part of the string.
218 */
Harvey Harrison9d85db22008-10-16 13:40:35 -0700219int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res)
220{
221 char *tail;
222 unsigned long long val;
223 size_t len;
224
225 *res = 0;
226 len = strlen(cp);
227 if (len == 0)
228 return -EINVAL;
229
230 val = simple_strtoull(cp, &tail, base);
Pavel Macheke899aa82009-01-06 14:40:53 -0800231 if (tail == cp)
232 return -EINVAL;
Harvey Harrison9d85db22008-10-16 13:40:35 -0700233 if ((*tail == '\0') ||
234 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
235 *res = val;
236 return 0;
237 }
238
239 return -EINVAL;
240}
241EXPORT_SYMBOL(strict_strtoull);
Yi Yang06b2a762008-02-08 04:21:57 -0800242
243/**
244 * strict_strtoll - convert a string to a long long strictly
245 * @cp: The string to be converted
246 * @base: The number base to use
247 * @res: The converted result value
248 *
249 * strict_strtoll is similiar to strict_strtoull, but it allows the first
250 * character of a string is '-'.
251 *
252 * It returns 0 if conversion is successful and *res is set to the converted
253 * value, otherwise it returns -EINVAL and *res is set to 0.
254 */
Harvey Harrison9d85db22008-10-16 13:40:35 -0700255int strict_strtoll(const char *cp, unsigned int base, long long *res)
256{
257 int ret;
258 if (*cp == '-') {
259 ret = strict_strtoull(cp + 1, base, (unsigned long long *)res);
260 if (!ret)
261 *res = -(*res);
262 } else {
263 ret = strict_strtoull(cp, base, (unsigned long long *)res);
264 }
Yi Yang06b2a762008-02-08 04:21:57 -0800265
Harvey Harrison9d85db22008-10-16 13:40:35 -0700266 return ret;
267}
Yi Yang06b2a762008-02-08 04:21:57 -0800268EXPORT_SYMBOL(strict_strtoll);
Yi Yang06b2a762008-02-08 04:21:57 -0800269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270static int skip_atoi(const char **s)
271{
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800272 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 while (isdigit(**s))
275 i = i*10 + *((*s)++) - '0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 return i;
278}
279
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700280/* Decimal conversion is by far the most typical, and is used
281 * for /proc and /sys data. This directly impacts e.g. top performance
282 * with many processes running. We optimize it for speed
283 * using code from
284 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
285 * (with permission from the author, Douglas W. Jones). */
286
287/* Formats correctly any integer in [0,99999].
288 * Outputs from one to five digits depending on input.
289 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800290static char *put_dec_trunc(char *buf, unsigned q)
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700291{
292 unsigned d3, d2, d1, d0;
293 d1 = (q>>4) & 0xf;
294 d2 = (q>>8) & 0xf;
295 d3 = (q>>12);
296
297 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
298 q = (d0 * 0xcd) >> 11;
299 d0 = d0 - 10*q;
300 *buf++ = d0 + '0'; /* least significant digit */
301 d1 = q + 9*d3 + 5*d2 + d1;
302 if (d1 != 0) {
303 q = (d1 * 0xcd) >> 11;
304 d1 = d1 - 10*q;
305 *buf++ = d1 + '0'; /* next digit */
306
307 d2 = q + 2*d2;
308 if ((d2 != 0) || (d3 != 0)) {
309 q = (d2 * 0xd) >> 7;
310 d2 = d2 - 10*q;
311 *buf++ = d2 + '0'; /* next digit */
312
313 d3 = q + 4*d3;
314 if (d3 != 0) {
315 q = (d3 * 0xcd) >> 11;
316 d3 = d3 - 10*q;
317 *buf++ = d3 + '0'; /* next digit */
318 if (q != 0)
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800319 *buf++ = q + '0'; /* most sign. digit */
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700320 }
321 }
322 }
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800323
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700324 return buf;
325}
326/* Same with if's removed. Always emits five digits */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800327static char *put_dec_full(char *buf, unsigned q)
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700328{
329 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
330 /* but anyway, gcc produces better code with full-sized ints */
331 unsigned d3, d2, d1, d0;
332 d1 = (q>>4) & 0xf;
333 d2 = (q>>8) & 0xf;
334 d3 = (q>>12);
335
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800336 /*
337 * Possible ways to approx. divide by 10
338 * gcc -O2 replaces multiply with shifts and adds
339 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
340 * (x * 0x67) >> 10: 1100111
341 * (x * 0x34) >> 9: 110100 - same
342 * (x * 0x1a) >> 8: 11010 - same
343 * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386)
344 */
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700345 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
346 q = (d0 * 0xcd) >> 11;
347 d0 = d0 - 10*q;
348 *buf++ = d0 + '0';
349 d1 = q + 9*d3 + 5*d2 + d1;
350 q = (d1 * 0xcd) >> 11;
351 d1 = d1 - 10*q;
352 *buf++ = d1 + '0';
353
354 d2 = q + 2*d2;
355 q = (d2 * 0xd) >> 7;
356 d2 = d2 - 10*q;
357 *buf++ = d2 + '0';
358
359 d3 = q + 4*d3;
360 q = (d3 * 0xcd) >> 11; /* - shorter code */
361 /* q = (d3 * 0x67) >> 10; - would also work */
362 d3 = d3 - 10*q;
363 *buf++ = d3 + '0';
364 *buf++ = q + '0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800365
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700366 return buf;
367}
368/* No inlining helps gcc to use registers better */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800369static noinline char *put_dec(char *buf, unsigned long long num)
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700370{
371 while (1) {
372 unsigned rem;
373 if (num < 100000)
374 return put_dec_trunc(buf, num);
375 rem = do_div(num, 100000);
376 buf = put_dec_full(buf, rem);
377 }
378}
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380#define ZEROPAD 1 /* pad with zero */
381#define SIGN 2 /* unsigned/signed long */
382#define PLUS 4 /* show plus */
383#define SPACE 8 /* space if plus */
384#define LEFT 16 /* left justified */
Bjorn Helgaasb89dc5d2010-03-05 10:47:31 -0700385#define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */
386#define SPECIAL 64 /* prefix hex with "0x", octal with "0" */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100388enum format_type {
389 FORMAT_TYPE_NONE, /* Just a string part */
Vegard Nossumed681a92009-03-14 12:08:50 +0100390 FORMAT_TYPE_WIDTH,
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100391 FORMAT_TYPE_PRECISION,
392 FORMAT_TYPE_CHAR,
393 FORMAT_TYPE_STR,
394 FORMAT_TYPE_PTR,
395 FORMAT_TYPE_PERCENT_CHAR,
396 FORMAT_TYPE_INVALID,
397 FORMAT_TYPE_LONG_LONG,
398 FORMAT_TYPE_ULONG,
399 FORMAT_TYPE_LONG,
Zhaoleia4e94ef2009-03-27 17:07:05 +0800400 FORMAT_TYPE_UBYTE,
401 FORMAT_TYPE_BYTE,
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100402 FORMAT_TYPE_USHORT,
403 FORMAT_TYPE_SHORT,
404 FORMAT_TYPE_UINT,
405 FORMAT_TYPE_INT,
406 FORMAT_TYPE_NRCHARS,
407 FORMAT_TYPE_SIZE_T,
408 FORMAT_TYPE_PTRDIFF
409};
410
411struct printf_spec {
Joe Perches4e310fd2010-04-14 09:27:40 -0700412 u8 type; /* format_type enum */
Joe Perchesef0658f2010-03-06 17:10:14 -0800413 u8 flags; /* flags to number() */
Joe Perches4e310fd2010-04-14 09:27:40 -0700414 u8 base; /* number base, 8, 10 or 16 only */
415 u8 qualifier; /* number qualifier, one of 'hHlLtzZ' */
416 s16 field_width; /* width of output field */
417 s16 precision; /* # of digits/chars */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100418};
419
420static char *number(char *buf, char *end, unsigned long long num,
421 struct printf_spec spec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100423 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
424 static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
425
426 char tmp[66];
427 char sign;
428 char locase;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100429 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 int i;
431
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100432 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
433 * produces same digits or (maybe lowercased) letters */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100434 locase = (spec.flags & SMALL);
435 if (spec.flags & LEFT)
436 spec.flags &= ~ZEROPAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 sign = 0;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100438 if (spec.flags & SIGN) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800439 if ((signed long long)num < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 sign = '-';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800441 num = -(signed long long)num;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100442 spec.field_width--;
443 } else if (spec.flags & PLUS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 sign = '+';
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100445 spec.field_width--;
446 } else if (spec.flags & SPACE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 sign = ' ';
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100448 spec.field_width--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
450 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700451 if (need_pfx) {
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100452 spec.field_width--;
453 if (spec.base == 16)
454 spec.field_width--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700456
457 /* generate full string in tmp[], in reverse order */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 i = 0;
459 if (num == 0)
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700460 tmp[i++] = '0';
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700461 /* Generic code, for any base:
462 else do {
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100463 tmp[i++] = (digits[do_div(num,base)] | locase);
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700464 } while (num != 0);
465 */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100466 else if (spec.base != 10) { /* 8 or 16 */
467 int mask = spec.base - 1;
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700468 int shift = 3;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800469
470 if (spec.base == 16)
471 shift = 4;
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700472 do {
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100473 tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700474 num >>= shift;
475 } while (num);
Denis Vlasenko4277eed2007-07-15 23:41:56 -0700476 } else { /* base 10 */
477 i = put_dec(tmp, num) - tmp;
478 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700479
480 /* printing 100 using %2d gives "100", not "00" */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100481 if (i > spec.precision)
482 spec.precision = i;
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700483 /* leading space padding */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100484 spec.field_width -= spec.precision;
485 if (!(spec.flags & (ZEROPAD+LEFT))) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800486 while (--spec.field_width >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700487 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 *buf = ' ';
489 ++buf;
490 }
491 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700492 /* sign */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (sign) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700494 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 *buf = sign;
496 ++buf;
497 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700498 /* "0x" / "0" prefix */
499 if (need_pfx) {
500 if (buf < end)
501 *buf = '0';
502 ++buf;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100503 if (spec.base == 16) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700504 if (buf < end)
Denys Vlasenko9b706ae2008-02-09 23:24:09 +0100505 *buf = ('X' | locase);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 ++buf;
507 }
508 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700509 /* zero or space padding */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100510 if (!(spec.flags & LEFT)) {
511 char c = (spec.flags & ZEROPAD) ? '0' : ' ';
512 while (--spec.field_width >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700513 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 *buf = c;
515 ++buf;
516 }
517 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700518 /* hmm even more zero padding? */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100519 while (i <= --spec.precision) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700520 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 *buf = '0';
522 ++buf;
523 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700524 /* actual digits of result */
525 while (--i >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700526 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 *buf = tmp[i];
528 ++buf;
529 }
Denis Vlasenkob39a7342007-07-15 23:41:54 -0700530 /* trailing space padding */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100531 while (--spec.field_width >= 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -0700532 if (buf < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 *buf = ' ';
534 ++buf;
535 }
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return buf;
538}
539
André Goddard Rosa0f4f81d2009-12-14 18:00:55 -0800540static char *string(char *buf, char *end, const char *s, struct printf_spec spec)
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700541{
542 int len, i;
543
544 if ((unsigned long)s < PAGE_SIZE)
André Goddard Rosa0f4f81d2009-12-14 18:00:55 -0800545 s = "(null)";
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700546
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100547 len = strnlen(s, spec.precision);
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700548
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100549 if (!(spec.flags & LEFT)) {
550 while (len < spec.field_width--) {
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700551 if (buf < end)
552 *buf = ' ';
553 ++buf;
554 }
555 }
556 for (i = 0; i < len; ++i) {
557 if (buf < end)
558 *buf = *s;
559 ++buf; ++s;
560 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100561 while (len < spec.field_width--) {
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700562 if (buf < end)
563 *buf = ' ';
564 ++buf;
565 }
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800566
Linus Torvalds0f9bfa52008-07-06 16:06:25 -0700567 return buf;
568}
569
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100570static char *symbol_string(char *buf, char *end, void *ptr,
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +0200571 struct printf_spec spec, char ext)
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700572{
573 unsigned long value = (unsigned long) ptr;
574#ifdef CONFIG_KALLSYMS
575 char sym[KSYM_SYMBOL_LEN];
Steven Rostedt91adcd22009-09-16 20:03:06 -0400576 if (ext != 'f' && ext != 's')
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +0200577 sprint_symbol(sym, value);
578 else
579 kallsyms_lookup(value, NULL, NULL, NULL, sym);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800580
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100581 return string(buf, end, sym, spec);
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700582#else
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800583 spec.field_width = 2 * sizeof(void *);
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100584 spec.flags |= SPECIAL | SMALL | ZEROPAD;
585 spec.base = 16;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800586
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100587 return number(buf, end, value, spec);
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700588#endif
589}
590
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100591static char *resource_string(char *buf, char *end, struct resource *res,
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600592 struct printf_spec spec, const char *fmt)
Linus Torvalds332d2e72008-10-20 15:07:34 +1100593{
594#ifndef IO_RSRC_PRINTK_SIZE
Bjorn Helgaas28405372009-10-06 15:33:29 -0600595#define IO_RSRC_PRINTK_SIZE 6
Linus Torvalds332d2e72008-10-20 15:07:34 +1100596#endif
597
598#ifndef MEM_RSRC_PRINTK_SIZE
Bjorn Helgaas28405372009-10-06 15:33:29 -0600599#define MEM_RSRC_PRINTK_SIZE 10
Linus Torvalds332d2e72008-10-20 15:07:34 +1100600#endif
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700601 static const struct printf_spec io_spec = {
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100602 .base = 16,
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700603 .field_width = IO_RSRC_PRINTK_SIZE,
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100604 .precision = -1,
605 .flags = SPECIAL | SMALL | ZEROPAD,
606 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700607 static const struct printf_spec mem_spec = {
608 .base = 16,
609 .field_width = MEM_RSRC_PRINTK_SIZE,
610 .precision = -1,
611 .flags = SPECIAL | SMALL | ZEROPAD,
612 };
Bjorn Helgaas0f4050c2010-03-05 10:47:42 -0700613 static const struct printf_spec bus_spec = {
614 .base = 16,
615 .field_width = 2,
616 .precision = -1,
617 .flags = SMALL | ZEROPAD,
618 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700619 static const struct printf_spec dec_spec = {
Bjorn Helgaasc91d3372009-10-06 15:33:34 -0600620 .base = 10,
621 .precision = -1,
622 .flags = 0,
623 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700624 static const struct printf_spec str_spec = {
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600625 .field_width = -1,
626 .precision = 10,
627 .flags = LEFT,
628 };
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700629 static const struct printf_spec flag_spec = {
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600630 .base = 16,
631 .precision = -1,
632 .flags = SPECIAL | SMALL,
633 };
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600634
635 /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
636 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
637#define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
638#define FLAG_BUF_SIZE (2 * sizeof(res->flags))
Bjorn Helgaas9d7cca02010-03-05 10:47:47 -0700639#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600640#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
641 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
642 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
643
Linus Torvalds332d2e72008-10-20 15:07:34 +1100644 char *p = sym, *pend = sym + sizeof(sym);
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600645 int decode = (fmt[0] == 'R') ? 1 : 0;
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700646 const struct printf_spec *specp;
Linus Torvalds332d2e72008-10-20 15:07:34 +1100647
648 *p++ = '[';
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700649 if (res->flags & IORESOURCE_IO) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600650 p = string(p, pend, "io ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700651 specp = &io_spec;
652 } else if (res->flags & IORESOURCE_MEM) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600653 p = string(p, pend, "mem ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700654 specp = &mem_spec;
655 } else if (res->flags & IORESOURCE_IRQ) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600656 p = string(p, pend, "irq ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700657 specp = &dec_spec;
658 } else if (res->flags & IORESOURCE_DMA) {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600659 p = string(p, pend, "dma ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700660 specp = &dec_spec;
Bjorn Helgaas0f4050c2010-03-05 10:47:42 -0700661 } else if (res->flags & IORESOURCE_BUS) {
662 p = string(p, pend, "bus ", str_spec);
663 specp = &bus_spec;
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700664 } else {
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600665 p = string(p, pend, "??? ", str_spec);
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700666 specp = &mem_spec;
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600667 decode = 0;
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600668 }
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700669 p = number(p, pend, res->start, *specp);
Bjorn Helgaasc91d3372009-10-06 15:33:34 -0600670 if (res->start != res->end) {
671 *p++ = '-';
Bjorn Helgaas4da0b662010-03-05 10:47:37 -0700672 p = number(p, pend, res->end, *specp);
Bjorn Helgaasc91d3372009-10-06 15:33:34 -0600673 }
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600674 if (decode) {
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600675 if (res->flags & IORESOURCE_MEM_64)
676 p = string(p, pend, " 64bit", str_spec);
677 if (res->flags & IORESOURCE_PREFETCH)
678 p = string(p, pend, " pref", str_spec);
Bjorn Helgaas9d7cca02010-03-05 10:47:47 -0700679 if (res->flags & IORESOURCE_WINDOW)
680 p = string(p, pend, " window", str_spec);
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600681 if (res->flags & IORESOURCE_DISABLED)
682 p = string(p, pend, " disabled", str_spec);
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600683 } else {
684 p = string(p, pend, " flags ", str_spec);
685 p = number(p, pend, res->flags, flag_spec);
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600686 }
Linus Torvalds332d2e72008-10-20 15:07:34 +1100687 *p++ = ']';
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600688 *p = '\0';
Linus Torvalds332d2e72008-10-20 15:07:34 +1100689
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100690 return string(buf, end, sym, spec);
Linus Torvalds332d2e72008-10-20 15:07:34 +1100691}
692
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100693static char *mac_address_string(char *buf, char *end, u8 *addr,
Joe Perches8a27f7c2009-08-17 12:29:44 +0000694 struct printf_spec spec, const char *fmt)
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700695{
Joe Perches8a27f7c2009-08-17 12:29:44 +0000696 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700697 char *p = mac_addr;
698 int i;
Joe Perchesbc7259a2010-01-07 11:43:50 +0000699 char separator;
700
701 if (fmt[1] == 'F') { /* FDDI canonical format */
Joe Perchesbc7259a2010-01-07 11:43:50 +0000702 separator = '-';
703 } else {
Joe Perchesbc7259a2010-01-07 11:43:50 +0000704 separator = ':';
705 }
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700706
707 for (i = 0; i < 6; i++) {
Joe Perchesc8e00062010-01-11 00:44:14 -0800708 p = pack_hex_byte(p, addr[i]);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000709 if (fmt[0] == 'M' && i != 5)
Joe Perchesbc7259a2010-01-07 11:43:50 +0000710 *p++ = separator;
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700711 }
712 *p = '\0';
713
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100714 return string(buf, end, mac_addr, spec);
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700715}
716
Joe Perches0159f242010-01-13 20:23:30 -0800717static char *ip4_string(char *p, const u8 *addr, const char *fmt)
Harvey Harrison689afa72008-10-28 16:04:44 -0700718{
Harvey Harrison689afa72008-10-28 16:04:44 -0700719 int i;
Joe Perches0159f242010-01-13 20:23:30 -0800720 bool leading_zeros = (fmt[0] == 'i');
721 int index;
722 int step;
Harvey Harrison689afa72008-10-28 16:04:44 -0700723
Joe Perches0159f242010-01-13 20:23:30 -0800724 switch (fmt[2]) {
725 case 'h':
726#ifdef __BIG_ENDIAN
727 index = 0;
728 step = 1;
729#else
730 index = 3;
731 step = -1;
732#endif
733 break;
734 case 'l':
735 index = 3;
736 step = -1;
737 break;
738 case 'n':
739 case 'b':
740 default:
741 index = 0;
742 step = 1;
743 break;
744 }
Joe Perches8a27f7c2009-08-17 12:29:44 +0000745 for (i = 0; i < 4; i++) {
746 char temp[3]; /* hold each IP quad in reverse order */
Joe Perches0159f242010-01-13 20:23:30 -0800747 int digits = put_dec_trunc(temp, addr[index]) - temp;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000748 if (leading_zeros) {
749 if (digits < 3)
750 *p++ = '0';
751 if (digits < 2)
752 *p++ = '0';
753 }
754 /* reverse the digits in the quad */
755 while (digits--)
756 *p++ = temp[digits];
757 if (i < 3)
758 *p++ = '.';
Joe Perches0159f242010-01-13 20:23:30 -0800759 index += step;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000760 }
Joe Perches8a27f7c2009-08-17 12:29:44 +0000761 *p = '\0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800762
Joe Perches8a27f7c2009-08-17 12:29:44 +0000763 return p;
764}
765
Joe Percheseb78cd22009-09-18 13:04:06 +0000766static char *ip6_compressed_string(char *p, const char *addr)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000767{
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800768 int i, j, range;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000769 unsigned char zerolength[8];
770 int longest = 1;
771 int colonpos = -1;
772 u16 word;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800773 u8 hi, lo;
Joe Perches8a27f7c2009-08-17 12:29:44 +0000774 bool needcolon = false;
Joe Percheseb78cd22009-09-18 13:04:06 +0000775 bool useIPv4;
776 struct in6_addr in6;
777
778 memcpy(&in6, addr, sizeof(struct in6_addr));
779
780 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000781
782 memset(zerolength, 0, sizeof(zerolength));
783
784 if (useIPv4)
785 range = 6;
786 else
787 range = 8;
788
789 /* find position of longest 0 run */
790 for (i = 0; i < range; i++) {
791 for (j = i; j < range; j++) {
Joe Percheseb78cd22009-09-18 13:04:06 +0000792 if (in6.s6_addr16[j] != 0)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000793 break;
794 zerolength[i]++;
795 }
796 }
797 for (i = 0; i < range; i++) {
798 if (zerolength[i] > longest) {
799 longest = zerolength[i];
800 colonpos = i;
801 }
802 }
803
804 /* emit address */
805 for (i = 0; i < range; i++) {
806 if (i == colonpos) {
807 if (needcolon || i == 0)
808 *p++ = ':';
809 *p++ = ':';
810 needcolon = false;
811 i += longest - 1;
812 continue;
813 }
814 if (needcolon) {
815 *p++ = ':';
816 needcolon = false;
817 }
818 /* hex u16 without leading 0s */
Joe Percheseb78cd22009-09-18 13:04:06 +0000819 word = ntohs(in6.s6_addr16[i]);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000820 hi = word >> 8;
821 lo = word & 0xff;
822 if (hi) {
823 if (hi > 0x0f)
824 p = pack_hex_byte(p, hi);
825 else
826 *p++ = hex_asc_lo(hi);
André Goddard Rosab5ff9922009-12-14 18:00:59 -0800827 p = pack_hex_byte(p, lo);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000828 }
André Goddard Rosab5ff9922009-12-14 18:00:59 -0800829 else if (lo > 0x0f)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000830 p = pack_hex_byte(p, lo);
831 else
832 *p++ = hex_asc_lo(lo);
833 needcolon = true;
834 }
835
836 if (useIPv4) {
837 if (needcolon)
838 *p++ = ':';
Joe Perches0159f242010-01-13 20:23:30 -0800839 p = ip4_string(p, &in6.s6_addr[12], "I4");
Joe Perches8a27f7c2009-08-17 12:29:44 +0000840 }
Joe Perches8a27f7c2009-08-17 12:29:44 +0000841 *p = '\0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800842
Joe Perches8a27f7c2009-08-17 12:29:44 +0000843 return p;
844}
845
Joe Percheseb78cd22009-09-18 13:04:06 +0000846static char *ip6_string(char *p, const char *addr, const char *fmt)
Joe Perches8a27f7c2009-08-17 12:29:44 +0000847{
848 int i;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800849
Harvey Harrison689afa72008-10-28 16:04:44 -0700850 for (i = 0; i < 8; i++) {
Joe Percheseb78cd22009-09-18 13:04:06 +0000851 p = pack_hex_byte(p, *addr++);
852 p = pack_hex_byte(p, *addr++);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000853 if (fmt[0] == 'I' && i != 7)
Harvey Harrison689afa72008-10-28 16:04:44 -0700854 *p++ = ':';
855 }
856 *p = '\0';
André Goddard Rosa7b9186f2009-12-14 18:00:57 -0800857
Joe Perches8a27f7c2009-08-17 12:29:44 +0000858 return p;
859}
860
861static char *ip6_addr_string(char *buf, char *end, const u8 *addr,
862 struct printf_spec spec, const char *fmt)
863{
864 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
865
866 if (fmt[0] == 'I' && fmt[2] == 'c')
Joe Percheseb78cd22009-09-18 13:04:06 +0000867 ip6_compressed_string(ip6_addr, addr);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000868 else
Joe Percheseb78cd22009-09-18 13:04:06 +0000869 ip6_string(ip6_addr, addr, fmt);
Harvey Harrison689afa72008-10-28 16:04:44 -0700870
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100871 return string(buf, end, ip6_addr, spec);
Harvey Harrison689afa72008-10-28 16:04:44 -0700872}
873
Joe Perches8a27f7c2009-08-17 12:29:44 +0000874static char *ip4_addr_string(char *buf, char *end, const u8 *addr,
875 struct printf_spec spec, const char *fmt)
Harvey Harrison4aa99602008-10-29 12:49:58 -0700876{
Joe Perches8a27f7c2009-08-17 12:29:44 +0000877 char ip4_addr[sizeof("255.255.255.255")];
Harvey Harrison4aa99602008-10-29 12:49:58 -0700878
Joe Perches0159f242010-01-13 20:23:30 -0800879 ip4_string(ip4_addr, addr, fmt);
Harvey Harrison4aa99602008-10-29 12:49:58 -0700880
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100881 return string(buf, end, ip4_addr, spec);
Harvey Harrison4aa99602008-10-29 12:49:58 -0700882}
883
Joe Perches9ac6e442009-12-14 18:01:09 -0800884static char *uuid_string(char *buf, char *end, const u8 *addr,
885 struct printf_spec spec, const char *fmt)
886{
887 char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
888 char *p = uuid;
889 int i;
890 static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
891 static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
892 const u8 *index = be;
893 bool uc = false;
894
895 switch (*(++fmt)) {
896 case 'L':
897 uc = true; /* fall-through */
898 case 'l':
899 index = le;
900 break;
901 case 'B':
902 uc = true;
903 break;
904 }
905
906 for (i = 0; i < 16; i++) {
907 p = pack_hex_byte(p, addr[index[i]]);
908 switch (i) {
909 case 3:
910 case 5:
911 case 7:
912 case 9:
913 *p++ = '-';
914 break;
915 }
916 }
917
918 *p = 0;
919
920 if (uc) {
921 p = uuid;
922 do {
923 *p = toupper(*p);
924 } while (*(++p));
925 }
926
927 return string(buf, end, uuid, spec);
928}
929
Linus Torvalds4d8a7432008-07-06 16:24:57 -0700930/*
931 * Show a '%p' thing. A kernel extension is that the '%p' is followed
932 * by an extra set of alphanumeric characters that are extended format
933 * specifiers.
934 *
Linus Torvalds332d2e72008-10-20 15:07:34 +1100935 * Right now we handle:
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700936 *
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +0200937 * - 'F' For symbolic function descriptor pointers with offset
938 * - 'f' For simple symbolic function names without offset
Steven Rostedt0efb4d22009-09-17 09:27:29 -0400939 * - 'S' For symbolic direct pointers with offset
940 * - 's' For symbolic direct pointers without offset
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600941 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
942 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
Harvey Harrisondd45c9c2008-10-27 15:47:12 -0700943 * - 'M' For a 6-byte MAC address, it prints the address in the
944 * usual colon-separated hex notation
Joe Perches8a27f7c2009-08-17 12:29:44 +0000945 * - 'm' For a 6-byte MAC address, it prints the hex address without colons
Joe Perchesbc7259a2010-01-07 11:43:50 +0000946 * - 'MF' For a 6-byte MAC FDDI address, it prints the address
Joe Perchesc8e00062010-01-11 00:44:14 -0800947 * with a dash-separated hex notation
Joe Perches8a27f7c2009-08-17 12:29:44 +0000948 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
949 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
950 * IPv6 uses colon separated network-order 16 bit hex with leading 0's
951 * - 'i' [46] for 'raw' IPv4/IPv6 addresses
952 * IPv6 omits the colons (01020304...0f)
953 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
Joe Perches0159f242010-01-13 20:23:30 -0800954 * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order
Joe Perches8a27f7c2009-08-17 12:29:44 +0000955 * - 'I6c' for IPv6 addresses printed as specified by
Uwe Kleine-König3f472402010-01-08 14:43:02 -0800956 * http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
Joe Perches9ac6e442009-12-14 18:01:09 -0800957 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
958 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
959 * Options for %pU are:
960 * b big endian lower case hex (default)
961 * B big endian UPPER case hex
962 * l little endian lower case hex
963 * L little endian UPPER case hex
964 * big endian output byte order is:
965 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
966 * little endian output byte order is:
967 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
968 *
Linus Torvalds332d2e72008-10-20 15:07:34 +1100969 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
970 * function pointers are really function descriptors, which contain a
971 * pointer to the real address.
Linus Torvalds4d8a7432008-07-06 16:24:57 -0700972 */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100973static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
974 struct printf_spec spec)
Linus Torvalds78a8bf62008-07-06 16:16:15 -0700975{
Linus Torvaldsd97106a2009-01-03 11:46:17 -0800976 if (!ptr)
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +0100977 return string(buf, end, "(null)", spec);
Linus Torvaldsd97106a2009-01-03 11:46:17 -0800978
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700979 switch (*fmt) {
980 case 'F':
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +0200981 case 'f':
Linus Torvalds0fe1ef22008-07-06 16:43:12 -0700982 ptr = dereference_function_descriptor(ptr);
983 /* Fallthrough */
984 case 'S':
Joe Perches9ac6e442009-12-14 18:01:09 -0800985 case 's':
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +0200986 return symbol_string(buf, end, ptr, spec, *fmt);
Linus Torvalds332d2e72008-10-20 15:07:34 +1100987 case 'R':
Bjorn Helgaasc7dabef2009-10-27 13:26:47 -0600988 case 'r':
Bjorn Helgaasfd955412009-10-06 15:33:39 -0600989 return resource_string(buf, end, ptr, spec, fmt);
Joe Perches8a27f7c2009-08-17 12:29:44 +0000990 case 'M': /* Colon separated: 00:01:02:03:04:05 */
991 case 'm': /* Contiguous: 000102030405 */
Joe Perchesbc7259a2010-01-07 11:43:50 +0000992 /* [mM]F (FDDI, bit reversed) */
Joe Perches8a27f7c2009-08-17 12:29:44 +0000993 return mac_address_string(buf, end, ptr, spec, fmt);
994 case 'I': /* Formatted IP supported
995 * 4: 1.2.3.4
996 * 6: 0001:0203:...:0708
997 * 6c: 1::708 or 1::1.2.3.4
998 */
999 case 'i': /* Contiguous:
1000 * 4: 001.002.003.004
1001 * 6: 000102...0f
1002 */
1003 switch (fmt[1]) {
1004 case '6':
1005 return ip6_addr_string(buf, end, ptr, spec, fmt);
1006 case '4':
1007 return ip4_addr_string(buf, end, ptr, spec, fmt);
1008 }
Harvey Harrison4aa99602008-10-29 12:49:58 -07001009 break;
Joe Perches9ac6e442009-12-14 18:01:09 -08001010 case 'U':
1011 return uuid_string(buf, end, ptr, spec, fmt);
Linus Torvalds0fe1ef22008-07-06 16:43:12 -07001012 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001013 spec.flags |= SMALL;
1014 if (spec.field_width == -1) {
1015 spec.field_width = 2*sizeof(void *);
1016 spec.flags |= ZEROPAD;
Linus Torvalds78a8bf62008-07-06 16:16:15 -07001017 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001018 spec.base = 16;
1019
1020 return number(buf, end, (unsigned long) ptr, spec);
1021}
1022
1023/*
1024 * Helper function to decode printf style format.
1025 * Each call decode a token from the format and return the
1026 * number of characters read (or likely the delta where it wants
1027 * to go on the next call).
1028 * The decoded token is returned through the parameters
1029 *
1030 * 'h', 'l', or 'L' for integer fields
1031 * 'z' support added 23/7/1999 S.H.
1032 * 'z' changed to 'Z' --davidm 1/25/99
1033 * 't' added for ptrdiff_t
1034 *
1035 * @fmt: the format string
1036 * @type of the token returned
1037 * @flags: various flags such as +, -, # tokens..
1038 * @field_width: overwritten width
1039 * @base: base of the number (octal, hex, ...)
1040 * @precision: precision of a number
1041 * @qualifier: qualifier of a number (long, size_t, ...)
1042 */
1043static int format_decode(const char *fmt, struct printf_spec *spec)
1044{
1045 const char *start = fmt;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001046
1047 /* we finished early by reading the field width */
Vegard Nossumed681a92009-03-14 12:08:50 +01001048 if (spec->type == FORMAT_TYPE_WIDTH) {
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001049 if (spec->field_width < 0) {
1050 spec->field_width = -spec->field_width;
1051 spec->flags |= LEFT;
1052 }
1053 spec->type = FORMAT_TYPE_NONE;
1054 goto precision;
1055 }
1056
1057 /* we finished early by reading the precision */
1058 if (spec->type == FORMAT_TYPE_PRECISION) {
1059 if (spec->precision < 0)
1060 spec->precision = 0;
1061
1062 spec->type = FORMAT_TYPE_NONE;
1063 goto qualifier;
1064 }
1065
1066 /* By default */
1067 spec->type = FORMAT_TYPE_NONE;
1068
1069 for (; *fmt ; ++fmt) {
1070 if (*fmt == '%')
1071 break;
1072 }
1073
1074 /* Return the current non-format string */
1075 if (fmt != start || !*fmt)
1076 return fmt - start;
1077
1078 /* Process flags */
1079 spec->flags = 0;
1080
1081 while (1) { /* this also skips first '%' */
1082 bool found = true;
1083
1084 ++fmt;
1085
1086 switch (*fmt) {
1087 case '-': spec->flags |= LEFT; break;
1088 case '+': spec->flags |= PLUS; break;
1089 case ' ': spec->flags |= SPACE; break;
1090 case '#': spec->flags |= SPECIAL; break;
1091 case '0': spec->flags |= ZEROPAD; break;
1092 default: found = false;
1093 }
1094
1095 if (!found)
1096 break;
1097 }
1098
1099 /* get field width */
1100 spec->field_width = -1;
1101
1102 if (isdigit(*fmt))
1103 spec->field_width = skip_atoi(&fmt);
1104 else if (*fmt == '*') {
1105 /* it's the next argument */
Vegard Nossumed681a92009-03-14 12:08:50 +01001106 spec->type = FORMAT_TYPE_WIDTH;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001107 return ++fmt - start;
1108 }
1109
1110precision:
1111 /* get the precision */
1112 spec->precision = -1;
1113 if (*fmt == '.') {
1114 ++fmt;
1115 if (isdigit(*fmt)) {
1116 spec->precision = skip_atoi(&fmt);
1117 if (spec->precision < 0)
1118 spec->precision = 0;
1119 } else if (*fmt == '*') {
1120 /* it's the next argument */
Vegard Nossumadf26f82009-03-14 12:08:50 +01001121 spec->type = FORMAT_TYPE_PRECISION;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001122 return ++fmt - start;
1123 }
1124 }
1125
1126qualifier:
1127 /* get the conversion qualifier */
1128 spec->qualifier = -1;
André Goddard Rosa08562cb2009-12-14 18:00:58 -08001129 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1130 TOLOWER(*fmt) == 'z' || *fmt == 't') {
Zhaoleia4e94ef2009-03-27 17:07:05 +08001131 spec->qualifier = *fmt++;
1132 if (unlikely(spec->qualifier == *fmt)) {
1133 if (spec->qualifier == 'l') {
1134 spec->qualifier = 'L';
1135 ++fmt;
1136 } else if (spec->qualifier == 'h') {
1137 spec->qualifier = 'H';
1138 ++fmt;
1139 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001140 }
1141 }
1142
1143 /* default base */
1144 spec->base = 10;
1145 switch (*fmt) {
1146 case 'c':
1147 spec->type = FORMAT_TYPE_CHAR;
1148 return ++fmt - start;
1149
1150 case 's':
1151 spec->type = FORMAT_TYPE_STR;
1152 return ++fmt - start;
1153
1154 case 'p':
1155 spec->type = FORMAT_TYPE_PTR;
1156 return fmt - start;
1157 /* skip alnum */
1158
1159 case 'n':
1160 spec->type = FORMAT_TYPE_NRCHARS;
1161 return ++fmt - start;
1162
1163 case '%':
1164 spec->type = FORMAT_TYPE_PERCENT_CHAR;
1165 return ++fmt - start;
1166
1167 /* integer number formats - set up the flags and "break" */
1168 case 'o':
1169 spec->base = 8;
1170 break;
1171
1172 case 'x':
1173 spec->flags |= SMALL;
1174
1175 case 'X':
1176 spec->base = 16;
1177 break;
1178
1179 case 'd':
1180 case 'i':
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001181 spec->flags |= SIGN;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001182 case 'u':
1183 break;
1184
1185 default:
1186 spec->type = FORMAT_TYPE_INVALID;
1187 return fmt - start;
1188 }
1189
1190 if (spec->qualifier == 'L')
1191 spec->type = FORMAT_TYPE_LONG_LONG;
1192 else if (spec->qualifier == 'l') {
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001193 if (spec->flags & SIGN)
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001194 spec->type = FORMAT_TYPE_LONG;
1195 else
1196 spec->type = FORMAT_TYPE_ULONG;
André Goddard Rosa08562cb2009-12-14 18:00:58 -08001197 } else if (TOLOWER(spec->qualifier) == 'z') {
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001198 spec->type = FORMAT_TYPE_SIZE_T;
1199 } else if (spec->qualifier == 't') {
1200 spec->type = FORMAT_TYPE_PTRDIFF;
Zhaoleia4e94ef2009-03-27 17:07:05 +08001201 } else if (spec->qualifier == 'H') {
1202 if (spec->flags & SIGN)
1203 spec->type = FORMAT_TYPE_BYTE;
1204 else
1205 spec->type = FORMAT_TYPE_UBYTE;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001206 } else if (spec->qualifier == 'h') {
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001207 if (spec->flags & SIGN)
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001208 spec->type = FORMAT_TYPE_SHORT;
1209 else
1210 spec->type = FORMAT_TYPE_USHORT;
1211 } else {
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001212 if (spec->flags & SIGN)
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001213 spec->type = FORMAT_TYPE_INT;
1214 else
1215 spec->type = FORMAT_TYPE_UINT;
1216 }
1217
1218 return ++fmt - start;
Linus Torvalds78a8bf62008-07-06 16:16:15 -07001219}
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221/**
1222 * vsnprintf - Format a string and place it in a buffer
1223 * @buf: The buffer to place the result into
1224 * @size: The size of the buffer, including the trailing null space
1225 * @fmt: The format string to use
1226 * @args: Arguments for the format string
1227 *
Andi Kleen20036fd2008-10-15 22:02:02 -07001228 * This function follows C99 vsnprintf, but has some extensions:
Steven Rostedt91adcd22009-09-16 20:03:06 -04001229 * %pS output the name of a text symbol with offset
1230 * %ps output the name of a text symbol without offset
Frederic Weisbecker0c8b9462009-04-15 17:48:18 +02001231 * %pF output the name of a function pointer with its offset
1232 * %pf output the name of a function pointer without its offset
Uwe Kleine-König8a795032009-12-17 15:27:12 -08001233 * %pR output the address range in a struct resource with decoded flags
1234 * %pr output the address range in a struct resource with raw flags
1235 * %pM output a 6-byte MAC address with colons
1236 * %pm output a 6-byte MAC address without colons
1237 * %pI4 print an IPv4 address without leading zeros
1238 * %pi4 print an IPv4 address with leading zeros
1239 * %pI6 print an IPv6 address with colons
1240 * %pi6 print an IPv6 address without colons
1241 * %pI6c print an IPv6 address as specified by
Uwe Kleine-König3f472402010-01-08 14:43:02 -08001242 * http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
Uwe Kleine-König8a795032009-12-17 15:27:12 -08001243 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
1244 * case.
Steven Rostedt0efb4d22009-09-17 09:27:29 -04001245 * %n is ignored
Andi Kleen20036fd2008-10-15 22:02:02 -07001246 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 * The return value is the number of characters which would
1248 * be generated for the given input, excluding the trailing
1249 * '\0', as per ISO C99. If you want to have the exact
1250 * number of characters written into @buf as return value
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001251 * (not including the trailing '\0'), use vscnprintf(). If the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 * return is greater than or equal to @size, the resulting
1253 * string is truncated.
1254 *
1255 * Call this function if you are already dealing with a va_list.
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001256 * You probably want snprintf() instead.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 */
1258int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1259{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 unsigned long long num;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001261 char *str, *end;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001262 struct printf_spec spec = {0};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001264 /* Reject out-of-range values early. Large positive sizes are
1265 used for unknown buffer sizes. */
Marcin Slusarz2f30b1f92009-09-21 17:04:29 -07001266 if (WARN_ON_ONCE((int) size < 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 str = buf;
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001270 end = buf + size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001272 /* Make sure end is always >= buf */
1273 if (end < buf) {
1274 end = ((void *)-1);
1275 size = end - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 }
1277
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001278 while (*fmt) {
1279 const char *old_fmt = fmt;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001280 int read = format_decode(fmt, &spec);
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001281
1282 fmt += read;
1283
1284 switch (spec.type) {
1285 case FORMAT_TYPE_NONE: {
1286 int copy = read;
1287 if (str < end) {
1288 if (copy > end - str)
1289 copy = end - str;
1290 memcpy(str, old_fmt, copy);
1291 }
1292 str += read;
1293 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 }
1295
Vegard Nossumed681a92009-03-14 12:08:50 +01001296 case FORMAT_TYPE_WIDTH:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001297 spec.field_width = va_arg(args, int);
1298 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001300 case FORMAT_TYPE_PRECISION:
1301 spec.precision = va_arg(args, int);
1302 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
André Goddard Rosad4be1512009-12-14 18:00:59 -08001304 case FORMAT_TYPE_CHAR: {
1305 char c;
1306
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001307 if (!(spec.flags & LEFT)) {
1308 while (--spec.field_width > 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001309 if (str < end)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 *str = ' ';
1311 ++str;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001312
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001314 }
1315 c = (unsigned char) va_arg(args, int);
1316 if (str < end)
1317 *str = c;
1318 ++str;
1319 while (--spec.field_width > 0) {
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001320 if (str < end)
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001321 *str = ' ';
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 ++str;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001323 }
1324 break;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001325 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001327 case FORMAT_TYPE_STR:
1328 str = string(str, end, va_arg(args, char *), spec);
1329 break;
1330
1331 case FORMAT_TYPE_PTR:
1332 str = pointer(fmt+1, str, end, va_arg(args, void *),
1333 spec);
1334 while (isalnum(*fmt))
1335 fmt++;
1336 break;
1337
1338 case FORMAT_TYPE_PERCENT_CHAR:
1339 if (str < end)
1340 *str = '%';
1341 ++str;
1342 break;
1343
1344 case FORMAT_TYPE_INVALID:
1345 if (str < end)
1346 *str = '%';
1347 ++str;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001348 break;
1349
1350 case FORMAT_TYPE_NRCHARS: {
Joe Perchesef0658f2010-03-06 17:10:14 -08001351 u8 qualifier = spec.qualifier;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001352
1353 if (qualifier == 'l') {
1354 long *ip = va_arg(args, long *);
1355 *ip = (str - buf);
André Goddard Rosa08562cb2009-12-14 18:00:58 -08001356 } else if (TOLOWER(qualifier) == 'z') {
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001357 size_t *ip = va_arg(args, size_t *);
1358 *ip = (str - buf);
1359 } else {
1360 int *ip = va_arg(args, int *);
1361 *ip = (str - buf);
1362 }
1363 break;
1364 }
1365
1366 default:
1367 switch (spec.type) {
1368 case FORMAT_TYPE_LONG_LONG:
1369 num = va_arg(args, long long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 break;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001371 case FORMAT_TYPE_ULONG:
1372 num = va_arg(args, unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 break;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001374 case FORMAT_TYPE_LONG:
1375 num = va_arg(args, long);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 break;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001377 case FORMAT_TYPE_SIZE_T:
1378 num = va_arg(args, size_t);
1379 break;
1380 case FORMAT_TYPE_PTRDIFF:
1381 num = va_arg(args, ptrdiff_t);
1382 break;
Zhaoleia4e94ef2009-03-27 17:07:05 +08001383 case FORMAT_TYPE_UBYTE:
1384 num = (unsigned char) va_arg(args, int);
1385 break;
1386 case FORMAT_TYPE_BYTE:
1387 num = (signed char) va_arg(args, int);
1388 break;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001389 case FORMAT_TYPE_USHORT:
1390 num = (unsigned short) va_arg(args, int);
1391 break;
1392 case FORMAT_TYPE_SHORT:
1393 num = (short) va_arg(args, int);
1394 break;
Frederic Weisbecker39e874f2009-03-09 21:15:04 +01001395 case FORMAT_TYPE_INT:
1396 num = (int) va_arg(args, int);
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001397 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 default:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001399 num = va_arg(args, unsigned int);
1400 }
1401
1402 str = number(str, end, num, spec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001405
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001406 if (size > 0) {
1407 if (str < end)
1408 *str = '\0';
1409 else
Linus Torvalds0a6047e2006-06-28 17:09:34 -07001410 end[-1] = '\0';
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001411 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001412
Jeremy Fitzhardingef7969372006-06-25 05:49:17 -07001413 /* the trailing null byte doesn't count towards the total */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 return str-buf;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001415
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417EXPORT_SYMBOL(vsnprintf);
1418
1419/**
1420 * vscnprintf - Format a string and place it in a buffer
1421 * @buf: The buffer to place the result into
1422 * @size: The size of the buffer, including the trailing null space
1423 * @fmt: The format string to use
1424 * @args: Arguments for the format string
1425 *
1426 * The return value is the number of characters which have been written into
1427 * the @buf not including the trailing '\0'. If @size is <= 0 the function
1428 * returns 0.
1429 *
1430 * Call this function if you are already dealing with a va_list.
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001431 * You probably want scnprintf() instead.
Andi Kleen20036fd2008-10-15 22:02:02 -07001432 *
1433 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 */
1435int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1436{
1437 int i;
1438
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001439 i = vsnprintf(buf, size, fmt, args);
1440
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 return (i >= size) ? (size - 1) : i;
1442}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443EXPORT_SYMBOL(vscnprintf);
1444
1445/**
1446 * snprintf - Format a string and place it in a buffer
1447 * @buf: The buffer to place the result into
1448 * @size: The size of the buffer, including the trailing null space
1449 * @fmt: The format string to use
1450 * @...: Arguments for the format string
1451 *
1452 * The return value is the number of characters which would be
1453 * generated for the given input, excluding the trailing null,
1454 * as per ISO C99. If the return is greater than or equal to
1455 * @size, the resulting string is truncated.
Andi Kleen20036fd2008-10-15 22:02:02 -07001456 *
1457 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001459int snprintf(char *buf, size_t size, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460{
1461 va_list args;
1462 int i;
1463
1464 va_start(args, fmt);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001465 i = vsnprintf(buf, size, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001467
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 return i;
1469}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470EXPORT_SYMBOL(snprintf);
1471
1472/**
1473 * scnprintf - Format a string and place it in a buffer
1474 * @buf: The buffer to place the result into
1475 * @size: The size of the buffer, including the trailing null space
1476 * @fmt: The format string to use
1477 * @...: Arguments for the format string
1478 *
1479 * The return value is the number of characters written into @buf not including
Martin Peschkeea6f3282007-02-12 00:51:56 -08001480 * the trailing '\0'. If @size is <= 0 the function returns 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 */
1482
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001483int scnprintf(char *buf, size_t size, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484{
1485 va_list args;
1486 int i;
1487
1488 va_start(args, fmt);
1489 i = vsnprintf(buf, size, fmt, args);
1490 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001491
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 return (i >= size) ? (size - 1) : i;
1493}
1494EXPORT_SYMBOL(scnprintf);
1495
1496/**
1497 * vsprintf - Format a string and place it in a buffer
1498 * @buf: The buffer to place the result into
1499 * @fmt: The format string to use
1500 * @args: Arguments for the format string
1501 *
1502 * The function returns the number of characters written
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001503 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 * buffer overflows.
1505 *
1506 * Call this function if you are already dealing with a va_list.
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001507 * You probably want sprintf() instead.
Andi Kleen20036fd2008-10-15 22:02:02 -07001508 *
1509 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 */
1511int vsprintf(char *buf, const char *fmt, va_list args)
1512{
1513 return vsnprintf(buf, INT_MAX, fmt, args);
1514}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515EXPORT_SYMBOL(vsprintf);
1516
1517/**
1518 * sprintf - Format a string and place it in a buffer
1519 * @buf: The buffer to place the result into
1520 * @fmt: The format string to use
1521 * @...: Arguments for the format string
1522 *
1523 * The function returns the number of characters written
Robert P. J. Day72fd4a32007-02-10 01:45:59 -08001524 * into @buf. Use snprintf() or scnprintf() in order to avoid
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 * buffer overflows.
Andi Kleen20036fd2008-10-15 22:02:02 -07001526 *
1527 * See the vsnprintf() documentation for format string extensions over C99.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001529int sprintf(char *buf, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530{
1531 va_list args;
1532 int i;
1533
1534 va_start(args, fmt);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001535 i = vsnprintf(buf, INT_MAX, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001537
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 return i;
1539}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540EXPORT_SYMBOL(sprintf);
1541
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001542#ifdef CONFIG_BINARY_PRINTF
1543/*
1544 * bprintf service:
1545 * vbin_printf() - VA arguments to binary data
1546 * bstr_printf() - Binary data to text string
1547 */
1548
1549/**
1550 * vbin_printf - Parse a format string and place args' binary value in a buffer
1551 * @bin_buf: The buffer to place args' binary value
1552 * @size: The size of the buffer(by words(32bits), not characters)
1553 * @fmt: The format string to use
1554 * @args: Arguments for the format string
1555 *
1556 * The format follows C99 vsnprintf, except %n is ignored, and its argument
1557 * is skiped.
1558 *
1559 * The return value is the number of words(32bits) which would be generated for
1560 * the given input.
1561 *
1562 * NOTE:
1563 * If the return value is greater than @size, the resulting bin_buf is NOT
1564 * valid for bstr_printf().
1565 */
1566int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
1567{
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001568 struct printf_spec spec = {0};
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001569 char *str, *end;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001570
1571 str = (char *)bin_buf;
1572 end = (char *)(bin_buf + size);
1573
1574#define save_arg(type) \
1575do { \
1576 if (sizeof(type) == 8) { \
1577 unsigned long long value; \
1578 str = PTR_ALIGN(str, sizeof(u32)); \
1579 value = va_arg(args, unsigned long long); \
1580 if (str + sizeof(type) <= end) { \
1581 *(u32 *)str = *(u32 *)&value; \
1582 *(u32 *)(str + 4) = *((u32 *)&value + 1); \
1583 } \
1584 } else { \
1585 unsigned long value; \
1586 str = PTR_ALIGN(str, sizeof(type)); \
1587 value = va_arg(args, int); \
1588 if (str + sizeof(type) <= end) \
1589 *(typeof(type) *)str = (type)value; \
1590 } \
1591 str += sizeof(type); \
1592} while (0)
1593
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001594 while (*fmt) {
André Goddard Rosad4be1512009-12-14 18:00:59 -08001595 int read = format_decode(fmt, &spec);
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001596
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001597 fmt += read;
1598
1599 switch (spec.type) {
1600 case FORMAT_TYPE_NONE:
André Goddard Rosad4be1512009-12-14 18:00:59 -08001601 case FORMAT_TYPE_INVALID:
1602 case FORMAT_TYPE_PERCENT_CHAR:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001603 break;
1604
Vegard Nossumed681a92009-03-14 12:08:50 +01001605 case FORMAT_TYPE_WIDTH:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001606 case FORMAT_TYPE_PRECISION:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001607 save_arg(int);
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001608 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001609
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001610 case FORMAT_TYPE_CHAR:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001611 save_arg(char);
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001612 break;
1613
1614 case FORMAT_TYPE_STR: {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001615 const char *save_str = va_arg(args, char *);
1616 size_t len;
André Goddard Rosa6c356632009-12-14 18:00:56 -08001617
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001618 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
1619 || (unsigned long)save_str < PAGE_SIZE)
André Goddard Rosa0f4f81d2009-12-14 18:00:55 -08001620 save_str = "(null)";
André Goddard Rosa6c356632009-12-14 18:00:56 -08001621 len = strlen(save_str) + 1;
1622 if (str + len < end)
1623 memcpy(str, save_str, len);
1624 str += len;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001625 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001626 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001627
1628 case FORMAT_TYPE_PTR:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001629 save_arg(void *);
1630 /* skip all alphanumeric pointer suffixes */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001631 while (isalnum(*fmt))
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001632 fmt++;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001633 break;
1634
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001635 case FORMAT_TYPE_NRCHARS: {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001636 /* skip %n 's argument */
Joe Perchesef0658f2010-03-06 17:10:14 -08001637 u8 qualifier = spec.qualifier;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001638 void *skip_arg;
1639 if (qualifier == 'l')
1640 skip_arg = va_arg(args, long *);
André Goddard Rosa08562cb2009-12-14 18:00:58 -08001641 else if (TOLOWER(qualifier) == 'z')
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001642 skip_arg = va_arg(args, size_t *);
1643 else
1644 skip_arg = va_arg(args, int *);
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001645 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001646 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001647
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001648 default:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001649 switch (spec.type) {
1650
1651 case FORMAT_TYPE_LONG_LONG:
1652 save_arg(long long);
1653 break;
1654 case FORMAT_TYPE_ULONG:
1655 case FORMAT_TYPE_LONG:
1656 save_arg(unsigned long);
1657 break;
1658 case FORMAT_TYPE_SIZE_T:
1659 save_arg(size_t);
1660 break;
1661 case FORMAT_TYPE_PTRDIFF:
1662 save_arg(ptrdiff_t);
1663 break;
Zhaoleia4e94ef2009-03-27 17:07:05 +08001664 case FORMAT_TYPE_UBYTE:
1665 case FORMAT_TYPE_BYTE:
1666 save_arg(char);
1667 break;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001668 case FORMAT_TYPE_USHORT:
1669 case FORMAT_TYPE_SHORT:
1670 save_arg(short);
1671 break;
1672 default:
1673 save_arg(int);
1674 }
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001675 }
1676 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001677
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001678 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001679#undef save_arg
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001680}
1681EXPORT_SYMBOL_GPL(vbin_printf);
1682
1683/**
1684 * bstr_printf - Format a string from binary arguments and place it in a buffer
1685 * @buf: The buffer to place the result into
1686 * @size: The size of the buffer, including the trailing null space
1687 * @fmt: The format string to use
1688 * @bin_buf: Binary arguments for the format string
1689 *
1690 * This function like C99 vsnprintf, but the difference is that vsnprintf gets
1691 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is
1692 * a binary buffer that generated by vbin_printf.
1693 *
1694 * The format follows C99 vsnprintf, but has some extensions:
Steven Rostedt0efb4d22009-09-17 09:27:29 -04001695 * see vsnprintf comment for details.
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001696 *
1697 * The return value is the number of characters which would
1698 * be generated for the given input, excluding the trailing
1699 * '\0', as per ISO C99. If you want to have the exact
1700 * number of characters written into @buf as return value
1701 * (not including the trailing '\0'), use vscnprintf(). If the
1702 * return is greater than or equal to @size, the resulting
1703 * string is truncated.
1704 */
1705int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
1706{
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001707 struct printf_spec spec = {0};
André Goddard Rosad4be1512009-12-14 18:00:59 -08001708 char *str, *end;
1709 const char *args = (const char *)bin_buf;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001710
Marcin Slusarz2f30b1f92009-09-21 17:04:29 -07001711 if (WARN_ON_ONCE((int) size < 0))
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001712 return 0;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001713
1714 str = buf;
1715 end = buf + size;
1716
1717#define get_arg(type) \
1718({ \
1719 typeof(type) value; \
1720 if (sizeof(type) == 8) { \
1721 args = PTR_ALIGN(args, sizeof(u32)); \
1722 *(u32 *)&value = *(u32 *)args; \
1723 *((u32 *)&value + 1) = *(u32 *)(args + 4); \
1724 } else { \
1725 args = PTR_ALIGN(args, sizeof(type)); \
1726 value = *(typeof(type) *)args; \
1727 } \
1728 args += sizeof(type); \
1729 value; \
1730})
1731
1732 /* Make sure end is always >= buf */
1733 if (end < buf) {
1734 end = ((void *)-1);
1735 size = end - buf;
1736 }
1737
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001738 while (*fmt) {
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001739 const char *old_fmt = fmt;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001740 int read = format_decode(fmt, &spec);
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001741
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001742 fmt += read;
1743
1744 switch (spec.type) {
1745 case FORMAT_TYPE_NONE: {
1746 int copy = read;
1747 if (str < end) {
1748 if (copy > end - str)
1749 copy = end - str;
1750 memcpy(str, old_fmt, copy);
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001751 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001752 str += read;
1753 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001754 }
1755
Vegard Nossumed681a92009-03-14 12:08:50 +01001756 case FORMAT_TYPE_WIDTH:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001757 spec.field_width = get_arg(int);
1758 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001759
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001760 case FORMAT_TYPE_PRECISION:
1761 spec.precision = get_arg(int);
1762 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001763
André Goddard Rosad4be1512009-12-14 18:00:59 -08001764 case FORMAT_TYPE_CHAR: {
1765 char c;
1766
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001767 if (!(spec.flags & LEFT)) {
1768 while (--spec.field_width > 0) {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001769 if (str < end)
1770 *str = ' ';
1771 ++str;
1772 }
1773 }
1774 c = (unsigned char) get_arg(char);
1775 if (str < end)
1776 *str = c;
1777 ++str;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001778 while (--spec.field_width > 0) {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001779 if (str < end)
1780 *str = ' ';
1781 ++str;
1782 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001783 break;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001784 }
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001785
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001786 case FORMAT_TYPE_STR: {
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001787 const char *str_arg = args;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001788 args += strlen(str_arg) + 1;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001789 str = string(str, end, (char *)str_arg, spec);
1790 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001791 }
1792
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001793 case FORMAT_TYPE_PTR:
1794 str = pointer(fmt+1, str, end, get_arg(void *), spec);
1795 while (isalnum(*fmt))
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001796 fmt++;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001797 break;
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001798
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001799 case FORMAT_TYPE_PERCENT_CHAR:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001800 case FORMAT_TYPE_INVALID:
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001801 if (str < end)
1802 *str = '%';
1803 ++str;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001804 break;
1805
1806 case FORMAT_TYPE_NRCHARS:
1807 /* skip */
1808 break;
1809
André Goddard Rosad4be1512009-12-14 18:00:59 -08001810 default: {
1811 unsigned long long num;
1812
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001813 switch (spec.type) {
1814
1815 case FORMAT_TYPE_LONG_LONG:
1816 num = get_arg(long long);
1817 break;
1818 case FORMAT_TYPE_ULONG:
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001819 case FORMAT_TYPE_LONG:
1820 num = get_arg(unsigned long);
1821 break;
1822 case FORMAT_TYPE_SIZE_T:
1823 num = get_arg(size_t);
1824 break;
1825 case FORMAT_TYPE_PTRDIFF:
1826 num = get_arg(ptrdiff_t);
1827 break;
Zhaoleia4e94ef2009-03-27 17:07:05 +08001828 case FORMAT_TYPE_UBYTE:
1829 num = get_arg(unsigned char);
1830 break;
1831 case FORMAT_TYPE_BYTE:
1832 num = get_arg(signed char);
1833 break;
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001834 case FORMAT_TYPE_USHORT:
1835 num = get_arg(unsigned short);
1836 break;
1837 case FORMAT_TYPE_SHORT:
1838 num = get_arg(short);
1839 break;
1840 case FORMAT_TYPE_UINT:
1841 num = get_arg(unsigned int);
1842 break;
1843 default:
1844 num = get_arg(int);
1845 }
1846
1847 str = number(str, end, num, spec);
André Goddard Rosad4be1512009-12-14 18:00:59 -08001848 } /* default: */
1849 } /* switch(spec.type) */
1850 } /* while(*fmt) */
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001851
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001852 if (size > 0) {
1853 if (str < end)
1854 *str = '\0';
1855 else
1856 end[-1] = '\0';
1857 }
Frederic Weisbeckerfef20d92009-03-06 17:21:50 +01001858
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001859#undef get_arg
1860
1861 /* the trailing null byte doesn't count towards the total */
1862 return str - buf;
1863}
1864EXPORT_SYMBOL_GPL(bstr_printf);
1865
1866/**
1867 * bprintf - Parse a format string and place args' binary value in a buffer
1868 * @bin_buf: The buffer to place args' binary value
1869 * @size: The size of the buffer(by words(32bits), not characters)
1870 * @fmt: The format string to use
1871 * @...: Arguments for the format string
1872 *
1873 * The function returns the number of words(u32) written
1874 * into @bin_buf.
1875 */
1876int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
1877{
1878 va_list args;
1879 int ret;
1880
1881 va_start(args, fmt);
1882 ret = vbin_printf(bin_buf, size, fmt, args);
1883 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001884
Lai Jiangshan4370aa42009-03-06 17:21:46 +01001885 return ret;
1886}
1887EXPORT_SYMBOL_GPL(bprintf);
1888
1889#endif /* CONFIG_BINARY_PRINTF */
1890
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891/**
1892 * vsscanf - Unformat a buffer into a list of arguments
1893 * @buf: input buffer
1894 * @fmt: format of buffer
1895 * @args: arguments
1896 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001897int vsscanf(const char *buf, const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898{
1899 const char *str = buf;
1900 char *next;
1901 char digit;
1902 int num = 0;
Joe Perchesef0658f2010-03-06 17:10:14 -08001903 u8 qualifier;
1904 u8 base;
1905 s16 field_width;
André Goddard Rosad4be1512009-12-14 18:00:59 -08001906 bool is_sign;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001908 while (*fmt && *str) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 /* skip any white space in format */
1910 /* white space in format matchs any amount of
1911 * white space, including none, in the input.
1912 */
1913 if (isspace(*fmt)) {
André Goddard Rosae7d28602009-12-14 18:01:06 -08001914 fmt = skip_spaces(++fmt);
1915 str = skip_spaces(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 }
1917
1918 /* anything that is not a conversion must match exactly */
1919 if (*fmt != '%' && *fmt) {
1920 if (*fmt++ != *str++)
1921 break;
1922 continue;
1923 }
1924
1925 if (!*fmt)
1926 break;
1927 ++fmt;
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001928
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 /* skip this conversion.
1930 * advance both strings to next white space
1931 */
1932 if (*fmt == '*') {
Andy Spencer8fccae22009-10-01 15:44:27 -07001933 while (!isspace(*fmt) && *fmt != '%' && *fmt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 fmt++;
1935 while (!isspace(*str) && *str)
1936 str++;
1937 continue;
1938 }
1939
1940 /* get field width */
1941 field_width = -1;
1942 if (isdigit(*fmt))
1943 field_width = skip_atoi(&fmt);
1944
1945 /* get conversion qualifier */
1946 qualifier = -1;
André Goddard Rosa08562cb2009-12-14 18:00:58 -08001947 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1948 TOLOWER(*fmt) == 'z') {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 qualifier = *fmt++;
1950 if (unlikely(qualifier == *fmt)) {
1951 if (qualifier == 'h') {
1952 qualifier = 'H';
1953 fmt++;
1954 } else if (qualifier == 'l') {
1955 qualifier = 'L';
1956 fmt++;
1957 }
1958 }
1959 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960
1961 if (!*fmt || !*str)
1962 break;
1963
André Goddard Rosad4be1512009-12-14 18:00:59 -08001964 base = 10;
1965 is_sign = 0;
1966
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001967 switch (*fmt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 case 'c':
1969 {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001970 char *s = (char *)va_arg(args, char*);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 if (field_width == -1)
1972 field_width = 1;
1973 do {
1974 *s++ = *str++;
1975 } while (--field_width > 0 && *str);
1976 num++;
1977 }
1978 continue;
1979 case 's':
1980 {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001981 char *s = (char *)va_arg(args, char *);
1982 if (field_width == -1)
Joe Perchesef0658f2010-03-06 17:10:14 -08001983 field_width = SHORT_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 /* first, skip leading white space in buffer */
André Goddard Rosae7d28602009-12-14 18:01:06 -08001985 str = skip_spaces(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986
1987 /* now copy until next white space */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001988 while (*str && !isspace(*str) && field_width--)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 *s++ = *str++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 *s = '\0';
1991 num++;
1992 }
1993 continue;
1994 case 'n':
1995 /* return number of characters read so far */
1996 {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08001997 int *i = (int *)va_arg(args, int*);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 *i = str - buf;
1999 }
2000 continue;
2001 case 'o':
2002 base = 8;
2003 break;
2004 case 'x':
2005 case 'X':
2006 base = 16;
2007 break;
2008 case 'i':
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002009 base = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 case 'd':
2011 is_sign = 1;
2012 case 'u':
2013 break;
2014 case '%':
2015 /* looking for '%' in str */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002016 if (*str++ != '%')
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 return num;
2018 continue;
2019 default:
2020 /* invalid format; stop here */
2021 return num;
2022 }
2023
2024 /* have some sort of integer conversion.
2025 * first, skip white space in buffer.
2026 */
André Goddard Rosae7d28602009-12-14 18:01:06 -08002027 str = skip_spaces(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028
2029 digit = *str;
2030 if (is_sign && digit == '-')
2031 digit = *(str + 1);
2032
2033 if (!digit
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002034 || (base == 16 && !isxdigit(digit))
2035 || (base == 10 && !isdigit(digit))
2036 || (base == 8 && (!isdigit(digit) || digit > '7'))
2037 || (base == 0 && !isdigit(digit)))
2038 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002040 switch (qualifier) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 case 'H': /* that's 'hh' in format */
2042 if (is_sign) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002043 signed char *s = (signed char *)va_arg(args, signed char *);
2044 *s = (signed char)simple_strtol(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 } else {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002046 unsigned char *s = (unsigned char *)va_arg(args, unsigned char *);
2047 *s = (unsigned char)simple_strtoul(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 }
2049 break;
2050 case 'h':
2051 if (is_sign) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002052 short *s = (short *)va_arg(args, short *);
2053 *s = (short)simple_strtol(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 } else {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002055 unsigned short *s = (unsigned short *)va_arg(args, unsigned short *);
2056 *s = (unsigned short)simple_strtoul(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 }
2058 break;
2059 case 'l':
2060 if (is_sign) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002061 long *l = (long *)va_arg(args, long *);
2062 *l = simple_strtol(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 } else {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002064 unsigned long *l = (unsigned long *)va_arg(args, unsigned long *);
2065 *l = simple_strtoul(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 }
2067 break;
2068 case 'L':
2069 if (is_sign) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002070 long long *l = (long long *)va_arg(args, long long *);
2071 *l = simple_strtoll(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 } else {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002073 unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *);
2074 *l = simple_strtoull(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 }
2076 break;
2077 case 'Z':
2078 case 'z':
2079 {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002080 size_t *s = (size_t *)va_arg(args, size_t *);
2081 *s = (size_t)simple_strtoul(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 }
2083 break;
2084 default:
2085 if (is_sign) {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002086 int *i = (int *)va_arg(args, int *);
2087 *i = (int)simple_strtol(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 } else {
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002089 unsigned int *i = (unsigned int *)va_arg(args, unsigned int*);
2090 *i = (unsigned int)simple_strtoul(str, &next, base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 }
2092 break;
2093 }
2094 num++;
2095
2096 if (!next)
2097 break;
2098 str = next;
2099 }
Johannes Bergc6b40d12007-05-08 00:27:20 -07002100
2101 /*
2102 * Now we've come all the way through so either the input string or the
2103 * format ended. In the former case, there can be a %n at the current
2104 * position in the format that needs to be filled.
2105 */
2106 if (*fmt == '%' && *(fmt + 1) == 'n') {
2107 int *p = (int *)va_arg(args, int *);
2108 *p = str - buf;
2109 }
2110
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 return num;
2112}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113EXPORT_SYMBOL(vsscanf);
2114
2115/**
2116 * sscanf - Unformat a buffer into a list of arguments
2117 * @buf: input buffer
2118 * @fmt: formatting of buffer
2119 * @...: resulting arguments
2120 */
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002121int sscanf(const char *buf, const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122{
2123 va_list args;
2124 int i;
2125
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002126 va_start(args, fmt);
2127 i = vsscanf(buf, fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 va_end(args);
André Goddard Rosa7b9186f2009-12-14 18:00:57 -08002129
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 return i;
2131}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132EXPORT_SYMBOL(sscanf);