4 * Copyright (C) 1991, 1992 Linus Torvalds
7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
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
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 <linux/bitrev.h>
29 #include <net/addrconf.h>
31 #include <asm/page.h> /* for PAGE_SIZE */
32 #include <asm/div64.h>
33 #include <asm/sections.h> /* for dereference_function_descriptor() */
35 /* Works only for digits and letters, but small and fast */
36 #define TOLOWER(x) ((x) | 0x20)
38 static unsigned int simple_guess_base(const char *cp)
41 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
51 * simple_strtoull - convert a string to an unsigned long long
52 * @cp: The start of the string
53 * @endp: A pointer to the end of the parsed string will be placed here
54 * @base: The number base to use
56 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
58 unsigned long long result = 0;
61 base = simple_guess_base(cp);
63 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
66 while (isxdigit(*cp)) {
69 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
72 result = result * base + value;
80 EXPORT_SYMBOL(simple_strtoull);
83 * simple_strtoul - convert a string to an unsigned long
84 * @cp: The start of the string
85 * @endp: A pointer to the end of the parsed string will be placed here
86 * @base: The number base to use
88 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
90 return simple_strtoull(cp, endp, base);
92 EXPORT_SYMBOL(simple_strtoul);
95 * simple_strtol - convert a string to a signed long
96 * @cp: The start of the string
97 * @endp: A pointer to the end of the parsed string will be placed here
98 * @base: The number base to use
100 long simple_strtol(const char *cp, char **endp, unsigned int base)
103 return -simple_strtoul(cp + 1, endp, base);
105 return simple_strtoul(cp, endp, base);
107 EXPORT_SYMBOL(simple_strtol);
110 * simple_strtoll - convert a string to a signed long long
111 * @cp: The start of the string
112 * @endp: A pointer to the end of the parsed string will be placed here
113 * @base: The number base to use
115 long long simple_strtoll(const char *cp, char **endp, unsigned int base)
118 return -simple_strtoull(cp + 1, endp, base);
120 return simple_strtoull(cp, endp, base);
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)
156 val = simple_strtoul(cp, &tail, base);
160 if ((*tail == '\0') ||
161 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
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)
186 ret = strict_strtoul(cp + 1, base, (unsigned long *)res);
190 ret = strict_strtoul(cp, base, (unsigned long *)res);
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)
222 unsigned long long val;
230 val = simple_strtoull(cp, &tail, base);
233 if ((*tail == '\0') ||
234 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
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)
259 ret = strict_strtoull(cp + 1, base, (unsigned long long *)res);
263 ret = strict_strtoull(cp, base, (unsigned long long *)res);
268 EXPORT_SYMBOL(strict_strtoll);
270 static int skip_atoi(const char **s)
275 i = i*10 + *((*s)++) - '0';
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
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;
297 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
298 q = (d0 * 0xcd) >> 11;
300 *buf++ = d0 + '0'; /* least significant digit */
301 d1 = q + 9*d3 + 5*d2 + d1;
303 q = (d1 * 0xcd) >> 11;
305 *buf++ = d1 + '0'; /* next digit */
308 if ((d2 != 0) || (d3 != 0)) {
311 *buf++ = d2 + '0'; /* next digit */
315 q = (d3 * 0xcd) >> 11;
317 *buf++ = d3 + '0'; /* next digit */
319 *buf++ = q + '0'; /* most sign. digit */
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;
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;
349 d1 = q + 9*d3 + 5*d2 + d1;
350 q = (d1 * 0xcd) >> 11;
360 q = (d3 * 0xcd) >> 11; /* - shorter code */
361 /* q = (d3 * 0x67) >> 10; - would also work */
368 /* No inlining helps gcc to use registers better */
369 static noinline char *put_dec(char *buf, unsigned long long num)
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 /* Must be 32 == 0x20 */
386 #define SPECIAL 64 /* 0x */
389 FORMAT_TYPE_NONE, /* Just a string part */
391 FORMAT_TYPE_PRECISION,
395 FORMAT_TYPE_PERCENT_CHAR,
397 FORMAT_TYPE_LONG_LONG,
412 enum format_type type;
413 int flags; /* flags to number() */
414 int field_width; /* width of output field */
416 int 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"; */
429 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
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;
438 if (spec.flags & SIGN) {
439 if ((signed long long)num < 0) {
441 num = -(signed long long)num;
443 } else if (spec.flags & PLUS) {
446 } else if (spec.flags & SPACE) {
457 /* generate full string in tmp[], in reverse order */
461 /* Generic code, for any base:
463 tmp[i++] = (digits[do_div(num,base)] | locase);
466 else if (spec.base != 10) { /* 8 or 16 */
467 int mask = spec.base - 1;
473 tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
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)
483 /* leading space padding */
484 spec.field_width -= spec.precision;
485 if (!(spec.flags & (ZEROPAD+LEFT))) {
486 while (--spec.field_width >= 0) {
498 /* "0x" / "0" prefix */
503 if (spec.base == 16) {
505 *buf = ('X' | locase);
509 /* zero or space padding */
510 if (!(spec.flags & LEFT)) {
511 char c = (spec.flags & ZEROPAD) ? '0' : ' ';
512 while (--spec.field_width >= 0) {
518 /* hmm even more zero padding? */
519 while (i <= --spec.precision) {
524 /* actual digits of result */
530 /* trailing space padding */
531 while (--spec.field_width >= 0) {
540 static char *string(char *buf, char *end, const char *s, struct printf_spec spec)
544 if ((unsigned long)s < PAGE_SIZE)
547 len = strnlen(s, spec.precision);
549 if (!(spec.flags & LEFT)) {
550 while (len < spec.field_width--) {
556 for (i = 0; i < len; ++i) {
561 while (len < spec.field_width--) {
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);
579 kallsyms_lookup(value, NULL, NULL, NULL, sym);
581 return string(buf, end, sym, spec);
583 spec.field_width = 2 * sizeof(void *);
584 spec.flags |= SPECIAL | SMALL | ZEROPAD;
587 return number(buf, end, value, spec);
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
598 #ifndef MEM_RSRC_PRINTK_SIZE
599 #define MEM_RSRC_PRINTK_SIZE 10
601 struct printf_spec hex_spec = {
604 .flags = SPECIAL | SMALL | ZEROPAD,
606 struct printf_spec dec_spec = {
611 struct printf_spec str_spec = {
616 struct printf_spec flag_spec = {
619 .flags = SPECIAL | SMALL,
622 /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
623 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
624 #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
625 #define FLAG_BUF_SIZE (2 * sizeof(res->flags))
626 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref disabled]")
627 #define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
628 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
629 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
631 char *p = sym, *pend = sym + sizeof(sym);
632 int size = -1, addr = 0;
633 int decode = (fmt[0] == 'R') ? 1 : 0;
635 if (res->flags & IORESOURCE_IO) {
636 size = IO_RSRC_PRINTK_SIZE;
638 } else if (res->flags & IORESOURCE_MEM) {
639 size = MEM_RSRC_PRINTK_SIZE;
644 if (res->flags & IORESOURCE_IO)
645 p = string(p, pend, "io ", str_spec);
646 else if (res->flags & IORESOURCE_MEM)
647 p = string(p, pend, "mem ", str_spec);
648 else if (res->flags & IORESOURCE_IRQ)
649 p = string(p, pend, "irq ", str_spec);
650 else if (res->flags & IORESOURCE_DMA)
651 p = string(p, pend, "dma ", str_spec);
653 p = string(p, pend, "??? ", str_spec);
656 hex_spec.field_width = size;
657 p = number(p, pend, res->start, addr ? hex_spec : dec_spec);
658 if (res->start != res->end) {
660 p = number(p, pend, res->end, addr ? hex_spec : dec_spec);
663 if (res->flags & IORESOURCE_MEM_64)
664 p = string(p, pend, " 64bit", str_spec);
665 if (res->flags & IORESOURCE_PREFETCH)
666 p = string(p, pend, " pref", str_spec);
667 if (res->flags & IORESOURCE_DISABLED)
668 p = string(p, pend, " disabled", str_spec);
670 p = string(p, pend, " flags ", str_spec);
671 p = number(p, pend, res->flags, flag_spec);
676 return string(buf, end, sym, spec);
679 static char *mac_address_string(char *buf, char *end, u8 *addr,
680 struct printf_spec spec, const char *fmt)
682 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
688 if (fmt[1] == 'F') { /* FDDI canonical format */
696 for (i = 0; i < 6; i++) {
697 p = pack_hex_byte(p, bitrev ? bitrev8(addr[i]) : addr[i]);
698 if (fmt[0] == 'M' && i != 5)
703 return string(buf, end, mac_addr, spec);
706 static char *ip4_string(char *p, const u8 *addr, bool leading_zeros)
710 for (i = 0; i < 4; i++) {
711 char temp[3]; /* hold each IP quad in reverse order */
712 int digits = put_dec_trunc(temp, addr[i]) - temp;
719 /* reverse the digits in the quad */
730 static char *ip6_compressed_string(char *p, const char *addr)
733 unsigned char zerolength[8];
738 bool needcolon = false;
742 memcpy(&in6, addr, sizeof(struct in6_addr));
744 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
746 memset(zerolength, 0, sizeof(zerolength));
753 /* find position of longest 0 run */
754 for (i = 0; i < range; i++) {
755 for (j = i; j < range; j++) {
756 if (in6.s6_addr16[j] != 0)
761 for (i = 0; i < range; i++) {
762 if (zerolength[i] > longest) {
763 longest = zerolength[i];
769 for (i = 0; i < range; i++) {
771 if (needcolon || i == 0)
782 /* hex u16 without leading 0s */
783 word = ntohs(in6.s6_addr16[i]);
788 p = pack_hex_byte(p, hi);
790 *p++ = hex_asc_lo(hi);
791 p = pack_hex_byte(p, lo);
794 p = pack_hex_byte(p, lo);
796 *p++ = hex_asc_lo(lo);
803 p = ip4_string(p, &in6.s6_addr[12], false);
810 static char *ip6_string(char *p, const char *addr, const char *fmt)
814 for (i = 0; i < 8; i++) {
815 p = pack_hex_byte(p, *addr++);
816 p = pack_hex_byte(p, *addr++);
817 if (fmt[0] == 'I' && i != 7)
825 static char *ip6_addr_string(char *buf, char *end, const u8 *addr,
826 struct printf_spec spec, const char *fmt)
828 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
830 if (fmt[0] == 'I' && fmt[2] == 'c')
831 ip6_compressed_string(ip6_addr, addr);
833 ip6_string(ip6_addr, addr, fmt);
835 return string(buf, end, ip6_addr, spec);
838 static char *ip4_addr_string(char *buf, char *end, const u8 *addr,
839 struct printf_spec spec, const char *fmt)
841 char ip4_addr[sizeof("255.255.255.255")];
843 ip4_string(ip4_addr, addr, fmt[0] == 'i');
845 return string(buf, end, ip4_addr, spec);
848 static char *uuid_string(char *buf, char *end, const u8 *addr,
849 struct printf_spec spec, const char *fmt)
851 char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
854 static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
855 static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
856 const u8 *index = be;
861 uc = true; /* fall-through */
870 for (i = 0; i < 16; i++) {
871 p = pack_hex_byte(p, addr[index[i]]);
891 return string(buf, end, uuid, spec);
895 * Show a '%p' thing. A kernel extension is that the '%p' is followed
896 * by an extra set of alphanumeric characters that are extended format
899 * Right now we handle:
901 * - 'F' For symbolic function descriptor pointers with offset
902 * - 'f' For simple symbolic function names without offset
903 * - 'S' For symbolic direct pointers with offset
904 * - 's' For symbolic direct pointers without offset
905 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
906 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
907 * - 'M' For a 6-byte MAC address, it prints the address in the
908 * usual colon-separated hex notation
909 * - 'm' For a 6-byte MAC address, it prints the hex address without colons
910 * - 'MF' For a 6-byte MAC FDDI address, it prints the address
911 * with a dash-separated hex notation with bit reversed bytes
912 * - 'mF' For a 6-byte MAC FDDI address, it prints the address
913 * in hex notation without separators with bit reversed bytes
914 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
915 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
916 * IPv6 uses colon separated network-order 16 bit hex with leading 0's
917 * - 'i' [46] for 'raw' IPv4/IPv6 addresses
918 * IPv6 omits the colons (01020304...0f)
919 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
920 * - 'I6c' for IPv6 addresses printed as specified by
921 * http://www.ietf.org/id/draft-kawamura-ipv6-text-representation-03.txt
922 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
923 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
924 * Options for %pU are:
925 * b big endian lower case hex (default)
926 * B big endian UPPER case hex
927 * l little endian lower case hex
928 * L little endian UPPER case hex
929 * big endian output byte order is:
930 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
931 * little endian output byte order is:
932 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
934 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
935 * function pointers are really function descriptors, which contain a
936 * pointer to the real address.
938 static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
939 struct printf_spec spec)
942 return string(buf, end, "(null)", spec);
947 ptr = dereference_function_descriptor(ptr);
951 return symbol_string(buf, end, ptr, spec, *fmt);
954 return resource_string(buf, end, ptr, spec, fmt);
955 case 'M': /* Colon separated: 00:01:02:03:04:05 */
956 case 'm': /* Contiguous: 000102030405 */
957 /* [mM]F (FDDI, bit reversed) */
958 return mac_address_string(buf, end, ptr, spec, fmt);
959 case 'I': /* Formatted IP supported
961 * 6: 0001:0203:...:0708
962 * 6c: 1::708 or 1::1.2.3.4
964 case 'i': /* Contiguous:
970 return ip6_addr_string(buf, end, ptr, spec, fmt);
972 return ip4_addr_string(buf, end, ptr, spec, fmt);
976 return uuid_string(buf, end, ptr, spec, fmt);
979 if (spec.field_width == -1) {
980 spec.field_width = 2*sizeof(void *);
981 spec.flags |= ZEROPAD;
985 return number(buf, end, (unsigned long) ptr, spec);
989 * Helper function to decode printf style format.
990 * Each call decode a token from the format and return the
991 * number of characters read (or likely the delta where it wants
992 * to go on the next call).
993 * The decoded token is returned through the parameters
995 * 'h', 'l', or 'L' for integer fields
996 * 'z' support added 23/7/1999 S.H.
997 * 'z' changed to 'Z' --davidm 1/25/99
998 * 't' added for ptrdiff_t
1000 * @fmt: the format string
1001 * @type of the token returned
1002 * @flags: various flags such as +, -, # tokens..
1003 * @field_width: overwritten width
1004 * @base: base of the number (octal, hex, ...)
1005 * @precision: precision of a number
1006 * @qualifier: qualifier of a number (long, size_t, ...)
1008 static int format_decode(const char *fmt, struct printf_spec *spec)
1010 const char *start = fmt;
1012 /* we finished early by reading the field width */
1013 if (spec->type == FORMAT_TYPE_WIDTH) {
1014 if (spec->field_width < 0) {
1015 spec->field_width = -spec->field_width;
1016 spec->flags |= LEFT;
1018 spec->type = FORMAT_TYPE_NONE;
1022 /* we finished early by reading the precision */
1023 if (spec->type == FORMAT_TYPE_PRECISION) {
1024 if (spec->precision < 0)
1025 spec->precision = 0;
1027 spec->type = FORMAT_TYPE_NONE;
1032 spec->type = FORMAT_TYPE_NONE;
1034 for (; *fmt ; ++fmt) {
1039 /* Return the current non-format string */
1040 if (fmt != start || !*fmt)
1046 while (1) { /* this also skips first '%' */
1052 case '-': spec->flags |= LEFT; break;
1053 case '+': spec->flags |= PLUS; break;
1054 case ' ': spec->flags |= SPACE; break;
1055 case '#': spec->flags |= SPECIAL; break;
1056 case '0': spec->flags |= ZEROPAD; break;
1057 default: found = false;
1064 /* get field width */
1065 spec->field_width = -1;
1068 spec->field_width = skip_atoi(&fmt);
1069 else if (*fmt == '*') {
1070 /* it's the next argument */
1071 spec->type = FORMAT_TYPE_WIDTH;
1072 return ++fmt - start;
1076 /* get the precision */
1077 spec->precision = -1;
1080 if (isdigit(*fmt)) {
1081 spec->precision = skip_atoi(&fmt);
1082 if (spec->precision < 0)
1083 spec->precision = 0;
1084 } else if (*fmt == '*') {
1085 /* it's the next argument */
1086 spec->type = FORMAT_TYPE_PRECISION;
1087 return ++fmt - start;
1092 /* get the conversion qualifier */
1093 spec->qualifier = -1;
1094 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1095 TOLOWER(*fmt) == 'z' || *fmt == 't') {
1096 spec->qualifier = *fmt++;
1097 if (unlikely(spec->qualifier == *fmt)) {
1098 if (spec->qualifier == 'l') {
1099 spec->qualifier = 'L';
1101 } else if (spec->qualifier == 'h') {
1102 spec->qualifier = 'H';
1112 spec->type = FORMAT_TYPE_CHAR;
1113 return ++fmt - start;
1116 spec->type = FORMAT_TYPE_STR;
1117 return ++fmt - start;
1120 spec->type = FORMAT_TYPE_PTR;
1125 spec->type = FORMAT_TYPE_NRCHARS;
1126 return ++fmt - start;
1129 spec->type = FORMAT_TYPE_PERCENT_CHAR;
1130 return ++fmt - start;
1132 /* integer number formats - set up the flags and "break" */
1138 spec->flags |= SMALL;
1146 spec->flags |= SIGN;
1151 spec->type = FORMAT_TYPE_INVALID;
1155 if (spec->qualifier == 'L')
1156 spec->type = FORMAT_TYPE_LONG_LONG;
1157 else if (spec->qualifier == 'l') {
1158 if (spec->flags & SIGN)
1159 spec->type = FORMAT_TYPE_LONG;
1161 spec->type = FORMAT_TYPE_ULONG;
1162 } else if (TOLOWER(spec->qualifier) == 'z') {
1163 spec->type = FORMAT_TYPE_SIZE_T;
1164 } else if (spec->qualifier == 't') {
1165 spec->type = FORMAT_TYPE_PTRDIFF;
1166 } else if (spec->qualifier == 'H') {
1167 if (spec->flags & SIGN)
1168 spec->type = FORMAT_TYPE_BYTE;
1170 spec->type = FORMAT_TYPE_UBYTE;
1171 } else if (spec->qualifier == 'h') {
1172 if (spec->flags & SIGN)
1173 spec->type = FORMAT_TYPE_SHORT;
1175 spec->type = FORMAT_TYPE_USHORT;
1177 if (spec->flags & SIGN)
1178 spec->type = FORMAT_TYPE_INT;
1180 spec->type = FORMAT_TYPE_UINT;
1183 return ++fmt - start;
1187 * vsnprintf - Format a string and place it in a buffer
1188 * @buf: The buffer to place the result into
1189 * @size: The size of the buffer, including the trailing null space
1190 * @fmt: The format string to use
1191 * @args: Arguments for the format string
1193 * This function follows C99 vsnprintf, but has some extensions:
1194 * %pS output the name of a text symbol with offset
1195 * %ps output the name of a text symbol without offset
1196 * %pF output the name of a function pointer with its offset
1197 * %pf output the name of a function pointer without its offset
1198 * %pR output the address range in a struct resource with decoded flags
1199 * %pr output the address range in a struct resource with raw flags
1200 * %pM output a 6-byte MAC address with colons
1201 * %pm output a 6-byte MAC address without colons
1202 * %pI4 print an IPv4 address without leading zeros
1203 * %pi4 print an IPv4 address with leading zeros
1204 * %pI6 print an IPv6 address with colons
1205 * %pi6 print an IPv6 address without colons
1206 * %pI6c print an IPv6 address as specified by
1207 * http://www.ietf.org/id/draft-kawamura-ipv6-text-representation-03.txt
1208 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
1212 * The return value is the number of characters which would
1213 * be generated for the given input, excluding the trailing
1214 * '\0', as per ISO C99. If you want to have the exact
1215 * number of characters written into @buf as return value
1216 * (not including the trailing '\0'), use vscnprintf(). If the
1217 * return is greater than or equal to @size, the resulting
1218 * string is truncated.
1220 * Call this function if you are already dealing with a va_list.
1221 * You probably want snprintf() instead.
1223 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1225 unsigned long long num;
1227 struct printf_spec spec = {0};
1229 /* Reject out-of-range values early. Large positive sizes are
1230 used for unknown buffer sizes. */
1231 if (WARN_ON_ONCE((int) size < 0))
1237 /* Make sure end is always >= buf */
1244 const char *old_fmt = fmt;
1245 int read = format_decode(fmt, &spec);
1249 switch (spec.type) {
1250 case FORMAT_TYPE_NONE: {
1253 if (copy > end - str)
1255 memcpy(str, old_fmt, copy);
1261 case FORMAT_TYPE_WIDTH:
1262 spec.field_width = va_arg(args, int);
1265 case FORMAT_TYPE_PRECISION:
1266 spec.precision = va_arg(args, int);
1269 case FORMAT_TYPE_CHAR: {
1272 if (!(spec.flags & LEFT)) {
1273 while (--spec.field_width > 0) {
1280 c = (unsigned char) va_arg(args, int);
1284 while (--spec.field_width > 0) {
1292 case FORMAT_TYPE_STR:
1293 str = string(str, end, va_arg(args, char *), spec);
1296 case FORMAT_TYPE_PTR:
1297 str = pointer(fmt+1, str, end, va_arg(args, void *),
1299 while (isalnum(*fmt))
1303 case FORMAT_TYPE_PERCENT_CHAR:
1309 case FORMAT_TYPE_INVALID:
1315 case FORMAT_TYPE_NRCHARS: {
1316 int qualifier = spec.qualifier;
1318 if (qualifier == 'l') {
1319 long *ip = va_arg(args, long *);
1321 } else if (TOLOWER(qualifier) == 'z') {
1322 size_t *ip = va_arg(args, size_t *);
1325 int *ip = va_arg(args, int *);
1332 switch (spec.type) {
1333 case FORMAT_TYPE_LONG_LONG:
1334 num = va_arg(args, long long);
1336 case FORMAT_TYPE_ULONG:
1337 num = va_arg(args, unsigned long);
1339 case FORMAT_TYPE_LONG:
1340 num = va_arg(args, long);
1342 case FORMAT_TYPE_SIZE_T:
1343 num = va_arg(args, size_t);
1345 case FORMAT_TYPE_PTRDIFF:
1346 num = va_arg(args, ptrdiff_t);
1348 case FORMAT_TYPE_UBYTE:
1349 num = (unsigned char) va_arg(args, int);
1351 case FORMAT_TYPE_BYTE:
1352 num = (signed char) va_arg(args, int);
1354 case FORMAT_TYPE_USHORT:
1355 num = (unsigned short) va_arg(args, int);
1357 case FORMAT_TYPE_SHORT:
1358 num = (short) va_arg(args, int);
1360 case FORMAT_TYPE_INT:
1361 num = (int) va_arg(args, int);
1364 num = va_arg(args, unsigned int);
1367 str = number(str, end, num, spec);
1378 /* the trailing null byte doesn't count towards the total */
1382 EXPORT_SYMBOL(vsnprintf);
1385 * vscnprintf - Format a string and place it in a buffer
1386 * @buf: The buffer to place the result into
1387 * @size: The size of the buffer, including the trailing null space
1388 * @fmt: The format string to use
1389 * @args: Arguments for the format string
1391 * The return value is the number of characters which have been written into
1392 * the @buf not including the trailing '\0'. If @size is <= 0 the function
1395 * Call this function if you are already dealing with a va_list.
1396 * You probably want scnprintf() instead.
1398 * See the vsnprintf() documentation for format string extensions over C99.
1400 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1404 i = vsnprintf(buf, size, fmt, args);
1406 return (i >= size) ? (size - 1) : i;
1408 EXPORT_SYMBOL(vscnprintf);
1411 * snprintf - Format a string and place it in a buffer
1412 * @buf: The buffer to place the result into
1413 * @size: The size of the buffer, including the trailing null space
1414 * @fmt: The format string to use
1415 * @...: Arguments for the format string
1417 * The return value is the number of characters which would be
1418 * generated for the given input, excluding the trailing null,
1419 * as per ISO C99. If the return is greater than or equal to
1420 * @size, the resulting string is truncated.
1422 * See the vsnprintf() documentation for format string extensions over C99.
1424 int snprintf(char *buf, size_t size, const char *fmt, ...)
1429 va_start(args, fmt);
1430 i = vsnprintf(buf, size, fmt, args);
1435 EXPORT_SYMBOL(snprintf);
1438 * scnprintf - Format a string and place it in a buffer
1439 * @buf: The buffer to place the result into
1440 * @size: The size of the buffer, including the trailing null space
1441 * @fmt: The format string to use
1442 * @...: Arguments for the format string
1444 * The return value is the number of characters written into @buf not including
1445 * the trailing '\0'. If @size is <= 0 the function returns 0.
1448 int scnprintf(char *buf, size_t size, const char *fmt, ...)
1453 va_start(args, fmt);
1454 i = vsnprintf(buf, size, fmt, args);
1457 return (i >= size) ? (size - 1) : i;
1459 EXPORT_SYMBOL(scnprintf);
1462 * vsprintf - Format a string and place it in a buffer
1463 * @buf: The buffer to place the result into
1464 * @fmt: The format string to use
1465 * @args: Arguments for the format string
1467 * The function returns the number of characters written
1468 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
1471 * Call this function if you are already dealing with a va_list.
1472 * You probably want sprintf() instead.
1474 * See the vsnprintf() documentation for format string extensions over C99.
1476 int vsprintf(char *buf, const char *fmt, va_list args)
1478 return vsnprintf(buf, INT_MAX, fmt, args);
1480 EXPORT_SYMBOL(vsprintf);
1483 * sprintf - Format a string and place it in a buffer
1484 * @buf: The buffer to place the result into
1485 * @fmt: The format string to use
1486 * @...: Arguments for the format string
1488 * The function returns the number of characters written
1489 * into @buf. Use snprintf() or scnprintf() in order to avoid
1492 * See the vsnprintf() documentation for format string extensions over C99.
1494 int sprintf(char *buf, const char *fmt, ...)
1499 va_start(args, fmt);
1500 i = vsnprintf(buf, INT_MAX, fmt, args);
1505 EXPORT_SYMBOL(sprintf);
1507 #ifdef CONFIG_BINARY_PRINTF
1510 * vbin_printf() - VA arguments to binary data
1511 * bstr_printf() - Binary data to text string
1515 * vbin_printf - Parse a format string and place args' binary value in a buffer
1516 * @bin_buf: The buffer to place args' binary value
1517 * @size: The size of the buffer(by words(32bits), not characters)
1518 * @fmt: The format string to use
1519 * @args: Arguments for the format string
1521 * The format follows C99 vsnprintf, except %n is ignored, and its argument
1524 * The return value is the number of words(32bits) which would be generated for
1528 * If the return value is greater than @size, the resulting bin_buf is NOT
1529 * valid for bstr_printf().
1531 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
1533 struct printf_spec spec = {0};
1536 str = (char *)bin_buf;
1537 end = (char *)(bin_buf + size);
1539 #define save_arg(type) \
1541 if (sizeof(type) == 8) { \
1542 unsigned long long value; \
1543 str = PTR_ALIGN(str, sizeof(u32)); \
1544 value = va_arg(args, unsigned long long); \
1545 if (str + sizeof(type) <= end) { \
1546 *(u32 *)str = *(u32 *)&value; \
1547 *(u32 *)(str + 4) = *((u32 *)&value + 1); \
1550 unsigned long value; \
1551 str = PTR_ALIGN(str, sizeof(type)); \
1552 value = va_arg(args, int); \
1553 if (str + sizeof(type) <= end) \
1554 *(typeof(type) *)str = (type)value; \
1556 str += sizeof(type); \
1560 int read = format_decode(fmt, &spec);
1564 switch (spec.type) {
1565 case FORMAT_TYPE_NONE:
1566 case FORMAT_TYPE_INVALID:
1567 case FORMAT_TYPE_PERCENT_CHAR:
1570 case FORMAT_TYPE_WIDTH:
1571 case FORMAT_TYPE_PRECISION:
1575 case FORMAT_TYPE_CHAR:
1579 case FORMAT_TYPE_STR: {
1580 const char *save_str = va_arg(args, char *);
1583 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
1584 || (unsigned long)save_str < PAGE_SIZE)
1585 save_str = "(null)";
1586 len = strlen(save_str) + 1;
1587 if (str + len < end)
1588 memcpy(str, save_str, len);
1593 case FORMAT_TYPE_PTR:
1595 /* skip all alphanumeric pointer suffixes */
1596 while (isalnum(*fmt))
1600 case FORMAT_TYPE_NRCHARS: {
1601 /* skip %n 's argument */
1602 int qualifier = spec.qualifier;
1604 if (qualifier == 'l')
1605 skip_arg = va_arg(args, long *);
1606 else if (TOLOWER(qualifier) == 'z')
1607 skip_arg = va_arg(args, size_t *);
1609 skip_arg = va_arg(args, int *);
1614 switch (spec.type) {
1616 case FORMAT_TYPE_LONG_LONG:
1617 save_arg(long long);
1619 case FORMAT_TYPE_ULONG:
1620 case FORMAT_TYPE_LONG:
1621 save_arg(unsigned long);
1623 case FORMAT_TYPE_SIZE_T:
1626 case FORMAT_TYPE_PTRDIFF:
1627 save_arg(ptrdiff_t);
1629 case FORMAT_TYPE_UBYTE:
1630 case FORMAT_TYPE_BYTE:
1633 case FORMAT_TYPE_USHORT:
1634 case FORMAT_TYPE_SHORT:
1643 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
1646 EXPORT_SYMBOL_GPL(vbin_printf);
1649 * bstr_printf - Format a string from binary arguments and place it in a buffer
1650 * @buf: The buffer to place the result into
1651 * @size: The size of the buffer, including the trailing null space
1652 * @fmt: The format string to use
1653 * @bin_buf: Binary arguments for the format string
1655 * This function like C99 vsnprintf, but the difference is that vsnprintf gets
1656 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is
1657 * a binary buffer that generated by vbin_printf.
1659 * The format follows C99 vsnprintf, but has some extensions:
1660 * see vsnprintf comment for details.
1662 * The return value is the number of characters which would
1663 * be generated for the given input, excluding the trailing
1664 * '\0', as per ISO C99. If you want to have the exact
1665 * number of characters written into @buf as return value
1666 * (not including the trailing '\0'), use vscnprintf(). If the
1667 * return is greater than or equal to @size, the resulting
1668 * string is truncated.
1670 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
1672 struct printf_spec spec = {0};
1674 const char *args = (const char *)bin_buf;
1676 if (WARN_ON_ONCE((int) size < 0))
1682 #define get_arg(type) \
1684 typeof(type) value; \
1685 if (sizeof(type) == 8) { \
1686 args = PTR_ALIGN(args, sizeof(u32)); \
1687 *(u32 *)&value = *(u32 *)args; \
1688 *((u32 *)&value + 1) = *(u32 *)(args + 4); \
1690 args = PTR_ALIGN(args, sizeof(type)); \
1691 value = *(typeof(type) *)args; \
1693 args += sizeof(type); \
1697 /* Make sure end is always >= buf */
1704 const char *old_fmt = fmt;
1705 int read = format_decode(fmt, &spec);
1709 switch (spec.type) {
1710 case FORMAT_TYPE_NONE: {
1713 if (copy > end - str)
1715 memcpy(str, old_fmt, copy);
1721 case FORMAT_TYPE_WIDTH:
1722 spec.field_width = get_arg(int);
1725 case FORMAT_TYPE_PRECISION:
1726 spec.precision = get_arg(int);
1729 case FORMAT_TYPE_CHAR: {
1732 if (!(spec.flags & LEFT)) {
1733 while (--spec.field_width > 0) {
1739 c = (unsigned char) get_arg(char);
1743 while (--spec.field_width > 0) {
1751 case FORMAT_TYPE_STR: {
1752 const char *str_arg = args;
1753 args += strlen(str_arg) + 1;
1754 str = string(str, end, (char *)str_arg, spec);
1758 case FORMAT_TYPE_PTR:
1759 str = pointer(fmt+1, str, end, get_arg(void *), spec);
1760 while (isalnum(*fmt))
1764 case FORMAT_TYPE_PERCENT_CHAR:
1765 case FORMAT_TYPE_INVALID:
1771 case FORMAT_TYPE_NRCHARS:
1776 unsigned long long num;
1778 switch (spec.type) {
1780 case FORMAT_TYPE_LONG_LONG:
1781 num = get_arg(long long);
1783 case FORMAT_TYPE_ULONG:
1784 case FORMAT_TYPE_LONG:
1785 num = get_arg(unsigned long);
1787 case FORMAT_TYPE_SIZE_T:
1788 num = get_arg(size_t);
1790 case FORMAT_TYPE_PTRDIFF:
1791 num = get_arg(ptrdiff_t);
1793 case FORMAT_TYPE_UBYTE:
1794 num = get_arg(unsigned char);
1796 case FORMAT_TYPE_BYTE:
1797 num = get_arg(signed char);
1799 case FORMAT_TYPE_USHORT:
1800 num = get_arg(unsigned short);
1802 case FORMAT_TYPE_SHORT:
1803 num = get_arg(short);
1805 case FORMAT_TYPE_UINT:
1806 num = get_arg(unsigned int);
1812 str = number(str, end, num, spec);
1814 } /* switch(spec.type) */
1826 /* the trailing null byte doesn't count towards the total */
1829 EXPORT_SYMBOL_GPL(bstr_printf);
1832 * bprintf - Parse a format string and place args' binary value in a buffer
1833 * @bin_buf: The buffer to place args' binary value
1834 * @size: The size of the buffer(by words(32bits), not characters)
1835 * @fmt: The format string to use
1836 * @...: Arguments for the format string
1838 * The function returns the number of words(u32) written
1841 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
1846 va_start(args, fmt);
1847 ret = vbin_printf(bin_buf, size, fmt, args);
1852 EXPORT_SYMBOL_GPL(bprintf);
1854 #endif /* CONFIG_BINARY_PRINTF */
1857 * vsscanf - Unformat a buffer into a list of arguments
1858 * @buf: input buffer
1859 * @fmt: format of buffer
1862 int vsscanf(const char *buf, const char *fmt, va_list args)
1864 const char *str = buf;
1868 int qualifier, base, field_width;
1871 while (*fmt && *str) {
1872 /* skip any white space in format */
1873 /* white space in format matchs any amount of
1874 * white space, including none, in the input.
1876 if (isspace(*fmt)) {
1877 fmt = skip_spaces(++fmt);
1878 str = skip_spaces(str);
1881 /* anything that is not a conversion must match exactly */
1882 if (*fmt != '%' && *fmt) {
1883 if (*fmt++ != *str++)
1892 /* skip this conversion.
1893 * advance both strings to next white space
1896 while (!isspace(*fmt) && *fmt != '%' && *fmt)
1898 while (!isspace(*str) && *str)
1903 /* get field width */
1906 field_width = skip_atoi(&fmt);
1908 /* get conversion qualifier */
1910 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1911 TOLOWER(*fmt) == 'z') {
1913 if (unlikely(qualifier == *fmt)) {
1914 if (qualifier == 'h') {
1917 } else if (qualifier == 'l') {
1933 char *s = (char *)va_arg(args, char*);
1934 if (field_width == -1)
1938 } while (--field_width > 0 && *str);
1944 char *s = (char *)va_arg(args, char *);
1945 if (field_width == -1)
1946 field_width = INT_MAX;
1947 /* first, skip leading white space in buffer */
1948 str = skip_spaces(str);
1950 /* now copy until next white space */
1951 while (*str && !isspace(*str) && field_width--)
1958 /* return number of characters read so far */
1960 int *i = (int *)va_arg(args, int*);
1978 /* looking for '%' in str */
1983 /* invalid format; stop here */
1987 /* have some sort of integer conversion.
1988 * first, skip white space in buffer.
1990 str = skip_spaces(str);
1993 if (is_sign && digit == '-')
1997 || (base == 16 && !isxdigit(digit))
1998 || (base == 10 && !isdigit(digit))
1999 || (base == 8 && (!isdigit(digit) || digit > '7'))
2000 || (base == 0 && !isdigit(digit)))
2003 switch (qualifier) {
2004 case 'H': /* that's 'hh' in format */
2006 signed char *s = (signed char *)va_arg(args, signed char *);
2007 *s = (signed char)simple_strtol(str, &next, base);
2009 unsigned char *s = (unsigned char *)va_arg(args, unsigned char *);
2010 *s = (unsigned char)simple_strtoul(str, &next, base);
2015 short *s = (short *)va_arg(args, short *);
2016 *s = (short)simple_strtol(str, &next, base);
2018 unsigned short *s = (unsigned short *)va_arg(args, unsigned short *);
2019 *s = (unsigned short)simple_strtoul(str, &next, base);
2024 long *l = (long *)va_arg(args, long *);
2025 *l = simple_strtol(str, &next, base);
2027 unsigned long *l = (unsigned long *)va_arg(args, unsigned long *);
2028 *l = simple_strtoul(str, &next, base);
2033 long long *l = (long long *)va_arg(args, long long *);
2034 *l = simple_strtoll(str, &next, base);
2036 unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *);
2037 *l = simple_strtoull(str, &next, base);
2043 size_t *s = (size_t *)va_arg(args, size_t *);
2044 *s = (size_t)simple_strtoul(str, &next, base);
2049 int *i = (int *)va_arg(args, int *);
2050 *i = (int)simple_strtol(str, &next, base);
2052 unsigned int *i = (unsigned int *)va_arg(args, unsigned int*);
2053 *i = (unsigned int)simple_strtoul(str, &next, base);
2065 * Now we've come all the way through so either the input string or the
2066 * format ended. In the former case, there can be a %n at the current
2067 * position in the format that needs to be filled.
2069 if (*fmt == '%' && *(fmt + 1) == 'n') {
2070 int *p = (int *)va_arg(args, int *);
2076 EXPORT_SYMBOL(vsscanf);
2079 * sscanf - Unformat a buffer into a list of arguments
2080 * @buf: input buffer
2081 * @fmt: formatting of buffer
2082 * @...: resulting arguments
2084 int sscanf(const char *buf, const char *fmt, ...)
2089 va_start(args, fmt);
2090 i = vsscanf(buf, fmt, args);
2095 EXPORT_SYMBOL(sscanf);