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 noinline_for_stack 697 char *resource_string(char *buf, char *end, struct resource *res, 698 struct printf_spec spec, const char *fmt) 699 { 700 #ifndef IO_RSRC_PRINTK_SIZE 701 #define IO_RSRC_PRINTK_SIZE 6 702 #endif 703 704 #ifndef MEM_RSRC_PRINTK_SIZE 705 #define MEM_RSRC_PRINTK_SIZE 10 706 #endif 707 static const struct printf_spec io_spec = { 708 .base = 16, 709 .field_width = IO_RSRC_PRINTK_SIZE, 710 .precision = -1, 711 .flags = SPECIAL | SMALL | ZEROPAD, 712 }; 713 static const struct printf_spec mem_spec = { 714 .base = 16, 715 .field_width = MEM_RSRC_PRINTK_SIZE, 716 .precision = -1, 717 .flags = SPECIAL | SMALL | ZEROPAD, 718 }; 719 static const struct printf_spec bus_spec = { 720 .base = 16, 721 .field_width = 2, 722 .precision = -1, 723 .flags = SMALL | ZEROPAD, 724 }; 725 static const struct printf_spec dec_spec = { 726 .base = 10, 727 .precision = -1, 728 .flags = 0, 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 = &dec_spec; 764 } else if (res->flags & IORESOURCE_DMA) { 765 p = string(p, pend, "dma ", str_spec); 766 specp = &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 /* reused to print numbers */ 907 spec = (struct printf_spec){ .base = 10 }; 908 909 rbot = cur = find_first_bit(bitmap, nr_bits); 910 while (cur < nr_bits) { 911 rtop = cur; 912 cur = find_next_bit(bitmap, nr_bits, cur + 1); 913 if (cur < nr_bits && cur <= rtop + 1) 914 continue; 915 916 if (!first) { 917 if (buf < end) 918 *buf = ','; 919 buf++; 920 } 921 first = false; 922 923 buf = number(buf, end, rbot, spec); 924 if (rbot < rtop) { 925 if (buf < end) 926 *buf = '-'; 927 buf++; 928 929 buf = number(buf, end, rtop, spec); 930 } 931 932 rbot = cur; 933 } 934 return buf; 935 } 936 937 static noinline_for_stack 938 char *mac_address_string(char *buf, char *end, u8 *addr, 939 struct printf_spec spec, const char *fmt) 940 { 941 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")]; 942 char *p = mac_addr; 943 int i; 944 char separator; 945 bool reversed = false; 946 947 switch (fmt[1]) { 948 case 'F': 949 separator = '-'; 950 break; 951 952 case 'R': 953 reversed = true; 954 /* fall through */ 955 956 default: 957 separator = ':'; 958 break; 959 } 960 961 for (i = 0; i < 6; i++) { 962 if (reversed) 963 p = hex_byte_pack(p, addr[5 - i]); 964 else 965 p = hex_byte_pack(p, addr[i]); 966 967 if (fmt[0] == 'M' && i != 5) 968 *p++ = separator; 969 } 970 *p = '\0'; 971 972 return string(buf, end, mac_addr, spec); 973 } 974 975 static noinline_for_stack 976 char *ip4_string(char *p, const u8 *addr, const char *fmt) 977 { 978 int i; 979 bool leading_zeros = (fmt[0] == 'i'); 980 int index; 981 int step; 982 983 switch (fmt[2]) { 984 case 'h': 985 #ifdef __BIG_ENDIAN 986 index = 0; 987 step = 1; 988 #else 989 index = 3; 990 step = -1; 991 #endif 992 break; 993 case 'l': 994 index = 3; 995 step = -1; 996 break; 997 case 'n': 998 case 'b': 999 default: 1000 index = 0; 1001 step = 1; 1002 break; 1003 } 1004 for (i = 0; i < 4; i++) { 1005 char temp[4] __aligned(2); /* hold each IP quad in reverse order */ 1006 int digits = put_dec_trunc8(temp, addr[index]) - temp; 1007 if (leading_zeros) { 1008 if (digits < 3) 1009 *p++ = '0'; 1010 if (digits < 2) 1011 *p++ = '0'; 1012 } 1013 /* reverse the digits in the quad */ 1014 while (digits--) 1015 *p++ = temp[digits]; 1016 if (i < 3) 1017 *p++ = '.'; 1018 index += step; 1019 } 1020 *p = '\0'; 1021 1022 return p; 1023 } 1024 1025 static noinline_for_stack 1026 char *ip6_compressed_string(char *p, const char *addr) 1027 { 1028 int i, j, range; 1029 unsigned char zerolength[8]; 1030 int longest = 1; 1031 int colonpos = -1; 1032 u16 word; 1033 u8 hi, lo; 1034 bool needcolon = false; 1035 bool useIPv4; 1036 struct in6_addr in6; 1037 1038 memcpy(&in6, addr, sizeof(struct in6_addr)); 1039 1040 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 1041 1042 memset(zerolength, 0, sizeof(zerolength)); 1043 1044 if (useIPv4) 1045 range = 6; 1046 else 1047 range = 8; 1048 1049 /* find position of longest 0 run */ 1050 for (i = 0; i < range; i++) { 1051 for (j = i; j < range; j++) { 1052 if (in6.s6_addr16[j] != 0) 1053 break; 1054 zerolength[i]++; 1055 } 1056 } 1057 for (i = 0; i < range; i++) { 1058 if (zerolength[i] > longest) { 1059 longest = zerolength[i]; 1060 colonpos = i; 1061 } 1062 } 1063 if (longest == 1) /* don't compress a single 0 */ 1064 colonpos = -1; 1065 1066 /* emit address */ 1067 for (i = 0; i < range; i++) { 1068 if (i == colonpos) { 1069 if (needcolon || i == 0) 1070 *p++ = ':'; 1071 *p++ = ':'; 1072 needcolon = false; 1073 i += longest - 1; 1074 continue; 1075 } 1076 if (needcolon) { 1077 *p++ = ':'; 1078 needcolon = false; 1079 } 1080 /* hex u16 without leading 0s */ 1081 word = ntohs(in6.s6_addr16[i]); 1082 hi = word >> 8; 1083 lo = word & 0xff; 1084 if (hi) { 1085 if (hi > 0x0f) 1086 p = hex_byte_pack(p, hi); 1087 else 1088 *p++ = hex_asc_lo(hi); 1089 p = hex_byte_pack(p, lo); 1090 } 1091 else if (lo > 0x0f) 1092 p = hex_byte_pack(p, lo); 1093 else 1094 *p++ = hex_asc_lo(lo); 1095 needcolon = true; 1096 } 1097 1098 if (useIPv4) { 1099 if (needcolon) 1100 *p++ = ':'; 1101 p = ip4_string(p, &in6.s6_addr[12], "I4"); 1102 } 1103 *p = '\0'; 1104 1105 return p; 1106 } 1107 1108 static noinline_for_stack 1109 char *ip6_string(char *p, const char *addr, const char *fmt) 1110 { 1111 int i; 1112 1113 for (i = 0; i < 8; i++) { 1114 p = hex_byte_pack(p, *addr++); 1115 p = hex_byte_pack(p, *addr++); 1116 if (fmt[0] == 'I' && i != 7) 1117 *p++ = ':'; 1118 } 1119 *p = '\0'; 1120 1121 return p; 1122 } 1123 1124 static noinline_for_stack 1125 char *ip6_addr_string(char *buf, char *end, const u8 *addr, 1126 struct printf_spec spec, const char *fmt) 1127 { 1128 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 1129 1130 if (fmt[0] == 'I' && fmt[2] == 'c') 1131 ip6_compressed_string(ip6_addr, addr); 1132 else 1133 ip6_string(ip6_addr, addr, fmt); 1134 1135 return string(buf, end, ip6_addr, spec); 1136 } 1137 1138 static noinline_for_stack 1139 char *ip4_addr_string(char *buf, char *end, const u8 *addr, 1140 struct printf_spec spec, const char *fmt) 1141 { 1142 char ip4_addr[sizeof("255.255.255.255")]; 1143 1144 ip4_string(ip4_addr, addr, fmt); 1145 1146 return string(buf, end, ip4_addr, spec); 1147 } 1148 1149 static noinline_for_stack 1150 char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa, 1151 struct printf_spec spec, const char *fmt) 1152 { 1153 bool have_p = false, have_s = false, have_f = false, have_c = false; 1154 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") + 1155 sizeof(":12345") + sizeof("/123456789") + 1156 sizeof("%1234567890")]; 1157 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr); 1158 const u8 *addr = (const u8 *) &sa->sin6_addr; 1159 char fmt6[2] = { fmt[0], '6' }; 1160 u8 off = 0; 1161 1162 fmt++; 1163 while (isalpha(*++fmt)) { 1164 switch (*fmt) { 1165 case 'p': 1166 have_p = true; 1167 break; 1168 case 'f': 1169 have_f = true; 1170 break; 1171 case 's': 1172 have_s = true; 1173 break; 1174 case 'c': 1175 have_c = true; 1176 break; 1177 } 1178 } 1179 1180 if (have_p || have_s || have_f) { 1181 *p = '['; 1182 off = 1; 1183 } 1184 1185 if (fmt6[0] == 'I' && have_c) 1186 p = ip6_compressed_string(ip6_addr + off, addr); 1187 else 1188 p = ip6_string(ip6_addr + off, addr, fmt6); 1189 1190 if (have_p || have_s || have_f) 1191 *p++ = ']'; 1192 1193 if (have_p) { 1194 *p++ = ':'; 1195 p = number(p, pend, ntohs(sa->sin6_port), spec); 1196 } 1197 if (have_f) { 1198 *p++ = '/'; 1199 p = number(p, pend, ntohl(sa->sin6_flowinfo & 1200 IPV6_FLOWINFO_MASK), spec); 1201 } 1202 if (have_s) { 1203 *p++ = '%'; 1204 p = number(p, pend, sa->sin6_scope_id, spec); 1205 } 1206 *p = '\0'; 1207 1208 return string(buf, end, ip6_addr, spec); 1209 } 1210 1211 static noinline_for_stack 1212 char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa, 1213 struct printf_spec spec, const char *fmt) 1214 { 1215 bool have_p = false; 1216 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")]; 1217 char *pend = ip4_addr + sizeof(ip4_addr); 1218 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr; 1219 char fmt4[3] = { fmt[0], '4', 0 }; 1220 1221 fmt++; 1222 while (isalpha(*++fmt)) { 1223 switch (*fmt) { 1224 case 'p': 1225 have_p = true; 1226 break; 1227 case 'h': 1228 case 'l': 1229 case 'n': 1230 case 'b': 1231 fmt4[2] = *fmt; 1232 break; 1233 } 1234 } 1235 1236 p = ip4_string(ip4_addr, addr, fmt4); 1237 if (have_p) { 1238 *p++ = ':'; 1239 p = number(p, pend, ntohs(sa->sin_port), spec); 1240 } 1241 *p = '\0'; 1242 1243 return string(buf, end, ip4_addr, spec); 1244 } 1245 1246 static noinline_for_stack 1247 char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec, 1248 const char *fmt) 1249 { 1250 bool found = true; 1251 int count = 1; 1252 unsigned int flags = 0; 1253 int len; 1254 1255 if (spec.field_width == 0) 1256 return buf; /* nothing to print */ 1257 1258 if (ZERO_OR_NULL_PTR(addr)) 1259 return string(buf, end, NULL, spec); /* NULL pointer */ 1260 1261 1262 do { 1263 switch (fmt[count++]) { 1264 case 'a': 1265 flags |= ESCAPE_ANY; 1266 break; 1267 case 'c': 1268 flags |= ESCAPE_SPECIAL; 1269 break; 1270 case 'h': 1271 flags |= ESCAPE_HEX; 1272 break; 1273 case 'n': 1274 flags |= ESCAPE_NULL; 1275 break; 1276 case 'o': 1277 flags |= ESCAPE_OCTAL; 1278 break; 1279 case 'p': 1280 flags |= ESCAPE_NP; 1281 break; 1282 case 's': 1283 flags |= ESCAPE_SPACE; 1284 break; 1285 default: 1286 found = false; 1287 break; 1288 } 1289 } while (found); 1290 1291 if (!flags) 1292 flags = ESCAPE_ANY_NP; 1293 1294 len = spec.field_width < 0 ? 1 : spec.field_width; 1295 1296 /* 1297 * string_escape_mem() writes as many characters as it can to 1298 * the given buffer, and returns the total size of the output 1299 * had the buffer been big enough. 1300 */ 1301 buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL); 1302 1303 return buf; 1304 } 1305 1306 static noinline_for_stack 1307 char *uuid_string(char *buf, char *end, const u8 *addr, 1308 struct printf_spec spec, const char *fmt) 1309 { 1310 char uuid[UUID_STRING_LEN + 1]; 1311 char *p = uuid; 1312 int i; 1313 const u8 *index = uuid_index; 1314 bool uc = false; 1315 1316 switch (*(++fmt)) { 1317 case 'L': 1318 uc = true; /* fall-through */ 1319 case 'l': 1320 index = guid_index; 1321 break; 1322 case 'B': 1323 uc = true; 1324 break; 1325 } 1326 1327 for (i = 0; i < 16; i++) { 1328 if (uc) 1329 p = hex_byte_pack_upper(p, addr[index[i]]); 1330 else 1331 p = hex_byte_pack(p, addr[index[i]]); 1332 switch (i) { 1333 case 3: 1334 case 5: 1335 case 7: 1336 case 9: 1337 *p++ = '-'; 1338 break; 1339 } 1340 } 1341 1342 *p = 0; 1343 1344 return string(buf, end, uuid, spec); 1345 } 1346 1347 int kptr_restrict __read_mostly; 1348 1349 static noinline_for_stack 1350 char *restricted_pointer(char *buf, char *end, const void *ptr, 1351 struct printf_spec spec) 1352 { 1353 spec.base = 16; 1354 spec.flags |= SMALL; 1355 if (spec.field_width == -1) { 1356 spec.field_width = 2 * sizeof(ptr); 1357 spec.flags |= ZEROPAD; 1358 } 1359 1360 switch (kptr_restrict) { 1361 case 0: 1362 /* Always print %pK values */ 1363 break; 1364 case 1: { 1365 const struct cred *cred; 1366 1367 /* 1368 * kptr_restrict==1 cannot be used in IRQ context 1369 * because its test for CAP_SYSLOG would be meaningless. 1370 */ 1371 if (in_irq() || in_serving_softirq() || in_nmi()) 1372 return string(buf, end, "pK-error", spec); 1373 1374 /* 1375 * Only print the real pointer value if the current 1376 * process has CAP_SYSLOG and is running with the 1377 * same credentials it started with. This is because 1378 * access to files is checked at open() time, but %pK 1379 * checks permission at read() time. We don't want to 1380 * leak pointer values if a binary opens a file using 1381 * %pK and then elevates privileges before reading it. 1382 */ 1383 cred = current_cred(); 1384 if (!has_capability_noaudit(current, CAP_SYSLOG) || 1385 !uid_eq(cred->euid, cred->uid) || 1386 !gid_eq(cred->egid, cred->gid)) 1387 ptr = NULL; 1388 break; 1389 } 1390 case 2: 1391 default: 1392 /* Always print 0's for %pK */ 1393 ptr = NULL; 1394 break; 1395 } 1396 1397 return number(buf, end, (unsigned long)ptr, spec); 1398 } 1399 1400 static noinline_for_stack 1401 char *netdev_bits(char *buf, char *end, const void *addr, const char *fmt) 1402 { 1403 unsigned long long num; 1404 int size; 1405 1406 switch (fmt[1]) { 1407 case 'F': 1408 num = *(const netdev_features_t *)addr; 1409 size = sizeof(netdev_features_t); 1410 break; 1411 default: 1412 num = (unsigned long)addr; 1413 size = sizeof(unsigned long); 1414 break; 1415 } 1416 1417 return special_hex_number(buf, end, num, size); 1418 } 1419 1420 static noinline_for_stack 1421 char *address_val(char *buf, char *end, const void *addr, const char *fmt) 1422 { 1423 unsigned long long num; 1424 int size; 1425 1426 switch (fmt[1]) { 1427 case 'd': 1428 num = *(const dma_addr_t *)addr; 1429 size = sizeof(dma_addr_t); 1430 break; 1431 case 'p': 1432 default: 1433 num = *(const phys_addr_t *)addr; 1434 size = sizeof(phys_addr_t); 1435 break; 1436 } 1437 1438 return special_hex_number(buf, end, num, size); 1439 } 1440 1441 static noinline_for_stack 1442 char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec, 1443 const char *fmt) 1444 { 1445 if (!IS_ENABLED(CONFIG_HAVE_CLK) || !clk) 1446 return string(buf, end, NULL, spec); 1447 1448 switch (fmt[1]) { 1449 case 'r': 1450 return number(buf, end, clk_get_rate(clk), spec); 1451 1452 case 'n': 1453 default: 1454 #ifdef CONFIG_COMMON_CLK 1455 return string(buf, end, __clk_get_name(clk), spec); 1456 #else 1457 return special_hex_number(buf, end, (unsigned long)clk, sizeof(unsigned long)); 1458 #endif 1459 } 1460 } 1461 1462 static 1463 char *format_flags(char *buf, char *end, unsigned long flags, 1464 const struct trace_print_flags *names) 1465 { 1466 unsigned long mask; 1467 const struct printf_spec strspec = { 1468 .field_width = -1, 1469 .precision = -1, 1470 }; 1471 const struct printf_spec numspec = { 1472 .flags = SPECIAL|SMALL, 1473 .field_width = -1, 1474 .precision = -1, 1475 .base = 16, 1476 }; 1477 1478 for ( ; flags && names->name; names++) { 1479 mask = names->mask; 1480 if ((flags & mask) != mask) 1481 continue; 1482 1483 buf = string(buf, end, names->name, strspec); 1484 1485 flags &= ~mask; 1486 if (flags) { 1487 if (buf < end) 1488 *buf = '|'; 1489 buf++; 1490 } 1491 } 1492 1493 if (flags) 1494 buf = number(buf, end, flags, numspec); 1495 1496 return buf; 1497 } 1498 1499 static noinline_for_stack 1500 char *flags_string(char *buf, char *end, void *flags_ptr, const char *fmt) 1501 { 1502 unsigned long flags; 1503 const struct trace_print_flags *names; 1504 1505 switch (fmt[1]) { 1506 case 'p': 1507 flags = *(unsigned long *)flags_ptr; 1508 /* Remove zone id */ 1509 flags &= (1UL << NR_PAGEFLAGS) - 1; 1510 names = pageflag_names; 1511 break; 1512 case 'v': 1513 flags = *(unsigned long *)flags_ptr; 1514 names = vmaflag_names; 1515 break; 1516 case 'g': 1517 flags = *(gfp_t *)flags_ptr; 1518 names = gfpflag_names; 1519 break; 1520 default: 1521 WARN_ONCE(1, "Unsupported flags modifier: %c\n", fmt[1]); 1522 return buf; 1523 } 1524 1525 return format_flags(buf, end, flags, names); 1526 } 1527 1528 static const char *device_node_name_for_depth(const struct device_node *np, int depth) 1529 { 1530 for ( ; np && depth; depth--) 1531 np = np->parent; 1532 1533 return kbasename(np->full_name); 1534 } 1535 1536 static noinline_for_stack 1537 char *device_node_gen_full_name(const struct device_node *np, char *buf, char *end) 1538 { 1539 int depth; 1540 const struct device_node *parent = np->parent; 1541 static const struct printf_spec strspec = { 1542 .field_width = -1, 1543 .precision = -1, 1544 }; 1545 1546 /* special case for root node */ 1547 if (!parent) 1548 return string(buf, end, "/", strspec); 1549 1550 for (depth = 0; parent->parent; depth++) 1551 parent = parent->parent; 1552 1553 for ( ; depth >= 0; depth--) { 1554 buf = string(buf, end, "/", strspec); 1555 buf = string(buf, end, device_node_name_for_depth(np, depth), 1556 strspec); 1557 } 1558 return buf; 1559 } 1560 1561 static noinline_for_stack 1562 char *device_node_string(char *buf, char *end, struct device_node *dn, 1563 struct printf_spec spec, const char *fmt) 1564 { 1565 char tbuf[sizeof("xxxx") + 1]; 1566 const char *p; 1567 int ret; 1568 char *buf_start = buf; 1569 struct property *prop; 1570 bool has_mult, pass; 1571 static const struct printf_spec num_spec = { 1572 .flags = SMALL, 1573 .field_width = -1, 1574 .precision = -1, 1575 .base = 10, 1576 }; 1577 1578 struct printf_spec str_spec = spec; 1579 str_spec.field_width = -1; 1580 1581 if (!IS_ENABLED(CONFIG_OF)) 1582 return string(buf, end, "(!OF)", spec); 1583 1584 if ((unsigned long)dn < PAGE_SIZE) 1585 return string(buf, end, "(null)", spec); 1586 1587 /* simple case without anything any more format specifiers */ 1588 fmt++; 1589 if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0) 1590 fmt = "f"; 1591 1592 for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) { 1593 if (pass) { 1594 if (buf < end) 1595 *buf = ':'; 1596 buf++; 1597 } 1598 1599 switch (*fmt) { 1600 case 'f': /* full_name */ 1601 buf = device_node_gen_full_name(dn, buf, end); 1602 break; 1603 case 'n': /* name */ 1604 buf = string(buf, end, dn->name, str_spec); 1605 break; 1606 case 'p': /* phandle */ 1607 buf = number(buf, end, (unsigned int)dn->phandle, num_spec); 1608 break; 1609 case 'P': /* path-spec */ 1610 p = kbasename(of_node_full_name(dn)); 1611 if (!p[1]) 1612 p = "/"; 1613 buf = string(buf, end, p, str_spec); 1614 break; 1615 case 'F': /* flags */ 1616 tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-'; 1617 tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-'; 1618 tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-'; 1619 tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-'; 1620 tbuf[4] = 0; 1621 buf = string(buf, end, tbuf, str_spec); 1622 break; 1623 case 'c': /* major compatible string */ 1624 ret = of_property_read_string(dn, "compatible", &p); 1625 if (!ret) 1626 buf = string(buf, end, p, str_spec); 1627 break; 1628 case 'C': /* full compatible string */ 1629 has_mult = false; 1630 of_property_for_each_string(dn, "compatible", prop, p) { 1631 if (has_mult) 1632 buf = string(buf, end, ",", str_spec); 1633 buf = string(buf, end, "\"", str_spec); 1634 buf = string(buf, end, p, str_spec); 1635 buf = string(buf, end, "\"", str_spec); 1636 1637 has_mult = true; 1638 } 1639 break; 1640 default: 1641 break; 1642 } 1643 } 1644 1645 return widen_string(buf, buf - buf_start, end, spec); 1646 } 1647 1648 static noinline_for_stack 1649 char *pointer_string(char *buf, char *end, const void *ptr, 1650 struct printf_spec spec) 1651 { 1652 spec.base = 16; 1653 spec.flags |= SMALL; 1654 if (spec.field_width == -1) { 1655 spec.field_width = 2 * sizeof(ptr); 1656 spec.flags |= ZEROPAD; 1657 } 1658 1659 return number(buf, end, (unsigned long int)ptr, spec); 1660 } 1661 1662 static bool have_filled_random_ptr_key __read_mostly; 1663 static siphash_key_t ptr_key __read_mostly; 1664 1665 static void fill_random_ptr_key(struct random_ready_callback *unused) 1666 { 1667 get_random_bytes(&ptr_key, sizeof(ptr_key)); 1668 /* 1669 * have_filled_random_ptr_key==true is dependent on get_random_bytes(). 1670 * ptr_to_id() needs to see have_filled_random_ptr_key==true 1671 * after get_random_bytes() returns. 1672 */ 1673 smp_mb(); 1674 WRITE_ONCE(have_filled_random_ptr_key, true); 1675 } 1676 1677 static struct random_ready_callback random_ready = { 1678 .func = fill_random_ptr_key 1679 }; 1680 1681 static int __init initialize_ptr_random(void) 1682 { 1683 int ret = add_random_ready_callback(&random_ready); 1684 1685 if (!ret) { 1686 return 0; 1687 } else if (ret == -EALREADY) { 1688 fill_random_ptr_key(&random_ready); 1689 return 0; 1690 } 1691 1692 return ret; 1693 } 1694 early_initcall(initialize_ptr_random); 1695 1696 /* Maps a pointer to a 32 bit unique identifier. */ 1697 static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec) 1698 { 1699 unsigned long hashval; 1700 const int default_width = 2 * sizeof(ptr); 1701 1702 if (unlikely(!have_filled_random_ptr_key)) { 1703 spec.field_width = default_width; 1704 /* string length must be less than default_width */ 1705 return string(buf, end, "(ptrval)", spec); 1706 } 1707 1708 #ifdef CONFIG_64BIT 1709 hashval = (unsigned long)siphash_1u64((u64)ptr, &ptr_key); 1710 /* 1711 * Mask off the first 32 bits, this makes explicit that we have 1712 * modified the address (and 32 bits is plenty for a unique ID). 1713 */ 1714 hashval = hashval & 0xffffffff; 1715 #else 1716 hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key); 1717 #endif 1718 1719 spec.flags |= SMALL; 1720 if (spec.field_width == -1) { 1721 spec.field_width = default_width; 1722 spec.flags |= ZEROPAD; 1723 } 1724 spec.base = 16; 1725 1726 return number(buf, end, hashval, spec); 1727 } 1728 1729 /* 1730 * Show a '%p' thing. A kernel extension is that the '%p' is followed 1731 * by an extra set of alphanumeric characters that are extended format 1732 * specifiers. 1733 * 1734 * Please update scripts/checkpatch.pl when adding/removing conversion 1735 * characters. (Search for "check for vsprintf extension"). 1736 * 1737 * Right now we handle: 1738 * 1739 * - 'F' For symbolic function descriptor pointers with offset 1740 * - 'f' For simple symbolic function names without offset 1741 * - 'S' For symbolic direct pointers with offset 1742 * - 's' For symbolic direct pointers without offset 1743 * - '[FfSs]R' as above with __builtin_extract_return_addr() translation 1744 * - 'B' For backtraced symbolic direct pointers with offset 1745 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 1746 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 1747 * - 'b[l]' For a bitmap, the number of bits is determined by the field 1748 * width which must be explicitly specified either as part of the 1749 * format string '%32b[l]' or through '%*b[l]', [l] selects 1750 * range-list format instead of hex format 1751 * - 'M' For a 6-byte MAC address, it prints the address in the 1752 * usual colon-separated hex notation 1753 * - 'm' For a 6-byte MAC address, it prints the hex address without colons 1754 * - 'MF' For a 6-byte MAC FDDI address, it prints the address 1755 * with a dash-separated hex notation 1756 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth) 1757 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 1758 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 1759 * IPv6 uses colon separated network-order 16 bit hex with leading 0's 1760 * [S][pfs] 1761 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 1762 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 1763 * - 'i' [46] for 'raw' IPv4/IPv6 addresses 1764 * IPv6 omits the colons (01020304...0f) 1765 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 1766 * [S][pfs] 1767 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 1768 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 1769 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order 1770 * - 'I[6S]c' for IPv6 addresses printed as specified by 1771 * http://tools.ietf.org/html/rfc5952 1772 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination 1773 * of the following flags (see string_escape_mem() for the 1774 * details): 1775 * a - ESCAPE_ANY 1776 * c - ESCAPE_SPECIAL 1777 * h - ESCAPE_HEX 1778 * n - ESCAPE_NULL 1779 * o - ESCAPE_OCTAL 1780 * p - ESCAPE_NP 1781 * s - ESCAPE_SPACE 1782 * By default ESCAPE_ANY_NP is used. 1783 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 1784 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 1785 * Options for %pU are: 1786 * b big endian lower case hex (default) 1787 * B big endian UPPER case hex 1788 * l little endian lower case hex 1789 * L little endian UPPER case hex 1790 * big endian output byte order is: 1791 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 1792 * little endian output byte order is: 1793 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 1794 * - 'V' For a struct va_format which contains a format string * and va_list *, 1795 * call vsnprintf(->format, *->va_list). 1796 * Implements a "recursive vsnprintf". 1797 * Do not use this feature without some mechanism to verify the 1798 * correctness of the format string and va_list arguments. 1799 * - 'K' For a kernel pointer that should be hidden from unprivileged users 1800 * - 'NF' For a netdev_features_t 1801 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with 1802 * a certain separator (' ' by default): 1803 * C colon 1804 * D dash 1805 * N no separator 1806 * The maximum supported length is 64 bytes of the input. Consider 1807 * to use print_hex_dump() for the larger input. 1808 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives 1809 * (default assumed to be phys_addr_t, passed by reference) 1810 * - 'd[234]' For a dentry name (optionally 2-4 last components) 1811 * - 'D[234]' Same as 'd' but for a struct file 1812 * - 'g' For block_device name (gendisk + partition number) 1813 * - 'C' For a clock, it prints the name (Common Clock Framework) or address 1814 * (legacy clock framework) of the clock 1815 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address 1816 * (legacy clock framework) of the clock 1817 * - 'Cr' For a clock, it prints the current rate of the clock 1818 * - 'G' For flags to be printed as a collection of symbolic strings that would 1819 * construct the specific value. Supported flags given by option: 1820 * p page flags (see struct page) given as pointer to unsigned long 1821 * g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t 1822 * v vma flags (VM_*) given as pointer to unsigned long 1823 * - 'O' For a kobject based struct. Must be one of the following: 1824 * - 'OF[fnpPcCF]' For a device tree object 1825 * Without any optional arguments prints the full_name 1826 * f device node full_name 1827 * n device node name 1828 * p device node phandle 1829 * P device node path spec (name + @unit) 1830 * F device node flags 1831 * c major compatible string 1832 * C full compatible string 1833 * 1834 * - 'x' For printing the address. Equivalent to "%lx". 1835 * 1836 * ** When making changes please also update: 1837 * Documentation/core-api/printk-formats.rst 1838 * 1839 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 1840 * function pointers are really function descriptors, which contain a 1841 * pointer to the real address. 1842 * 1843 * Note: The default behaviour (unadorned %p) is to hash the address, 1844 * rendering it useful as a unique identifier. 1845 */ 1846 static noinline_for_stack 1847 char *pointer(const char *fmt, char *buf, char *end, void *ptr, 1848 struct printf_spec spec) 1849 { 1850 const int default_width = 2 * sizeof(void *); 1851 1852 if (!ptr && *fmt != 'K') { 1853 /* 1854 * Print (null) with the same width as a pointer so it makes 1855 * tabular output look nice. 1856 */ 1857 if (spec.field_width == -1) 1858 spec.field_width = default_width; 1859 return string(buf, end, "(null)", spec); 1860 } 1861 1862 switch (*fmt) { 1863 case 'F': 1864 case 'f': 1865 case 'S': 1866 case 's': 1867 ptr = dereference_symbol_descriptor(ptr); 1868 /* Fallthrough */ 1869 case 'B': 1870 return symbol_string(buf, end, ptr, spec, fmt); 1871 case 'R': 1872 case 'r': 1873 return resource_string(buf, end, ptr, spec, fmt); 1874 case 'h': 1875 return hex_string(buf, end, ptr, spec, fmt); 1876 case 'b': 1877 switch (fmt[1]) { 1878 case 'l': 1879 return bitmap_list_string(buf, end, ptr, spec, fmt); 1880 default: 1881 return bitmap_string(buf, end, ptr, spec, fmt); 1882 } 1883 case 'M': /* Colon separated: 00:01:02:03:04:05 */ 1884 case 'm': /* Contiguous: 000102030405 */ 1885 /* [mM]F (FDDI) */ 1886 /* [mM]R (Reverse order; Bluetooth) */ 1887 return mac_address_string(buf, end, ptr, spec, fmt); 1888 case 'I': /* Formatted IP supported 1889 * 4: 1.2.3.4 1890 * 6: 0001:0203:...:0708 1891 * 6c: 1::708 or 1::1.2.3.4 1892 */ 1893 case 'i': /* Contiguous: 1894 * 4: 001.002.003.004 1895 * 6: 000102...0f 1896 */ 1897 switch (fmt[1]) { 1898 case '6': 1899 return ip6_addr_string(buf, end, ptr, spec, fmt); 1900 case '4': 1901 return ip4_addr_string(buf, end, ptr, spec, fmt); 1902 case 'S': { 1903 const union { 1904 struct sockaddr raw; 1905 struct sockaddr_in v4; 1906 struct sockaddr_in6 v6; 1907 } *sa = ptr; 1908 1909 switch (sa->raw.sa_family) { 1910 case AF_INET: 1911 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt); 1912 case AF_INET6: 1913 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt); 1914 default: 1915 return string(buf, end, "(invalid address)", spec); 1916 }} 1917 } 1918 break; 1919 case 'E': 1920 return escaped_string(buf, end, ptr, spec, fmt); 1921 case 'U': 1922 return uuid_string(buf, end, ptr, spec, fmt); 1923 case 'V': 1924 { 1925 va_list va; 1926 1927 va_copy(va, *((struct va_format *)ptr)->va); 1928 buf += vsnprintf(buf, end > buf ? end - buf : 0, 1929 ((struct va_format *)ptr)->fmt, va); 1930 va_end(va); 1931 return buf; 1932 } 1933 case 'K': 1934 if (!kptr_restrict) 1935 break; 1936 return restricted_pointer(buf, end, ptr, spec); 1937 case 'N': 1938 return netdev_bits(buf, end, ptr, fmt); 1939 case 'a': 1940 return address_val(buf, end, ptr, fmt); 1941 case 'd': 1942 return dentry_name(buf, end, ptr, spec, fmt); 1943 case 'C': 1944 return clock(buf, end, ptr, spec, fmt); 1945 case 'D': 1946 return dentry_name(buf, end, 1947 ((const struct file *)ptr)->f_path.dentry, 1948 spec, fmt); 1949 #ifdef CONFIG_BLOCK 1950 case 'g': 1951 return bdev_name(buf, end, ptr, spec, fmt); 1952 #endif 1953 1954 case 'G': 1955 return flags_string(buf, end, ptr, fmt); 1956 case 'O': 1957 switch (fmt[1]) { 1958 case 'F': 1959 return device_node_string(buf, end, ptr, spec, fmt + 1); 1960 } 1961 case 'x': 1962 return pointer_string(buf, end, ptr, spec); 1963 } 1964 1965 /* default is to _not_ leak addresses, hash before printing */ 1966 return ptr_to_id(buf, end, ptr, spec); 1967 } 1968 1969 /* 1970 * Helper function to decode printf style format. 1971 * Each call decode a token from the format and return the 1972 * number of characters read (or likely the delta where it wants 1973 * to go on the next call). 1974 * The decoded token is returned through the parameters 1975 * 1976 * 'h', 'l', or 'L' for integer fields 1977 * 'z' support added 23/7/1999 S.H. 1978 * 'z' changed to 'Z' --davidm 1/25/99 1979 * 'Z' changed to 'z' --adobriyan 2017-01-25 1980 * 't' added for ptrdiff_t 1981 * 1982 * @fmt: the format string 1983 * @type of the token returned 1984 * @flags: various flags such as +, -, # tokens.. 1985 * @field_width: overwritten width 1986 * @base: base of the number (octal, hex, ...) 1987 * @precision: precision of a number 1988 * @qualifier: qualifier of a number (long, size_t, ...) 1989 */ 1990 static noinline_for_stack 1991 int format_decode(const char *fmt, struct printf_spec *spec) 1992 { 1993 const char *start = fmt; 1994 char qualifier; 1995 1996 /* we finished early by reading the field width */ 1997 if (spec->type == FORMAT_TYPE_WIDTH) { 1998 if (spec->field_width < 0) { 1999 spec->field_width = -spec->field_width; 2000 spec->flags |= LEFT; 2001 } 2002 spec->type = FORMAT_TYPE_NONE; 2003 goto precision; 2004 } 2005 2006 /* we finished early by reading the precision */ 2007 if (spec->type == FORMAT_TYPE_PRECISION) { 2008 if (spec->precision < 0) 2009 spec->precision = 0; 2010 2011 spec->type = FORMAT_TYPE_NONE; 2012 goto qualifier; 2013 } 2014 2015 /* By default */ 2016 spec->type = FORMAT_TYPE_NONE; 2017 2018 for (; *fmt ; ++fmt) { 2019 if (*fmt == '%') 2020 break; 2021 } 2022 2023 /* Return the current non-format string */ 2024 if (fmt != start || !*fmt) 2025 return fmt - start; 2026 2027 /* Process flags */ 2028 spec->flags = 0; 2029 2030 while (1) { /* this also skips first '%' */ 2031 bool found = true; 2032 2033 ++fmt; 2034 2035 switch (*fmt) { 2036 case '-': spec->flags |= LEFT; break; 2037 case '+': spec->flags |= PLUS; break; 2038 case ' ': spec->flags |= SPACE; break; 2039 case '#': spec->flags |= SPECIAL; break; 2040 case '0': spec->flags |= ZEROPAD; break; 2041 default: found = false; 2042 } 2043 2044 if (!found) 2045 break; 2046 } 2047 2048 /* get field width */ 2049 spec->field_width = -1; 2050 2051 if (isdigit(*fmt)) 2052 spec->field_width = skip_atoi(&fmt); 2053 else if (*fmt == '*') { 2054 /* it's the next argument */ 2055 spec->type = FORMAT_TYPE_WIDTH; 2056 return ++fmt - start; 2057 } 2058 2059 precision: 2060 /* get the precision */ 2061 spec->precision = -1; 2062 if (*fmt == '.') { 2063 ++fmt; 2064 if (isdigit(*fmt)) { 2065 spec->precision = skip_atoi(&fmt); 2066 if (spec->precision < 0) 2067 spec->precision = 0; 2068 } else if (*fmt == '*') { 2069 /* it's the next argument */ 2070 spec->type = FORMAT_TYPE_PRECISION; 2071 return ++fmt - start; 2072 } 2073 } 2074 2075 qualifier: 2076 /* get the conversion qualifier */ 2077 qualifier = 0; 2078 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2079 *fmt == 'z' || *fmt == 't') { 2080 qualifier = *fmt++; 2081 if (unlikely(qualifier == *fmt)) { 2082 if (qualifier == 'l') { 2083 qualifier = 'L'; 2084 ++fmt; 2085 } else if (qualifier == 'h') { 2086 qualifier = 'H'; 2087 ++fmt; 2088 } 2089 } 2090 } 2091 2092 /* default base */ 2093 spec->base = 10; 2094 switch (*fmt) { 2095 case 'c': 2096 spec->type = FORMAT_TYPE_CHAR; 2097 return ++fmt - start; 2098 2099 case 's': 2100 spec->type = FORMAT_TYPE_STR; 2101 return ++fmt - start; 2102 2103 case 'p': 2104 spec->type = FORMAT_TYPE_PTR; 2105 return ++fmt - start; 2106 2107 case '%': 2108 spec->type = FORMAT_TYPE_PERCENT_CHAR; 2109 return ++fmt - start; 2110 2111 /* integer number formats - set up the flags and "break" */ 2112 case 'o': 2113 spec->base = 8; 2114 break; 2115 2116 case 'x': 2117 spec->flags |= SMALL; 2118 2119 case 'X': 2120 spec->base = 16; 2121 break; 2122 2123 case 'd': 2124 case 'i': 2125 spec->flags |= SIGN; 2126 case 'u': 2127 break; 2128 2129 case 'n': 2130 /* 2131 * Since %n poses a greater security risk than 2132 * utility, treat it as any other invalid or 2133 * unsupported format specifier. 2134 */ 2135 /* Fall-through */ 2136 2137 default: 2138 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt); 2139 spec->type = FORMAT_TYPE_INVALID; 2140 return fmt - start; 2141 } 2142 2143 if (qualifier == 'L') 2144 spec->type = FORMAT_TYPE_LONG_LONG; 2145 else if (qualifier == 'l') { 2146 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 2147 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 2148 } else if (qualifier == 'z') { 2149 spec->type = FORMAT_TYPE_SIZE_T; 2150 } else if (qualifier == 't') { 2151 spec->type = FORMAT_TYPE_PTRDIFF; 2152 } else if (qualifier == 'H') { 2153 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE); 2154 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN); 2155 } else if (qualifier == 'h') { 2156 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT); 2157 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN); 2158 } else { 2159 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT); 2160 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN); 2161 } 2162 2163 return ++fmt - start; 2164 } 2165 2166 static void 2167 set_field_width(struct printf_spec *spec, int width) 2168 { 2169 spec->field_width = width; 2170 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) { 2171 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX); 2172 } 2173 } 2174 2175 static void 2176 set_precision(struct printf_spec *spec, int prec) 2177 { 2178 spec->precision = prec; 2179 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) { 2180 spec->precision = clamp(prec, 0, PRECISION_MAX); 2181 } 2182 } 2183 2184 /** 2185 * vsnprintf - Format a string and place it in a buffer 2186 * @buf: The buffer to place the result into 2187 * @size: The size of the buffer, including the trailing null space 2188 * @fmt: The format string to use 2189 * @args: Arguments for the format string 2190 * 2191 * This function generally follows C99 vsnprintf, but has some 2192 * extensions and a few limitations: 2193 * 2194 * - ``%n`` is unsupported 2195 * - ``%p*`` is handled by pointer() 2196 * 2197 * See pointer() or Documentation/core-api/printk-formats.rst for more 2198 * extensive description. 2199 * 2200 * **Please update the documentation in both places when making changes** 2201 * 2202 * The return value is the number of characters which would 2203 * be generated for the given input, excluding the trailing 2204 * '\0', as per ISO C99. If you want to have the exact 2205 * number of characters written into @buf as return value 2206 * (not including the trailing '\0'), use vscnprintf(). If the 2207 * return is greater than or equal to @size, the resulting 2208 * string is truncated. 2209 * 2210 * If you're not already dealing with a va_list consider using snprintf(). 2211 */ 2212 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 2213 { 2214 unsigned long long num; 2215 char *str, *end; 2216 struct printf_spec spec = {0}; 2217 2218 /* Reject out-of-range values early. Large positive sizes are 2219 used for unknown buffer sizes. */ 2220 if (WARN_ON_ONCE(size > INT_MAX)) 2221 return 0; 2222 2223 str = buf; 2224 end = buf + size; 2225 2226 /* Make sure end is always >= buf */ 2227 if (end < buf) { 2228 end = ((void *)-1); 2229 size = end - buf; 2230 } 2231 2232 while (*fmt) { 2233 const char *old_fmt = fmt; 2234 int read = format_decode(fmt, &spec); 2235 2236 fmt += read; 2237 2238 switch (spec.type) { 2239 case FORMAT_TYPE_NONE: { 2240 int copy = read; 2241 if (str < end) { 2242 if (copy > end - str) 2243 copy = end - str; 2244 memcpy(str, old_fmt, copy); 2245 } 2246 str += read; 2247 break; 2248 } 2249 2250 case FORMAT_TYPE_WIDTH: 2251 set_field_width(&spec, va_arg(args, int)); 2252 break; 2253 2254 case FORMAT_TYPE_PRECISION: 2255 set_precision(&spec, va_arg(args, int)); 2256 break; 2257 2258 case FORMAT_TYPE_CHAR: { 2259 char c; 2260 2261 if (!(spec.flags & LEFT)) { 2262 while (--spec.field_width > 0) { 2263 if (str < end) 2264 *str = ' '; 2265 ++str; 2266 2267 } 2268 } 2269 c = (unsigned char) va_arg(args, int); 2270 if (str < end) 2271 *str = c; 2272 ++str; 2273 while (--spec.field_width > 0) { 2274 if (str < end) 2275 *str = ' '; 2276 ++str; 2277 } 2278 break; 2279 } 2280 2281 case FORMAT_TYPE_STR: 2282 str = string(str, end, va_arg(args, char *), spec); 2283 break; 2284 2285 case FORMAT_TYPE_PTR: 2286 str = pointer(fmt, str, end, va_arg(args, void *), 2287 spec); 2288 while (isalnum(*fmt)) 2289 fmt++; 2290 break; 2291 2292 case FORMAT_TYPE_PERCENT_CHAR: 2293 if (str < end) 2294 *str = '%'; 2295 ++str; 2296 break; 2297 2298 case FORMAT_TYPE_INVALID: 2299 /* 2300 * Presumably the arguments passed gcc's type 2301 * checking, but there is no safe or sane way 2302 * for us to continue parsing the format and 2303 * fetching from the va_list; the remaining 2304 * specifiers and arguments would be out of 2305 * sync. 2306 */ 2307 goto out; 2308 2309 default: 2310 switch (spec.type) { 2311 case FORMAT_TYPE_LONG_LONG: 2312 num = va_arg(args, long long); 2313 break; 2314 case FORMAT_TYPE_ULONG: 2315 num = va_arg(args, unsigned long); 2316 break; 2317 case FORMAT_TYPE_LONG: 2318 num = va_arg(args, long); 2319 break; 2320 case FORMAT_TYPE_SIZE_T: 2321 if (spec.flags & SIGN) 2322 num = va_arg(args, ssize_t); 2323 else 2324 num = va_arg(args, size_t); 2325 break; 2326 case FORMAT_TYPE_PTRDIFF: 2327 num = va_arg(args, ptrdiff_t); 2328 break; 2329 case FORMAT_TYPE_UBYTE: 2330 num = (unsigned char) va_arg(args, int); 2331 break; 2332 case FORMAT_TYPE_BYTE: 2333 num = (signed char) va_arg(args, int); 2334 break; 2335 case FORMAT_TYPE_USHORT: 2336 num = (unsigned short) va_arg(args, int); 2337 break; 2338 case FORMAT_TYPE_SHORT: 2339 num = (short) va_arg(args, int); 2340 break; 2341 case FORMAT_TYPE_INT: 2342 num = (int) va_arg(args, int); 2343 break; 2344 default: 2345 num = va_arg(args, unsigned int); 2346 } 2347 2348 str = number(str, end, num, spec); 2349 } 2350 } 2351 2352 out: 2353 if (size > 0) { 2354 if (str < end) 2355 *str = '\0'; 2356 else 2357 end[-1] = '\0'; 2358 } 2359 2360 /* the trailing null byte doesn't count towards the total */ 2361 return str-buf; 2362 2363 } 2364 EXPORT_SYMBOL(vsnprintf); 2365 2366 /** 2367 * vscnprintf - Format a string and place it in a buffer 2368 * @buf: The buffer to place the result into 2369 * @size: The size of the buffer, including the trailing null space 2370 * @fmt: The format string to use 2371 * @args: Arguments for the format string 2372 * 2373 * The return value is the number of characters which have been written into 2374 * the @buf not including the trailing '\0'. If @size is == 0 the function 2375 * returns 0. 2376 * 2377 * If you're not already dealing with a va_list consider using scnprintf(). 2378 * 2379 * See the vsnprintf() documentation for format string extensions over C99. 2380 */ 2381 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 2382 { 2383 int i; 2384 2385 i = vsnprintf(buf, size, fmt, args); 2386 2387 if (likely(i < size)) 2388 return i; 2389 if (size != 0) 2390 return size - 1; 2391 return 0; 2392 } 2393 EXPORT_SYMBOL(vscnprintf); 2394 2395 /** 2396 * snprintf - Format a string and place it in a buffer 2397 * @buf: The buffer to place the result into 2398 * @size: The size of the buffer, including the trailing null space 2399 * @fmt: The format string to use 2400 * @...: Arguments for the format string 2401 * 2402 * The return value is the number of characters which would be 2403 * generated for the given input, excluding the trailing null, 2404 * as per ISO C99. If the return is greater than or equal to 2405 * @size, the resulting string is truncated. 2406 * 2407 * See the vsnprintf() documentation for format string extensions over C99. 2408 */ 2409 int snprintf(char *buf, size_t size, const char *fmt, ...) 2410 { 2411 va_list args; 2412 int i; 2413 2414 va_start(args, fmt); 2415 i = vsnprintf(buf, size, fmt, args); 2416 va_end(args); 2417 2418 return i; 2419 } 2420 EXPORT_SYMBOL(snprintf); 2421 2422 /** 2423 * scnprintf - Format a string and place it in a buffer 2424 * @buf: The buffer to place the result into 2425 * @size: The size of the buffer, including the trailing null space 2426 * @fmt: The format string to use 2427 * @...: Arguments for the format string 2428 * 2429 * The return value is the number of characters written into @buf not including 2430 * the trailing '\0'. If @size is == 0 the function returns 0. 2431 */ 2432 2433 int scnprintf(char *buf, size_t size, const char *fmt, ...) 2434 { 2435 va_list args; 2436 int i; 2437 2438 va_start(args, fmt); 2439 i = vscnprintf(buf, size, fmt, args); 2440 va_end(args); 2441 2442 return i; 2443 } 2444 EXPORT_SYMBOL(scnprintf); 2445 2446 /** 2447 * vsprintf - Format a string and place it in a buffer 2448 * @buf: The buffer to place the result into 2449 * @fmt: The format string to use 2450 * @args: Arguments for the format string 2451 * 2452 * The function returns the number of characters written 2453 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 2454 * buffer overflows. 2455 * 2456 * If you're not already dealing with a va_list consider using sprintf(). 2457 * 2458 * See the vsnprintf() documentation for format string extensions over C99. 2459 */ 2460 int vsprintf(char *buf, const char *fmt, va_list args) 2461 { 2462 return vsnprintf(buf, INT_MAX, fmt, args); 2463 } 2464 EXPORT_SYMBOL(vsprintf); 2465 2466 /** 2467 * sprintf - Format a string and place it in a buffer 2468 * @buf: The buffer to place the result into 2469 * @fmt: The format string to use 2470 * @...: Arguments for the format string 2471 * 2472 * The function returns the number of characters written 2473 * into @buf. Use snprintf() or scnprintf() in order to avoid 2474 * buffer overflows. 2475 * 2476 * See the vsnprintf() documentation for format string extensions over C99. 2477 */ 2478 int sprintf(char *buf, const char *fmt, ...) 2479 { 2480 va_list args; 2481 int i; 2482 2483 va_start(args, fmt); 2484 i = vsnprintf(buf, INT_MAX, fmt, args); 2485 va_end(args); 2486 2487 return i; 2488 } 2489 EXPORT_SYMBOL(sprintf); 2490 2491 #ifdef CONFIG_BINARY_PRINTF 2492 /* 2493 * bprintf service: 2494 * vbin_printf() - VA arguments to binary data 2495 * bstr_printf() - Binary data to text string 2496 */ 2497 2498 /** 2499 * vbin_printf - Parse a format string and place args' binary value in a buffer 2500 * @bin_buf: The buffer to place args' binary value 2501 * @size: The size of the buffer(by words(32bits), not characters) 2502 * @fmt: The format string to use 2503 * @args: Arguments for the format string 2504 * 2505 * The format follows C99 vsnprintf, except %n is ignored, and its argument 2506 * is skipped. 2507 * 2508 * The return value is the number of words(32bits) which would be generated for 2509 * the given input. 2510 * 2511 * NOTE: 2512 * If the return value is greater than @size, the resulting bin_buf is NOT 2513 * valid for bstr_printf(). 2514 */ 2515 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 2516 { 2517 struct printf_spec spec = {0}; 2518 char *str, *end; 2519 int width; 2520 2521 str = (char *)bin_buf; 2522 end = (char *)(bin_buf + size); 2523 2524 #define save_arg(type) \ 2525 ({ \ 2526 unsigned long long value; \ 2527 if (sizeof(type) == 8) { \ 2528 unsigned long long val8; \ 2529 str = PTR_ALIGN(str, sizeof(u32)); \ 2530 val8 = va_arg(args, unsigned long long); \ 2531 if (str + sizeof(type) <= end) { \ 2532 *(u32 *)str = *(u32 *)&val8; \ 2533 *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \ 2534 } \ 2535 value = val8; \ 2536 } else { \ 2537 unsigned int val4; \ 2538 str = PTR_ALIGN(str, sizeof(type)); \ 2539 val4 = va_arg(args, int); \ 2540 if (str + sizeof(type) <= end) \ 2541 *(typeof(type) *)str = (type)(long)val4; \ 2542 value = (unsigned long long)val4; \ 2543 } \ 2544 str += sizeof(type); \ 2545 value; \ 2546 }) 2547 2548 while (*fmt) { 2549 int read = format_decode(fmt, &spec); 2550 2551 fmt += read; 2552 2553 switch (spec.type) { 2554 case FORMAT_TYPE_NONE: 2555 case FORMAT_TYPE_PERCENT_CHAR: 2556 break; 2557 case FORMAT_TYPE_INVALID: 2558 goto out; 2559 2560 case FORMAT_TYPE_WIDTH: 2561 case FORMAT_TYPE_PRECISION: 2562 width = (int)save_arg(int); 2563 /* Pointers may require the width */ 2564 if (*fmt == 'p') 2565 set_field_width(&spec, width); 2566 break; 2567 2568 case FORMAT_TYPE_CHAR: 2569 save_arg(char); 2570 break; 2571 2572 case FORMAT_TYPE_STR: { 2573 const char *save_str = va_arg(args, char *); 2574 size_t len; 2575 2576 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 2577 || (unsigned long)save_str < PAGE_SIZE) 2578 save_str = "(null)"; 2579 len = strlen(save_str) + 1; 2580 if (str + len < end) 2581 memcpy(str, save_str, len); 2582 str += len; 2583 break; 2584 } 2585 2586 case FORMAT_TYPE_PTR: 2587 /* Dereferenced pointers must be done now */ 2588 switch (*fmt) { 2589 /* Dereference of functions is still OK */ 2590 case 'S': 2591 case 's': 2592 case 'F': 2593 case 'f': 2594 save_arg(void *); 2595 break; 2596 default: 2597 if (!isalnum(*fmt)) { 2598 save_arg(void *); 2599 break; 2600 } 2601 str = pointer(fmt, str, end, va_arg(args, void *), 2602 spec); 2603 if (str + 1 < end) 2604 *str++ = '\0'; 2605 else 2606 end[-1] = '\0'; /* Must be nul terminated */ 2607 } 2608 /* skip all alphanumeric pointer suffixes */ 2609 while (isalnum(*fmt)) 2610 fmt++; 2611 break; 2612 2613 default: 2614 switch (spec.type) { 2615 2616 case FORMAT_TYPE_LONG_LONG: 2617 save_arg(long long); 2618 break; 2619 case FORMAT_TYPE_ULONG: 2620 case FORMAT_TYPE_LONG: 2621 save_arg(unsigned long); 2622 break; 2623 case FORMAT_TYPE_SIZE_T: 2624 save_arg(size_t); 2625 break; 2626 case FORMAT_TYPE_PTRDIFF: 2627 save_arg(ptrdiff_t); 2628 break; 2629 case FORMAT_TYPE_UBYTE: 2630 case FORMAT_TYPE_BYTE: 2631 save_arg(char); 2632 break; 2633 case FORMAT_TYPE_USHORT: 2634 case FORMAT_TYPE_SHORT: 2635 save_arg(short); 2636 break; 2637 default: 2638 save_arg(int); 2639 } 2640 } 2641 } 2642 2643 out: 2644 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 2645 #undef save_arg 2646 } 2647 EXPORT_SYMBOL_GPL(vbin_printf); 2648 2649 /** 2650 * bstr_printf - Format a string from binary arguments and place it in a buffer 2651 * @buf: The buffer to place the result into 2652 * @size: The size of the buffer, including the trailing null space 2653 * @fmt: The format string to use 2654 * @bin_buf: Binary arguments for the format string 2655 * 2656 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 2657 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 2658 * a binary buffer that generated by vbin_printf. 2659 * 2660 * The format follows C99 vsnprintf, but has some extensions: 2661 * see vsnprintf comment for details. 2662 * 2663 * The return value is the number of characters which would 2664 * be generated for the given input, excluding the trailing 2665 * '\0', as per ISO C99. If you want to have the exact 2666 * number of characters written into @buf as return value 2667 * (not including the trailing '\0'), use vscnprintf(). If the 2668 * return is greater than or equal to @size, the resulting 2669 * string is truncated. 2670 */ 2671 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 2672 { 2673 struct printf_spec spec = {0}; 2674 char *str, *end; 2675 const char *args = (const char *)bin_buf; 2676 2677 if (WARN_ON_ONCE(size > INT_MAX)) 2678 return 0; 2679 2680 str = buf; 2681 end = buf + size; 2682 2683 #define get_arg(type) \ 2684 ({ \ 2685 typeof(type) value; \ 2686 if (sizeof(type) == 8) { \ 2687 args = PTR_ALIGN(args, sizeof(u32)); \ 2688 *(u32 *)&value = *(u32 *)args; \ 2689 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 2690 } else { \ 2691 args = PTR_ALIGN(args, sizeof(type)); \ 2692 value = *(typeof(type) *)args; \ 2693 } \ 2694 args += sizeof(type); \ 2695 value; \ 2696 }) 2697 2698 /* Make sure end is always >= buf */ 2699 if (end < buf) { 2700 end = ((void *)-1); 2701 size = end - buf; 2702 } 2703 2704 while (*fmt) { 2705 const char *old_fmt = fmt; 2706 int read = format_decode(fmt, &spec); 2707 2708 fmt += read; 2709 2710 switch (spec.type) { 2711 case FORMAT_TYPE_NONE: { 2712 int copy = read; 2713 if (str < end) { 2714 if (copy > end - str) 2715 copy = end - str; 2716 memcpy(str, old_fmt, copy); 2717 } 2718 str += read; 2719 break; 2720 } 2721 2722 case FORMAT_TYPE_WIDTH: 2723 set_field_width(&spec, get_arg(int)); 2724 break; 2725 2726 case FORMAT_TYPE_PRECISION: 2727 set_precision(&spec, get_arg(int)); 2728 break; 2729 2730 case FORMAT_TYPE_CHAR: { 2731 char c; 2732 2733 if (!(spec.flags & LEFT)) { 2734 while (--spec.field_width > 0) { 2735 if (str < end) 2736 *str = ' '; 2737 ++str; 2738 } 2739 } 2740 c = (unsigned char) get_arg(char); 2741 if (str < end) 2742 *str = c; 2743 ++str; 2744 while (--spec.field_width > 0) { 2745 if (str < end) 2746 *str = ' '; 2747 ++str; 2748 } 2749 break; 2750 } 2751 2752 case FORMAT_TYPE_STR: { 2753 const char *str_arg = args; 2754 args += strlen(str_arg) + 1; 2755 str = string(str, end, (char *)str_arg, spec); 2756 break; 2757 } 2758 2759 case FORMAT_TYPE_PTR: { 2760 bool process = false; 2761 int copy, len; 2762 /* Non function dereferences were already done */ 2763 switch (*fmt) { 2764 case 'S': 2765 case 's': 2766 case 'F': 2767 case 'f': 2768 process = true; 2769 break; 2770 default: 2771 if (!isalnum(*fmt)) { 2772 process = true; 2773 break; 2774 } 2775 /* Pointer dereference was already processed */ 2776 if (str < end) { 2777 len = copy = strlen(args); 2778 if (copy > end - str) 2779 copy = end - str; 2780 memcpy(str, args, copy); 2781 str += len; 2782 args += len; 2783 } 2784 } 2785 if (process) 2786 str = pointer(fmt, str, end, get_arg(void *), spec); 2787 2788 while (isalnum(*fmt)) 2789 fmt++; 2790 break; 2791 } 2792 2793 case FORMAT_TYPE_PERCENT_CHAR: 2794 if (str < end) 2795 *str = '%'; 2796 ++str; 2797 break; 2798 2799 case FORMAT_TYPE_INVALID: 2800 goto out; 2801 2802 default: { 2803 unsigned long long num; 2804 2805 switch (spec.type) { 2806 2807 case FORMAT_TYPE_LONG_LONG: 2808 num = get_arg(long long); 2809 break; 2810 case FORMAT_TYPE_ULONG: 2811 case FORMAT_TYPE_LONG: 2812 num = get_arg(unsigned long); 2813 break; 2814 case FORMAT_TYPE_SIZE_T: 2815 num = get_arg(size_t); 2816 break; 2817 case FORMAT_TYPE_PTRDIFF: 2818 num = get_arg(ptrdiff_t); 2819 break; 2820 case FORMAT_TYPE_UBYTE: 2821 num = get_arg(unsigned char); 2822 break; 2823 case FORMAT_TYPE_BYTE: 2824 num = get_arg(signed char); 2825 break; 2826 case FORMAT_TYPE_USHORT: 2827 num = get_arg(unsigned short); 2828 break; 2829 case FORMAT_TYPE_SHORT: 2830 num = get_arg(short); 2831 break; 2832 case FORMAT_TYPE_UINT: 2833 num = get_arg(unsigned int); 2834 break; 2835 default: 2836 num = get_arg(int); 2837 } 2838 2839 str = number(str, end, num, spec); 2840 } /* default: */ 2841 } /* switch(spec.type) */ 2842 } /* while(*fmt) */ 2843 2844 out: 2845 if (size > 0) { 2846 if (str < end) 2847 *str = '\0'; 2848 else 2849 end[-1] = '\0'; 2850 } 2851 2852 #undef get_arg 2853 2854 /* the trailing null byte doesn't count towards the total */ 2855 return str - buf; 2856 } 2857 EXPORT_SYMBOL_GPL(bstr_printf); 2858 2859 /** 2860 * bprintf - Parse a format string and place args' binary value in a buffer 2861 * @bin_buf: The buffer to place args' binary value 2862 * @size: The size of the buffer(by words(32bits), not characters) 2863 * @fmt: The format string to use 2864 * @...: Arguments for the format string 2865 * 2866 * The function returns the number of words(u32) written 2867 * into @bin_buf. 2868 */ 2869 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 2870 { 2871 va_list args; 2872 int ret; 2873 2874 va_start(args, fmt); 2875 ret = vbin_printf(bin_buf, size, fmt, args); 2876 va_end(args); 2877 2878 return ret; 2879 } 2880 EXPORT_SYMBOL_GPL(bprintf); 2881 2882 #endif /* CONFIG_BINARY_PRINTF */ 2883 2884 /** 2885 * vsscanf - Unformat a buffer into a list of arguments 2886 * @buf: input buffer 2887 * @fmt: format of buffer 2888 * @args: arguments 2889 */ 2890 int vsscanf(const char *buf, const char *fmt, va_list args) 2891 { 2892 const char *str = buf; 2893 char *next; 2894 char digit; 2895 int num = 0; 2896 u8 qualifier; 2897 unsigned int base; 2898 union { 2899 long long s; 2900 unsigned long long u; 2901 } val; 2902 s16 field_width; 2903 bool is_sign; 2904 2905 while (*fmt) { 2906 /* skip any white space in format */ 2907 /* white space in format matchs any amount of 2908 * white space, including none, in the input. 2909 */ 2910 if (isspace(*fmt)) { 2911 fmt = skip_spaces(++fmt); 2912 str = skip_spaces(str); 2913 } 2914 2915 /* anything that is not a conversion must match exactly */ 2916 if (*fmt != '%' && *fmt) { 2917 if (*fmt++ != *str++) 2918 break; 2919 continue; 2920 } 2921 2922 if (!*fmt) 2923 break; 2924 ++fmt; 2925 2926 /* skip this conversion. 2927 * advance both strings to next white space 2928 */ 2929 if (*fmt == '*') { 2930 if (!*str) 2931 break; 2932 while (!isspace(*fmt) && *fmt != '%' && *fmt) { 2933 /* '%*[' not yet supported, invalid format */ 2934 if (*fmt == '[') 2935 return num; 2936 fmt++; 2937 } 2938 while (!isspace(*str) && *str) 2939 str++; 2940 continue; 2941 } 2942 2943 /* get field width */ 2944 field_width = -1; 2945 if (isdigit(*fmt)) { 2946 field_width = skip_atoi(&fmt); 2947 if (field_width <= 0) 2948 break; 2949 } 2950 2951 /* get conversion qualifier */ 2952 qualifier = -1; 2953 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2954 *fmt == 'z') { 2955 qualifier = *fmt++; 2956 if (unlikely(qualifier == *fmt)) { 2957 if (qualifier == 'h') { 2958 qualifier = 'H'; 2959 fmt++; 2960 } else if (qualifier == 'l') { 2961 qualifier = 'L'; 2962 fmt++; 2963 } 2964 } 2965 } 2966 2967 if (!*fmt) 2968 break; 2969 2970 if (*fmt == 'n') { 2971 /* return number of characters read so far */ 2972 *va_arg(args, int *) = str - buf; 2973 ++fmt; 2974 continue; 2975 } 2976 2977 if (!*str) 2978 break; 2979 2980 base = 10; 2981 is_sign = false; 2982 2983 switch (*fmt++) { 2984 case 'c': 2985 { 2986 char *s = (char *)va_arg(args, char*); 2987 if (field_width == -1) 2988 field_width = 1; 2989 do { 2990 *s++ = *str++; 2991 } while (--field_width > 0 && *str); 2992 num++; 2993 } 2994 continue; 2995 case 's': 2996 { 2997 char *s = (char *)va_arg(args, char *); 2998 if (field_width == -1) 2999 field_width = SHRT_MAX; 3000 /* first, skip leading white space in buffer */ 3001 str = skip_spaces(str); 3002 3003 /* now copy until next white space */ 3004 while (*str && !isspace(*str) && field_width--) 3005 *s++ = *str++; 3006 *s = '\0'; 3007 num++; 3008 } 3009 continue; 3010 /* 3011 * Warning: This implementation of the '[' conversion specifier 3012 * deviates from its glibc counterpart in the following ways: 3013 * (1) It does NOT support ranges i.e. '-' is NOT a special 3014 * character 3015 * (2) It cannot match the closing bracket ']' itself 3016 * (3) A field width is required 3017 * (4) '%*[' (discard matching input) is currently not supported 3018 * 3019 * Example usage: 3020 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]", 3021 * buf1, buf2, buf3); 3022 * if (ret < 3) 3023 * // etc.. 3024 */ 3025 case '[': 3026 { 3027 char *s = (char *)va_arg(args, char *); 3028 DECLARE_BITMAP(set, 256) = {0}; 3029 unsigned int len = 0; 3030 bool negate = (*fmt == '^'); 3031 3032 /* field width is required */ 3033 if (field_width == -1) 3034 return num; 3035 3036 if (negate) 3037 ++fmt; 3038 3039 for ( ; *fmt && *fmt != ']'; ++fmt, ++len) 3040 set_bit((u8)*fmt, set); 3041 3042 /* no ']' or no character set found */ 3043 if (!*fmt || !len) 3044 return num; 3045 ++fmt; 3046 3047 if (negate) { 3048 bitmap_complement(set, set, 256); 3049 /* exclude null '\0' byte */ 3050 clear_bit(0, set); 3051 } 3052 3053 /* match must be non-empty */ 3054 if (!test_bit((u8)*str, set)) 3055 return num; 3056 3057 while (test_bit((u8)*str, set) && field_width--) 3058 *s++ = *str++; 3059 *s = '\0'; 3060 ++num; 3061 } 3062 continue; 3063 case 'o': 3064 base = 8; 3065 break; 3066 case 'x': 3067 case 'X': 3068 base = 16; 3069 break; 3070 case 'i': 3071 base = 0; 3072 case 'd': 3073 is_sign = true; 3074 case 'u': 3075 break; 3076 case '%': 3077 /* looking for '%' in str */ 3078 if (*str++ != '%') 3079 return num; 3080 continue; 3081 default: 3082 /* invalid format; stop here */ 3083 return num; 3084 } 3085 3086 /* have some sort of integer conversion. 3087 * first, skip white space in buffer. 3088 */ 3089 str = skip_spaces(str); 3090 3091 digit = *str; 3092 if (is_sign && digit == '-') 3093 digit = *(str + 1); 3094 3095 if (!digit 3096 || (base == 16 && !isxdigit(digit)) 3097 || (base == 10 && !isdigit(digit)) 3098 || (base == 8 && (!isdigit(digit) || digit > '7')) 3099 || (base == 0 && !isdigit(digit))) 3100 break; 3101 3102 if (is_sign) 3103 val.s = qualifier != 'L' ? 3104 simple_strtol(str, &next, base) : 3105 simple_strtoll(str, &next, base); 3106 else 3107 val.u = qualifier != 'L' ? 3108 simple_strtoul(str, &next, base) : 3109 simple_strtoull(str, &next, base); 3110 3111 if (field_width > 0 && next - str > field_width) { 3112 if (base == 0) 3113 _parse_integer_fixup_radix(str, &base); 3114 while (next - str > field_width) { 3115 if (is_sign) 3116 val.s = div_s64(val.s, base); 3117 else 3118 val.u = div_u64(val.u, base); 3119 --next; 3120 } 3121 } 3122 3123 switch (qualifier) { 3124 case 'H': /* that's 'hh' in format */ 3125 if (is_sign) 3126 *va_arg(args, signed char *) = val.s; 3127 else 3128 *va_arg(args, unsigned char *) = val.u; 3129 break; 3130 case 'h': 3131 if (is_sign) 3132 *va_arg(args, short *) = val.s; 3133 else 3134 *va_arg(args, unsigned short *) = val.u; 3135 break; 3136 case 'l': 3137 if (is_sign) 3138 *va_arg(args, long *) = val.s; 3139 else 3140 *va_arg(args, unsigned long *) = val.u; 3141 break; 3142 case 'L': 3143 if (is_sign) 3144 *va_arg(args, long long *) = val.s; 3145 else 3146 *va_arg(args, unsigned long long *) = val.u; 3147 break; 3148 case 'z': 3149 *va_arg(args, size_t *) = val.u; 3150 break; 3151 default: 3152 if (is_sign) 3153 *va_arg(args, int *) = val.s; 3154 else 3155 *va_arg(args, unsigned int *) = val.u; 3156 break; 3157 } 3158 num++; 3159 3160 if (!next) 3161 break; 3162 str = next; 3163 } 3164 3165 return num; 3166 } 3167 EXPORT_SYMBOL(vsscanf); 3168 3169 /** 3170 * sscanf - Unformat a buffer into a list of arguments 3171 * @buf: input buffer 3172 * @fmt: formatting of buffer 3173 * @...: resulting arguments 3174 */ 3175 int sscanf(const char *buf, const char *fmt, ...) 3176 { 3177 va_list args; 3178 int i; 3179 3180 va_start(args, fmt); 3181 i = vsscanf(buf, fmt, args); 3182 va_end(args); 3183 3184 return i; 3185 } 3186 EXPORT_SYMBOL(sscanf); 3187