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