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