Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
vsprintf.c
Go to the documentation of this file.
1 /*
2  * linux/lib/vsprintf.c
3  *
4  * Copyright (C) 1991, 1992 Linus Torvalds
5  */
6 
7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8 /*
9  * Wirzenius wrote this portably, Torvalds fucked it up :-)
10  */
11 
12 /*
13  * Fri Jul 13 2001 Crutcher Dunnavant <[email protected]>
14  * - changed to provide snprintf and vsnprintf functions
15  * So Feb 1 16:51:32 CET 2004 Juergen Quade <[email protected]>
16  * - scnprintf and vscnprintf
17  */
18 
19 #include <stdarg.h>
20 #include <linux/module.h> /* for KSYM_SYMBOL_LEN */
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>
29 
30 #include <asm/page.h> /* for PAGE_SIZE */
31 #include <asm/div64.h>
32 #include <asm/sections.h> /* for dereference_function_descriptor() */
33 
34 #include "kstrtox.h"
35 
42 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
43 {
44  unsigned long long result;
45  unsigned int rv;
46 
47  cp = _parse_integer_fixup_radix(cp, &base);
48  rv = _parse_integer(cp, base, &result);
49  /* FIXME */
50  cp += (rv & ~KSTRTOX_OVERFLOW);
51 
52  if (endp)
53  *endp = (char *)cp;
54 
55  return result;
56 }
57 EXPORT_SYMBOL(simple_strtoull);
58 
65 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
66 {
67  return simple_strtoull(cp, endp, base);
68 }
69 EXPORT_SYMBOL(simple_strtoul);
70 
77 long simple_strtol(const char *cp, char **endp, unsigned int base)
78 {
79  if (*cp == '-')
80  return -simple_strtoul(cp + 1, endp, base);
81 
82  return simple_strtoul(cp, endp, base);
83 }
84 EXPORT_SYMBOL(simple_strtol);
85 
92 long long simple_strtoll(const char *cp, char **endp, unsigned int base)
93 {
94  if (*cp == '-')
95  return -simple_strtoull(cp + 1, endp, base);
96 
97  return simple_strtoull(cp, endp, base);
98 }
99 EXPORT_SYMBOL(simple_strtoll);
100 
101 static noinline_for_stack
102 int skip_atoi(const char **s)
103 {
104  int i = 0;
105 
106  while (isdigit(**s))
107  i = i*10 + *((*s)++) - '0';
108 
109  return i;
110 }
111 
112 /* Decimal conversion is by far the most typical, and is used
113  * for /proc and /sys data. This directly impacts e.g. top performance
114  * with many processes running. We optimize it for speed
115  * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
116  * (with permission from the author, Douglas W. Jones).
117  */
118 
119 #if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
120 /* Formats correctly any integer in [0, 999999999] */
121 static noinline_for_stack
122 char *put_dec_full9(char *buf, unsigned q)
123 {
124  unsigned r;
125 
126  /*
127  * Possible ways to approx. divide by 10
128  * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
129  * (x * 0xcccd) >> 19 x < 81920 (x < 262149 when 64-bit mul)
130  * (x * 0x6667) >> 18 x < 43699
131  * (x * 0x3334) >> 17 x < 16389
132  * (x * 0x199a) >> 16 x < 16389
133  * (x * 0x0ccd) >> 15 x < 16389
134  * (x * 0x0667) >> 14 x < 2739
135  * (x * 0x0334) >> 13 x < 1029
136  * (x * 0x019a) >> 12 x < 1029
137  * (x * 0x00cd) >> 11 x < 1029 shorter code than * 0x67 (on i386)
138  * (x * 0x0067) >> 10 x < 179
139  * (x * 0x0034) >> 9 x < 69 same
140  * (x * 0x001a) >> 8 x < 69 same
141  * (x * 0x000d) >> 7 x < 69 same, shortest code (on i386)
142  * (x * 0x0007) >> 6 x < 19
143  * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
144  */
145  r = (q * (uint64_t)0x1999999a) >> 32;
146  *buf++ = (q - 10 * r) + '0'; /* 1 */
147  q = (r * (uint64_t)0x1999999a) >> 32;
148  *buf++ = (r - 10 * q) + '0'; /* 2 */
149  r = (q * (uint64_t)0x1999999a) >> 32;
150  *buf++ = (q - 10 * r) + '0'; /* 3 */
151  q = (r * (uint64_t)0x1999999a) >> 32;
152  *buf++ = (r - 10 * q) + '0'; /* 4 */
153  r = (q * (uint64_t)0x1999999a) >> 32;
154  *buf++ = (q - 10 * r) + '0'; /* 5 */
155  /* Now value is under 10000, can avoid 64-bit multiply */
156  q = (r * 0x199a) >> 16;
157  *buf++ = (r - 10 * q) + '0'; /* 6 */
158  r = (q * 0xcd) >> 11;
159  *buf++ = (q - 10 * r) + '0'; /* 7 */
160  q = (r * 0xcd) >> 11;
161  *buf++ = (r - 10 * q) + '0'; /* 8 */
162  *buf++ = q + '0'; /* 9 */
163  return buf;
164 }
165 #endif
166 
167 /* Similar to above but do not pad with zeros.
168  * Code can be easily arranged to print 9 digits too, but our callers
169  * always call put_dec_full9() instead when the number has 9 decimal digits.
170  */
171 static noinline_for_stack
172 char *put_dec_trunc8(char *buf, unsigned r)
173 {
174  unsigned q;
175 
176  /* Copy of previous function's body with added early returns */
177  while (r >= 10000) {
178  q = r + '0';
179  r = (r * (uint64_t)0x1999999a) >> 32;
180  *buf++ = q - 10*r;
181  }
182 
183  q = (r * 0x199a) >> 16; /* r <= 9999 */
184  *buf++ = (r - 10 * q) + '0';
185  if (q == 0)
186  return buf;
187  r = (q * 0xcd) >> 11; /* q <= 999 */
188  *buf++ = (q - 10 * r) + '0';
189  if (r == 0)
190  return buf;
191  q = (r * 0xcd) >> 11; /* r <= 99 */
192  *buf++ = (r - 10 * q) + '0';
193  if (q == 0)
194  return buf;
195  *buf++ = q + '0'; /* q <= 9 */
196  return buf;
197 }
198 
199 /* There are two algorithms to print larger numbers.
200  * One is generic: divide by 1000000000 and repeatedly print
201  * groups of (up to) 9 digits. It's conceptually simple,
202  * but requires a (unsigned long long) / 1000000000 division.
203  *
204  * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
205  * manipulates them cleverly and generates groups of 4 decimal digits.
206  * It so happens that it does NOT require long long division.
207  *
208  * If long is > 32 bits, division of 64-bit values is relatively easy,
209  * and we will use the first algorithm.
210  * If long long is > 64 bits (strange architecture with VERY large long long),
211  * second algorithm can't be used, and we again use the first one.
212  *
213  * Else (if long is 32 bits and long long is 64 bits) we use second one.
214  */
215 
216 #if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
217 
218 /* First algorithm: generic */
219 
220 static
221 char *put_dec(char *buf, unsigned long long n)
222 {
223  if (n >= 100*1000*1000) {
224  while (n >= 1000*1000*1000)
225  buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
226  if (n >= 100*1000*1000)
227  return put_dec_full9(buf, n);
228  }
229  return put_dec_trunc8(buf, n);
230 }
231 
232 #else
233 
234 /* Second algorithm: valid only for 64-bit long longs */
235 
236 /* See comment in put_dec_full9 for choice of constants */
237 static noinline_for_stack
238 void put_dec_full4(char *buf, unsigned q)
239 {
240  unsigned r;
241  r = (q * 0xccd) >> 15;
242  buf[0] = (q - 10 * r) + '0';
243  q = (r * 0xcd) >> 11;
244  buf[1] = (r - 10 * q) + '0';
245  r = (q * 0xcd) >> 11;
246  buf[2] = (q - 10 * r) + '0';
247  buf[3] = r + '0';
248 }
249 
250 /*
251  * Call put_dec_full4 on x % 10000, return x / 10000.
252  * The approximation x/10000 == (x * 0x346DC5D7) >> 43
253  * holds for all x < 1,128,869,999. The largest value this
254  * helper will ever be asked to convert is 1,125,520,955.
255  * (d1 in the put_dec code, assuming n is all-ones).
256  */
257 static
258 unsigned put_dec_helper4(char *buf, unsigned x)
259 {
260  uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
261 
262  put_dec_full4(buf, x - q * 10000);
263  return q;
264 }
265 
266 /* Based on code by Douglas W. Jones found at
267  * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
268  * (with permission from the author).
269  * Performs no 64-bit division and hence should be fast on 32-bit machines.
270  */
271 static
272 char *put_dec(char *buf, unsigned long long n)
273 {
274  uint32_t d3, d2, d1, q, h;
275 
276  if (n < 100*1000*1000)
277  return put_dec_trunc8(buf, n);
278 
279  d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
280  h = (n >> 32);
281  d2 = (h ) & 0xffff;
282  d3 = (h >> 16); /* implicit "& 0xffff" */
283 
284  q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
285  q = put_dec_helper4(buf, q);
286 
287  q += 7671 * d3 + 9496 * d2 + 6 * d1;
288  q = put_dec_helper4(buf+4, q);
289 
290  q += 4749 * d3 + 42 * d2;
291  q = put_dec_helper4(buf+8, q);
292 
293  q += 281 * d3;
294  buf += 12;
295  if (q)
296  buf = put_dec_trunc8(buf, q);
297  else while (buf[-1] == '0')
298  --buf;
299 
300  return buf;
301 }
302 
303 #endif
304 
305 /*
306  * Convert passed number to decimal string.
307  * Returns the length of string. On buffer overflow, returns 0.
308  *
309  * If speed is not important, use snprintf(). It's easy to read the code.
310  */
311 int num_to_str(char *buf, int size, unsigned long long num)
312 {
313  char tmp[sizeof(num) * 3];
314  int idx, len;
315 
316  /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
317  if (num <= 9) {
318  tmp[0] = '0' + num;
319  len = 1;
320  } else {
321  len = put_dec(tmp, num) - tmp;
322  }
323 
324  if (len > size)
325  return 0;
326  for (idx = 0; idx < len; ++idx)
327  buf[idx] = tmp[len - idx - 1];
328  return len;
329 }
330 
331 #define ZEROPAD 1 /* pad with zero */
332 #define SIGN 2 /* unsigned/signed long */
333 #define PLUS 4 /* show plus */
334 #define SPACE 8 /* space if plus */
335 #define LEFT 16 /* left justified */
336 #define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */
337 #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */
338 
339 enum format_type {
340  FORMAT_TYPE_NONE, /* Just a string part */
341  FORMAT_TYPE_WIDTH,
342  FORMAT_TYPE_PRECISION,
343  FORMAT_TYPE_CHAR,
344  FORMAT_TYPE_STR,
345  FORMAT_TYPE_PTR,
346  FORMAT_TYPE_PERCENT_CHAR,
347  FORMAT_TYPE_INVALID,
348  FORMAT_TYPE_LONG_LONG,
349  FORMAT_TYPE_ULONG,
350  FORMAT_TYPE_LONG,
351  FORMAT_TYPE_UBYTE,
352  FORMAT_TYPE_BYTE,
353  FORMAT_TYPE_USHORT,
354  FORMAT_TYPE_SHORT,
355  FORMAT_TYPE_UINT,
356  FORMAT_TYPE_INT,
357  FORMAT_TYPE_NRCHARS,
358  FORMAT_TYPE_SIZE_T,
359  FORMAT_TYPE_PTRDIFF
360 };
361 
362 struct printf_spec {
363  u8 type; /* format_type enum */
364  u8 flags; /* flags to number() */
365  u8 base; /* number base, 8, 10 or 16 only */
366  u8 qualifier; /* number qualifier, one of 'hHlLtzZ' */
367  s16 field_width; /* width of output field */
368  s16 precision; /* # of digits/chars */
369 };
370 
371 static noinline_for_stack
372 char *number(char *buf, char *end, unsigned long long num,
373  struct printf_spec spec)
374 {
375  /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
376  static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
377 
378  char tmp[66];
379  char sign;
380  char locase;
381  int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
382  int i;
383  bool is_zero = num == 0LL;
384 
385  /* locase = 0 or 0x20. ORing digits or letters with 'locase'
386  * produces same digits or (maybe lowercased) letters */
387  locase = (spec.flags & SMALL);
388  if (spec.flags & LEFT)
389  spec.flags &= ~ZEROPAD;
390  sign = 0;
391  if (spec.flags & SIGN) {
392  if ((signed long long)num < 0) {
393  sign = '-';
394  num = -(signed long long)num;
395  spec.field_width--;
396  } else if (spec.flags & PLUS) {
397  sign = '+';
398  spec.field_width--;
399  } else if (spec.flags & SPACE) {
400  sign = ' ';
401  spec.field_width--;
402  }
403  }
404  if (need_pfx) {
405  if (spec.base == 16)
406  spec.field_width -= 2;
407  else if (!is_zero)
408  spec.field_width--;
409  }
410 
411  /* generate full string in tmp[], in reverse order */
412  i = 0;
413  if (num < spec.base)
414  tmp[i++] = digits[num] | locase;
415  /* Generic code, for any base:
416  else do {
417  tmp[i++] = (digits[do_div(num,base)] | locase);
418  } while (num != 0);
419  */
420  else if (spec.base != 10) { /* 8 or 16 */
421  int mask = spec.base - 1;
422  int shift = 3;
423 
424  if (spec.base == 16)
425  shift = 4;
426  do {
427  tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
428  num >>= shift;
429  } while (num);
430  } else { /* base 10 */
431  i = put_dec(tmp, num) - tmp;
432  }
433 
434  /* printing 100 using %2d gives "100", not "00" */
435  if (i > spec.precision)
436  spec.precision = i;
437  /* leading space padding */
438  spec.field_width -= spec.precision;
439  if (!(spec.flags & (ZEROPAD+LEFT))) {
440  while (--spec.field_width >= 0) {
441  if (buf < end)
442  *buf = ' ';
443  ++buf;
444  }
445  }
446  /* sign */
447  if (sign) {
448  if (buf < end)
449  *buf = sign;
450  ++buf;
451  }
452  /* "0x" / "0" prefix */
453  if (need_pfx) {
454  if (spec.base == 16 || !is_zero) {
455  if (buf < end)
456  *buf = '0';
457  ++buf;
458  }
459  if (spec.base == 16) {
460  if (buf < end)
461  *buf = ('X' | locase);
462  ++buf;
463  }
464  }
465  /* zero or space padding */
466  if (!(spec.flags & LEFT)) {
467  char c = (spec.flags & ZEROPAD) ? '0' : ' ';
468  while (--spec.field_width >= 0) {
469  if (buf < end)
470  *buf = c;
471  ++buf;
472  }
473  }
474  /* hmm even more zero padding? */
475  while (i <= --spec.precision) {
476  if (buf < end)
477  *buf = '0';
478  ++buf;
479  }
480  /* actual digits of result */
481  while (--i >= 0) {
482  if (buf < end)
483  *buf = tmp[i];
484  ++buf;
485  }
486  /* trailing space padding */
487  while (--spec.field_width >= 0) {
488  if (buf < end)
489  *buf = ' ';
490  ++buf;
491  }
492 
493  return buf;
494 }
495 
496 static noinline_for_stack
497 char *string(char *buf, char *end, const char *s, struct printf_spec spec)
498 {
499  int len, i;
500 
501  if ((unsigned long)s < PAGE_SIZE)
502  s = "(null)";
503 
504  len = strnlen(s, spec.precision);
505 
506  if (!(spec.flags & LEFT)) {
507  while (len < spec.field_width--) {
508  if (buf < end)
509  *buf = ' ';
510  ++buf;
511  }
512  }
513  for (i = 0; i < len; ++i) {
514  if (buf < end)
515  *buf = *s;
516  ++buf; ++s;
517  }
518  while (len < spec.field_width--) {
519  if (buf < end)
520  *buf = ' ';
521  ++buf;
522  }
523 
524  return buf;
525 }
526 
527 static noinline_for_stack
528 char *symbol_string(char *buf, char *end, void *ptr,
529  struct printf_spec spec, char ext)
530 {
531  unsigned long value = (unsigned long) ptr;
532 #ifdef CONFIG_KALLSYMS
533  char sym[KSYM_SYMBOL_LEN];
534  if (ext == 'B')
535  sprint_backtrace(sym, value);
536  else if (ext != 'f' && ext != 's')
537  sprint_symbol(sym, value);
538  else
539  sprint_symbol_no_offset(sym, value);
540 
541  return string(buf, end, sym, spec);
542 #else
543  spec.field_width = 2 * sizeof(void *);
544  spec.flags |= SPECIAL | SMALL | ZEROPAD;
545  spec.base = 16;
546 
547  return number(buf, end, value, spec);
548 #endif
549 }
550 
551 static noinline_for_stack
552 char *resource_string(char *buf, char *end, struct resource *res,
553  struct printf_spec spec, const char *fmt)
554 {
555 #ifndef IO_RSRC_PRINTK_SIZE
556 #define IO_RSRC_PRINTK_SIZE 6
557 #endif
558 
559 #ifndef MEM_RSRC_PRINTK_SIZE
560 #define MEM_RSRC_PRINTK_SIZE 10
561 #endif
562  static const struct printf_spec io_spec = {
563  .base = 16,
564  .field_width = IO_RSRC_PRINTK_SIZE,
565  .precision = -1,
566  .flags = SPECIAL | SMALL | ZEROPAD,
567  };
568  static const struct printf_spec mem_spec = {
569  .base = 16,
570  .field_width = MEM_RSRC_PRINTK_SIZE,
571  .precision = -1,
572  .flags = SPECIAL | SMALL | ZEROPAD,
573  };
574  static const struct printf_spec bus_spec = {
575  .base = 16,
576  .field_width = 2,
577  .precision = -1,
578  .flags = SMALL | ZEROPAD,
579  };
580  static const struct printf_spec dec_spec = {
581  .base = 10,
582  .precision = -1,
583  .flags = 0,
584  };
585  static const struct printf_spec str_spec = {
586  .field_width = -1,
587  .precision = 10,
588  .flags = LEFT,
589  };
590  static const struct printf_spec flag_spec = {
591  .base = 16,
592  .precision = -1,
593  .flags = SPECIAL | SMALL,
594  };
595 
596  /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
597  * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
598 #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
599 #define FLAG_BUF_SIZE (2 * sizeof(res->flags))
600 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
601 #define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
602  char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
603  2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
604 
605  char *p = sym, *pend = sym + sizeof(sym);
606  int decode = (fmt[0] == 'R') ? 1 : 0;
607  const struct printf_spec *specp;
608 
609  *p++ = '[';
610  if (res->flags & IORESOURCE_IO) {
611  p = string(p, pend, "io ", str_spec);
612  specp = &io_spec;
613  } else if (res->flags & IORESOURCE_MEM) {
614  p = string(p, pend, "mem ", str_spec);
615  specp = &mem_spec;
616  } else if (res->flags & IORESOURCE_IRQ) {
617  p = string(p, pend, "irq ", str_spec);
618  specp = &dec_spec;
619  } else if (res->flags & IORESOURCE_DMA) {
620  p = string(p, pend, "dma ", str_spec);
621  specp = &dec_spec;
622  } else if (res->flags & IORESOURCE_BUS) {
623  p = string(p, pend, "bus ", str_spec);
624  specp = &bus_spec;
625  } else {
626  p = string(p, pend, "??? ", str_spec);
627  specp = &mem_spec;
628  decode = 0;
629  }
630  p = number(p, pend, res->start, *specp);
631  if (res->start != res->end) {
632  *p++ = '-';
633  p = number(p, pend, res->end, *specp);
634  }
635  if (decode) {
636  if (res->flags & IORESOURCE_MEM_64)
637  p = string(p, pend, " 64bit", str_spec);
638  if (res->flags & IORESOURCE_PREFETCH)
639  p = string(p, pend, " pref", str_spec);
640  if (res->flags & IORESOURCE_WINDOW)
641  p = string(p, pend, " window", str_spec);
642  if (res->flags & IORESOURCE_DISABLED)
643  p = string(p, pend, " disabled", str_spec);
644  } else {
645  p = string(p, pend, " flags ", str_spec);
646  p = number(p, pend, res->flags, flag_spec);
647  }
648  *p++ = ']';
649  *p = '\0';
650 
651  return string(buf, end, sym, spec);
652 }
653 
654 static noinline_for_stack
655 char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
656  const char *fmt)
657 {
658  int i, len = 1; /* if we pass '%ph[CDN]', field witdh remains
659  negative value, fallback to the default */
660  char separator;
661 
662  if (spec.field_width == 0)
663  /* nothing to print */
664  return buf;
665 
666  if (ZERO_OR_NULL_PTR(addr))
667  /* NULL pointer */
668  return string(buf, end, NULL, spec);
669 
670  switch (fmt[1]) {
671  case 'C':
672  separator = ':';
673  break;
674  case 'D':
675  separator = '-';
676  break;
677  case 'N':
678  separator = 0;
679  break;
680  default:
681  separator = ' ';
682  break;
683  }
684 
685  if (spec.field_width > 0)
686  len = min_t(int, spec.field_width, 64);
687 
688  for (i = 0; i < len && buf < end - 1; i++) {
689  buf = hex_byte_pack(buf, addr[i]);
690 
691  if (buf < end && separator && i != len - 1)
692  *buf++ = separator;
693  }
694 
695  return buf;
696 }
697 
698 static noinline_for_stack
699 char *mac_address_string(char *buf, char *end, u8 *addr,
700  struct printf_spec spec, const char *fmt)
701 {
702  char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
703  char *p = mac_addr;
704  int i;
705  char separator;
706  bool reversed = false;
707 
708  switch (fmt[1]) {
709  case 'F':
710  separator = '-';
711  break;
712 
713  case 'R':
714  reversed = true;
715  /* fall through */
716 
717  default:
718  separator = ':';
719  break;
720  }
721 
722  for (i = 0; i < 6; i++) {
723  if (reversed)
724  p = hex_byte_pack(p, addr[5 - i]);
725  else
726  p = hex_byte_pack(p, addr[i]);
727 
728  if (fmt[0] == 'M' && i != 5)
729  *p++ = separator;
730  }
731  *p = '\0';
732 
733  return string(buf, end, mac_addr, spec);
734 }
735 
736 static noinline_for_stack
737 char *ip4_string(char *p, const u8 *addr, const char *fmt)
738 {
739  int i;
740  bool leading_zeros = (fmt[0] == 'i');
741  int index;
742  int step;
743 
744  switch (fmt[2]) {
745  case 'h':
746 #ifdef __BIG_ENDIAN
747  index = 0;
748  step = 1;
749 #else
750  index = 3;
751  step = -1;
752 #endif
753  break;
754  case 'l':
755  index = 3;
756  step = -1;
757  break;
758  case 'n':
759  case 'b':
760  default:
761  index = 0;
762  step = 1;
763  break;
764  }
765  for (i = 0; i < 4; i++) {
766  char temp[3]; /* hold each IP quad in reverse order */
767  int digits = put_dec_trunc8(temp, addr[index]) - temp;
768  if (leading_zeros) {
769  if (digits < 3)
770  *p++ = '0';
771  if (digits < 2)
772  *p++ = '0';
773  }
774  /* reverse the digits in the quad */
775  while (digits--)
776  *p++ = temp[digits];
777  if (i < 3)
778  *p++ = '.';
779  index += step;
780  }
781  *p = '\0';
782 
783  return p;
784 }
785 
786 static noinline_for_stack
787 char *ip6_compressed_string(char *p, const char *addr)
788 {
789  int i, j, range;
790  unsigned char zerolength[8];
791  int longest = 1;
792  int colonpos = -1;
793  u16 word;
794  u8 hi, lo;
795  bool needcolon = false;
796  bool useIPv4;
797  struct in6_addr in6;
798 
799  memcpy(&in6, addr, sizeof(struct in6_addr));
800 
801  useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
802 
803  memset(zerolength, 0, sizeof(zerolength));
804 
805  if (useIPv4)
806  range = 6;
807  else
808  range = 8;
809 
810  /* find position of longest 0 run */
811  for (i = 0; i < range; i++) {
812  for (j = i; j < range; j++) {
813  if (in6.s6_addr16[j] != 0)
814  break;
815  zerolength[i]++;
816  }
817  }
818  for (i = 0; i < range; i++) {
819  if (zerolength[i] > longest) {
820  longest = zerolength[i];
821  colonpos = i;
822  }
823  }
824  if (longest == 1) /* don't compress a single 0 */
825  colonpos = -1;
826 
827  /* emit address */
828  for (i = 0; i < range; i++) {
829  if (i == colonpos) {
830  if (needcolon || i == 0)
831  *p++ = ':';
832  *p++ = ':';
833  needcolon = false;
834  i += longest - 1;
835  continue;
836  }
837  if (needcolon) {
838  *p++ = ':';
839  needcolon = false;
840  }
841  /* hex u16 without leading 0s */
842  word = ntohs(in6.s6_addr16[i]);
843  hi = word >> 8;
844  lo = word & 0xff;
845  if (hi) {
846  if (hi > 0x0f)
847  p = hex_byte_pack(p, hi);
848  else
849  *p++ = hex_asc_lo(hi);
850  p = hex_byte_pack(p, lo);
851  }
852  else if (lo > 0x0f)
853  p = hex_byte_pack(p, lo);
854  else
855  *p++ = hex_asc_lo(lo);
856  needcolon = true;
857  }
858 
859  if (useIPv4) {
860  if (needcolon)
861  *p++ = ':';
862  p = ip4_string(p, &in6.s6_addr[12], "I4");
863  }
864  *p = '\0';
865 
866  return p;
867 }
868 
869 static noinline_for_stack
870 char *ip6_string(char *p, const char *addr, const char *fmt)
871 {
872  int i;
873 
874  for (i = 0; i < 8; i++) {
875  p = hex_byte_pack(p, *addr++);
876  p = hex_byte_pack(p, *addr++);
877  if (fmt[0] == 'I' && i != 7)
878  *p++ = ':';
879  }
880  *p = '\0';
881 
882  return p;
883 }
884 
885 static noinline_for_stack
886 char *ip6_addr_string(char *buf, char *end, const u8 *addr,
887  struct printf_spec spec, const char *fmt)
888 {
889  char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
890 
891  if (fmt[0] == 'I' && fmt[2] == 'c')
892  ip6_compressed_string(ip6_addr, addr);
893  else
894  ip6_string(ip6_addr, addr, fmt);
895 
896  return string(buf, end, ip6_addr, spec);
897 }
898 
899 static noinline_for_stack
900 char *ip4_addr_string(char *buf, char *end, const u8 *addr,
901  struct printf_spec spec, const char *fmt)
902 {
903  char ip4_addr[sizeof("255.255.255.255")];
904 
905  ip4_string(ip4_addr, addr, fmt);
906 
907  return string(buf, end, ip4_addr, spec);
908 }
909 
910 static noinline_for_stack
911 char *uuid_string(char *buf, char *end, const u8 *addr,
912  struct printf_spec spec, const char *fmt)
913 {
914  char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
915  char *p = uuid;
916  int i;
917  static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
918  static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
919  const u8 *index = be;
920  bool uc = false;
921 
922  switch (*(++fmt)) {
923  case 'L':
924  uc = true; /* fall-through */
925  case 'l':
926  index = le;
927  break;
928  case 'B':
929  uc = true;
930  break;
931  }
932 
933  for (i = 0; i < 16; i++) {
934  p = hex_byte_pack(p, addr[index[i]]);
935  switch (i) {
936  case 3:
937  case 5:
938  case 7:
939  case 9:
940  *p++ = '-';
941  break;
942  }
943  }
944 
945  *p = 0;
946 
947  if (uc) {
948  p = uuid;
949  do {
950  *p = toupper(*p);
951  } while (*(++p));
952  }
953 
954  return string(buf, end, uuid, spec);
955 }
956 
957 static
958 char *netdev_feature_string(char *buf, char *end, const u8 *addr,
959  struct printf_spec spec)
960 {
961  spec.flags |= SPECIAL | SMALL | ZEROPAD;
962  if (spec.field_width == -1)
963  spec.field_width = 2 + 2 * sizeof(netdev_features_t);
964  spec.base = 16;
965 
966  return number(buf, end, *(const netdev_features_t *)addr, spec);
967 }
968 
969 int kptr_restrict __read_mostly;
970 
971 /*
972  * Show a '%p' thing. A kernel extension is that the '%p' is followed
973  * by an extra set of alphanumeric characters that are extended format
974  * specifiers.
975  *
976  * Right now we handle:
977  *
978  * - 'F' For symbolic function descriptor pointers with offset
979  * - 'f' For simple symbolic function names without offset
980  * - 'S' For symbolic direct pointers with offset
981  * - 's' For symbolic direct pointers without offset
982  * - 'B' For backtraced symbolic direct pointers with offset
983  * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
984  * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
985  * - 'M' For a 6-byte MAC address, it prints the address in the
986  * usual colon-separated hex notation
987  * - 'm' For a 6-byte MAC address, it prints the hex address without colons
988  * - 'MF' For a 6-byte MAC FDDI address, it prints the address
989  * with a dash-separated hex notation
990  * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)
991  * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
992  * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
993  * IPv6 uses colon separated network-order 16 bit hex with leading 0's
994  * - 'i' [46] for 'raw' IPv4/IPv6 addresses
995  * IPv6 omits the colons (01020304...0f)
996  * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
997  * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order
998  * - 'I6c' for IPv6 addresses printed as specified by
999  * http://tools.ietf.org/html/rfc5952
1000  * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
1001  * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
1002  * Options for %pU are:
1003  * b big endian lower case hex (default)
1004  * B big endian UPPER case hex
1005  * l little endian lower case hex
1006  * L little endian UPPER case hex
1007  * big endian output byte order is:
1008  * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
1009  * little endian output byte order is:
1010  * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
1011  * - 'V' For a struct va_format which contains a format string * and va_list *,
1012  * call vsnprintf(->format, *->va_list).
1013  * Implements a "recursive vsnprintf".
1014  * Do not use this feature without some mechanism to verify the
1015  * correctness of the format string and va_list arguments.
1016  * - 'K' For a kernel pointer that should be hidden from unprivileged users
1017  * - 'NF' For a netdev_features_t
1018  * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
1019  * a certain separator (' ' by default):
1020  * C colon
1021  * D dash
1022  * N no separator
1023  * The maximum supported length is 64 bytes of the input. Consider
1024  * to use print_hex_dump() for the larger input.
1025  *
1026  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
1027  * function pointers are really function descriptors, which contain a
1028  * pointer to the real address.
1029  */
1030 static noinline_for_stack
1031 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
1032  struct printf_spec spec)
1033 {
1034  int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
1035 
1036  if (!ptr && *fmt != 'K') {
1037  /*
1038  * Print (null) with the same width as a pointer so it makes
1039  * tabular output look nice.
1040  */
1041  if (spec.field_width == -1)
1042  spec.field_width = default_width;
1043  return string(buf, end, "(null)", spec);
1044  }
1045 
1046  switch (*fmt) {
1047  case 'F':
1048  case 'f':
1049  ptr = dereference_function_descriptor(ptr);
1050  /* Fallthrough */
1051  case 'S':
1052  case 's':
1053  case 'B':
1054  return symbol_string(buf, end, ptr, spec, *fmt);
1055  case 'R':
1056  case 'r':
1057  return resource_string(buf, end, ptr, spec, fmt);
1058  case 'h':
1059  return hex_string(buf, end, ptr, spec, fmt);
1060  case 'M': /* Colon separated: 00:01:02:03:04:05 */
1061  case 'm': /* Contiguous: 000102030405 */
1062  /* [mM]F (FDDI) */
1063  /* [mM]R (Reverse order; Bluetooth) */
1064  return mac_address_string(buf, end, ptr, spec, fmt);
1065  case 'I': /* Formatted IP supported
1066  * 4: 1.2.3.4
1067  * 6: 0001:0203:...:0708
1068  * 6c: 1::708 or 1::1.2.3.4
1069  */
1070  case 'i': /* Contiguous:
1071  * 4: 001.002.003.004
1072  * 6: 000102...0f
1073  */
1074  switch (fmt[1]) {
1075  case '6':
1076  return ip6_addr_string(buf, end, ptr, spec, fmt);
1077  case '4':
1078  return ip4_addr_string(buf, end, ptr, spec, fmt);
1079  }
1080  break;
1081  case 'U':
1082  return uuid_string(buf, end, ptr, spec, fmt);
1083  case 'V':
1084  {
1085  va_list va;
1086 
1087  va_copy(va, *((struct va_format *)ptr)->va);
1088  buf += vsnprintf(buf, end > buf ? end - buf : 0,
1089  ((struct va_format *)ptr)->fmt, va);
1090  va_end(va);
1091  return buf;
1092  }
1093  case 'K':
1094  /*
1095  * %pK cannot be used in IRQ context because its test
1096  * for CAP_SYSLOG would be meaningless.
1097  */
1098  if (kptr_restrict && (in_irq() || in_serving_softirq() ||
1099  in_nmi())) {
1100  if (spec.field_width == -1)
1101  spec.field_width = default_width;
1102  return string(buf, end, "pK-error", spec);
1103  }
1104  if (!((kptr_restrict == 0) ||
1105  (kptr_restrict == 1 &&
1106  has_capability_noaudit(current, CAP_SYSLOG))))
1107  ptr = NULL;
1108  break;
1109  case 'N':
1110  switch (fmt[1]) {
1111  case 'F':
1112  return netdev_feature_string(buf, end, ptr, spec);
1113  }
1114  break;
1115  }
1116  spec.flags |= SMALL;
1117  if (spec.field_width == -1) {
1118  spec.field_width = default_width;
1119  spec.flags |= ZEROPAD;
1120  }
1121  spec.base = 16;
1122 
1123  return number(buf, end, (unsigned long) ptr, spec);
1124 }
1125 
1126 /*
1127  * Helper function to decode printf style format.
1128  * Each call decode a token from the format and return the
1129  * number of characters read (or likely the delta where it wants
1130  * to go on the next call).
1131  * The decoded token is returned through the parameters
1132  *
1133  * 'h', 'l', or 'L' for integer fields
1134  * 'z' support added 23/7/1999 S.H.
1135  * 'z' changed to 'Z' --davidm 1/25/99
1136  * 't' added for ptrdiff_t
1137  *
1138  * @fmt: the format string
1139  * @type of the token returned
1140  * @flags: various flags such as +, -, # tokens..
1141  * @field_width: overwritten width
1142  * @base: base of the number (octal, hex, ...)
1143  * @precision: precision of a number
1144  * @qualifier: qualifier of a number (long, size_t, ...)
1145  */
1146 static noinline_for_stack
1147 int format_decode(const char *fmt, struct printf_spec *spec)
1148 {
1149  const char *start = fmt;
1150 
1151  /* we finished early by reading the field width */
1152  if (spec->type == FORMAT_TYPE_WIDTH) {
1153  if (spec->field_width < 0) {
1154  spec->field_width = -spec->field_width;
1155  spec->flags |= LEFT;
1156  }
1157  spec->type = FORMAT_TYPE_NONE;
1158  goto precision;
1159  }
1160 
1161  /* we finished early by reading the precision */
1162  if (spec->type == FORMAT_TYPE_PRECISION) {
1163  if (spec->precision < 0)
1164  spec->precision = 0;
1165 
1166  spec->type = FORMAT_TYPE_NONE;
1167  goto qualifier;
1168  }
1169 
1170  /* By default */
1171  spec->type = FORMAT_TYPE_NONE;
1172 
1173  for (; *fmt ; ++fmt) {
1174  if (*fmt == '%')
1175  break;
1176  }
1177 
1178  /* Return the current non-format string */
1179  if (fmt != start || !*fmt)
1180  return fmt - start;
1181 
1182  /* Process flags */
1183  spec->flags = 0;
1184 
1185  while (1) { /* this also skips first '%' */
1186  bool found = true;
1187 
1188  ++fmt;
1189 
1190  switch (*fmt) {
1191  case '-': spec->flags |= LEFT; break;
1192  case '+': spec->flags |= PLUS; break;
1193  case ' ': spec->flags |= SPACE; break;
1194  case '#': spec->flags |= SPECIAL; break;
1195  case '0': spec->flags |= ZEROPAD; break;
1196  default: found = false;
1197  }
1198 
1199  if (!found)
1200  break;
1201  }
1202 
1203  /* get field width */
1204  spec->field_width = -1;
1205 
1206  if (isdigit(*fmt))
1207  spec->field_width = skip_atoi(&fmt);
1208  else if (*fmt == '*') {
1209  /* it's the next argument */
1210  spec->type = FORMAT_TYPE_WIDTH;
1211  return ++fmt - start;
1212  }
1213 
1214 precision:
1215  /* get the precision */
1216  spec->precision = -1;
1217  if (*fmt == '.') {
1218  ++fmt;
1219  if (isdigit(*fmt)) {
1220  spec->precision = skip_atoi(&fmt);
1221  if (spec->precision < 0)
1222  spec->precision = 0;
1223  } else if (*fmt == '*') {
1224  /* it's the next argument */
1225  spec->type = FORMAT_TYPE_PRECISION;
1226  return ++fmt - start;
1227  }
1228  }
1229 
1230 qualifier:
1231  /* get the conversion qualifier */
1232  spec->qualifier = -1;
1233  if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
1234  _tolower(*fmt) == 'z' || *fmt == 't') {
1235  spec->qualifier = *fmt++;
1236  if (unlikely(spec->qualifier == *fmt)) {
1237  if (spec->qualifier == 'l') {
1238  spec->qualifier = 'L';
1239  ++fmt;
1240  } else if (spec->qualifier == 'h') {
1241  spec->qualifier = 'H';
1242  ++fmt;
1243  }
1244  }
1245  }
1246 
1247  /* default base */
1248  spec->base = 10;
1249  switch (*fmt) {
1250  case 'c':
1251  spec->type = FORMAT_TYPE_CHAR;
1252  return ++fmt - start;
1253 
1254  case 's':
1255  spec->type = FORMAT_TYPE_STR;
1256  return ++fmt - start;
1257 
1258  case 'p':
1259  spec->type = FORMAT_TYPE_PTR;
1260  return fmt - start;
1261  /* skip alnum */
1262 
1263  case 'n':
1264  spec->type = FORMAT_TYPE_NRCHARS;
1265  return ++fmt - start;
1266 
1267  case '%':
1268  spec->type = FORMAT_TYPE_PERCENT_CHAR;
1269  return ++fmt - start;
1270 
1271  /* integer number formats - set up the flags and "break" */
1272  case 'o':
1273  spec->base = 8;
1274  break;
1275 
1276  case 'x':
1277  spec->flags |= SMALL;
1278 
1279  case 'X':
1280  spec->base = 16;
1281  break;
1282 
1283  case 'd':
1284  case 'i':
1285  spec->flags |= SIGN;
1286  case 'u':
1287  break;
1288 
1289  default:
1290  spec->type = FORMAT_TYPE_INVALID;
1291  return fmt - start;
1292  }
1293 
1294  if (spec->qualifier == 'L')
1295  spec->type = FORMAT_TYPE_LONG_LONG;
1296  else if (spec->qualifier == 'l') {
1297  if (spec->flags & SIGN)
1298  spec->type = FORMAT_TYPE_LONG;
1299  else
1300  spec->type = FORMAT_TYPE_ULONG;
1301  } else if (_tolower(spec->qualifier) == 'z') {
1302  spec->type = FORMAT_TYPE_SIZE_T;
1303  } else if (spec->qualifier == 't') {
1304  spec->type = FORMAT_TYPE_PTRDIFF;
1305  } else if (spec->qualifier == 'H') {
1306  if (spec->flags & SIGN)
1307  spec->type = FORMAT_TYPE_BYTE;
1308  else
1309  spec->type = FORMAT_TYPE_UBYTE;
1310  } else if (spec->qualifier == 'h') {
1311  if (spec->flags & SIGN)
1312  spec->type = FORMAT_TYPE_SHORT;
1313  else
1314  spec->type = FORMAT_TYPE_USHORT;
1315  } else {
1316  if (spec->flags & SIGN)
1317  spec->type = FORMAT_TYPE_INT;
1318  else
1319  spec->type = FORMAT_TYPE_UINT;
1320  }
1321 
1322  return ++fmt - start;
1323 }
1324 
1368 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1369 {
1370  unsigned long long num;
1371  char *str, *end;
1372  struct printf_spec spec = {0};
1373 
1374  /* Reject out-of-range values early. Large positive sizes are
1375  used for unknown buffer sizes. */
1376  if (WARN_ON_ONCE((int) size < 0))
1377  return 0;
1378 
1379  str = buf;
1380  end = buf + size;
1381 
1382  /* Make sure end is always >= buf */
1383  if (end < buf) {
1384  end = ((void *)-1);
1385  size = end - buf;
1386  }
1387 
1388  while (*fmt) {
1389  const char *old_fmt = fmt;
1390  int read = format_decode(fmt, &spec);
1391 
1392  fmt += read;
1393 
1394  switch (spec.type) {
1395  case FORMAT_TYPE_NONE: {
1396  int copy = read;
1397  if (str < end) {
1398  if (copy > end - str)
1399  copy = end - str;
1400  memcpy(str, old_fmt, copy);
1401  }
1402  str += read;
1403  break;
1404  }
1405 
1406  case FORMAT_TYPE_WIDTH:
1407  spec.field_width = va_arg(args, int);
1408  break;
1409 
1410  case FORMAT_TYPE_PRECISION:
1411  spec.precision = va_arg(args, int);
1412  break;
1413 
1414  case FORMAT_TYPE_CHAR: {
1415  char c;
1416 
1417  if (!(spec.flags & LEFT)) {
1418  while (--spec.field_width > 0) {
1419  if (str < end)
1420  *str = ' ';
1421  ++str;
1422 
1423  }
1424  }
1425  c = (unsigned char) va_arg(args, int);
1426  if (str < end)
1427  *str = c;
1428  ++str;
1429  while (--spec.field_width > 0) {
1430  if (str < end)
1431  *str = ' ';
1432  ++str;
1433  }
1434  break;
1435  }
1436 
1437  case FORMAT_TYPE_STR:
1438  str = string(str, end, va_arg(args, char *), spec);
1439  break;
1440 
1441  case FORMAT_TYPE_PTR:
1442  str = pointer(fmt+1, str, end, va_arg(args, void *),
1443  spec);
1444  while (isalnum(*fmt))
1445  fmt++;
1446  break;
1447 
1448  case FORMAT_TYPE_PERCENT_CHAR:
1449  if (str < end)
1450  *str = '%';
1451  ++str;
1452  break;
1453 
1454  case FORMAT_TYPE_INVALID:
1455  if (str < end)
1456  *str = '%';
1457  ++str;
1458  break;
1459 
1460  case FORMAT_TYPE_NRCHARS: {
1461  u8 qualifier = spec.qualifier;
1462 
1463  if (qualifier == 'l') {
1464  long *ip = va_arg(args, long *);
1465  *ip = (str - buf);
1466  } else if (_tolower(qualifier) == 'z') {
1467  size_t *ip = va_arg(args, size_t *);
1468  *ip = (str - buf);
1469  } else {
1470  int *ip = va_arg(args, int *);
1471  *ip = (str - buf);
1472  }
1473  break;
1474  }
1475 
1476  default:
1477  switch (spec.type) {
1478  case FORMAT_TYPE_LONG_LONG:
1479  num = va_arg(args, long long);
1480  break;
1481  case FORMAT_TYPE_ULONG:
1482  num = va_arg(args, unsigned long);
1483  break;
1484  case FORMAT_TYPE_LONG:
1485  num = va_arg(args, long);
1486  break;
1487  case FORMAT_TYPE_SIZE_T:
1488  num = va_arg(args, size_t);
1489  break;
1490  case FORMAT_TYPE_PTRDIFF:
1491  num = va_arg(args, ptrdiff_t);
1492  break;
1493  case FORMAT_TYPE_UBYTE:
1494  num = (unsigned char) va_arg(args, int);
1495  break;
1496  case FORMAT_TYPE_BYTE:
1497  num = (signed char) va_arg(args, int);
1498  break;
1499  case FORMAT_TYPE_USHORT:
1500  num = (unsigned short) va_arg(args, int);
1501  break;
1502  case FORMAT_TYPE_SHORT:
1503  num = (short) va_arg(args, int);
1504  break;
1505  case FORMAT_TYPE_INT:
1506  num = (int) va_arg(args, int);
1507  break;
1508  default:
1509  num = va_arg(args, unsigned int);
1510  }
1511 
1512  str = number(str, end, num, spec);
1513  }
1514  }
1515 
1516  if (size > 0) {
1517  if (str < end)
1518  *str = '\0';
1519  else
1520  end[-1] = '\0';
1521  }
1522 
1523  /* the trailing null byte doesn't count towards the total */
1524  return str-buf;
1525 
1526 }
1527 EXPORT_SYMBOL(vsnprintf);
1528 
1544 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1545 {
1546  int i;
1547 
1548  i = vsnprintf(buf, size, fmt, args);
1549 
1550  if (likely(i < size))
1551  return i;
1552  if (size != 0)
1553  return size - 1;
1554  return 0;
1555 }
1556 EXPORT_SYMBOL(vscnprintf);
1557 
1572 int snprintf(char *buf, size_t size, const char *fmt, ...)
1573 {
1574  va_list args;
1575  int i;
1576 
1577  va_start(args, fmt);
1578  i = vsnprintf(buf, size, fmt, args);
1579  va_end(args);
1580 
1581  return i;
1582 }
1583 EXPORT_SYMBOL(snprintf);
1584 
1596 int scnprintf(char *buf, size_t size, const char *fmt, ...)
1597 {
1598  va_list args;
1599  int i;
1600 
1601  va_start(args, fmt);
1602  i = vscnprintf(buf, size, fmt, args);
1603  va_end(args);
1604 
1605  return i;
1606 }
1607 EXPORT_SYMBOL(scnprintf);
1608 
1623 int vsprintf(char *buf, const char *fmt, va_list args)
1624 {
1625  return vsnprintf(buf, INT_MAX, fmt, args);
1626 }
1627 EXPORT_SYMBOL(vsprintf);
1628 
1641 int sprintf(char *buf, const char *fmt, ...)
1642 {
1643  va_list args;
1644  int i;
1645 
1646  va_start(args, fmt);
1647  i = vsnprintf(buf, INT_MAX, fmt, args);
1648  va_end(args);
1649 
1650  return i;
1651 }
1652 EXPORT_SYMBOL(sprintf);
1653 
1654 #ifdef CONFIG_BINARY_PRINTF
1655 /*
1656  * bprintf service:
1657  * vbin_printf() - VA arguments to binary data
1658  * bstr_printf() - Binary data to text string
1659  */
1660 
1678 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
1679 {
1680  struct printf_spec spec = {0};
1681  char *str, *end;
1682 
1683  str = (char *)bin_buf;
1684  end = (char *)(bin_buf + size);
1685 
1686 #define save_arg(type) \
1687 do { \
1688  if (sizeof(type) == 8) { \
1689  unsigned long long value; \
1690  str = PTR_ALIGN(str, sizeof(u32)); \
1691  value = va_arg(args, unsigned long long); \
1692  if (str + sizeof(type) <= end) { \
1693  *(u32 *)str = *(u32 *)&value; \
1694  *(u32 *)(str + 4) = *((u32 *)&value + 1); \
1695  } \
1696  } else { \
1697  unsigned long value; \
1698  str = PTR_ALIGN(str, sizeof(type)); \
1699  value = va_arg(args, int); \
1700  if (str + sizeof(type) <= end) \
1701  *(typeof(type) *)str = (type)value; \
1702  } \
1703  str += sizeof(type); \
1704 } while (0)
1705 
1706  while (*fmt) {
1707  int read = format_decode(fmt, &spec);
1708 
1709  fmt += read;
1710 
1711  switch (spec.type) {
1712  case FORMAT_TYPE_NONE:
1713  case FORMAT_TYPE_INVALID:
1714  case FORMAT_TYPE_PERCENT_CHAR:
1715  break;
1716 
1717  case FORMAT_TYPE_WIDTH:
1718  case FORMAT_TYPE_PRECISION:
1719  save_arg(int);
1720  break;
1721 
1722  case FORMAT_TYPE_CHAR:
1723  save_arg(char);
1724  break;
1725 
1726  case FORMAT_TYPE_STR: {
1727  const char *save_str = va_arg(args, char *);
1728  size_t len;
1729 
1730  if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
1731  || (unsigned long)save_str < PAGE_SIZE)
1732  save_str = "(null)";
1733  len = strlen(save_str) + 1;
1734  if (str + len < end)
1735  memcpy(str, save_str, len);
1736  str += len;
1737  break;
1738  }
1739 
1740  case FORMAT_TYPE_PTR:
1741  save_arg(void *);
1742  /* skip all alphanumeric pointer suffixes */
1743  while (isalnum(*fmt))
1744  fmt++;
1745  break;
1746 
1747  case FORMAT_TYPE_NRCHARS: {
1748  /* skip %n 's argument */
1749  u8 qualifier = spec.qualifier;
1750  void *skip_arg;
1751  if (qualifier == 'l')
1752  skip_arg = va_arg(args, long *);
1753  else if (_tolower(qualifier) == 'z')
1754  skip_arg = va_arg(args, size_t *);
1755  else
1756  skip_arg = va_arg(args, int *);
1757  break;
1758  }
1759 
1760  default:
1761  switch (spec.type) {
1762 
1763  case FORMAT_TYPE_LONG_LONG:
1764  save_arg(long long);
1765  break;
1766  case FORMAT_TYPE_ULONG:
1767  case FORMAT_TYPE_LONG:
1768  save_arg(unsigned long);
1769  break;
1770  case FORMAT_TYPE_SIZE_T:
1771  save_arg(size_t);
1772  break;
1773  case FORMAT_TYPE_PTRDIFF:
1774  save_arg(ptrdiff_t);
1775  break;
1776  case FORMAT_TYPE_UBYTE:
1777  case FORMAT_TYPE_BYTE:
1778  save_arg(char);
1779  break;
1780  case FORMAT_TYPE_USHORT:
1781  case FORMAT_TYPE_SHORT:
1782  save_arg(short);
1783  break;
1784  default:
1785  save_arg(int);
1786  }
1787  }
1788  }
1789 
1790  return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
1791 #undef save_arg
1792 }
1793 EXPORT_SYMBOL_GPL(vbin_printf);
1794 
1817 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
1818 {
1819  struct printf_spec spec = {0};
1820  char *str, *end;
1821  const char *args = (const char *)bin_buf;
1822 
1823  if (WARN_ON_ONCE((int) size < 0))
1824  return 0;
1825 
1826  str = buf;
1827  end = buf + size;
1828 
1829 #define get_arg(type) \
1830 ({ \
1831  typeof(type) value; \
1832  if (sizeof(type) == 8) { \
1833  args = PTR_ALIGN(args, sizeof(u32)); \
1834  *(u32 *)&value = *(u32 *)args; \
1835  *((u32 *)&value + 1) = *(u32 *)(args + 4); \
1836  } else { \
1837  args = PTR_ALIGN(args, sizeof(type)); \
1838  value = *(typeof(type) *)args; \
1839  } \
1840  args += sizeof(type); \
1841  value; \
1842 })
1843 
1844  /* Make sure end is always >= buf */
1845  if (end < buf) {
1846  end = ((void *)-1);
1847  size = end - buf;
1848  }
1849 
1850  while (*fmt) {
1851  const char *old_fmt = fmt;
1852  int read = format_decode(fmt, &spec);
1853 
1854  fmt += read;
1855 
1856  switch (spec.type) {
1857  case FORMAT_TYPE_NONE: {
1858  int copy = read;
1859  if (str < end) {
1860  if (copy > end - str)
1861  copy = end - str;
1862  memcpy(str, old_fmt, copy);
1863  }
1864  str += read;
1865  break;
1866  }
1867 
1868  case FORMAT_TYPE_WIDTH:
1869  spec.field_width = get_arg(int);
1870  break;
1871 
1872  case FORMAT_TYPE_PRECISION:
1873  spec.precision = get_arg(int);
1874  break;
1875 
1876  case FORMAT_TYPE_CHAR: {
1877  char c;
1878 
1879  if (!(spec.flags & LEFT)) {
1880  while (--spec.field_width > 0) {
1881  if (str < end)
1882  *str = ' ';
1883  ++str;
1884  }
1885  }
1886  c = (unsigned char) get_arg(char);
1887  if (str < end)
1888  *str = c;
1889  ++str;
1890  while (--spec.field_width > 0) {
1891  if (str < end)
1892  *str = ' ';
1893  ++str;
1894  }
1895  break;
1896  }
1897 
1898  case FORMAT_TYPE_STR: {
1899  const char *str_arg = args;
1900  args += strlen(str_arg) + 1;
1901  str = string(str, end, (char *)str_arg, spec);
1902  break;
1903  }
1904 
1905  case FORMAT_TYPE_PTR:
1906  str = pointer(fmt+1, str, end, get_arg(void *), spec);
1907  while (isalnum(*fmt))
1908  fmt++;
1909  break;
1910 
1911  case FORMAT_TYPE_PERCENT_CHAR:
1912  case FORMAT_TYPE_INVALID:
1913  if (str < end)
1914  *str = '%';
1915  ++str;
1916  break;
1917 
1918  case FORMAT_TYPE_NRCHARS:
1919  /* skip */
1920  break;
1921 
1922  default: {
1923  unsigned long long num;
1924 
1925  switch (spec.type) {
1926 
1927  case FORMAT_TYPE_LONG_LONG:
1928  num = get_arg(long long);
1929  break;
1930  case FORMAT_TYPE_ULONG:
1931  case FORMAT_TYPE_LONG:
1932  num = get_arg(unsigned long);
1933  break;
1934  case FORMAT_TYPE_SIZE_T:
1935  num = get_arg(size_t);
1936  break;
1937  case FORMAT_TYPE_PTRDIFF:
1938  num = get_arg(ptrdiff_t);
1939  break;
1940  case FORMAT_TYPE_UBYTE:
1941  num = get_arg(unsigned char);
1942  break;
1943  case FORMAT_TYPE_BYTE:
1944  num = get_arg(signed char);
1945  break;
1946  case FORMAT_TYPE_USHORT:
1947  num = get_arg(unsigned short);
1948  break;
1949  case FORMAT_TYPE_SHORT:
1950  num = get_arg(short);
1951  break;
1952  case FORMAT_TYPE_UINT:
1953  num = get_arg(unsigned int);
1954  break;
1955  default:
1956  num = get_arg(int);
1957  }
1958 
1959  str = number(str, end, num, spec);
1960  } /* default: */
1961  } /* switch(spec.type) */
1962  } /* while(*fmt) */
1963 
1964  if (size > 0) {
1965  if (str < end)
1966  *str = '\0';
1967  else
1968  end[-1] = '\0';
1969  }
1970 
1971 #undef get_arg
1972 
1973  /* the trailing null byte doesn't count towards the total */
1974  return str - buf;
1975 }
1976 EXPORT_SYMBOL_GPL(bstr_printf);
1977 
1988 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
1989 {
1990  va_list args;
1991  int ret;
1992 
1993  va_start(args, fmt);
1994  ret = vbin_printf(bin_buf, size, fmt, args);
1995  va_end(args);
1996 
1997  return ret;
1998 }
1999 EXPORT_SYMBOL_GPL(bprintf);
2000 
2001 #endif /* CONFIG_BINARY_PRINTF */
2002 
2009 int vsscanf(const char *buf, const char *fmt, va_list args)
2010 {
2011  const char *str = buf;
2012  char *next;
2013  char digit;
2014  int num = 0;
2015  u8 qualifier;
2016  u8 base;
2017  s16 field_width;
2018  bool is_sign;
2019 
2020  while (*fmt) {
2021  /* skip any white space in format */
2022  /* white space in format matchs any amount of
2023  * white space, including none, in the input.
2024  */
2025  if (isspace(*fmt)) {
2026  fmt = skip_spaces(++fmt);
2027  str = skip_spaces(str);
2028  }
2029 
2030  /* anything that is not a conversion must match exactly */
2031  if (*fmt != '%' && *fmt) {
2032  if (*fmt++ != *str++)
2033  break;
2034  continue;
2035  }
2036 
2037  if (!*fmt)
2038  break;
2039  ++fmt;
2040 
2041  /* skip this conversion.
2042  * advance both strings to next white space
2043  */
2044  if (*fmt == '*') {
2045  if (!*str)
2046  break;
2047  while (!isspace(*fmt) && *fmt != '%' && *fmt)
2048  fmt++;
2049  while (!isspace(*str) && *str)
2050  str++;
2051  continue;
2052  }
2053 
2054  /* get field width */
2055  field_width = -1;
2056  if (isdigit(*fmt))
2057  field_width = skip_atoi(&fmt);
2058 
2059  /* get conversion qualifier */
2060  qualifier = -1;
2061  if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2062  _tolower(*fmt) == 'z') {
2063  qualifier = *fmt++;
2064  if (unlikely(qualifier == *fmt)) {
2065  if (qualifier == 'h') {
2066  qualifier = 'H';
2067  fmt++;
2068  } else if (qualifier == 'l') {
2069  qualifier = 'L';
2070  fmt++;
2071  }
2072  }
2073  }
2074 
2075  if (!*fmt)
2076  break;
2077 
2078  if (*fmt == 'n') {
2079  /* return number of characters read so far */
2080  *va_arg(args, int *) = str - buf;
2081  ++fmt;
2082  continue;
2083  }
2084 
2085  if (!*str)
2086  break;
2087 
2088  base = 10;
2089  is_sign = 0;
2090 
2091  switch (*fmt++) {
2092  case 'c':
2093  {
2094  char *s = (char *)va_arg(args, char*);
2095  if (field_width == -1)
2096  field_width = 1;
2097  do {
2098  *s++ = *str++;
2099  } while (--field_width > 0 && *str);
2100  num++;
2101  }
2102  continue;
2103  case 's':
2104  {
2105  char *s = (char *)va_arg(args, char *);
2106  if (field_width == -1)
2107  field_width = SHRT_MAX;
2108  /* first, skip leading white space in buffer */
2109  str = skip_spaces(str);
2110 
2111  /* now copy until next white space */
2112  while (*str && !isspace(*str) && field_width--)
2113  *s++ = *str++;
2114  *s = '\0';
2115  num++;
2116  }
2117  continue;
2118  case 'o':
2119  base = 8;
2120  break;
2121  case 'x':
2122  case 'X':
2123  base = 16;
2124  break;
2125  case 'i':
2126  base = 0;
2127  case 'd':
2128  is_sign = 1;
2129  case 'u':
2130  break;
2131  case '%':
2132  /* looking for '%' in str */
2133  if (*str++ != '%')
2134  return num;
2135  continue;
2136  default:
2137  /* invalid format; stop here */
2138  return num;
2139  }
2140 
2141  /* have some sort of integer conversion.
2142  * first, skip white space in buffer.
2143  */
2144  str = skip_spaces(str);
2145 
2146  digit = *str;
2147  if (is_sign && digit == '-')
2148  digit = *(str + 1);
2149 
2150  if (!digit
2151  || (base == 16 && !isxdigit(digit))
2152  || (base == 10 && !isdigit(digit))
2153  || (base == 8 && (!isdigit(digit) || digit > '7'))
2154  || (base == 0 && !isdigit(digit)))
2155  break;
2156 
2157  switch (qualifier) {
2158  case 'H': /* that's 'hh' in format */
2159  if (is_sign) {
2160  signed char *s = (signed char *)va_arg(args, signed char *);
2161  *s = (signed char)simple_strtol(str, &next, base);
2162  } else {
2163  unsigned char *s = (unsigned char *)va_arg(args, unsigned char *);
2164  *s = (unsigned char)simple_strtoul(str, &next, base);
2165  }
2166  break;
2167  case 'h':
2168  if (is_sign) {
2169  short *s = (short *)va_arg(args, short *);
2170  *s = (short)simple_strtol(str, &next, base);
2171  } else {
2172  unsigned short *s = (unsigned short *)va_arg(args, unsigned short *);
2173  *s = (unsigned short)simple_strtoul(str, &next, base);
2174  }
2175  break;
2176  case 'l':
2177  if (is_sign) {
2178  long *l = (long *)va_arg(args, long *);
2179  *l = simple_strtol(str, &next, base);
2180  } else {
2181  unsigned long *l = (unsigned long *)va_arg(args, unsigned long *);
2182  *l = simple_strtoul(str, &next, base);
2183  }
2184  break;
2185  case 'L':
2186  if (is_sign) {
2187  long long *l = (long long *)va_arg(args, long long *);
2188  *l = simple_strtoll(str, &next, base);
2189  } else {
2190  unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *);
2191  *l = simple_strtoull(str, &next, base);
2192  }
2193  break;
2194  case 'Z':
2195  case 'z':
2196  {
2197  size_t *s = (size_t *)va_arg(args, size_t *);
2198  *s = (size_t)simple_strtoul(str, &next, base);
2199  }
2200  break;
2201  default:
2202  if (is_sign) {
2203  int *i = (int *)va_arg(args, int *);
2204  *i = (int)simple_strtol(str, &next, base);
2205  } else {
2206  unsigned int *i = (unsigned int *)va_arg(args, unsigned int*);
2207  *i = (unsigned int)simple_strtoul(str, &next, base);
2208  }
2209  break;
2210  }
2211  num++;
2212 
2213  if (!next)
2214  break;
2215  str = next;
2216  }
2217 
2218  return num;
2219 }
2220 EXPORT_SYMBOL(vsscanf);
2221 
2228 int sscanf(const char *buf, const char *fmt, ...)
2229 {
2230  va_list args;
2231  int i;
2232 
2233  va_start(args, fmt);
2234  i = vsscanf(buf, fmt, args);
2235  va_end(args);
2236 
2237  return i;
2238 }
2239 EXPORT_SYMBOL(sscanf);
Generated on Thu Jan 10 2013 14:55:58 for Linux Kernel by   doxygen 1.8.2