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