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