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