Merge commit 'v2.6.34.7' into dev-df3210-staging
[linux-2.6/parrot-frames.git] / lib / vsprintf.c
blob46d34b0b74a873290b0cd9fcfff6c19561c91de4
1 /*
2 * linux/lib/vsprintf.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8 /*
9 * Wirzenius wrote this portably, Torvalds fucked it up :-)
13 * 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
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>
25 #include <linux/kallsyms.h>
26 #include <linux/uaccess.h>
27 #include <linux/ioport.h>
28 #include <net/addrconf.h>
30 #include <asm/page.h> /* for PAGE_SIZE */
31 #include <asm/div64.h>
32 #include <asm/sections.h> /* for dereference_function_descriptor() */
34 /* Works only for digits and letters, but small and fast */
35 #define TOLOWER(x) ((x) | 0x20)
37 static unsigned int simple_guess_base(const char *cp)
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;
49 /**
50 * 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
55 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
57 unsigned long long result = 0;
59 if (!base)
60 base = simple_guess_base(cp);
62 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
63 cp += 2;
65 while (isxdigit(*cp)) {
66 unsigned int value;
68 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
69 if (value >= base)
70 break;
71 result = result * base + value;
72 cp++;
74 if (endp)
75 *endp = (char *)cp;
77 return result;
79 EXPORT_SYMBOL(simple_strtoull);
81 /**
82 * 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
87 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
89 return simple_strtoull(cp, endp, base);
91 EXPORT_SYMBOL(simple_strtoul);
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
99 long simple_strtol(const char *cp, char **endp, unsigned int base)
101 if (*cp == '-')
102 return -simple_strtoul(cp + 1, endp, base);
104 return simple_strtoul(cp, endp, base);
106 EXPORT_SYMBOL(simple_strtol);
109 * 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
114 long long simple_strtoll(const char *cp, char **endp, unsigned int base)
116 if (*cp == '-')
117 return -simple_strtoull(cp + 1, endp, base);
119 return simple_strtoull(cp, endp, base);
121 EXPORT_SYMBOL(simple_strtoll);
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
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:
135 * echo 1024 > /sys/module/e1000/parameters/copybreak
137 * echo will append a newline to the tail.
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.
142 * simple_strtoul just ignores the successive invalid characters and
143 * return the converted value of prefix part of the string.
145 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
147 char *tail;
148 unsigned long val;
149 size_t len;
151 *res = 0;
152 len = strlen(cp);
153 if (len == 0)
154 return -EINVAL;
156 val = simple_strtoul(cp, &tail, base);
157 if (tail == cp)
158 return -EINVAL;
160 if ((*tail == '\0') ||
161 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
162 *res = val;
163 return 0;
166 return -EINVAL;
168 EXPORT_SYMBOL(strict_strtoul);
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
176 * strict_strtol is similiar to strict_strtoul, but it allows the first
177 * character of a string is '-'.
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.
182 int strict_strtol(const char *cp, unsigned int base, long *res)
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);
193 return ret;
195 EXPORT_SYMBOL(strict_strtol);
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
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:
209 * echo 1024 > /sys/module/e1000/parameters/copybreak
211 * echo will append a newline to the tail of the string.
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.
216 * simple_strtoull just ignores the successive invalid characters and
217 * return the converted value of prefix part of the string.
219 int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res)
221 char *tail;
222 unsigned long long val;
223 size_t len;
225 *res = 0;
226 len = strlen(cp);
227 if (len == 0)
228 return -EINVAL;
230 val = simple_strtoull(cp, &tail, base);
231 if (tail == cp)
232 return -EINVAL;
233 if ((*tail == '\0') ||
234 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
235 *res = val;
236 return 0;
239 return -EINVAL;
241 EXPORT_SYMBOL(strict_strtoull);
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
249 * strict_strtoll is similiar to strict_strtoull, but it allows the first
250 * character of a string is '-'.
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.
255 int strict_strtoll(const char *cp, unsigned int base, long long *res)
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);
266 return ret;
268 EXPORT_SYMBOL(strict_strtoll);
270 static int skip_atoi(const char **s)
272 int i = 0;
274 while (isdigit(**s))
275 i = i*10 + *((*s)++) - '0';
277 return i;
280 /* 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). */
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. */
290 static char *put_dec_trunc(char *buf, unsigned q)
292 unsigned d3, d2, d1, d0;
293 d1 = (q>>4) & 0xf;
294 d2 = (q>>8) & 0xf;
295 d3 = (q>>12);
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 */
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 */
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)
319 *buf++ = q + '0'; /* most sign. digit */
324 return buf;
326 /* Same with if's removed. Always emits five digits */
327 static char *put_dec_full(char *buf, unsigned q)
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);
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)
345 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';
354 d2 = q + 2*d2;
355 q = (d2 * 0xd) >> 7;
356 d2 = d2 - 10*q;
357 *buf++ = d2 + '0';
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';
366 return buf;
368 /* No inlining helps gcc to use registers better */
369 static noinline char *put_dec(char *buf, unsigned long long num)
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);
380 #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 */
385 #define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */
386 #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */
388 enum format_type {
389 FORMAT_TYPE_NONE, /* Just a string part */
390 FORMAT_TYPE_WIDTH,
391 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,
400 FORMAT_TYPE_UBYTE,
401 FORMAT_TYPE_BYTE,
402 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
411 struct printf_spec {
412 u8 type; /* format_type enum */
413 u8 flags; /* flags to number() */
414 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 */
420 static char *number(char *buf, char *end, unsigned long long num,
421 struct printf_spec spec)
423 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
424 static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
426 char tmp[66];
427 char sign;
428 char locase;
429 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
430 int i;
432 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
433 * produces same digits or (maybe lowercased) letters */
434 locase = (spec.flags & SMALL);
435 if (spec.flags & LEFT)
436 spec.flags &= ~ZEROPAD;
437 sign = 0;
438 if (spec.flags & SIGN) {
439 if ((signed long long)num < 0) {
440 sign = '-';
441 num = -(signed long long)num;
442 spec.field_width--;
443 } else if (spec.flags & PLUS) {
444 sign = '+';
445 spec.field_width--;
446 } else if (spec.flags & SPACE) {
447 sign = ' ';
448 spec.field_width--;
451 if (need_pfx) {
452 spec.field_width--;
453 if (spec.base == 16)
454 spec.field_width--;
457 /* generate full string in tmp[], in reverse order */
458 i = 0;
459 if (num == 0)
460 tmp[i++] = '0';
461 /* Generic code, for any base:
462 else do {
463 tmp[i++] = (digits[do_div(num,base)] | locase);
464 } while (num != 0);
466 else if (spec.base != 10) { /* 8 or 16 */
467 int mask = spec.base - 1;
468 int shift = 3;
470 if (spec.base == 16)
471 shift = 4;
472 do {
473 tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
474 num >>= shift;
475 } while (num);
476 } else { /* base 10 */
477 i = put_dec(tmp, num) - tmp;
480 /* printing 100 using %2d gives "100", not "00" */
481 if (i > spec.precision)
482 spec.precision = i;
483 /* leading space padding */
484 spec.field_width -= spec.precision;
485 if (!(spec.flags & (ZEROPAD+LEFT))) {
486 while (--spec.field_width >= 0) {
487 if (buf < end)
488 *buf = ' ';
489 ++buf;
492 /* sign */
493 if (sign) {
494 if (buf < end)
495 *buf = sign;
496 ++buf;
498 /* "0x" / "0" prefix */
499 if (need_pfx) {
500 if (buf < end)
501 *buf = '0';
502 ++buf;
503 if (spec.base == 16) {
504 if (buf < end)
505 *buf = ('X' | locase);
506 ++buf;
509 /* zero or space padding */
510 if (!(spec.flags & LEFT)) {
511 char c = (spec.flags & ZEROPAD) ? '0' : ' ';
512 while (--spec.field_width >= 0) {
513 if (buf < end)
514 *buf = c;
515 ++buf;
518 /* hmm even more zero padding? */
519 while (i <= --spec.precision) {
520 if (buf < end)
521 *buf = '0';
522 ++buf;
524 /* actual digits of result */
525 while (--i >= 0) {
526 if (buf < end)
527 *buf = tmp[i];
528 ++buf;
530 /* trailing space padding */
531 while (--spec.field_width >= 0) {
532 if (buf < end)
533 *buf = ' ';
534 ++buf;
537 return buf;
540 static char *string(char *buf, char *end, const char *s, struct printf_spec spec)
542 int len, i;
544 if ((unsigned long)s < PAGE_SIZE)
545 s = "(null)";
547 len = strnlen(s, spec.precision);
549 if (!(spec.flags & LEFT)) {
550 while (len < spec.field_width--) {
551 if (buf < end)
552 *buf = ' ';
553 ++buf;
556 for (i = 0; i < len; ++i) {
557 if (buf < end)
558 *buf = *s;
559 ++buf; ++s;
561 while (len < spec.field_width--) {
562 if (buf < end)
563 *buf = ' ';
564 ++buf;
567 return buf;
570 static char *symbol_string(char *buf, char *end, void *ptr,
571 struct printf_spec spec, char ext)
573 unsigned long value = (unsigned long) ptr;
574 #ifdef CONFIG_KALLSYMS
575 char sym[KSYM_SYMBOL_LEN];
576 if (ext != 'f' && ext != 's')
577 sprint_symbol(sym, value);
578 else
579 kallsyms_lookup(value, NULL, NULL, NULL, sym);
581 return string(buf, end, sym, spec);
582 #else
583 spec.field_width = 2 * sizeof(void *);
584 spec.flags |= SPECIAL | SMALL | ZEROPAD;
585 spec.base = 16;
587 return number(buf, end, value, spec);
588 #endif
591 static char *resource_string(char *buf, char *end, struct resource *res,
592 struct printf_spec spec, const char *fmt)
594 #ifndef IO_RSRC_PRINTK_SIZE
595 #define IO_RSRC_PRINTK_SIZE 6
596 #endif
598 #ifndef MEM_RSRC_PRINTK_SIZE
599 #define MEM_RSRC_PRINTK_SIZE 10
600 #endif
601 static const struct printf_spec io_spec = {
602 .base = 16,
603 .field_width = IO_RSRC_PRINTK_SIZE,
604 .precision = -1,
605 .flags = SPECIAL | SMALL | ZEROPAD,
607 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,
613 static const struct printf_spec bus_spec = {
614 .base = 16,
615 .field_width = 2,
616 .precision = -1,
617 .flags = SMALL | ZEROPAD,
619 static const struct printf_spec dec_spec = {
620 .base = 10,
621 .precision = -1,
622 .flags = 0,
624 static const struct printf_spec str_spec = {
625 .field_width = -1,
626 .precision = 10,
627 .flags = LEFT,
629 static const struct printf_spec flag_spec = {
630 .base = 16,
631 .precision = -1,
632 .flags = SPECIAL | SMALL,
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))
639 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
640 #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)];
644 char *p = sym, *pend = sym + sizeof(sym);
645 int decode = (fmt[0] == 'R') ? 1 : 0;
646 const struct printf_spec *specp;
648 *p++ = '[';
649 if (res->flags & IORESOURCE_IO) {
650 p = string(p, pend, "io ", str_spec);
651 specp = &io_spec;
652 } else if (res->flags & IORESOURCE_MEM) {
653 p = string(p, pend, "mem ", str_spec);
654 specp = &mem_spec;
655 } else if (res->flags & IORESOURCE_IRQ) {
656 p = string(p, pend, "irq ", str_spec);
657 specp = &dec_spec;
658 } else if (res->flags & IORESOURCE_DMA) {
659 p = string(p, pend, "dma ", str_spec);
660 specp = &dec_spec;
661 } else if (res->flags & IORESOURCE_BUS) {
662 p = string(p, pend, "bus ", str_spec);
663 specp = &bus_spec;
664 } else {
665 p = string(p, pend, "??? ", str_spec);
666 specp = &mem_spec;
667 decode = 0;
669 p = number(p, pend, res->start, *specp);
670 if (res->start != res->end) {
671 *p++ = '-';
672 p = number(p, pend, res->end, *specp);
674 if (decode) {
675 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);
679 if (res->flags & IORESOURCE_WINDOW)
680 p = string(p, pend, " window", str_spec);
681 if (res->flags & IORESOURCE_DISABLED)
682 p = string(p, pend, " disabled", str_spec);
683 } else {
684 p = string(p, pend, " flags ", str_spec);
685 p = number(p, pend, res->flags, flag_spec);
687 *p++ = ']';
688 *p = '\0';
690 return string(buf, end, sym, spec);
693 static char *mac_address_string(char *buf, char *end, u8 *addr,
694 struct printf_spec spec, const char *fmt)
696 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
697 char *p = mac_addr;
698 int i;
699 char separator;
701 if (fmt[1] == 'F') { /* FDDI canonical format */
702 separator = '-';
703 } else {
704 separator = ':';
707 for (i = 0; i < 6; i++) {
708 p = pack_hex_byte(p, addr[i]);
709 if (fmt[0] == 'M' && i != 5)
710 *p++ = separator;
712 *p = '\0';
714 return string(buf, end, mac_addr, spec);
717 static char *ip4_string(char *p, const u8 *addr, const char *fmt)
719 int i;
720 bool leading_zeros = (fmt[0] == 'i');
721 int index;
722 int step;
724 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;
745 for (i = 0; i < 4; i++) {
746 char temp[3]; /* hold each IP quad in reverse order */
747 int digits = put_dec_trunc(temp, addr[index]) - temp;
748 if (leading_zeros) {
749 if (digits < 3)
750 *p++ = '0';
751 if (digits < 2)
752 *p++ = '0';
754 /* reverse the digits in the quad */
755 while (digits--)
756 *p++ = temp[digits];
757 if (i < 3)
758 *p++ = '.';
759 index += step;
761 *p = '\0';
763 return p;
766 static char *ip6_compressed_string(char *p, const char *addr)
768 int i, j, range;
769 unsigned char zerolength[8];
770 int longest = 1;
771 int colonpos = -1;
772 u16 word;
773 u8 hi, lo;
774 bool needcolon = false;
775 bool useIPv4;
776 struct in6_addr in6;
778 memcpy(&in6, addr, sizeof(struct in6_addr));
780 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
782 memset(zerolength, 0, sizeof(zerolength));
784 if (useIPv4)
785 range = 6;
786 else
787 range = 8;
789 /* find position of longest 0 run */
790 for (i = 0; i < range; i++) {
791 for (j = i; j < range; j++) {
792 if (in6.s6_addr16[j] != 0)
793 break;
794 zerolength[i]++;
797 for (i = 0; i < range; i++) {
798 if (zerolength[i] > longest) {
799 longest = zerolength[i];
800 colonpos = i;
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;
814 if (needcolon) {
815 *p++ = ':';
816 needcolon = false;
818 /* hex u16 without leading 0s */
819 word = ntohs(in6.s6_addr16[i]);
820 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);
827 p = pack_hex_byte(p, lo);
829 else if (lo > 0x0f)
830 p = pack_hex_byte(p, lo);
831 else
832 *p++ = hex_asc_lo(lo);
833 needcolon = true;
836 if (useIPv4) {
837 if (needcolon)
838 *p++ = ':';
839 p = ip4_string(p, &in6.s6_addr[12], "I4");
841 *p = '\0';
843 return p;
846 static char *ip6_string(char *p, const char *addr, const char *fmt)
848 int i;
850 for (i = 0; i < 8; i++) {
851 p = pack_hex_byte(p, *addr++);
852 p = pack_hex_byte(p, *addr++);
853 if (fmt[0] == 'I' && i != 7)
854 *p++ = ':';
856 *p = '\0';
858 return p;
861 static char *ip6_addr_string(char *buf, char *end, const u8 *addr,
862 struct printf_spec spec, const char *fmt)
864 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
866 if (fmt[0] == 'I' && fmt[2] == 'c')
867 ip6_compressed_string(ip6_addr, addr);
868 else
869 ip6_string(ip6_addr, addr, fmt);
871 return string(buf, end, ip6_addr, spec);
874 static char *ip4_addr_string(char *buf, char *end, const u8 *addr,
875 struct printf_spec spec, const char *fmt)
877 char ip4_addr[sizeof("255.255.255.255")];
879 ip4_string(ip4_addr, addr, fmt);
881 return string(buf, end, ip4_addr, spec);
884 static char *uuid_string(char *buf, char *end, const u8 *addr,
885 struct printf_spec spec, const char *fmt)
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;
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;
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;
918 *p = 0;
920 if (uc) {
921 p = uuid;
922 do {
923 *p = toupper(*p);
924 } while (*(++p));
927 return string(buf, end, uuid, spec);
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.
935 * Right now we handle:
937 * - 'F' For symbolic function descriptor pointers with offset
938 * - 'f' For simple symbolic function names without offset
939 * - 'S' For symbolic direct pointers with offset
940 * - 's' For symbolic direct pointers without offset
941 * - '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]
943 * - 'M' For a 6-byte MAC address, it prints the address in the
944 * usual colon-separated hex notation
945 * - 'm' For a 6-byte MAC address, it prints the hex address without colons
946 * - 'MF' For a 6-byte MAC FDDI address, it prints the address
947 * with a dash-separated hex notation
948 * - '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)
954 * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order
955 * - 'I6c' for IPv6 addresses printed as specified by
956 * http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
957 * - '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]
969 * 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.
973 static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
974 struct printf_spec spec)
976 if (!ptr)
977 return string(buf, end, "(null)", spec);
979 switch (*fmt) {
980 case 'F':
981 case 'f':
982 ptr = dereference_function_descriptor(ptr);
983 /* Fallthrough */
984 case 'S':
985 case 's':
986 return symbol_string(buf, end, ptr, spec, *fmt);
987 case 'R':
988 case 'r':
989 return resource_string(buf, end, ptr, spec, fmt);
990 case 'M': /* Colon separated: 00:01:02:03:04:05 */
991 case 'm': /* Contiguous: 000102030405 */
992 /* [mM]F (FDDI, bit reversed) */
993 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
999 case 'i': /* Contiguous:
1000 * 4: 001.002.003.004
1001 * 6: 000102...0f
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);
1009 break;
1010 case 'U':
1011 return uuid_string(buf, end, ptr, spec, fmt);
1013 spec.flags |= SMALL;
1014 if (spec.field_width == -1) {
1015 spec.field_width = 2*sizeof(void *);
1016 spec.flags |= ZEROPAD;
1018 spec.base = 16;
1020 return number(buf, end, (unsigned long) ptr, spec);
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
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
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, ...)
1043 static int format_decode(const char *fmt, struct printf_spec *spec)
1045 const char *start = fmt;
1047 /* we finished early by reading the field width */
1048 if (spec->type == FORMAT_TYPE_WIDTH) {
1049 if (spec->field_width < 0) {
1050 spec->field_width = -spec->field_width;
1051 spec->flags |= LEFT;
1053 spec->type = FORMAT_TYPE_NONE;
1054 goto precision;
1057 /* we finished early by reading the precision */
1058 if (spec->type == FORMAT_TYPE_PRECISION) {
1059 if (spec->precision < 0)
1060 spec->precision = 0;
1062 spec->type = FORMAT_TYPE_NONE;
1063 goto qualifier;
1066 /* By default */
1067 spec->type = FORMAT_TYPE_NONE;
1069 for (; *fmt ; ++fmt) {
1070 if (*fmt == '%')
1071 break;
1074 /* Return the current non-format string */
1075 if (fmt != start || !*fmt)
1076 return fmt - start;
1078 /* Process flags */
1079 spec->flags = 0;
1081 while (1) { /* this also skips first '%' */
1082 bool found = true;
1084 ++fmt;
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;
1095 if (!found)
1096 break;
1099 /* get field width */
1100 spec->field_width = -1;
1102 if (isdigit(*fmt))
1103 spec->field_width = skip_atoi(&fmt);
1104 else if (*fmt == '*') {
1105 /* it's the next argument */
1106 spec->type = FORMAT_TYPE_WIDTH;
1107 return ++fmt - start;
1110 precision:
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 */
1121 spec->type = FORMAT_TYPE_PRECISION;
1122 return ++fmt - start;
1126 qualifier:
1127 /* get the conversion qualifier */
1128 spec->qualifier = -1;
1129 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1130 TOLOWER(*fmt) == 'z' || *fmt == 't') {
1131 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;
1143 /* default base */
1144 spec->base = 10;
1145 switch (*fmt) {
1146 case 'c':
1147 spec->type = FORMAT_TYPE_CHAR;
1148 return ++fmt - start;
1150 case 's':
1151 spec->type = FORMAT_TYPE_STR;
1152 return ++fmt - start;
1154 case 'p':
1155 spec->type = FORMAT_TYPE_PTR;
1156 return fmt - start;
1157 /* skip alnum */
1159 case 'n':
1160 spec->type = FORMAT_TYPE_NRCHARS;
1161 return ++fmt - start;
1163 case '%':
1164 spec->type = FORMAT_TYPE_PERCENT_CHAR;
1165 return ++fmt - start;
1167 /* integer number formats - set up the flags and "break" */
1168 case 'o':
1169 spec->base = 8;
1170 break;
1172 case 'x':
1173 spec->flags |= SMALL;
1175 case 'X':
1176 spec->base = 16;
1177 break;
1179 case 'd':
1180 case 'i':
1181 spec->flags |= SIGN;
1182 case 'u':
1183 break;
1185 default:
1186 spec->type = FORMAT_TYPE_INVALID;
1187 return fmt - start;
1190 if (spec->qualifier == 'L')
1191 spec->type = FORMAT_TYPE_LONG_LONG;
1192 else if (spec->qualifier == 'l') {
1193 if (spec->flags & SIGN)
1194 spec->type = FORMAT_TYPE_LONG;
1195 else
1196 spec->type = FORMAT_TYPE_ULONG;
1197 } else if (TOLOWER(spec->qualifier) == 'z') {
1198 spec->type = FORMAT_TYPE_SIZE_T;
1199 } else if (spec->qualifier == 't') {
1200 spec->type = FORMAT_TYPE_PTRDIFF;
1201 } else if (spec->qualifier == 'H') {
1202 if (spec->flags & SIGN)
1203 spec->type = FORMAT_TYPE_BYTE;
1204 else
1205 spec->type = FORMAT_TYPE_UBYTE;
1206 } else if (spec->qualifier == 'h') {
1207 if (spec->flags & SIGN)
1208 spec->type = FORMAT_TYPE_SHORT;
1209 else
1210 spec->type = FORMAT_TYPE_USHORT;
1211 } else {
1212 if (spec->flags & SIGN)
1213 spec->type = FORMAT_TYPE_INT;
1214 else
1215 spec->type = FORMAT_TYPE_UINT;
1218 return ++fmt - start;
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
1228 * This function follows C99 vsnprintf, but has some extensions:
1229 * %pS output the name of a text symbol with offset
1230 * %ps output the name of a text symbol without offset
1231 * %pF output the name of a function pointer with its offset
1232 * %pf output the name of a function pointer without its offset
1233 * %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
1242 * http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
1243 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
1244 * case.
1245 * %n is ignored
1247 * 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
1251 * (not including the trailing '\0'), use vscnprintf(). If the
1252 * return is greater than or equal to @size, the resulting
1253 * string is truncated.
1255 * Call this function if you are already dealing with a va_list.
1256 * You probably want snprintf() instead.
1258 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1260 unsigned long long num;
1261 char *str, *end;
1262 struct printf_spec spec = {0};
1264 /* Reject out-of-range values early. Large positive sizes are
1265 used for unknown buffer sizes. */
1266 if (WARN_ON_ONCE((int) size < 0))
1267 return 0;
1269 str = buf;
1270 end = buf + size;
1272 /* Make sure end is always >= buf */
1273 if (end < buf) {
1274 end = ((void *)-1);
1275 size = end - buf;
1278 while (*fmt) {
1279 const char *old_fmt = fmt;
1280 int read = format_decode(fmt, &spec);
1282 fmt += read;
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);
1292 str += read;
1293 break;
1296 case FORMAT_TYPE_WIDTH:
1297 spec.field_width = va_arg(args, int);
1298 break;
1300 case FORMAT_TYPE_PRECISION:
1301 spec.precision = va_arg(args, int);
1302 break;
1304 case FORMAT_TYPE_CHAR: {
1305 char c;
1307 if (!(spec.flags & LEFT)) {
1308 while (--spec.field_width > 0) {
1309 if (str < end)
1310 *str = ' ';
1311 ++str;
1315 c = (unsigned char) va_arg(args, int);
1316 if (str < end)
1317 *str = c;
1318 ++str;
1319 while (--spec.field_width > 0) {
1320 if (str < end)
1321 *str = ' ';
1322 ++str;
1324 break;
1327 case FORMAT_TYPE_STR:
1328 str = string(str, end, va_arg(args, char *), spec);
1329 break;
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;
1338 case FORMAT_TYPE_PERCENT_CHAR:
1339 if (str < end)
1340 *str = '%';
1341 ++str;
1342 break;
1344 case FORMAT_TYPE_INVALID:
1345 if (str < end)
1346 *str = '%';
1347 ++str;
1348 break;
1350 case FORMAT_TYPE_NRCHARS: {
1351 u8 qualifier = spec.qualifier;
1353 if (qualifier == 'l') {
1354 long *ip = va_arg(args, long *);
1355 *ip = (str - buf);
1356 } else if (TOLOWER(qualifier) == 'z') {
1357 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);
1363 break;
1366 default:
1367 switch (spec.type) {
1368 case FORMAT_TYPE_LONG_LONG:
1369 num = va_arg(args, long long);
1370 break;
1371 case FORMAT_TYPE_ULONG:
1372 num = va_arg(args, unsigned long);
1373 break;
1374 case FORMAT_TYPE_LONG:
1375 num = va_arg(args, long);
1376 break;
1377 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;
1383 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;
1389 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;
1395 case FORMAT_TYPE_INT:
1396 num = (int) va_arg(args, int);
1397 break;
1398 default:
1399 num = va_arg(args, unsigned int);
1402 str = number(str, end, num, spec);
1406 if (size > 0) {
1407 if (str < end)
1408 *str = '\0';
1409 else
1410 end[-1] = '\0';
1413 /* the trailing null byte doesn't count towards the total */
1414 return str-buf;
1417 EXPORT_SYMBOL(vsnprintf);
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
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.
1430 * Call this function if you are already dealing with a va_list.
1431 * You probably want scnprintf() instead.
1433 * See the vsnprintf() documentation for format string extensions over C99.
1435 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1437 int i;
1439 i = vsnprintf(buf, size, fmt, args);
1441 return (i >= size) ? (size - 1) : i;
1443 EXPORT_SYMBOL(vscnprintf);
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
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.
1457 * See the vsnprintf() documentation for format string extensions over C99.
1459 int snprintf(char *buf, size_t size, const char *fmt, ...)
1461 va_list args;
1462 int i;
1464 va_start(args, fmt);
1465 i = vsnprintf(buf, size, fmt, args);
1466 va_end(args);
1468 return i;
1470 EXPORT_SYMBOL(snprintf);
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
1479 * The return value is the number of characters written into @buf not including
1480 * the trailing '\0'. If @size is <= 0 the function returns 0.
1483 int scnprintf(char *buf, size_t size, const char *fmt, ...)
1485 va_list args;
1486 int i;
1488 va_start(args, fmt);
1489 i = vsnprintf(buf, size, fmt, args);
1490 va_end(args);
1492 return (i >= size) ? (size - 1) : i;
1494 EXPORT_SYMBOL(scnprintf);
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
1502 * The function returns the number of characters written
1503 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
1504 * buffer overflows.
1506 * Call this function if you are already dealing with a va_list.
1507 * You probably want sprintf() instead.
1509 * See the vsnprintf() documentation for format string extensions over C99.
1511 int vsprintf(char *buf, const char *fmt, va_list args)
1513 return vsnprintf(buf, INT_MAX, fmt, args);
1515 EXPORT_SYMBOL(vsprintf);
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
1523 * The function returns the number of characters written
1524 * into @buf. Use snprintf() or scnprintf() in order to avoid
1525 * buffer overflows.
1527 * See the vsnprintf() documentation for format string extensions over C99.
1529 int sprintf(char *buf, const char *fmt, ...)
1531 va_list args;
1532 int i;
1534 va_start(args, fmt);
1535 i = vsnprintf(buf, INT_MAX, fmt, args);
1536 va_end(args);
1538 return i;
1540 EXPORT_SYMBOL(sprintf);
1542 #ifdef CONFIG_BINARY_PRINTF
1544 * bprintf service:
1545 * vbin_printf() - VA arguments to binary data
1546 * bstr_printf() - Binary data to text string
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
1556 * The format follows C99 vsnprintf, except %n is ignored, and its argument
1557 * is skiped.
1559 * The return value is the number of words(32bits) which would be generated for
1560 * the given input.
1562 * NOTE:
1563 * If the return value is greater than @size, the resulting bin_buf is NOT
1564 * valid for bstr_printf().
1566 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
1568 struct printf_spec spec = {0};
1569 char *str, *end;
1571 str = (char *)bin_buf;
1572 end = (char *)(bin_buf + size);
1574 #define save_arg(type) \
1575 do { \
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); \
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; \
1591 str += sizeof(type); \
1592 } while (0)
1594 while (*fmt) {
1595 int read = format_decode(fmt, &spec);
1597 fmt += read;
1599 switch (spec.type) {
1600 case FORMAT_TYPE_NONE:
1601 case FORMAT_TYPE_INVALID:
1602 case FORMAT_TYPE_PERCENT_CHAR:
1603 break;
1605 case FORMAT_TYPE_WIDTH:
1606 case FORMAT_TYPE_PRECISION:
1607 save_arg(int);
1608 break;
1610 case FORMAT_TYPE_CHAR:
1611 save_arg(char);
1612 break;
1614 case FORMAT_TYPE_STR: {
1615 const char *save_str = va_arg(args, char *);
1616 size_t len;
1618 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
1619 || (unsigned long)save_str < PAGE_SIZE)
1620 save_str = "(null)";
1621 len = strlen(save_str) + 1;
1622 if (str + len < end)
1623 memcpy(str, save_str, len);
1624 str += len;
1625 break;
1628 case FORMAT_TYPE_PTR:
1629 save_arg(void *);
1630 /* skip all alphanumeric pointer suffixes */
1631 while (isalnum(*fmt))
1632 fmt++;
1633 break;
1635 case FORMAT_TYPE_NRCHARS: {
1636 /* skip %n 's argument */
1637 u8 qualifier = spec.qualifier;
1638 void *skip_arg;
1639 if (qualifier == 'l')
1640 skip_arg = va_arg(args, long *);
1641 else if (TOLOWER(qualifier) == 'z')
1642 skip_arg = va_arg(args, size_t *);
1643 else
1644 skip_arg = va_arg(args, int *);
1645 break;
1648 default:
1649 switch (spec.type) {
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;
1664 case FORMAT_TYPE_UBYTE:
1665 case FORMAT_TYPE_BYTE:
1666 save_arg(char);
1667 break;
1668 case FORMAT_TYPE_USHORT:
1669 case FORMAT_TYPE_SHORT:
1670 save_arg(short);
1671 break;
1672 default:
1673 save_arg(int);
1678 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
1679 #undef save_arg
1681 EXPORT_SYMBOL_GPL(vbin_printf);
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
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.
1694 * The format follows C99 vsnprintf, but has some extensions:
1695 * see vsnprintf comment for details.
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.
1705 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
1707 struct printf_spec spec = {0};
1708 char *str, *end;
1709 const char *args = (const char *)bin_buf;
1711 if (WARN_ON_ONCE((int) size < 0))
1712 return 0;
1714 str = buf;
1715 end = buf + size;
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; \
1728 args += sizeof(type); \
1729 value; \
1732 /* Make sure end is always >= buf */
1733 if (end < buf) {
1734 end = ((void *)-1);
1735 size = end - buf;
1738 while (*fmt) {
1739 const char *old_fmt = fmt;
1740 int read = format_decode(fmt, &spec);
1742 fmt += read;
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);
1752 str += read;
1753 break;
1756 case FORMAT_TYPE_WIDTH:
1757 spec.field_width = get_arg(int);
1758 break;
1760 case FORMAT_TYPE_PRECISION:
1761 spec.precision = get_arg(int);
1762 break;
1764 case FORMAT_TYPE_CHAR: {
1765 char c;
1767 if (!(spec.flags & LEFT)) {
1768 while (--spec.field_width > 0) {
1769 if (str < end)
1770 *str = ' ';
1771 ++str;
1774 c = (unsigned char) get_arg(char);
1775 if (str < end)
1776 *str = c;
1777 ++str;
1778 while (--spec.field_width > 0) {
1779 if (str < end)
1780 *str = ' ';
1781 ++str;
1783 break;
1786 case FORMAT_TYPE_STR: {
1787 const char *str_arg = args;
1788 args += strlen(str_arg) + 1;
1789 str = string(str, end, (char *)str_arg, spec);
1790 break;
1793 case FORMAT_TYPE_PTR:
1794 str = pointer(fmt+1, str, end, get_arg(void *), spec);
1795 while (isalnum(*fmt))
1796 fmt++;
1797 break;
1799 case FORMAT_TYPE_PERCENT_CHAR:
1800 case FORMAT_TYPE_INVALID:
1801 if (str < end)
1802 *str = '%';
1803 ++str;
1804 break;
1806 case FORMAT_TYPE_NRCHARS:
1807 /* skip */
1808 break;
1810 default: {
1811 unsigned long long num;
1813 switch (spec.type) {
1815 case FORMAT_TYPE_LONG_LONG:
1816 num = get_arg(long long);
1817 break;
1818 case FORMAT_TYPE_ULONG:
1819 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;
1828 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;
1834 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);
1847 str = number(str, end, num, spec);
1848 } /* default: */
1849 } /* switch(spec.type) */
1850 } /* while(*fmt) */
1852 if (size > 0) {
1853 if (str < end)
1854 *str = '\0';
1855 else
1856 end[-1] = '\0';
1859 #undef get_arg
1861 /* the trailing null byte doesn't count towards the total */
1862 return str - buf;
1864 EXPORT_SYMBOL_GPL(bstr_printf);
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
1873 * The function returns the number of words(u32) written
1874 * into @bin_buf.
1876 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
1878 va_list args;
1879 int ret;
1881 va_start(args, fmt);
1882 ret = vbin_printf(bin_buf, size, fmt, args);
1883 va_end(args);
1885 return ret;
1887 EXPORT_SYMBOL_GPL(bprintf);
1889 #endif /* CONFIG_BINARY_PRINTF */
1892 * vsscanf - Unformat a buffer into a list of arguments
1893 * @buf: input buffer
1894 * @fmt: format of buffer
1895 * @args: arguments
1897 int vsscanf(const char *buf, const char *fmt, va_list args)
1899 const char *str = buf;
1900 char *next;
1901 char digit;
1902 int num = 0;
1903 u8 qualifier;
1904 u8 base;
1905 s16 field_width;
1906 bool is_sign;
1908 while (*fmt && *str) {
1909 /* skip any white space in format */
1910 /* white space in format matchs any amount of
1911 * white space, including none, in the input.
1913 if (isspace(*fmt)) {
1914 fmt = skip_spaces(++fmt);
1915 str = skip_spaces(str);
1918 /* anything that is not a conversion must match exactly */
1919 if (*fmt != '%' && *fmt) {
1920 if (*fmt++ != *str++)
1921 break;
1922 continue;
1925 if (!*fmt)
1926 break;
1927 ++fmt;
1929 /* skip this conversion.
1930 * advance both strings to next white space
1932 if (*fmt == '*') {
1933 while (!isspace(*fmt) && *fmt != '%' && *fmt)
1934 fmt++;
1935 while (!isspace(*str) && *str)
1936 str++;
1937 continue;
1940 /* get field width */
1941 field_width = -1;
1942 if (isdigit(*fmt))
1943 field_width = skip_atoi(&fmt);
1945 /* get conversion qualifier */
1946 qualifier = -1;
1947 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1948 TOLOWER(*fmt) == 'z') {
1949 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++;
1961 if (!*fmt || !*str)
1962 break;
1964 base = 10;
1965 is_sign = 0;
1967 switch (*fmt++) {
1968 case 'c':
1970 char *s = (char *)va_arg(args, char*);
1971 if (field_width == -1)
1972 field_width = 1;
1973 do {
1974 *s++ = *str++;
1975 } while (--field_width > 0 && *str);
1976 num++;
1978 continue;
1979 case 's':
1981 char *s = (char *)va_arg(args, char *);
1982 if (field_width == -1)
1983 field_width = SHORT_MAX;
1984 /* first, skip leading white space in buffer */
1985 str = skip_spaces(str);
1987 /* now copy until next white space */
1988 while (*str && !isspace(*str) && field_width--)
1989 *s++ = *str++;
1990 *s = '\0';
1991 num++;
1993 continue;
1994 case 'n':
1995 /* return number of characters read so far */
1997 int *i = (int *)va_arg(args, int*);
1998 *i = str - buf;
2000 continue;
2001 case 'o':
2002 base = 8;
2003 break;
2004 case 'x':
2005 case 'X':
2006 base = 16;
2007 break;
2008 case 'i':
2009 base = 0;
2010 case 'd':
2011 is_sign = 1;
2012 case 'u':
2013 break;
2014 case '%':
2015 /* looking for '%' in str */
2016 if (*str++ != '%')
2017 return num;
2018 continue;
2019 default:
2020 /* invalid format; stop here */
2021 return num;
2024 /* have some sort of integer conversion.
2025 * first, skip white space in buffer.
2027 str = skip_spaces(str);
2029 digit = *str;
2030 if (is_sign && digit == '-')
2031 digit = *(str + 1);
2033 if (!digit
2034 || (base == 16 && !isxdigit(digit))
2035 || (base == 10 && !isdigit(digit))
2036 || (base == 8 && (!isdigit(digit) || digit > '7'))
2037 || (base == 0 && !isdigit(digit)))
2038 break;
2040 switch (qualifier) {
2041 case 'H': /* that's 'hh' in format */
2042 if (is_sign) {
2043 signed char *s = (signed char *)va_arg(args, signed char *);
2044 *s = (signed char)simple_strtol(str, &next, base);
2045 } else {
2046 unsigned char *s = (unsigned char *)va_arg(args, unsigned char *);
2047 *s = (unsigned char)simple_strtoul(str, &next, base);
2049 break;
2050 case 'h':
2051 if (is_sign) {
2052 short *s = (short *)va_arg(args, short *);
2053 *s = (short)simple_strtol(str, &next, base);
2054 } else {
2055 unsigned short *s = (unsigned short *)va_arg(args, unsigned short *);
2056 *s = (unsigned short)simple_strtoul(str, &next, base);
2058 break;
2059 case 'l':
2060 if (is_sign) {
2061 long *l = (long *)va_arg(args, long *);
2062 *l = simple_strtol(str, &next, base);
2063 } else {
2064 unsigned long *l = (unsigned long *)va_arg(args, unsigned long *);
2065 *l = simple_strtoul(str, &next, base);
2067 break;
2068 case 'L':
2069 if (is_sign) {
2070 long long *l = (long long *)va_arg(args, long long *);
2071 *l = simple_strtoll(str, &next, base);
2072 } else {
2073 unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *);
2074 *l = simple_strtoull(str, &next, base);
2076 break;
2077 case 'Z':
2078 case 'z':
2080 size_t *s = (size_t *)va_arg(args, size_t *);
2081 *s = (size_t)simple_strtoul(str, &next, base);
2083 break;
2084 default:
2085 if (is_sign) {
2086 int *i = (int *)va_arg(args, int *);
2087 *i = (int)simple_strtol(str, &next, base);
2088 } else {
2089 unsigned int *i = (unsigned int *)va_arg(args, unsigned int*);
2090 *i = (unsigned int)simple_strtoul(str, &next, base);
2092 break;
2094 num++;
2096 if (!next)
2097 break;
2098 str = next;
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.
2106 if (*fmt == '%' && *(fmt + 1) == 'n') {
2107 int *p = (int *)va_arg(args, int *);
2108 *p = str - buf;
2111 return num;
2113 EXPORT_SYMBOL(vsscanf);
2116 * sscanf - Unformat a buffer into a list of arguments
2117 * @buf: input buffer
2118 * @fmt: formatting of buffer
2119 * @...: resulting arguments
2121 int sscanf(const char *buf, const char *fmt, ...)
2123 va_list args;
2124 int i;
2126 va_start(args, fmt);
2127 i = vsscanf(buf, fmt, args);
2128 va_end(args);
2130 return i;
2132 EXPORT_SYMBOL(sscanf);