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 * 't' added for ptrdiff_t 1743 * 1744 * @fmt: the format string 1745 * @type of the token returned 1746 * @flags: various flags such as +, -, # tokens.. 1747 * @field_width: overwritten width 1748 * @base: base of the number (octal, hex, ...) 1749 * @precision: precision of a number 1750 * @qualifier: qualifier of a number (long, size_t, ...) 1751 */ 1752 static noinline_for_stack 1753 int format_decode(const char *fmt, struct printf_spec *spec) 1754 { 1755 const char *start = fmt; 1756 char qualifier; 1757 1758 /* we finished early by reading the field width */ 1759 if (spec->type == FORMAT_TYPE_WIDTH) { 1760 if (spec->field_width < 0) { 1761 spec->field_width = -spec->field_width; 1762 spec->flags |= LEFT; 1763 } 1764 spec->type = FORMAT_TYPE_NONE; 1765 goto precision; 1766 } 1767 1768 /* we finished early by reading the precision */ 1769 if (spec->type == FORMAT_TYPE_PRECISION) { 1770 if (spec->precision < 0) 1771 spec->precision = 0; 1772 1773 spec->type = FORMAT_TYPE_NONE; 1774 goto qualifier; 1775 } 1776 1777 /* By default */ 1778 spec->type = FORMAT_TYPE_NONE; 1779 1780 for (; *fmt ; ++fmt) { 1781 if (*fmt == '%') 1782 break; 1783 } 1784 1785 /* Return the current non-format string */ 1786 if (fmt != start || !*fmt) 1787 return fmt - start; 1788 1789 /* Process flags */ 1790 spec->flags = 0; 1791 1792 while (1) { /* this also skips first '%' */ 1793 bool found = true; 1794 1795 ++fmt; 1796 1797 switch (*fmt) { 1798 case '-': spec->flags |= LEFT; break; 1799 case '+': spec->flags |= PLUS; break; 1800 case ' ': spec->flags |= SPACE; break; 1801 case '#': spec->flags |= SPECIAL; break; 1802 case '0': spec->flags |= ZEROPAD; break; 1803 default: found = false; 1804 } 1805 1806 if (!found) 1807 break; 1808 } 1809 1810 /* get field width */ 1811 spec->field_width = -1; 1812 1813 if (isdigit(*fmt)) 1814 spec->field_width = skip_atoi(&fmt); 1815 else if (*fmt == '*') { 1816 /* it's the next argument */ 1817 spec->type = FORMAT_TYPE_WIDTH; 1818 return ++fmt - start; 1819 } 1820 1821 precision: 1822 /* get the precision */ 1823 spec->precision = -1; 1824 if (*fmt == '.') { 1825 ++fmt; 1826 if (isdigit(*fmt)) { 1827 spec->precision = skip_atoi(&fmt); 1828 if (spec->precision < 0) 1829 spec->precision = 0; 1830 } else if (*fmt == '*') { 1831 /* it's the next argument */ 1832 spec->type = FORMAT_TYPE_PRECISION; 1833 return ++fmt - start; 1834 } 1835 } 1836 1837 qualifier: 1838 /* get the conversion qualifier */ 1839 qualifier = 0; 1840 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 1841 _tolower(*fmt) == 'z' || *fmt == 't') { 1842 qualifier = *fmt++; 1843 if (unlikely(qualifier == *fmt)) { 1844 if (qualifier == 'l') { 1845 qualifier = 'L'; 1846 ++fmt; 1847 } else if (qualifier == 'h') { 1848 qualifier = 'H'; 1849 ++fmt; 1850 } 1851 } 1852 } 1853 1854 /* default base */ 1855 spec->base = 10; 1856 switch (*fmt) { 1857 case 'c': 1858 spec->type = FORMAT_TYPE_CHAR; 1859 return ++fmt - start; 1860 1861 case 's': 1862 spec->type = FORMAT_TYPE_STR; 1863 return ++fmt - start; 1864 1865 case 'p': 1866 spec->type = FORMAT_TYPE_PTR; 1867 return ++fmt - start; 1868 1869 case '%': 1870 spec->type = FORMAT_TYPE_PERCENT_CHAR; 1871 return ++fmt - start; 1872 1873 /* integer number formats - set up the flags and "break" */ 1874 case 'o': 1875 spec->base = 8; 1876 break; 1877 1878 case 'x': 1879 spec->flags |= SMALL; 1880 1881 case 'X': 1882 spec->base = 16; 1883 break; 1884 1885 case 'd': 1886 case 'i': 1887 spec->flags |= SIGN; 1888 case 'u': 1889 break; 1890 1891 case 'n': 1892 /* 1893 * Since %n poses a greater security risk than 1894 * utility, treat it as any other invalid or 1895 * unsupported format specifier. 1896 */ 1897 /* Fall-through */ 1898 1899 default: 1900 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt); 1901 spec->type = FORMAT_TYPE_INVALID; 1902 return fmt - start; 1903 } 1904 1905 if (qualifier == 'L') 1906 spec->type = FORMAT_TYPE_LONG_LONG; 1907 else if (qualifier == 'l') { 1908 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 1909 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 1910 } else if (_tolower(qualifier) == 'z') { 1911 spec->type = FORMAT_TYPE_SIZE_T; 1912 } else if (qualifier == 't') { 1913 spec->type = FORMAT_TYPE_PTRDIFF; 1914 } else if (qualifier == 'H') { 1915 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE); 1916 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN); 1917 } else if (qualifier == 'h') { 1918 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT); 1919 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN); 1920 } else { 1921 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT); 1922 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN); 1923 } 1924 1925 return ++fmt - start; 1926 } 1927 1928 static void 1929 set_field_width(struct printf_spec *spec, int width) 1930 { 1931 spec->field_width = width; 1932 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) { 1933 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX); 1934 } 1935 } 1936 1937 static void 1938 set_precision(struct printf_spec *spec, int prec) 1939 { 1940 spec->precision = prec; 1941 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) { 1942 spec->precision = clamp(prec, 0, PRECISION_MAX); 1943 } 1944 } 1945 1946 /** 1947 * vsnprintf - Format a string and place it in a buffer 1948 * @buf: The buffer to place the result into 1949 * @size: The size of the buffer, including the trailing null space 1950 * @fmt: The format string to use 1951 * @args: Arguments for the format string 1952 * 1953 * This function generally follows C99 vsnprintf, but has some 1954 * extensions and a few limitations: 1955 * 1956 * %n is unsupported 1957 * %p* is handled by pointer() 1958 * 1959 * See pointer() or Documentation/printk-formats.txt for more 1960 * extensive description. 1961 * 1962 * ** Please update the documentation in both places when making changes ** 1963 * 1964 * The return value is the number of characters which would 1965 * be generated for the given input, excluding the trailing 1966 * '\0', as per ISO C99. If you want to have the exact 1967 * number of characters written into @buf as return value 1968 * (not including the trailing '\0'), use vscnprintf(). If the 1969 * return is greater than or equal to @size, the resulting 1970 * string is truncated. 1971 * 1972 * If you're not already dealing with a va_list consider using snprintf(). 1973 */ 1974 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 1975 { 1976 unsigned long long num; 1977 char *str, *end; 1978 struct printf_spec spec = {0}; 1979 1980 /* Reject out-of-range values early. Large positive sizes are 1981 used for unknown buffer sizes. */ 1982 if (WARN_ON_ONCE(size > INT_MAX)) 1983 return 0; 1984 1985 str = buf; 1986 end = buf + size; 1987 1988 /* Make sure end is always >= buf */ 1989 if (end < buf) { 1990 end = ((void *)-1); 1991 size = end - buf; 1992 } 1993 1994 while (*fmt) { 1995 const char *old_fmt = fmt; 1996 int read = format_decode(fmt, &spec); 1997 1998 fmt += read; 1999 2000 switch (spec.type) { 2001 case FORMAT_TYPE_NONE: { 2002 int copy = read; 2003 if (str < end) { 2004 if (copy > end - str) 2005 copy = end - str; 2006 memcpy(str, old_fmt, copy); 2007 } 2008 str += read; 2009 break; 2010 } 2011 2012 case FORMAT_TYPE_WIDTH: 2013 set_field_width(&spec, va_arg(args, int)); 2014 break; 2015 2016 case FORMAT_TYPE_PRECISION: 2017 set_precision(&spec, va_arg(args, int)); 2018 break; 2019 2020 case FORMAT_TYPE_CHAR: { 2021 char c; 2022 2023 if (!(spec.flags & LEFT)) { 2024 while (--spec.field_width > 0) { 2025 if (str < end) 2026 *str = ' '; 2027 ++str; 2028 2029 } 2030 } 2031 c = (unsigned char) va_arg(args, int); 2032 if (str < end) 2033 *str = c; 2034 ++str; 2035 while (--spec.field_width > 0) { 2036 if (str < end) 2037 *str = ' '; 2038 ++str; 2039 } 2040 break; 2041 } 2042 2043 case FORMAT_TYPE_STR: 2044 str = string(str, end, va_arg(args, char *), spec); 2045 break; 2046 2047 case FORMAT_TYPE_PTR: 2048 str = pointer(fmt, str, end, va_arg(args, void *), 2049 spec); 2050 while (isalnum(*fmt)) 2051 fmt++; 2052 break; 2053 2054 case FORMAT_TYPE_PERCENT_CHAR: 2055 if (str < end) 2056 *str = '%'; 2057 ++str; 2058 break; 2059 2060 case FORMAT_TYPE_INVALID: 2061 /* 2062 * Presumably the arguments passed gcc's type 2063 * checking, but there is no safe or sane way 2064 * for us to continue parsing the format and 2065 * fetching from the va_list; the remaining 2066 * specifiers and arguments would be out of 2067 * sync. 2068 */ 2069 goto out; 2070 2071 default: 2072 switch (spec.type) { 2073 case FORMAT_TYPE_LONG_LONG: 2074 num = va_arg(args, long long); 2075 break; 2076 case FORMAT_TYPE_ULONG: 2077 num = va_arg(args, unsigned long); 2078 break; 2079 case FORMAT_TYPE_LONG: 2080 num = va_arg(args, long); 2081 break; 2082 case FORMAT_TYPE_SIZE_T: 2083 if (spec.flags & SIGN) 2084 num = va_arg(args, ssize_t); 2085 else 2086 num = va_arg(args, size_t); 2087 break; 2088 case FORMAT_TYPE_PTRDIFF: 2089 num = va_arg(args, ptrdiff_t); 2090 break; 2091 case FORMAT_TYPE_UBYTE: 2092 num = (unsigned char) va_arg(args, int); 2093 break; 2094 case FORMAT_TYPE_BYTE: 2095 num = (signed char) va_arg(args, int); 2096 break; 2097 case FORMAT_TYPE_USHORT: 2098 num = (unsigned short) va_arg(args, int); 2099 break; 2100 case FORMAT_TYPE_SHORT: 2101 num = (short) va_arg(args, int); 2102 break; 2103 case FORMAT_TYPE_INT: 2104 num = (int) va_arg(args, int); 2105 break; 2106 default: 2107 num = va_arg(args, unsigned int); 2108 } 2109 2110 str = number(str, end, num, spec); 2111 } 2112 } 2113 2114 out: 2115 if (size > 0) { 2116 if (str < end) 2117 *str = '\0'; 2118 else 2119 end[-1] = '\0'; 2120 } 2121 2122 /* the trailing null byte doesn't count towards the total */ 2123 return str-buf; 2124 2125 } 2126 EXPORT_SYMBOL(vsnprintf); 2127 2128 /** 2129 * vscnprintf - Format a string and place it in a buffer 2130 * @buf: The buffer to place the result into 2131 * @size: The size of the buffer, including the trailing null space 2132 * @fmt: The format string to use 2133 * @args: Arguments for the format string 2134 * 2135 * The return value is the number of characters which have been written into 2136 * the @buf not including the trailing '\0'. If @size is == 0 the function 2137 * returns 0. 2138 * 2139 * If you're not already dealing with a va_list consider using scnprintf(). 2140 * 2141 * See the vsnprintf() documentation for format string extensions over C99. 2142 */ 2143 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 2144 { 2145 int i; 2146 2147 i = vsnprintf(buf, size, fmt, args); 2148 2149 if (likely(i < size)) 2150 return i; 2151 if (size != 0) 2152 return size - 1; 2153 return 0; 2154 } 2155 EXPORT_SYMBOL(vscnprintf); 2156 2157 /** 2158 * snprintf - Format a string and place it in a buffer 2159 * @buf: The buffer to place the result into 2160 * @size: The size of the buffer, including the trailing null space 2161 * @fmt: The format string to use 2162 * @...: Arguments for the format string 2163 * 2164 * The return value is the number of characters which would be 2165 * generated for the given input, excluding the trailing null, 2166 * as per ISO C99. If the return is greater than or equal to 2167 * @size, the resulting string is truncated. 2168 * 2169 * See the vsnprintf() documentation for format string extensions over C99. 2170 */ 2171 int snprintf(char *buf, size_t size, const char *fmt, ...) 2172 { 2173 va_list args; 2174 int i; 2175 2176 va_start(args, fmt); 2177 i = vsnprintf(buf, size, fmt, args); 2178 va_end(args); 2179 2180 return i; 2181 } 2182 EXPORT_SYMBOL(snprintf); 2183 2184 /** 2185 * scnprintf - Format a string and place it in a buffer 2186 * @buf: The buffer to place the result into 2187 * @size: The size of the buffer, including the trailing null space 2188 * @fmt: The format string to use 2189 * @...: Arguments for the format string 2190 * 2191 * The return value is the number of characters written into @buf not including 2192 * the trailing '\0'. If @size is == 0 the function returns 0. 2193 */ 2194 2195 int scnprintf(char *buf, size_t size, const char *fmt, ...) 2196 { 2197 va_list args; 2198 int i; 2199 2200 va_start(args, fmt); 2201 i = vscnprintf(buf, size, fmt, args); 2202 va_end(args); 2203 2204 return i; 2205 } 2206 EXPORT_SYMBOL(scnprintf); 2207 2208 /** 2209 * vsprintf - Format a string and place it in a buffer 2210 * @buf: The buffer to place the result into 2211 * @fmt: The format string to use 2212 * @args: Arguments for the format string 2213 * 2214 * The function returns the number of characters written 2215 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 2216 * buffer overflows. 2217 * 2218 * If you're not already dealing with a va_list consider using sprintf(). 2219 * 2220 * See the vsnprintf() documentation for format string extensions over C99. 2221 */ 2222 int vsprintf(char *buf, const char *fmt, va_list args) 2223 { 2224 return vsnprintf(buf, INT_MAX, fmt, args); 2225 } 2226 EXPORT_SYMBOL(vsprintf); 2227 2228 /** 2229 * sprintf - Format a string and place it in a buffer 2230 * @buf: The buffer to place the result into 2231 * @fmt: The format string to use 2232 * @...: Arguments for the format string 2233 * 2234 * The function returns the number of characters written 2235 * into @buf. Use snprintf() or scnprintf() in order to avoid 2236 * buffer overflows. 2237 * 2238 * See the vsnprintf() documentation for format string extensions over C99. 2239 */ 2240 int sprintf(char *buf, const char *fmt, ...) 2241 { 2242 va_list args; 2243 int i; 2244 2245 va_start(args, fmt); 2246 i = vsnprintf(buf, INT_MAX, fmt, args); 2247 va_end(args); 2248 2249 return i; 2250 } 2251 EXPORT_SYMBOL(sprintf); 2252 2253 #ifdef CONFIG_BINARY_PRINTF 2254 /* 2255 * bprintf service: 2256 * vbin_printf() - VA arguments to binary data 2257 * bstr_printf() - Binary data to text string 2258 */ 2259 2260 /** 2261 * vbin_printf - Parse a format string and place args' binary value in a buffer 2262 * @bin_buf: The buffer to place args' binary value 2263 * @size: The size of the buffer(by words(32bits), not characters) 2264 * @fmt: The format string to use 2265 * @args: Arguments for the format string 2266 * 2267 * The format follows C99 vsnprintf, except %n is ignored, and its argument 2268 * is skipped. 2269 * 2270 * The return value is the number of words(32bits) which would be generated for 2271 * the given input. 2272 * 2273 * NOTE: 2274 * If the return value is greater than @size, the resulting bin_buf is NOT 2275 * valid for bstr_printf(). 2276 */ 2277 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 2278 { 2279 struct printf_spec spec = {0}; 2280 char *str, *end; 2281 2282 str = (char *)bin_buf; 2283 end = (char *)(bin_buf + size); 2284 2285 #define save_arg(type) \ 2286 do { \ 2287 if (sizeof(type) == 8) { \ 2288 unsigned long long value; \ 2289 str = PTR_ALIGN(str, sizeof(u32)); \ 2290 value = va_arg(args, unsigned long long); \ 2291 if (str + sizeof(type) <= end) { \ 2292 *(u32 *)str = *(u32 *)&value; \ 2293 *(u32 *)(str + 4) = *((u32 *)&value + 1); \ 2294 } \ 2295 } else { \ 2296 unsigned long value; \ 2297 str = PTR_ALIGN(str, sizeof(type)); \ 2298 value = va_arg(args, int); \ 2299 if (str + sizeof(type) <= end) \ 2300 *(typeof(type) *)str = (type)value; \ 2301 } \ 2302 str += sizeof(type); \ 2303 } while (0) 2304 2305 while (*fmt) { 2306 int read = format_decode(fmt, &spec); 2307 2308 fmt += read; 2309 2310 switch (spec.type) { 2311 case FORMAT_TYPE_NONE: 2312 case FORMAT_TYPE_PERCENT_CHAR: 2313 break; 2314 case FORMAT_TYPE_INVALID: 2315 goto out; 2316 2317 case FORMAT_TYPE_WIDTH: 2318 case FORMAT_TYPE_PRECISION: 2319 save_arg(int); 2320 break; 2321 2322 case FORMAT_TYPE_CHAR: 2323 save_arg(char); 2324 break; 2325 2326 case FORMAT_TYPE_STR: { 2327 const char *save_str = va_arg(args, char *); 2328 size_t len; 2329 2330 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 2331 || (unsigned long)save_str < PAGE_SIZE) 2332 save_str = "(null)"; 2333 len = strlen(save_str) + 1; 2334 if (str + len < end) 2335 memcpy(str, save_str, len); 2336 str += len; 2337 break; 2338 } 2339 2340 case FORMAT_TYPE_PTR: 2341 save_arg(void *); 2342 /* skip all alphanumeric pointer suffixes */ 2343 while (isalnum(*fmt)) 2344 fmt++; 2345 break; 2346 2347 default: 2348 switch (spec.type) { 2349 2350 case FORMAT_TYPE_LONG_LONG: 2351 save_arg(long long); 2352 break; 2353 case FORMAT_TYPE_ULONG: 2354 case FORMAT_TYPE_LONG: 2355 save_arg(unsigned long); 2356 break; 2357 case FORMAT_TYPE_SIZE_T: 2358 save_arg(size_t); 2359 break; 2360 case FORMAT_TYPE_PTRDIFF: 2361 save_arg(ptrdiff_t); 2362 break; 2363 case FORMAT_TYPE_UBYTE: 2364 case FORMAT_TYPE_BYTE: 2365 save_arg(char); 2366 break; 2367 case FORMAT_TYPE_USHORT: 2368 case FORMAT_TYPE_SHORT: 2369 save_arg(short); 2370 break; 2371 default: 2372 save_arg(int); 2373 } 2374 } 2375 } 2376 2377 out: 2378 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 2379 #undef save_arg 2380 } 2381 EXPORT_SYMBOL_GPL(vbin_printf); 2382 2383 /** 2384 * bstr_printf - Format a string from binary arguments and place it in a buffer 2385 * @buf: The buffer to place the result into 2386 * @size: The size of the buffer, including the trailing null space 2387 * @fmt: The format string to use 2388 * @bin_buf: Binary arguments for the format string 2389 * 2390 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 2391 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 2392 * a binary buffer that generated by vbin_printf. 2393 * 2394 * The format follows C99 vsnprintf, but has some extensions: 2395 * see vsnprintf comment for details. 2396 * 2397 * The return value is the number of characters which would 2398 * be generated for the given input, excluding the trailing 2399 * '\0', as per ISO C99. If you want to have the exact 2400 * number of characters written into @buf as return value 2401 * (not including the trailing '\0'), use vscnprintf(). If the 2402 * return is greater than or equal to @size, the resulting 2403 * string is truncated. 2404 */ 2405 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 2406 { 2407 struct printf_spec spec = {0}; 2408 char *str, *end; 2409 const char *args = (const char *)bin_buf; 2410 2411 if (WARN_ON_ONCE(size > INT_MAX)) 2412 return 0; 2413 2414 str = buf; 2415 end = buf + size; 2416 2417 #define get_arg(type) \ 2418 ({ \ 2419 typeof(type) value; \ 2420 if (sizeof(type) == 8) { \ 2421 args = PTR_ALIGN(args, sizeof(u32)); \ 2422 *(u32 *)&value = *(u32 *)args; \ 2423 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 2424 } else { \ 2425 args = PTR_ALIGN(args, sizeof(type)); \ 2426 value = *(typeof(type) *)args; \ 2427 } \ 2428 args += sizeof(type); \ 2429 value; \ 2430 }) 2431 2432 /* Make sure end is always >= buf */ 2433 if (end < buf) { 2434 end = ((void *)-1); 2435 size = end - buf; 2436 } 2437 2438 while (*fmt) { 2439 const char *old_fmt = fmt; 2440 int read = format_decode(fmt, &spec); 2441 2442 fmt += read; 2443 2444 switch (spec.type) { 2445 case FORMAT_TYPE_NONE: { 2446 int copy = read; 2447 if (str < end) { 2448 if (copy > end - str) 2449 copy = end - str; 2450 memcpy(str, old_fmt, copy); 2451 } 2452 str += read; 2453 break; 2454 } 2455 2456 case FORMAT_TYPE_WIDTH: 2457 set_field_width(&spec, get_arg(int)); 2458 break; 2459 2460 case FORMAT_TYPE_PRECISION: 2461 set_precision(&spec, get_arg(int)); 2462 break; 2463 2464 case FORMAT_TYPE_CHAR: { 2465 char c; 2466 2467 if (!(spec.flags & LEFT)) { 2468 while (--spec.field_width > 0) { 2469 if (str < end) 2470 *str = ' '; 2471 ++str; 2472 } 2473 } 2474 c = (unsigned char) get_arg(char); 2475 if (str < end) 2476 *str = c; 2477 ++str; 2478 while (--spec.field_width > 0) { 2479 if (str < end) 2480 *str = ' '; 2481 ++str; 2482 } 2483 break; 2484 } 2485 2486 case FORMAT_TYPE_STR: { 2487 const char *str_arg = args; 2488 args += strlen(str_arg) + 1; 2489 str = string(str, end, (char *)str_arg, spec); 2490 break; 2491 } 2492 2493 case FORMAT_TYPE_PTR: 2494 str = pointer(fmt, str, end, get_arg(void *), spec); 2495 while (isalnum(*fmt)) 2496 fmt++; 2497 break; 2498 2499 case FORMAT_TYPE_PERCENT_CHAR: 2500 if (str < end) 2501 *str = '%'; 2502 ++str; 2503 break; 2504 2505 case FORMAT_TYPE_INVALID: 2506 goto out; 2507 2508 default: { 2509 unsigned long long num; 2510 2511 switch (spec.type) { 2512 2513 case FORMAT_TYPE_LONG_LONG: 2514 num = get_arg(long long); 2515 break; 2516 case FORMAT_TYPE_ULONG: 2517 case FORMAT_TYPE_LONG: 2518 num = get_arg(unsigned long); 2519 break; 2520 case FORMAT_TYPE_SIZE_T: 2521 num = get_arg(size_t); 2522 break; 2523 case FORMAT_TYPE_PTRDIFF: 2524 num = get_arg(ptrdiff_t); 2525 break; 2526 case FORMAT_TYPE_UBYTE: 2527 num = get_arg(unsigned char); 2528 break; 2529 case FORMAT_TYPE_BYTE: 2530 num = get_arg(signed char); 2531 break; 2532 case FORMAT_TYPE_USHORT: 2533 num = get_arg(unsigned short); 2534 break; 2535 case FORMAT_TYPE_SHORT: 2536 num = get_arg(short); 2537 break; 2538 case FORMAT_TYPE_UINT: 2539 num = get_arg(unsigned int); 2540 break; 2541 default: 2542 num = get_arg(int); 2543 } 2544 2545 str = number(str, end, num, spec); 2546 } /* default: */ 2547 } /* switch(spec.type) */ 2548 } /* while(*fmt) */ 2549 2550 out: 2551 if (size > 0) { 2552 if (str < end) 2553 *str = '\0'; 2554 else 2555 end[-1] = '\0'; 2556 } 2557 2558 #undef get_arg 2559 2560 /* the trailing null byte doesn't count towards the total */ 2561 return str - buf; 2562 } 2563 EXPORT_SYMBOL_GPL(bstr_printf); 2564 2565 /** 2566 * bprintf - Parse a format string and place args' binary value in a buffer 2567 * @bin_buf: The buffer to place args' binary value 2568 * @size: The size of the buffer(by words(32bits), not characters) 2569 * @fmt: The format string to use 2570 * @...: Arguments for the format string 2571 * 2572 * The function returns the number of words(u32) written 2573 * into @bin_buf. 2574 */ 2575 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 2576 { 2577 va_list args; 2578 int ret; 2579 2580 va_start(args, fmt); 2581 ret = vbin_printf(bin_buf, size, fmt, args); 2582 va_end(args); 2583 2584 return ret; 2585 } 2586 EXPORT_SYMBOL_GPL(bprintf); 2587 2588 #endif /* CONFIG_BINARY_PRINTF */ 2589 2590 /** 2591 * vsscanf - Unformat a buffer into a list of arguments 2592 * @buf: input buffer 2593 * @fmt: format of buffer 2594 * @args: arguments 2595 */ 2596 int vsscanf(const char *buf, const char *fmt, va_list args) 2597 { 2598 const char *str = buf; 2599 char *next; 2600 char digit; 2601 int num = 0; 2602 u8 qualifier; 2603 unsigned int base; 2604 union { 2605 long long s; 2606 unsigned long long u; 2607 } val; 2608 s16 field_width; 2609 bool is_sign; 2610 2611 while (*fmt) { 2612 /* skip any white space in format */ 2613 /* white space in format matchs any amount of 2614 * white space, including none, in the input. 2615 */ 2616 if (isspace(*fmt)) { 2617 fmt = skip_spaces(++fmt); 2618 str = skip_spaces(str); 2619 } 2620 2621 /* anything that is not a conversion must match exactly */ 2622 if (*fmt != '%' && *fmt) { 2623 if (*fmt++ != *str++) 2624 break; 2625 continue; 2626 } 2627 2628 if (!*fmt) 2629 break; 2630 ++fmt; 2631 2632 /* skip this conversion. 2633 * advance both strings to next white space 2634 */ 2635 if (*fmt == '*') { 2636 if (!*str) 2637 break; 2638 while (!isspace(*fmt) && *fmt != '%' && *fmt) { 2639 /* '%*[' not yet supported, invalid format */ 2640 if (*fmt == '[') 2641 return num; 2642 fmt++; 2643 } 2644 while (!isspace(*str) && *str) 2645 str++; 2646 continue; 2647 } 2648 2649 /* get field width */ 2650 field_width = -1; 2651 if (isdigit(*fmt)) { 2652 field_width = skip_atoi(&fmt); 2653 if (field_width <= 0) 2654 break; 2655 } 2656 2657 /* get conversion qualifier */ 2658 qualifier = -1; 2659 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2660 _tolower(*fmt) == 'z') { 2661 qualifier = *fmt++; 2662 if (unlikely(qualifier == *fmt)) { 2663 if (qualifier == 'h') { 2664 qualifier = 'H'; 2665 fmt++; 2666 } else if (qualifier == 'l') { 2667 qualifier = 'L'; 2668 fmt++; 2669 } 2670 } 2671 } 2672 2673 if (!*fmt) 2674 break; 2675 2676 if (*fmt == 'n') { 2677 /* return number of characters read so far */ 2678 *va_arg(args, int *) = str - buf; 2679 ++fmt; 2680 continue; 2681 } 2682 2683 if (!*str) 2684 break; 2685 2686 base = 10; 2687 is_sign = false; 2688 2689 switch (*fmt++) { 2690 case 'c': 2691 { 2692 char *s = (char *)va_arg(args, char*); 2693 if (field_width == -1) 2694 field_width = 1; 2695 do { 2696 *s++ = *str++; 2697 } while (--field_width > 0 && *str); 2698 num++; 2699 } 2700 continue; 2701 case 's': 2702 { 2703 char *s = (char *)va_arg(args, char *); 2704 if (field_width == -1) 2705 field_width = SHRT_MAX; 2706 /* first, skip leading white space in buffer */ 2707 str = skip_spaces(str); 2708 2709 /* now copy until next white space */ 2710 while (*str && !isspace(*str) && field_width--) 2711 *s++ = *str++; 2712 *s = '\0'; 2713 num++; 2714 } 2715 continue; 2716 /* 2717 * Warning: This implementation of the '[' conversion specifier 2718 * deviates from its glibc counterpart in the following ways: 2719 * (1) It does NOT support ranges i.e. '-' is NOT a special 2720 * character 2721 * (2) It cannot match the closing bracket ']' itself 2722 * (3) A field width is required 2723 * (4) '%*[' (discard matching input) is currently not supported 2724 * 2725 * Example usage: 2726 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]", 2727 * buf1, buf2, buf3); 2728 * if (ret < 3) 2729 * // etc.. 2730 */ 2731 case '[': 2732 { 2733 char *s = (char *)va_arg(args, char *); 2734 DECLARE_BITMAP(set, 256) = {0}; 2735 unsigned int len = 0; 2736 bool negate = (*fmt == '^'); 2737 2738 /* field width is required */ 2739 if (field_width == -1) 2740 return num; 2741 2742 if (negate) 2743 ++fmt; 2744 2745 for ( ; *fmt && *fmt != ']'; ++fmt, ++len) 2746 set_bit((u8)*fmt, set); 2747 2748 /* no ']' or no character set found */ 2749 if (!*fmt || !len) 2750 return num; 2751 ++fmt; 2752 2753 if (negate) { 2754 bitmap_complement(set, set, 256); 2755 /* exclude null '\0' byte */ 2756 clear_bit(0, set); 2757 } 2758 2759 /* match must be non-empty */ 2760 if (!test_bit((u8)*str, set)) 2761 return num; 2762 2763 while (test_bit((u8)*str, set) && field_width--) 2764 *s++ = *str++; 2765 *s = '\0'; 2766 ++num; 2767 } 2768 continue; 2769 case 'o': 2770 base = 8; 2771 break; 2772 case 'x': 2773 case 'X': 2774 base = 16; 2775 break; 2776 case 'i': 2777 base = 0; 2778 case 'd': 2779 is_sign = true; 2780 case 'u': 2781 break; 2782 case '%': 2783 /* looking for '%' in str */ 2784 if (*str++ != '%') 2785 return num; 2786 continue; 2787 default: 2788 /* invalid format; stop here */ 2789 return num; 2790 } 2791 2792 /* have some sort of integer conversion. 2793 * first, skip white space in buffer. 2794 */ 2795 str = skip_spaces(str); 2796 2797 digit = *str; 2798 if (is_sign && digit == '-') 2799 digit = *(str + 1); 2800 2801 if (!digit 2802 || (base == 16 && !isxdigit(digit)) 2803 || (base == 10 && !isdigit(digit)) 2804 || (base == 8 && (!isdigit(digit) || digit > '7')) 2805 || (base == 0 && !isdigit(digit))) 2806 break; 2807 2808 if (is_sign) 2809 val.s = qualifier != 'L' ? 2810 simple_strtol(str, &next, base) : 2811 simple_strtoll(str, &next, base); 2812 else 2813 val.u = qualifier != 'L' ? 2814 simple_strtoul(str, &next, base) : 2815 simple_strtoull(str, &next, base); 2816 2817 if (field_width > 0 && next - str > field_width) { 2818 if (base == 0) 2819 _parse_integer_fixup_radix(str, &base); 2820 while (next - str > field_width) { 2821 if (is_sign) 2822 val.s = div_s64(val.s, base); 2823 else 2824 val.u = div_u64(val.u, base); 2825 --next; 2826 } 2827 } 2828 2829 switch (qualifier) { 2830 case 'H': /* that's 'hh' in format */ 2831 if (is_sign) 2832 *va_arg(args, signed char *) = val.s; 2833 else 2834 *va_arg(args, unsigned char *) = val.u; 2835 break; 2836 case 'h': 2837 if (is_sign) 2838 *va_arg(args, short *) = val.s; 2839 else 2840 *va_arg(args, unsigned short *) = val.u; 2841 break; 2842 case 'l': 2843 if (is_sign) 2844 *va_arg(args, long *) = val.s; 2845 else 2846 *va_arg(args, unsigned long *) = val.u; 2847 break; 2848 case 'L': 2849 if (is_sign) 2850 *va_arg(args, long long *) = val.s; 2851 else 2852 *va_arg(args, unsigned long long *) = val.u; 2853 break; 2854 case 'Z': 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