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 <common.h>
15 #include <charset.h>
16 #include <efi_loader.h>
17 #include <div64.h>
18 #include <hexdump.h>
19 #include <uuid.h>
20 #include <stdarg.h>
21 #include <linux/ctype.h>
22 #include <linux/err.h>
23 #include <linux/types.h>
24 #include <linux/string.h>
25
26 #define noinline __attribute__((noinline))
27
28 /* we use this so that we can do without the ctype library */
29 #define is_digit(c) ((c) >= '0' && (c) <= '9')
30
skip_atoi(const char ** s)31 static 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. */
put_dec_trunc(char * buf,unsigned q)51 static 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 */
put_dec_full(char * buf,unsigned q)87 static 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 */
put_dec(char * buf,uint64_t num)129 static 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
148 /*
149 * Macro to add a new character to our output string, but only if it will
150 * fit. The macro moves to the next character position in the output string.
151 */
152 #define ADDCH(str, ch) do { \
153 if ((str) < end) \
154 *(str) = (ch); \
155 ++str; \
156 } while (0)
157
number(char * buf,char * end,u64 num,int base,int size,int precision,int type)158 static char *number(char *buf, char *end, u64 num,
159 int base, int size, int precision, int type)
160 {
161 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
162 static const char digits[16] = "0123456789ABCDEF";
163
164 char tmp[66];
165 char sign;
166 char locase;
167 int need_pfx = ((type & SPECIAL) && base != 10);
168 int i;
169
170 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
171 * produces same digits or (maybe lowercased) letters */
172 locase = (type & SMALL);
173 if (type & LEFT)
174 type &= ~ZEROPAD;
175 sign = 0;
176 if (type & SIGN) {
177 if ((s64) num < 0) {
178 sign = '-';
179 num = -(s64) num;
180 size--;
181 } else if (type & PLUS) {
182 sign = '+';
183 size--;
184 } else if (type & SPACE) {
185 sign = ' ';
186 size--;
187 }
188 }
189 if (need_pfx) {
190 size--;
191 if (base == 16)
192 size--;
193 }
194
195 /* generate full string in tmp[], in reverse order */
196 i = 0;
197 if (num == 0)
198 tmp[i++] = '0';
199 /* Generic code, for any base:
200 else do {
201 tmp[i++] = (digits[do_div(num,base)] | locase);
202 } while (num != 0);
203 */
204 else if (base != 10) { /* 8 or 16 */
205 int mask = base - 1;
206 int shift = 3;
207
208 if (base == 16)
209 shift = 4;
210
211 do {
212 tmp[i++] = (digits[((unsigned char)num) & mask]
213 | locase);
214 num >>= shift;
215 } while (num);
216 } else { /* base 10 */
217 i = put_dec(tmp, num) - tmp;
218 }
219
220 /* printing 100 using %2d gives "100", not "00" */
221 if (i > precision)
222 precision = i;
223 /* leading space padding */
224 size -= precision;
225 if (!(type & (ZEROPAD + LEFT))) {
226 while (--size >= 0)
227 ADDCH(buf, ' ');
228 }
229 /* sign */
230 if (sign)
231 ADDCH(buf, sign);
232 /* "0x" / "0" prefix */
233 if (need_pfx) {
234 ADDCH(buf, '0');
235 if (base == 16)
236 ADDCH(buf, 'X' | locase);
237 }
238 /* zero or space padding */
239 if (!(type & LEFT)) {
240 char c = (type & ZEROPAD) ? '0' : ' ';
241
242 while (--size >= 0)
243 ADDCH(buf, c);
244 }
245 /* hmm even more zero padding? */
246 while (i <= --precision)
247 ADDCH(buf, '0');
248 /* actual digits of result */
249 while (--i >= 0)
250 ADDCH(buf, tmp[i]);
251 /* trailing space padding */
252 while (--size >= 0)
253 ADDCH(buf, ' ');
254 return buf;
255 }
256
string(char * buf,char * end,char * s,int field_width,int precision,int flags)257 static char *string(char *buf, char *end, char *s, int field_width,
258 int precision, int flags)
259 {
260 int len, i;
261
262 if (s == NULL)
263 s = "<NULL>";
264
265 len = strnlen(s, precision);
266
267 if (!(flags & LEFT))
268 while (len < field_width--)
269 ADDCH(buf, ' ');
270 for (i = 0; i < len; ++i)
271 ADDCH(buf, *s++);
272 while (len < field_width--)
273 ADDCH(buf, ' ');
274 return buf;
275 }
276
string16(char * buf,char * end,u16 * s,int field_width,int precision,int flags)277 static char *string16(char *buf, char *end, u16 *s, int field_width,
278 int precision, int flags)
279 {
280 u16 *str = s ? s : L"<NULL>";
281 int utf16_len = utf16_strnlen(str, precision);
282 u8 utf8[utf16_len * MAX_UTF8_PER_UTF16];
283 int utf8_len, i;
284
285 utf8_len = utf16_to_utf8(utf8, str, utf16_len) - utf8;
286
287 if (!(flags & LEFT))
288 while (utf8_len < field_width--)
289 ADDCH(buf, ' ');
290 for (i = 0; i < utf8_len; ++i)
291 ADDCH(buf, utf8[i]);
292 while (utf8_len < field_width--)
293 ADDCH(buf, ' ');
294 return buf;
295 }
296
297 #if defined(CONFIG_EFI_LOADER) && \
298 !defined(CONFIG_SPL_BUILD) && !defined(API_BUILD)
device_path_string(char * buf,char * end,void * dp,int field_width,int precision,int flags)299 static char *device_path_string(char *buf, char *end, void *dp, int field_width,
300 int precision, int flags)
301 {
302 u16 *str;
303
304 /* If dp == NULL output the string '<NULL>' */
305 if (!dp)
306 return string16(buf, end, dp, field_width, precision, flags);
307
308 str = efi_dp_str((struct efi_device_path *)dp);
309 if (!str)
310 return ERR_PTR(-ENOMEM);
311
312 buf = string16(buf, end, str, field_width, precision, flags);
313 efi_free_pool(str);
314 return buf;
315 }
316 #endif
317
318 #ifdef CONFIG_CMD_NET
mac_address_string(char * buf,char * end,u8 * addr,int field_width,int precision,int flags)319 static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
320 int precision, int flags)
321 {
322 /* (6 * 2 hex digits), 5 colons and trailing zero */
323 char mac_addr[6 * 3];
324 char *p = mac_addr;
325 int i;
326
327 for (i = 0; i < 6; i++) {
328 p = hex_byte_pack(p, addr[i]);
329 if (!(flags & SPECIAL) && i != 5)
330 *p++ = ':';
331 }
332 *p = '\0';
333
334 return string(buf, end, mac_addr, field_width, precision,
335 flags & ~SPECIAL);
336 }
337
ip6_addr_string(char * buf,char * end,u8 * addr,int field_width,int precision,int flags)338 static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
339 int precision, int flags)
340 {
341 /* (8 * 4 hex digits), 7 colons and trailing zero */
342 char ip6_addr[8 * 5];
343 char *p = ip6_addr;
344 int i;
345
346 for (i = 0; i < 8; i++) {
347 p = hex_byte_pack(p, addr[2 * i]);
348 p = hex_byte_pack(p, addr[2 * i + 1]);
349 if (!(flags & SPECIAL) && i != 7)
350 *p++ = ':';
351 }
352 *p = '\0';
353
354 return string(buf, end, ip6_addr, field_width, precision,
355 flags & ~SPECIAL);
356 }
357
ip4_addr_string(char * buf,char * end,u8 * addr,int field_width,int precision,int flags)358 static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
359 int precision, int flags)
360 {
361 /* (4 * 3 decimal digits), 3 dots and trailing zero */
362 char ip4_addr[4 * 4];
363 char temp[3]; /* hold each IP quad in reverse order */
364 char *p = ip4_addr;
365 int i, digits;
366
367 for (i = 0; i < 4; i++) {
368 digits = put_dec_trunc(temp, addr[i]) - temp;
369 /* reverse the digits in the quad */
370 while (digits--)
371 *p++ = temp[digits];
372 if (i != 3)
373 *p++ = '.';
374 }
375 *p = '\0';
376
377 return string(buf, end, ip4_addr, field_width, precision,
378 flags & ~SPECIAL);
379 }
380 #endif
381
382 #ifdef CONFIG_LIB_UUID
383 /*
384 * This works (roughly) the same way as linux's, but we currently always
385 * print lower-case (ie. we just keep %pUB and %pUL for compat with linux),
386 * mostly just because that is what uuid_bin_to_str() supports.
387 *
388 * %pUb: 01020304-0506-0708-090a-0b0c0d0e0f10
389 * %pUl: 04030201-0605-0807-090a-0b0c0d0e0f10
390 */
uuid_string(char * buf,char * end,u8 * addr,int field_width,int precision,int flags,const char * fmt)391 static char *uuid_string(char *buf, char *end, u8 *addr, int field_width,
392 int precision, int flags, const char *fmt)
393 {
394 char uuid[UUID_STR_LEN + 1];
395 int str_format = UUID_STR_FORMAT_STD;
396
397 switch (*(++fmt)) {
398 case 'L':
399 case 'l':
400 str_format = UUID_STR_FORMAT_GUID;
401 break;
402 case 'B':
403 case 'b':
404 /* this is the default */
405 break;
406 default:
407 break;
408 }
409
410 uuid_bin_to_str(addr, uuid, str_format);
411
412 return string(buf, end, uuid, field_width, precision, flags);
413 }
414 #endif
415
416 /*
417 * Show a '%p' thing. A kernel extension is that the '%p' is followed
418 * by an extra set of alphanumeric characters that are extended format
419 * specifiers.
420 *
421 * Right now we handle:
422 *
423 * - 'M' For a 6-byte MAC address, it prints the address in the
424 * usual colon-separated hex notation
425 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated
426 * decimal for v4 and colon separated network-order 16 bit hex for v6)
427 * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is
428 * currently the same
429 *
430 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
431 * function pointers are really function descriptors, which contain a
432 * pointer to the real address.
433 */
pointer(const char * fmt,char * buf,char * end,void * ptr,int field_width,int precision,int flags)434 static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
435 int field_width, int precision, int flags)
436 {
437 u64 num = (uintptr_t)ptr;
438
439 /*
440 * Being a boot loader, we explicitly allow pointers to
441 * (physical) address null.
442 */
443 #if 0
444 if (!ptr)
445 return string(buf, end, "(null)", field_width, precision,
446 flags);
447 #endif
448
449 switch (*fmt) {
450 #if defined(CONFIG_EFI_LOADER) && \
451 !defined(CONFIG_SPL_BUILD) && !defined(API_BUILD)
452 case 'D':
453 return device_path_string(buf, end, ptr, field_width,
454 precision, flags);
455 #endif
456 #ifdef CONFIG_CMD_NET
457 case 'a':
458 flags |= SPECIAL | ZEROPAD;
459
460 switch (fmt[1]) {
461 case 'p':
462 default:
463 field_width = sizeof(phys_addr_t) * 2 + 2;
464 num = *(phys_addr_t *)ptr;
465 break;
466 }
467 break;
468 case 'm':
469 flags |= SPECIAL;
470 /* Fallthrough */
471 case 'M':
472 return mac_address_string(buf, end, ptr, field_width,
473 precision, flags);
474 case 'i':
475 flags |= SPECIAL;
476 /* Fallthrough */
477 case 'I':
478 if (fmt[1] == '6')
479 return ip6_addr_string(buf, end, ptr, field_width,
480 precision, flags);
481 if (fmt[1] == '4')
482 return ip4_addr_string(buf, end, ptr, field_width,
483 precision, flags);
484 flags &= ~SPECIAL;
485 break;
486 #endif
487 #ifdef CONFIG_LIB_UUID
488 case 'U':
489 return uuid_string(buf, end, ptr, field_width, precision,
490 flags, fmt);
491 #endif
492 default:
493 break;
494 }
495 flags |= SMALL;
496 if (field_width == -1) {
497 field_width = 2*sizeof(void *);
498 flags |= ZEROPAD;
499 }
500 return number(buf, end, num, 16, field_width, precision, flags);
501 }
502
vsnprintf_internal(char * buf,size_t size,const char * fmt,va_list args)503 static int vsnprintf_internal(char *buf, size_t size, const char *fmt,
504 va_list args)
505 {
506 u64 num;
507 int base;
508 char *str;
509
510 int flags; /* flags to number() */
511
512 int field_width; /* width of output field */
513 int precision; /* min. # of digits for integers; max
514 number of chars for from string */
515 int qualifier; /* 'h', 'l', or 'L' for integer fields */
516 /* 'z' support added 23/7/1999 S.H. */
517 /* 'z' changed to 'Z' --davidm 1/25/99 */
518 /* 't' added for ptrdiff_t */
519 char *end = buf + size;
520
521 /* Make sure end is always >= buf - do we want this in U-Boot? */
522 if (end < buf) {
523 end = ((void *)-1);
524 size = end - buf;
525 }
526 str = buf;
527
528 for (; *fmt ; ++fmt) {
529 if (*fmt != '%') {
530 ADDCH(str, *fmt);
531 continue;
532 }
533
534 /* process flags */
535 flags = 0;
536 repeat:
537 ++fmt; /* this also skips first '%' */
538 switch (*fmt) {
539 case '-':
540 flags |= LEFT;
541 goto repeat;
542 case '+':
543 flags |= PLUS;
544 goto repeat;
545 case ' ':
546 flags |= SPACE;
547 goto repeat;
548 case '#':
549 flags |= SPECIAL;
550 goto repeat;
551 case '0':
552 flags |= ZEROPAD;
553 goto repeat;
554 }
555
556 /* get field width */
557 field_width = -1;
558 if (is_digit(*fmt))
559 field_width = skip_atoi(&fmt);
560 else if (*fmt == '*') {
561 ++fmt;
562 /* it's the next argument */
563 field_width = va_arg(args, int);
564 if (field_width < 0) {
565 field_width = -field_width;
566 flags |= LEFT;
567 }
568 }
569
570 /* get the precision */
571 precision = -1;
572 if (*fmt == '.') {
573 ++fmt;
574 if (is_digit(*fmt))
575 precision = skip_atoi(&fmt);
576 else if (*fmt == '*') {
577 ++fmt;
578 /* it's the next argument */
579 precision = va_arg(args, int);
580 }
581 if (precision < 0)
582 precision = 0;
583 }
584
585 /* get the conversion qualifier */
586 qualifier = -1;
587 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
588 *fmt == 'Z' || *fmt == 'z' || *fmt == 't') {
589 qualifier = *fmt;
590 ++fmt;
591 if (qualifier == 'l' && *fmt == 'l') {
592 qualifier = 'L';
593 ++fmt;
594 }
595 }
596
597 /* default base */
598 base = 10;
599
600 switch (*fmt) {
601 case 'c':
602 if (!(flags & LEFT)) {
603 while (--field_width > 0)
604 ADDCH(str, ' ');
605 }
606 ADDCH(str, (unsigned char) va_arg(args, int));
607 while (--field_width > 0)
608 ADDCH(str, ' ');
609 continue;
610
611 case 's':
612 if (qualifier == 'l' && !IS_ENABLED(CONFIG_SPL_BUILD)) {
613 str = string16(str, end, va_arg(args, u16 *),
614 field_width, precision, flags);
615 } else {
616 str = string(str, end, va_arg(args, char *),
617 field_width, precision, flags);
618 }
619 continue;
620
621 case 'p':
622 str = pointer(fmt + 1, str, end,
623 va_arg(args, void *),
624 field_width, precision, flags);
625 if (IS_ERR(str))
626 return PTR_ERR(str);
627 /* Skip all alphanumeric pointer suffixes */
628 while (isalnum(fmt[1]))
629 fmt++;
630 continue;
631
632 case 'n':
633 if (qualifier == 'l') {
634 long *ip = va_arg(args, long *);
635 *ip = (str - buf);
636 } else {
637 int *ip = va_arg(args, int *);
638 *ip = (str - buf);
639 }
640 continue;
641
642 case '%':
643 ADDCH(str, '%');
644 continue;
645
646 /* integer number formats - set up the flags and "break" */
647 case 'o':
648 base = 8;
649 break;
650
651 case 'x':
652 flags |= SMALL;
653 case 'X':
654 base = 16;
655 break;
656
657 case 'd':
658 case 'i':
659 flags |= SIGN;
660 case 'u':
661 break;
662
663 default:
664 ADDCH(str, '%');
665 if (*fmt)
666 ADDCH(str, *fmt);
667 else
668 --fmt;
669 continue;
670 }
671 if (qualifier == 'L') /* "quad" for 64 bit variables */
672 num = va_arg(args, unsigned long long);
673 else if (qualifier == 'l') {
674 num = va_arg(args, unsigned long);
675 if (flags & SIGN)
676 num = (signed long) num;
677 } else if (qualifier == 'Z' || qualifier == 'z') {
678 num = va_arg(args, size_t);
679 } else if (qualifier == 't') {
680 num = va_arg(args, ptrdiff_t);
681 } else if (qualifier == 'h') {
682 num = (unsigned short) va_arg(args, int);
683 if (flags & SIGN)
684 num = (signed short) num;
685 } else {
686 num = va_arg(args, unsigned int);
687 if (flags & SIGN)
688 num = (signed int) num;
689 }
690 str = number(str, end, num, base, field_width, precision,
691 flags);
692 }
693
694 if (size > 0) {
695 ADDCH(str, '\0');
696 if (str > end)
697 end[-1] = '\0';
698 --str;
699 }
700 /* the trailing null byte doesn't count towards the total */
701 return str - buf;
702 }
703
vsnprintf(char * buf,size_t size,const char * fmt,va_list args)704 int vsnprintf(char *buf, size_t size, const char *fmt,
705 va_list args)
706 {
707 return vsnprintf_internal(buf, size, fmt, args);
708 }
709
vscnprintf(char * buf,size_t size,const char * fmt,va_list args)710 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
711 {
712 int i;
713
714 i = vsnprintf(buf, size, fmt, args);
715
716 if (likely(i < size))
717 return i;
718 if (size != 0)
719 return size - 1;
720 return 0;
721 }
722
snprintf(char * buf,size_t size,const char * fmt,...)723 int snprintf(char *buf, size_t size, const char *fmt, ...)
724 {
725 va_list args;
726 int i;
727
728 va_start(args, fmt);
729 i = vsnprintf(buf, size, fmt, args);
730 va_end(args);
731
732 return i;
733 }
734
scnprintf(char * buf,size_t size,const char * fmt,...)735 int scnprintf(char *buf, size_t size, const char *fmt, ...)
736 {
737 va_list args;
738 int i;
739
740 va_start(args, fmt);
741 i = vscnprintf(buf, size, fmt, args);
742 va_end(args);
743
744 return i;
745 }
746
747 /**
748 * Format a string and place it in a buffer (va_list version)
749 *
750 * @param buf The buffer to place the result into
751 * @param fmt The format string to use
752 * @param args Arguments for the format string
753 *
754 * The function returns the number of characters written
755 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
756 * buffer overflows.
757 *
758 * If you're not already dealing with a va_list consider using sprintf().
759 */
vsprintf(char * buf,const char * fmt,va_list args)760 int vsprintf(char *buf, const char *fmt, va_list args)
761 {
762 return vsnprintf_internal(buf, INT_MAX, fmt, args);
763 }
764
sprintf(char * buf,const char * fmt,...)765 int sprintf(char *buf, const char *fmt, ...)
766 {
767 va_list args;
768 int i;
769
770 va_start(args, fmt);
771 i = vsprintf(buf, fmt, args);
772 va_end(args);
773 return i;
774 }
775
776 #if CONFIG_IS_ENABLED(PRINTF)
printf(const char * fmt,...)777 int printf(const char *fmt, ...)
778 {
779 va_list args;
780 uint i;
781 char printbuffer[CONFIG_SYS_PBSIZE];
782
783 va_start(args, fmt);
784
785 /*
786 * For this to work, printbuffer must be larger than
787 * anything we ever want to print.
788 */
789 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
790 va_end(args);
791
792 /* Handle error */
793 if (i <= 0)
794 return i;
795 /* Print the string */
796 puts(printbuffer);
797 return i;
798 }
799
vprintf(const char * fmt,va_list args)800 int vprintf(const char *fmt, va_list args)
801 {
802 uint i;
803 char printbuffer[CONFIG_SYS_PBSIZE];
804
805 /*
806 * For this to work, printbuffer must be larger than
807 * anything we ever want to print.
808 */
809 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
810
811 /* Handle error */
812 if (i <= 0)
813 return i;
814 /* Print the string */
815 puts(printbuffer);
816 return i;
817 }
818 #endif
819
simple_itoa(ulong i)820 char *simple_itoa(ulong i)
821 {
822 /* 21 digits plus null terminator, good for 64-bit or smaller ints */
823 static char local[22];
824 char *p = &local[21];
825
826 *p-- = '\0';
827 do {
828 *p-- = '0' + i % 10;
829 i /= 10;
830 } while (i > 0);
831 return p + 1;
832 }
833
834 /* We don't seem to have %'d in U-Boot */
print_grouped_ull(unsigned long long int_val,int digits)835 void print_grouped_ull(unsigned long long int_val, int digits)
836 {
837 char str[21], *s;
838 int grab = 3;
839
840 digits = (digits + 2) / 3;
841 sprintf(str, "%*llu", digits * 3, int_val);
842 for (s = str; *s; s += grab) {
843 if (s != str)
844 putc(s[-1] != ' ' ? ',' : ' ');
845 printf("%.*s", grab, s);
846 grab = 3;
847 }
848 }
849
str2off(const char * p,loff_t * num)850 bool str2off(const char *p, loff_t *num)
851 {
852 char *endptr;
853
854 *num = simple_strtoull(p, &endptr, 16);
855 return *p != '\0' && *endptr == '\0';
856 }
857
str2long(const char * p,ulong * num)858 bool str2long(const char *p, ulong *num)
859 {
860 char *endptr;
861
862 *num = simple_strtoul(p, &endptr, 16);
863 return *p != '\0' && *endptr == '\0';
864 }
865