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 static noinline_for_stack 873 char *file_dentry_name(char *buf, char *end, const struct file *f, 874 struct printf_spec spec, const char *fmt) 875 { 876 if (check_pointer(&buf, end, f, spec)) 877 return buf; 878 879 return dentry_name(buf, end, f->f_path.dentry, spec, fmt); 880 } 881 #ifdef CONFIG_BLOCK 882 static noinline_for_stack 883 char *bdev_name(char *buf, char *end, struct block_device *bdev, 884 struct printf_spec spec, const char *fmt) 885 { 886 struct gendisk *hd; 887 888 if (check_pointer(&buf, end, bdev, spec)) 889 return buf; 890 891 hd = bdev->bd_disk; 892 buf = string(buf, end, hd->disk_name, spec); 893 if (bdev->bd_part->partno) { 894 if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) { 895 if (buf < end) 896 *buf = 'p'; 897 buf++; 898 } 899 buf = number(buf, end, bdev->bd_part->partno, spec); 900 } 901 return buf; 902 } 903 #endif 904 905 static noinline_for_stack 906 char *symbol_string(char *buf, char *end, void *ptr, 907 struct printf_spec spec, const char *fmt) 908 { 909 unsigned long value; 910 #ifdef CONFIG_KALLSYMS 911 char sym[KSYM_SYMBOL_LEN]; 912 #endif 913 914 if (fmt[1] == 'R') 915 ptr = __builtin_extract_return_addr(ptr); 916 value = (unsigned long)ptr; 917 918 #ifdef CONFIG_KALLSYMS 919 if (*fmt == 'B') 920 sprint_backtrace(sym, value); 921 else if (*fmt != 'f' && *fmt != 's') 922 sprint_symbol(sym, value); 923 else 924 sprint_symbol_no_offset(sym, value); 925 926 return string_nocheck(buf, end, sym, spec); 927 #else 928 return special_hex_number(buf, end, value, sizeof(void *)); 929 #endif 930 } 931 932 static const struct printf_spec default_str_spec = { 933 .field_width = -1, 934 .precision = -1, 935 }; 936 937 static const struct printf_spec default_flag_spec = { 938 .base = 16, 939 .precision = -1, 940 .flags = SPECIAL | SMALL, 941 }; 942 943 static const struct printf_spec default_dec_spec = { 944 .base = 10, 945 .precision = -1, 946 }; 947 948 static const struct printf_spec default_dec02_spec = { 949 .base = 10, 950 .field_width = 2, 951 .precision = -1, 952 .flags = ZEROPAD, 953 }; 954 955 static const struct printf_spec default_dec04_spec = { 956 .base = 10, 957 .field_width = 4, 958 .precision = -1, 959 .flags = ZEROPAD, 960 }; 961 962 static noinline_for_stack 963 char *resource_string(char *buf, char *end, struct resource *res, 964 struct printf_spec spec, const char *fmt) 965 { 966 #ifndef IO_RSRC_PRINTK_SIZE 967 #define IO_RSRC_PRINTK_SIZE 6 968 #endif 969 970 #ifndef MEM_RSRC_PRINTK_SIZE 971 #define MEM_RSRC_PRINTK_SIZE 10 972 #endif 973 static const struct printf_spec io_spec = { 974 .base = 16, 975 .field_width = IO_RSRC_PRINTK_SIZE, 976 .precision = -1, 977 .flags = SPECIAL | SMALL | ZEROPAD, 978 }; 979 static const struct printf_spec mem_spec = { 980 .base = 16, 981 .field_width = MEM_RSRC_PRINTK_SIZE, 982 .precision = -1, 983 .flags = SPECIAL | SMALL | ZEROPAD, 984 }; 985 static const struct printf_spec bus_spec = { 986 .base = 16, 987 .field_width = 2, 988 .precision = -1, 989 .flags = SMALL | ZEROPAD, 990 }; 991 static const struct printf_spec str_spec = { 992 .field_width = -1, 993 .precision = 10, 994 .flags = LEFT, 995 }; 996 997 /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8) 998 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */ 999 #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4) 1000 #define FLAG_BUF_SIZE (2 * sizeof(res->flags)) 1001 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]") 1002 #define RAW_BUF_SIZE sizeof("[mem - flags 0x]") 1003 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, 1004 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)]; 1005 1006 char *p = sym, *pend = sym + sizeof(sym); 1007 int decode = (fmt[0] == 'R') ? 1 : 0; 1008 const struct printf_spec *specp; 1009 1010 if (check_pointer(&buf, end, res, spec)) 1011 return buf; 1012 1013 *p++ = '['; 1014 if (res->flags & IORESOURCE_IO) { 1015 p = string_nocheck(p, pend, "io ", str_spec); 1016 specp = &io_spec; 1017 } else if (res->flags & IORESOURCE_MEM) { 1018 p = string_nocheck(p, pend, "mem ", str_spec); 1019 specp = &mem_spec; 1020 } else if (res->flags & IORESOURCE_IRQ) { 1021 p = string_nocheck(p, pend, "irq ", str_spec); 1022 specp = &default_dec_spec; 1023 } else if (res->flags & IORESOURCE_DMA) { 1024 p = string_nocheck(p, pend, "dma ", str_spec); 1025 specp = &default_dec_spec; 1026 } else if (res->flags & IORESOURCE_BUS) { 1027 p = string_nocheck(p, pend, "bus ", str_spec); 1028 specp = &bus_spec; 1029 } else { 1030 p = string_nocheck(p, pend, "??? ", str_spec); 1031 specp = &mem_spec; 1032 decode = 0; 1033 } 1034 if (decode && res->flags & IORESOURCE_UNSET) { 1035 p = string_nocheck(p, pend, "size ", str_spec); 1036 p = number(p, pend, resource_size(res), *specp); 1037 } else { 1038 p = number(p, pend, res->start, *specp); 1039 if (res->start != res->end) { 1040 *p++ = '-'; 1041 p = number(p, pend, res->end, *specp); 1042 } 1043 } 1044 if (decode) { 1045 if (res->flags & IORESOURCE_MEM_64) 1046 p = string_nocheck(p, pend, " 64bit", str_spec); 1047 if (res->flags & IORESOURCE_PREFETCH) 1048 p = string_nocheck(p, pend, " pref", str_spec); 1049 if (res->flags & IORESOURCE_WINDOW) 1050 p = string_nocheck(p, pend, " window", str_spec); 1051 if (res->flags & IORESOURCE_DISABLED) 1052 p = string_nocheck(p, pend, " disabled", str_spec); 1053 } else { 1054 p = string_nocheck(p, pend, " flags ", str_spec); 1055 p = number(p, pend, res->flags, default_flag_spec); 1056 } 1057 *p++ = ']'; 1058 *p = '\0'; 1059 1060 return string_nocheck(buf, end, sym, spec); 1061 } 1062 1063 static noinline_for_stack 1064 char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec, 1065 const char *fmt) 1066 { 1067 int i, len = 1; /* if we pass '%ph[CDN]', field width remains 1068 negative value, fallback to the default */ 1069 char separator; 1070 1071 if (spec.field_width == 0) 1072 /* nothing to print */ 1073 return buf; 1074 1075 if (check_pointer(&buf, end, addr, spec)) 1076 return buf; 1077 1078 switch (fmt[1]) { 1079 case 'C': 1080 separator = ':'; 1081 break; 1082 case 'D': 1083 separator = '-'; 1084 break; 1085 case 'N': 1086 separator = 0; 1087 break; 1088 default: 1089 separator = ' '; 1090 break; 1091 } 1092 1093 if (spec.field_width > 0) 1094 len = min_t(int, spec.field_width, 64); 1095 1096 for (i = 0; i < len; ++i) { 1097 if (buf < end) 1098 *buf = hex_asc_hi(addr[i]); 1099 ++buf; 1100 if (buf < end) 1101 *buf = hex_asc_lo(addr[i]); 1102 ++buf; 1103 1104 if (separator && i != len - 1) { 1105 if (buf < end) 1106 *buf = separator; 1107 ++buf; 1108 } 1109 } 1110 1111 return buf; 1112 } 1113 1114 static noinline_for_stack 1115 char *bitmap_string(char *buf, char *end, unsigned long *bitmap, 1116 struct printf_spec spec, const char *fmt) 1117 { 1118 const int CHUNKSZ = 32; 1119 int nr_bits = max_t(int, spec.field_width, 0); 1120 int i, chunksz; 1121 bool first = true; 1122 1123 if (check_pointer(&buf, end, bitmap, spec)) 1124 return buf; 1125 1126 /* reused to print numbers */ 1127 spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 }; 1128 1129 chunksz = nr_bits & (CHUNKSZ - 1); 1130 if (chunksz == 0) 1131 chunksz = CHUNKSZ; 1132 1133 i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ; 1134 for (; i >= 0; i -= CHUNKSZ) { 1135 u32 chunkmask, val; 1136 int word, bit; 1137 1138 chunkmask = ((1ULL << chunksz) - 1); 1139 word = i / BITS_PER_LONG; 1140 bit = i % BITS_PER_LONG; 1141 val = (bitmap[word] >> bit) & chunkmask; 1142 1143 if (!first) { 1144 if (buf < end) 1145 *buf = ','; 1146 buf++; 1147 } 1148 first = false; 1149 1150 spec.field_width = DIV_ROUND_UP(chunksz, 4); 1151 buf = number(buf, end, val, spec); 1152 1153 chunksz = CHUNKSZ; 1154 } 1155 return buf; 1156 } 1157 1158 static noinline_for_stack 1159 char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap, 1160 struct printf_spec spec, const char *fmt) 1161 { 1162 int nr_bits = max_t(int, spec.field_width, 0); 1163 /* current bit is 'cur', most recently seen range is [rbot, rtop] */ 1164 int cur, rbot, rtop; 1165 bool first = true; 1166 1167 if (check_pointer(&buf, end, bitmap, spec)) 1168 return buf; 1169 1170 rbot = cur = find_first_bit(bitmap, nr_bits); 1171 while (cur < nr_bits) { 1172 rtop = cur; 1173 cur = find_next_bit(bitmap, nr_bits, cur + 1); 1174 if (cur < nr_bits && cur <= rtop + 1) 1175 continue; 1176 1177 if (!first) { 1178 if (buf < end) 1179 *buf = ','; 1180 buf++; 1181 } 1182 first = false; 1183 1184 buf = number(buf, end, rbot, default_dec_spec); 1185 if (rbot < rtop) { 1186 if (buf < end) 1187 *buf = '-'; 1188 buf++; 1189 1190 buf = number(buf, end, rtop, default_dec_spec); 1191 } 1192 1193 rbot = cur; 1194 } 1195 return buf; 1196 } 1197 1198 static noinline_for_stack 1199 char *mac_address_string(char *buf, char *end, u8 *addr, 1200 struct printf_spec spec, const char *fmt) 1201 { 1202 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")]; 1203 char *p = mac_addr; 1204 int i; 1205 char separator; 1206 bool reversed = false; 1207 1208 if (check_pointer(&buf, end, addr, spec)) 1209 return buf; 1210 1211 switch (fmt[1]) { 1212 case 'F': 1213 separator = '-'; 1214 break; 1215 1216 case 'R': 1217 reversed = true; 1218 /* fall through */ 1219 1220 default: 1221 separator = ':'; 1222 break; 1223 } 1224 1225 for (i = 0; i < 6; i++) { 1226 if (reversed) 1227 p = hex_byte_pack(p, addr[5 - i]); 1228 else 1229 p = hex_byte_pack(p, addr[i]); 1230 1231 if (fmt[0] == 'M' && i != 5) 1232 *p++ = separator; 1233 } 1234 *p = '\0'; 1235 1236 return string_nocheck(buf, end, mac_addr, spec); 1237 } 1238 1239 static noinline_for_stack 1240 char *ip4_string(char *p, const u8 *addr, const char *fmt) 1241 { 1242 int i; 1243 bool leading_zeros = (fmt[0] == 'i'); 1244 int index; 1245 int step; 1246 1247 switch (fmt[2]) { 1248 case 'h': 1249 #ifdef __BIG_ENDIAN 1250 index = 0; 1251 step = 1; 1252 #else 1253 index = 3; 1254 step = -1; 1255 #endif 1256 break; 1257 case 'l': 1258 index = 3; 1259 step = -1; 1260 break; 1261 case 'n': 1262 case 'b': 1263 default: 1264 index = 0; 1265 step = 1; 1266 break; 1267 } 1268 for (i = 0; i < 4; i++) { 1269 char temp[4] __aligned(2); /* hold each IP quad in reverse order */ 1270 int digits = put_dec_trunc8(temp, addr[index]) - temp; 1271 if (leading_zeros) { 1272 if (digits < 3) 1273 *p++ = '0'; 1274 if (digits < 2) 1275 *p++ = '0'; 1276 } 1277 /* reverse the digits in the quad */ 1278 while (digits--) 1279 *p++ = temp[digits]; 1280 if (i < 3) 1281 *p++ = '.'; 1282 index += step; 1283 } 1284 *p = '\0'; 1285 1286 return p; 1287 } 1288 1289 static noinline_for_stack 1290 char *ip6_compressed_string(char *p, const char *addr) 1291 { 1292 int i, j, range; 1293 unsigned char zerolength[8]; 1294 int longest = 1; 1295 int colonpos = -1; 1296 u16 word; 1297 u8 hi, lo; 1298 bool needcolon = false; 1299 bool useIPv4; 1300 struct in6_addr in6; 1301 1302 memcpy(&in6, addr, sizeof(struct in6_addr)); 1303 1304 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 1305 1306 memset(zerolength, 0, sizeof(zerolength)); 1307 1308 if (useIPv4) 1309 range = 6; 1310 else 1311 range = 8; 1312 1313 /* find position of longest 0 run */ 1314 for (i = 0; i < range; i++) { 1315 for (j = i; j < range; j++) { 1316 if (in6.s6_addr16[j] != 0) 1317 break; 1318 zerolength[i]++; 1319 } 1320 } 1321 for (i = 0; i < range; i++) { 1322 if (zerolength[i] > longest) { 1323 longest = zerolength[i]; 1324 colonpos = i; 1325 } 1326 } 1327 if (longest == 1) /* don't compress a single 0 */ 1328 colonpos = -1; 1329 1330 /* emit address */ 1331 for (i = 0; i < range; i++) { 1332 if (i == colonpos) { 1333 if (needcolon || i == 0) 1334 *p++ = ':'; 1335 *p++ = ':'; 1336 needcolon = false; 1337 i += longest - 1; 1338 continue; 1339 } 1340 if (needcolon) { 1341 *p++ = ':'; 1342 needcolon = false; 1343 } 1344 /* hex u16 without leading 0s */ 1345 word = ntohs(in6.s6_addr16[i]); 1346 hi = word >> 8; 1347 lo = word & 0xff; 1348 if (hi) { 1349 if (hi > 0x0f) 1350 p = hex_byte_pack(p, hi); 1351 else 1352 *p++ = hex_asc_lo(hi); 1353 p = hex_byte_pack(p, lo); 1354 } 1355 else if (lo > 0x0f) 1356 p = hex_byte_pack(p, lo); 1357 else 1358 *p++ = hex_asc_lo(lo); 1359 needcolon = true; 1360 } 1361 1362 if (useIPv4) { 1363 if (needcolon) 1364 *p++ = ':'; 1365 p = ip4_string(p, &in6.s6_addr[12], "I4"); 1366 } 1367 *p = '\0'; 1368 1369 return p; 1370 } 1371 1372 static noinline_for_stack 1373 char *ip6_string(char *p, const char *addr, const char *fmt) 1374 { 1375 int i; 1376 1377 for (i = 0; i < 8; i++) { 1378 p = hex_byte_pack(p, *addr++); 1379 p = hex_byte_pack(p, *addr++); 1380 if (fmt[0] == 'I' && i != 7) 1381 *p++ = ':'; 1382 } 1383 *p = '\0'; 1384 1385 return p; 1386 } 1387 1388 static noinline_for_stack 1389 char *ip6_addr_string(char *buf, char *end, const u8 *addr, 1390 struct printf_spec spec, const char *fmt) 1391 { 1392 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 1393 1394 if (fmt[0] == 'I' && fmt[2] == 'c') 1395 ip6_compressed_string(ip6_addr, addr); 1396 else 1397 ip6_string(ip6_addr, addr, fmt); 1398 1399 return string_nocheck(buf, end, ip6_addr, spec); 1400 } 1401 1402 static noinline_for_stack 1403 char *ip4_addr_string(char *buf, char *end, const u8 *addr, 1404 struct printf_spec spec, const char *fmt) 1405 { 1406 char ip4_addr[sizeof("255.255.255.255")]; 1407 1408 ip4_string(ip4_addr, addr, fmt); 1409 1410 return string_nocheck(buf, end, ip4_addr, spec); 1411 } 1412 1413 static noinline_for_stack 1414 char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa, 1415 struct printf_spec spec, const char *fmt) 1416 { 1417 bool have_p = false, have_s = false, have_f = false, have_c = false; 1418 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") + 1419 sizeof(":12345") + sizeof("/123456789") + 1420 sizeof("%1234567890")]; 1421 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr); 1422 const u8 *addr = (const u8 *) &sa->sin6_addr; 1423 char fmt6[2] = { fmt[0], '6' }; 1424 u8 off = 0; 1425 1426 fmt++; 1427 while (isalpha(*++fmt)) { 1428 switch (*fmt) { 1429 case 'p': 1430 have_p = true; 1431 break; 1432 case 'f': 1433 have_f = true; 1434 break; 1435 case 's': 1436 have_s = true; 1437 break; 1438 case 'c': 1439 have_c = true; 1440 break; 1441 } 1442 } 1443 1444 if (have_p || have_s || have_f) { 1445 *p = '['; 1446 off = 1; 1447 } 1448 1449 if (fmt6[0] == 'I' && have_c) 1450 p = ip6_compressed_string(ip6_addr + off, addr); 1451 else 1452 p = ip6_string(ip6_addr + off, addr, fmt6); 1453 1454 if (have_p || have_s || have_f) 1455 *p++ = ']'; 1456 1457 if (have_p) { 1458 *p++ = ':'; 1459 p = number(p, pend, ntohs(sa->sin6_port), spec); 1460 } 1461 if (have_f) { 1462 *p++ = '/'; 1463 p = number(p, pend, ntohl(sa->sin6_flowinfo & 1464 IPV6_FLOWINFO_MASK), spec); 1465 } 1466 if (have_s) { 1467 *p++ = '%'; 1468 p = number(p, pend, sa->sin6_scope_id, spec); 1469 } 1470 *p = '\0'; 1471 1472 return string_nocheck(buf, end, ip6_addr, spec); 1473 } 1474 1475 static noinline_for_stack 1476 char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa, 1477 struct printf_spec spec, const char *fmt) 1478 { 1479 bool have_p = false; 1480 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")]; 1481 char *pend = ip4_addr + sizeof(ip4_addr); 1482 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr; 1483 char fmt4[3] = { fmt[0], '4', 0 }; 1484 1485 fmt++; 1486 while (isalpha(*++fmt)) { 1487 switch (*fmt) { 1488 case 'p': 1489 have_p = true; 1490 break; 1491 case 'h': 1492 case 'l': 1493 case 'n': 1494 case 'b': 1495 fmt4[2] = *fmt; 1496 break; 1497 } 1498 } 1499 1500 p = ip4_string(ip4_addr, addr, fmt4); 1501 if (have_p) { 1502 *p++ = ':'; 1503 p = number(p, pend, ntohs(sa->sin_port), spec); 1504 } 1505 *p = '\0'; 1506 1507 return string_nocheck(buf, end, ip4_addr, spec); 1508 } 1509 1510 static noinline_for_stack 1511 char *ip_addr_string(char *buf, char *end, const void *ptr, 1512 struct printf_spec spec, const char *fmt) 1513 { 1514 char *err_fmt_msg; 1515 1516 if (check_pointer(&buf, end, ptr, spec)) 1517 return buf; 1518 1519 switch (fmt[1]) { 1520 case '6': 1521 return ip6_addr_string(buf, end, ptr, spec, fmt); 1522 case '4': 1523 return ip4_addr_string(buf, end, ptr, spec, fmt); 1524 case 'S': { 1525 const union { 1526 struct sockaddr raw; 1527 struct sockaddr_in v4; 1528 struct sockaddr_in6 v6; 1529 } *sa = ptr; 1530 1531 switch (sa->raw.sa_family) { 1532 case AF_INET: 1533 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt); 1534 case AF_INET6: 1535 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt); 1536 default: 1537 return error_string(buf, end, "(einval)", spec); 1538 }} 1539 } 1540 1541 err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)"; 1542 return error_string(buf, end, err_fmt_msg, spec); 1543 } 1544 1545 static noinline_for_stack 1546 char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec, 1547 const char *fmt) 1548 { 1549 bool found = true; 1550 int count = 1; 1551 unsigned int flags = 0; 1552 int len; 1553 1554 if (spec.field_width == 0) 1555 return buf; /* nothing to print */ 1556 1557 if (check_pointer(&buf, end, addr, spec)) 1558 return buf; 1559 1560 do { 1561 switch (fmt[count++]) { 1562 case 'a': 1563 flags |= ESCAPE_ANY; 1564 break; 1565 case 'c': 1566 flags |= ESCAPE_SPECIAL; 1567 break; 1568 case 'h': 1569 flags |= ESCAPE_HEX; 1570 break; 1571 case 'n': 1572 flags |= ESCAPE_NULL; 1573 break; 1574 case 'o': 1575 flags |= ESCAPE_OCTAL; 1576 break; 1577 case 'p': 1578 flags |= ESCAPE_NP; 1579 break; 1580 case 's': 1581 flags |= ESCAPE_SPACE; 1582 break; 1583 default: 1584 found = false; 1585 break; 1586 } 1587 } while (found); 1588 1589 if (!flags) 1590 flags = ESCAPE_ANY_NP; 1591 1592 len = spec.field_width < 0 ? 1 : spec.field_width; 1593 1594 /* 1595 * string_escape_mem() writes as many characters as it can to 1596 * the given buffer, and returns the total size of the output 1597 * had the buffer been big enough. 1598 */ 1599 buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL); 1600 1601 return buf; 1602 } 1603 1604 static char *va_format(char *buf, char *end, struct va_format *va_fmt, 1605 struct printf_spec spec, const char *fmt) 1606 { 1607 va_list va; 1608 1609 if (check_pointer(&buf, end, va_fmt, spec)) 1610 return buf; 1611 1612 va_copy(va, *va_fmt->va); 1613 buf += vsnprintf(buf, end > buf ? end - buf : 0, va_fmt->fmt, va); 1614 va_end(va); 1615 1616 return buf; 1617 } 1618 1619 static noinline_for_stack 1620 char *uuid_string(char *buf, char *end, const u8 *addr, 1621 struct printf_spec spec, const char *fmt) 1622 { 1623 char uuid[UUID_STRING_LEN + 1]; 1624 char *p = uuid; 1625 int i; 1626 const u8 *index = uuid_index; 1627 bool uc = false; 1628 1629 if (check_pointer(&buf, end, addr, spec)) 1630 return buf; 1631 1632 switch (*(++fmt)) { 1633 case 'L': 1634 uc = true; /* fall-through */ 1635 case 'l': 1636 index = guid_index; 1637 break; 1638 case 'B': 1639 uc = true; 1640 break; 1641 } 1642 1643 for (i = 0; i < 16; i++) { 1644 if (uc) 1645 p = hex_byte_pack_upper(p, addr[index[i]]); 1646 else 1647 p = hex_byte_pack(p, addr[index[i]]); 1648 switch (i) { 1649 case 3: 1650 case 5: 1651 case 7: 1652 case 9: 1653 *p++ = '-'; 1654 break; 1655 } 1656 } 1657 1658 *p = 0; 1659 1660 return string_nocheck(buf, end, uuid, spec); 1661 } 1662 1663 static noinline_for_stack 1664 char *netdev_bits(char *buf, char *end, const void *addr, 1665 struct printf_spec spec, const char *fmt) 1666 { 1667 unsigned long long num; 1668 int size; 1669 1670 if (check_pointer(&buf, end, addr, spec)) 1671 return buf; 1672 1673 switch (fmt[1]) { 1674 case 'F': 1675 num = *(const netdev_features_t *)addr; 1676 size = sizeof(netdev_features_t); 1677 break; 1678 default: 1679 return error_string(buf, end, "(%pN?)", spec); 1680 } 1681 1682 return special_hex_number(buf, end, num, size); 1683 } 1684 1685 static noinline_for_stack 1686 char *address_val(char *buf, char *end, const void *addr, 1687 struct printf_spec spec, const char *fmt) 1688 { 1689 unsigned long long num; 1690 int size; 1691 1692 if (check_pointer(&buf, end, addr, spec)) 1693 return buf; 1694 1695 switch (fmt[1]) { 1696 case 'd': 1697 num = *(const dma_addr_t *)addr; 1698 size = sizeof(dma_addr_t); 1699 break; 1700 case 'p': 1701 default: 1702 num = *(const phys_addr_t *)addr; 1703 size = sizeof(phys_addr_t); 1704 break; 1705 } 1706 1707 return special_hex_number(buf, end, num, size); 1708 } 1709 1710 static noinline_for_stack 1711 char *date_str(char *buf, char *end, const struct rtc_time *tm, bool r) 1712 { 1713 int year = tm->tm_year + (r ? 0 : 1900); 1714 int mon = tm->tm_mon + (r ? 0 : 1); 1715 1716 buf = number(buf, end, year, default_dec04_spec); 1717 if (buf < end) 1718 *buf = '-'; 1719 buf++; 1720 1721 buf = number(buf, end, mon, default_dec02_spec); 1722 if (buf < end) 1723 *buf = '-'; 1724 buf++; 1725 1726 return number(buf, end, tm->tm_mday, default_dec02_spec); 1727 } 1728 1729 static noinline_for_stack 1730 char *time_str(char *buf, char *end, const struct rtc_time *tm, bool r) 1731 { 1732 buf = number(buf, end, tm->tm_hour, default_dec02_spec); 1733 if (buf < end) 1734 *buf = ':'; 1735 buf++; 1736 1737 buf = number(buf, end, tm->tm_min, default_dec02_spec); 1738 if (buf < end) 1739 *buf = ':'; 1740 buf++; 1741 1742 return number(buf, end, tm->tm_sec, default_dec02_spec); 1743 } 1744 1745 static noinline_for_stack 1746 char *rtc_str(char *buf, char *end, const struct rtc_time *tm, 1747 struct printf_spec spec, const char *fmt) 1748 { 1749 bool have_t = true, have_d = true; 1750 bool raw = false; 1751 int count = 2; 1752 1753 if (check_pointer(&buf, end, tm, spec)) 1754 return buf; 1755 1756 switch (fmt[count]) { 1757 case 'd': 1758 have_t = false; 1759 count++; 1760 break; 1761 case 't': 1762 have_d = false; 1763 count++; 1764 break; 1765 } 1766 1767 raw = fmt[count] == 'r'; 1768 1769 if (have_d) 1770 buf = date_str(buf, end, tm, raw); 1771 if (have_d && have_t) { 1772 /* Respect ISO 8601 */ 1773 if (buf < end) 1774 *buf = 'T'; 1775 buf++; 1776 } 1777 if (have_t) 1778 buf = time_str(buf, end, tm, raw); 1779 1780 return buf; 1781 } 1782 1783 static noinline_for_stack 1784 char *time_and_date(char *buf, char *end, void *ptr, struct printf_spec spec, 1785 const char *fmt) 1786 { 1787 switch (fmt[1]) { 1788 case 'R': 1789 return rtc_str(buf, end, (const struct rtc_time *)ptr, spec, fmt); 1790 default: 1791 return error_string(buf, end, "(%ptR?)", spec); 1792 } 1793 } 1794 1795 static noinline_for_stack 1796 char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec, 1797 const char *fmt) 1798 { 1799 if (!IS_ENABLED(CONFIG_HAVE_CLK)) 1800 return error_string(buf, end, "(%pC?)", spec); 1801 1802 if (check_pointer(&buf, end, clk, spec)) 1803 return buf; 1804 1805 switch (fmt[1]) { 1806 case 'n': 1807 default: 1808 #ifdef CONFIG_COMMON_CLK 1809 return string(buf, end, __clk_get_name(clk), spec); 1810 #else 1811 return ptr_to_id(buf, end, clk, spec); 1812 #endif 1813 } 1814 } 1815 1816 static 1817 char *format_flags(char *buf, char *end, unsigned long flags, 1818 const struct trace_print_flags *names) 1819 { 1820 unsigned long mask; 1821 1822 for ( ; flags && names->name; names++) { 1823 mask = names->mask; 1824 if ((flags & mask) != mask) 1825 continue; 1826 1827 buf = string(buf, end, names->name, default_str_spec); 1828 1829 flags &= ~mask; 1830 if (flags) { 1831 if (buf < end) 1832 *buf = '|'; 1833 buf++; 1834 } 1835 } 1836 1837 if (flags) 1838 buf = number(buf, end, flags, default_flag_spec); 1839 1840 return buf; 1841 } 1842 1843 static noinline_for_stack 1844 char *flags_string(char *buf, char *end, void *flags_ptr, 1845 struct printf_spec spec, const char *fmt) 1846 { 1847 unsigned long flags; 1848 const struct trace_print_flags *names; 1849 1850 if (check_pointer(&buf, end, flags_ptr, spec)) 1851 return buf; 1852 1853 switch (fmt[1]) { 1854 case 'p': 1855 flags = *(unsigned long *)flags_ptr; 1856 /* Remove zone id */ 1857 flags &= (1UL << NR_PAGEFLAGS) - 1; 1858 names = pageflag_names; 1859 break; 1860 case 'v': 1861 flags = *(unsigned long *)flags_ptr; 1862 names = vmaflag_names; 1863 break; 1864 case 'g': 1865 flags = *(gfp_t *)flags_ptr; 1866 names = gfpflag_names; 1867 break; 1868 default: 1869 return error_string(buf, end, "(%pG?)", spec); 1870 } 1871 1872 return format_flags(buf, end, flags, names); 1873 } 1874 1875 static const char *device_node_name_for_depth(const struct device_node *np, int depth) 1876 { 1877 for ( ; np && depth; depth--) 1878 np = np->parent; 1879 1880 return kbasename(np->full_name); 1881 } 1882 1883 static noinline_for_stack 1884 char *device_node_gen_full_name(const struct device_node *np, char *buf, char *end) 1885 { 1886 int depth; 1887 const struct device_node *parent = np->parent; 1888 1889 /* special case for root node */ 1890 if (!parent) 1891 return string_nocheck(buf, end, "/", default_str_spec); 1892 1893 for (depth = 0; parent->parent; depth++) 1894 parent = parent->parent; 1895 1896 for ( ; depth >= 0; depth--) { 1897 buf = string_nocheck(buf, end, "/", default_str_spec); 1898 buf = string(buf, end, device_node_name_for_depth(np, depth), 1899 default_str_spec); 1900 } 1901 return buf; 1902 } 1903 1904 static noinline_for_stack 1905 char *device_node_string(char *buf, char *end, struct device_node *dn, 1906 struct printf_spec spec, const char *fmt) 1907 { 1908 char tbuf[sizeof("xxxx") + 1]; 1909 const char *p; 1910 int ret; 1911 char *buf_start = buf; 1912 struct property *prop; 1913 bool has_mult, pass; 1914 static const struct printf_spec num_spec = { 1915 .flags = SMALL, 1916 .field_width = -1, 1917 .precision = -1, 1918 .base = 10, 1919 }; 1920 1921 struct printf_spec str_spec = spec; 1922 str_spec.field_width = -1; 1923 1924 if (!IS_ENABLED(CONFIG_OF)) 1925 return error_string(buf, end, "(%pOF?)", spec); 1926 1927 if (check_pointer(&buf, end, dn, spec)) 1928 return buf; 1929 1930 /* simple case without anything any more format specifiers */ 1931 fmt++; 1932 if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0) 1933 fmt = "f"; 1934 1935 for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) { 1936 int precision; 1937 if (pass) { 1938 if (buf < end) 1939 *buf = ':'; 1940 buf++; 1941 } 1942 1943 switch (*fmt) { 1944 case 'f': /* full_name */ 1945 buf = device_node_gen_full_name(dn, buf, end); 1946 break; 1947 case 'n': /* name */ 1948 p = kbasename(of_node_full_name(dn)); 1949 precision = str_spec.precision; 1950 str_spec.precision = strchrnul(p, '@') - p; 1951 buf = string(buf, end, p, str_spec); 1952 str_spec.precision = precision; 1953 break; 1954 case 'p': /* phandle */ 1955 buf = number(buf, end, (unsigned int)dn->phandle, num_spec); 1956 break; 1957 case 'P': /* path-spec */ 1958 p = kbasename(of_node_full_name(dn)); 1959 if (!p[1]) 1960 p = "/"; 1961 buf = string(buf, end, p, str_spec); 1962 break; 1963 case 'F': /* flags */ 1964 tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; 1965 tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-'; 1966 tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-'; 1967 tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-'; 1968 tbuf[4] = 0; 1969 buf = string_nocheck(buf, end, tbuf, str_spec); 1970 break; 1971 case 'c': /* major compatible string */ 1972 ret = of_property_read_string(dn, "compatible", &p); 1973 if (!ret) 1974 buf = string(buf, end, p, str_spec); 1975 break; 1976 case 'C': /* full compatible string */ 1977 has_mult = false; 1978 of_property_for_each_string(dn, "compatible", prop, p) { 1979 if (has_mult) 1980 buf = string_nocheck(buf, end, ",", str_spec); 1981 buf = string_nocheck(buf, end, "\"", str_spec); 1982 buf = string(buf, end, p, str_spec); 1983 buf = string_nocheck(buf, end, "\"", str_spec); 1984 1985 has_mult = true; 1986 } 1987 break; 1988 default: 1989 break; 1990 } 1991 } 1992 1993 return widen_string(buf, buf - buf_start, end, spec); 1994 } 1995 1996 static char *kobject_string(char *buf, char *end, void *ptr, 1997 struct printf_spec spec, const char *fmt) 1998 { 1999 switch (fmt[1]) { 2000 case 'F': 2001 return device_node_string(buf, end, ptr, spec, fmt + 1); 2002 } 2003 2004 return error_string(buf, end, "(%pO?)", spec); 2005 } 2006 2007 /* 2008 * Show a '%p' thing. A kernel extension is that the '%p' is followed 2009 * by an extra set of alphanumeric characters that are extended format 2010 * specifiers. 2011 * 2012 * Please update scripts/checkpatch.pl when adding/removing conversion 2013 * characters. (Search for "check for vsprintf extension"). 2014 * 2015 * Right now we handle: 2016 * 2017 * - 'S' For symbolic direct pointers (or function descriptors) with offset 2018 * - 's' For symbolic direct pointers (or function descriptors) without offset 2019 * - 'F' Same as 'S' 2020 * - 'f' Same as 's' 2021 * - '[FfSs]R' as above with __builtin_extract_return_addr() translation 2022 * - 'B' For backtraced symbolic direct pointers with offset 2023 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 2024 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 2025 * - 'b[l]' For a bitmap, the number of bits is determined by the field 2026 * width which must be explicitly specified either as part of the 2027 * format string '%32b[l]' or through '%*b[l]', [l] selects 2028 * range-list format instead of hex format 2029 * - 'M' For a 6-byte MAC address, it prints the address in the 2030 * usual colon-separated hex notation 2031 * - 'm' For a 6-byte MAC address, it prints the hex address without colons 2032 * - 'MF' For a 6-byte MAC FDDI address, it prints the address 2033 * with a dash-separated hex notation 2034 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth) 2035 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 2036 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 2037 * IPv6 uses colon separated network-order 16 bit hex with leading 0's 2038 * [S][pfs] 2039 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 2040 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 2041 * - 'i' [46] for 'raw' IPv4/IPv6 addresses 2042 * IPv6 omits the colons (01020304...0f) 2043 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 2044 * [S][pfs] 2045 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 2046 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 2047 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order 2048 * - 'I[6S]c' for IPv6 addresses printed as specified by 2049 * http://tools.ietf.org/html/rfc5952 2050 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination 2051 * of the following flags (see string_escape_mem() for the 2052 * details): 2053 * a - ESCAPE_ANY 2054 * c - ESCAPE_SPECIAL 2055 * h - ESCAPE_HEX 2056 * n - ESCAPE_NULL 2057 * o - ESCAPE_OCTAL 2058 * p - ESCAPE_NP 2059 * s - ESCAPE_SPACE 2060 * By default ESCAPE_ANY_NP is used. 2061 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 2062 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 2063 * Options for %pU are: 2064 * b big endian lower case hex (default) 2065 * B big endian UPPER case hex 2066 * l little endian lower case hex 2067 * L little endian UPPER case hex 2068 * big endian output byte order is: 2069 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 2070 * little endian output byte order is: 2071 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 2072 * - 'V' For a struct va_format which contains a format string * and va_list *, 2073 * call vsnprintf(->format, *->va_list). 2074 * Implements a "recursive vsnprintf". 2075 * Do not use this feature without some mechanism to verify the 2076 * correctness of the format string and va_list arguments. 2077 * - 'K' For a kernel pointer that should be hidden from unprivileged users 2078 * - 'NF' For a netdev_features_t 2079 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with 2080 * a certain separator (' ' by default): 2081 * C colon 2082 * D dash 2083 * N no separator 2084 * The maximum supported length is 64 bytes of the input. Consider 2085 * to use print_hex_dump() for the larger input. 2086 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives 2087 * (default assumed to be phys_addr_t, passed by reference) 2088 * - 'd[234]' For a dentry name (optionally 2-4 last components) 2089 * - 'D[234]' Same as 'd' but for a struct file 2090 * - 'g' For block_device name (gendisk + partition number) 2091 * - 't[R][dt][r]' For time and date as represented: 2092 * R struct rtc_time 2093 * - 'C' For a clock, it prints the name (Common Clock Framework) or address 2094 * (legacy clock framework) of the clock 2095 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address 2096 * (legacy clock framework) of the clock 2097 * - 'G' For flags to be printed as a collection of symbolic strings that would 2098 * construct the specific value. Supported flags given by option: 2099 * p page flags (see struct page) given as pointer to unsigned long 2100 * g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t 2101 * v vma flags (VM_*) given as pointer to unsigned long 2102 * - 'OF[fnpPcCF]' For a device tree object 2103 * Without any optional arguments prints the full_name 2104 * f device node full_name 2105 * n device node name 2106 * p device node phandle 2107 * P device node path spec (name + @unit) 2108 * F device node flags 2109 * c major compatible string 2110 * C full compatible string 2111 * - 'x' For printing the address. Equivalent to "%lx". 2112 * 2113 * ** When making changes please also update: 2114 * Documentation/core-api/printk-formats.rst 2115 * 2116 * Note: The default behaviour (unadorned %p) is to hash the address, 2117 * rendering it useful as a unique identifier. 2118 */ 2119 static noinline_for_stack 2120 char *pointer(const char *fmt, char *buf, char *end, void *ptr, 2121 struct printf_spec spec) 2122 { 2123 switch (*fmt) { 2124 case 'F': 2125 case 'f': 2126 case 'S': 2127 case 's': 2128 ptr = dereference_symbol_descriptor(ptr); 2129 /* Fallthrough */ 2130 case 'B': 2131 return symbol_string(buf, end, ptr, spec, fmt); 2132 case 'R': 2133 case 'r': 2134 return resource_string(buf, end, ptr, spec, fmt); 2135 case 'h': 2136 return hex_string(buf, end, ptr, spec, fmt); 2137 case 'b': 2138 switch (fmt[1]) { 2139 case 'l': 2140 return bitmap_list_string(buf, end, ptr, spec, fmt); 2141 default: 2142 return bitmap_string(buf, end, ptr, spec, fmt); 2143 } 2144 case 'M': /* Colon separated: 00:01:02:03:04:05 */ 2145 case 'm': /* Contiguous: 000102030405 */ 2146 /* [mM]F (FDDI) */ 2147 /* [mM]R (Reverse order; Bluetooth) */ 2148 return mac_address_string(buf, end, ptr, spec, fmt); 2149 case 'I': /* Formatted IP supported 2150 * 4: 1.2.3.4 2151 * 6: 0001:0203:...:0708 2152 * 6c: 1::708 or 1::1.2.3.4 2153 */ 2154 case 'i': /* Contiguous: 2155 * 4: 001.002.003.004 2156 * 6: 000102...0f 2157 */ 2158 return ip_addr_string(buf, end, ptr, spec, fmt); 2159 case 'E': 2160 return escaped_string(buf, end, ptr, spec, fmt); 2161 case 'U': 2162 return uuid_string(buf, end, ptr, spec, fmt); 2163 case 'V': 2164 return va_format(buf, end, ptr, spec, fmt); 2165 case 'K': 2166 return restricted_pointer(buf, end, ptr, spec); 2167 case 'N': 2168 return netdev_bits(buf, end, ptr, spec, fmt); 2169 case 'a': 2170 return address_val(buf, end, ptr, spec, fmt); 2171 case 'd': 2172 return dentry_name(buf, end, ptr, spec, fmt); 2173 case 't': 2174 return time_and_date(buf, end, ptr, spec, fmt); 2175 case 'C': 2176 return clock(buf, end, ptr, spec, fmt); 2177 case 'D': 2178 return file_dentry_name(buf, end, ptr, spec, fmt); 2179 #ifdef CONFIG_BLOCK 2180 case 'g': 2181 return bdev_name(buf, end, ptr, spec, fmt); 2182 #endif 2183 2184 case 'G': 2185 return flags_string(buf, end, ptr, spec, fmt); 2186 case 'O': 2187 return kobject_string(buf, end, ptr, spec, fmt); 2188 case 'x': 2189 return pointer_string(buf, end, ptr, spec); 2190 } 2191 2192 /* default is to _not_ leak addresses, hash before printing */ 2193 return ptr_to_id(buf, end, ptr, spec); 2194 } 2195 2196 /* 2197 * Helper function to decode printf style format. 2198 * Each call decode a token from the format and return the 2199 * number of characters read (or likely the delta where it wants 2200 * to go on the next call). 2201 * The decoded token is returned through the parameters 2202 * 2203 * 'h', 'l', or 'L' for integer fields 2204 * 'z' support added 23/7/1999 S.H. 2205 * 'z' changed to 'Z' --davidm 1/25/99 2206 * 'Z' changed to 'z' --adobriyan 2017-01-25 2207 * 't' added for ptrdiff_t 2208 * 2209 * @fmt: the format string 2210 * @type of the token returned 2211 * @flags: various flags such as +, -, # tokens.. 2212 * @field_width: overwritten width 2213 * @base: base of the number (octal, hex, ...) 2214 * @precision: precision of a number 2215 * @qualifier: qualifier of a number (long, size_t, ...) 2216 */ 2217 static noinline_for_stack 2218 int format_decode(const char *fmt, struct printf_spec *spec) 2219 { 2220 const char *start = fmt; 2221 char qualifier; 2222 2223 /* we finished early by reading the field width */ 2224 if (spec->type == FORMAT_TYPE_WIDTH) { 2225 if (spec->field_width < 0) { 2226 spec->field_width = -spec->field_width; 2227 spec->flags |= LEFT; 2228 } 2229 spec->type = FORMAT_TYPE_NONE; 2230 goto precision; 2231 } 2232 2233 /* we finished early by reading the precision */ 2234 if (spec->type == FORMAT_TYPE_PRECISION) { 2235 if (spec->precision < 0) 2236 spec->precision = 0; 2237 2238 spec->type = FORMAT_TYPE_NONE; 2239 goto qualifier; 2240 } 2241 2242 /* By default */ 2243 spec->type = FORMAT_TYPE_NONE; 2244 2245 for (; *fmt ; ++fmt) { 2246 if (*fmt == '%') 2247 break; 2248 } 2249 2250 /* Return the current non-format string */ 2251 if (fmt != start || !*fmt) 2252 return fmt - start; 2253 2254 /* Process flags */ 2255 spec->flags = 0; 2256 2257 while (1) { /* this also skips first '%' */ 2258 bool found = true; 2259 2260 ++fmt; 2261 2262 switch (*fmt) { 2263 case '-': spec->flags |= LEFT; break; 2264 case '+': spec->flags |= PLUS; break; 2265 case ' ': spec->flags |= SPACE; break; 2266 case '#': spec->flags |= SPECIAL; break; 2267 case '0': spec->flags |= ZEROPAD; break; 2268 default: found = false; 2269 } 2270 2271 if (!found) 2272 break; 2273 } 2274 2275 /* get field width */ 2276 spec->field_width = -1; 2277 2278 if (isdigit(*fmt)) 2279 spec->field_width = skip_atoi(&fmt); 2280 else if (*fmt == '*') { 2281 /* it's the next argument */ 2282 spec->type = FORMAT_TYPE_WIDTH; 2283 return ++fmt - start; 2284 } 2285 2286 precision: 2287 /* get the precision */ 2288 spec->precision = -1; 2289 if (*fmt == '.') { 2290 ++fmt; 2291 if (isdigit(*fmt)) { 2292 spec->precision = skip_atoi(&fmt); 2293 if (spec->precision < 0) 2294 spec->precision = 0; 2295 } else if (*fmt == '*') { 2296 /* it's the next argument */ 2297 spec->type = FORMAT_TYPE_PRECISION; 2298 return ++fmt - start; 2299 } 2300 } 2301 2302 qualifier: 2303 /* get the conversion qualifier */ 2304 qualifier = 0; 2305 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2306 *fmt == 'z' || *fmt == 't') { 2307 qualifier = *fmt++; 2308 if (unlikely(qualifier == *fmt)) { 2309 if (qualifier == 'l') { 2310 qualifier = 'L'; 2311 ++fmt; 2312 } else if (qualifier == 'h') { 2313 qualifier = 'H'; 2314 ++fmt; 2315 } 2316 } 2317 } 2318 2319 /* default base */ 2320 spec->base = 10; 2321 switch (*fmt) { 2322 case 'c': 2323 spec->type = FORMAT_TYPE_CHAR; 2324 return ++fmt - start; 2325 2326 case 's': 2327 spec->type = FORMAT_TYPE_STR; 2328 return ++fmt - start; 2329 2330 case 'p': 2331 spec->type = FORMAT_TYPE_PTR; 2332 return ++fmt - start; 2333 2334 case '%': 2335 spec->type = FORMAT_TYPE_PERCENT_CHAR; 2336 return ++fmt - start; 2337 2338 /* integer number formats - set up the flags and "break" */ 2339 case 'o': 2340 spec->base = 8; 2341 break; 2342 2343 case 'x': 2344 spec->flags |= SMALL; 2345 /* fall through */ 2346 2347 case 'X': 2348 spec->base = 16; 2349 break; 2350 2351 case 'd': 2352 case 'i': 2353 spec->flags |= SIGN; 2354 case 'u': 2355 break; 2356 2357 case 'n': 2358 /* 2359 * Since %n poses a greater security risk than 2360 * utility, treat it as any other invalid or 2361 * unsupported format specifier. 2362 */ 2363 /* Fall-through */ 2364 2365 default: 2366 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt); 2367 spec->type = FORMAT_TYPE_INVALID; 2368 return fmt - start; 2369 } 2370 2371 if (qualifier == 'L') 2372 spec->type = FORMAT_TYPE_LONG_LONG; 2373 else if (qualifier == 'l') { 2374 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 2375 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 2376 } else if (qualifier == 'z') { 2377 spec->type = FORMAT_TYPE_SIZE_T; 2378 } else if (qualifier == 't') { 2379 spec->type = FORMAT_TYPE_PTRDIFF; 2380 } else if (qualifier == 'H') { 2381 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE); 2382 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN); 2383 } else if (qualifier == 'h') { 2384 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT); 2385 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN); 2386 } else { 2387 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT); 2388 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN); 2389 } 2390 2391 return ++fmt - start; 2392 } 2393 2394 static void 2395 set_field_width(struct printf_spec *spec, int width) 2396 { 2397 spec->field_width = width; 2398 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) { 2399 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX); 2400 } 2401 } 2402 2403 static void 2404 set_precision(struct printf_spec *spec, int prec) 2405 { 2406 spec->precision = prec; 2407 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) { 2408 spec->precision = clamp(prec, 0, PRECISION_MAX); 2409 } 2410 } 2411 2412 /** 2413 * vsnprintf - Format a string and place it in a buffer 2414 * @buf: The buffer to place the result into 2415 * @size: The size of the buffer, including the trailing null space 2416 * @fmt: The format string to use 2417 * @args: Arguments for the format string 2418 * 2419 * This function generally follows C99 vsnprintf, but has some 2420 * extensions and a few limitations: 2421 * 2422 * - ``%n`` is unsupported 2423 * - ``%p*`` is handled by pointer() 2424 * 2425 * See pointer() or Documentation/core-api/printk-formats.rst for more 2426 * extensive description. 2427 * 2428 * **Please update the documentation in both places when making changes** 2429 * 2430 * The return value is the number of characters which would 2431 * be generated for the given input, excluding the trailing 2432 * '\0', as per ISO C99. If you want to have the exact 2433 * number of characters written into @buf as return value 2434 * (not including the trailing '\0'), use vscnprintf(). If the 2435 * return is greater than or equal to @size, the resulting 2436 * string is truncated. 2437 * 2438 * If you're not already dealing with a va_list consider using snprintf(). 2439 */ 2440 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 2441 { 2442 unsigned long long num; 2443 char *str, *end; 2444 struct printf_spec spec = {0}; 2445 2446 /* Reject out-of-range values early. Large positive sizes are 2447 used for unknown buffer sizes. */ 2448 if (WARN_ON_ONCE(size > INT_MAX)) 2449 return 0; 2450 2451 str = buf; 2452 end = buf + size; 2453 2454 /* Make sure end is always >= buf */ 2455 if (end < buf) { 2456 end = ((void *)-1); 2457 size = end - buf; 2458 } 2459 2460 while (*fmt) { 2461 const char *old_fmt = fmt; 2462 int read = format_decode(fmt, &spec); 2463 2464 fmt += read; 2465 2466 switch (spec.type) { 2467 case FORMAT_TYPE_NONE: { 2468 int copy = read; 2469 if (str < end) { 2470 if (copy > end - str) 2471 copy = end - str; 2472 memcpy(str, old_fmt, copy); 2473 } 2474 str += read; 2475 break; 2476 } 2477 2478 case FORMAT_TYPE_WIDTH: 2479 set_field_width(&spec, va_arg(args, int)); 2480 break; 2481 2482 case FORMAT_TYPE_PRECISION: 2483 set_precision(&spec, va_arg(args, int)); 2484 break; 2485 2486 case FORMAT_TYPE_CHAR: { 2487 char c; 2488 2489 if (!(spec.flags & LEFT)) { 2490 while (--spec.field_width > 0) { 2491 if (str < end) 2492 *str = ' '; 2493 ++str; 2494 2495 } 2496 } 2497 c = (unsigned char) va_arg(args, int); 2498 if (str < end) 2499 *str = c; 2500 ++str; 2501 while (--spec.field_width > 0) { 2502 if (str < end) 2503 *str = ' '; 2504 ++str; 2505 } 2506 break; 2507 } 2508 2509 case FORMAT_TYPE_STR: 2510 str = string(str, end, va_arg(args, char *), spec); 2511 break; 2512 2513 case FORMAT_TYPE_PTR: 2514 str = pointer(fmt, str, end, va_arg(args, void *), 2515 spec); 2516 while (isalnum(*fmt)) 2517 fmt++; 2518 break; 2519 2520 case FORMAT_TYPE_PERCENT_CHAR: 2521 if (str < end) 2522 *str = '%'; 2523 ++str; 2524 break; 2525 2526 case FORMAT_TYPE_INVALID: 2527 /* 2528 * Presumably the arguments passed gcc's type 2529 * checking, but there is no safe or sane way 2530 * for us to continue parsing the format and 2531 * fetching from the va_list; the remaining 2532 * specifiers and arguments would be out of 2533 * sync. 2534 */ 2535 goto out; 2536 2537 default: 2538 switch (spec.type) { 2539 case FORMAT_TYPE_LONG_LONG: 2540 num = va_arg(args, long long); 2541 break; 2542 case FORMAT_TYPE_ULONG: 2543 num = va_arg(args, unsigned long); 2544 break; 2545 case FORMAT_TYPE_LONG: 2546 num = va_arg(args, long); 2547 break; 2548 case FORMAT_TYPE_SIZE_T: 2549 if (spec.flags & SIGN) 2550 num = va_arg(args, ssize_t); 2551 else 2552 num = va_arg(args, size_t); 2553 break; 2554 case FORMAT_TYPE_PTRDIFF: 2555 num = va_arg(args, ptrdiff_t); 2556 break; 2557 case FORMAT_TYPE_UBYTE: 2558 num = (unsigned char) va_arg(args, int); 2559 break; 2560 case FORMAT_TYPE_BYTE: 2561 num = (signed char) va_arg(args, int); 2562 break; 2563 case FORMAT_TYPE_USHORT: 2564 num = (unsigned short) va_arg(args, int); 2565 break; 2566 case FORMAT_TYPE_SHORT: 2567 num = (short) va_arg(args, int); 2568 break; 2569 case FORMAT_TYPE_INT: 2570 num = (int) va_arg(args, int); 2571 break; 2572 default: 2573 num = va_arg(args, unsigned int); 2574 } 2575 2576 str = number(str, end, num, spec); 2577 } 2578 } 2579 2580 out: 2581 if (size > 0) { 2582 if (str < end) 2583 *str = '\0'; 2584 else 2585 end[-1] = '\0'; 2586 } 2587 2588 /* the trailing null byte doesn't count towards the total */ 2589 return str-buf; 2590 2591 } 2592 EXPORT_SYMBOL(vsnprintf); 2593 2594 /** 2595 * vscnprintf - Format a string and place it in a buffer 2596 * @buf: The buffer to place the result into 2597 * @size: The size of the buffer, including the trailing null space 2598 * @fmt: The format string to use 2599 * @args: Arguments for the format string 2600 * 2601 * The return value is the number of characters which have been written into 2602 * the @buf not including the trailing '\0'. If @size is == 0 the function 2603 * returns 0. 2604 * 2605 * If you're not already dealing with a va_list consider using scnprintf(). 2606 * 2607 * See the vsnprintf() documentation for format string extensions over C99. 2608 */ 2609 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 2610 { 2611 int i; 2612 2613 i = vsnprintf(buf, size, fmt, args); 2614 2615 if (likely(i < size)) 2616 return i; 2617 if (size != 0) 2618 return size - 1; 2619 return 0; 2620 } 2621 EXPORT_SYMBOL(vscnprintf); 2622 2623 /** 2624 * snprintf - Format a string and place it in a buffer 2625 * @buf: The buffer to place the result into 2626 * @size: The size of the buffer, including the trailing null space 2627 * @fmt: The format string to use 2628 * @...: Arguments for the format string 2629 * 2630 * The return value is the number of characters which would be 2631 * generated for the given input, excluding the trailing null, 2632 * as per ISO C99. If the return is greater than or equal to 2633 * @size, the resulting string is truncated. 2634 * 2635 * See the vsnprintf() documentation for format string extensions over C99. 2636 */ 2637 int snprintf(char *buf, size_t size, const char *fmt, ...) 2638 { 2639 va_list args; 2640 int i; 2641 2642 va_start(args, fmt); 2643 i = vsnprintf(buf, size, fmt, args); 2644 va_end(args); 2645 2646 return i; 2647 } 2648 EXPORT_SYMBOL(snprintf); 2649 2650 /** 2651 * scnprintf - Format a string and place it in a buffer 2652 * @buf: The buffer to place the result into 2653 * @size: The size of the buffer, including the trailing null space 2654 * @fmt: The format string to use 2655 * @...: Arguments for the format string 2656 * 2657 * The return value is the number of characters written into @buf not including 2658 * the trailing '\0'. If @size is == 0 the function returns 0. 2659 */ 2660 2661 int scnprintf(char *buf, size_t size, const char *fmt, ...) 2662 { 2663 va_list args; 2664 int i; 2665 2666 va_start(args, fmt); 2667 i = vscnprintf(buf, size, fmt, args); 2668 va_end(args); 2669 2670 return i; 2671 } 2672 EXPORT_SYMBOL(scnprintf); 2673 2674 /** 2675 * vsprintf - Format a string and place it in a buffer 2676 * @buf: The buffer to place the result into 2677 * @fmt: The format string to use 2678 * @args: Arguments for the format string 2679 * 2680 * The function returns the number of characters written 2681 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 2682 * buffer overflows. 2683 * 2684 * If you're not already dealing with a va_list consider using sprintf(). 2685 * 2686 * See the vsnprintf() documentation for format string extensions over C99. 2687 */ 2688 int vsprintf(char *buf, const char *fmt, va_list args) 2689 { 2690 return vsnprintf(buf, INT_MAX, fmt, args); 2691 } 2692 EXPORT_SYMBOL(vsprintf); 2693 2694 /** 2695 * sprintf - Format a string and place it in a buffer 2696 * @buf: The buffer to place the result into 2697 * @fmt: The format string to use 2698 * @...: Arguments for the format string 2699 * 2700 * The function returns the number of characters written 2701 * into @buf. Use snprintf() or scnprintf() in order to avoid 2702 * buffer overflows. 2703 * 2704 * See the vsnprintf() documentation for format string extensions over C99. 2705 */ 2706 int sprintf(char *buf, const char *fmt, ...) 2707 { 2708 va_list args; 2709 int i; 2710 2711 va_start(args, fmt); 2712 i = vsnprintf(buf, INT_MAX, fmt, args); 2713 va_end(args); 2714 2715 return i; 2716 } 2717 EXPORT_SYMBOL(sprintf); 2718 2719 #ifdef CONFIG_BINARY_PRINTF 2720 /* 2721 * bprintf service: 2722 * vbin_printf() - VA arguments to binary data 2723 * bstr_printf() - Binary data to text string 2724 */ 2725 2726 /** 2727 * vbin_printf - Parse a format string and place args' binary value in a buffer 2728 * @bin_buf: The buffer to place args' binary value 2729 * @size: The size of the buffer(by words(32bits), not characters) 2730 * @fmt: The format string to use 2731 * @args: Arguments for the format string 2732 * 2733 * The format follows C99 vsnprintf, except %n is ignored, and its argument 2734 * is skipped. 2735 * 2736 * The return value is the number of words(32bits) which would be generated for 2737 * the given input. 2738 * 2739 * NOTE: 2740 * If the return value is greater than @size, the resulting bin_buf is NOT 2741 * valid for bstr_printf(). 2742 */ 2743 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 2744 { 2745 struct printf_spec spec = {0}; 2746 char *str, *end; 2747 int width; 2748 2749 str = (char *)bin_buf; 2750 end = (char *)(bin_buf + size); 2751 2752 #define save_arg(type) \ 2753 ({ \ 2754 unsigned long long value; \ 2755 if (sizeof(type) == 8) { \ 2756 unsigned long long val8; \ 2757 str = PTR_ALIGN(str, sizeof(u32)); \ 2758 val8 = va_arg(args, unsigned long long); \ 2759 if (str + sizeof(type) <= end) { \ 2760 *(u32 *)str = *(u32 *)&val8; \ 2761 *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \ 2762 } \ 2763 value = val8; \ 2764 } else { \ 2765 unsigned int val4; \ 2766 str = PTR_ALIGN(str, sizeof(type)); \ 2767 val4 = va_arg(args, int); \ 2768 if (str + sizeof(type) <= end) \ 2769 *(typeof(type) *)str = (type)(long)val4; \ 2770 value = (unsigned long long)val4; \ 2771 } \ 2772 str += sizeof(type); \ 2773 value; \ 2774 }) 2775 2776 while (*fmt) { 2777 int read = format_decode(fmt, &spec); 2778 2779 fmt += read; 2780 2781 switch (spec.type) { 2782 case FORMAT_TYPE_NONE: 2783 case FORMAT_TYPE_PERCENT_CHAR: 2784 break; 2785 case FORMAT_TYPE_INVALID: 2786 goto out; 2787 2788 case FORMAT_TYPE_WIDTH: 2789 case FORMAT_TYPE_PRECISION: 2790 width = (int)save_arg(int); 2791 /* Pointers may require the width */ 2792 if (*fmt == 'p') 2793 set_field_width(&spec, width); 2794 break; 2795 2796 case FORMAT_TYPE_CHAR: 2797 save_arg(char); 2798 break; 2799 2800 case FORMAT_TYPE_STR: { 2801 const char *save_str = va_arg(args, char *); 2802 const char *err_msg; 2803 size_t len; 2804 2805 err_msg = check_pointer_msg(save_str); 2806 if (err_msg) 2807 save_str = err_msg; 2808 2809 len = strlen(save_str) + 1; 2810 if (str + len < end) 2811 memcpy(str, save_str, len); 2812 str += len; 2813 break; 2814 } 2815 2816 case FORMAT_TYPE_PTR: 2817 /* Dereferenced pointers must be done now */ 2818 switch (*fmt) { 2819 /* Dereference of functions is still OK */ 2820 case 'S': 2821 case 's': 2822 case 'F': 2823 case 'f': 2824 case 'x': 2825 case 'K': 2826 save_arg(void *); 2827 break; 2828 default: 2829 if (!isalnum(*fmt)) { 2830 save_arg(void *); 2831 break; 2832 } 2833 str = pointer(fmt, str, end, va_arg(args, void *), 2834 spec); 2835 if (str + 1 < end) 2836 *str++ = '\0'; 2837 else 2838 end[-1] = '\0'; /* Must be nul terminated */ 2839 } 2840 /* skip all alphanumeric pointer suffixes */ 2841 while (isalnum(*fmt)) 2842 fmt++; 2843 break; 2844 2845 default: 2846 switch (spec.type) { 2847 2848 case FORMAT_TYPE_LONG_LONG: 2849 save_arg(long long); 2850 break; 2851 case FORMAT_TYPE_ULONG: 2852 case FORMAT_TYPE_LONG: 2853 save_arg(unsigned long); 2854 break; 2855 case FORMAT_TYPE_SIZE_T: 2856 save_arg(size_t); 2857 break; 2858 case FORMAT_TYPE_PTRDIFF: 2859 save_arg(ptrdiff_t); 2860 break; 2861 case FORMAT_TYPE_UBYTE: 2862 case FORMAT_TYPE_BYTE: 2863 save_arg(char); 2864 break; 2865 case FORMAT_TYPE_USHORT: 2866 case FORMAT_TYPE_SHORT: 2867 save_arg(short); 2868 break; 2869 default: 2870 save_arg(int); 2871 } 2872 } 2873 } 2874 2875 out: 2876 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 2877 #undef save_arg 2878 } 2879 EXPORT_SYMBOL_GPL(vbin_printf); 2880 2881 /** 2882 * bstr_printf - Format a string from binary arguments and place it in a buffer 2883 * @buf: The buffer to place the result into 2884 * @size: The size of the buffer, including the trailing null space 2885 * @fmt: The format string to use 2886 * @bin_buf: Binary arguments for the format string 2887 * 2888 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 2889 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 2890 * a binary buffer that generated by vbin_printf. 2891 * 2892 * The format follows C99 vsnprintf, but has some extensions: 2893 * see vsnprintf comment for details. 2894 * 2895 * The return value is the number of characters which would 2896 * be generated for the given input, excluding the trailing 2897 * '\0', as per ISO C99. If you want to have the exact 2898 * number of characters written into @buf as return value 2899 * (not including the trailing '\0'), use vscnprintf(). If the 2900 * return is greater than or equal to @size, the resulting 2901 * string is truncated. 2902 */ 2903 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 2904 { 2905 struct printf_spec spec = {0}; 2906 char *str, *end; 2907 const char *args = (const char *)bin_buf; 2908 2909 if (WARN_ON_ONCE(size > INT_MAX)) 2910 return 0; 2911 2912 str = buf; 2913 end = buf + size; 2914 2915 #define get_arg(type) \ 2916 ({ \ 2917 typeof(type) value; \ 2918 if (sizeof(type) == 8) { \ 2919 args = PTR_ALIGN(args, sizeof(u32)); \ 2920 *(u32 *)&value = *(u32 *)args; \ 2921 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 2922 } else { \ 2923 args = PTR_ALIGN(args, sizeof(type)); \ 2924 value = *(typeof(type) *)args; \ 2925 } \ 2926 args += sizeof(type); \ 2927 value; \ 2928 }) 2929 2930 /* Make sure end is always >= buf */ 2931 if (end < buf) { 2932 end = ((void *)-1); 2933 size = end - buf; 2934 } 2935 2936 while (*fmt) { 2937 const char *old_fmt = fmt; 2938 int read = format_decode(fmt, &spec); 2939 2940 fmt += read; 2941 2942 switch (spec.type) { 2943 case FORMAT_TYPE_NONE: { 2944 int copy = read; 2945 if (str < end) { 2946 if (copy > end - str) 2947 copy = end - str; 2948 memcpy(str, old_fmt, copy); 2949 } 2950 str += read; 2951 break; 2952 } 2953 2954 case FORMAT_TYPE_WIDTH: 2955 set_field_width(&spec, get_arg(int)); 2956 break; 2957 2958 case FORMAT_TYPE_PRECISION: 2959 set_precision(&spec, get_arg(int)); 2960 break; 2961 2962 case FORMAT_TYPE_CHAR: { 2963 char c; 2964 2965 if (!(spec.flags & LEFT)) { 2966 while (--spec.field_width > 0) { 2967 if (str < end) 2968 *str = ' '; 2969 ++str; 2970 } 2971 } 2972 c = (unsigned char) get_arg(char); 2973 if (str < end) 2974 *str = c; 2975 ++str; 2976 while (--spec.field_width > 0) { 2977 if (str < end) 2978 *str = ' '; 2979 ++str; 2980 } 2981 break; 2982 } 2983 2984 case FORMAT_TYPE_STR: { 2985 const char *str_arg = args; 2986 args += strlen(str_arg) + 1; 2987 str = string(str, end, (char *)str_arg, spec); 2988 break; 2989 } 2990 2991 case FORMAT_TYPE_PTR: { 2992 bool process = false; 2993 int copy, len; 2994 /* Non function dereferences were already done */ 2995 switch (*fmt) { 2996 case 'S': 2997 case 's': 2998 case 'F': 2999 case 'f': 3000 case 'x': 3001 case 'K': 3002 process = true; 3003 break; 3004 default: 3005 if (!isalnum(*fmt)) { 3006 process = true; 3007 break; 3008 } 3009 /* Pointer dereference was already processed */ 3010 if (str < end) { 3011 len = copy = strlen(args); 3012 if (copy > end - str) 3013 copy = end - str; 3014 memcpy(str, args, copy); 3015 str += len; 3016 args += len + 1; 3017 } 3018 } 3019 if (process) 3020 str = pointer(fmt, str, end, get_arg(void *), spec); 3021 3022 while (isalnum(*fmt)) 3023 fmt++; 3024 break; 3025 } 3026 3027 case FORMAT_TYPE_PERCENT_CHAR: 3028 if (str < end) 3029 *str = '%'; 3030 ++str; 3031 break; 3032 3033 case FORMAT_TYPE_INVALID: 3034 goto out; 3035 3036 default: { 3037 unsigned long long num; 3038 3039 switch (spec.type) { 3040 3041 case FORMAT_TYPE_LONG_LONG: 3042 num = get_arg(long long); 3043 break; 3044 case FORMAT_TYPE_ULONG: 3045 case FORMAT_TYPE_LONG: 3046 num = get_arg(unsigned long); 3047 break; 3048 case FORMAT_TYPE_SIZE_T: 3049 num = get_arg(size_t); 3050 break; 3051 case FORMAT_TYPE_PTRDIFF: 3052 num = get_arg(ptrdiff_t); 3053 break; 3054 case FORMAT_TYPE_UBYTE: 3055 num = get_arg(unsigned char); 3056 break; 3057 case FORMAT_TYPE_BYTE: 3058 num = get_arg(signed char); 3059 break; 3060 case FORMAT_TYPE_USHORT: 3061 num = get_arg(unsigned short); 3062 break; 3063 case FORMAT_TYPE_SHORT: 3064 num = get_arg(short); 3065 break; 3066 case FORMAT_TYPE_UINT: 3067 num = get_arg(unsigned int); 3068 break; 3069 default: 3070 num = get_arg(int); 3071 } 3072 3073 str = number(str, end, num, spec); 3074 } /* default: */ 3075 } /* switch(spec.type) */ 3076 } /* while(*fmt) */ 3077 3078 out: 3079 if (size > 0) { 3080 if (str < end) 3081 *str = '\0'; 3082 else 3083 end[-1] = '\0'; 3084 } 3085 3086 #undef get_arg 3087 3088 /* the trailing null byte doesn't count towards the total */ 3089 return str - buf; 3090 } 3091 EXPORT_SYMBOL_GPL(bstr_printf); 3092 3093 /** 3094 * bprintf - Parse a format string and place args' binary value in a buffer 3095 * @bin_buf: The buffer to place args' binary value 3096 * @size: The size of the buffer(by words(32bits), not characters) 3097 * @fmt: The format string to use 3098 * @...: Arguments for the format string 3099 * 3100 * The function returns the number of words(u32) written 3101 * into @bin_buf. 3102 */ 3103 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 3104 { 3105 va_list args; 3106 int ret; 3107 3108 va_start(args, fmt); 3109 ret = vbin_printf(bin_buf, size, fmt, args); 3110 va_end(args); 3111 3112 return ret; 3113 } 3114 EXPORT_SYMBOL_GPL(bprintf); 3115 3116 #endif /* CONFIG_BINARY_PRINTF */ 3117 3118 /** 3119 * vsscanf - Unformat a buffer into a list of arguments 3120 * @buf: input buffer 3121 * @fmt: format of buffer 3122 * @args: arguments 3123 */ 3124 int vsscanf(const char *buf, const char *fmt, va_list args) 3125 { 3126 const char *str = buf; 3127 char *next; 3128 char digit; 3129 int num = 0; 3130 u8 qualifier; 3131 unsigned int base; 3132 union { 3133 long long s; 3134 unsigned long long u; 3135 } val; 3136 s16 field_width; 3137 bool is_sign; 3138 3139 while (*fmt) { 3140 /* skip any white space in format */ 3141 /* white space in format matchs any amount of 3142 * white space, including none, in the input. 3143 */ 3144 if (isspace(*fmt)) { 3145 fmt = skip_spaces(++fmt); 3146 str = skip_spaces(str); 3147 } 3148 3149 /* anything that is not a conversion must match exactly */ 3150 if (*fmt != '%' && *fmt) { 3151 if (*fmt++ != *str++) 3152 break; 3153 continue; 3154 } 3155 3156 if (!*fmt) 3157 break; 3158 ++fmt; 3159 3160 /* skip this conversion. 3161 * advance both strings to next white space 3162 */ 3163 if (*fmt == '*') { 3164 if (!*str) 3165 break; 3166 while (!isspace(*fmt) && *fmt != '%' && *fmt) { 3167 /* '%*[' not yet supported, invalid format */ 3168 if (*fmt == '[') 3169 return num; 3170 fmt++; 3171 } 3172 while (!isspace(*str) && *str) 3173 str++; 3174 continue; 3175 } 3176 3177 /* get field width */ 3178 field_width = -1; 3179 if (isdigit(*fmt)) { 3180 field_width = skip_atoi(&fmt); 3181 if (field_width <= 0) 3182 break; 3183 } 3184 3185 /* get conversion qualifier */ 3186 qualifier = -1; 3187 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 3188 *fmt == 'z') { 3189 qualifier = *fmt++; 3190 if (unlikely(qualifier == *fmt)) { 3191 if (qualifier == 'h') { 3192 qualifier = 'H'; 3193 fmt++; 3194 } else if (qualifier == 'l') { 3195 qualifier = 'L'; 3196 fmt++; 3197 } 3198 } 3199 } 3200 3201 if (!*fmt) 3202 break; 3203 3204 if (*fmt == 'n') { 3205 /* return number of characters read so far */ 3206 *va_arg(args, int *) = str - buf; 3207 ++fmt; 3208 continue; 3209 } 3210 3211 if (!*str) 3212 break; 3213 3214 base = 10; 3215 is_sign = false; 3216 3217 switch (*fmt++) { 3218 case 'c': 3219 { 3220 char *s = (char *)va_arg(args, char*); 3221 if (field_width == -1) 3222 field_width = 1; 3223 do { 3224 *s++ = *str++; 3225 } while (--field_width > 0 && *str); 3226 num++; 3227 } 3228 continue; 3229 case 's': 3230 { 3231 char *s = (char *)va_arg(args, char *); 3232 if (field_width == -1) 3233 field_width = SHRT_MAX; 3234 /* first, skip leading white space in buffer */ 3235 str = skip_spaces(str); 3236 3237 /* now copy until next white space */ 3238 while (*str && !isspace(*str) && field_width--) 3239 *s++ = *str++; 3240 *s = '\0'; 3241 num++; 3242 } 3243 continue; 3244 /* 3245 * Warning: This implementation of the '[' conversion specifier 3246 * deviates from its glibc counterpart in the following ways: 3247 * (1) It does NOT support ranges i.e. '-' is NOT a special 3248 * character 3249 * (2) It cannot match the closing bracket ']' itself 3250 * (3) A field width is required 3251 * (4) '%*[' (discard matching input) is currently not supported 3252 * 3253 * Example usage: 3254 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]", 3255 * buf1, buf2, buf3); 3256 * if (ret < 3) 3257 * // etc.. 3258 */ 3259 case '[': 3260 { 3261 char *s = (char *)va_arg(args, char *); 3262 DECLARE_BITMAP(set, 256) = {0}; 3263 unsigned int len = 0; 3264 bool negate = (*fmt == '^'); 3265 3266 /* field width is required */ 3267 if (field_width == -1) 3268 return num; 3269 3270 if (negate) 3271 ++fmt; 3272 3273 for ( ; *fmt && *fmt != ']'; ++fmt, ++len) 3274 set_bit((u8)*fmt, set); 3275 3276 /* no ']' or no character set found */ 3277 if (!*fmt || !len) 3278 return num; 3279 ++fmt; 3280 3281 if (negate) { 3282 bitmap_complement(set, set, 256); 3283 /* exclude null '\0' byte */ 3284 clear_bit(0, set); 3285 } 3286 3287 /* match must be non-empty */ 3288 if (!test_bit((u8)*str, set)) 3289 return num; 3290 3291 while (test_bit((u8)*str, set) && field_width--) 3292 *s++ = *str++; 3293 *s = '\0'; 3294 ++num; 3295 } 3296 continue; 3297 case 'o': 3298 base = 8; 3299 break; 3300 case 'x': 3301 case 'X': 3302 base = 16; 3303 break; 3304 case 'i': 3305 base = 0; 3306 /* fall through */ 3307 case 'd': 3308 is_sign = true; 3309 /* fall through */ 3310 case 'u': 3311 break; 3312 case '%': 3313 /* looking for '%' in str */ 3314 if (*str++ != '%') 3315 return num; 3316 continue; 3317 default: 3318 /* invalid format; stop here */ 3319 return num; 3320 } 3321 3322 /* have some sort of integer conversion. 3323 * first, skip white space in buffer. 3324 */ 3325 str = skip_spaces(str); 3326 3327 digit = *str; 3328 if (is_sign && digit == '-') 3329 digit = *(str + 1); 3330 3331 if (!digit 3332 || (base == 16 && !isxdigit(digit)) 3333 || (base == 10 && !isdigit(digit)) 3334 || (base == 8 && (!isdigit(digit) || digit > '7')) 3335 || (base == 0 && !isdigit(digit))) 3336 break; 3337 3338 if (is_sign) 3339 val.s = qualifier != 'L' ? 3340 simple_strtol(str, &next, base) : 3341 simple_strtoll(str, &next, base); 3342 else 3343 val.u = qualifier != 'L' ? 3344 simple_strtoul(str, &next, base) : 3345 simple_strtoull(str, &next, base); 3346 3347 if (field_width > 0 && next - str > field_width) { 3348 if (base == 0) 3349 _parse_integer_fixup_radix(str, &base); 3350 while (next - str > field_width) { 3351 if (is_sign) 3352 val.s = div_s64(val.s, base); 3353 else 3354 val.u = div_u64(val.u, base); 3355 --next; 3356 } 3357 } 3358 3359 switch (qualifier) { 3360 case 'H': /* that's 'hh' in format */ 3361 if (is_sign) 3362 *va_arg(args, signed char *) = val.s; 3363 else 3364 *va_arg(args, unsigned char *) = val.u; 3365 break; 3366 case 'h': 3367 if (is_sign) 3368 *va_arg(args, short *) = val.s; 3369 else 3370 *va_arg(args, unsigned short *) = val.u; 3371 break; 3372 case 'l': 3373 if (is_sign) 3374 *va_arg(args, long *) = val.s; 3375 else 3376 *va_arg(args, unsigned long *) = val.u; 3377 break; 3378 case 'L': 3379 if (is_sign) 3380 *va_arg(args, long long *) = val.s; 3381 else 3382 *va_arg(args, unsigned long long *) = val.u; 3383 break; 3384 case 'z': 3385 *va_arg(args, size_t *) = val.u; 3386 break; 3387 default: 3388 if (is_sign) 3389 *va_arg(args, int *) = val.s; 3390 else 3391 *va_arg(args, unsigned int *) = val.u; 3392 break; 3393 } 3394 num++; 3395 3396 if (!next) 3397 break; 3398 str = next; 3399 } 3400 3401 return num; 3402 } 3403 EXPORT_SYMBOL(vsscanf); 3404 3405 /** 3406 * sscanf - Unformat a buffer into a list of arguments 3407 * @buf: input buffer 3408 * @fmt: formatting of buffer 3409 * @...: resulting arguments 3410 */ 3411 int sscanf(const char *buf, const char *fmt, ...) 3412 { 3413 va_list args; 3414 int i; 3415 3416 va_start(args, fmt); 3417 i = vsscanf(buf, fmt, args); 3418 va_end(args); 3419 3420 return i; 3421 } 3422 EXPORT_SYMBOL(sscanf); 3423