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