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