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