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 * Please update scripts/checkpatch.pl when adding/removing conversion 1481 * characters. (Search for "check for vsprintf extension"). 1482 * 1483 * Right now we handle: 1484 * 1485 * - 'F' For symbolic function descriptor pointers with offset 1486 * - 'f' For simple symbolic function names without offset 1487 * - 'S' For symbolic direct pointers with offset 1488 * - 's' For symbolic direct pointers without offset 1489 * - '[FfSs]R' as above with __builtin_extract_return_addr() translation 1490 * - 'B' For backtraced symbolic direct pointers with offset 1491 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 1492 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 1493 * - 'b[l]' For a bitmap, the number of bits is determined by the field 1494 * width which must be explicitly specified either as part of the 1495 * format string '%32b[l]' or through '%*b[l]', [l] selects 1496 * range-list format instead of hex format 1497 * - 'M' For a 6-byte MAC address, it prints the address in the 1498 * usual colon-separated hex notation 1499 * - 'm' For a 6-byte MAC address, it prints the hex address without colons 1500 * - 'MF' For a 6-byte MAC FDDI address, it prints the address 1501 * with a dash-separated hex notation 1502 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth) 1503 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 1504 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 1505 * IPv6 uses colon separated network-order 16 bit hex with leading 0's 1506 * [S][pfs] 1507 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 1508 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 1509 * - 'i' [46] for 'raw' IPv4/IPv6 addresses 1510 * IPv6 omits the colons (01020304...0f) 1511 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 1512 * [S][pfs] 1513 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 1514 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 1515 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order 1516 * - 'I[6S]c' for IPv6 addresses printed as specified by 1517 * http://tools.ietf.org/html/rfc5952 1518 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination 1519 * of the following flags (see string_escape_mem() for the 1520 * details): 1521 * a - ESCAPE_ANY 1522 * c - ESCAPE_SPECIAL 1523 * h - ESCAPE_HEX 1524 * n - ESCAPE_NULL 1525 * o - ESCAPE_OCTAL 1526 * p - ESCAPE_NP 1527 * s - ESCAPE_SPACE 1528 * By default ESCAPE_ANY_NP is used. 1529 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 1530 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 1531 * Options for %pU are: 1532 * b big endian lower case hex (default) 1533 * B big endian UPPER case hex 1534 * l little endian lower case hex 1535 * L little endian UPPER case hex 1536 * big endian output byte order is: 1537 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 1538 * little endian output byte order is: 1539 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 1540 * - 'V' For a struct va_format which contains a format string * and va_list *, 1541 * call vsnprintf(->format, *->va_list). 1542 * Implements a "recursive vsnprintf". 1543 * Do not use this feature without some mechanism to verify the 1544 * correctness of the format string and va_list arguments. 1545 * - 'K' For a kernel pointer that should be hidden from unprivileged users 1546 * - 'NF' For a netdev_features_t 1547 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with 1548 * a certain separator (' ' by default): 1549 * C colon 1550 * D dash 1551 * N no separator 1552 * The maximum supported length is 64 bytes of the input. Consider 1553 * to use print_hex_dump() for the larger input. 1554 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives 1555 * (default assumed to be phys_addr_t, passed by reference) 1556 * - 'd[234]' For a dentry name (optionally 2-4 last components) 1557 * - 'D[234]' Same as 'd' but for a struct file 1558 * - 'g' For block_device name (gendisk + partition number) 1559 * - 'C' For a clock, it prints the name (Common Clock Framework) or address 1560 * (legacy clock framework) of the clock 1561 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address 1562 * (legacy clock framework) of the clock 1563 * - 'Cr' For a clock, it prints the current rate of the clock 1564 * - 'G' For flags to be printed as a collection of symbolic strings that would 1565 * construct the specific value. Supported flags given by option: 1566 * p page flags (see struct page) given as pointer to unsigned long 1567 * g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t 1568 * v vma flags (VM_*) given as pointer to unsigned long 1569 * 1570 * ** Please update also Documentation/printk-formats.txt when making changes ** 1571 * 1572 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 1573 * function pointers are really function descriptors, which contain a 1574 * pointer to the real address. 1575 */ 1576 static noinline_for_stack 1577 char *pointer(const char *fmt, char *buf, char *end, void *ptr, 1578 struct printf_spec spec) 1579 { 1580 const int default_width = 2 * sizeof(void *); 1581 1582 if (!ptr && *fmt != 'K') { 1583 /* 1584 * Print (null) with the same width as a pointer so it makes 1585 * tabular output look nice. 1586 */ 1587 if (spec.field_width == -1) 1588 spec.field_width = default_width; 1589 return string(buf, end, "(null)", spec); 1590 } 1591 1592 switch (*fmt) { 1593 case 'F': 1594 case 'f': 1595 ptr = dereference_function_descriptor(ptr); 1596 /* Fallthrough */ 1597 case 'S': 1598 case 's': 1599 case 'B': 1600 return symbol_string(buf, end, ptr, spec, fmt); 1601 case 'R': 1602 case 'r': 1603 return resource_string(buf, end, ptr, spec, fmt); 1604 case 'h': 1605 return hex_string(buf, end, ptr, spec, fmt); 1606 case 'b': 1607 switch (fmt[1]) { 1608 case 'l': 1609 return bitmap_list_string(buf, end, ptr, spec, fmt); 1610 default: 1611 return bitmap_string(buf, end, ptr, spec, fmt); 1612 } 1613 case 'M': /* Colon separated: 00:01:02:03:04:05 */ 1614 case 'm': /* Contiguous: 000102030405 */ 1615 /* [mM]F (FDDI) */ 1616 /* [mM]R (Reverse order; Bluetooth) */ 1617 return mac_address_string(buf, end, ptr, spec, fmt); 1618 case 'I': /* Formatted IP supported 1619 * 4: 1.2.3.4 1620 * 6: 0001:0203:...:0708 1621 * 6c: 1::708 or 1::1.2.3.4 1622 */ 1623 case 'i': /* Contiguous: 1624 * 4: 001.002.003.004 1625 * 6: 000102...0f 1626 */ 1627 switch (fmt[1]) { 1628 case '6': 1629 return ip6_addr_string(buf, end, ptr, spec, fmt); 1630 case '4': 1631 return ip4_addr_string(buf, end, ptr, spec, fmt); 1632 case 'S': { 1633 const union { 1634 struct sockaddr raw; 1635 struct sockaddr_in v4; 1636 struct sockaddr_in6 v6; 1637 } *sa = ptr; 1638 1639 switch (sa->raw.sa_family) { 1640 case AF_INET: 1641 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt); 1642 case AF_INET6: 1643 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt); 1644 default: 1645 return string(buf, end, "(invalid address)", spec); 1646 }} 1647 } 1648 break; 1649 case 'E': 1650 return escaped_string(buf, end, ptr, spec, fmt); 1651 case 'U': 1652 return uuid_string(buf, end, ptr, spec, fmt); 1653 case 'V': 1654 { 1655 va_list va; 1656 1657 va_copy(va, *((struct va_format *)ptr)->va); 1658 buf += vsnprintf(buf, end > buf ? end - buf : 0, 1659 ((struct va_format *)ptr)->fmt, va); 1660 va_end(va); 1661 return buf; 1662 } 1663 case 'K': 1664 switch (kptr_restrict) { 1665 case 0: 1666 /* Always print %pK values */ 1667 break; 1668 case 1: { 1669 const struct cred *cred; 1670 1671 /* 1672 * kptr_restrict==1 cannot be used in IRQ context 1673 * because its test for CAP_SYSLOG would be meaningless. 1674 */ 1675 if (in_irq() || in_serving_softirq() || in_nmi()) { 1676 if (spec.field_width == -1) 1677 spec.field_width = default_width; 1678 return string(buf, end, "pK-error", spec); 1679 } 1680 1681 /* 1682 * Only print the real pointer value if the current 1683 * process has CAP_SYSLOG and is running with the 1684 * same credentials it started with. This is because 1685 * access to files is checked at open() time, but %pK 1686 * checks permission at read() time. We don't want to 1687 * leak pointer values if a binary opens a file using 1688 * %pK and then elevates privileges before reading it. 1689 */ 1690 cred = current_cred(); 1691 if (!has_capability_noaudit(current, CAP_SYSLOG) || 1692 !uid_eq(cred->euid, cred->uid) || 1693 !gid_eq(cred->egid, cred->gid)) 1694 ptr = NULL; 1695 break; 1696 } 1697 case 2: 1698 default: 1699 /* Always print 0's for %pK */ 1700 ptr = NULL; 1701 break; 1702 } 1703 break; 1704 1705 case 'N': 1706 return netdev_bits(buf, end, ptr, fmt); 1707 case 'a': 1708 return address_val(buf, end, ptr, fmt); 1709 case 'd': 1710 return dentry_name(buf, end, ptr, spec, fmt); 1711 case 'C': 1712 return clock(buf, end, ptr, spec, fmt); 1713 case 'D': 1714 return dentry_name(buf, end, 1715 ((const struct file *)ptr)->f_path.dentry, 1716 spec, fmt); 1717 #ifdef CONFIG_BLOCK 1718 case 'g': 1719 return bdev_name(buf, end, ptr, spec, fmt); 1720 #endif 1721 1722 case 'G': 1723 return flags_string(buf, end, ptr, fmt); 1724 } 1725 spec.flags |= SMALL; 1726 if (spec.field_width == -1) { 1727 spec.field_width = default_width; 1728 spec.flags |= ZEROPAD; 1729 } 1730 spec.base = 16; 1731 1732 return number(buf, end, (unsigned long) ptr, spec); 1733 } 1734 1735 /* 1736 * Helper function to decode printf style format. 1737 * Each call decode a token from the format and return the 1738 * number of characters read (or likely the delta where it wants 1739 * to go on the next call). 1740 * The decoded token is returned through the parameters 1741 * 1742 * 'h', 'l', or 'L' for integer fields 1743 * 'z' support added 23/7/1999 S.H. 1744 * 'z' changed to 'Z' --davidm 1/25/99 1745 * 'Z' changed to 'z' --adobriyan 2017-01-25 1746 * 't' added for ptrdiff_t 1747 * 1748 * @fmt: the format string 1749 * @type of the token returned 1750 * @flags: various flags such as +, -, # tokens.. 1751 * @field_width: overwritten width 1752 * @base: base of the number (octal, hex, ...) 1753 * @precision: precision of a number 1754 * @qualifier: qualifier of a number (long, size_t, ...) 1755 */ 1756 static noinline_for_stack 1757 int format_decode(const char *fmt, struct printf_spec *spec) 1758 { 1759 const char *start = fmt; 1760 char qualifier; 1761 1762 /* we finished early by reading the field width */ 1763 if (spec->type == FORMAT_TYPE_WIDTH) { 1764 if (spec->field_width < 0) { 1765 spec->field_width = -spec->field_width; 1766 spec->flags |= LEFT; 1767 } 1768 spec->type = FORMAT_TYPE_NONE; 1769 goto precision; 1770 } 1771 1772 /* we finished early by reading the precision */ 1773 if (spec->type == FORMAT_TYPE_PRECISION) { 1774 if (spec->precision < 0) 1775 spec->precision = 0; 1776 1777 spec->type = FORMAT_TYPE_NONE; 1778 goto qualifier; 1779 } 1780 1781 /* By default */ 1782 spec->type = FORMAT_TYPE_NONE; 1783 1784 for (; *fmt ; ++fmt) { 1785 if (*fmt == '%') 1786 break; 1787 } 1788 1789 /* Return the current non-format string */ 1790 if (fmt != start || !*fmt) 1791 return fmt - start; 1792 1793 /* Process flags */ 1794 spec->flags = 0; 1795 1796 while (1) { /* this also skips first '%' */ 1797 bool found = true; 1798 1799 ++fmt; 1800 1801 switch (*fmt) { 1802 case '-': spec->flags |= LEFT; break; 1803 case '+': spec->flags |= PLUS; break; 1804 case ' ': spec->flags |= SPACE; break; 1805 case '#': spec->flags |= SPECIAL; break; 1806 case '0': spec->flags |= ZEROPAD; break; 1807 default: found = false; 1808 } 1809 1810 if (!found) 1811 break; 1812 } 1813 1814 /* get field width */ 1815 spec->field_width = -1; 1816 1817 if (isdigit(*fmt)) 1818 spec->field_width = skip_atoi(&fmt); 1819 else if (*fmt == '*') { 1820 /* it's the next argument */ 1821 spec->type = FORMAT_TYPE_WIDTH; 1822 return ++fmt - start; 1823 } 1824 1825 precision: 1826 /* get the precision */ 1827 spec->precision = -1; 1828 if (*fmt == '.') { 1829 ++fmt; 1830 if (isdigit(*fmt)) { 1831 spec->precision = skip_atoi(&fmt); 1832 if (spec->precision < 0) 1833 spec->precision = 0; 1834 } else if (*fmt == '*') { 1835 /* it's the next argument */ 1836 spec->type = FORMAT_TYPE_PRECISION; 1837 return ++fmt - start; 1838 } 1839 } 1840 1841 qualifier: 1842 /* get the conversion qualifier */ 1843 qualifier = 0; 1844 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 1845 *fmt == 'z' || *fmt == 't') { 1846 qualifier = *fmt++; 1847 if (unlikely(qualifier == *fmt)) { 1848 if (qualifier == 'l') { 1849 qualifier = 'L'; 1850 ++fmt; 1851 } else if (qualifier == 'h') { 1852 qualifier = 'H'; 1853 ++fmt; 1854 } 1855 } 1856 } 1857 1858 /* default base */ 1859 spec->base = 10; 1860 switch (*fmt) { 1861 case 'c': 1862 spec->type = FORMAT_TYPE_CHAR; 1863 return ++fmt - start; 1864 1865 case 's': 1866 spec->type = FORMAT_TYPE_STR; 1867 return ++fmt - start; 1868 1869 case 'p': 1870 spec->type = FORMAT_TYPE_PTR; 1871 return ++fmt - start; 1872 1873 case '%': 1874 spec->type = FORMAT_TYPE_PERCENT_CHAR; 1875 return ++fmt - start; 1876 1877 /* integer number formats - set up the flags and "break" */ 1878 case 'o': 1879 spec->base = 8; 1880 break; 1881 1882 case 'x': 1883 spec->flags |= SMALL; 1884 1885 case 'X': 1886 spec->base = 16; 1887 break; 1888 1889 case 'd': 1890 case 'i': 1891 spec->flags |= SIGN; 1892 case 'u': 1893 break; 1894 1895 case 'n': 1896 /* 1897 * Since %n poses a greater security risk than 1898 * utility, treat it as any other invalid or 1899 * unsupported format specifier. 1900 */ 1901 /* Fall-through */ 1902 1903 default: 1904 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt); 1905 spec->type = FORMAT_TYPE_INVALID; 1906 return fmt - start; 1907 } 1908 1909 if (qualifier == 'L') 1910 spec->type = FORMAT_TYPE_LONG_LONG; 1911 else if (qualifier == 'l') { 1912 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 1913 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 1914 } else if (qualifier == 'z') { 1915 spec->type = FORMAT_TYPE_SIZE_T; 1916 } else if (qualifier == 't') { 1917 spec->type = FORMAT_TYPE_PTRDIFF; 1918 } else if (qualifier == 'H') { 1919 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE); 1920 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN); 1921 } else if (qualifier == 'h') { 1922 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT); 1923 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN); 1924 } else { 1925 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT); 1926 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN); 1927 } 1928 1929 return ++fmt - start; 1930 } 1931 1932 static void 1933 set_field_width(struct printf_spec *spec, int width) 1934 { 1935 spec->field_width = width; 1936 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) { 1937 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX); 1938 } 1939 } 1940 1941 static void 1942 set_precision(struct printf_spec *spec, int prec) 1943 { 1944 spec->precision = prec; 1945 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) { 1946 spec->precision = clamp(prec, 0, PRECISION_MAX); 1947 } 1948 } 1949 1950 /** 1951 * vsnprintf - Format a string and place it in a buffer 1952 * @buf: The buffer to place the result into 1953 * @size: The size of the buffer, including the trailing null space 1954 * @fmt: The format string to use 1955 * @args: Arguments for the format string 1956 * 1957 * This function generally follows C99 vsnprintf, but has some 1958 * extensions and a few limitations: 1959 * 1960 * - ``%n`` is unsupported 1961 * - ``%p*`` is handled by pointer() 1962 * 1963 * See pointer() or Documentation/printk-formats.txt for more 1964 * extensive description. 1965 * 1966 * **Please update the documentation in both places when making changes** 1967 * 1968 * The return value is the number of characters which would 1969 * be generated for the given input, excluding the trailing 1970 * '\0', as per ISO C99. If you want to have the exact 1971 * number of characters written into @buf as return value 1972 * (not including the trailing '\0'), use vscnprintf(). If the 1973 * return is greater than or equal to @size, the resulting 1974 * string is truncated. 1975 * 1976 * If you're not already dealing with a va_list consider using snprintf(). 1977 */ 1978 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 1979 { 1980 unsigned long long num; 1981 char *str, *end; 1982 struct printf_spec spec = {0}; 1983 1984 /* Reject out-of-range values early. Large positive sizes are 1985 used for unknown buffer sizes. */ 1986 if (WARN_ON_ONCE(size > INT_MAX)) 1987 return 0; 1988 1989 str = buf; 1990 end = buf + size; 1991 1992 /* Make sure end is always >= buf */ 1993 if (end < buf) { 1994 end = ((void *)-1); 1995 size = end - buf; 1996 } 1997 1998 while (*fmt) { 1999 const char *old_fmt = fmt; 2000 int read = format_decode(fmt, &spec); 2001 2002 fmt += read; 2003 2004 switch (spec.type) { 2005 case FORMAT_TYPE_NONE: { 2006 int copy = read; 2007 if (str < end) { 2008 if (copy > end - str) 2009 copy = end - str; 2010 memcpy(str, old_fmt, copy); 2011 } 2012 str += read; 2013 break; 2014 } 2015 2016 case FORMAT_TYPE_WIDTH: 2017 set_field_width(&spec, va_arg(args, int)); 2018 break; 2019 2020 case FORMAT_TYPE_PRECISION: 2021 set_precision(&spec, va_arg(args, int)); 2022 break; 2023 2024 case FORMAT_TYPE_CHAR: { 2025 char c; 2026 2027 if (!(spec.flags & LEFT)) { 2028 while (--spec.field_width > 0) { 2029 if (str < end) 2030 *str = ' '; 2031 ++str; 2032 2033 } 2034 } 2035 c = (unsigned char) va_arg(args, int); 2036 if (str < end) 2037 *str = c; 2038 ++str; 2039 while (--spec.field_width > 0) { 2040 if (str < end) 2041 *str = ' '; 2042 ++str; 2043 } 2044 break; 2045 } 2046 2047 case FORMAT_TYPE_STR: 2048 str = string(str, end, va_arg(args, char *), spec); 2049 break; 2050 2051 case FORMAT_TYPE_PTR: 2052 str = pointer(fmt, str, end, va_arg(args, void *), 2053 spec); 2054 while (isalnum(*fmt)) 2055 fmt++; 2056 break; 2057 2058 case FORMAT_TYPE_PERCENT_CHAR: 2059 if (str < end) 2060 *str = '%'; 2061 ++str; 2062 break; 2063 2064 case FORMAT_TYPE_INVALID: 2065 /* 2066 * Presumably the arguments passed gcc's type 2067 * checking, but there is no safe or sane way 2068 * for us to continue parsing the format and 2069 * fetching from the va_list; the remaining 2070 * specifiers and arguments would be out of 2071 * sync. 2072 */ 2073 goto out; 2074 2075 default: 2076 switch (spec.type) { 2077 case FORMAT_TYPE_LONG_LONG: 2078 num = va_arg(args, long long); 2079 break; 2080 case FORMAT_TYPE_ULONG: 2081 num = va_arg(args, unsigned long); 2082 break; 2083 case FORMAT_TYPE_LONG: 2084 num = va_arg(args, long); 2085 break; 2086 case FORMAT_TYPE_SIZE_T: 2087 if (spec.flags & SIGN) 2088 num = va_arg(args, ssize_t); 2089 else 2090 num = va_arg(args, size_t); 2091 break; 2092 case FORMAT_TYPE_PTRDIFF: 2093 num = va_arg(args, ptrdiff_t); 2094 break; 2095 case FORMAT_TYPE_UBYTE: 2096 num = (unsigned char) va_arg(args, int); 2097 break; 2098 case FORMAT_TYPE_BYTE: 2099 num = (signed char) va_arg(args, int); 2100 break; 2101 case FORMAT_TYPE_USHORT: 2102 num = (unsigned short) va_arg(args, int); 2103 break; 2104 case FORMAT_TYPE_SHORT: 2105 num = (short) va_arg(args, int); 2106 break; 2107 case FORMAT_TYPE_INT: 2108 num = (int) va_arg(args, int); 2109 break; 2110 default: 2111 num = va_arg(args, unsigned int); 2112 } 2113 2114 str = number(str, end, num, spec); 2115 } 2116 } 2117 2118 out: 2119 if (size > 0) { 2120 if (str < end) 2121 *str = '\0'; 2122 else 2123 end[-1] = '\0'; 2124 } 2125 2126 /* the trailing null byte doesn't count towards the total */ 2127 return str-buf; 2128 2129 } 2130 EXPORT_SYMBOL(vsnprintf); 2131 2132 /** 2133 * vscnprintf - Format a string and place it in a buffer 2134 * @buf: The buffer to place the result into 2135 * @size: The size of the buffer, including the trailing null space 2136 * @fmt: The format string to use 2137 * @args: Arguments for the format string 2138 * 2139 * The return value is the number of characters which have been written into 2140 * the @buf not including the trailing '\0'. If @size is == 0 the function 2141 * returns 0. 2142 * 2143 * If you're not already dealing with a va_list consider using scnprintf(). 2144 * 2145 * See the vsnprintf() documentation for format string extensions over C99. 2146 */ 2147 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 2148 { 2149 int i; 2150 2151 i = vsnprintf(buf, size, fmt, args); 2152 2153 if (likely(i < size)) 2154 return i; 2155 if (size != 0) 2156 return size - 1; 2157 return 0; 2158 } 2159 EXPORT_SYMBOL(vscnprintf); 2160 2161 /** 2162 * snprintf - Format a string and place it in a buffer 2163 * @buf: The buffer to place the result into 2164 * @size: The size of the buffer, including the trailing null space 2165 * @fmt: The format string to use 2166 * @...: Arguments for the format string 2167 * 2168 * The return value is the number of characters which would be 2169 * generated for the given input, excluding the trailing null, 2170 * as per ISO C99. If the return is greater than or equal to 2171 * @size, the resulting string is truncated. 2172 * 2173 * See the vsnprintf() documentation for format string extensions over C99. 2174 */ 2175 int snprintf(char *buf, size_t size, const char *fmt, ...) 2176 { 2177 va_list args; 2178 int i; 2179 2180 va_start(args, fmt); 2181 i = vsnprintf(buf, size, fmt, args); 2182 va_end(args); 2183 2184 return i; 2185 } 2186 EXPORT_SYMBOL(snprintf); 2187 2188 /** 2189 * scnprintf - Format a string and place it in a buffer 2190 * @buf: The buffer to place the result into 2191 * @size: The size of the buffer, including the trailing null space 2192 * @fmt: The format string to use 2193 * @...: Arguments for the format string 2194 * 2195 * The return value is the number of characters written into @buf not including 2196 * the trailing '\0'. If @size is == 0 the function returns 0. 2197 */ 2198 2199 int scnprintf(char *buf, size_t size, const char *fmt, ...) 2200 { 2201 va_list args; 2202 int i; 2203 2204 va_start(args, fmt); 2205 i = vscnprintf(buf, size, fmt, args); 2206 va_end(args); 2207 2208 return i; 2209 } 2210 EXPORT_SYMBOL(scnprintf); 2211 2212 /** 2213 * vsprintf - Format a string and place it in a buffer 2214 * @buf: The buffer to place the result into 2215 * @fmt: The format string to use 2216 * @args: Arguments for the format string 2217 * 2218 * The function returns the number of characters written 2219 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 2220 * buffer overflows. 2221 * 2222 * If you're not already dealing with a va_list consider using sprintf(). 2223 * 2224 * See the vsnprintf() documentation for format string extensions over C99. 2225 */ 2226 int vsprintf(char *buf, const char *fmt, va_list args) 2227 { 2228 return vsnprintf(buf, INT_MAX, fmt, args); 2229 } 2230 EXPORT_SYMBOL(vsprintf); 2231 2232 /** 2233 * sprintf - Format a string and place it in a buffer 2234 * @buf: The buffer to place the result into 2235 * @fmt: The format string to use 2236 * @...: Arguments for the format string 2237 * 2238 * The function returns the number of characters written 2239 * into @buf. Use snprintf() or scnprintf() in order to avoid 2240 * buffer overflows. 2241 * 2242 * See the vsnprintf() documentation for format string extensions over C99. 2243 */ 2244 int sprintf(char *buf, const char *fmt, ...) 2245 { 2246 va_list args; 2247 int i; 2248 2249 va_start(args, fmt); 2250 i = vsnprintf(buf, INT_MAX, fmt, args); 2251 va_end(args); 2252 2253 return i; 2254 } 2255 EXPORT_SYMBOL(sprintf); 2256 2257 #ifdef CONFIG_BINARY_PRINTF 2258 /* 2259 * bprintf service: 2260 * vbin_printf() - VA arguments to binary data 2261 * bstr_printf() - Binary data to text string 2262 */ 2263 2264 /** 2265 * vbin_printf - Parse a format string and place args' binary value in a buffer 2266 * @bin_buf: The buffer to place args' binary value 2267 * @size: The size of the buffer(by words(32bits), not characters) 2268 * @fmt: The format string to use 2269 * @args: Arguments for the format string 2270 * 2271 * The format follows C99 vsnprintf, except %n is ignored, and its argument 2272 * is skipped. 2273 * 2274 * The return value is the number of words(32bits) which would be generated for 2275 * the given input. 2276 * 2277 * NOTE: 2278 * If the return value is greater than @size, the resulting bin_buf is NOT 2279 * valid for bstr_printf(). 2280 */ 2281 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 2282 { 2283 struct printf_spec spec = {0}; 2284 char *str, *end; 2285 2286 str = (char *)bin_buf; 2287 end = (char *)(bin_buf + size); 2288 2289 #define save_arg(type) \ 2290 do { \ 2291 if (sizeof(type) == 8) { \ 2292 unsigned long long value; \ 2293 str = PTR_ALIGN(str, sizeof(u32)); \ 2294 value = va_arg(args, unsigned long long); \ 2295 if (str + sizeof(type) <= end) { \ 2296 *(u32 *)str = *(u32 *)&value; \ 2297 *(u32 *)(str + 4) = *((u32 *)&value + 1); \ 2298 } \ 2299 } else { \ 2300 unsigned long value; \ 2301 str = PTR_ALIGN(str, sizeof(type)); \ 2302 value = va_arg(args, int); \ 2303 if (str + sizeof(type) <= end) \ 2304 *(typeof(type) *)str = (type)value; \ 2305 } \ 2306 str += sizeof(type); \ 2307 } while (0) 2308 2309 while (*fmt) { 2310 int read = format_decode(fmt, &spec); 2311 2312 fmt += read; 2313 2314 switch (spec.type) { 2315 case FORMAT_TYPE_NONE: 2316 case FORMAT_TYPE_PERCENT_CHAR: 2317 break; 2318 case FORMAT_TYPE_INVALID: 2319 goto out; 2320 2321 case FORMAT_TYPE_WIDTH: 2322 case FORMAT_TYPE_PRECISION: 2323 save_arg(int); 2324 break; 2325 2326 case FORMAT_TYPE_CHAR: 2327 save_arg(char); 2328 break; 2329 2330 case FORMAT_TYPE_STR: { 2331 const char *save_str = va_arg(args, char *); 2332 size_t len; 2333 2334 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 2335 || (unsigned long)save_str < PAGE_SIZE) 2336 save_str = "(null)"; 2337 len = strlen(save_str) + 1; 2338 if (str + len < end) 2339 memcpy(str, save_str, len); 2340 str += len; 2341 break; 2342 } 2343 2344 case FORMAT_TYPE_PTR: 2345 save_arg(void *); 2346 /* skip all alphanumeric pointer suffixes */ 2347 while (isalnum(*fmt)) 2348 fmt++; 2349 break; 2350 2351 default: 2352 switch (spec.type) { 2353 2354 case FORMAT_TYPE_LONG_LONG: 2355 save_arg(long long); 2356 break; 2357 case FORMAT_TYPE_ULONG: 2358 case FORMAT_TYPE_LONG: 2359 save_arg(unsigned long); 2360 break; 2361 case FORMAT_TYPE_SIZE_T: 2362 save_arg(size_t); 2363 break; 2364 case FORMAT_TYPE_PTRDIFF: 2365 save_arg(ptrdiff_t); 2366 break; 2367 case FORMAT_TYPE_UBYTE: 2368 case FORMAT_TYPE_BYTE: 2369 save_arg(char); 2370 break; 2371 case FORMAT_TYPE_USHORT: 2372 case FORMAT_TYPE_SHORT: 2373 save_arg(short); 2374 break; 2375 default: 2376 save_arg(int); 2377 } 2378 } 2379 } 2380 2381 out: 2382 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 2383 #undef save_arg 2384 } 2385 EXPORT_SYMBOL_GPL(vbin_printf); 2386 2387 /** 2388 * bstr_printf - Format a string from binary arguments and place it in a buffer 2389 * @buf: The buffer to place the result into 2390 * @size: The size of the buffer, including the trailing null space 2391 * @fmt: The format string to use 2392 * @bin_buf: Binary arguments for the format string 2393 * 2394 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 2395 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 2396 * a binary buffer that generated by vbin_printf. 2397 * 2398 * The format follows C99 vsnprintf, but has some extensions: 2399 * see vsnprintf comment for details. 2400 * 2401 * The return value is the number of characters which would 2402 * be generated for the given input, excluding the trailing 2403 * '\0', as per ISO C99. If you want to have the exact 2404 * number of characters written into @buf as return value 2405 * (not including the trailing '\0'), use vscnprintf(). If the 2406 * return is greater than or equal to @size, the resulting 2407 * string is truncated. 2408 */ 2409 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 2410 { 2411 struct printf_spec spec = {0}; 2412 char *str, *end; 2413 const char *args = (const char *)bin_buf; 2414 2415 if (WARN_ON_ONCE(size > INT_MAX)) 2416 return 0; 2417 2418 str = buf; 2419 end = buf + size; 2420 2421 #define get_arg(type) \ 2422 ({ \ 2423 typeof(type) value; \ 2424 if (sizeof(type) == 8) { \ 2425 args = PTR_ALIGN(args, sizeof(u32)); \ 2426 *(u32 *)&value = *(u32 *)args; \ 2427 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 2428 } else { \ 2429 args = PTR_ALIGN(args, sizeof(type)); \ 2430 value = *(typeof(type) *)args; \ 2431 } \ 2432 args += sizeof(type); \ 2433 value; \ 2434 }) 2435 2436 /* Make sure end is always >= buf */ 2437 if (end < buf) { 2438 end = ((void *)-1); 2439 size = end - buf; 2440 } 2441 2442 while (*fmt) { 2443 const char *old_fmt = fmt; 2444 int read = format_decode(fmt, &spec); 2445 2446 fmt += read; 2447 2448 switch (spec.type) { 2449 case FORMAT_TYPE_NONE: { 2450 int copy = read; 2451 if (str < end) { 2452 if (copy > end - str) 2453 copy = end - str; 2454 memcpy(str, old_fmt, copy); 2455 } 2456 str += read; 2457 break; 2458 } 2459 2460 case FORMAT_TYPE_WIDTH: 2461 set_field_width(&spec, get_arg(int)); 2462 break; 2463 2464 case FORMAT_TYPE_PRECISION: 2465 set_precision(&spec, get_arg(int)); 2466 break; 2467 2468 case FORMAT_TYPE_CHAR: { 2469 char c; 2470 2471 if (!(spec.flags & LEFT)) { 2472 while (--spec.field_width > 0) { 2473 if (str < end) 2474 *str = ' '; 2475 ++str; 2476 } 2477 } 2478 c = (unsigned char) get_arg(char); 2479 if (str < end) 2480 *str = c; 2481 ++str; 2482 while (--spec.field_width > 0) { 2483 if (str < end) 2484 *str = ' '; 2485 ++str; 2486 } 2487 break; 2488 } 2489 2490 case FORMAT_TYPE_STR: { 2491 const char *str_arg = args; 2492 args += strlen(str_arg) + 1; 2493 str = string(str, end, (char *)str_arg, spec); 2494 break; 2495 } 2496 2497 case FORMAT_TYPE_PTR: 2498 str = pointer(fmt, str, end, get_arg(void *), spec); 2499 while (isalnum(*fmt)) 2500 fmt++; 2501 break; 2502 2503 case FORMAT_TYPE_PERCENT_CHAR: 2504 if (str < end) 2505 *str = '%'; 2506 ++str; 2507 break; 2508 2509 case FORMAT_TYPE_INVALID: 2510 goto out; 2511 2512 default: { 2513 unsigned long long num; 2514 2515 switch (spec.type) { 2516 2517 case FORMAT_TYPE_LONG_LONG: 2518 num = get_arg(long long); 2519 break; 2520 case FORMAT_TYPE_ULONG: 2521 case FORMAT_TYPE_LONG: 2522 num = get_arg(unsigned long); 2523 break; 2524 case FORMAT_TYPE_SIZE_T: 2525 num = get_arg(size_t); 2526 break; 2527 case FORMAT_TYPE_PTRDIFF: 2528 num = get_arg(ptrdiff_t); 2529 break; 2530 case FORMAT_TYPE_UBYTE: 2531 num = get_arg(unsigned char); 2532 break; 2533 case FORMAT_TYPE_BYTE: 2534 num = get_arg(signed char); 2535 break; 2536 case FORMAT_TYPE_USHORT: 2537 num = get_arg(unsigned short); 2538 break; 2539 case FORMAT_TYPE_SHORT: 2540 num = get_arg(short); 2541 break; 2542 case FORMAT_TYPE_UINT: 2543 num = get_arg(unsigned int); 2544 break; 2545 default: 2546 num = get_arg(int); 2547 } 2548 2549 str = number(str, end, num, spec); 2550 } /* default: */ 2551 } /* switch(spec.type) */ 2552 } /* while(*fmt) */ 2553 2554 out: 2555 if (size > 0) { 2556 if (str < end) 2557 *str = '\0'; 2558 else 2559 end[-1] = '\0'; 2560 } 2561 2562 #undef get_arg 2563 2564 /* the trailing null byte doesn't count towards the total */ 2565 return str - buf; 2566 } 2567 EXPORT_SYMBOL_GPL(bstr_printf); 2568 2569 /** 2570 * bprintf - Parse a format string and place args' binary value in a buffer 2571 * @bin_buf: The buffer to place args' binary value 2572 * @size: The size of the buffer(by words(32bits), not characters) 2573 * @fmt: The format string to use 2574 * @...: Arguments for the format string 2575 * 2576 * The function returns the number of words(u32) written 2577 * into @bin_buf. 2578 */ 2579 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 2580 { 2581 va_list args; 2582 int ret; 2583 2584 va_start(args, fmt); 2585 ret = vbin_printf(bin_buf, size, fmt, args); 2586 va_end(args); 2587 2588 return ret; 2589 } 2590 EXPORT_SYMBOL_GPL(bprintf); 2591 2592 #endif /* CONFIG_BINARY_PRINTF */ 2593 2594 /** 2595 * vsscanf - Unformat a buffer into a list of arguments 2596 * @buf: input buffer 2597 * @fmt: format of buffer 2598 * @args: arguments 2599 */ 2600 int vsscanf(const char *buf, const char *fmt, va_list args) 2601 { 2602 const char *str = buf; 2603 char *next; 2604 char digit; 2605 int num = 0; 2606 u8 qualifier; 2607 unsigned int base; 2608 union { 2609 long long s; 2610 unsigned long long u; 2611 } val; 2612 s16 field_width; 2613 bool is_sign; 2614 2615 while (*fmt) { 2616 /* skip any white space in format */ 2617 /* white space in format matchs any amount of 2618 * white space, including none, in the input. 2619 */ 2620 if (isspace(*fmt)) { 2621 fmt = skip_spaces(++fmt); 2622 str = skip_spaces(str); 2623 } 2624 2625 /* anything that is not a conversion must match exactly */ 2626 if (*fmt != '%' && *fmt) { 2627 if (*fmt++ != *str++) 2628 break; 2629 continue; 2630 } 2631 2632 if (!*fmt) 2633 break; 2634 ++fmt; 2635 2636 /* skip this conversion. 2637 * advance both strings to next white space 2638 */ 2639 if (*fmt == '*') { 2640 if (!*str) 2641 break; 2642 while (!isspace(*fmt) && *fmt != '%' && *fmt) { 2643 /* '%*[' not yet supported, invalid format */ 2644 if (*fmt == '[') 2645 return num; 2646 fmt++; 2647 } 2648 while (!isspace(*str) && *str) 2649 str++; 2650 continue; 2651 } 2652 2653 /* get field width */ 2654 field_width = -1; 2655 if (isdigit(*fmt)) { 2656 field_width = skip_atoi(&fmt); 2657 if (field_width <= 0) 2658 break; 2659 } 2660 2661 /* get conversion qualifier */ 2662 qualifier = -1; 2663 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2664 *fmt == 'z') { 2665 qualifier = *fmt++; 2666 if (unlikely(qualifier == *fmt)) { 2667 if (qualifier == 'h') { 2668 qualifier = 'H'; 2669 fmt++; 2670 } else if (qualifier == 'l') { 2671 qualifier = 'L'; 2672 fmt++; 2673 } 2674 } 2675 } 2676 2677 if (!*fmt) 2678 break; 2679 2680 if (*fmt == 'n') { 2681 /* return number of characters read so far */ 2682 *va_arg(args, int *) = str - buf; 2683 ++fmt; 2684 continue; 2685 } 2686 2687 if (!*str) 2688 break; 2689 2690 base = 10; 2691 is_sign = false; 2692 2693 switch (*fmt++) { 2694 case 'c': 2695 { 2696 char *s = (char *)va_arg(args, char*); 2697 if (field_width == -1) 2698 field_width = 1; 2699 do { 2700 *s++ = *str++; 2701 } while (--field_width > 0 && *str); 2702 num++; 2703 } 2704 continue; 2705 case 's': 2706 { 2707 char *s = (char *)va_arg(args, char *); 2708 if (field_width == -1) 2709 field_width = SHRT_MAX; 2710 /* first, skip leading white space in buffer */ 2711 str = skip_spaces(str); 2712 2713 /* now copy until next white space */ 2714 while (*str && !isspace(*str) && field_width--) 2715 *s++ = *str++; 2716 *s = '\0'; 2717 num++; 2718 } 2719 continue; 2720 /* 2721 * Warning: This implementation of the '[' conversion specifier 2722 * deviates from its glibc counterpart in the following ways: 2723 * (1) It does NOT support ranges i.e. '-' is NOT a special 2724 * character 2725 * (2) It cannot match the closing bracket ']' itself 2726 * (3) A field width is required 2727 * (4) '%*[' (discard matching input) is currently not supported 2728 * 2729 * Example usage: 2730 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]", 2731 * buf1, buf2, buf3); 2732 * if (ret < 3) 2733 * // etc.. 2734 */ 2735 case '[': 2736 { 2737 char *s = (char *)va_arg(args, char *); 2738 DECLARE_BITMAP(set, 256) = {0}; 2739 unsigned int len = 0; 2740 bool negate = (*fmt == '^'); 2741 2742 /* field width is required */ 2743 if (field_width == -1) 2744 return num; 2745 2746 if (negate) 2747 ++fmt; 2748 2749 for ( ; *fmt && *fmt != ']'; ++fmt, ++len) 2750 set_bit((u8)*fmt, set); 2751 2752 /* no ']' or no character set found */ 2753 if (!*fmt || !len) 2754 return num; 2755 ++fmt; 2756 2757 if (negate) { 2758 bitmap_complement(set, set, 256); 2759 /* exclude null '\0' byte */ 2760 clear_bit(0, set); 2761 } 2762 2763 /* match must be non-empty */ 2764 if (!test_bit((u8)*str, set)) 2765 return num; 2766 2767 while (test_bit((u8)*str, set) && field_width--) 2768 *s++ = *str++; 2769 *s = '\0'; 2770 ++num; 2771 } 2772 continue; 2773 case 'o': 2774 base = 8; 2775 break; 2776 case 'x': 2777 case 'X': 2778 base = 16; 2779 break; 2780 case 'i': 2781 base = 0; 2782 case 'd': 2783 is_sign = true; 2784 case 'u': 2785 break; 2786 case '%': 2787 /* looking for '%' in str */ 2788 if (*str++ != '%') 2789 return num; 2790 continue; 2791 default: 2792 /* invalid format; stop here */ 2793 return num; 2794 } 2795 2796 /* have some sort of integer conversion. 2797 * first, skip white space in buffer. 2798 */ 2799 str = skip_spaces(str); 2800 2801 digit = *str; 2802 if (is_sign && digit == '-') 2803 digit = *(str + 1); 2804 2805 if (!digit 2806 || (base == 16 && !isxdigit(digit)) 2807 || (base == 10 && !isdigit(digit)) 2808 || (base == 8 && (!isdigit(digit) || digit > '7')) 2809 || (base == 0 && !isdigit(digit))) 2810 break; 2811 2812 if (is_sign) 2813 val.s = qualifier != 'L' ? 2814 simple_strtol(str, &next, base) : 2815 simple_strtoll(str, &next, base); 2816 else 2817 val.u = qualifier != 'L' ? 2818 simple_strtoul(str, &next, base) : 2819 simple_strtoull(str, &next, base); 2820 2821 if (field_width > 0 && next - str > field_width) { 2822 if (base == 0) 2823 _parse_integer_fixup_radix(str, &base); 2824 while (next - str > field_width) { 2825 if (is_sign) 2826 val.s = div_s64(val.s, base); 2827 else 2828 val.u = div_u64(val.u, base); 2829 --next; 2830 } 2831 } 2832 2833 switch (qualifier) { 2834 case 'H': /* that's 'hh' in format */ 2835 if (is_sign) 2836 *va_arg(args, signed char *) = val.s; 2837 else 2838 *va_arg(args, unsigned char *) = val.u; 2839 break; 2840 case 'h': 2841 if (is_sign) 2842 *va_arg(args, short *) = val.s; 2843 else 2844 *va_arg(args, unsigned short *) = val.u; 2845 break; 2846 case 'l': 2847 if (is_sign) 2848 *va_arg(args, long *) = val.s; 2849 else 2850 *va_arg(args, unsigned long *) = val.u; 2851 break; 2852 case 'L': 2853 if (is_sign) 2854 *va_arg(args, long long *) = val.s; 2855 else 2856 *va_arg(args, unsigned long long *) = val.u; 2857 break; 2858 case 'z': 2859 *va_arg(args, size_t *) = val.u; 2860 break; 2861 default: 2862 if (is_sign) 2863 *va_arg(args, int *) = val.s; 2864 else 2865 *va_arg(args, unsigned int *) = val.u; 2866 break; 2867 } 2868 num++; 2869 2870 if (!next) 2871 break; 2872 str = next; 2873 } 2874 2875 return num; 2876 } 2877 EXPORT_SYMBOL(vsscanf); 2878 2879 /** 2880 * sscanf - Unformat a buffer into a list of arguments 2881 * @buf: input buffer 2882 * @fmt: formatting of buffer 2883 * @...: resulting arguments 2884 */ 2885 int sscanf(const char *buf, const char *fmt, ...) 2886 { 2887 va_list args; 2888 int i; 2889 2890 va_start(args, fmt); 2891 i = vsscanf(buf, fmt, args); 2892 va_end(args); 2893 2894 return i; 2895 } 2896 EXPORT_SYMBOL(sscanf); 2897