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