lib/vsprintf.c

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