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