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/module.h> /* for KSYM_SYMBOL_LEN */ 21 #include <linux/types.h> 22 #include <linux/string.h> 23 #include <linux/ctype.h> 24 #include <linux/kernel.h> 25 #include <linux/kallsyms.h> 26 #include <linux/math64.h> 27 #include <linux/uaccess.h> 28 #include <linux/ioport.h> 29 #include <linux/dcache.h> 30 #include <linux/cred.h> 31 #include <net/addrconf.h> 32 33 #include <asm/page.h> /* for PAGE_SIZE */ 34 #include <asm/sections.h> /* for dereference_function_descriptor() */ 35 36 #include "kstrtox.h" 37 38 /** 39 * simple_strtoull - convert a string to an unsigned long long 40 * @cp: The start of the string 41 * @endp: A pointer to the end of the parsed string will be placed here 42 * @base: The number base to use 43 * 44 * This function is obsolete. Please use kstrtoull instead. 45 */ 46 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base) 47 { 48 unsigned long long result; 49 unsigned int rv; 50 51 cp = _parse_integer_fixup_radix(cp, &base); 52 rv = _parse_integer(cp, base, &result); 53 /* FIXME */ 54 cp += (rv & ~KSTRTOX_OVERFLOW); 55 56 if (endp) 57 *endp = (char *)cp; 58 59 return result; 60 } 61 EXPORT_SYMBOL(simple_strtoull); 62 63 /** 64 * simple_strtoul - convert a string to an unsigned long 65 * @cp: The start of the string 66 * @endp: A pointer to the end of the parsed string will be placed here 67 * @base: The number base to use 68 * 69 * This function is obsolete. Please use kstrtoul instead. 70 */ 71 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base) 72 { 73 return simple_strtoull(cp, endp, base); 74 } 75 EXPORT_SYMBOL(simple_strtoul); 76 77 /** 78 * simple_strtol - convert a string to a signed long 79 * @cp: The start of the string 80 * @endp: A pointer to the end of the parsed string will be placed here 81 * @base: The number base to use 82 * 83 * This function is obsolete. Please use kstrtol instead. 84 */ 85 long simple_strtol(const char *cp, char **endp, unsigned int base) 86 { 87 if (*cp == '-') 88 return -simple_strtoul(cp + 1, endp, base); 89 90 return simple_strtoul(cp, endp, base); 91 } 92 EXPORT_SYMBOL(simple_strtol); 93 94 /** 95 * simple_strtoll - convert a string to a signed long long 96 * @cp: The start of the string 97 * @endp: A pointer to the end of the parsed string will be placed here 98 * @base: The number base to use 99 * 100 * This function is obsolete. Please use kstrtoll instead. 101 */ 102 long long simple_strtoll(const char *cp, char **endp, unsigned int base) 103 { 104 if (*cp == '-') 105 return -simple_strtoull(cp + 1, endp, base); 106 107 return simple_strtoull(cp, endp, base); 108 } 109 EXPORT_SYMBOL(simple_strtoll); 110 111 static noinline_for_stack 112 int skip_atoi(const char **s) 113 { 114 int i = 0; 115 116 while (isdigit(**s)) 117 i = i*10 + *((*s)++) - '0'; 118 119 return i; 120 } 121 122 /* Decimal conversion is by far the most typical, and is used 123 * for /proc and /sys data. This directly impacts e.g. top performance 124 * with many processes running. We optimize it for speed 125 * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html> 126 * (with permission from the author, Douglas W. Jones). 127 */ 128 129 #if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64 130 /* Formats correctly any integer in [0, 999999999] */ 131 static noinline_for_stack 132 char *put_dec_full9(char *buf, unsigned q) 133 { 134 unsigned r; 135 136 /* 137 * Possible ways to approx. divide by 10 138 * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit) 139 * (x * 0xcccd) >> 19 x < 81920 (x < 262149 when 64-bit mul) 140 * (x * 0x6667) >> 18 x < 43699 141 * (x * 0x3334) >> 17 x < 16389 142 * (x * 0x199a) >> 16 x < 16389 143 * (x * 0x0ccd) >> 15 x < 16389 144 * (x * 0x0667) >> 14 x < 2739 145 * (x * 0x0334) >> 13 x < 1029 146 * (x * 0x019a) >> 12 x < 1029 147 * (x * 0x00cd) >> 11 x < 1029 shorter code than * 0x67 (on i386) 148 * (x * 0x0067) >> 10 x < 179 149 * (x * 0x0034) >> 9 x < 69 same 150 * (x * 0x001a) >> 8 x < 69 same 151 * (x * 0x000d) >> 7 x < 69 same, shortest code (on i386) 152 * (x * 0x0007) >> 6 x < 19 153 * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html> 154 */ 155 r = (q * (uint64_t)0x1999999a) >> 32; 156 *buf++ = (q - 10 * r) + '0'; /* 1 */ 157 q = (r * (uint64_t)0x1999999a) >> 32; 158 *buf++ = (r - 10 * q) + '0'; /* 2 */ 159 r = (q * (uint64_t)0x1999999a) >> 32; 160 *buf++ = (q - 10 * r) + '0'; /* 3 */ 161 q = (r * (uint64_t)0x1999999a) >> 32; 162 *buf++ = (r - 10 * q) + '0'; /* 4 */ 163 r = (q * (uint64_t)0x1999999a) >> 32; 164 *buf++ = (q - 10 * r) + '0'; /* 5 */ 165 /* Now value is under 10000, can avoid 64-bit multiply */ 166 q = (r * 0x199a) >> 16; 167 *buf++ = (r - 10 * q) + '0'; /* 6 */ 168 r = (q * 0xcd) >> 11; 169 *buf++ = (q - 10 * r) + '0'; /* 7 */ 170 q = (r * 0xcd) >> 11; 171 *buf++ = (r - 10 * q) + '0'; /* 8 */ 172 *buf++ = q + '0'; /* 9 */ 173 return buf; 174 } 175 #endif 176 177 /* Similar to above but do not pad with zeros. 178 * Code can be easily arranged to print 9 digits too, but our callers 179 * always call put_dec_full9() instead when the number has 9 decimal digits. 180 */ 181 static noinline_for_stack 182 char *put_dec_trunc8(char *buf, unsigned r) 183 { 184 unsigned q; 185 186 /* Copy of previous function's body with added early returns */ 187 while (r >= 10000) { 188 q = r + '0'; 189 r = (r * (uint64_t)0x1999999a) >> 32; 190 *buf++ = q - 10*r; 191 } 192 193 q = (r * 0x199a) >> 16; /* r <= 9999 */ 194 *buf++ = (r - 10 * q) + '0'; 195 if (q == 0) 196 return buf; 197 r = (q * 0xcd) >> 11; /* q <= 999 */ 198 *buf++ = (q - 10 * r) + '0'; 199 if (r == 0) 200 return buf; 201 q = (r * 0xcd) >> 11; /* r <= 99 */ 202 *buf++ = (r - 10 * q) + '0'; 203 if (q == 0) 204 return buf; 205 *buf++ = q + '0'; /* q <= 9 */ 206 return buf; 207 } 208 209 /* There are two algorithms to print larger numbers. 210 * One is generic: divide by 1000000000 and repeatedly print 211 * groups of (up to) 9 digits. It's conceptually simple, 212 * but requires a (unsigned long long) / 1000000000 division. 213 * 214 * Second algorithm splits 64-bit unsigned long long into 16-bit chunks, 215 * manipulates them cleverly and generates groups of 4 decimal digits. 216 * It so happens that it does NOT require long long division. 217 * 218 * If long is > 32 bits, division of 64-bit values is relatively easy, 219 * and we will use the first algorithm. 220 * If long long is > 64 bits (strange architecture with VERY large long long), 221 * second algorithm can't be used, and we again use the first one. 222 * 223 * Else (if long is 32 bits and long long is 64 bits) we use second one. 224 */ 225 226 #if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64 227 228 /* First algorithm: generic */ 229 230 static 231 char *put_dec(char *buf, unsigned long long n) 232 { 233 if (n >= 100*1000*1000) { 234 while (n >= 1000*1000*1000) 235 buf = put_dec_full9(buf, do_div(n, 1000*1000*1000)); 236 if (n >= 100*1000*1000) 237 return put_dec_full9(buf, n); 238 } 239 return put_dec_trunc8(buf, n); 240 } 241 242 #else 243 244 /* Second algorithm: valid only for 64-bit long longs */ 245 246 /* See comment in put_dec_full9 for choice of constants */ 247 static noinline_for_stack 248 void put_dec_full4(char *buf, unsigned q) 249 { 250 unsigned r; 251 r = (q * 0xccd) >> 15; 252 buf[0] = (q - 10 * r) + '0'; 253 q = (r * 0xcd) >> 11; 254 buf[1] = (r - 10 * q) + '0'; 255 r = (q * 0xcd) >> 11; 256 buf[2] = (q - 10 * r) + '0'; 257 buf[3] = r + '0'; 258 } 259 260 /* 261 * Call put_dec_full4 on x % 10000, return x / 10000. 262 * The approximation x/10000 == (x * 0x346DC5D7) >> 43 263 * holds for all x < 1,128,869,999. The largest value this 264 * helper will ever be asked to convert is 1,125,520,955. 265 * (d1 in the put_dec code, assuming n is all-ones). 266 */ 267 static 268 unsigned put_dec_helper4(char *buf, unsigned x) 269 { 270 uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43; 271 272 put_dec_full4(buf, x - q * 10000); 273 return q; 274 } 275 276 /* Based on code by Douglas W. Jones found at 277 * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour> 278 * (with permission from the author). 279 * Performs no 64-bit division and hence should be fast on 32-bit machines. 280 */ 281 static 282 char *put_dec(char *buf, unsigned long long n) 283 { 284 uint32_t d3, d2, d1, q, h; 285 286 if (n < 100*1000*1000) 287 return put_dec_trunc8(buf, n); 288 289 d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */ 290 h = (n >> 32); 291 d2 = (h ) & 0xffff; 292 d3 = (h >> 16); /* implicit "& 0xffff" */ 293 294 q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff); 295 q = put_dec_helper4(buf, q); 296 297 q += 7671 * d3 + 9496 * d2 + 6 * d1; 298 q = put_dec_helper4(buf+4, q); 299 300 q += 4749 * d3 + 42 * d2; 301 q = put_dec_helper4(buf+8, q); 302 303 q += 281 * d3; 304 buf += 12; 305 if (q) 306 buf = put_dec_trunc8(buf, q); 307 else while (buf[-1] == '0') 308 --buf; 309 310 return buf; 311 } 312 313 #endif 314 315 /* 316 * Convert passed number to decimal string. 317 * Returns the length of string. On buffer overflow, returns 0. 318 * 319 * If speed is not important, use snprintf(). It's easy to read the code. 320 */ 321 int num_to_str(char *buf, int size, unsigned long long num) 322 { 323 char tmp[sizeof(num) * 3]; 324 int idx, len; 325 326 /* put_dec() may work incorrectly for num = 0 (generate "", not "0") */ 327 if (num <= 9) { 328 tmp[0] = '0' + num; 329 len = 1; 330 } else { 331 len = put_dec(tmp, num) - tmp; 332 } 333 334 if (len > size) 335 return 0; 336 for (idx = 0; idx < len; ++idx) 337 buf[idx] = tmp[len - idx - 1]; 338 return len; 339 } 340 341 #define ZEROPAD 1 /* pad with zero */ 342 #define SIGN 2 /* unsigned/signed long */ 343 #define PLUS 4 /* show plus */ 344 #define SPACE 8 /* space if plus */ 345 #define LEFT 16 /* left justified */ 346 #define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */ 347 #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */ 348 349 enum format_type { 350 FORMAT_TYPE_NONE, /* Just a string part */ 351 FORMAT_TYPE_WIDTH, 352 FORMAT_TYPE_PRECISION, 353 FORMAT_TYPE_CHAR, 354 FORMAT_TYPE_STR, 355 FORMAT_TYPE_PTR, 356 FORMAT_TYPE_PERCENT_CHAR, 357 FORMAT_TYPE_INVALID, 358 FORMAT_TYPE_LONG_LONG, 359 FORMAT_TYPE_ULONG, 360 FORMAT_TYPE_LONG, 361 FORMAT_TYPE_UBYTE, 362 FORMAT_TYPE_BYTE, 363 FORMAT_TYPE_USHORT, 364 FORMAT_TYPE_SHORT, 365 FORMAT_TYPE_UINT, 366 FORMAT_TYPE_INT, 367 FORMAT_TYPE_NRCHARS, 368 FORMAT_TYPE_SIZE_T, 369 FORMAT_TYPE_PTRDIFF 370 }; 371 372 struct printf_spec { 373 u8 type; /* format_type enum */ 374 u8 flags; /* flags to number() */ 375 u8 base; /* number base, 8, 10 or 16 only */ 376 u8 qualifier; /* number qualifier, one of 'hHlLtzZ' */ 377 s16 field_width; /* width of output field */ 378 s16 precision; /* # of digits/chars */ 379 }; 380 381 static noinline_for_stack 382 char *number(char *buf, char *end, unsigned long long num, 383 struct printf_spec spec) 384 { 385 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ 386 static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ 387 388 char tmp[66]; 389 char sign; 390 char locase; 391 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10); 392 int i; 393 bool is_zero = num == 0LL; 394 395 /* locase = 0 or 0x20. ORing digits or letters with 'locase' 396 * produces same digits or (maybe lowercased) letters */ 397 locase = (spec.flags & SMALL); 398 if (spec.flags & LEFT) 399 spec.flags &= ~ZEROPAD; 400 sign = 0; 401 if (spec.flags & SIGN) { 402 if ((signed long long)num < 0) { 403 sign = '-'; 404 num = -(signed long long)num; 405 spec.field_width--; 406 } else if (spec.flags & PLUS) { 407 sign = '+'; 408 spec.field_width--; 409 } else if (spec.flags & SPACE) { 410 sign = ' '; 411 spec.field_width--; 412 } 413 } 414 if (need_pfx) { 415 if (spec.base == 16) 416 spec.field_width -= 2; 417 else if (!is_zero) 418 spec.field_width--; 419 } 420 421 /* generate full string in tmp[], in reverse order */ 422 i = 0; 423 if (num < spec.base) 424 tmp[i++] = digits[num] | locase; 425 /* Generic code, for any base: 426 else do { 427 tmp[i++] = (digits[do_div(num,base)] | locase); 428 } while (num != 0); 429 */ 430 else if (spec.base != 10) { /* 8 or 16 */ 431 int mask = spec.base - 1; 432 int shift = 3; 433 434 if (spec.base == 16) 435 shift = 4; 436 do { 437 tmp[i++] = (digits[((unsigned char)num) & mask] | locase); 438 num >>= shift; 439 } while (num); 440 } else { /* base 10 */ 441 i = put_dec(tmp, num) - tmp; 442 } 443 444 /* printing 100 using %2d gives "100", not "00" */ 445 if (i > spec.precision) 446 spec.precision = i; 447 /* leading space padding */ 448 spec.field_width -= spec.precision; 449 if (!(spec.flags & (ZEROPAD+LEFT))) { 450 while (--spec.field_width >= 0) { 451 if (buf < end) 452 *buf = ' '; 453 ++buf; 454 } 455 } 456 /* sign */ 457 if (sign) { 458 if (buf < end) 459 *buf = sign; 460 ++buf; 461 } 462 /* "0x" / "0" prefix */ 463 if (need_pfx) { 464 if (spec.base == 16 || !is_zero) { 465 if (buf < end) 466 *buf = '0'; 467 ++buf; 468 } 469 if (spec.base == 16) { 470 if (buf < end) 471 *buf = ('X' | locase); 472 ++buf; 473 } 474 } 475 /* zero or space padding */ 476 if (!(spec.flags & LEFT)) { 477 char c = (spec.flags & ZEROPAD) ? '0' : ' '; 478 while (--spec.field_width >= 0) { 479 if (buf < end) 480 *buf = c; 481 ++buf; 482 } 483 } 484 /* hmm even more zero padding? */ 485 while (i <= --spec.precision) { 486 if (buf < end) 487 *buf = '0'; 488 ++buf; 489 } 490 /* actual digits of result */ 491 while (--i >= 0) { 492 if (buf < end) 493 *buf = tmp[i]; 494 ++buf; 495 } 496 /* trailing space padding */ 497 while (--spec.field_width >= 0) { 498 if (buf < end) 499 *buf = ' '; 500 ++buf; 501 } 502 503 return buf; 504 } 505 506 static noinline_for_stack 507 char *string(char *buf, char *end, const char *s, struct printf_spec spec) 508 { 509 int len, i; 510 511 if ((unsigned long)s < PAGE_SIZE) 512 s = "(null)"; 513 514 len = strnlen(s, spec.precision); 515 516 if (!(spec.flags & LEFT)) { 517 while (len < spec.field_width--) { 518 if (buf < end) 519 *buf = ' '; 520 ++buf; 521 } 522 } 523 for (i = 0; i < len; ++i) { 524 if (buf < end) 525 *buf = *s; 526 ++buf; ++s; 527 } 528 while (len < spec.field_width--) { 529 if (buf < end) 530 *buf = ' '; 531 ++buf; 532 } 533 534 return buf; 535 } 536 537 static void widen(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 static noinline_for_stack 556 char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec, 557 const char *fmt) 558 { 559 const char *array[4], *s; 560 const struct dentry *p; 561 int depth; 562 int i, n; 563 564 switch (fmt[1]) { 565 case '2': case '3': case '4': 566 depth = fmt[1] - '0'; 567 break; 568 default: 569 depth = 1; 570 } 571 572 rcu_read_lock(); 573 for (i = 0; i < depth; i++, d = p) { 574 p = ACCESS_ONCE(d->d_parent); 575 array[i] = ACCESS_ONCE(d->d_name.name); 576 if (p == d) { 577 if (i) 578 array[i] = ""; 579 i++; 580 break; 581 } 582 } 583 s = array[--i]; 584 for (n = 0; n != spec.precision; n++, buf++) { 585 char c = *s++; 586 if (!c) { 587 if (!i) 588 break; 589 c = '/'; 590 s = array[--i]; 591 } 592 if (buf < end) 593 *buf = c; 594 } 595 rcu_read_unlock(); 596 if (n < spec.field_width) { 597 /* we want to pad the sucker */ 598 unsigned spaces = spec.field_width - n; 599 if (!(spec.flags & LEFT)) { 600 widen(buf - n, end, n, spaces); 601 return buf + spaces; 602 } 603 while (spaces--) { 604 if (buf < end) 605 *buf = ' '; 606 ++buf; 607 } 608 } 609 return buf; 610 } 611 612 static noinline_for_stack 613 char *symbol_string(char *buf, char *end, void *ptr, 614 struct printf_spec spec, const char *fmt) 615 { 616 unsigned long value; 617 #ifdef CONFIG_KALLSYMS 618 char sym[KSYM_SYMBOL_LEN]; 619 #endif 620 621 if (fmt[1] == 'R') 622 ptr = __builtin_extract_return_addr(ptr); 623 value = (unsigned long)ptr; 624 625 #ifdef CONFIG_KALLSYMS 626 if (*fmt == 'B') 627 sprint_backtrace(sym, value); 628 else if (*fmt != 'f' && *fmt != 's') 629 sprint_symbol(sym, value); 630 else 631 sprint_symbol_no_offset(sym, value); 632 633 return string(buf, end, sym, spec); 634 #else 635 spec.field_width = 2 * sizeof(void *); 636 spec.flags |= SPECIAL | SMALL | ZEROPAD; 637 spec.base = 16; 638 639 return number(buf, end, value, spec); 640 #endif 641 } 642 643 static noinline_for_stack 644 char *resource_string(char *buf, char *end, struct resource *res, 645 struct printf_spec spec, const char *fmt) 646 { 647 #ifndef IO_RSRC_PRINTK_SIZE 648 #define IO_RSRC_PRINTK_SIZE 6 649 #endif 650 651 #ifndef MEM_RSRC_PRINTK_SIZE 652 #define MEM_RSRC_PRINTK_SIZE 10 653 #endif 654 static const struct printf_spec io_spec = { 655 .base = 16, 656 .field_width = IO_RSRC_PRINTK_SIZE, 657 .precision = -1, 658 .flags = SPECIAL | SMALL | ZEROPAD, 659 }; 660 static const struct printf_spec mem_spec = { 661 .base = 16, 662 .field_width = MEM_RSRC_PRINTK_SIZE, 663 .precision = -1, 664 .flags = SPECIAL | SMALL | ZEROPAD, 665 }; 666 static const struct printf_spec bus_spec = { 667 .base = 16, 668 .field_width = 2, 669 .precision = -1, 670 .flags = SMALL | ZEROPAD, 671 }; 672 static const struct printf_spec dec_spec = { 673 .base = 10, 674 .precision = -1, 675 .flags = 0, 676 }; 677 static const struct printf_spec str_spec = { 678 .field_width = -1, 679 .precision = 10, 680 .flags = LEFT, 681 }; 682 static const struct printf_spec flag_spec = { 683 .base = 16, 684 .precision = -1, 685 .flags = SPECIAL | SMALL, 686 }; 687 688 /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8) 689 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */ 690 #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4) 691 #define FLAG_BUF_SIZE (2 * sizeof(res->flags)) 692 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]") 693 #define RAW_BUF_SIZE sizeof("[mem - flags 0x]") 694 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, 695 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)]; 696 697 char *p = sym, *pend = sym + sizeof(sym); 698 int decode = (fmt[0] == 'R') ? 1 : 0; 699 const struct printf_spec *specp; 700 701 *p++ = '['; 702 if (res->flags & IORESOURCE_IO) { 703 p = string(p, pend, "io ", str_spec); 704 specp = &io_spec; 705 } else if (res->flags & IORESOURCE_MEM) { 706 p = string(p, pend, "mem ", str_spec); 707 specp = &mem_spec; 708 } else if (res->flags & IORESOURCE_IRQ) { 709 p = string(p, pend, "irq ", str_spec); 710 specp = &dec_spec; 711 } else if (res->flags & IORESOURCE_DMA) { 712 p = string(p, pend, "dma ", str_spec); 713 specp = &dec_spec; 714 } else if (res->flags & IORESOURCE_BUS) { 715 p = string(p, pend, "bus ", str_spec); 716 specp = &bus_spec; 717 } else { 718 p = string(p, pend, "??? ", str_spec); 719 specp = &mem_spec; 720 decode = 0; 721 } 722 p = number(p, pend, res->start, *specp); 723 if (res->start != res->end) { 724 *p++ = '-'; 725 p = number(p, pend, res->end, *specp); 726 } 727 if (decode) { 728 if (res->flags & IORESOURCE_MEM_64) 729 p = string(p, pend, " 64bit", str_spec); 730 if (res->flags & IORESOURCE_PREFETCH) 731 p = string(p, pend, " pref", str_spec); 732 if (res->flags & IORESOURCE_WINDOW) 733 p = string(p, pend, " window", str_spec); 734 if (res->flags & IORESOURCE_DISABLED) 735 p = string(p, pend, " disabled", str_spec); 736 } else { 737 p = string(p, pend, " flags ", str_spec); 738 p = number(p, pend, res->flags, flag_spec); 739 } 740 *p++ = ']'; 741 *p = '\0'; 742 743 return string(buf, end, sym, spec); 744 } 745 746 static noinline_for_stack 747 char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec, 748 const char *fmt) 749 { 750 int i, len = 1; /* if we pass '%ph[CDN]', field width remains 751 negative value, fallback to the default */ 752 char separator; 753 754 if (spec.field_width == 0) 755 /* nothing to print */ 756 return buf; 757 758 if (ZERO_OR_NULL_PTR(addr)) 759 /* NULL pointer */ 760 return string(buf, end, NULL, spec); 761 762 switch (fmt[1]) { 763 case 'C': 764 separator = ':'; 765 break; 766 case 'D': 767 separator = '-'; 768 break; 769 case 'N': 770 separator = 0; 771 break; 772 default: 773 separator = ' '; 774 break; 775 } 776 777 if (spec.field_width > 0) 778 len = min_t(int, spec.field_width, 64); 779 780 for (i = 0; i < len && buf < end - 1; i++) { 781 buf = hex_byte_pack(buf, addr[i]); 782 783 if (buf < end && separator && i != len - 1) 784 *buf++ = separator; 785 } 786 787 return buf; 788 } 789 790 static noinline_for_stack 791 char *mac_address_string(char *buf, char *end, u8 *addr, 792 struct printf_spec spec, const char *fmt) 793 { 794 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")]; 795 char *p = mac_addr; 796 int i; 797 char separator; 798 bool reversed = false; 799 800 switch (fmt[1]) { 801 case 'F': 802 separator = '-'; 803 break; 804 805 case 'R': 806 reversed = true; 807 /* fall through */ 808 809 default: 810 separator = ':'; 811 break; 812 } 813 814 for (i = 0; i < 6; i++) { 815 if (reversed) 816 p = hex_byte_pack(p, addr[5 - i]); 817 else 818 p = hex_byte_pack(p, addr[i]); 819 820 if (fmt[0] == 'M' && i != 5) 821 *p++ = separator; 822 } 823 *p = '\0'; 824 825 return string(buf, end, mac_addr, spec); 826 } 827 828 static noinline_for_stack 829 char *ip4_string(char *p, const u8 *addr, const char *fmt) 830 { 831 int i; 832 bool leading_zeros = (fmt[0] == 'i'); 833 int index; 834 int step; 835 836 switch (fmt[2]) { 837 case 'h': 838 #ifdef __BIG_ENDIAN 839 index = 0; 840 step = 1; 841 #else 842 index = 3; 843 step = -1; 844 #endif 845 break; 846 case 'l': 847 index = 3; 848 step = -1; 849 break; 850 case 'n': 851 case 'b': 852 default: 853 index = 0; 854 step = 1; 855 break; 856 } 857 for (i = 0; i < 4; i++) { 858 char temp[3]; /* hold each IP quad in reverse order */ 859 int digits = put_dec_trunc8(temp, addr[index]) - temp; 860 if (leading_zeros) { 861 if (digits < 3) 862 *p++ = '0'; 863 if (digits < 2) 864 *p++ = '0'; 865 } 866 /* reverse the digits in the quad */ 867 while (digits--) 868 *p++ = temp[digits]; 869 if (i < 3) 870 *p++ = '.'; 871 index += step; 872 } 873 *p = '\0'; 874 875 return p; 876 } 877 878 static noinline_for_stack 879 char *ip6_compressed_string(char *p, const char *addr) 880 { 881 int i, j, range; 882 unsigned char zerolength[8]; 883 int longest = 1; 884 int colonpos = -1; 885 u16 word; 886 u8 hi, lo; 887 bool needcolon = false; 888 bool useIPv4; 889 struct in6_addr in6; 890 891 memcpy(&in6, addr, sizeof(struct in6_addr)); 892 893 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 894 895 memset(zerolength, 0, sizeof(zerolength)); 896 897 if (useIPv4) 898 range = 6; 899 else 900 range = 8; 901 902 /* find position of longest 0 run */ 903 for (i = 0; i < range; i++) { 904 for (j = i; j < range; j++) { 905 if (in6.s6_addr16[j] != 0) 906 break; 907 zerolength[i]++; 908 } 909 } 910 for (i = 0; i < range; i++) { 911 if (zerolength[i] > longest) { 912 longest = zerolength[i]; 913 colonpos = i; 914 } 915 } 916 if (longest == 1) /* don't compress a single 0 */ 917 colonpos = -1; 918 919 /* emit address */ 920 for (i = 0; i < range; i++) { 921 if (i == colonpos) { 922 if (needcolon || i == 0) 923 *p++ = ':'; 924 *p++ = ':'; 925 needcolon = false; 926 i += longest - 1; 927 continue; 928 } 929 if (needcolon) { 930 *p++ = ':'; 931 needcolon = false; 932 } 933 /* hex u16 without leading 0s */ 934 word = ntohs(in6.s6_addr16[i]); 935 hi = word >> 8; 936 lo = word & 0xff; 937 if (hi) { 938 if (hi > 0x0f) 939 p = hex_byte_pack(p, hi); 940 else 941 *p++ = hex_asc_lo(hi); 942 p = hex_byte_pack(p, lo); 943 } 944 else if (lo > 0x0f) 945 p = hex_byte_pack(p, lo); 946 else 947 *p++ = hex_asc_lo(lo); 948 needcolon = true; 949 } 950 951 if (useIPv4) { 952 if (needcolon) 953 *p++ = ':'; 954 p = ip4_string(p, &in6.s6_addr[12], "I4"); 955 } 956 *p = '\0'; 957 958 return p; 959 } 960 961 static noinline_for_stack 962 char *ip6_string(char *p, const char *addr, const char *fmt) 963 { 964 int i; 965 966 for (i = 0; i < 8; i++) { 967 p = hex_byte_pack(p, *addr++); 968 p = hex_byte_pack(p, *addr++); 969 if (fmt[0] == 'I' && i != 7) 970 *p++ = ':'; 971 } 972 *p = '\0'; 973 974 return p; 975 } 976 977 static noinline_for_stack 978 char *ip6_addr_string(char *buf, char *end, const u8 *addr, 979 struct printf_spec spec, const char *fmt) 980 { 981 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 982 983 if (fmt[0] == 'I' && fmt[2] == 'c') 984 ip6_compressed_string(ip6_addr, addr); 985 else 986 ip6_string(ip6_addr, addr, fmt); 987 988 return string(buf, end, ip6_addr, spec); 989 } 990 991 static noinline_for_stack 992 char *ip4_addr_string(char *buf, char *end, const u8 *addr, 993 struct printf_spec spec, const char *fmt) 994 { 995 char ip4_addr[sizeof("255.255.255.255")]; 996 997 ip4_string(ip4_addr, addr, fmt); 998 999 return string(buf, end, ip4_addr, spec); 1000 } 1001 1002 static noinline_for_stack 1003 char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa, 1004 struct printf_spec spec, const char *fmt) 1005 { 1006 bool have_p = false, have_s = false, have_f = false, have_c = false; 1007 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") + 1008 sizeof(":12345") + sizeof("/123456789") + 1009 sizeof("%1234567890")]; 1010 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr); 1011 const u8 *addr = (const u8 *) &sa->sin6_addr; 1012 char fmt6[2] = { fmt[0], '6' }; 1013 u8 off = 0; 1014 1015 fmt++; 1016 while (isalpha(*++fmt)) { 1017 switch (*fmt) { 1018 case 'p': 1019 have_p = true; 1020 break; 1021 case 'f': 1022 have_f = true; 1023 break; 1024 case 's': 1025 have_s = true; 1026 break; 1027 case 'c': 1028 have_c = true; 1029 break; 1030 } 1031 } 1032 1033 if (have_p || have_s || have_f) { 1034 *p = '['; 1035 off = 1; 1036 } 1037 1038 if (fmt6[0] == 'I' && have_c) 1039 p = ip6_compressed_string(ip6_addr + off, addr); 1040 else 1041 p = ip6_string(ip6_addr + off, addr, fmt6); 1042 1043 if (have_p || have_s || have_f) 1044 *p++ = ']'; 1045 1046 if (have_p) { 1047 *p++ = ':'; 1048 p = number(p, pend, ntohs(sa->sin6_port), spec); 1049 } 1050 if (have_f) { 1051 *p++ = '/'; 1052 p = number(p, pend, ntohl(sa->sin6_flowinfo & 1053 IPV6_FLOWINFO_MASK), spec); 1054 } 1055 if (have_s) { 1056 *p++ = '%'; 1057 p = number(p, pend, sa->sin6_scope_id, spec); 1058 } 1059 *p = '\0'; 1060 1061 return string(buf, end, ip6_addr, spec); 1062 } 1063 1064 static noinline_for_stack 1065 char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa, 1066 struct printf_spec spec, const char *fmt) 1067 { 1068 bool have_p = false; 1069 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")]; 1070 char *pend = ip4_addr + sizeof(ip4_addr); 1071 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr; 1072 char fmt4[3] = { fmt[0], '4', 0 }; 1073 1074 fmt++; 1075 while (isalpha(*++fmt)) { 1076 switch (*fmt) { 1077 case 'p': 1078 have_p = true; 1079 break; 1080 case 'h': 1081 case 'l': 1082 case 'n': 1083 case 'b': 1084 fmt4[2] = *fmt; 1085 break; 1086 } 1087 } 1088 1089 p = ip4_string(ip4_addr, addr, fmt4); 1090 if (have_p) { 1091 *p++ = ':'; 1092 p = number(p, pend, ntohs(sa->sin_port), spec); 1093 } 1094 *p = '\0'; 1095 1096 return string(buf, end, ip4_addr, spec); 1097 } 1098 1099 static noinline_for_stack 1100 char *uuid_string(char *buf, char *end, const u8 *addr, 1101 struct printf_spec spec, const char *fmt) 1102 { 1103 char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")]; 1104 char *p = uuid; 1105 int i; 1106 static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; 1107 static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15}; 1108 const u8 *index = be; 1109 bool uc = false; 1110 1111 switch (*(++fmt)) { 1112 case 'L': 1113 uc = true; /* fall-through */ 1114 case 'l': 1115 index = le; 1116 break; 1117 case 'B': 1118 uc = true; 1119 break; 1120 } 1121 1122 for (i = 0; i < 16; i++) { 1123 p = hex_byte_pack(p, addr[index[i]]); 1124 switch (i) { 1125 case 3: 1126 case 5: 1127 case 7: 1128 case 9: 1129 *p++ = '-'; 1130 break; 1131 } 1132 } 1133 1134 *p = 0; 1135 1136 if (uc) { 1137 p = uuid; 1138 do { 1139 *p = toupper(*p); 1140 } while (*(++p)); 1141 } 1142 1143 return string(buf, end, uuid, spec); 1144 } 1145 1146 static 1147 char *netdev_feature_string(char *buf, char *end, const u8 *addr, 1148 struct printf_spec spec) 1149 { 1150 spec.flags |= SPECIAL | SMALL | ZEROPAD; 1151 if (spec.field_width == -1) 1152 spec.field_width = 2 + 2 * sizeof(netdev_features_t); 1153 spec.base = 16; 1154 1155 return number(buf, end, *(const netdev_features_t *)addr, spec); 1156 } 1157 1158 int kptr_restrict __read_mostly; 1159 1160 /* 1161 * Show a '%p' thing. A kernel extension is that the '%p' is followed 1162 * by an extra set of alphanumeric characters that are extended format 1163 * specifiers. 1164 * 1165 * Right now we handle: 1166 * 1167 * - 'F' For symbolic function descriptor pointers with offset 1168 * - 'f' For simple symbolic function names without offset 1169 * - 'S' For symbolic direct pointers with offset 1170 * - 's' For symbolic direct pointers without offset 1171 * - '[FfSs]R' as above with __builtin_extract_return_addr() translation 1172 * - 'B' For backtraced symbolic direct pointers with offset 1173 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 1174 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 1175 * - 'M' For a 6-byte MAC address, it prints the address in the 1176 * usual colon-separated hex notation 1177 * - 'm' For a 6-byte MAC address, it prints the hex address without colons 1178 * - 'MF' For a 6-byte MAC FDDI address, it prints the address 1179 * with a dash-separated hex notation 1180 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth) 1181 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 1182 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 1183 * IPv6 uses colon separated network-order 16 bit hex with leading 0's 1184 * [S][pfs] 1185 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 1186 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 1187 * - 'i' [46] for 'raw' IPv4/IPv6 addresses 1188 * IPv6 omits the colons (01020304...0f) 1189 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 1190 * [S][pfs] 1191 * Generic IPv4/IPv6 address (struct sockaddr *) that falls back to 1192 * [4] or [6] and is able to print port [p], flowinfo [f], scope [s] 1193 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order 1194 * - 'I[6S]c' for IPv6 addresses printed as specified by 1195 * http://tools.ietf.org/html/rfc5952 1196 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 1197 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 1198 * Options for %pU are: 1199 * b big endian lower case hex (default) 1200 * B big endian UPPER case hex 1201 * l little endian lower case hex 1202 * L little endian UPPER case hex 1203 * big endian output byte order is: 1204 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 1205 * little endian output byte order is: 1206 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 1207 * - 'V' For a struct va_format which contains a format string * and va_list *, 1208 * call vsnprintf(->format, *->va_list). 1209 * Implements a "recursive vsnprintf". 1210 * Do not use this feature without some mechanism to verify the 1211 * correctness of the format string and va_list arguments. 1212 * - 'K' For a kernel pointer that should be hidden from unprivileged users 1213 * - 'NF' For a netdev_features_t 1214 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with 1215 * a certain separator (' ' by default): 1216 * C colon 1217 * D dash 1218 * N no separator 1219 * The maximum supported length is 64 bytes of the input. Consider 1220 * to use print_hex_dump() for the larger input. 1221 * - 'a' For a phys_addr_t type and its derivative types (passed by reference) 1222 * - 'd[234]' For a dentry name (optionally 2-4 last components) 1223 * - 'D[234]' Same as 'd' but for a struct file 1224 * 1225 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 1226 * function pointers are really function descriptors, which contain a 1227 * pointer to the real address. 1228 */ 1229 static noinline_for_stack 1230 char *pointer(const char *fmt, char *buf, char *end, void *ptr, 1231 struct printf_spec spec) 1232 { 1233 int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0); 1234 1235 if (!ptr && *fmt != 'K') { 1236 /* 1237 * Print (null) with the same width as a pointer so it makes 1238 * tabular output look nice. 1239 */ 1240 if (spec.field_width == -1) 1241 spec.field_width = default_width; 1242 return string(buf, end, "(null)", spec); 1243 } 1244 1245 switch (*fmt) { 1246 case 'F': 1247 case 'f': 1248 ptr = dereference_function_descriptor(ptr); 1249 /* Fallthrough */ 1250 case 'S': 1251 case 's': 1252 case 'B': 1253 return symbol_string(buf, end, ptr, spec, fmt); 1254 case 'R': 1255 case 'r': 1256 return resource_string(buf, end, ptr, spec, fmt); 1257 case 'h': 1258 return hex_string(buf, end, ptr, spec, fmt); 1259 case 'M': /* Colon separated: 00:01:02:03:04:05 */ 1260 case 'm': /* Contiguous: 000102030405 */ 1261 /* [mM]F (FDDI) */ 1262 /* [mM]R (Reverse order; Bluetooth) */ 1263 return mac_address_string(buf, end, ptr, spec, fmt); 1264 case 'I': /* Formatted IP supported 1265 * 4: 1.2.3.4 1266 * 6: 0001:0203:...:0708 1267 * 6c: 1::708 or 1::1.2.3.4 1268 */ 1269 case 'i': /* Contiguous: 1270 * 4: 001.002.003.004 1271 * 6: 000102...0f 1272 */ 1273 switch (fmt[1]) { 1274 case '6': 1275 return ip6_addr_string(buf, end, ptr, spec, fmt); 1276 case '4': 1277 return ip4_addr_string(buf, end, ptr, spec, fmt); 1278 case 'S': { 1279 const union { 1280 struct sockaddr raw; 1281 struct sockaddr_in v4; 1282 struct sockaddr_in6 v6; 1283 } *sa = ptr; 1284 1285 switch (sa->raw.sa_family) { 1286 case AF_INET: 1287 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt); 1288 case AF_INET6: 1289 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt); 1290 default: 1291 return string(buf, end, "(invalid address)", spec); 1292 }} 1293 } 1294 break; 1295 case 'U': 1296 return uuid_string(buf, end, ptr, spec, fmt); 1297 case 'V': 1298 { 1299 va_list va; 1300 1301 va_copy(va, *((struct va_format *)ptr)->va); 1302 buf += vsnprintf(buf, end > buf ? end - buf : 0, 1303 ((struct va_format *)ptr)->fmt, va); 1304 va_end(va); 1305 return buf; 1306 } 1307 case 'K': 1308 /* 1309 * %pK cannot be used in IRQ context because its test 1310 * for CAP_SYSLOG would be meaningless. 1311 */ 1312 if (kptr_restrict && (in_irq() || in_serving_softirq() || 1313 in_nmi())) { 1314 if (spec.field_width == -1) 1315 spec.field_width = default_width; 1316 return string(buf, end, "pK-error", spec); 1317 } 1318 1319 switch (kptr_restrict) { 1320 case 0: 1321 /* Always print %pK values */ 1322 break; 1323 case 1: { 1324 /* 1325 * Only print the real pointer value if the current 1326 * process has CAP_SYSLOG and is running with the 1327 * same credentials it started with. This is because 1328 * access to files is checked at open() time, but %pK 1329 * checks permission at read() time. We don't want to 1330 * leak pointer values if a binary opens a file using 1331 * %pK and then elevates privileges before reading it. 1332 */ 1333 const struct cred *cred = current_cred(); 1334 1335 if (!has_capability_noaudit(current, CAP_SYSLOG) || 1336 !uid_eq(cred->euid, cred->uid) || 1337 !gid_eq(cred->egid, cred->gid)) 1338 ptr = NULL; 1339 break; 1340 } 1341 case 2: 1342 default: 1343 /* Always print 0's for %pK */ 1344 ptr = NULL; 1345 break; 1346 } 1347 break; 1348 1349 case 'N': 1350 switch (fmt[1]) { 1351 case 'F': 1352 return netdev_feature_string(buf, end, ptr, spec); 1353 } 1354 break; 1355 case 'a': 1356 spec.flags |= SPECIAL | SMALL | ZEROPAD; 1357 spec.field_width = sizeof(phys_addr_t) * 2 + 2; 1358 spec.base = 16; 1359 return number(buf, end, 1360 (unsigned long long) *((phys_addr_t *)ptr), spec); 1361 case 'd': 1362 return dentry_name(buf, end, ptr, spec, fmt); 1363 case 'D': 1364 return dentry_name(buf, end, 1365 ((const struct file *)ptr)->f_path.dentry, 1366 spec, fmt); 1367 } 1368 spec.flags |= SMALL; 1369 if (spec.field_width == -1) { 1370 spec.field_width = default_width; 1371 spec.flags |= ZEROPAD; 1372 } 1373 spec.base = 16; 1374 1375 return number(buf, end, (unsigned long) ptr, spec); 1376 } 1377 1378 /* 1379 * Helper function to decode printf style format. 1380 * Each call decode a token from the format and return the 1381 * number of characters read (or likely the delta where it wants 1382 * to go on the next call). 1383 * The decoded token is returned through the parameters 1384 * 1385 * 'h', 'l', or 'L' for integer fields 1386 * 'z' support added 23/7/1999 S.H. 1387 * 'z' changed to 'Z' --davidm 1/25/99 1388 * 't' added for ptrdiff_t 1389 * 1390 * @fmt: the format string 1391 * @type of the token returned 1392 * @flags: various flags such as +, -, # tokens.. 1393 * @field_width: overwritten width 1394 * @base: base of the number (octal, hex, ...) 1395 * @precision: precision of a number 1396 * @qualifier: qualifier of a number (long, size_t, ...) 1397 */ 1398 static noinline_for_stack 1399 int format_decode(const char *fmt, struct printf_spec *spec) 1400 { 1401 const char *start = fmt; 1402 1403 /* we finished early by reading the field width */ 1404 if (spec->type == FORMAT_TYPE_WIDTH) { 1405 if (spec->field_width < 0) { 1406 spec->field_width = -spec->field_width; 1407 spec->flags |= LEFT; 1408 } 1409 spec->type = FORMAT_TYPE_NONE; 1410 goto precision; 1411 } 1412 1413 /* we finished early by reading the precision */ 1414 if (spec->type == FORMAT_TYPE_PRECISION) { 1415 if (spec->precision < 0) 1416 spec->precision = 0; 1417 1418 spec->type = FORMAT_TYPE_NONE; 1419 goto qualifier; 1420 } 1421 1422 /* By default */ 1423 spec->type = FORMAT_TYPE_NONE; 1424 1425 for (; *fmt ; ++fmt) { 1426 if (*fmt == '%') 1427 break; 1428 } 1429 1430 /* Return the current non-format string */ 1431 if (fmt != start || !*fmt) 1432 return fmt - start; 1433 1434 /* Process flags */ 1435 spec->flags = 0; 1436 1437 while (1) { /* this also skips first '%' */ 1438 bool found = true; 1439 1440 ++fmt; 1441 1442 switch (*fmt) { 1443 case '-': spec->flags |= LEFT; break; 1444 case '+': spec->flags |= PLUS; break; 1445 case ' ': spec->flags |= SPACE; break; 1446 case '#': spec->flags |= SPECIAL; break; 1447 case '0': spec->flags |= ZEROPAD; break; 1448 default: found = false; 1449 } 1450 1451 if (!found) 1452 break; 1453 } 1454 1455 /* get field width */ 1456 spec->field_width = -1; 1457 1458 if (isdigit(*fmt)) 1459 spec->field_width = skip_atoi(&fmt); 1460 else if (*fmt == '*') { 1461 /* it's the next argument */ 1462 spec->type = FORMAT_TYPE_WIDTH; 1463 return ++fmt - start; 1464 } 1465 1466 precision: 1467 /* get the precision */ 1468 spec->precision = -1; 1469 if (*fmt == '.') { 1470 ++fmt; 1471 if (isdigit(*fmt)) { 1472 spec->precision = skip_atoi(&fmt); 1473 if (spec->precision < 0) 1474 spec->precision = 0; 1475 } else if (*fmt == '*') { 1476 /* it's the next argument */ 1477 spec->type = FORMAT_TYPE_PRECISION; 1478 return ++fmt - start; 1479 } 1480 } 1481 1482 qualifier: 1483 /* get the conversion qualifier */ 1484 spec->qualifier = -1; 1485 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 1486 _tolower(*fmt) == 'z' || *fmt == 't') { 1487 spec->qualifier = *fmt++; 1488 if (unlikely(spec->qualifier == *fmt)) { 1489 if (spec->qualifier == 'l') { 1490 spec->qualifier = 'L'; 1491 ++fmt; 1492 } else if (spec->qualifier == 'h') { 1493 spec->qualifier = 'H'; 1494 ++fmt; 1495 } 1496 } 1497 } 1498 1499 /* default base */ 1500 spec->base = 10; 1501 switch (*fmt) { 1502 case 'c': 1503 spec->type = FORMAT_TYPE_CHAR; 1504 return ++fmt - start; 1505 1506 case 's': 1507 spec->type = FORMAT_TYPE_STR; 1508 return ++fmt - start; 1509 1510 case 'p': 1511 spec->type = FORMAT_TYPE_PTR; 1512 return fmt - start; 1513 /* skip alnum */ 1514 1515 case 'n': 1516 spec->type = FORMAT_TYPE_NRCHARS; 1517 return ++fmt - start; 1518 1519 case '%': 1520 spec->type = FORMAT_TYPE_PERCENT_CHAR; 1521 return ++fmt - start; 1522 1523 /* integer number formats - set up the flags and "break" */ 1524 case 'o': 1525 spec->base = 8; 1526 break; 1527 1528 case 'x': 1529 spec->flags |= SMALL; 1530 1531 case 'X': 1532 spec->base = 16; 1533 break; 1534 1535 case 'd': 1536 case 'i': 1537 spec->flags |= SIGN; 1538 case 'u': 1539 break; 1540 1541 default: 1542 spec->type = FORMAT_TYPE_INVALID; 1543 return fmt - start; 1544 } 1545 1546 if (spec->qualifier == 'L') 1547 spec->type = FORMAT_TYPE_LONG_LONG; 1548 else if (spec->qualifier == 'l') { 1549 if (spec->flags & SIGN) 1550 spec->type = FORMAT_TYPE_LONG; 1551 else 1552 spec->type = FORMAT_TYPE_ULONG; 1553 } else if (_tolower(spec->qualifier) == 'z') { 1554 spec->type = FORMAT_TYPE_SIZE_T; 1555 } else if (spec->qualifier == 't') { 1556 spec->type = FORMAT_TYPE_PTRDIFF; 1557 } else if (spec->qualifier == 'H') { 1558 if (spec->flags & SIGN) 1559 spec->type = FORMAT_TYPE_BYTE; 1560 else 1561 spec->type = FORMAT_TYPE_UBYTE; 1562 } else if (spec->qualifier == 'h') { 1563 if (spec->flags & SIGN) 1564 spec->type = FORMAT_TYPE_SHORT; 1565 else 1566 spec->type = FORMAT_TYPE_USHORT; 1567 } else { 1568 if (spec->flags & SIGN) 1569 spec->type = FORMAT_TYPE_INT; 1570 else 1571 spec->type = FORMAT_TYPE_UINT; 1572 } 1573 1574 return ++fmt - start; 1575 } 1576 1577 /** 1578 * vsnprintf - Format a string and place it in a buffer 1579 * @buf: The buffer to place the result into 1580 * @size: The size of the buffer, including the trailing null space 1581 * @fmt: The format string to use 1582 * @args: Arguments for the format string 1583 * 1584 * This function follows C99 vsnprintf, but has some extensions: 1585 * %pS output the name of a text symbol with offset 1586 * %ps output the name of a text symbol without offset 1587 * %pF output the name of a function pointer with its offset 1588 * %pf output the name of a function pointer without its offset 1589 * %pB output the name of a backtrace symbol with its offset 1590 * %pR output the address range in a struct resource with decoded flags 1591 * %pr output the address range in a struct resource with raw flags 1592 * %pM output a 6-byte MAC address with colons 1593 * %pMR output a 6-byte MAC address with colons in reversed order 1594 * %pMF output a 6-byte MAC address with dashes 1595 * %pm output a 6-byte MAC address without colons 1596 * %pmR output a 6-byte MAC address without colons in reversed order 1597 * %pI4 print an IPv4 address without leading zeros 1598 * %pi4 print an IPv4 address with leading zeros 1599 * %pI6 print an IPv6 address with colons 1600 * %pi6 print an IPv6 address without colons 1601 * %pI6c print an IPv6 address as specified by RFC 5952 1602 * %pIS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address 1603 * %piS depending on sa_family of 'struct sockaddr *' print IPv4/IPv6 address 1604 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper 1605 * case. 1606 * %*ph[CDN] a variable-length hex string with a separator (supports up to 64 1607 * bytes of the input) 1608 * %n is ignored 1609 * 1610 * ** Please update Documentation/printk-formats.txt when making changes ** 1611 * 1612 * The return value is the number of characters which would 1613 * be generated for the given input, excluding the trailing 1614 * '\0', as per ISO C99. If you want to have the exact 1615 * number of characters written into @buf as return value 1616 * (not including the trailing '\0'), use vscnprintf(). If the 1617 * return is greater than or equal to @size, the resulting 1618 * string is truncated. 1619 * 1620 * If you're not already dealing with a va_list consider using snprintf(). 1621 */ 1622 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 1623 { 1624 unsigned long long num; 1625 char *str, *end; 1626 struct printf_spec spec = {0}; 1627 1628 /* Reject out-of-range values early. Large positive sizes are 1629 used for unknown buffer sizes. */ 1630 if (WARN_ON_ONCE((int) size < 0)) 1631 return 0; 1632 1633 str = buf; 1634 end = buf + size; 1635 1636 /* Make sure end is always >= buf */ 1637 if (end < buf) { 1638 end = ((void *)-1); 1639 size = end - buf; 1640 } 1641 1642 while (*fmt) { 1643 const char *old_fmt = fmt; 1644 int read = format_decode(fmt, &spec); 1645 1646 fmt += read; 1647 1648 switch (spec.type) { 1649 case FORMAT_TYPE_NONE: { 1650 int copy = read; 1651 if (str < end) { 1652 if (copy > end - str) 1653 copy = end - str; 1654 memcpy(str, old_fmt, copy); 1655 } 1656 str += read; 1657 break; 1658 } 1659 1660 case FORMAT_TYPE_WIDTH: 1661 spec.field_width = va_arg(args, int); 1662 break; 1663 1664 case FORMAT_TYPE_PRECISION: 1665 spec.precision = va_arg(args, int); 1666 break; 1667 1668 case FORMAT_TYPE_CHAR: { 1669 char c; 1670 1671 if (!(spec.flags & LEFT)) { 1672 while (--spec.field_width > 0) { 1673 if (str < end) 1674 *str = ' '; 1675 ++str; 1676 1677 } 1678 } 1679 c = (unsigned char) va_arg(args, int); 1680 if (str < end) 1681 *str = c; 1682 ++str; 1683 while (--spec.field_width > 0) { 1684 if (str < end) 1685 *str = ' '; 1686 ++str; 1687 } 1688 break; 1689 } 1690 1691 case FORMAT_TYPE_STR: 1692 str = string(str, end, va_arg(args, char *), spec); 1693 break; 1694 1695 case FORMAT_TYPE_PTR: 1696 str = pointer(fmt+1, str, end, va_arg(args, void *), 1697 spec); 1698 while (isalnum(*fmt)) 1699 fmt++; 1700 break; 1701 1702 case FORMAT_TYPE_PERCENT_CHAR: 1703 if (str < end) 1704 *str = '%'; 1705 ++str; 1706 break; 1707 1708 case FORMAT_TYPE_INVALID: 1709 if (str < end) 1710 *str = '%'; 1711 ++str; 1712 break; 1713 1714 case FORMAT_TYPE_NRCHARS: { 1715 /* 1716 * Since %n poses a greater security risk than 1717 * utility, ignore %n and skip its argument. 1718 */ 1719 void *skip_arg; 1720 1721 WARN_ONCE(1, "Please remove ignored %%n in '%s'\n", 1722 old_fmt); 1723 1724 skip_arg = va_arg(args, void *); 1725 break; 1726 } 1727 1728 default: 1729 switch (spec.type) { 1730 case FORMAT_TYPE_LONG_LONG: 1731 num = va_arg(args, long long); 1732 break; 1733 case FORMAT_TYPE_ULONG: 1734 num = va_arg(args, unsigned long); 1735 break; 1736 case FORMAT_TYPE_LONG: 1737 num = va_arg(args, long); 1738 break; 1739 case FORMAT_TYPE_SIZE_T: 1740 if (spec.flags & SIGN) 1741 num = va_arg(args, ssize_t); 1742 else 1743 num = va_arg(args, size_t); 1744 break; 1745 case FORMAT_TYPE_PTRDIFF: 1746 num = va_arg(args, ptrdiff_t); 1747 break; 1748 case FORMAT_TYPE_UBYTE: 1749 num = (unsigned char) va_arg(args, int); 1750 break; 1751 case FORMAT_TYPE_BYTE: 1752 num = (signed char) va_arg(args, int); 1753 break; 1754 case FORMAT_TYPE_USHORT: 1755 num = (unsigned short) va_arg(args, int); 1756 break; 1757 case FORMAT_TYPE_SHORT: 1758 num = (short) va_arg(args, int); 1759 break; 1760 case FORMAT_TYPE_INT: 1761 num = (int) va_arg(args, int); 1762 break; 1763 default: 1764 num = va_arg(args, unsigned int); 1765 } 1766 1767 str = number(str, end, num, spec); 1768 } 1769 } 1770 1771 if (size > 0) { 1772 if (str < end) 1773 *str = '\0'; 1774 else 1775 end[-1] = '\0'; 1776 } 1777 1778 /* the trailing null byte doesn't count towards the total */ 1779 return str-buf; 1780 1781 } 1782 EXPORT_SYMBOL(vsnprintf); 1783 1784 /** 1785 * vscnprintf - Format a string and place it in a buffer 1786 * @buf: The buffer to place the result into 1787 * @size: The size of the buffer, including the trailing null space 1788 * @fmt: The format string to use 1789 * @args: Arguments for the format string 1790 * 1791 * The return value is the number of characters which have been written into 1792 * the @buf not including the trailing '\0'. If @size is == 0 the function 1793 * returns 0. 1794 * 1795 * If you're not already dealing with a va_list consider using scnprintf(). 1796 * 1797 * See the vsnprintf() documentation for format string extensions over C99. 1798 */ 1799 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 1800 { 1801 int i; 1802 1803 i = vsnprintf(buf, size, fmt, args); 1804 1805 if (likely(i < size)) 1806 return i; 1807 if (size != 0) 1808 return size - 1; 1809 return 0; 1810 } 1811 EXPORT_SYMBOL(vscnprintf); 1812 1813 /** 1814 * snprintf - Format a string and place it in a buffer 1815 * @buf: The buffer to place the result into 1816 * @size: The size of the buffer, including the trailing null space 1817 * @fmt: The format string to use 1818 * @...: Arguments for the format string 1819 * 1820 * The return value is the number of characters which would be 1821 * generated for the given input, excluding the trailing null, 1822 * as per ISO C99. If the return is greater than or equal to 1823 * @size, the resulting string is truncated. 1824 * 1825 * See the vsnprintf() documentation for format string extensions over C99. 1826 */ 1827 int snprintf(char *buf, size_t size, const char *fmt, ...) 1828 { 1829 va_list args; 1830 int i; 1831 1832 va_start(args, fmt); 1833 i = vsnprintf(buf, size, fmt, args); 1834 va_end(args); 1835 1836 return i; 1837 } 1838 EXPORT_SYMBOL(snprintf); 1839 1840 /** 1841 * scnprintf - Format a string and place it in a buffer 1842 * @buf: The buffer to place the result into 1843 * @size: The size of the buffer, including the trailing null space 1844 * @fmt: The format string to use 1845 * @...: Arguments for the format string 1846 * 1847 * The return value is the number of characters written into @buf not including 1848 * the trailing '\0'. If @size is == 0 the function returns 0. 1849 */ 1850 1851 int scnprintf(char *buf, size_t size, const char *fmt, ...) 1852 { 1853 va_list args; 1854 int i; 1855 1856 va_start(args, fmt); 1857 i = vscnprintf(buf, size, fmt, args); 1858 va_end(args); 1859 1860 return i; 1861 } 1862 EXPORT_SYMBOL(scnprintf); 1863 1864 /** 1865 * vsprintf - Format a string and place it in a buffer 1866 * @buf: The buffer to place the result into 1867 * @fmt: The format string to use 1868 * @args: Arguments for the format string 1869 * 1870 * The function returns the number of characters written 1871 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 1872 * buffer overflows. 1873 * 1874 * If you're not already dealing with a va_list consider using sprintf(). 1875 * 1876 * See the vsnprintf() documentation for format string extensions over C99. 1877 */ 1878 int vsprintf(char *buf, const char *fmt, va_list args) 1879 { 1880 return vsnprintf(buf, INT_MAX, fmt, args); 1881 } 1882 EXPORT_SYMBOL(vsprintf); 1883 1884 /** 1885 * sprintf - Format a string and place it in a buffer 1886 * @buf: The buffer to place the result into 1887 * @fmt: The format string to use 1888 * @...: Arguments for the format string 1889 * 1890 * The function returns the number of characters written 1891 * into @buf. Use snprintf() or scnprintf() in order to avoid 1892 * buffer overflows. 1893 * 1894 * See the vsnprintf() documentation for format string extensions over C99. 1895 */ 1896 int sprintf(char *buf, const char *fmt, ...) 1897 { 1898 va_list args; 1899 int i; 1900 1901 va_start(args, fmt); 1902 i = vsnprintf(buf, INT_MAX, fmt, args); 1903 va_end(args); 1904 1905 return i; 1906 } 1907 EXPORT_SYMBOL(sprintf); 1908 1909 #ifdef CONFIG_BINARY_PRINTF 1910 /* 1911 * bprintf service: 1912 * vbin_printf() - VA arguments to binary data 1913 * bstr_printf() - Binary data to text string 1914 */ 1915 1916 /** 1917 * vbin_printf - Parse a format string and place args' binary value in a buffer 1918 * @bin_buf: The buffer to place args' binary value 1919 * @size: The size of the buffer(by words(32bits), not characters) 1920 * @fmt: The format string to use 1921 * @args: Arguments for the format string 1922 * 1923 * The format follows C99 vsnprintf, except %n is ignored, and its argument 1924 * is skiped. 1925 * 1926 * The return value is the number of words(32bits) which would be generated for 1927 * the given input. 1928 * 1929 * NOTE: 1930 * If the return value is greater than @size, the resulting bin_buf is NOT 1931 * valid for bstr_printf(). 1932 */ 1933 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 1934 { 1935 struct printf_spec spec = {0}; 1936 char *str, *end; 1937 1938 str = (char *)bin_buf; 1939 end = (char *)(bin_buf + size); 1940 1941 #define save_arg(type) \ 1942 do { \ 1943 if (sizeof(type) == 8) { \ 1944 unsigned long long value; \ 1945 str = PTR_ALIGN(str, sizeof(u32)); \ 1946 value = va_arg(args, unsigned long long); \ 1947 if (str + sizeof(type) <= end) { \ 1948 *(u32 *)str = *(u32 *)&value; \ 1949 *(u32 *)(str + 4) = *((u32 *)&value + 1); \ 1950 } \ 1951 } else { \ 1952 unsigned long value; \ 1953 str = PTR_ALIGN(str, sizeof(type)); \ 1954 value = va_arg(args, int); \ 1955 if (str + sizeof(type) <= end) \ 1956 *(typeof(type) *)str = (type)value; \ 1957 } \ 1958 str += sizeof(type); \ 1959 } while (0) 1960 1961 while (*fmt) { 1962 int read = format_decode(fmt, &spec); 1963 1964 fmt += read; 1965 1966 switch (spec.type) { 1967 case FORMAT_TYPE_NONE: 1968 case FORMAT_TYPE_INVALID: 1969 case FORMAT_TYPE_PERCENT_CHAR: 1970 break; 1971 1972 case FORMAT_TYPE_WIDTH: 1973 case FORMAT_TYPE_PRECISION: 1974 save_arg(int); 1975 break; 1976 1977 case FORMAT_TYPE_CHAR: 1978 save_arg(char); 1979 break; 1980 1981 case FORMAT_TYPE_STR: { 1982 const char *save_str = va_arg(args, char *); 1983 size_t len; 1984 1985 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 1986 || (unsigned long)save_str < PAGE_SIZE) 1987 save_str = "(null)"; 1988 len = strlen(save_str) + 1; 1989 if (str + len < end) 1990 memcpy(str, save_str, len); 1991 str += len; 1992 break; 1993 } 1994 1995 case FORMAT_TYPE_PTR: 1996 save_arg(void *); 1997 /* skip all alphanumeric pointer suffixes */ 1998 while (isalnum(*fmt)) 1999 fmt++; 2000 break; 2001 2002 case FORMAT_TYPE_NRCHARS: { 2003 /* skip %n 's argument */ 2004 u8 qualifier = spec.qualifier; 2005 void *skip_arg; 2006 if (qualifier == 'l') 2007 skip_arg = va_arg(args, long *); 2008 else if (_tolower(qualifier) == 'z') 2009 skip_arg = va_arg(args, size_t *); 2010 else 2011 skip_arg = va_arg(args, int *); 2012 break; 2013 } 2014 2015 default: 2016 switch (spec.type) { 2017 2018 case FORMAT_TYPE_LONG_LONG: 2019 save_arg(long long); 2020 break; 2021 case FORMAT_TYPE_ULONG: 2022 case FORMAT_TYPE_LONG: 2023 save_arg(unsigned long); 2024 break; 2025 case FORMAT_TYPE_SIZE_T: 2026 save_arg(size_t); 2027 break; 2028 case FORMAT_TYPE_PTRDIFF: 2029 save_arg(ptrdiff_t); 2030 break; 2031 case FORMAT_TYPE_UBYTE: 2032 case FORMAT_TYPE_BYTE: 2033 save_arg(char); 2034 break; 2035 case FORMAT_TYPE_USHORT: 2036 case FORMAT_TYPE_SHORT: 2037 save_arg(short); 2038 break; 2039 default: 2040 save_arg(int); 2041 } 2042 } 2043 } 2044 2045 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 2046 #undef save_arg 2047 } 2048 EXPORT_SYMBOL_GPL(vbin_printf); 2049 2050 /** 2051 * bstr_printf - Format a string from binary arguments and place it in a buffer 2052 * @buf: The buffer to place the result into 2053 * @size: The size of the buffer, including the trailing null space 2054 * @fmt: The format string to use 2055 * @bin_buf: Binary arguments for the format string 2056 * 2057 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 2058 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 2059 * a binary buffer that generated by vbin_printf. 2060 * 2061 * The format follows C99 vsnprintf, but has some extensions: 2062 * see vsnprintf comment for details. 2063 * 2064 * The return value is the number of characters which would 2065 * be generated for the given input, excluding the trailing 2066 * '\0', as per ISO C99. If you want to have the exact 2067 * number of characters written into @buf as return value 2068 * (not including the trailing '\0'), use vscnprintf(). If the 2069 * return is greater than or equal to @size, the resulting 2070 * string is truncated. 2071 */ 2072 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 2073 { 2074 struct printf_spec spec = {0}; 2075 char *str, *end; 2076 const char *args = (const char *)bin_buf; 2077 2078 if (WARN_ON_ONCE((int) size < 0)) 2079 return 0; 2080 2081 str = buf; 2082 end = buf + size; 2083 2084 #define get_arg(type) \ 2085 ({ \ 2086 typeof(type) value; \ 2087 if (sizeof(type) == 8) { \ 2088 args = PTR_ALIGN(args, sizeof(u32)); \ 2089 *(u32 *)&value = *(u32 *)args; \ 2090 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 2091 } else { \ 2092 args = PTR_ALIGN(args, sizeof(type)); \ 2093 value = *(typeof(type) *)args; \ 2094 } \ 2095 args += sizeof(type); \ 2096 value; \ 2097 }) 2098 2099 /* Make sure end is always >= buf */ 2100 if (end < buf) { 2101 end = ((void *)-1); 2102 size = end - buf; 2103 } 2104 2105 while (*fmt) { 2106 const char *old_fmt = fmt; 2107 int read = format_decode(fmt, &spec); 2108 2109 fmt += read; 2110 2111 switch (spec.type) { 2112 case FORMAT_TYPE_NONE: { 2113 int copy = read; 2114 if (str < end) { 2115 if (copy > end - str) 2116 copy = end - str; 2117 memcpy(str, old_fmt, copy); 2118 } 2119 str += read; 2120 break; 2121 } 2122 2123 case FORMAT_TYPE_WIDTH: 2124 spec.field_width = get_arg(int); 2125 break; 2126 2127 case FORMAT_TYPE_PRECISION: 2128 spec.precision = get_arg(int); 2129 break; 2130 2131 case FORMAT_TYPE_CHAR: { 2132 char c; 2133 2134 if (!(spec.flags & LEFT)) { 2135 while (--spec.field_width > 0) { 2136 if (str < end) 2137 *str = ' '; 2138 ++str; 2139 } 2140 } 2141 c = (unsigned char) get_arg(char); 2142 if (str < end) 2143 *str = c; 2144 ++str; 2145 while (--spec.field_width > 0) { 2146 if (str < end) 2147 *str = ' '; 2148 ++str; 2149 } 2150 break; 2151 } 2152 2153 case FORMAT_TYPE_STR: { 2154 const char *str_arg = args; 2155 args += strlen(str_arg) + 1; 2156 str = string(str, end, (char *)str_arg, spec); 2157 break; 2158 } 2159 2160 case FORMAT_TYPE_PTR: 2161 str = pointer(fmt+1, str, end, get_arg(void *), spec); 2162 while (isalnum(*fmt)) 2163 fmt++; 2164 break; 2165 2166 case FORMAT_TYPE_PERCENT_CHAR: 2167 case FORMAT_TYPE_INVALID: 2168 if (str < end) 2169 *str = '%'; 2170 ++str; 2171 break; 2172 2173 case FORMAT_TYPE_NRCHARS: 2174 /* skip */ 2175 break; 2176 2177 default: { 2178 unsigned long long num; 2179 2180 switch (spec.type) { 2181 2182 case FORMAT_TYPE_LONG_LONG: 2183 num = get_arg(long long); 2184 break; 2185 case FORMAT_TYPE_ULONG: 2186 case FORMAT_TYPE_LONG: 2187 num = get_arg(unsigned long); 2188 break; 2189 case FORMAT_TYPE_SIZE_T: 2190 num = get_arg(size_t); 2191 break; 2192 case FORMAT_TYPE_PTRDIFF: 2193 num = get_arg(ptrdiff_t); 2194 break; 2195 case FORMAT_TYPE_UBYTE: 2196 num = get_arg(unsigned char); 2197 break; 2198 case FORMAT_TYPE_BYTE: 2199 num = get_arg(signed char); 2200 break; 2201 case FORMAT_TYPE_USHORT: 2202 num = get_arg(unsigned short); 2203 break; 2204 case FORMAT_TYPE_SHORT: 2205 num = get_arg(short); 2206 break; 2207 case FORMAT_TYPE_UINT: 2208 num = get_arg(unsigned int); 2209 break; 2210 default: 2211 num = get_arg(int); 2212 } 2213 2214 str = number(str, end, num, spec); 2215 } /* default: */ 2216 } /* switch(spec.type) */ 2217 } /* while(*fmt) */ 2218 2219 if (size > 0) { 2220 if (str < end) 2221 *str = '\0'; 2222 else 2223 end[-1] = '\0'; 2224 } 2225 2226 #undef get_arg 2227 2228 /* the trailing null byte doesn't count towards the total */ 2229 return str - buf; 2230 } 2231 EXPORT_SYMBOL_GPL(bstr_printf); 2232 2233 /** 2234 * bprintf - Parse a format string and place args' binary value in a buffer 2235 * @bin_buf: The buffer to place args' binary value 2236 * @size: The size of the buffer(by words(32bits), not characters) 2237 * @fmt: The format string to use 2238 * @...: Arguments for the format string 2239 * 2240 * The function returns the number of words(u32) written 2241 * into @bin_buf. 2242 */ 2243 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 2244 { 2245 va_list args; 2246 int ret; 2247 2248 va_start(args, fmt); 2249 ret = vbin_printf(bin_buf, size, fmt, args); 2250 va_end(args); 2251 2252 return ret; 2253 } 2254 EXPORT_SYMBOL_GPL(bprintf); 2255 2256 #endif /* CONFIG_BINARY_PRINTF */ 2257 2258 /** 2259 * vsscanf - Unformat a buffer into a list of arguments 2260 * @buf: input buffer 2261 * @fmt: format of buffer 2262 * @args: arguments 2263 */ 2264 int vsscanf(const char *buf, const char *fmt, va_list args) 2265 { 2266 const char *str = buf; 2267 char *next; 2268 char digit; 2269 int num = 0; 2270 u8 qualifier; 2271 unsigned int base; 2272 union { 2273 long long s; 2274 unsigned long long u; 2275 } val; 2276 s16 field_width; 2277 bool is_sign; 2278 2279 while (*fmt) { 2280 /* skip any white space in format */ 2281 /* white space in format matchs any amount of 2282 * white space, including none, in the input. 2283 */ 2284 if (isspace(*fmt)) { 2285 fmt = skip_spaces(++fmt); 2286 str = skip_spaces(str); 2287 } 2288 2289 /* anything that is not a conversion must match exactly */ 2290 if (*fmt != '%' && *fmt) { 2291 if (*fmt++ != *str++) 2292 break; 2293 continue; 2294 } 2295 2296 if (!*fmt) 2297 break; 2298 ++fmt; 2299 2300 /* skip this conversion. 2301 * advance both strings to next white space 2302 */ 2303 if (*fmt == '*') { 2304 if (!*str) 2305 break; 2306 while (!isspace(*fmt) && *fmt != '%' && *fmt) 2307 fmt++; 2308 while (!isspace(*str) && *str) 2309 str++; 2310 continue; 2311 } 2312 2313 /* get field width */ 2314 field_width = -1; 2315 if (isdigit(*fmt)) { 2316 field_width = skip_atoi(&fmt); 2317 if (field_width <= 0) 2318 break; 2319 } 2320 2321 /* get conversion qualifier */ 2322 qualifier = -1; 2323 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2324 _tolower(*fmt) == 'z') { 2325 qualifier = *fmt++; 2326 if (unlikely(qualifier == *fmt)) { 2327 if (qualifier == 'h') { 2328 qualifier = 'H'; 2329 fmt++; 2330 } else if (qualifier == 'l') { 2331 qualifier = 'L'; 2332 fmt++; 2333 } 2334 } 2335 } 2336 2337 if (!*fmt) 2338 break; 2339 2340 if (*fmt == 'n') { 2341 /* return number of characters read so far */ 2342 *va_arg(args, int *) = str - buf; 2343 ++fmt; 2344 continue; 2345 } 2346 2347 if (!*str) 2348 break; 2349 2350 base = 10; 2351 is_sign = 0; 2352 2353 switch (*fmt++) { 2354 case 'c': 2355 { 2356 char *s = (char *)va_arg(args, char*); 2357 if (field_width == -1) 2358 field_width = 1; 2359 do { 2360 *s++ = *str++; 2361 } while (--field_width > 0 && *str); 2362 num++; 2363 } 2364 continue; 2365 case 's': 2366 { 2367 char *s = (char *)va_arg(args, char *); 2368 if (field_width == -1) 2369 field_width = SHRT_MAX; 2370 /* first, skip leading white space in buffer */ 2371 str = skip_spaces(str); 2372 2373 /* now copy until next white space */ 2374 while (*str && !isspace(*str) && field_width--) 2375 *s++ = *str++; 2376 *s = '\0'; 2377 num++; 2378 } 2379 continue; 2380 case 'o': 2381 base = 8; 2382 break; 2383 case 'x': 2384 case 'X': 2385 base = 16; 2386 break; 2387 case 'i': 2388 base = 0; 2389 case 'd': 2390 is_sign = 1; 2391 case 'u': 2392 break; 2393 case '%': 2394 /* looking for '%' in str */ 2395 if (*str++ != '%') 2396 return num; 2397 continue; 2398 default: 2399 /* invalid format; stop here */ 2400 return num; 2401 } 2402 2403 /* have some sort of integer conversion. 2404 * first, skip white space in buffer. 2405 */ 2406 str = skip_spaces(str); 2407 2408 digit = *str; 2409 if (is_sign && digit == '-') 2410 digit = *(str + 1); 2411 2412 if (!digit 2413 || (base == 16 && !isxdigit(digit)) 2414 || (base == 10 && !isdigit(digit)) 2415 || (base == 8 && (!isdigit(digit) || digit > '7')) 2416 || (base == 0 && !isdigit(digit))) 2417 break; 2418 2419 if (is_sign) 2420 val.s = qualifier != 'L' ? 2421 simple_strtol(str, &next, base) : 2422 simple_strtoll(str, &next, base); 2423 else 2424 val.u = qualifier != 'L' ? 2425 simple_strtoul(str, &next, base) : 2426 simple_strtoull(str, &next, base); 2427 2428 if (field_width > 0 && next - str > field_width) { 2429 if (base == 0) 2430 _parse_integer_fixup_radix(str, &base); 2431 while (next - str > field_width) { 2432 if (is_sign) 2433 val.s = div_s64(val.s, base); 2434 else 2435 val.u = div_u64(val.u, base); 2436 --next; 2437 } 2438 } 2439 2440 switch (qualifier) { 2441 case 'H': /* that's 'hh' in format */ 2442 if (is_sign) 2443 *va_arg(args, signed char *) = val.s; 2444 else 2445 *va_arg(args, unsigned char *) = val.u; 2446 break; 2447 case 'h': 2448 if (is_sign) 2449 *va_arg(args, short *) = val.s; 2450 else 2451 *va_arg(args, unsigned short *) = val.u; 2452 break; 2453 case 'l': 2454 if (is_sign) 2455 *va_arg(args, long *) = val.s; 2456 else 2457 *va_arg(args, unsigned long *) = val.u; 2458 break; 2459 case 'L': 2460 if (is_sign) 2461 *va_arg(args, long long *) = val.s; 2462 else 2463 *va_arg(args, unsigned long long *) = val.u; 2464 break; 2465 case 'Z': 2466 case 'z': 2467 *va_arg(args, size_t *) = val.u; 2468 break; 2469 default: 2470 if (is_sign) 2471 *va_arg(args, int *) = val.s; 2472 else 2473 *va_arg(args, unsigned int *) = val.u; 2474 break; 2475 } 2476 num++; 2477 2478 if (!next) 2479 break; 2480 str = next; 2481 } 2482 2483 return num; 2484 } 2485 EXPORT_SYMBOL(vsscanf); 2486 2487 /** 2488 * sscanf - Unformat a buffer into a list of arguments 2489 * @buf: input buffer 2490 * @fmt: formatting of buffer 2491 * @...: resulting arguments 2492 */ 2493 int sscanf(const char *buf, const char *fmt, ...) 2494 { 2495 va_list args; 2496 int i; 2497 2498 va_start(args, fmt); 2499 i = vsscanf(buf, fmt, args); 2500 va_end(args); 2501 2502 return i; 2503 } 2504 EXPORT_SYMBOL(sscanf); 2505