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 * from hush: simple_itoa() was lifted from boa-0.93.15 12 */ 13 14 #include <stdarg.h> 15 #include <linux/types.h> 16 #include <linux/string.h> 17 #include <linux/ctype.h> 18 #include <errno.h> 19 20 #include <common.h> 21 #if !defined(CONFIG_PANIC_HANG) 22 #include <command.h> 23 #endif 24 25 #include <div64.h> 26 #define noinline __attribute__((noinline)) 27 28 unsigned long simple_strtoul(const char *cp, char **endp, 29 unsigned int base) 30 { 31 unsigned long result = 0; 32 unsigned long value; 33 34 if (*cp == '0') { 35 cp++; 36 if ((*cp == 'x') && isxdigit(cp[1])) { 37 base = 16; 38 cp++; 39 } 40 41 if (!base) 42 base = 8; 43 } 44 45 if (!base) 46 base = 10; 47 48 while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp) 49 ? toupper(*cp) : *cp)-'A'+10) < base) { 50 result = result*base + value; 51 cp++; 52 } 53 54 if (endp) 55 *endp = (char *)cp; 56 57 return result; 58 } 59 60 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res) 61 { 62 char *tail; 63 unsigned long val; 64 size_t len; 65 66 *res = 0; 67 len = strlen(cp); 68 if (len == 0) 69 return -EINVAL; 70 71 val = simple_strtoul(cp, &tail, base); 72 if (tail == cp) 73 return -EINVAL; 74 75 if ((*tail == '\0') || 76 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 77 *res = val; 78 return 0; 79 } 80 81 return -EINVAL; 82 } 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 92 unsigned long ustrtoul(const char *cp, char **endp, unsigned int base) 93 { 94 unsigned long result = simple_strtoul(cp, endp, base); 95 switch (**endp) { 96 case 'G': 97 result *= 1024; 98 /* fall through */ 99 case 'M': 100 result *= 1024; 101 /* fall through */ 102 case 'K': 103 case 'k': 104 result *= 1024; 105 if ((*endp)[1] == 'i') { 106 if ((*endp)[2] == 'B') 107 (*endp) += 3; 108 else 109 (*endp) += 2; 110 } 111 } 112 return result; 113 } 114 115 unsigned long long ustrtoull(const char *cp, char **endp, unsigned int base) 116 { 117 unsigned long long result = simple_strtoull(cp, endp, base); 118 switch (**endp) { 119 case 'G': 120 result *= 1024; 121 /* fall through */ 122 case 'M': 123 result *= 1024; 124 /* fall through */ 125 case 'K': 126 case 'k': 127 result *= 1024; 128 if ((*endp)[1] == 'i') { 129 if ((*endp)[2] == 'B') 130 (*endp) += 3; 131 else 132 (*endp) += 2; 133 } 134 } 135 return result; 136 } 137 138 unsigned long long simple_strtoull(const char *cp, char **endp, 139 unsigned int base) 140 { 141 unsigned long long result = 0, value; 142 143 if (*cp == '0') { 144 cp++; 145 if ((*cp == 'x') && isxdigit(cp[1])) { 146 base = 16; 147 cp++; 148 } 149 150 if (!base) 151 base = 8; 152 } 153 154 if (!base) 155 base = 10; 156 157 while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp - '0' 158 : (islower(*cp) ? toupper(*cp) : *cp) - 'A' + 10) < base) { 159 result = result * base + value; 160 cp++; 161 } 162 163 if (endp) 164 *endp = (char *) cp; 165 166 return result; 167 } 168 169 /* we use this so that we can do without the ctype library */ 170 #define is_digit(c) ((c) >= '0' && (c) <= '9') 171 172 static int skip_atoi(const char **s) 173 { 174 int i = 0; 175 176 while (is_digit(**s)) 177 i = i * 10 + *((*s)++) - '0'; 178 179 return i; 180 } 181 182 /* Decimal conversion is by far the most typical, and is used 183 * for /proc and /sys data. This directly impacts e.g. top performance 184 * with many processes running. We optimize it for speed 185 * using code from 186 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html 187 * (with permission from the author, Douglas W. Jones). */ 188 189 /* Formats correctly any integer in [0,99999]. 190 * Outputs from one to five digits depending on input. 191 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */ 192 static char *put_dec_trunc(char *buf, unsigned q) 193 { 194 unsigned d3, d2, d1, d0; 195 d1 = (q>>4) & 0xf; 196 d2 = (q>>8) & 0xf; 197 d3 = (q>>12); 198 199 d0 = 6*(d3 + d2 + d1) + (q & 0xf); 200 q = (d0 * 0xcd) >> 11; 201 d0 = d0 - 10*q; 202 *buf++ = d0 + '0'; /* least significant digit */ 203 d1 = q + 9*d3 + 5*d2 + d1; 204 if (d1 != 0) { 205 q = (d1 * 0xcd) >> 11; 206 d1 = d1 - 10*q; 207 *buf++ = d1 + '0'; /* next digit */ 208 209 d2 = q + 2*d2; 210 if ((d2 != 0) || (d3 != 0)) { 211 q = (d2 * 0xd) >> 7; 212 d2 = d2 - 10*q; 213 *buf++ = d2 + '0'; /* next digit */ 214 215 d3 = q + 4*d3; 216 if (d3 != 0) { 217 q = (d3 * 0xcd) >> 11; 218 d3 = d3 - 10*q; 219 *buf++ = d3 + '0'; /* next digit */ 220 if (q != 0) 221 *buf++ = q + '0'; /* most sign. digit */ 222 } 223 } 224 } 225 return buf; 226 } 227 /* Same with if's removed. Always emits five digits */ 228 static char *put_dec_full(char *buf, unsigned q) 229 { 230 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */ 231 /* but anyway, gcc produces better code with full-sized ints */ 232 unsigned d3, d2, d1, d0; 233 d1 = (q>>4) & 0xf; 234 d2 = (q>>8) & 0xf; 235 d3 = (q>>12); 236 237 /* 238 * Possible ways to approx. divide by 10 239 * gcc -O2 replaces multiply with shifts and adds 240 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386) 241 * (x * 0x67) >> 10: 1100111 242 * (x * 0x34) >> 9: 110100 - same 243 * (x * 0x1a) >> 8: 11010 - same 244 * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386) 245 */ 246 247 d0 = 6*(d3 + d2 + d1) + (q & 0xf); 248 q = (d0 * 0xcd) >> 11; 249 d0 = d0 - 10*q; 250 *buf++ = d0 + '0'; 251 d1 = q + 9*d3 + 5*d2 + d1; 252 q = (d1 * 0xcd) >> 11; 253 d1 = d1 - 10*q; 254 *buf++ = d1 + '0'; 255 256 d2 = q + 2*d2; 257 q = (d2 * 0xd) >> 7; 258 d2 = d2 - 10*q; 259 *buf++ = d2 + '0'; 260 261 d3 = q + 4*d3; 262 q = (d3 * 0xcd) >> 11; /* - shorter code */ 263 /* q = (d3 * 0x67) >> 10; - would also work */ 264 d3 = d3 - 10*q; 265 *buf++ = d3 + '0'; 266 *buf++ = q + '0'; 267 return buf; 268 } 269 /* No inlining helps gcc to use registers better */ 270 static noinline char *put_dec(char *buf, uint64_t num) 271 { 272 while (1) { 273 unsigned rem; 274 if (num < 100000) 275 return put_dec_trunc(buf, num); 276 rem = do_div(num, 100000); 277 buf = put_dec_full(buf, rem); 278 } 279 } 280 281 #define ZEROPAD 1 /* pad with zero */ 282 #define SIGN 2 /* unsigned/signed long */ 283 #define PLUS 4 /* show plus */ 284 #define SPACE 8 /* space if plus */ 285 #define LEFT 16 /* left justified */ 286 #define SMALL 32 /* Must be 32 == 0x20 */ 287 #define SPECIAL 64 /* 0x */ 288 289 #ifdef CONFIG_SYS_VSNPRINTF 290 /* 291 * Macro to add a new character to our output string, but only if it will 292 * fit. The macro moves to the next character position in the output string. 293 */ 294 #define ADDCH(str, ch) do { \ 295 if ((str) < end) \ 296 *(str) = (ch); \ 297 ++str; \ 298 } while (0) 299 #else 300 #define ADDCH(str, ch) (*(str)++ = (ch)) 301 #endif 302 303 static char *number(char *buf, char *end, u64 num, 304 int base, int size, int precision, int type) 305 { 306 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ 307 static const char digits[16] = "0123456789ABCDEF"; 308 309 char tmp[66]; 310 char sign; 311 char locase; 312 int need_pfx = ((type & SPECIAL) && base != 10); 313 int i; 314 315 /* locase = 0 or 0x20. ORing digits or letters with 'locase' 316 * produces same digits or (maybe lowercased) letters */ 317 locase = (type & SMALL); 318 if (type & LEFT) 319 type &= ~ZEROPAD; 320 sign = 0; 321 if (type & SIGN) { 322 if ((s64) num < 0) { 323 sign = '-'; 324 num = -(s64) num; 325 size--; 326 } else if (type & PLUS) { 327 sign = '+'; 328 size--; 329 } else if (type & SPACE) { 330 sign = ' '; 331 size--; 332 } 333 } 334 if (need_pfx) { 335 size--; 336 if (base == 16) 337 size--; 338 } 339 340 /* generate full string in tmp[], in reverse order */ 341 i = 0; 342 if (num == 0) 343 tmp[i++] = '0'; 344 /* Generic code, for any base: 345 else do { 346 tmp[i++] = (digits[do_div(num,base)] | locase); 347 } while (num != 0); 348 */ 349 else if (base != 10) { /* 8 or 16 */ 350 int mask = base - 1; 351 int shift = 3; 352 353 if (base == 16) 354 shift = 4; 355 356 do { 357 tmp[i++] = (digits[((unsigned char)num) & mask] 358 | locase); 359 num >>= shift; 360 } while (num); 361 } else { /* base 10 */ 362 i = put_dec(tmp, num) - tmp; 363 } 364 365 /* printing 100 using %2d gives "100", not "00" */ 366 if (i > precision) 367 precision = i; 368 /* leading space padding */ 369 size -= precision; 370 if (!(type & (ZEROPAD + LEFT))) { 371 while (--size >= 0) 372 ADDCH(buf, ' '); 373 } 374 /* sign */ 375 if (sign) 376 ADDCH(buf, sign); 377 /* "0x" / "0" prefix */ 378 if (need_pfx) { 379 ADDCH(buf, '0'); 380 if (base == 16) 381 ADDCH(buf, 'X' | locase); 382 } 383 /* zero or space padding */ 384 if (!(type & LEFT)) { 385 char c = (type & ZEROPAD) ? '0' : ' '; 386 387 while (--size >= 0) 388 ADDCH(buf, c); 389 } 390 /* hmm even more zero padding? */ 391 while (i <= --precision) 392 ADDCH(buf, '0'); 393 /* actual digits of result */ 394 while (--i >= 0) 395 ADDCH(buf, tmp[i]); 396 /* trailing space padding */ 397 while (--size >= 0) 398 ADDCH(buf, ' '); 399 return buf; 400 } 401 402 static char *string(char *buf, char *end, char *s, int field_width, 403 int precision, int flags) 404 { 405 int len, i; 406 407 if (s == NULL) 408 s = "<NULL>"; 409 410 len = strnlen(s, precision); 411 412 if (!(flags & LEFT)) 413 while (len < field_width--) 414 ADDCH(buf, ' '); 415 for (i = 0; i < len; ++i) 416 ADDCH(buf, *s++); 417 while (len < field_width--) 418 ADDCH(buf, ' '); 419 return buf; 420 } 421 422 #ifdef CONFIG_CMD_NET 423 static const char hex_asc[] = "0123456789abcdef"; 424 #define hex_asc_lo(x) hex_asc[((x) & 0x0f)] 425 #define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4] 426 427 static inline char *pack_hex_byte(char *buf, u8 byte) 428 { 429 *buf++ = hex_asc_hi(byte); 430 *buf++ = hex_asc_lo(byte); 431 return buf; 432 } 433 434 static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width, 435 int precision, int flags) 436 { 437 /* (6 * 2 hex digits), 5 colons and trailing zero */ 438 char mac_addr[6 * 3]; 439 char *p = mac_addr; 440 int i; 441 442 for (i = 0; i < 6; i++) { 443 p = pack_hex_byte(p, addr[i]); 444 if (!(flags & SPECIAL) && i != 5) 445 *p++ = ':'; 446 } 447 *p = '\0'; 448 449 return string(buf, end, mac_addr, field_width, precision, 450 flags & ~SPECIAL); 451 } 452 453 static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width, 454 int precision, int flags) 455 { 456 /* (8 * 4 hex digits), 7 colons and trailing zero */ 457 char ip6_addr[8 * 5]; 458 char *p = ip6_addr; 459 int i; 460 461 for (i = 0; i < 8; i++) { 462 p = pack_hex_byte(p, addr[2 * i]); 463 p = pack_hex_byte(p, addr[2 * i + 1]); 464 if (!(flags & SPECIAL) && i != 7) 465 *p++ = ':'; 466 } 467 *p = '\0'; 468 469 return string(buf, end, ip6_addr, field_width, precision, 470 flags & ~SPECIAL); 471 } 472 473 static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, 474 int precision, int flags) 475 { 476 /* (4 * 3 decimal digits), 3 dots and trailing zero */ 477 char ip4_addr[4 * 4]; 478 char temp[3]; /* hold each IP quad in reverse order */ 479 char *p = ip4_addr; 480 int i, digits; 481 482 for (i = 0; i < 4; i++) { 483 digits = put_dec_trunc(temp, addr[i]) - temp; 484 /* reverse the digits in the quad */ 485 while (digits--) 486 *p++ = temp[digits]; 487 if (i != 3) 488 *p++ = '.'; 489 } 490 *p = '\0'; 491 492 return string(buf, end, ip4_addr, field_width, precision, 493 flags & ~SPECIAL); 494 } 495 #endif 496 497 /* 498 * Show a '%p' thing. A kernel extension is that the '%p' is followed 499 * by an extra set of alphanumeric characters that are extended format 500 * specifiers. 501 * 502 * Right now we handle: 503 * 504 * - 'M' For a 6-byte MAC address, it prints the address in the 505 * usual colon-separated hex notation 506 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated 507 * decimal for v4 and colon separated network-order 16 bit hex for v6) 508 * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is 509 * currently the same 510 * 511 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64 512 * function pointers are really function descriptors, which contain a 513 * pointer to the real address. 514 */ 515 static char *pointer(const char *fmt, char *buf, char *end, void *ptr, 516 int field_width, int precision, int flags) 517 { 518 u64 num = (uintptr_t)ptr; 519 520 /* 521 * Being a boot loader, we explicitly allow pointers to 522 * (physical) address null. 523 */ 524 #if 0 525 if (!ptr) 526 return string(buf, end, "(null)", field_width, precision, 527 flags); 528 #endif 529 530 #ifdef CONFIG_CMD_NET 531 switch (*fmt) { 532 case 'a': 533 flags |= SPECIAL | ZEROPAD; 534 535 switch (fmt[1]) { 536 case 'p': 537 default: 538 field_width = sizeof(phys_addr_t) * 2 + 2; 539 num = *(phys_addr_t *)ptr; 540 break; 541 } 542 break; 543 case 'm': 544 flags |= SPECIAL; 545 /* Fallthrough */ 546 case 'M': 547 return mac_address_string(buf, end, ptr, field_width, 548 precision, flags); 549 case 'i': 550 flags |= SPECIAL; 551 /* Fallthrough */ 552 case 'I': 553 if (fmt[1] == '6') 554 return ip6_addr_string(buf, end, ptr, field_width, 555 precision, flags); 556 if (fmt[1] == '4') 557 return ip4_addr_string(buf, end, ptr, field_width, 558 precision, flags); 559 flags &= ~SPECIAL; 560 break; 561 } 562 #endif 563 flags |= SMALL; 564 if (field_width == -1) { 565 field_width = 2*sizeof(void *); 566 flags |= ZEROPAD; 567 } 568 return number(buf, end, num, 16, field_width, precision, flags); 569 } 570 571 static int vsnprintf_internal(char *buf, size_t size, const char *fmt, 572 va_list args) 573 { 574 u64 num; 575 int base; 576 char *str; 577 578 int flags; /* flags to number() */ 579 580 int field_width; /* width of output field */ 581 int precision; /* min. # of digits for integers; max 582 number of chars for from string */ 583 int qualifier; /* 'h', 'l', or 'L' for integer fields */ 584 /* 'z' support added 23/7/1999 S.H. */ 585 /* 'z' changed to 'Z' --davidm 1/25/99 */ 586 /* 't' added for ptrdiff_t */ 587 char *end = buf + size; 588 589 #ifdef CONFIG_SYS_VSNPRINTF 590 /* Make sure end is always >= buf - do we want this in U-Boot? */ 591 if (end < buf) { 592 end = ((void *)-1); 593 size = end - buf; 594 } 595 #endif 596 str = buf; 597 598 for (; *fmt ; ++fmt) { 599 if (*fmt != '%') { 600 ADDCH(str, *fmt); 601 continue; 602 } 603 604 /* process flags */ 605 flags = 0; 606 repeat: 607 ++fmt; /* this also skips first '%' */ 608 switch (*fmt) { 609 case '-': 610 flags |= LEFT; 611 goto repeat; 612 case '+': 613 flags |= PLUS; 614 goto repeat; 615 case ' ': 616 flags |= SPACE; 617 goto repeat; 618 case '#': 619 flags |= SPECIAL; 620 goto repeat; 621 case '0': 622 flags |= ZEROPAD; 623 goto repeat; 624 } 625 626 /* get field width */ 627 field_width = -1; 628 if (is_digit(*fmt)) 629 field_width = skip_atoi(&fmt); 630 else if (*fmt == '*') { 631 ++fmt; 632 /* it's the next argument */ 633 field_width = va_arg(args, int); 634 if (field_width < 0) { 635 field_width = -field_width; 636 flags |= LEFT; 637 } 638 } 639 640 /* get the precision */ 641 precision = -1; 642 if (*fmt == '.') { 643 ++fmt; 644 if (is_digit(*fmt)) 645 precision = skip_atoi(&fmt); 646 else if (*fmt == '*') { 647 ++fmt; 648 /* it's the next argument */ 649 precision = va_arg(args, int); 650 } 651 if (precision < 0) 652 precision = 0; 653 } 654 655 /* get the conversion qualifier */ 656 qualifier = -1; 657 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || 658 *fmt == 'Z' || *fmt == 'z' || *fmt == 't') { 659 qualifier = *fmt; 660 ++fmt; 661 if (qualifier == 'l' && *fmt == 'l') { 662 qualifier = 'L'; 663 ++fmt; 664 } 665 } 666 667 /* default base */ 668 base = 10; 669 670 switch (*fmt) { 671 case 'c': 672 if (!(flags & LEFT)) { 673 while (--field_width > 0) 674 ADDCH(str, ' '); 675 } 676 ADDCH(str, (unsigned char) va_arg(args, int)); 677 while (--field_width > 0) 678 ADDCH(str, ' '); 679 continue; 680 681 case 's': 682 str = string(str, end, va_arg(args, char *), 683 field_width, precision, flags); 684 continue; 685 686 case 'p': 687 str = pointer(fmt + 1, str, end, 688 va_arg(args, void *), 689 field_width, precision, flags); 690 /* Skip all alphanumeric pointer suffixes */ 691 while (isalnum(fmt[1])) 692 fmt++; 693 continue; 694 695 case 'n': 696 if (qualifier == 'l') { 697 long *ip = va_arg(args, long *); 698 *ip = (str - buf); 699 } else { 700 int *ip = va_arg(args, int *); 701 *ip = (str - buf); 702 } 703 continue; 704 705 case '%': 706 ADDCH(str, '%'); 707 continue; 708 709 /* integer number formats - set up the flags and "break" */ 710 case 'o': 711 base = 8; 712 break; 713 714 case 'x': 715 flags |= SMALL; 716 case 'X': 717 base = 16; 718 break; 719 720 case 'd': 721 case 'i': 722 flags |= SIGN; 723 case 'u': 724 break; 725 726 default: 727 ADDCH(str, '%'); 728 if (*fmt) 729 ADDCH(str, *fmt); 730 else 731 --fmt; 732 continue; 733 } 734 if (qualifier == 'L') /* "quad" for 64 bit variables */ 735 num = va_arg(args, unsigned long long); 736 else if (qualifier == 'l') { 737 num = va_arg(args, unsigned long); 738 if (flags & SIGN) 739 num = (signed long) num; 740 } else if (qualifier == 'Z' || qualifier == 'z') { 741 num = va_arg(args, size_t); 742 } else if (qualifier == 't') { 743 num = va_arg(args, ptrdiff_t); 744 } else if (qualifier == 'h') { 745 num = (unsigned short) va_arg(args, int); 746 if (flags & SIGN) 747 num = (signed short) num; 748 } else { 749 num = va_arg(args, unsigned int); 750 if (flags & SIGN) 751 num = (signed int) num; 752 } 753 str = number(str, end, num, base, field_width, precision, 754 flags); 755 } 756 757 #ifdef CONFIG_SYS_VSNPRINTF 758 if (size > 0) { 759 ADDCH(str, '\0'); 760 if (str > end) 761 end[-1] = '\0'; 762 --str; 763 } 764 #else 765 *str = '\0'; 766 #endif 767 /* the trailing null byte doesn't count towards the total */ 768 return str - buf; 769 } 770 771 #ifdef CONFIG_SYS_VSNPRINTF 772 int vsnprintf(char *buf, size_t size, const char *fmt, 773 va_list args) 774 { 775 return vsnprintf_internal(buf, size, fmt, args); 776 } 777 778 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args) 779 { 780 int i; 781 782 i = vsnprintf(buf, size, fmt, args); 783 784 if (likely(i < size)) 785 return i; 786 if (size != 0) 787 return size - 1; 788 return 0; 789 } 790 791 int snprintf(char *buf, size_t size, const char *fmt, ...) 792 { 793 va_list args; 794 int i; 795 796 va_start(args, fmt); 797 i = vsnprintf(buf, size, fmt, args); 798 va_end(args); 799 800 return i; 801 } 802 803 int scnprintf(char *buf, size_t size, const char *fmt, ...) 804 { 805 va_list args; 806 int i; 807 808 va_start(args, fmt); 809 i = vscnprintf(buf, size, fmt, args); 810 va_end(args); 811 812 return i; 813 } 814 #endif /* CONFIG_SYS_VSNPRINT */ 815 816 /** 817 * Format a string and place it in a buffer (va_list version) 818 * 819 * @param buf The buffer to place the result into 820 * @param fmt The format string to use 821 * @param args Arguments for the format string 822 * 823 * The function returns the number of characters written 824 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid 825 * buffer overflows. 826 * 827 * If you're not already dealing with a va_list consider using sprintf(). 828 */ 829 int vsprintf(char *buf, const char *fmt, va_list args) 830 { 831 return vsnprintf_internal(buf, INT_MAX, fmt, args); 832 } 833 834 int sprintf(char *buf, const char *fmt, ...) 835 { 836 va_list args; 837 int i; 838 839 va_start(args, fmt); 840 i = vsprintf(buf, fmt, args); 841 va_end(args); 842 return i; 843 } 844 845 static void panic_finish(void) __attribute__ ((noreturn)); 846 847 static void panic_finish(void) 848 { 849 putc('\n'); 850 #if defined(CONFIG_PANIC_HANG) 851 hang(); 852 #else 853 udelay(100000); /* allow messages to go out */ 854 do_reset(NULL, 0, 0, NULL); 855 #endif 856 while (1) 857 ; 858 } 859 860 void panic_str(const char *str) 861 { 862 puts(str); 863 panic_finish(); 864 } 865 866 void panic(const char *fmt, ...) 867 { 868 va_list args; 869 va_start(args, fmt); 870 vprintf(fmt, args); 871 va_end(args); 872 panic_finish(); 873 } 874 875 void __assert_fail(const char *assertion, const char *file, unsigned line, 876 const char *function) 877 { 878 /* This will not return */ 879 panic("%s:%u: %s: Assertion `%s' failed.", file, line, function, 880 assertion); 881 } 882 883 char *simple_itoa(ulong i) 884 { 885 /* 21 digits plus null terminator, good for 64-bit or smaller ints */ 886 static char local[22]; 887 char *p = &local[21]; 888 889 *p-- = '\0'; 890 do { 891 *p-- = '0' + i % 10; 892 i /= 10; 893 } while (i > 0); 894 return p + 1; 895 } 896 897 /* We don't seem to have %'d in U-Boot */ 898 void print_grouped_ull(unsigned long long int_val, int digits) 899 { 900 char str[21], *s; 901 int grab = 3; 902 903 digits = (digits + 2) / 3; 904 sprintf(str, "%*llu", digits * 3, int_val); 905 for (s = str; *s; s += grab) { 906 if (s != str) 907 putc(s[-1] != ' ' ? ',' : ' '); 908 printf("%.*s", grab, s); 909 grab = 3; 910 } 911 } 912