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