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> 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/uaccess.h> 27 #include <linux/ioport.h> 28 #include <net/addrconf.h> 29 30 #include <asm/page.h> /* for PAGE_SIZE */ 31 #include <asm/div64.h> 32 #include <asm/sections.h> /* for dereference_function_descriptor() */ 33 34 /* Works only for digits and letters, but small and fast */ 35 #define TOLOWER(x) ((x) | 0x20) 36 37 static unsigned int simple_guess_base(const char *cp) 38 { 39 if (cp[0] == '0') { 40 if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2])) 41 return 16; 42 else 43 return 8; 44 } else { 45 return 10; 46 } 47 } 48 49 /** 50 * simple_strtoull - convert a string to an unsigned long long 51 * @cp: The start of the string 52 * @endp: A pointer to the end of the parsed string will be placed here 53 * @base: The number base to use 54 */ 55 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base) 56 { 57 unsigned long long result = 0; 58 59 if (!base) 60 base = simple_guess_base(cp); 61 62 if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x') 63 cp += 2; 64 65 while (isxdigit(*cp)) { 66 unsigned int value; 67 68 value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10; 69 if (value >= base) 70 break; 71 result = result * base + value; 72 cp++; 73 } 74 if (endp) 75 *endp = (char *)cp; 76 77 return result; 78 } 79 EXPORT_SYMBOL(simple_strtoull); 80 81 /** 82 * simple_strtoul - convert a string to an unsigned long 83 * @cp: The start of the string 84 * @endp: A pointer to the end of the parsed string will be placed here 85 * @base: The number base to use 86 */ 87 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base) 88 { 89 return simple_strtoull(cp, endp, base); 90 } 91 EXPORT_SYMBOL(simple_strtoul); 92 93 /** 94 * simple_strtol - convert a string to a signed 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 long simple_strtol(const char *cp, char **endp, unsigned int base) 100 { 101 if (*cp == '-') 102 return -simple_strtoul(cp + 1, endp, base); 103 104 return simple_strtoul(cp, endp, base); 105 } 106 EXPORT_SYMBOL(simple_strtol); 107 108 /** 109 * simple_strtoll - convert a string to a signed long long 110 * @cp: The start of the string 111 * @endp: A pointer to the end of the parsed string will be placed here 112 * @base: The number base to use 113 */ 114 long long simple_strtoll(const char *cp, char **endp, unsigned int base) 115 { 116 if (*cp == '-') 117 return -simple_strtoull(cp + 1, endp, base); 118 119 return simple_strtoull(cp, endp, base); 120 } 121 EXPORT_SYMBOL(simple_strtoll); 122 123 /** 124 * strict_strtoul - convert a string to an unsigned long strictly 125 * @cp: The string to be converted 126 * @base: The number base to use 127 * @res: The converted result value 128 * 129 * strict_strtoul converts a string to an unsigned long only if the 130 * string is really an unsigned long string, any string containing 131 * any invalid char at the tail will be rejected and -EINVAL is returned, 132 * only a newline char at the tail is acceptible because people generally 133 * change a module parameter in the following way: 134 * 135 * echo 1024 > /sys/module/e1000/parameters/copybreak 136 * 137 * echo will append a newline to the tail. 138 * 139 * It returns 0 if conversion is successful and *res is set to the converted 140 * value, otherwise it returns -EINVAL and *res is set to 0. 141 * 142 * simple_strtoul just ignores the successive invalid characters and 143 * return the converted value of prefix part of the string. 144 */ 145 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res) 146 { 147 char *tail; 148 unsigned long val; 149 size_t len; 150 151 *res = 0; 152 len = strlen(cp); 153 if (len == 0) 154 return -EINVAL; 155 156 val = simple_strtoul(cp, &tail, base); 157 if (tail == cp) 158 return -EINVAL; 159 160 if ((*tail == '\0') || 161 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 162 *res = val; 163 return 0; 164 } 165 166 return -EINVAL; 167 } 168 EXPORT_SYMBOL(strict_strtoul); 169 170 /** 171 * strict_strtol - convert a string to a long strictly 172 * @cp: The string to be converted 173 * @base: The number base to use 174 * @res: The converted result value 175 * 176 * strict_strtol is similiar to strict_strtoul, but it allows the first 177 * character of a string is '-'. 178 * 179 * It returns 0 if conversion is successful and *res is set to the converted 180 * value, otherwise it returns -EINVAL and *res is set to 0. 181 */ 182 int strict_strtol(const char *cp, unsigned int base, long *res) 183 { 184 int ret; 185 if (*cp == '-') { 186 ret = strict_strtoul(cp + 1, base, (unsigned long *)res); 187 if (!ret) 188 *res = -(*res); 189 } else { 190 ret = strict_strtoul(cp, base, (unsigned long *)res); 191 } 192 193 return ret; 194 } 195 EXPORT_SYMBOL(strict_strtol); 196 197 /** 198 * strict_strtoull - convert a string to an unsigned long long strictly 199 * @cp: The string to be converted 200 * @base: The number base to use 201 * @res: The converted result value 202 * 203 * strict_strtoull converts a string to an unsigned long long only if the 204 * string is really an unsigned long long string, any string containing 205 * any invalid char at the tail will be rejected and -EINVAL is returned, 206 * only a newline char at the tail is acceptible because people generally 207 * change a module parameter in the following way: 208 * 209 * echo 1024 > /sys/module/e1000/parameters/copybreak 210 * 211 * echo will append a newline to the tail of the string. 212 * 213 * It returns 0 if conversion is successful and *res is set to the converted 214 * value, otherwise it returns -EINVAL and *res is set to 0. 215 * 216 * simple_strtoull just ignores the successive invalid characters and 217 * return the converted value of prefix part of the string. 218 */ 219 int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res) 220 { 221 char *tail; 222 unsigned long long val; 223 size_t len; 224 225 *res = 0; 226 len = strlen(cp); 227 if (len == 0) 228 return -EINVAL; 229 230 val = simple_strtoull(cp, &tail, base); 231 if (tail == cp) 232 return -EINVAL; 233 if ((*tail == '\0') || 234 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 235 *res = val; 236 return 0; 237 } 238 239 return -EINVAL; 240 } 241 EXPORT_SYMBOL(strict_strtoull); 242 243 /** 244 * strict_strtoll - convert a string to a long long strictly 245 * @cp: The string to be converted 246 * @base: The number base to use 247 * @res: The converted result value 248 * 249 * strict_strtoll is similiar to strict_strtoull, but it allows the first 250 * character of a string is '-'. 251 * 252 * It returns 0 if conversion is successful and *res is set to the converted 253 * value, otherwise it returns -EINVAL and *res is set to 0. 254 */ 255 int strict_strtoll(const char *cp, unsigned int base, long long *res) 256 { 257 int ret; 258 if (*cp == '-') { 259 ret = strict_strtoull(cp + 1, base, (unsigned long long *)res); 260 if (!ret) 261 *res = -(*res); 262 } else { 263 ret = strict_strtoull(cp, base, (unsigned long long *)res); 264 } 265 266 return ret; 267 } 268 EXPORT_SYMBOL(strict_strtoll); 269 270 static int skip_atoi(const char **s) 271 { 272 int i = 0; 273 274 while (isdigit(**s)) 275 i = i*10 + *((*s)++) - '0'; 276 277 return i; 278 } 279 280 /* Decimal conversion is by far the most typical, and is used 281 * for /proc and /sys data. This directly impacts e.g. top performance 282 * with many processes running. We optimize it for speed 283 * using code from 284 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html 285 * (with permission from the author, Douglas W. Jones). */ 286 287 /* Formats correctly any integer in [0,99999]. 288 * Outputs from one to five digits depending on input. 289 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */ 290 static char *put_dec_trunc(char *buf, unsigned q) 291 { 292 unsigned d3, d2, d1, d0; 293 d1 = (q>>4) & 0xf; 294 d2 = (q>>8) & 0xf; 295 d3 = (q>>12); 296 297 d0 = 6*(d3 + d2 + d1) + (q & 0xf); 298 q = (d0 * 0xcd) >> 11; 299 d0 = d0 - 10*q; 300 *buf++ = d0 + '0'; /* least significant digit */ 301 d1 = q + 9*d3 + 5*d2 + d1; 302 if (d1 != 0) { 303 q = (d1 * 0xcd) >> 11; 304 d1 = d1 - 10*q; 305 *buf++ = d1 + '0'; /* next digit */ 306 307 d2 = q + 2*d2; 308 if ((d2 != 0) || (d3 != 0)) { 309 q = (d2 * 0xd) >> 7; 310 d2 = d2 - 10*q; 311 *buf++ = d2 + '0'; /* next digit */ 312 313 d3 = q + 4*d3; 314 if (d3 != 0) { 315 q = (d3 * 0xcd) >> 11; 316 d3 = d3 - 10*q; 317 *buf++ = d3 + '0'; /* next digit */ 318 if (q != 0) 319 *buf++ = q + '0'; /* most sign. digit */ 320 } 321 } 322 } 323 324 return buf; 325 } 326 /* Same with if's removed. Always emits five digits */ 327 static char *put_dec_full(char *buf, unsigned q) 328 { 329 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */ 330 /* but anyway, gcc produces better code with full-sized ints */ 331 unsigned d3, d2, d1, d0; 332 d1 = (q>>4) & 0xf; 333 d2 = (q>>8) & 0xf; 334 d3 = (q>>12); 335 336 /* 337 * Possible ways to approx. divide by 10 338 * gcc -O2 replaces multiply with shifts and adds 339 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386) 340 * (x * 0x67) >> 10: 1100111 341 * (x * 0x34) >> 9: 110100 - same 342 * (x * 0x1a) >> 8: 11010 - same 343 * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386) 344 */ 345 d0 = 6*(d3 + d2 + d1) + (q & 0xf); 346 q = (d0 * 0xcd) >> 11; 347 d0 = d0 - 10*q; 348 *buf++ = d0 + '0'; 349 d1 = q + 9*d3 + 5*d2 + d1; 350 q = (d1 * 0xcd) >> 11; 351 d1 = d1 - 10*q; 352 *buf++ = d1 + '0'; 353 354 d2 = q + 2*d2; 355 q = (d2 * 0xd) >> 7; 356 d2 = d2 - 10*q; 357 *buf++ = d2 + '0'; 358 359 d3 = q + 4*d3; 360 q = (d3 * 0xcd) >> 11; /* - shorter code */ 361 /* q = (d3 * 0x67) >> 10; - would also work */ 362 d3 = d3 - 10*q; 363 *buf++ = d3 + '0'; 364 *buf++ = q + '0'; 365 366 return buf; 367 } 368 /* No inlining helps gcc to use registers better */ 369 static noinline char *put_dec(char *buf, unsigned long long num) 370 { 371 while (1) { 372 unsigned rem; 373 if (num < 100000) 374 return put_dec_trunc(buf, num); 375 rem = do_div(num, 100000); 376 buf = put_dec_full(buf, rem); 377 } 378 } 379 380 #define ZEROPAD 1 /* pad with zero */ 381 #define SIGN 2 /* unsigned/signed long */ 382 #define PLUS 4 /* show plus */ 383 #define SPACE 8 /* space if plus */ 384 #define LEFT 16 /* left justified */ 385 #define SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */ 386 #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */ 387 388 enum format_type { 389 FORMAT_TYPE_NONE, /* Just a string part */ 390 FORMAT_TYPE_WIDTH, 391 FORMAT_TYPE_PRECISION, 392 FORMAT_TYPE_CHAR, 393 FORMAT_TYPE_STR, 394 FORMAT_TYPE_PTR, 395 FORMAT_TYPE_PERCENT_CHAR, 396 FORMAT_TYPE_INVALID, 397 FORMAT_TYPE_LONG_LONG, 398 FORMAT_TYPE_ULONG, 399 FORMAT_TYPE_LONG, 400 FORMAT_TYPE_UBYTE, 401 FORMAT_TYPE_BYTE, 402 FORMAT_TYPE_USHORT, 403 FORMAT_TYPE_SHORT, 404 FORMAT_TYPE_UINT, 405 FORMAT_TYPE_INT, 406 FORMAT_TYPE_NRCHARS, 407 FORMAT_TYPE_SIZE_T, 408 FORMAT_TYPE_PTRDIFF 409 }; 410 411 struct printf_spec { 412 u8 type; /* format_type enum */ 413 u8 flags; /* flags to number() */ 414 u8 base; /* number base, 8, 10 or 16 only */ 415 u8 qualifier; /* number qualifier, one of 'hHlLtzZ' */ 416 s16 field_width; /* width of output field */ 417 s16 precision; /* # of digits/chars */ 418 }; 419 420 static char *number(char *buf, char *end, unsigned long long num, 421 struct printf_spec spec) 422 { 423 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ 424 static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ 425 426 char tmp[66]; 427 char sign; 428 char locase; 429 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10); 430 int i; 431 432 /* locase = 0 or 0x20. ORing digits or letters with 'locase' 433 * produces same digits or (maybe lowercased) letters */ 434 locase = (spec.flags & SMALL); 435 if (spec.flags & LEFT) 436 spec.flags &= ~ZEROPAD; 437 sign = 0; 438 if (spec.flags & SIGN) { 439 if ((signed long long)num < 0) { 440 sign = '-'; 441 num = -(signed long long)num; 442 spec.field_width--; 443 } else if (spec.flags & PLUS) { 444 sign = '+'; 445 spec.field_width--; 446 } else if (spec.flags & SPACE) { 447 sign = ' '; 448 spec.field_width--; 449 } 450 } 451 if (need_pfx) { 452 spec.field_width--; 453 if (spec.base == 16) 454 spec.field_width--; 455 } 456 457 /* generate full string in tmp[], in reverse order */ 458 i = 0; 459 if (num == 0) 460 tmp[i++] = '0'; 461 /* Generic code, for any base: 462 else do { 463 tmp[i++] = (digits[do_div(num,base)] | locase); 464 } while (num != 0); 465 */ 466 else if (spec.base != 10) { /* 8 or 16 */ 467 int mask = spec.base - 1; 468 int shift = 3; 469 470 if (spec.base == 16) 471 shift = 4; 472 do { 473 tmp[i++] = (digits[((unsigned char)num) & mask] | locase); 474 num >>= shift; 475 } while (num); 476 } else { /* base 10 */ 477 i = put_dec(tmp, num) - tmp; 478 } 479 480 /* printing 100 using %2d gives "100", not "00" */ 481 if (i > spec.precision) 482 spec.precision = i; 483 /* leading space padding */ 484 spec.field_width -= spec.precision; 485 if (!(spec.flags & (ZEROPAD+LEFT))) { 486 while (--spec.field_width >= 0) { 487 if (buf < end) 488 *buf = ' '; 489 ++buf; 490 } 491 } 492 /* sign */ 493 if (sign) { 494 if (buf < end) 495 *buf = sign; 496 ++buf; 497 } 498 /* "0x" / "0" prefix */ 499 if (need_pfx) { 500 if (buf < end) 501 *buf = '0'; 502 ++buf; 503 if (spec.base == 16) { 504 if (buf < end) 505 *buf = ('X' | locase); 506 ++buf; 507 } 508 } 509 /* zero or space padding */ 510 if (!(spec.flags & LEFT)) { 511 char c = (spec.flags & ZEROPAD) ? '0' : ' '; 512 while (--spec.field_width >= 0) { 513 if (buf < end) 514 *buf = c; 515 ++buf; 516 } 517 } 518 /* hmm even more zero padding? */ 519 while (i <= --spec.precision) { 520 if (buf < end) 521 *buf = '0'; 522 ++buf; 523 } 524 /* actual digits of result */ 525 while (--i >= 0) { 526 if (buf < end) 527 *buf = tmp[i]; 528 ++buf; 529 } 530 /* trailing space padding */ 531 while (--spec.field_width >= 0) { 532 if (buf < end) 533 *buf = ' '; 534 ++buf; 535 } 536 537 return buf; 538 } 539 540 static char *string(char *buf, char *end, const char *s, struct printf_spec spec) 541 { 542 int len, i; 543 544 if ((unsigned long)s < PAGE_SIZE) 545 s = "(null)"; 546 547 len = strnlen(s, spec.precision); 548 549 if (!(spec.flags & LEFT)) { 550 while (len < spec.field_width--) { 551 if (buf < end) 552 *buf = ' '; 553 ++buf; 554 } 555 } 556 for (i = 0; i < len; ++i) { 557 if (buf < end) 558 *buf = *s; 559 ++buf; ++s; 560 } 561 while (len < spec.field_width--) { 562 if (buf < end) 563 *buf = ' '; 564 ++buf; 565 } 566 567 return buf; 568 } 569 570 static char *symbol_string(char *buf, char *end, void *ptr, 571 struct printf_spec spec, char ext) 572 { 573 unsigned long value = (unsigned long) ptr; 574 #ifdef CONFIG_KALLSYMS 575 char sym[KSYM_SYMBOL_LEN]; 576 if (ext != 'f' && ext != 's') 577 sprint_symbol(sym, value); 578 else 579 kallsyms_lookup(value, NULL, NULL, NULL, sym); 580 581 return string(buf, end, sym, spec); 582 #else 583 spec.field_width = 2 * sizeof(void *); 584 spec.flags |= SPECIAL | SMALL | ZEROPAD; 585 spec.base = 16; 586 587 return number(buf, end, value, spec); 588 #endif 589 } 590 591 static char *resource_string(char *buf, char *end, struct resource *res, 592 struct printf_spec spec, const char *fmt) 593 { 594 #ifndef IO_RSRC_PRINTK_SIZE 595 #define IO_RSRC_PRINTK_SIZE 6 596 #endif 597 598 #ifndef MEM_RSRC_PRINTK_SIZE 599 #define MEM_RSRC_PRINTK_SIZE 10 600 #endif 601 static const struct printf_spec io_spec = { 602 .base = 16, 603 .field_width = IO_RSRC_PRINTK_SIZE, 604 .precision = -1, 605 .flags = SPECIAL | SMALL | ZEROPAD, 606 }; 607 static const struct printf_spec mem_spec = { 608 .base = 16, 609 .field_width = MEM_RSRC_PRINTK_SIZE, 610 .precision = -1, 611 .flags = SPECIAL | SMALL | ZEROPAD, 612 }; 613 static const struct printf_spec bus_spec = { 614 .base = 16, 615 .field_width = 2, 616 .precision = -1, 617 .flags = SMALL | ZEROPAD, 618 }; 619 static const struct printf_spec dec_spec = { 620 .base = 10, 621 .precision = -1, 622 .flags = 0, 623 }; 624 static const struct printf_spec str_spec = { 625 .field_width = -1, 626 .precision = 10, 627 .flags = LEFT, 628 }; 629 static const struct printf_spec flag_spec = { 630 .base = 16, 631 .precision = -1, 632 .flags = SPECIAL | SMALL, 633 }; 634 635 /* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8) 636 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */ 637 #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4) 638 #define FLAG_BUF_SIZE (2 * sizeof(res->flags)) 639 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]") 640 #define RAW_BUF_SIZE sizeof("[mem - flags 0x]") 641 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE, 642 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)]; 643 644 char *p = sym, *pend = sym + sizeof(sym); 645 int decode = (fmt[0] == 'R') ? 1 : 0; 646 const struct printf_spec *specp; 647 648 *p++ = '['; 649 if (res->flags & IORESOURCE_IO) { 650 p = string(p, pend, "io ", str_spec); 651 specp = &io_spec; 652 } else if (res->flags & IORESOURCE_MEM) { 653 p = string(p, pend, "mem ", str_spec); 654 specp = &mem_spec; 655 } else if (res->flags & IORESOURCE_IRQ) { 656 p = string(p, pend, "irq ", str_spec); 657 specp = &dec_spec; 658 } else if (res->flags & IORESOURCE_DMA) { 659 p = string(p, pend, "dma ", str_spec); 660 specp = &dec_spec; 661 } else if (res->flags & IORESOURCE_BUS) { 662 p = string(p, pend, "bus ", str_spec); 663 specp = &bus_spec; 664 } else { 665 p = string(p, pend, "??? ", str_spec); 666 specp = &mem_spec; 667 decode = 0; 668 } 669 p = number(p, pend, res->start, *specp); 670 if (res->start != res->end) { 671 *p++ = '-'; 672 p = number(p, pend, res->end, *specp); 673 } 674 if (decode) { 675 if (res->flags & IORESOURCE_MEM_64) 676 p = string(p, pend, " 64bit", str_spec); 677 if (res->flags & IORESOURCE_PREFETCH) 678 p = string(p, pend, " pref", str_spec); 679 if (res->flags & IORESOURCE_WINDOW) 680 p = string(p, pend, " window", str_spec); 681 if (res->flags & IORESOURCE_DISABLED) 682 p = string(p, pend, " disabled", str_spec); 683 } else { 684 p = string(p, pend, " flags ", str_spec); 685 p = number(p, pend, res->flags, flag_spec); 686 } 687 *p++ = ']'; 688 *p = '\0'; 689 690 return string(buf, end, sym, spec); 691 } 692 693 static char *mac_address_string(char *buf, char *end, u8 *addr, 694 struct printf_spec spec, const char *fmt) 695 { 696 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")]; 697 char *p = mac_addr; 698 int i; 699 char separator; 700 701 if (fmt[1] == 'F') { /* FDDI canonical format */ 702 separator = '-'; 703 } else { 704 separator = ':'; 705 } 706 707 for (i = 0; i < 6; i++) { 708 p = pack_hex_byte(p, addr[i]); 709 if (fmt[0] == 'M' && i != 5) 710 *p++ = separator; 711 } 712 *p = '\0'; 713 714 return string(buf, end, mac_addr, spec); 715 } 716 717 static char *ip4_string(char *p, const u8 *addr, const char *fmt) 718 { 719 int i; 720 bool leading_zeros = (fmt[0] == 'i'); 721 int index; 722 int step; 723 724 switch (fmt[2]) { 725 case 'h': 726 #ifdef __BIG_ENDIAN 727 index = 0; 728 step = 1; 729 #else 730 index = 3; 731 step = -1; 732 #endif 733 break; 734 case 'l': 735 index = 3; 736 step = -1; 737 break; 738 case 'n': 739 case 'b': 740 default: 741 index = 0; 742 step = 1; 743 break; 744 } 745 for (i = 0; i < 4; i++) { 746 char temp[3]; /* hold each IP quad in reverse order */ 747 int digits = put_dec_trunc(temp, addr[index]) - temp; 748 if (leading_zeros) { 749 if (digits < 3) 750 *p++ = '0'; 751 if (digits < 2) 752 *p++ = '0'; 753 } 754 /* reverse the digits in the quad */ 755 while (digits--) 756 *p++ = temp[digits]; 757 if (i < 3) 758 *p++ = '.'; 759 index += step; 760 } 761 *p = '\0'; 762 763 return p; 764 } 765 766 static char *ip6_compressed_string(char *p, const char *addr) 767 { 768 int i, j, range; 769 unsigned char zerolength[8]; 770 int longest = 1; 771 int colonpos = -1; 772 u16 word; 773 u8 hi, lo; 774 bool needcolon = false; 775 bool useIPv4; 776 struct in6_addr in6; 777 778 memcpy(&in6, addr, sizeof(struct in6_addr)); 779 780 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6); 781 782 memset(zerolength, 0, sizeof(zerolength)); 783 784 if (useIPv4) 785 range = 6; 786 else 787 range = 8; 788 789 /* find position of longest 0 run */ 790 for (i = 0; i < range; i++) { 791 for (j = i; j < range; j++) { 792 if (in6.s6_addr16[j] != 0) 793 break; 794 zerolength[i]++; 795 } 796 } 797 for (i = 0; i < range; i++) { 798 if (zerolength[i] > longest) { 799 longest = zerolength[i]; 800 colonpos = i; 801 } 802 } 803 804 /* emit address */ 805 for (i = 0; i < range; i++) { 806 if (i == colonpos) { 807 if (needcolon || i == 0) 808 *p++ = ':'; 809 *p++ = ':'; 810 needcolon = false; 811 i += longest - 1; 812 continue; 813 } 814 if (needcolon) { 815 *p++ = ':'; 816 needcolon = false; 817 } 818 /* hex u16 without leading 0s */ 819 word = ntohs(in6.s6_addr16[i]); 820 hi = word >> 8; 821 lo = word & 0xff; 822 if (hi) { 823 if (hi > 0x0f) 824 p = pack_hex_byte(p, hi); 825 else 826 *p++ = hex_asc_lo(hi); 827 p = pack_hex_byte(p, lo); 828 } 829 else if (lo > 0x0f) 830 p = pack_hex_byte(p, lo); 831 else 832 *p++ = hex_asc_lo(lo); 833 needcolon = true; 834 } 835 836 if (useIPv4) { 837 if (needcolon) 838 *p++ = ':'; 839 p = ip4_string(p, &in6.s6_addr[12], "I4"); 840 } 841 *p = '\0'; 842 843 return p; 844 } 845 846 static char *ip6_string(char *p, const char *addr, const char *fmt) 847 { 848 int i; 849 850 for (i = 0; i < 8; i++) { 851 p = pack_hex_byte(p, *addr++); 852 p = pack_hex_byte(p, *addr++); 853 if (fmt[0] == 'I' && i != 7) 854 *p++ = ':'; 855 } 856 *p = '\0'; 857 858 return p; 859 } 860 861 static char *ip6_addr_string(char *buf, char *end, const u8 *addr, 862 struct printf_spec spec, const char *fmt) 863 { 864 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 865 866 if (fmt[0] == 'I' && fmt[2] == 'c') 867 ip6_compressed_string(ip6_addr, addr); 868 else 869 ip6_string(ip6_addr, addr, fmt); 870 871 return string(buf, end, ip6_addr, spec); 872 } 873 874 static char *ip4_addr_string(char *buf, char *end, const u8 *addr, 875 struct printf_spec spec, const char *fmt) 876 { 877 char ip4_addr[sizeof("255.255.255.255")]; 878 879 ip4_string(ip4_addr, addr, fmt); 880 881 return string(buf, end, ip4_addr, spec); 882 } 883 884 static char *uuid_string(char *buf, char *end, const u8 *addr, 885 struct printf_spec spec, const char *fmt) 886 { 887 char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")]; 888 char *p = uuid; 889 int i; 890 static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; 891 static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15}; 892 const u8 *index = be; 893 bool uc = false; 894 895 switch (*(++fmt)) { 896 case 'L': 897 uc = true; /* fall-through */ 898 case 'l': 899 index = le; 900 break; 901 case 'B': 902 uc = true; 903 break; 904 } 905 906 for (i = 0; i < 16; i++) { 907 p = pack_hex_byte(p, addr[index[i]]); 908 switch (i) { 909 case 3: 910 case 5: 911 case 7: 912 case 9: 913 *p++ = '-'; 914 break; 915 } 916 } 917 918 *p = 0; 919 920 if (uc) { 921 p = uuid; 922 do { 923 *p = toupper(*p); 924 } while (*(++p)); 925 } 926 927 return string(buf, end, uuid, spec); 928 } 929 930 /* 931 * Show a '%p' thing. A kernel extension is that the '%p' is followed 932 * by an extra set of alphanumeric characters that are extended format 933 * specifiers. 934 * 935 * Right now we handle: 936 * 937 * - 'F' For symbolic function descriptor pointers with offset 938 * - 'f' For simple symbolic function names without offset 939 * - 'S' For symbolic direct pointers with offset 940 * - 's' For symbolic direct pointers without offset 941 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref] 942 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201] 943 * - 'M' For a 6-byte MAC address, it prints the address in the 944 * usual colon-separated hex notation 945 * - 'm' For a 6-byte MAC address, it prints the hex address without colons 946 * - 'MF' For a 6-byte MAC FDDI address, it prints the address 947 * with a dash-separated hex notation 948 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way 949 * IPv4 uses dot-separated decimal without leading 0's (1.2.3.4) 950 * IPv6 uses colon separated network-order 16 bit hex with leading 0's 951 * - 'i' [46] for 'raw' IPv4/IPv6 addresses 952 * IPv6 omits the colons (01020304...0f) 953 * IPv4 uses dot-separated decimal with leading 0's (010.123.045.006) 954 * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order 955 * - 'I6c' for IPv6 addresses printed as specified by 956 * http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00 957 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form 958 * "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 959 * Options for %pU are: 960 * b big endian lower case hex (default) 961 * B big endian UPPER case hex 962 * l little endian lower case hex 963 * L little endian UPPER case hex 964 * big endian output byte order is: 965 * [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15] 966 * little endian output byte order is: 967 * [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15] 968 * 969 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 970 * function pointers are really function descriptors, which contain a 971 * pointer to the real address. 972 */ 973 static char *pointer(const char *fmt, char *buf, char *end, void *ptr, 974 struct printf_spec spec) 975 { 976 if (!ptr) 977 return string(buf, end, "(null)", spec); 978 979 switch (*fmt) { 980 case 'F': 981 case 'f': 982 ptr = dereference_function_descriptor(ptr); 983 /* Fallthrough */ 984 case 'S': 985 case 's': 986 return symbol_string(buf, end, ptr, spec, *fmt); 987 case 'R': 988 case 'r': 989 return resource_string(buf, end, ptr, spec, fmt); 990 case 'M': /* Colon separated: 00:01:02:03:04:05 */ 991 case 'm': /* Contiguous: 000102030405 */ 992 /* [mM]F (FDDI, bit reversed) */ 993 return mac_address_string(buf, end, ptr, spec, fmt); 994 case 'I': /* Formatted IP supported 995 * 4: 1.2.3.4 996 * 6: 0001:0203:...:0708 997 * 6c: 1::708 or 1::1.2.3.4 998 */ 999 case 'i': /* Contiguous: 1000 * 4: 001.002.003.004 1001 * 6: 000102...0f 1002 */ 1003 switch (fmt[1]) { 1004 case '6': 1005 return ip6_addr_string(buf, end, ptr, spec, fmt); 1006 case '4': 1007 return ip4_addr_string(buf, end, ptr, spec, fmt); 1008 } 1009 break; 1010 case 'U': 1011 return uuid_string(buf, end, ptr, spec, fmt); 1012 } 1013 spec.flags |= SMALL; 1014 if (spec.field_width == -1) { 1015 spec.field_width = 2*sizeof(void *); 1016 spec.flags |= ZEROPAD; 1017 } 1018 spec.base = 16; 1019 1020 return number(buf, end, (unsigned long) ptr, spec); 1021 } 1022 1023 /* 1024 * Helper function to decode printf style format. 1025 * Each call decode a token from the format and return the 1026 * number of characters read (or likely the delta where it wants 1027 * to go on the next call). 1028 * The decoded token is returned through the parameters 1029 * 1030 * 'h', 'l', or 'L' for integer fields 1031 * 'z' support added 23/7/1999 S.H. 1032 * 'z' changed to 'Z' --davidm 1/25/99 1033 * 't' added for ptrdiff_t 1034 * 1035 * @fmt: the format string 1036 * @type of the token returned 1037 * @flags: various flags such as +, -, # tokens.. 1038 * @field_width: overwritten width 1039 * @base: base of the number (octal, hex, ...) 1040 * @precision: precision of a number 1041 * @qualifier: qualifier of a number (long, size_t, ...) 1042 */ 1043 static int format_decode(const char *fmt, struct printf_spec *spec) 1044 { 1045 const char *start = fmt; 1046 1047 /* we finished early by reading the field width */ 1048 if (spec->type == FORMAT_TYPE_WIDTH) { 1049 if (spec->field_width < 0) { 1050 spec->field_width = -spec->field_width; 1051 spec->flags |= LEFT; 1052 } 1053 spec->type = FORMAT_TYPE_NONE; 1054 goto precision; 1055 } 1056 1057 /* we finished early by reading the precision */ 1058 if (spec->type == FORMAT_TYPE_PRECISION) { 1059 if (spec->precision < 0) 1060 spec->precision = 0; 1061 1062 spec->type = FORMAT_TYPE_NONE; 1063 goto qualifier; 1064 } 1065 1066 /* By default */ 1067 spec->type = FORMAT_TYPE_NONE; 1068 1069 for (; *fmt ; ++fmt) { 1070 if (*fmt == '%') 1071 break; 1072 } 1073 1074 /* Return the current non-format string */ 1075 if (fmt != start || !*fmt) 1076 return fmt - start; 1077 1078 /* Process flags */ 1079 spec->flags = 0; 1080 1081 while (1) { /* this also skips first '%' */ 1082 bool found = true; 1083 1084 ++fmt; 1085 1086 switch (*fmt) { 1087 case '-': spec->flags |= LEFT; break; 1088 case '+': spec->flags |= PLUS; break; 1089 case ' ': spec->flags |= SPACE; break; 1090 case '#': spec->flags |= SPECIAL; break; 1091 case '0': spec->flags |= ZEROPAD; break; 1092 default: found = false; 1093 } 1094 1095 if (!found) 1096 break; 1097 } 1098 1099 /* get field width */ 1100 spec->field_width = -1; 1101 1102 if (isdigit(*fmt)) 1103 spec->field_width = skip_atoi(&fmt); 1104 else if (*fmt == '*') { 1105 /* it's the next argument */ 1106 spec->type = FORMAT_TYPE_WIDTH; 1107 return ++fmt - start; 1108 } 1109 1110 precision: 1111 /* get the precision */ 1112 spec->precision = -1; 1113 if (*fmt == '.') { 1114 ++fmt; 1115 if (isdigit(*fmt)) { 1116 spec->precision = skip_atoi(&fmt); 1117 if (spec->precision < 0) 1118 spec->precision = 0; 1119 } else if (*fmt == '*') { 1120 /* it's the next argument */ 1121 spec->type = FORMAT_TYPE_PRECISION; 1122 return ++fmt - start; 1123 } 1124 } 1125 1126 qualifier: 1127 /* get the conversion qualifier */ 1128 spec->qualifier = -1; 1129 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' || 1130 TOLOWER(*fmt) == 'z' || *fmt == 't') { 1131 spec->qualifier = *fmt++; 1132 if (unlikely(spec->qualifier == *fmt)) { 1133 if (spec->qualifier == 'l') { 1134 spec->qualifier = 'L'; 1135 ++fmt; 1136 } else if (spec->qualifier == 'h') { 1137 spec->qualifier = 'H'; 1138 ++fmt; 1139 } 1140 } 1141 } 1142 1143 /* default base */ 1144 spec->base = 10; 1145 switch (*fmt) { 1146 case 'c': 1147 spec->type = FORMAT_TYPE_CHAR; 1148 return ++fmt - start; 1149 1150 case 's': 1151 spec->type = FORMAT_TYPE_STR; 1152 return ++fmt - start; 1153 1154 case 'p': 1155 spec->type = FORMAT_TYPE_PTR; 1156 return fmt - start; 1157 /* skip alnum */ 1158 1159 case 'n': 1160 spec->type = FORMAT_TYPE_NRCHARS; 1161 return ++fmt - start; 1162 1163 case '%': 1164 spec->type = FORMAT_TYPE_PERCENT_CHAR; 1165 return ++fmt - start; 1166 1167 /* integer number formats - set up the flags and "break" */ 1168 case 'o': 1169 spec->base = 8; 1170 break; 1171 1172 case 'x': 1173 spec->flags |= SMALL; 1174 1175 case 'X': 1176 spec->base = 16; 1177 break; 1178 1179 case 'd': 1180 case 'i': 1181 spec->flags |= SIGN; 1182 case 'u': 1183 break; 1184 1185 default: 1186 spec->type = FORMAT_TYPE_INVALID; 1187 return fmt - start; 1188 } 1189 1190 if (spec->qualifier == 'L') 1191 spec->type = FORMAT_TYPE_LONG_LONG; 1192 else if (spec->qualifier == 'l') { 1193 if (spec->flags & SIGN) 1194 spec->type = FORMAT_TYPE_LONG; 1195 else 1196 spec->type = FORMAT_TYPE_ULONG; 1197 } else if (TOLOWER(spec->qualifier) == 'z') { 1198 spec->type = FORMAT_TYPE_SIZE_T; 1199 } else if (spec->qualifier == 't') { 1200 spec->type = FORMAT_TYPE_PTRDIFF; 1201 } else if (spec->qualifier == 'H') { 1202 if (spec->flags & SIGN) 1203 spec->type = FORMAT_TYPE_BYTE; 1204 else 1205 spec->type = FORMAT_TYPE_UBYTE; 1206 } else if (spec->qualifier == 'h') { 1207 if (spec->flags & SIGN) 1208 spec->type = FORMAT_TYPE_SHORT; 1209 else 1210 spec->type = FORMAT_TYPE_USHORT; 1211 } else { 1212 if (spec->flags & SIGN) 1213 spec->type = FORMAT_TYPE_INT; 1214 else 1215 spec->type = FORMAT_TYPE_UINT; 1216 } 1217 1218 return ++fmt - start; 1219 } 1220 1221 /** 1222 * vsnprintf - Format a string and place it in a buffer 1223 * @buf: The buffer to place the result into 1224 * @size: The size of the buffer, including the trailing null space 1225 * @fmt: The format string to use 1226 * @args: Arguments for the format string 1227 * 1228 * This function follows C99 vsnprintf, but has some extensions: 1229 * %pS output the name of a text symbol with offset 1230 * %ps output the name of a text symbol without offset 1231 * %pF output the name of a function pointer with its offset 1232 * %pf output the name of a function pointer without its offset 1233 * %pR output the address range in a struct resource with decoded flags 1234 * %pr output the address range in a struct resource with raw flags 1235 * %pM output a 6-byte MAC address with colons 1236 * %pm output a 6-byte MAC address without colons 1237 * %pI4 print an IPv4 address without leading zeros 1238 * %pi4 print an IPv4 address with leading zeros 1239 * %pI6 print an IPv6 address with colons 1240 * %pi6 print an IPv6 address without colons 1241 * %pI6c print an IPv6 address as specified by 1242 * http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00 1243 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper 1244 * case. 1245 * %n is ignored 1246 * 1247 * The return value is the number of characters which would 1248 * be generated for the given input, excluding the trailing 1249 * '\0', as per ISO C99. If you want to have the exact 1250 * number of characters written into @buf as return value 1251 * (not including the trailing '\0'), use vscnprintf(). If the 1252 * return is greater than or equal to @size, the resulting 1253 * string is truncated. 1254 * 1255 * Call this function if you are already dealing with a va_list. 1256 * You probably want snprintf() instead. 1257 */ 1258 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) 1259 { 1260 unsigned long long num; 1261 char *str, *end; 1262 struct printf_spec spec = {0}; 1263 1264 /* Reject out-of-range values early. Large positive sizes are 1265 used for unknown buffer sizes. */ 1266 if (WARN_ON_ONCE((int) size < 0)) 1267 return 0; 1268 1269 str = buf; 1270 end = buf + size; 1271 1272 /* Make sure end is always >= buf */ 1273 if (end < buf) { 1274 end = ((void *)-1); 1275 size = end - buf; 1276 } 1277 1278 while (*fmt) { 1279 const char *old_fmt = fmt; 1280 int read = format_decode(fmt, &spec); 1281 1282 fmt += read; 1283 1284 switch (spec.type) { 1285 case FORMAT_TYPE_NONE: { 1286 int copy = read; 1287 if (str < end) { 1288 if (copy > end - str) 1289 copy = end - str; 1290 memcpy(str, old_fmt, copy); 1291 } 1292 str += read; 1293 break; 1294 } 1295 1296 case FORMAT_TYPE_WIDTH: 1297 spec.field_width = va_arg(args, int); 1298 break; 1299 1300 case FORMAT_TYPE_PRECISION: 1301 spec.precision = va_arg(args, int); 1302 break; 1303 1304 case FORMAT_TYPE_CHAR: { 1305 char c; 1306 1307 if (!(spec.flags & LEFT)) { 1308 while (--spec.field_width > 0) { 1309 if (str < end) 1310 *str = ' '; 1311 ++str; 1312 1313 } 1314 } 1315 c = (unsigned char) va_arg(args, int); 1316 if (str < end) 1317 *str = c; 1318 ++str; 1319 while (--spec.field_width > 0) { 1320 if (str < end) 1321 *str = ' '; 1322 ++str; 1323 } 1324 break; 1325 } 1326 1327 case FORMAT_TYPE_STR: 1328 str = string(str, end, va_arg(args, char *), spec); 1329 break; 1330 1331 case FORMAT_TYPE_PTR: 1332 str = pointer(fmt+1, str, end, va_arg(args, void *), 1333 spec); 1334 while (isalnum(*fmt)) 1335 fmt++; 1336 break; 1337 1338 case FORMAT_TYPE_PERCENT_CHAR: 1339 if (str < end) 1340 *str = '%'; 1341 ++str; 1342 break; 1343 1344 case FORMAT_TYPE_INVALID: 1345 if (str < end) 1346 *str = '%'; 1347 ++str; 1348 break; 1349 1350 case FORMAT_TYPE_NRCHARS: { 1351 u8 qualifier = spec.qualifier; 1352 1353 if (qualifier == 'l') { 1354 long *ip = va_arg(args, long *); 1355 *ip = (str - buf); 1356 } else if (TOLOWER(qualifier) == 'z') { 1357 size_t *ip = va_arg(args, size_t *); 1358 *ip = (str - buf); 1359 } else { 1360 int *ip = va_arg(args, int *); 1361 *ip = (str - buf); 1362 } 1363 break; 1364 } 1365 1366 default: 1367 switch (spec.type) { 1368 case FORMAT_TYPE_LONG_LONG: 1369 num = va_arg(args, long long); 1370 break; 1371 case FORMAT_TYPE_ULONG: 1372 num = va_arg(args, unsigned long); 1373 break; 1374 case FORMAT_TYPE_LONG: 1375 num = va_arg(args, long); 1376 break; 1377 case FORMAT_TYPE_SIZE_T: 1378 num = va_arg(args, size_t); 1379 break; 1380 case FORMAT_TYPE_PTRDIFF: 1381 num = va_arg(args, ptrdiff_t); 1382 break; 1383 case FORMAT_TYPE_UBYTE: 1384 num = (unsigned char) va_arg(args, int); 1385 break; 1386 case FORMAT_TYPE_BYTE: 1387 num = (signed char) va_arg(args, int); 1388 break; 1389 case FORMAT_TYPE_USHORT: 1390 num = (unsigned short) va_arg(args, int); 1391 break; 1392 case FORMAT_TYPE_SHORT: 1393 num = (short) va_arg(args, int); 1394 break; 1395 case FORMAT_TYPE_INT: 1396 num = (int) va_arg(args, int); 1397 break; 1398 default: 1399 num = va_arg(args, unsigned int); 1400 } 1401 1402 str = number(str, end, num, spec); 1403 } 1404 } 1405 1406 if (size > 0) { 1407 if (str < end) 1408 *str = '\0'; 1409 else 1410 end[-1] = '\0'; 1411 } 1412 1413 /* the trailing null byte doesn't count towards the total */ 1414 return str-buf; 1415 1416 } 1417 EXPORT_SYMBOL(vsnprintf); 1418 1419 /** 1420 * vscnprintf - Format a string and place it in a buffer 1421 * @buf: The buffer to place the result into 1422 * @size: The size of the buffer, including the trailing null space 1423 * @fmt: The format string to use 1424 * @args: Arguments for the format string 1425 * 1426 * The return value is the number of characters which have been written into 1427 * the @buf not including the trailing '\0'. If @size is <= 0 the function 1428 * returns 0. 1429 * 1430 * Call this function if you are already dealing with a va_list. 1431 * You probably want scnprintf() instead. 1432 * 1433 * See the vsnprintf() documentation for format string extensions over C99. 1434 */ 1435 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 1436 { 1437 int i; 1438 1439 i = vsnprintf(buf, size, fmt, args); 1440 1441 return (i >= size) ? (size - 1) : i; 1442 } 1443 EXPORT_SYMBOL(vscnprintf); 1444 1445 /** 1446 * snprintf - Format a string and place it in a buffer 1447 * @buf: The buffer to place the result into 1448 * @size: The size of the buffer, including the trailing null space 1449 * @fmt: The format string to use 1450 * @...: Arguments for the format string 1451 * 1452 * The return value is the number of characters which would be 1453 * generated for the given input, excluding the trailing null, 1454 * as per ISO C99. If the return is greater than or equal to 1455 * @size, the resulting string is truncated. 1456 * 1457 * See the vsnprintf() documentation for format string extensions over C99. 1458 */ 1459 int snprintf(char *buf, size_t size, const char *fmt, ...) 1460 { 1461 va_list args; 1462 int i; 1463 1464 va_start(args, fmt); 1465 i = vsnprintf(buf, size, fmt, args); 1466 va_end(args); 1467 1468 return i; 1469 } 1470 EXPORT_SYMBOL(snprintf); 1471 1472 /** 1473 * scnprintf - Format a string and place it in a buffer 1474 * @buf: The buffer to place the result into 1475 * @size: The size of the buffer, including the trailing null space 1476 * @fmt: The format string to use 1477 * @...: Arguments for the format string 1478 * 1479 * The return value is the number of characters written into @buf not including 1480 * the trailing '\0'. If @size is <= 0 the function returns 0. 1481 */ 1482 1483 int scnprintf(char *buf, size_t size, const char *fmt, ...) 1484 { 1485 va_list args; 1486 int i; 1487 1488 va_start(args, fmt); 1489 i = vsnprintf(buf, size, fmt, args); 1490 va_end(args); 1491 1492 return (i >= size) ? (size - 1) : i; 1493 } 1494 EXPORT_SYMBOL(scnprintf); 1495 1496 /** 1497 * vsprintf - Format a string and place it in a buffer 1498 * @buf: The buffer to place the result into 1499 * @fmt: The format string to use 1500 * @args: Arguments for the format string 1501 * 1502 * The function returns the number of characters written 1503 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 1504 * buffer overflows. 1505 * 1506 * Call this function if you are already dealing with a va_list. 1507 * You probably want sprintf() instead. 1508 * 1509 * See the vsnprintf() documentation for format string extensions over C99. 1510 */ 1511 int vsprintf(char *buf, const char *fmt, va_list args) 1512 { 1513 return vsnprintf(buf, INT_MAX, fmt, args); 1514 } 1515 EXPORT_SYMBOL(vsprintf); 1516 1517 /** 1518 * sprintf - Format a string and place it in a buffer 1519 * @buf: The buffer to place the result into 1520 * @fmt: The format string to use 1521 * @...: Arguments for the format string 1522 * 1523 * The function returns the number of characters written 1524 * into @buf. Use snprintf() or scnprintf() in order to avoid 1525 * buffer overflows. 1526 * 1527 * See the vsnprintf() documentation for format string extensions over C99. 1528 */ 1529 int sprintf(char *buf, const char *fmt, ...) 1530 { 1531 va_list args; 1532 int i; 1533 1534 va_start(args, fmt); 1535 i = vsnprintf(buf, INT_MAX, fmt, args); 1536 va_end(args); 1537 1538 return i; 1539 } 1540 EXPORT_SYMBOL(sprintf); 1541 1542 #ifdef CONFIG_BINARY_PRINTF 1543 /* 1544 * bprintf service: 1545 * vbin_printf() - VA arguments to binary data 1546 * bstr_printf() - Binary data to text string 1547 */ 1548 1549 /** 1550 * vbin_printf - Parse a format string and place args' binary value in a buffer 1551 * @bin_buf: The buffer to place args' binary value 1552 * @size: The size of the buffer(by words(32bits), not characters) 1553 * @fmt: The format string to use 1554 * @args: Arguments for the format string 1555 * 1556 * The format follows C99 vsnprintf, except %n is ignored, and its argument 1557 * is skiped. 1558 * 1559 * The return value is the number of words(32bits) which would be generated for 1560 * the given input. 1561 * 1562 * NOTE: 1563 * If the return value is greater than @size, the resulting bin_buf is NOT 1564 * valid for bstr_printf(). 1565 */ 1566 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) 1567 { 1568 struct printf_spec spec = {0}; 1569 char *str, *end; 1570 1571 str = (char *)bin_buf; 1572 end = (char *)(bin_buf + size); 1573 1574 #define save_arg(type) \ 1575 do { \ 1576 if (sizeof(type) == 8) { \ 1577 unsigned long long value; \ 1578 str = PTR_ALIGN(str, sizeof(u32)); \ 1579 value = va_arg(args, unsigned long long); \ 1580 if (str + sizeof(type) <= end) { \ 1581 *(u32 *)str = *(u32 *)&value; \ 1582 *(u32 *)(str + 4) = *((u32 *)&value + 1); \ 1583 } \ 1584 } else { \ 1585 unsigned long value; \ 1586 str = PTR_ALIGN(str, sizeof(type)); \ 1587 value = va_arg(args, int); \ 1588 if (str + sizeof(type) <= end) \ 1589 *(typeof(type) *)str = (type)value; \ 1590 } \ 1591 str += sizeof(type); \ 1592 } while (0) 1593 1594 while (*fmt) { 1595 int read = format_decode(fmt, &spec); 1596 1597 fmt += read; 1598 1599 switch (spec.type) { 1600 case FORMAT_TYPE_NONE: 1601 case FORMAT_TYPE_INVALID: 1602 case FORMAT_TYPE_PERCENT_CHAR: 1603 break; 1604 1605 case FORMAT_TYPE_WIDTH: 1606 case FORMAT_TYPE_PRECISION: 1607 save_arg(int); 1608 break; 1609 1610 case FORMAT_TYPE_CHAR: 1611 save_arg(char); 1612 break; 1613 1614 case FORMAT_TYPE_STR: { 1615 const char *save_str = va_arg(args, char *); 1616 size_t len; 1617 1618 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE 1619 || (unsigned long)save_str < PAGE_SIZE) 1620 save_str = "(null)"; 1621 len = strlen(save_str) + 1; 1622 if (str + len < end) 1623 memcpy(str, save_str, len); 1624 str += len; 1625 break; 1626 } 1627 1628 case FORMAT_TYPE_PTR: 1629 save_arg(void *); 1630 /* skip all alphanumeric pointer suffixes */ 1631 while (isalnum(*fmt)) 1632 fmt++; 1633 break; 1634 1635 case FORMAT_TYPE_NRCHARS: { 1636 /* skip %n 's argument */ 1637 u8 qualifier = spec.qualifier; 1638 void *skip_arg; 1639 if (qualifier == 'l') 1640 skip_arg = va_arg(args, long *); 1641 else if (TOLOWER(qualifier) == 'z') 1642 skip_arg = va_arg(args, size_t *); 1643 else 1644 skip_arg = va_arg(args, int *); 1645 break; 1646 } 1647 1648 default: 1649 switch (spec.type) { 1650 1651 case FORMAT_TYPE_LONG_LONG: 1652 save_arg(long long); 1653 break; 1654 case FORMAT_TYPE_ULONG: 1655 case FORMAT_TYPE_LONG: 1656 save_arg(unsigned long); 1657 break; 1658 case FORMAT_TYPE_SIZE_T: 1659 save_arg(size_t); 1660 break; 1661 case FORMAT_TYPE_PTRDIFF: 1662 save_arg(ptrdiff_t); 1663 break; 1664 case FORMAT_TYPE_UBYTE: 1665 case FORMAT_TYPE_BYTE: 1666 save_arg(char); 1667 break; 1668 case FORMAT_TYPE_USHORT: 1669 case FORMAT_TYPE_SHORT: 1670 save_arg(short); 1671 break; 1672 default: 1673 save_arg(int); 1674 } 1675 } 1676 } 1677 1678 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; 1679 #undef save_arg 1680 } 1681 EXPORT_SYMBOL_GPL(vbin_printf); 1682 1683 /** 1684 * bstr_printf - Format a string from binary arguments and place it in a buffer 1685 * @buf: The buffer to place the result into 1686 * @size: The size of the buffer, including the trailing null space 1687 * @fmt: The format string to use 1688 * @bin_buf: Binary arguments for the format string 1689 * 1690 * This function like C99 vsnprintf, but the difference is that vsnprintf gets 1691 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is 1692 * a binary buffer that generated by vbin_printf. 1693 * 1694 * The format follows C99 vsnprintf, but has some extensions: 1695 * see vsnprintf comment for details. 1696 * 1697 * The return value is the number of characters which would 1698 * be generated for the given input, excluding the trailing 1699 * '\0', as per ISO C99. If you want to have the exact 1700 * number of characters written into @buf as return value 1701 * (not including the trailing '\0'), use vscnprintf(). If the 1702 * return is greater than or equal to @size, the resulting 1703 * string is truncated. 1704 */ 1705 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) 1706 { 1707 struct printf_spec spec = {0}; 1708 char *str, *end; 1709 const char *args = (const char *)bin_buf; 1710 1711 if (WARN_ON_ONCE((int) size < 0)) 1712 return 0; 1713 1714 str = buf; 1715 end = buf + size; 1716 1717 #define get_arg(type) \ 1718 ({ \ 1719 typeof(type) value; \ 1720 if (sizeof(type) == 8) { \ 1721 args = PTR_ALIGN(args, sizeof(u32)); \ 1722 *(u32 *)&value = *(u32 *)args; \ 1723 *((u32 *)&value + 1) = *(u32 *)(args + 4); \ 1724 } else { \ 1725 args = PTR_ALIGN(args, sizeof(type)); \ 1726 value = *(typeof(type) *)args; \ 1727 } \ 1728 args += sizeof(type); \ 1729 value; \ 1730 }) 1731 1732 /* Make sure end is always >= buf */ 1733 if (end < buf) { 1734 end = ((void *)-1); 1735 size = end - buf; 1736 } 1737 1738 while (*fmt) { 1739 const char *old_fmt = fmt; 1740 int read = format_decode(fmt, &spec); 1741 1742 fmt += read; 1743 1744 switch (spec.type) { 1745 case FORMAT_TYPE_NONE: { 1746 int copy = read; 1747 if (str < end) { 1748 if (copy > end - str) 1749 copy = end - str; 1750 memcpy(str, old_fmt, copy); 1751 } 1752 str += read; 1753 break; 1754 } 1755 1756 case FORMAT_TYPE_WIDTH: 1757 spec.field_width = get_arg(int); 1758 break; 1759 1760 case FORMAT_TYPE_PRECISION: 1761 spec.precision = get_arg(int); 1762 break; 1763 1764 case FORMAT_TYPE_CHAR: { 1765 char c; 1766 1767 if (!(spec.flags & LEFT)) { 1768 while (--spec.field_width > 0) { 1769 if (str < end) 1770 *str = ' '; 1771 ++str; 1772 } 1773 } 1774 c = (unsigned char) get_arg(char); 1775 if (str < end) 1776 *str = c; 1777 ++str; 1778 while (--spec.field_width > 0) { 1779 if (str < end) 1780 *str = ' '; 1781 ++str; 1782 } 1783 break; 1784 } 1785 1786 case FORMAT_TYPE_STR: { 1787 const char *str_arg = args; 1788 args += strlen(str_arg) + 1; 1789 str = string(str, end, (char *)str_arg, spec); 1790 break; 1791 } 1792 1793 case FORMAT_TYPE_PTR: 1794 str = pointer(fmt+1, str, end, get_arg(void *), spec); 1795 while (isalnum(*fmt)) 1796 fmt++; 1797 break; 1798 1799 case FORMAT_TYPE_PERCENT_CHAR: 1800 case FORMAT_TYPE_INVALID: 1801 if (str < end) 1802 *str = '%'; 1803 ++str; 1804 break; 1805 1806 case FORMAT_TYPE_NRCHARS: 1807 /* skip */ 1808 break; 1809 1810 default: { 1811 unsigned long long num; 1812 1813 switch (spec.type) { 1814 1815 case FORMAT_TYPE_LONG_LONG: 1816 num = get_arg(long long); 1817 break; 1818 case FORMAT_TYPE_ULONG: 1819 case FORMAT_TYPE_LONG: 1820 num = get_arg(unsigned long); 1821 break; 1822 case FORMAT_TYPE_SIZE_T: 1823 num = get_arg(size_t); 1824 break; 1825 case FORMAT_TYPE_PTRDIFF: 1826 num = get_arg(ptrdiff_t); 1827 break; 1828 case FORMAT_TYPE_UBYTE: 1829 num = get_arg(unsigned char); 1830 break; 1831 case FORMAT_TYPE_BYTE: 1832 num = get_arg(signed char); 1833 break; 1834 case FORMAT_TYPE_USHORT: 1835 num = get_arg(unsigned short); 1836 break; 1837 case FORMAT_TYPE_SHORT: 1838 num = get_arg(short); 1839 break; 1840 case FORMAT_TYPE_UINT: 1841 num = get_arg(unsigned int); 1842 break; 1843 default: 1844 num = get_arg(int); 1845 } 1846 1847 str = number(str, end, num, spec); 1848 } /* default: */ 1849 } /* switch(spec.type) */ 1850 } /* while(*fmt) */ 1851 1852 if (size > 0) { 1853 if (str < end) 1854 *str = '\0'; 1855 else 1856 end[-1] = '\0'; 1857 } 1858 1859 #undef get_arg 1860 1861 /* the trailing null byte doesn't count towards the total */ 1862 return str - buf; 1863 } 1864 EXPORT_SYMBOL_GPL(bstr_printf); 1865 1866 /** 1867 * bprintf - Parse a format string and place args' binary value in a buffer 1868 * @bin_buf: The buffer to place args' binary value 1869 * @size: The size of the buffer(by words(32bits), not characters) 1870 * @fmt: The format string to use 1871 * @...: Arguments for the format string 1872 * 1873 * The function returns the number of words(u32) written 1874 * into @bin_buf. 1875 */ 1876 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) 1877 { 1878 va_list args; 1879 int ret; 1880 1881 va_start(args, fmt); 1882 ret = vbin_printf(bin_buf, size, fmt, args); 1883 va_end(args); 1884 1885 return ret; 1886 } 1887 EXPORT_SYMBOL_GPL(bprintf); 1888 1889 #endif /* CONFIG_BINARY_PRINTF */ 1890 1891 /** 1892 * vsscanf - Unformat a buffer into a list of arguments 1893 * @buf: input buffer 1894 * @fmt: format of buffer 1895 * @args: arguments 1896 */ 1897 int vsscanf(const char *buf, const char *fmt, va_list args) 1898 { 1899 const char *str = buf; 1900 char *next; 1901 char digit; 1902 int num = 0; 1903 u8 qualifier; 1904 u8 base; 1905 s16 field_width; 1906 bool is_sign; 1907 1908 while (*fmt && *str) { 1909 /* skip any white space in format */ 1910 /* white space in format matchs any amount of 1911 * white space, including none, in the input. 1912 */ 1913 if (isspace(*fmt)) { 1914 fmt = skip_spaces(++fmt); 1915 str = skip_spaces(str); 1916 } 1917 1918 /* anything that is not a conversion must match exactly */ 1919 if (*fmt != '%' && *fmt) { 1920 if (*fmt++ != *str++) 1921 break; 1922 continue; 1923 } 1924 1925 if (!*fmt) 1926 break; 1927 ++fmt; 1928 1929 /* skip this conversion. 1930 * advance both strings to next white space 1931 */ 1932 if (*fmt == '*') { 1933 while (!isspace(*fmt) && *fmt != '%' && *fmt) 1934 fmt++; 1935 while (!isspace(*str) && *str) 1936 str++; 1937 continue; 1938 } 1939 1940 /* get field width */ 1941 field_width = -1; 1942 if (isdigit(*fmt)) 1943 field_width = skip_atoi(&fmt); 1944 1945 /* get conversion qualifier */ 1946 qualifier = -1; 1947 if (*fmt == 'h' || TOLOWER(*fmt) == 'l' || 1948 TOLOWER(*fmt) == 'z') { 1949 qualifier = *fmt++; 1950 if (unlikely(qualifier == *fmt)) { 1951 if (qualifier == 'h') { 1952 qualifier = 'H'; 1953 fmt++; 1954 } else if (qualifier == 'l') { 1955 qualifier = 'L'; 1956 fmt++; 1957 } 1958 } 1959 } 1960 1961 if (!*fmt || !*str) 1962 break; 1963 1964 base = 10; 1965 is_sign = 0; 1966 1967 switch (*fmt++) { 1968 case 'c': 1969 { 1970 char *s = (char *)va_arg(args, char*); 1971 if (field_width == -1) 1972 field_width = 1; 1973 do { 1974 *s++ = *str++; 1975 } while (--field_width > 0 && *str); 1976 num++; 1977 } 1978 continue; 1979 case 's': 1980 { 1981 char *s = (char *)va_arg(args, char *); 1982 if (field_width == -1) 1983 field_width = SHORT_MAX; 1984 /* first, skip leading white space in buffer */ 1985 str = skip_spaces(str); 1986 1987 /* now copy until next white space */ 1988 while (*str && !isspace(*str) && field_width--) 1989 *s++ = *str++; 1990 *s = '\0'; 1991 num++; 1992 } 1993 continue; 1994 case 'n': 1995 /* return number of characters read so far */ 1996 { 1997 int *i = (int *)va_arg(args, int*); 1998 *i = str - buf; 1999 } 2000 continue; 2001 case 'o': 2002 base = 8; 2003 break; 2004 case 'x': 2005 case 'X': 2006 base = 16; 2007 break; 2008 case 'i': 2009 base = 0; 2010 case 'd': 2011 is_sign = 1; 2012 case 'u': 2013 break; 2014 case '%': 2015 /* looking for '%' in str */ 2016 if (*str++ != '%') 2017 return num; 2018 continue; 2019 default: 2020 /* invalid format; stop here */ 2021 return num; 2022 } 2023 2024 /* have some sort of integer conversion. 2025 * first, skip white space in buffer. 2026 */ 2027 str = skip_spaces(str); 2028 2029 digit = *str; 2030 if (is_sign && digit == '-') 2031 digit = *(str + 1); 2032 2033 if (!digit 2034 || (base == 16 && !isxdigit(digit)) 2035 || (base == 10 && !isdigit(digit)) 2036 || (base == 8 && (!isdigit(digit) || digit > '7')) 2037 || (base == 0 && !isdigit(digit))) 2038 break; 2039 2040 switch (qualifier) { 2041 case 'H': /* that's 'hh' in format */ 2042 if (is_sign) { 2043 signed char *s = (signed char *)va_arg(args, signed char *); 2044 *s = (signed char)simple_strtol(str, &next, base); 2045 } else { 2046 unsigned char *s = (unsigned char *)va_arg(args, unsigned char *); 2047 *s = (unsigned char)simple_strtoul(str, &next, base); 2048 } 2049 break; 2050 case 'h': 2051 if (is_sign) { 2052 short *s = (short *)va_arg(args, short *); 2053 *s = (short)simple_strtol(str, &next, base); 2054 } else { 2055 unsigned short *s = (unsigned short *)va_arg(args, unsigned short *); 2056 *s = (unsigned short)simple_strtoul(str, &next, base); 2057 } 2058 break; 2059 case 'l': 2060 if (is_sign) { 2061 long *l = (long *)va_arg(args, long *); 2062 *l = simple_strtol(str, &next, base); 2063 } else { 2064 unsigned long *l = (unsigned long *)va_arg(args, unsigned long *); 2065 *l = simple_strtoul(str, &next, base); 2066 } 2067 break; 2068 case 'L': 2069 if (is_sign) { 2070 long long *l = (long long *)va_arg(args, long long *); 2071 *l = simple_strtoll(str, &next, base); 2072 } else { 2073 unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *); 2074 *l = simple_strtoull(str, &next, base); 2075 } 2076 break; 2077 case 'Z': 2078 case 'z': 2079 { 2080 size_t *s = (size_t *)va_arg(args, size_t *); 2081 *s = (size_t)simple_strtoul(str, &next, base); 2082 } 2083 break; 2084 default: 2085 if (is_sign) { 2086 int *i = (int *)va_arg(args, int *); 2087 *i = (int)simple_strtol(str, &next, base); 2088 } else { 2089 unsigned int *i = (unsigned int *)va_arg(args, unsigned int*); 2090 *i = (unsigned int)simple_strtoul(str, &next, base); 2091 } 2092 break; 2093 } 2094 num++; 2095 2096 if (!next) 2097 break; 2098 str = next; 2099 } 2100 2101 /* 2102 * Now we've come all the way through so either the input string or the 2103 * format ended. In the former case, there can be a %n at the current 2104 * position in the format that needs to be filled. 2105 */ 2106 if (*fmt == '%' && *(fmt + 1) == 'n') { 2107 int *p = (int *)va_arg(args, int *); 2108 *p = str - buf; 2109 } 2110 2111 return num; 2112 } 2113 EXPORT_SYMBOL(vsscanf); 2114 2115 /** 2116 * sscanf - Unformat a buffer into a list of arguments 2117 * @buf: input buffer 2118 * @fmt: formatting of buffer 2119 * @...: resulting arguments 2120 */ 2121 int sscanf(const char *buf, const char *fmt, ...) 2122 { 2123 va_list args; 2124 int i; 2125 2126 va_start(args, fmt); 2127 i = vsscanf(buf, fmt, args); 2128 va_end(args); 2129 2130 return i; 2131 } 2132 EXPORT_SYMBOL(sscanf); 2133