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_is_partition(bdev)) { 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_partno(bdev), 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 /* 2115 * Only get a reference for other nodes (i.e. parent nodes). 2116 * fwnode refcount may be 0 here. 2117 */ 2118 struct fwnode_handle *__fwnode = depth ? 2119 fwnode_get_nth_parent(fwnode, depth) : fwnode; 2120 2121 buf = string(buf, end, fwnode_get_name_prefix(__fwnode), 2122 default_str_spec); 2123 buf = string(buf, end, fwnode_get_name(__fwnode), 2124 default_str_spec); 2125 2126 if (depth) 2127 fwnode_handle_put(__fwnode); 2128 } 2129 2130 return buf; 2131 } 2132 2133 static noinline_for_stack 2134 char *device_node_string(char *buf, char *end, struct device_node *dn, 2135 struct printf_spec spec, const char *fmt) 2136 { 2137 char tbuf[sizeof("xxxx") + 1]; 2138 const char *p; 2139 int ret; 2140 char *buf_start = buf; 2141 struct property *prop; 2142 bool has_mult, pass; 2143 2144 struct printf_spec str_spec = spec; 2145 str_spec.field_width = -1; 2146 2147 if (fmt[0] != 'F') 2148 return error_string(buf, end, "(%pO?)", spec); 2149 2150 if (!IS_ENABLED(CONFIG_OF)) 2151 return error_string(buf, end, "(%pOF?)", spec); 2152 2153 if (check_pointer(&buf, end, dn, spec)) 2154 return buf; 2155 2156 /* simple case without anything any more format specifiers */ 2157 fmt++; 2158 if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0) 2159 fmt = "f"; 2160 2161 for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) { 2162 int precision; 2163 if (pass) { 2164 if (buf < end) 2165 *buf = ':'; 2166 buf++; 2167 } 2168 2169 switch (*fmt) { 2170 case 'f': /* full_name */ 2171 buf = fwnode_full_name_string(of_fwnode_handle(dn), buf, 2172 end); 2173 break; 2174 case 'n': /* name */ 2175 p = fwnode_get_name(of_fwnode_handle(dn)); 2176 precision = str_spec.precision; 2177 str_spec.precision = strchrnul(p, '@') - p; 2178 buf = string(buf, end, p, str_spec); 2179 str_spec.precision = precision; 2180 break; 2181 case 'p': /* phandle */ 2182 buf = number(buf, end, (unsigned int)dn->phandle, default_dec_spec); 2183 break; 2184 case 'P': /* path-spec */ 2185 p = fwnode_get_name(of_fwnode_handle(dn)); 2186 if (!p[1]) 2187 p = "/"; 2188 buf = string(buf, end, p, str_spec); 2189 break; 2190 case 'F': /* flags */ 2191 tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; 2192 tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-'; 2193 tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-'; 2194 tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-'; 2195 tbuf[4] = 0; 2196 buf = string_nocheck(buf, end, tbuf, str_spec); 2197 break; 2198 case 'c': /* major compatible string */ 2199 ret = of_property_read_string(dn, "compatible", &p); 2200 if (!ret) 2201 buf = string(buf, end, p, str_spec); 2202 break; 2203 case 'C': /* full compatible string */ 2204 has_mult = false; 2205 of_property_for_each_string(dn, "compatible", prop, p) { 2206 if (has_mult) 2207 buf = string_nocheck(buf, end, ",", str_spec); 2208 buf = string_nocheck(buf, end, "\"", str_spec); 2209 buf = string(buf, end, p, str_spec); 2210 buf = string_nocheck(buf, end, "\"", str_spec); 2211 2212 has_mult = true; 2213 } 2214 break; 2215 default: 2216 break; 2217 } 2218 } 2219 2220 return widen_string(buf, buf - buf_start, end, spec); 2221 } 2222 2223 static noinline_for_stack 2224 char *fwnode_string(char *buf, char *end, struct fwnode_handle *fwnode, 2225 struct printf_spec spec, const char *fmt) 2226 { 2227 struct printf_spec str_spec = spec; 2228 char *buf_start = buf; 2229 2230 str_spec.field_width = -1; 2231 2232 if (*fmt != 'w') 2233 return error_string(buf, end, "(%pf?)", spec); 2234 2235 if (check_pointer(&buf, end, fwnode, spec)) 2236 return buf; 2237 2238 fmt++; 2239 2240 switch (*fmt) { 2241 case 'P': /* name */ 2242 buf = string(buf, end, fwnode_get_name(fwnode), str_spec); 2243 break; 2244 case 'f': /* full_name */ 2245 default: 2246 buf = fwnode_full_name_string(fwnode, buf, end); 2247 break; 2248 } 2249 2250 return widen_string(buf, buf - buf_start, end, spec); 2251 } 2252 2253 int __init no_hash_pointers_enable(char *str) 2254 { 2255 if (no_hash_pointers) 2256 return 0; 2257 2258 no_hash_pointers = true; 2259 2260 pr_warn("**********************************************************\n"); 2261 pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n"); 2262 pr_warn("** **\n"); 2263 pr_warn("** This system shows unhashed kernel memory addresses **\n"); 2264 pr_warn("** via the console, logs, and other interfaces. This **\n"); 2265 pr_warn("** might reduce the security of your system. **\n"); 2266 pr_warn("** **\n"); 2267 pr_warn("** If you see this message and you are not debugging **\n"); 2268 pr_warn("** the kernel, report this immediately to your system **\n"); 2269 pr_warn("** administrator! **\n"); 2270 pr_warn("** **\n"); 2271 pr_warn("** NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE **\n"); 2272 pr_warn("**********************************************************\n"); 2273 2274 return 0; 2275 } 2276 early_param("no_hash_pointers", no_hash_pointers_enable); 2277 2278 /* Used for Rust formatting ('%pA'). */ 2279 char *rust_fmt_argument(char *buf, char *end, void *ptr); 2280 2281 /* 2282 * Show a '%p' thing. A kernel extension is that the '%p' is followed 2283 * by an extra set of alphanumeric characters that are extended format 2284 * specifiers. 2285 * 2286 * Please update scripts/checkpatch.pl when adding/removing conversion 2287 * characters. (Search for "check for vsprintf extension"). 2288 * 2289 * Right now we handle: 2290 * 2291 * - 'S' For symbolic direct pointers (or function descriptors) with offset 2292 * - 's' For symbolic direct pointers (or function descriptors) without offset 2293 * - '[Ss]R' as above with __builtin_extract_return_addr() translation 2294 * - 'S[R]b' as above with module build ID (for use in backtraces) 2295 * - '[Ff]' %pf and %pF were obsoleted and later removed in favor of 2296 * %ps and %pS. Be careful when re-using these specifiers. 2297 * - 'B' For backtraced symbolic direct pointers with offset 2298 * - 'Bb' as above with module build ID (for use in backtraces) 2299 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 2300 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 2301 * - 'b[l]' For a bitmap, the number of bits is determined by the field 2302 * width which must be explicitly specified either as part of the 2303 * format string '%32b[l]' or through '%*b[l]', [l] selects 2304 * range-list format instead of hex format 2305 * - 'M' For a 6-byte MAC address, it prints the address in the 2306 * usual colon-separated hex notation 2307 * - 'm' For a 6-byte MAC address, it prints the hex address without colons 2308 * - 'MF' For a 6-byte MAC FDDI address, it prints the address 2309 * with a dash-separated hex notation 2310 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth) 2311 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 2312 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 2313 * IPv6 uses colon separated network-order 16 bit hex with leading 0's 2314 * [S][pfs] 2315 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 2316 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 2317 * - 'i' [46] for 'raw' IPv4/IPv6 addresses 2318 * IPv6 omits the colons (01020304...0f) 2319 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 2320 * [S][pfs] 2321 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 2322 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 2323 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order 2324 * - 'I[6S]c' for IPv6 addresses printed as specified by 2325 * https://tools.ietf.org/html/rfc5952 2326 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination 2327 * of the following flags (see string_escape_mem() for the 2328 * details): 2329 * a - ESCAPE_ANY 2330 * c - ESCAPE_SPECIAL 2331 * h - ESCAPE_HEX 2332 * n - ESCAPE_NULL 2333 * o - ESCAPE_OCTAL 2334 * p - ESCAPE_NP 2335 * s - ESCAPE_SPACE 2336 * By default ESCAPE_ANY_NP is used. 2337 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 2338 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 2339 * Options for %pU are: 2340 * b big endian lower case hex (default) 2341 * B big endian UPPER case hex 2342 * l little endian lower case hex 2343 * L little endian UPPER case hex 2344 * big endian output byte order is: 2345 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 2346 * little endian output byte order is: 2347 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 2348 * - 'V' For a struct va_format which contains a format string * and va_list *, 2349 * call vsnprintf(->format, *->va_list). 2350 * Implements a "recursive vsnprintf". 2351 * Do not use this feature without some mechanism to verify the 2352 * correctness of the format string and va_list arguments. 2353 * - 'K' For a kernel pointer that should be hidden from unprivileged users. 2354 * Use only for procfs, sysfs and similar files, not printk(); please 2355 * read the documentation (path below) first. 2356 * - 'NF' For a netdev_features_t 2357 * - '4cc' V4L2 or DRM FourCC code, with endianness and raw numerical value. 2358 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with 2359 * a certain separator (' ' by default): 2360 * C colon 2361 * D dash 2362 * N no separator 2363 * The maximum supported length is 64 bytes of the input. Consider 2364 * to use print_hex_dump() for the larger input. 2365 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives 2366 * (default assumed to be phys_addr_t, passed by reference) 2367 * - 'd[234]' For a dentry name (optionally 2-4 last components) 2368 * - 'D[234]' Same as 'd' but for a struct file 2369 * - 'g' For block_device name (gendisk + partition number) 2370 * - 't[RT][dt][r][s]' For time and date as represented by: 2371 * R struct rtc_time 2372 * T time64_t 2373 * - 'C' For a clock, it prints the name (Common Clock Framework) or address 2374 * (legacy clock framework) of the clock 2375 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address 2376 * (legacy clock framework) of the clock 2377 * - 'G' For flags to be printed as a collection of symbolic strings that would 2378 * construct the specific value. Supported flags given by option: 2379 * p page flags (see struct page) given as pointer to unsigned long 2380 * g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t 2381 * v vma flags (VM_*) given as pointer to unsigned long 2382 * - 'OF[fnpPcCF]' For a device tree object 2383 * Without any optional arguments prints the full_name 2384 * f device node full_name 2385 * n device node name 2386 * p device node phandle 2387 * P device node path spec (name + @unit) 2388 * F device node flags 2389 * c major compatible string 2390 * C full compatible string 2391 * - 'fw[fP]' For a firmware node (struct fwnode_handle) pointer 2392 * Without an option prints the full name of the node 2393 * f full name 2394 * P node name, including a possible unit address 2395 * - 'x' For printing the address unmodified. Equivalent to "%lx". 2396 * Please read the documentation (path below) before using! 2397 * - '[ku]s' For a BPF/tracing related format specifier, e.g. used out of 2398 * bpf_trace_printk() where [ku] prefix specifies either kernel (k) 2399 * or user (u) memory to probe, and: 2400 * s a string, equivalent to "%s" on direct vsnprintf() use 2401 * 2402 * ** When making changes please also update: 2403 * Documentation/core-api/printk-formats.rst 2404 * 2405 * Note: The default behaviour (unadorned %p) is to hash the address, 2406 * rendering it useful as a unique identifier. 2407 * 2408 * There is also a '%pA' format specifier, but it is only intended to be used 2409 * from Rust code to format core::fmt::Arguments. Do *not* use it from C. 2410 * See rust/kernel/print.rs for details. 2411 */ 2412 static noinline_for_stack 2413 char *pointer(const char *fmt, char *buf, char *end, void *ptr, 2414 struct printf_spec spec) 2415 { 2416 switch (*fmt) { 2417 case 'S': 2418 case 's': 2419 ptr = dereference_symbol_descriptor(ptr); 2420 fallthrough; 2421 case 'B': 2422 return symbol_string(buf, end, ptr, spec, fmt); 2423 case 'R': 2424 case 'r': 2425 return resource_string(buf, end, ptr, spec, fmt); 2426 case 'h': 2427 return hex_string(buf, end, ptr, spec, fmt); 2428 case 'b': 2429 switch (fmt[1]) { 2430 case 'l': 2431 return bitmap_list_string(buf, end, ptr, spec, fmt); 2432 default: 2433 return bitmap_string(buf, end, ptr, spec, fmt); 2434 } 2435 case 'M': /* Colon separated: 00:01:02:03:04:05 */ 2436 case 'm': /* Contiguous: 000102030405 */ 2437 /* [mM]F (FDDI) */ 2438 /* [mM]R (Reverse order; Bluetooth) */ 2439 return mac_address_string(buf, end, ptr, spec, fmt); 2440 case 'I': /* Formatted IP supported 2441 * 4: 1.2.3.4 2442 * 6: 0001:0203:...:0708 2443 * 6c: 1::708 or 1::1.2.3.4 2444 */ 2445 case 'i': /* Contiguous: 2446 * 4: 001.002.003.004 2447 * 6: 000102...0f 2448 */ 2449 return ip_addr_string(buf, end, ptr, spec, fmt); 2450 case 'E': 2451 return escaped_string(buf, end, ptr, spec, fmt); 2452 case 'U': 2453 return uuid_string(buf, end, ptr, spec, fmt); 2454 case 'V': 2455 return va_format(buf, end, ptr, spec, fmt); 2456 case 'K': 2457 return restricted_pointer(buf, end, ptr, spec); 2458 case 'N': 2459 return netdev_bits(buf, end, ptr, spec, fmt); 2460 case '4': 2461 return fourcc_string(buf, end, ptr, spec, fmt); 2462 case 'a': 2463 return address_val(buf, end, ptr, spec, fmt); 2464 case 'd': 2465 return dentry_name(buf, end, ptr, spec, fmt); 2466 case 't': 2467 return time_and_date(buf, end, ptr, spec, fmt); 2468 case 'C': 2469 return clock(buf, end, ptr, spec, fmt); 2470 case 'D': 2471 return file_dentry_name(buf, end, ptr, spec, fmt); 2472 #ifdef CONFIG_BLOCK 2473 case 'g': 2474 return bdev_name(buf, end, ptr, spec, fmt); 2475 #endif 2476 2477 case 'G': 2478 return flags_string(buf, end, ptr, spec, fmt); 2479 case 'O': 2480 return device_node_string(buf, end, ptr, spec, fmt + 1); 2481 case 'f': 2482 return fwnode_string(buf, end, ptr, spec, fmt + 1); 2483 case 'A': 2484 if (!IS_ENABLED(CONFIG_RUST)) { 2485 WARN_ONCE(1, "Please remove %%pA from non-Rust code\n"); 2486 return error_string(buf, end, "(%pA?)", spec); 2487 } 2488 return rust_fmt_argument(buf, end, ptr); 2489 case 'x': 2490 return pointer_string(buf, end, ptr, spec); 2491 case 'e': 2492 /* %pe with a non-ERR_PTR gets treated as plain %p */ 2493 if (!IS_ERR(ptr)) 2494 return default_pointer(buf, end, ptr, spec); 2495 return err_ptr(buf, end, ptr, spec); 2496 case 'u': 2497 case 'k': 2498 switch (fmt[1]) { 2499 case 's': 2500 return string(buf, end, ptr, spec); 2501 default: 2502 return error_string(buf, end, "(einval)", spec); 2503 } 2504 default: 2505 return default_pointer(buf, end, ptr, spec); 2506 } 2507 } 2508 2509 /* 2510 * Helper function to decode printf style format. 2511 * Each call decode a token from the format and return the 2512 * number of characters read (or likely the delta where it wants 2513 * to go on the next call). 2514 * The decoded token is returned through the parameters 2515 * 2516 * 'h', 'l', or 'L' for integer fields 2517 * 'z' support added 23/7/1999 S.H. 2518 * 'z' changed to 'Z' --davidm 1/25/99 2519 * 'Z' changed to 'z' --adobriyan 2017-01-25 2520 * 't' added for ptrdiff_t 2521 * 2522 * @fmt: the format string 2523 * @type of the token returned 2524 * @flags: various flags such as +, -, # tokens.. 2525 * @field_width: overwritten width 2526 * @base: base of the number (octal, hex, ...) 2527 * @precision: precision of a number 2528 * @qualifier: qualifier of a number (long, size_t, ...) 2529 */ 2530 static noinline_for_stack 2531 int format_decode(const char *fmt, struct printf_spec *spec) 2532 { 2533 const char *start = fmt; 2534 char qualifier; 2535 2536 /* we finished early by reading the field width */ 2537 if (spec->type == FORMAT_TYPE_WIDTH) { 2538 if (spec->field_width < 0) { 2539 spec->field_width = -spec->field_width; 2540 spec->flags |= LEFT; 2541 } 2542 spec->type = FORMAT_TYPE_NONE; 2543 goto precision; 2544 } 2545 2546 /* we finished early by reading the precision */ 2547 if (spec->type == FORMAT_TYPE_PRECISION) { 2548 if (spec->precision < 0) 2549 spec->precision = 0; 2550 2551 spec->type = FORMAT_TYPE_NONE; 2552 goto qualifier; 2553 } 2554 2555 /* By default */ 2556 spec->type = FORMAT_TYPE_NONE; 2557 2558 for (; *fmt ; ++fmt) { 2559 if (*fmt == '%') 2560 break; 2561 } 2562 2563 /* Return the current non-format string */ 2564 if (fmt != start || !*fmt) 2565 return fmt - start; 2566 2567 /* Process flags */ 2568 spec->flags = 0; 2569 2570 while (1) { /* this also skips first '%' */ 2571 bool found = true; 2572 2573 ++fmt; 2574 2575 switch (*fmt) { 2576 case '-': spec->flags |= LEFT; break; 2577 case '+': spec->flags |= PLUS; break; 2578 case ' ': spec->flags |= SPACE; break; 2579 case '#': spec->flags |= SPECIAL; break; 2580 case '0': spec->flags |= ZEROPAD; break; 2581 default: found = false; 2582 } 2583 2584 if (!found) 2585 break; 2586 } 2587 2588 /* get field width */ 2589 spec->field_width = -1; 2590 2591 if (isdigit(*fmt)) 2592 spec->field_width = skip_atoi(&fmt); 2593 else if (*fmt == '*') { 2594 /* it's the next argument */ 2595 spec->type = FORMAT_TYPE_WIDTH; 2596 return ++fmt - start; 2597 } 2598 2599 precision: 2600 /* get the precision */ 2601 spec->precision = -1; 2602 if (*fmt == '.') { 2603 ++fmt; 2604 if (isdigit(*fmt)) { 2605 spec->precision = skip_atoi(&fmt); 2606 if (spec->precision < 0) 2607 spec->precision = 0; 2608 } else if (*fmt == '*') { 2609 /* it's the next argument */ 2610 spec->type = FORMAT_TYPE_PRECISION; 2611 return ++fmt - start; 2612 } 2613 } 2614 2615 qualifier: 2616 /* get the conversion qualifier */ 2617 qualifier = 0; 2618 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2619 *fmt == 'z' || *fmt == 't') { 2620 qualifier = *fmt++; 2621 if (unlikely(qualifier == *fmt)) { 2622 if (qualifier == 'l') { 2623 qualifier = 'L'; 2624 ++fmt; 2625 } else if (qualifier == 'h') { 2626 qualifier = 'H'; 2627 ++fmt; 2628 } 2629 } 2630 } 2631 2632 /* default base */ 2633 spec->base = 10; 2634 switch (*fmt) { 2635 case 'c': 2636 spec->type = FORMAT_TYPE_CHAR; 2637 return ++fmt - start; 2638 2639 case 's': 2640 spec->type = FORMAT_TYPE_STR; 2641 return ++fmt - start; 2642 2643 case 'p': 2644 spec->type = FORMAT_TYPE_PTR; 2645 return ++fmt - start; 2646 2647 case '%': 2648 spec->type = FORMAT_TYPE_PERCENT_CHAR; 2649 return ++fmt - start; 2650 2651 /* integer number formats - set up the flags and "break" */ 2652 case 'o': 2653 spec->base = 8; 2654 break; 2655 2656 case 'x': 2657 spec->flags |= SMALL; 2658 fallthrough; 2659 2660 case 'X': 2661 spec->base = 16; 2662 break; 2663 2664 case 'd': 2665 case 'i': 2666 spec->flags |= SIGN; 2667 break; 2668 case 'u': 2669 break; 2670 2671 case 'n': 2672 /* 2673 * Since %n poses a greater security risk than 2674 * utility, treat it as any other invalid or 2675 * unsupported format specifier. 2676 */ 2677 fallthrough; 2678 2679 default: 2680 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt); 2681 spec->type = FORMAT_TYPE_INVALID; 2682 return fmt - start; 2683 } 2684 2685 if (qualifier == 'L') 2686 spec->type = FORMAT_TYPE_LONG_LONG; 2687 else if (qualifier == 'l') { 2688 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 2689 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 2690 } else if (qualifier == 'z') { 2691 spec->type = FORMAT_TYPE_SIZE_T; 2692 } else if (qualifier == 't') { 2693 spec->type = FORMAT_TYPE_PTRDIFF; 2694 } else if (qualifier == 'H') { 2695 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE); 2696 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN); 2697 } else if (qualifier == 'h') { 2698 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT); 2699 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN); 2700 } else { 2701 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT); 2702 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN); 2703 } 2704 2705 return ++fmt - start; 2706 } 2707 2708 static void 2709 set_field_width(struct printf_spec *spec, int width) 2710 { 2711 spec->field_width = width; 2712 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) { 2713 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX); 2714 } 2715 } 2716 2717 static void 2718 set_precision(struct printf_spec *spec, int prec) 2719 { 2720 spec->precision = prec; 2721 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) { 2722 spec->precision = clamp(prec, 0, PRECISION_MAX); 2723 } 2724 } 2725 2726 /** 2727 * vsnprintf - Format a string and place it in a buffer 2728 * @buf: The buffer to place the result into 2729 * @size: The size of the buffer, including the trailing null space 2730 * @fmt: The format string to use 2731 * @args: Arguments for the format string 2732 * 2733 * This function generally follows C99 vsnprintf, but has some 2734 * extensions and a few limitations: 2735 * 2736 * - ``%n`` is unsupported 2737 * - ``%p*`` is handled by pointer() 2738 * 2739 * See pointer() or Documentation/core-api/printk-formats.rst for more 2740 * extensive description. 2741 * 2742 * **Please update the documentation in both places when making changes** 2743 * 2744 * The return value is the number of characters which would 2745 * be generated for the given input, excluding the trailing 2746 * '\0', as per ISO C99. If you want to have the exact 2747 * number of characters written into @buf as return value 2748 * (not including the trailing '\0'), use vscnprintf(). If the 2749 * return is greater than or equal to @size, the resulting 2750 * string is truncated. 2751 * 2752 * If you're not already dealing with a va_list consider using snprintf(). 2753 */ 2754 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 2755 { 2756 unsigned long long num; 2757 char *str, *end; 2758 struct printf_spec spec = {0}; 2759 2760 /* Reject out-of-range values early. Large positive sizes are 2761 used for unknown buffer sizes. */ 2762 if (WARN_ON_ONCE(size > INT_MAX)) 2763 return 0; 2764 2765 str = buf; 2766 end = buf + size; 2767 2768 /* Make sure end is always >= buf */ 2769 if (end < buf) { 2770 end = ((void *)-1); 2771 size = end - buf; 2772 } 2773 2774 while (*fmt) { 2775 const char *old_fmt = fmt; 2776 int read = format_decode(fmt, &spec); 2777 2778 fmt += read; 2779 2780 switch (spec.type) { 2781 case FORMAT_TYPE_NONE: { 2782 int copy = read; 2783 if (str < end) { 2784 if (copy > end - str) 2785 copy = end - str; 2786 memcpy(str, old_fmt, copy); 2787 } 2788 str += read; 2789 break; 2790 } 2791 2792 case FORMAT_TYPE_WIDTH: 2793 set_field_width(&spec, va_arg(args, int)); 2794 break; 2795 2796 case FORMAT_TYPE_PRECISION: 2797 set_precision(&spec, va_arg(args, int)); 2798 break; 2799 2800 case FORMAT_TYPE_CHAR: { 2801 char c; 2802 2803 if (!(spec.flags & LEFT)) { 2804 while (--spec.field_width > 0) { 2805 if (str < end) 2806 *str = ' '; 2807 ++str; 2808 2809 } 2810 } 2811 c = (unsigned char) va_arg(args, int); 2812 if (str < end) 2813 *str = c; 2814 ++str; 2815 while (--spec.field_width > 0) { 2816 if (str < end) 2817 *str = ' '; 2818 ++str; 2819 } 2820 break; 2821 } 2822 2823 case FORMAT_TYPE_STR: 2824 str = string(str, end, va_arg(args, char *), spec); 2825 break; 2826 2827 case FORMAT_TYPE_PTR: 2828 str = pointer(fmt, str, end, va_arg(args, void *), 2829 spec); 2830 while (isalnum(*fmt)) 2831 fmt++; 2832 break; 2833 2834 case FORMAT_TYPE_PERCENT_CHAR: 2835 if (str < end) 2836 *str = '%'; 2837 ++str; 2838 break; 2839 2840 case FORMAT_TYPE_INVALID: 2841 /* 2842 * Presumably the arguments passed gcc's type 2843 * checking, but there is no safe or sane way 2844 * for us to continue parsing the format and 2845 * fetching from the va_list; the remaining 2846 * specifiers and arguments would be out of 2847 * sync. 2848 */ 2849 goto out; 2850 2851 default: 2852 switch (spec.type) { 2853 case FORMAT_TYPE_LONG_LONG: 2854 num = va_arg(args, long long); 2855 break; 2856 case FORMAT_TYPE_ULONG: 2857 num = va_arg(args, unsigned long); 2858 break; 2859 case FORMAT_TYPE_LONG: 2860 num = va_arg(args, long); 2861 break; 2862 case FORMAT_TYPE_SIZE_T: 2863 if (spec.flags & SIGN) 2864 num = va_arg(args, ssize_t); 2865 else 2866 num = va_arg(args, size_t); 2867 break; 2868 case FORMAT_TYPE_PTRDIFF: 2869 num = va_arg(args, ptrdiff_t); 2870 break; 2871 case FORMAT_TYPE_UBYTE: 2872 num = (unsigned char) va_arg(args, int); 2873 break; 2874 case FORMAT_TYPE_BYTE: 2875 num = (signed char) va_arg(args, int); 2876 break; 2877 case FORMAT_TYPE_USHORT: 2878 num = (unsigned short) va_arg(args, int); 2879 break; 2880 case FORMAT_TYPE_SHORT: 2881 num = (short) va_arg(args, int); 2882 break; 2883 case FORMAT_TYPE_INT: 2884 num = (int) va_arg(args, int); 2885 break; 2886 default: 2887 num = va_arg(args, unsigned int); 2888 } 2889 2890 str = number(str, end, num, spec); 2891 } 2892 } 2893 2894 out: 2895 if (size > 0) { 2896 if (str < end) 2897 *str = '\0'; 2898 else 2899 end[-1] = '\0'; 2900 } 2901 2902 /* the trailing null byte doesn't count towards the total */ 2903 return str-buf; 2904 2905 } 2906 EXPORT_SYMBOL(vsnprintf); 2907 2908 /** 2909 * vscnprintf - Format a string and place it in a buffer 2910 * @buf: The buffer to place the result into 2911 * @size: The size of the buffer, including the trailing null space 2912 * @fmt: The format string to use 2913 * @args: Arguments for the format string 2914 * 2915 * The return value is the number of characters which have been written into 2916 * the @buf not including the trailing '\0'. If @size is == 0 the function 2917 * returns 0. 2918 * 2919 * If you're not already dealing with a va_list consider using scnprintf(). 2920 * 2921 * See the vsnprintf() documentation for format string extensions over C99. 2922 */ 2923 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 2924 { 2925 int i; 2926 2927 if (unlikely(!size)) 2928 return 0; 2929 2930 i = vsnprintf(buf, size, fmt, args); 2931 2932 if (likely(i < size)) 2933 return i; 2934 2935 return size - 1; 2936 } 2937 EXPORT_SYMBOL(vscnprintf); 2938 2939 /** 2940 * snprintf - Format a string and place it in a buffer 2941 * @buf: The buffer to place the result into 2942 * @size: The size of the buffer, including the trailing null space 2943 * @fmt: The format string to use 2944 * @...: Arguments for the format string 2945 * 2946 * The return value is the number of characters which would be 2947 * generated for the given input, excluding the trailing null, 2948 * as per ISO C99. If the return is greater than or equal to 2949 * @size, the resulting string is truncated. 2950 * 2951 * See the vsnprintf() documentation for format string extensions over C99. 2952 */ 2953 int snprintf(char *buf, size_t size, const char *fmt, ...) 2954 { 2955 va_list args; 2956 int i; 2957 2958 va_start(args, fmt); 2959 i = vsnprintf(buf, size, fmt, args); 2960 va_end(args); 2961 2962 return i; 2963 } 2964 EXPORT_SYMBOL(snprintf); 2965 2966 /** 2967 * scnprintf - Format a string and place it in a buffer 2968 * @buf: The buffer to place the result into 2969 * @size: The size of the buffer, including the trailing null space 2970 * @fmt: The format string to use 2971 * @...: Arguments for the format string 2972 * 2973 * The return value is the number of characters written into @buf not including 2974 * the trailing '\0'. If @size is == 0 the function returns 0. 2975 */ 2976 2977 int scnprintf(char *buf, size_t size, const char *fmt, ...) 2978 { 2979 va_list args; 2980 int i; 2981 2982 va_start(args, fmt); 2983 i = vscnprintf(buf, size, fmt, args); 2984 va_end(args); 2985 2986 return i; 2987 } 2988 EXPORT_SYMBOL(scnprintf); 2989 2990 /** 2991 * vsprintf - Format a string and place it in a buffer 2992 * @buf: The buffer to place the result into 2993 * @fmt: The format string to use 2994 * @args: Arguments for the format string 2995 * 2996 * The function returns the number of characters written 2997 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 2998 * buffer overflows. 2999 * 3000 * If you're not already dealing with a va_list consider using sprintf(). 3001 * 3002 * See the vsnprintf() documentation for format string extensions over C99. 3003 */ 3004 int vsprintf(char *buf, const char *fmt, va_list args) 3005 { 3006 return vsnprintf(buf, INT_MAX, fmt, args); 3007 } 3008 EXPORT_SYMBOL(vsprintf); 3009 3010 /** 3011 * sprintf - Format a string and place it in a buffer 3012 * @buf: The buffer to place the result into 3013 * @fmt: The format string to use 3014 * @...: Arguments for the format string 3015 * 3016 * The function returns the number of characters written 3017 * into @buf. Use snprintf() or scnprintf() in order to avoid 3018 * buffer overflows. 3019 * 3020 * See the vsnprintf() documentation for format string extensions over C99. 3021 */ 3022 int sprintf(char *buf, const char *fmt, ...) 3023 { 3024 va_list args; 3025 int i; 3026 3027 va_start(args, fmt); 3028 i = vsnprintf(buf, INT_MAX, fmt, args); 3029 va_end(args); 3030 3031 return i; 3032 } 3033 EXPORT_SYMBOL(sprintf); 3034 3035 #ifdef CONFIG_BINARY_PRINTF 3036 /* 3037 * bprintf service: 3038 * vbin_printf() - VA arguments to binary data 3039 * bstr_printf() - Binary data to text string 3040 */ 3041 3042 /** 3043 * vbin_printf - Parse a format string and place args' binary value in a buffer 3044 * @bin_buf: The buffer to place args' binary value 3045 * @size: The size of the buffer(by words(32bits), not characters) 3046 * @fmt: The format string to use 3047 * @args: Arguments for the format string 3048 * 3049 * The format follows C99 vsnprintf, except %n is ignored, and its argument 3050 * is skipped. 3051 * 3052 * The return value is the number of words(32bits) which would be generated for 3053 * the given input. 3054 * 3055 * NOTE: 3056 * If the return value is greater than @size, the resulting bin_buf is NOT 3057 * valid for bstr_printf(). 3058 */ 3059 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 3060 { 3061 struct printf_spec spec = {0}; 3062 char *str, *end; 3063 int width; 3064 3065 str = (char *)bin_buf; 3066 end = (char *)(bin_buf + size); 3067 3068 #define save_arg(type) \ 3069 ({ \ 3070 unsigned long long value; \ 3071 if (sizeof(type) == 8) { \ 3072 unsigned long long val8; \ 3073 str = PTR_ALIGN(str, sizeof(u32)); \ 3074 val8 = va_arg(args, unsigned long long); \ 3075 if (str + sizeof(type) <= end) { \ 3076 *(u32 *)str = *(u32 *)&val8; \ 3077 *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \ 3078 } \ 3079 value = val8; \ 3080 } else { \ 3081 unsigned int val4; \ 3082 str = PTR_ALIGN(str, sizeof(type)); \ 3083 val4 = va_arg(args, int); \ 3084 if (str + sizeof(type) <= end) \ 3085 *(typeof(type) *)str = (type)(long)val4; \ 3086 value = (unsigned long long)val4; \ 3087 } \ 3088 str += sizeof(type); \ 3089 value; \ 3090 }) 3091 3092 while (*fmt) { 3093 int read = format_decode(fmt, &spec); 3094 3095 fmt += read; 3096 3097 switch (spec.type) { 3098 case FORMAT_TYPE_NONE: 3099 case FORMAT_TYPE_PERCENT_CHAR: 3100 break; 3101 case FORMAT_TYPE_INVALID: 3102 goto out; 3103 3104 case FORMAT_TYPE_WIDTH: 3105 case FORMAT_TYPE_PRECISION: 3106 width = (int)save_arg(int); 3107 /* Pointers may require the width */ 3108 if (*fmt == 'p') 3109 set_field_width(&spec, width); 3110 break; 3111 3112 case FORMAT_TYPE_CHAR: 3113 save_arg(char); 3114 break; 3115 3116 case FORMAT_TYPE_STR: { 3117 const char *save_str = va_arg(args, char *); 3118 const char *err_msg; 3119 size_t len; 3120 3121 err_msg = check_pointer_msg(save_str); 3122 if (err_msg) 3123 save_str = err_msg; 3124 3125 len = strlen(save_str) + 1; 3126 if (str + len < end) 3127 memcpy(str, save_str, len); 3128 str += len; 3129 break; 3130 } 3131 3132 case FORMAT_TYPE_PTR: 3133 /* Dereferenced pointers must be done now */ 3134 switch (*fmt) { 3135 /* Dereference of functions is still OK */ 3136 case 'S': 3137 case 's': 3138 case 'x': 3139 case 'K': 3140 case 'e': 3141 save_arg(void *); 3142 break; 3143 default: 3144 if (!isalnum(*fmt)) { 3145 save_arg(void *); 3146 break; 3147 } 3148 str = pointer(fmt, str, end, va_arg(args, void *), 3149 spec); 3150 if (str + 1 < end) 3151 *str++ = '\0'; 3152 else 3153 end[-1] = '\0'; /* Must be nul terminated */ 3154 } 3155 /* skip all alphanumeric pointer suffixes */ 3156 while (isalnum(*fmt)) 3157 fmt++; 3158 break; 3159 3160 default: 3161 switch (spec.type) { 3162 3163 case FORMAT_TYPE_LONG_LONG: 3164 save_arg(long long); 3165 break; 3166 case FORMAT_TYPE_ULONG: 3167 case FORMAT_TYPE_LONG: 3168 save_arg(unsigned long); 3169 break; 3170 case FORMAT_TYPE_SIZE_T: 3171 save_arg(size_t); 3172 break; 3173 case FORMAT_TYPE_PTRDIFF: 3174 save_arg(ptrdiff_t); 3175 break; 3176 case FORMAT_TYPE_UBYTE: 3177 case FORMAT_TYPE_BYTE: 3178 save_arg(char); 3179 break; 3180 case FORMAT_TYPE_USHORT: 3181 case FORMAT_TYPE_SHORT: 3182 save_arg(short); 3183 break; 3184 default: 3185 save_arg(int); 3186 } 3187 } 3188 } 3189 3190 out: 3191 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 3192 #undef save_arg 3193 } 3194 EXPORT_SYMBOL_GPL(vbin_printf); 3195 3196 /** 3197 * bstr_printf - Format a string from binary arguments and place it in a buffer 3198 * @buf: The buffer to place the result into 3199 * @size: The size of the buffer, including the trailing null space 3200 * @fmt: The format string to use 3201 * @bin_buf: Binary arguments for the format string 3202 * 3203 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 3204 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 3205 * a binary buffer that generated by vbin_printf. 3206 * 3207 * The format follows C99 vsnprintf, but has some extensions: 3208 * see vsnprintf comment for details. 3209 * 3210 * The return value is the number of characters which would 3211 * be generated for the given input, excluding the trailing 3212 * '\0', as per ISO C99. If you want to have the exact 3213 * number of characters written into @buf as return value 3214 * (not including the trailing '\0'), use vscnprintf(). If the 3215 * return is greater than or equal to @size, the resulting 3216 * string is truncated. 3217 */ 3218 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 3219 { 3220 struct printf_spec spec = {0}; 3221 char *str, *end; 3222 const char *args = (const char *)bin_buf; 3223 3224 if (WARN_ON_ONCE(size > INT_MAX)) 3225 return 0; 3226 3227 str = buf; 3228 end = buf + size; 3229 3230 #define get_arg(type) \ 3231 ({ \ 3232 typeof(type) value; \ 3233 if (sizeof(type) == 8) { \ 3234 args = PTR_ALIGN(args, sizeof(u32)); \ 3235 *(u32 *)&value = *(u32 *)args; \ 3236 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 3237 } else { \ 3238 args = PTR_ALIGN(args, sizeof(type)); \ 3239 value = *(typeof(type) *)args; \ 3240 } \ 3241 args += sizeof(type); \ 3242 value; \ 3243 }) 3244 3245 /* Make sure end is always >= buf */ 3246 if (end < buf) { 3247 end = ((void *)-1); 3248 size = end - buf; 3249 } 3250 3251 while (*fmt) { 3252 const char *old_fmt = fmt; 3253 int read = format_decode(fmt, &spec); 3254 3255 fmt += read; 3256 3257 switch (spec.type) { 3258 case FORMAT_TYPE_NONE: { 3259 int copy = read; 3260 if (str < end) { 3261 if (copy > end - str) 3262 copy = end - str; 3263 memcpy(str, old_fmt, copy); 3264 } 3265 str += read; 3266 break; 3267 } 3268 3269 case FORMAT_TYPE_WIDTH: 3270 set_field_width(&spec, get_arg(int)); 3271 break; 3272 3273 case FORMAT_TYPE_PRECISION: 3274 set_precision(&spec, get_arg(int)); 3275 break; 3276 3277 case FORMAT_TYPE_CHAR: { 3278 char c; 3279 3280 if (!(spec.flags & LEFT)) { 3281 while (--spec.field_width > 0) { 3282 if (str < end) 3283 *str = ' '; 3284 ++str; 3285 } 3286 } 3287 c = (unsigned char) get_arg(char); 3288 if (str < end) 3289 *str = c; 3290 ++str; 3291 while (--spec.field_width > 0) { 3292 if (str < end) 3293 *str = ' '; 3294 ++str; 3295 } 3296 break; 3297 } 3298 3299 case FORMAT_TYPE_STR: { 3300 const char *str_arg = args; 3301 args += strlen(str_arg) + 1; 3302 str = string(str, end, (char *)str_arg, spec); 3303 break; 3304 } 3305 3306 case FORMAT_TYPE_PTR: { 3307 bool process = false; 3308 int copy, len; 3309 /* Non function dereferences were already done */ 3310 switch (*fmt) { 3311 case 'S': 3312 case 's': 3313 case 'x': 3314 case 'K': 3315 case 'e': 3316 process = true; 3317 break; 3318 default: 3319 if (!isalnum(*fmt)) { 3320 process = true; 3321 break; 3322 } 3323 /* Pointer dereference was already processed */ 3324 if (str < end) { 3325 len = copy = strlen(args); 3326 if (copy > end - str) 3327 copy = end - str; 3328 memcpy(str, args, copy); 3329 str += len; 3330 args += len + 1; 3331 } 3332 } 3333 if (process) 3334 str = pointer(fmt, str, end, get_arg(void *), spec); 3335 3336 while (isalnum(*fmt)) 3337 fmt++; 3338 break; 3339 } 3340 3341 case FORMAT_TYPE_PERCENT_CHAR: 3342 if (str < end) 3343 *str = '%'; 3344 ++str; 3345 break; 3346 3347 case FORMAT_TYPE_INVALID: 3348 goto out; 3349 3350 default: { 3351 unsigned long long num; 3352 3353 switch (spec.type) { 3354 3355 case FORMAT_TYPE_LONG_LONG: 3356 num = get_arg(long long); 3357 break; 3358 case FORMAT_TYPE_ULONG: 3359 case FORMAT_TYPE_LONG: 3360 num = get_arg(unsigned long); 3361 break; 3362 case FORMAT_TYPE_SIZE_T: 3363 num = get_arg(size_t); 3364 break; 3365 case FORMAT_TYPE_PTRDIFF: 3366 num = get_arg(ptrdiff_t); 3367 break; 3368 case FORMAT_TYPE_UBYTE: 3369 num = get_arg(unsigned char); 3370 break; 3371 case FORMAT_TYPE_BYTE: 3372 num = get_arg(signed char); 3373 break; 3374 case FORMAT_TYPE_USHORT: 3375 num = get_arg(unsigned short); 3376 break; 3377 case FORMAT_TYPE_SHORT: 3378 num = get_arg(short); 3379 break; 3380 case FORMAT_TYPE_UINT: 3381 num = get_arg(unsigned int); 3382 break; 3383 default: 3384 num = get_arg(int); 3385 } 3386 3387 str = number(str, end, num, spec); 3388 } /* default: */ 3389 } /* switch(spec.type) */ 3390 } /* while(*fmt) */ 3391 3392 out: 3393 if (size > 0) { 3394 if (str < end) 3395 *str = '\0'; 3396 else 3397 end[-1] = '\0'; 3398 } 3399 3400 #undef get_arg 3401 3402 /* the trailing null byte doesn't count towards the total */ 3403 return str - buf; 3404 } 3405 EXPORT_SYMBOL_GPL(bstr_printf); 3406 3407 /** 3408 * bprintf - Parse a format string and place args' binary value in a buffer 3409 * @bin_buf: The buffer to place args' binary value 3410 * @size: The size of the buffer(by words(32bits), not characters) 3411 * @fmt: The format string to use 3412 * @...: Arguments for the format string 3413 * 3414 * The function returns the number of words(u32) written 3415 * into @bin_buf. 3416 */ 3417 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 3418 { 3419 va_list args; 3420 int ret; 3421 3422 va_start(args, fmt); 3423 ret = vbin_printf(bin_buf, size, fmt, args); 3424 va_end(args); 3425 3426 return ret; 3427 } 3428 EXPORT_SYMBOL_GPL(bprintf); 3429 3430 #endif /* CONFIG_BINARY_PRINTF */ 3431 3432 /** 3433 * vsscanf - Unformat a buffer into a list of arguments 3434 * @buf: input buffer 3435 * @fmt: format of buffer 3436 * @args: arguments 3437 */ 3438 int vsscanf(const char *buf, const char *fmt, va_list args) 3439 { 3440 const char *str = buf; 3441 char *next; 3442 char digit; 3443 int num = 0; 3444 u8 qualifier; 3445 unsigned int base; 3446 union { 3447 long long s; 3448 unsigned long long u; 3449 } val; 3450 s16 field_width; 3451 bool is_sign; 3452 3453 while (*fmt) { 3454 /* skip any white space in format */ 3455 /* white space in format matches any amount of 3456 * white space, including none, in the input. 3457 */ 3458 if (isspace(*fmt)) { 3459 fmt = skip_spaces(++fmt); 3460 str = skip_spaces(str); 3461 } 3462 3463 /* anything that is not a conversion must match exactly */ 3464 if (*fmt != '%' && *fmt) { 3465 if (*fmt++ != *str++) 3466 break; 3467 continue; 3468 } 3469 3470 if (!*fmt) 3471 break; 3472 ++fmt; 3473 3474 /* skip this conversion. 3475 * advance both strings to next white space 3476 */ 3477 if (*fmt == '*') { 3478 if (!*str) 3479 break; 3480 while (!isspace(*fmt) && *fmt != '%' && *fmt) { 3481 /* '%*[' not yet supported, invalid format */ 3482 if (*fmt == '[') 3483 return num; 3484 fmt++; 3485 } 3486 while (!isspace(*str) && *str) 3487 str++; 3488 continue; 3489 } 3490 3491 /* get field width */ 3492 field_width = -1; 3493 if (isdigit(*fmt)) { 3494 field_width = skip_atoi(&fmt); 3495 if (field_width <= 0) 3496 break; 3497 } 3498 3499 /* get conversion qualifier */ 3500 qualifier = -1; 3501 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 3502 *fmt == 'z') { 3503 qualifier = *fmt++; 3504 if (unlikely(qualifier == *fmt)) { 3505 if (qualifier == 'h') { 3506 qualifier = 'H'; 3507 fmt++; 3508 } else if (qualifier == 'l') { 3509 qualifier = 'L'; 3510 fmt++; 3511 } 3512 } 3513 } 3514 3515 if (!*fmt) 3516 break; 3517 3518 if (*fmt == 'n') { 3519 /* return number of characters read so far */ 3520 *va_arg(args, int *) = str - buf; 3521 ++fmt; 3522 continue; 3523 } 3524 3525 if (!*str) 3526 break; 3527 3528 base = 10; 3529 is_sign = false; 3530 3531 switch (*fmt++) { 3532 case 'c': 3533 { 3534 char *s = (char *)va_arg(args, char*); 3535 if (field_width == -1) 3536 field_width = 1; 3537 do { 3538 *s++ = *str++; 3539 } while (--field_width > 0 && *str); 3540 num++; 3541 } 3542 continue; 3543 case 's': 3544 { 3545 char *s = (char *)va_arg(args, char *); 3546 if (field_width == -1) 3547 field_width = SHRT_MAX; 3548 /* first, skip leading white space in buffer */ 3549 str = skip_spaces(str); 3550 3551 /* now copy until next white space */ 3552 while (*str && !isspace(*str) && field_width--) 3553 *s++ = *str++; 3554 *s = '\0'; 3555 num++; 3556 } 3557 continue; 3558 /* 3559 * Warning: This implementation of the '[' conversion specifier 3560 * deviates from its glibc counterpart in the following ways: 3561 * (1) It does NOT support ranges i.e. '-' is NOT a special 3562 * character 3563 * (2) It cannot match the closing bracket ']' itself 3564 * (3) A field width is required 3565 * (4) '%*[' (discard matching input) is currently not supported 3566 * 3567 * Example usage: 3568 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]", 3569 * buf1, buf2, buf3); 3570 * if (ret < 3) 3571 * // etc.. 3572 */ 3573 case '[': 3574 { 3575 char *s = (char *)va_arg(args, char *); 3576 DECLARE_BITMAP(set, 256) = {0}; 3577 unsigned int len = 0; 3578 bool negate = (*fmt == '^'); 3579 3580 /* field width is required */ 3581 if (field_width == -1) 3582 return num; 3583 3584 if (negate) 3585 ++fmt; 3586 3587 for ( ; *fmt && *fmt != ']'; ++fmt, ++len) 3588 __set_bit((u8)*fmt, set); 3589 3590 /* no ']' or no character set found */ 3591 if (!*fmt || !len) 3592 return num; 3593 ++fmt; 3594 3595 if (negate) { 3596 bitmap_complement(set, set, 256); 3597 /* exclude null '\0' byte */ 3598 __clear_bit(0, set); 3599 } 3600 3601 /* match must be non-empty */ 3602 if (!test_bit((u8)*str, set)) 3603 return num; 3604 3605 while (test_bit((u8)*str, set) && field_width--) 3606 *s++ = *str++; 3607 *s = '\0'; 3608 ++num; 3609 } 3610 continue; 3611 case 'o': 3612 base = 8; 3613 break; 3614 case 'x': 3615 case 'X': 3616 base = 16; 3617 break; 3618 case 'i': 3619 base = 0; 3620 fallthrough; 3621 case 'd': 3622 is_sign = true; 3623 fallthrough; 3624 case 'u': 3625 break; 3626 case '%': 3627 /* looking for '%' in str */ 3628 if (*str++ != '%') 3629 return num; 3630 continue; 3631 default: 3632 /* invalid format; stop here */ 3633 return num; 3634 } 3635 3636 /* have some sort of integer conversion. 3637 * first, skip white space in buffer. 3638 */ 3639 str = skip_spaces(str); 3640 3641 digit = *str; 3642 if (is_sign && digit == '-') { 3643 if (field_width == 1) 3644 break; 3645 3646 digit = *(str + 1); 3647 } 3648 3649 if (!digit 3650 || (base == 16 && !isxdigit(digit)) 3651 || (base == 10 && !isdigit(digit)) 3652 || (base == 8 && !isodigit(digit)) 3653 || (base == 0 && !isdigit(digit))) 3654 break; 3655 3656 if (is_sign) 3657 val.s = simple_strntoll(str, &next, base, 3658 field_width >= 0 ? field_width : INT_MAX); 3659 else 3660 val.u = simple_strntoull(str, &next, base, 3661 field_width >= 0 ? field_width : INT_MAX); 3662 3663 switch (qualifier) { 3664 case 'H': /* that's 'hh' in format */ 3665 if (is_sign) 3666 *va_arg(args, signed char *) = val.s; 3667 else 3668 *va_arg(args, unsigned char *) = val.u; 3669 break; 3670 case 'h': 3671 if (is_sign) 3672 *va_arg(args, short *) = val.s; 3673 else 3674 *va_arg(args, unsigned short *) = val.u; 3675 break; 3676 case 'l': 3677 if (is_sign) 3678 *va_arg(args, long *) = val.s; 3679 else 3680 *va_arg(args, unsigned long *) = val.u; 3681 break; 3682 case 'L': 3683 if (is_sign) 3684 *va_arg(args, long long *) = val.s; 3685 else 3686 *va_arg(args, unsigned long long *) = val.u; 3687 break; 3688 case 'z': 3689 *va_arg(args, size_t *) = val.u; 3690 break; 3691 default: 3692 if (is_sign) 3693 *va_arg(args, int *) = val.s; 3694 else 3695 *va_arg(args, unsigned int *) = val.u; 3696 break; 3697 } 3698 num++; 3699 3700 if (!next) 3701 break; 3702 str = next; 3703 } 3704 3705 return num; 3706 } 3707 EXPORT_SYMBOL(vsscanf); 3708 3709 /** 3710 * sscanf - Unformat a buffer into a list of arguments 3711 * @buf: input buffer 3712 * @fmt: formatting of buffer 3713 * @...: resulting arguments 3714 */ 3715 int sscanf(const char *buf, const char *fmt, ...) 3716 { 3717 va_list args; 3718 int i; 3719 3720 va_start(args, fmt); 3721 i = vsscanf(buf, fmt, args); 3722 va_end(args); 3723 3724 return i; 3725 } 3726 EXPORT_SYMBOL(sscanf); 3727