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