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