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