lib/vsprintf.c

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