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