blob: e14c6ca9f96670e348b1de46e0296d3c648eba39 [file] [log] [blame]
wdenk153d5112002-08-30 11:07:04 +00001/*
2 * linux/lib/vsprintf.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
Simon Glass2189d5f2019-11-14 12:57:20 -07005 * (C) Copyright 2000-2009
6 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
wdenk153d5112002-08-30 11:07:04 +00007 */
8
9/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
10/*
11 * Wirzenius wrote this portably, Torvalds fucked it up :-)
Simon Glass3cce8a52011-10-21 18:51:33 +000012 *
13 * from hush: simple_itoa() was lifted from boa-0.93.15
wdenk153d5112002-08-30 11:07:04 +000014 */
15
wdenk153d5112002-08-30 11:07:04 +000016#include <common.h>
Rob Clark274325c2017-09-09 06:47:41 -040017#include <charset.h>
Heinrich Schuchardt256060e2018-01-10 18:06:08 +010018#include <efi_loader.h>
Dirk Behme47910502009-07-22 17:51:56 +020019#include <div64.h>
Alexey Brodkinf8c987f2018-06-05 17:17:57 +030020#include <hexdump.h>
Heinrich Schuchardt256060e2018-01-10 18:06:08 +010021#include <stdarg.h>
Simon Glassba06b3c2020-05-10 11:39:52 -060022#include <uuid.h>
Simon Glass2189d5f2019-11-14 12:57:20 -070023#include <vsprintf.h>
Heinrich Schuchardt256060e2018-01-10 18:06:08 +010024#include <linux/ctype.h>
25#include <linux/err.h>
26#include <linux/types.h>
27#include <linux/string.h>
28
wdenk153d5112002-08-30 11:07:04 +000029/* we use this so that we can do without the ctype library */
30#define is_digit(c) ((c) >= '0' && (c) <= '9')
31
32static int skip_atoi(const char **s)
33{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000034 int i = 0;
wdenk153d5112002-08-30 11:07:04 +000035
36 while (is_digit(**s))
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000037 i = i * 10 + *((*s)++) - '0';
38
wdenk153d5112002-08-30 11:07:04 +000039 return i;
40}
41
Mike Frysinger6c6166f2009-02-16 23:21:36 -050042/* Decimal conversion is by far the most typical, and is used
43 * for /proc and /sys data. This directly impacts e.g. top performance
44 * with many processes running. We optimize it for speed
45 * using code from
46 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
47 * (with permission from the author, Douglas W. Jones). */
48
49/* Formats correctly any integer in [0,99999].
50 * Outputs from one to five digits depending on input.
51 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000052static char *put_dec_trunc(char *buf, unsigned q)
Mike Frysinger6c6166f2009-02-16 23:21:36 -050053{
54 unsigned d3, d2, d1, d0;
55 d1 = (q>>4) & 0xf;
56 d2 = (q>>8) & 0xf;
57 d3 = (q>>12);
58
59 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
60 q = (d0 * 0xcd) >> 11;
61 d0 = d0 - 10*q;
62 *buf++ = d0 + '0'; /* least significant digit */
63 d1 = q + 9*d3 + 5*d2 + d1;
64 if (d1 != 0) {
65 q = (d1 * 0xcd) >> 11;
66 d1 = d1 - 10*q;
67 *buf++ = d1 + '0'; /* next digit */
68
69 d2 = q + 2*d2;
70 if ((d2 != 0) || (d3 != 0)) {
71 q = (d2 * 0xd) >> 7;
72 d2 = d2 - 10*q;
73 *buf++ = d2 + '0'; /* next digit */
74
75 d3 = q + 4*d3;
76 if (d3 != 0) {
77 q = (d3 * 0xcd) >> 11;
78 d3 = d3 - 10*q;
79 *buf++ = d3 + '0'; /* next digit */
80 if (q != 0)
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000081 *buf++ = q + '0'; /* most sign. digit */
Mike Frysinger6c6166f2009-02-16 23:21:36 -050082 }
83 }
84 }
85 return buf;
86}
87/* Same with if's removed. Always emits five digits */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +000088static char *put_dec_full(char *buf, unsigned q)
Mike Frysinger6c6166f2009-02-16 23:21:36 -050089{
90 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
91 /* but anyway, gcc produces better code with full-sized ints */
92 unsigned d3, d2, d1, d0;
93 d1 = (q>>4) & 0xf;
94 d2 = (q>>8) & 0xf;
95 d3 = (q>>12);
96
Wolfgang Denkc0a14ae2009-04-05 00:27:57 +020097 /*
98 * Possible ways to approx. divide by 10
99 * gcc -O2 replaces multiply with shifts and adds
100 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
101 * (x * 0x67) >> 10: 1100111
102 * (x * 0x34) >> 9: 110100 - same
103 * (x * 0x1a) >> 8: 11010 - same
104 * (x * 0x0d) >> 7: 1101 - same, shortest code (on i386)
105 */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500106
107 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
108 q = (d0 * 0xcd) >> 11;
109 d0 = d0 - 10*q;
110 *buf++ = d0 + '0';
111 d1 = q + 9*d3 + 5*d2 + d1;
112 q = (d1 * 0xcd) >> 11;
113 d1 = d1 - 10*q;
114 *buf++ = d1 + '0';
115
116 d2 = q + 2*d2;
117 q = (d2 * 0xd) >> 7;
118 d2 = d2 - 10*q;
119 *buf++ = d2 + '0';
120
121 d3 = q + 4*d3;
122 q = (d3 * 0xcd) >> 11; /* - shorter code */
123 /* q = (d3 * 0x67) >> 10; - would also work */
124 d3 = d3 - 10*q;
125 *buf++ = d3 + '0';
126 *buf++ = q + '0';
127 return buf;
128}
129/* No inlining helps gcc to use registers better */
Simon Glass6bf67252014-10-15 04:38:34 -0600130static noinline char *put_dec(char *buf, uint64_t num)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500131{
132 while (1) {
133 unsigned rem;
134 if (num < 100000)
135 return put_dec_trunc(buf, num);
136 rem = do_div(num, 100000);
137 buf = put_dec_full(buf, rem);
138 }
139}
140
wdenk153d5112002-08-30 11:07:04 +0000141#define ZEROPAD 1 /* pad with zero */
142#define SIGN 2 /* unsigned/signed long */
143#define PLUS 4 /* show plus */
144#define SPACE 8 /* space if plus */
145#define LEFT 16 /* left justified */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500146#define SMALL 32 /* Must be 32 == 0x20 */
147#define SPECIAL 64 /* 0x */
Simon Glass7f331942023-01-17 10:47:30 -0700148#define ERRSTR 128 /* %dE showing error string if enabled */
wdenk153d5112002-08-30 11:07:04 +0000149
Sonny Rao046a37b2011-11-02 09:52:08 +0000150/*
151 * Macro to add a new character to our output string, but only if it will
152 * fit. The macro moves to the next character position in the output string.
153 */
154#define ADDCH(str, ch) do { \
155 if ((str) < end) \
156 *(str) = (ch); \
157 ++str; \
158 } while (0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000159
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000160static char *number(char *buf, char *end, u64 num,
Sonny Rao046a37b2011-11-02 09:52:08 +0000161 int base, int size, int precision, int type)
wdenk153d5112002-08-30 11:07:04 +0000162{
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500163 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000164 static const char digits[16] = "0123456789ABCDEF";
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500165
166 char tmp[66];
167 char sign;
168 char locase;
169 int need_pfx = ((type & SPECIAL) && base != 10);
wdenk153d5112002-08-30 11:07:04 +0000170 int i;
171
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500172 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
173 * produces same digits or (maybe lowercased) letters */
174 locase = (type & SMALL);
wdenk153d5112002-08-30 11:07:04 +0000175 if (type & LEFT)
176 type &= ~ZEROPAD;
wdenk153d5112002-08-30 11:07:04 +0000177 sign = 0;
178 if (type & SIGN) {
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000179 if ((s64) num < 0) {
wdenk153d5112002-08-30 11:07:04 +0000180 sign = '-';
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000181 num = -(s64) num;
wdenk153d5112002-08-30 11:07:04 +0000182 size--;
183 } else if (type & PLUS) {
184 sign = '+';
185 size--;
186 } else if (type & SPACE) {
187 sign = ' ';
188 size--;
189 }
190 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500191 if (need_pfx) {
192 size--;
wdenk153d5112002-08-30 11:07:04 +0000193 if (base == 16)
wdenk153d5112002-08-30 11:07:04 +0000194 size--;
195 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500196
197 /* generate full string in tmp[], in reverse order */
wdenk153d5112002-08-30 11:07:04 +0000198 i = 0;
199 if (num == 0)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500200 tmp[i++] = '0';
201 /* Generic code, for any base:
202 else do {
203 tmp[i++] = (digits[do_div(num,base)] | locase);
204 } while (num != 0);
205 */
206 else if (base != 10) { /* 8 or 16 */
207 int mask = base - 1;
208 int shift = 3;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000209
210 if (base == 16)
211 shift = 4;
212
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500213 do {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000214 tmp[i++] = (digits[((unsigned char)num) & mask]
215 | locase);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500216 num >>= shift;
217 } while (num);
218 } else { /* base 10 */
219 i = put_dec(tmp, num) - tmp;
220 }
221
222 /* printing 100 using %2d gives "100", not "00" */
wdenk153d5112002-08-30 11:07:04 +0000223 if (i > precision)
224 precision = i;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500225 /* leading space padding */
wdenk153d5112002-08-30 11:07:04 +0000226 size -= precision;
Sonny Rao046a37b2011-11-02 09:52:08 +0000227 if (!(type & (ZEROPAD + LEFT))) {
228 while (--size >= 0)
229 ADDCH(buf, ' ');
230 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500231 /* sign */
wdenk153d5112002-08-30 11:07:04 +0000232 if (sign)
Sonny Rao046a37b2011-11-02 09:52:08 +0000233 ADDCH(buf, sign);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500234 /* "0x" / "0" prefix */
235 if (need_pfx) {
Sonny Rao046a37b2011-11-02 09:52:08 +0000236 ADDCH(buf, '0');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500237 if (base == 16)
Sonny Rao046a37b2011-11-02 09:52:08 +0000238 ADDCH(buf, 'X' | locase);
wdenk153d5112002-08-30 11:07:04 +0000239 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500240 /* zero or space padding */
241 if (!(type & LEFT)) {
242 char c = (type & ZEROPAD) ? '0' : ' ';
Sonny Rao046a37b2011-11-02 09:52:08 +0000243
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500244 while (--size >= 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000245 ADDCH(buf, c);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500246 }
247 /* hmm even more zero padding? */
248 while (i <= --precision)
Sonny Rao046a37b2011-11-02 09:52:08 +0000249 ADDCH(buf, '0');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500250 /* actual digits of result */
251 while (--i >= 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000252 ADDCH(buf, tmp[i]);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500253 /* trailing space padding */
254 while (--size >= 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000255 ADDCH(buf, ' ');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500256 return buf;
wdenk153d5112002-08-30 11:07:04 +0000257}
258
Heinrich Schuchardt04872382022-01-16 11:59:21 +0100259static char *string(char *buf, char *end, const char *s, int field_width,
Sonny Rao046a37b2011-11-02 09:52:08 +0000260 int precision, int flags)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500261{
262 int len, i;
wdenk153d5112002-08-30 11:07:04 +0000263
Kim Phillips0eb25762012-10-29 13:34:36 +0000264 if (s == NULL)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500265 s = "<NULL>";
266
267 len = strnlen(s, precision);
268
269 if (!(flags & LEFT))
270 while (len < field_width--)
Sonny Rao046a37b2011-11-02 09:52:08 +0000271 ADDCH(buf, ' ');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500272 for (i = 0; i < len; ++i)
Sonny Rao046a37b2011-11-02 09:52:08 +0000273 ADDCH(buf, *s++);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500274 while (len < field_width--)
Sonny Rao046a37b2011-11-02 09:52:08 +0000275 ADDCH(buf, ' ');
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500276 return buf;
277}
278
Heinrich Schuchardtfbb3ea82018-08-31 21:31:25 +0200279/* U-Boot uses UTF-16 strings in the EFI context only. */
Simon Glass726cd982021-12-29 11:57:35 -0700280static __maybe_unused char *string16(char *buf, char *end, u16 *s,
281 int field_width, int precision, int flags)
Rob Clark274325c2017-09-09 06:47:41 -0400282{
Simon Glass5b9a5b22022-01-23 12:55:14 -0700283 const u16 *str = s ? s : u"<NULL>";
Heinrich Schuchardt0e66c102019-02-10 11:11:26 +0100284 ssize_t i, len = utf16_strnlen(str, precision);
Rob Clark274325c2017-09-09 06:47:41 -0400285
286 if (!(flags & LEFT))
Heinrich Schuchardt31bd7112018-08-31 21:31:29 +0200287 for (; len < field_width; --field_width)
Rob Clark274325c2017-09-09 06:47:41 -0400288 ADDCH(buf, ' ');
Heinrich Schuchardtfe14f882022-01-29 16:43:20 +0100289 if (buf < end)
290 *buf = 0;
291 for (i = 0; i < len; ++i) {
292 int slen = utf16_utf8_strnlen(str, 1);
Heinrich Schuchardt0e66c102019-02-10 11:11:26 +0100293 s32 s = utf16_get(&str);
294
Heinrich Schuchardt60c44542019-02-15 22:20:53 +0100295 if (s < 0)
296 s = '?';
Heinrich Schuchardtfe14f882022-01-29 16:43:20 +0100297 if (buf + slen < end) {
298 utf8_put(s, &buf);
299 if (buf < end)
300 *buf = 0;
301 } else {
302 buf += slen;
303 }
Heinrich Schuchardt0e66c102019-02-10 11:11:26 +0100304 }
Heinrich Schuchardt31bd7112018-08-31 21:31:29 +0200305 for (; len < field_width; --field_width)
Rob Clark274325c2017-09-09 06:47:41 -0400306 ADDCH(buf, ' ');
Heinrich Schuchardtfe14f882022-01-29 16:43:20 +0100307
Rob Clark274325c2017-09-09 06:47:41 -0400308 return buf;
309}
310
Heinrich Schuchardt64b5ba42019-05-11 09:53:33 +0200311#if CONFIG_IS_ENABLED(EFI_DEVICE_PATH_TO_TEXT)
Heinrich Schuchardt256060e2018-01-10 18:06:08 +0100312static char *device_path_string(char *buf, char *end, void *dp, int field_width,
313 int precision, int flags)
314{
315 u16 *str;
316
Heinrich Schuchardt5f1ce1d2018-01-26 06:30:30 +0100317 /* If dp == NULL output the string '<NULL>' */
Heinrich Schuchardt256060e2018-01-10 18:06:08 +0100318 if (!dp)
Heinrich Schuchardt5f1ce1d2018-01-26 06:30:30 +0100319 return string16(buf, end, dp, field_width, precision, flags);
Heinrich Schuchardt256060e2018-01-10 18:06:08 +0100320
321 str = efi_dp_str((struct efi_device_path *)dp);
322 if (!str)
323 return ERR_PTR(-ENOMEM);
324
325 buf = string16(buf, end, str, field_width, precision, flags);
326 efi_free_pool(str);
327 return buf;
328}
329#endif
330
Sonny Rao046a37b2011-11-02 09:52:08 +0000331static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500332 int precision, int flags)
333{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000334 /* (6 * 2 hex digits), 5 colons and trailing zero */
335 char mac_addr[6 * 3];
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500336 char *p = mac_addr;
337 int i;
338
339 for (i = 0; i < 6; i++) {
Alexey Brodkinf8c987f2018-06-05 17:17:57 +0300340 p = hex_byte_pack(p, addr[i]);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500341 if (!(flags & SPECIAL) && i != 5)
342 *p++ = ':';
343 }
344 *p = '\0';
345
Sonny Rao046a37b2011-11-02 09:52:08 +0000346 return string(buf, end, mac_addr, field_width, precision,
347 flags & ~SPECIAL);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500348}
349
Sonny Rao046a37b2011-11-02 09:52:08 +0000350static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500351 int precision, int flags)
352{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000353 /* (8 * 4 hex digits), 7 colons and trailing zero */
354 char ip6_addr[8 * 5];
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500355 char *p = ip6_addr;
356 int i;
357
358 for (i = 0; i < 8; i++) {
Alexey Brodkinf8c987f2018-06-05 17:17:57 +0300359 p = hex_byte_pack(p, addr[2 * i]);
360 p = hex_byte_pack(p, addr[2 * i + 1]);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500361 if (!(flags & SPECIAL) && i != 7)
362 *p++ = ':';
363 }
364 *p = '\0';
365
Sonny Rao046a37b2011-11-02 09:52:08 +0000366 return string(buf, end, ip6_addr, field_width, precision,
367 flags & ~SPECIAL);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500368}
369
Sonny Rao046a37b2011-11-02 09:52:08 +0000370static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500371 int precision, int flags)
372{
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000373 /* (4 * 3 decimal digits), 3 dots and trailing zero */
374 char ip4_addr[4 * 4];
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500375 char temp[3]; /* hold each IP quad in reverse order */
376 char *p = ip4_addr;
377 int i, digits;
378
379 for (i = 0; i < 4; i++) {
380 digits = put_dec_trunc(temp, addr[i]) - temp;
381 /* reverse the digits in the quad */
382 while (digits--)
383 *p++ = temp[digits];
384 if (i != 3)
385 *p++ = '.';
386 }
387 *p = '\0';
388
Sonny Rao046a37b2011-11-02 09:52:08 +0000389 return string(buf, end, ip4_addr, field_width, precision,
390 flags & ~SPECIAL);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500391}
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500392
Rob Clark22ada0c2017-09-09 06:47:42 -0400393#ifdef CONFIG_LIB_UUID
394/*
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200395 * This works (roughly) the same way as Linux's.
Rob Clark22ada0c2017-09-09 06:47:42 -0400396 *
397 * %pUb: 01020304-0506-0708-090a-0b0c0d0e0f10
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200398 * %pUB: 01020304-0506-0708-090A-0B0C0D0E0F10
Rob Clark22ada0c2017-09-09 06:47:42 -0400399 * %pUl: 04030201-0605-0807-090a-0b0c0d0e0f10
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200400 * %pUL: 04030201-0605-0807-090A-0B0C0D0E0F10
Heinrich Schuchardt04872382022-01-16 11:59:21 +0100401 * %pUs: GUID text representation if known or fallback to %pUl
Rob Clark22ada0c2017-09-09 06:47:42 -0400402 */
403static char *uuid_string(char *buf, char *end, u8 *addr, int field_width,
404 int precision, int flags, const char *fmt)
405{
406 char uuid[UUID_STR_LEN + 1];
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200407 int str_format;
Heinrich Schuchardt04872382022-01-16 11:59:21 +0100408 const char *str;
Rob Clark22ada0c2017-09-09 06:47:42 -0400409
410 switch (*(++fmt)) {
411 case 'L':
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200412 str_format = UUID_STR_FORMAT_GUID | UUID_STR_UPPER_CASE;
413 break;
Rob Clark22ada0c2017-09-09 06:47:42 -0400414 case 'l':
415 str_format = UUID_STR_FORMAT_GUID;
416 break;
417 case 'B':
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200418 str_format = UUID_STR_FORMAT_STD | UUID_STR_UPPER_CASE;
Rob Clark22ada0c2017-09-09 06:47:42 -0400419 break;
Heinrich Schuchardt04872382022-01-16 11:59:21 +0100420 case 's':
421 str = uuid_guid_get_str(addr);
422 if (str)
423 return string(buf, end, str,
424 field_width, precision, flags);
425 str_format = UUID_STR_FORMAT_GUID;
426 break;
Rob Clark22ada0c2017-09-09 06:47:42 -0400427 default:
Heinrich Schuchardt3bad2562019-04-29 08:08:43 +0200428 str_format = UUID_STR_FORMAT_STD;
Rob Clark22ada0c2017-09-09 06:47:42 -0400429 break;
430 }
431
Simon Glassd7ae1602018-06-18 08:08:20 -0600432 if (addr)
433 uuid_bin_to_str(addr, uuid, str_format);
434 else
435 strcpy(uuid, "<NULL>");
Rob Clark22ada0c2017-09-09 06:47:42 -0400436
437 return string(buf, end, uuid, field_width, precision, flags);
438}
439#endif
440
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500441/*
442 * Show a '%p' thing. A kernel extension is that the '%p' is followed
443 * by an extra set of alphanumeric characters that are extended format
444 * specifiers.
445 *
446 * Right now we handle:
447 *
448 * - 'M' For a 6-byte MAC address, it prints the address in the
449 * usual colon-separated hex notation
450 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated
451 * decimal for v4 and colon separated network-order 16 bit hex for v6)
452 * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is
453 * currently the same
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500454 */
Sonny Rao046a37b2011-11-02 09:52:08 +0000455static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
456 int field_width, int precision, int flags)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500457{
Thierry Reding1eebd142014-11-12 18:26:47 -0700458 u64 num = (uintptr_t)ptr;
459
Wolfgang Denkd266f662012-10-30 09:19:52 +0000460 /*
461 * Being a boot loader, we explicitly allow pointers to
462 * (physical) address null.
463 */
464#if 0
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500465 if (!ptr)
Sonny Rao046a37b2011-11-02 09:52:08 +0000466 return string(buf, end, "(null)", field_width, precision,
467 flags);
Wolfgang Denkd266f662012-10-30 09:19:52 +0000468#endif
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500469
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500470 switch (*fmt) {
Heinrich Schuchardt4ddcc4e2018-08-31 21:31:23 +0200471/* Device paths only exist in the EFI context. */
Heinrich Schuchardt64b5ba42019-05-11 09:53:33 +0200472#if CONFIG_IS_ENABLED(EFI_DEVICE_PATH_TO_TEXT) && !defined(API_BUILD)
Heinrich Schuchardt256060e2018-01-10 18:06:08 +0100473 case 'D':
474 return device_path_string(buf, end, ptr, field_width,
475 precision, flags);
476#endif
Thierry Reding1eebd142014-11-12 18:26:47 -0700477 case 'a':
478 flags |= SPECIAL | ZEROPAD;
479
480 switch (fmt[1]) {
481 case 'p':
482 default:
483 field_width = sizeof(phys_addr_t) * 2 + 2;
484 num = *(phys_addr_t *)ptr;
485 break;
486 }
487 break;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500488 case 'm':
489 flags |= SPECIAL;
490 /* Fallthrough */
491 case 'M':
Sonny Rao046a37b2011-11-02 09:52:08 +0000492 return mac_address_string(buf, end, ptr, field_width,
493 precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500494 case 'i':
495 flags |= SPECIAL;
496 /* Fallthrough */
497 case 'I':
Viacheslav Mitrofanovd8071992022-12-02 12:18:03 +0300498 if (IS_ENABLED(CONFIG_IPV6) && fmt[1] == '6')
Sonny Rao046a37b2011-11-02 09:52:08 +0000499 return ip6_addr_string(buf, end, ptr, field_width,
500 precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500501 if (fmt[1] == '4')
Sonny Rao046a37b2011-11-02 09:52:08 +0000502 return ip4_addr_string(buf, end, ptr, field_width,
503 precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500504 flags &= ~SPECIAL;
505 break;
Rob Clark22ada0c2017-09-09 06:47:42 -0400506#ifdef CONFIG_LIB_UUID
507 case 'U':
508 return uuid_string(buf, end, ptr, field_width, precision,
509 flags, fmt);
510#endif
511 default:
512 break;
513 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500514 flags |= SMALL;
515 if (field_width == -1) {
516 field_width = 2*sizeof(void *);
517 flags |= ZEROPAD;
518 }
Thierry Reding1eebd142014-11-12 18:26:47 -0700519 return number(buf, end, num, 16, field_width, precision, flags);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500520}
521
Sonny Rao046a37b2011-11-02 09:52:08 +0000522static int vsnprintf_internal(char *buf, size_t size, const char *fmt,
523 va_list args)
wdenk153d5112002-08-30 11:07:04 +0000524{
Daniel Schwierzeck7b64f662012-09-16 06:55:04 +0000525 u64 num;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500526 int base;
527 char *str;
wdenk153d5112002-08-30 11:07:04 +0000528
529 int flags; /* flags to number() */
530
531 int field_width; /* width of output field */
532 int precision; /* min. # of digits for integers; max
533 number of chars for from string */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500534 int qualifier; /* 'h', 'l', or 'L' for integer fields */
535 /* 'z' support added 23/7/1999 S.H. */
536 /* 'z' changed to 'Z' --davidm 1/25/99 */
537 /* 't' added for ptrdiff_t */
Sonny Rao046a37b2011-11-02 09:52:08 +0000538 char *end = buf + size;
wdenk153d5112002-08-30 11:07:04 +0000539
Sonny Rao046a37b2011-11-02 09:52:08 +0000540 /* Make sure end is always >= buf - do we want this in U-Boot? */
541 if (end < buf) {
542 end = ((void *)-1);
543 size = end - buf;
544 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500545 str = buf;
546
547 for (; *fmt ; ++fmt) {
wdenk153d5112002-08-30 11:07:04 +0000548 if (*fmt != '%') {
Sonny Rao046a37b2011-11-02 09:52:08 +0000549 ADDCH(str, *fmt);
wdenk153d5112002-08-30 11:07:04 +0000550 continue;
551 }
552
553 /* process flags */
554 flags = 0;
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000555repeat:
wdenk153d5112002-08-30 11:07:04 +0000556 ++fmt; /* this also skips first '%' */
557 switch (*fmt) {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000558 case '-':
559 flags |= LEFT;
560 goto repeat;
561 case '+':
562 flags |= PLUS;
563 goto repeat;
564 case ' ':
565 flags |= SPACE;
566 goto repeat;
567 case '#':
568 flags |= SPECIAL;
569 goto repeat;
570 case '0':
571 flags |= ZEROPAD;
572 goto repeat;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500573 }
wdenk153d5112002-08-30 11:07:04 +0000574
575 /* get field width */
576 field_width = -1;
577 if (is_digit(*fmt))
578 field_width = skip_atoi(&fmt);
579 else if (*fmt == '*') {
580 ++fmt;
581 /* it's the next argument */
582 field_width = va_arg(args, int);
583 if (field_width < 0) {
584 field_width = -field_width;
585 flags |= LEFT;
586 }
587 }
588
589 /* get the precision */
590 precision = -1;
591 if (*fmt == '.') {
592 ++fmt;
593 if (is_digit(*fmt))
594 precision = skip_atoi(&fmt);
595 else if (*fmt == '*') {
596 ++fmt;
597 /* it's the next argument */
598 precision = va_arg(args, int);
599 }
600 if (precision < 0)
601 precision = 0;
602 }
603
604 /* get the conversion qualifier */
605 qualifier = -1;
Jean-Christophe PLAGNIOL-VILLARDf354b732008-07-14 14:11:45 +0200606 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500607 *fmt == 'Z' || *fmt == 'z' || *fmt == 't') {
wdenk153d5112002-08-30 11:07:04 +0000608 qualifier = *fmt;
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500609 ++fmt;
610 if (qualifier == 'l' && *fmt == 'l') {
611 qualifier = 'L';
James Yangbf052932008-01-10 16:02:07 -0600612 ++fmt;
613 }
wdenk153d5112002-08-30 11:07:04 +0000614 }
615
616 /* default base */
617 base = 10;
618
619 switch (*fmt) {
620 case 'c':
Sonny Rao046a37b2011-11-02 09:52:08 +0000621 if (!(flags & LEFT)) {
wdenk153d5112002-08-30 11:07:04 +0000622 while (--field_width > 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000623 ADDCH(str, ' ');
624 }
625 ADDCH(str, (unsigned char) va_arg(args, int));
wdenk153d5112002-08-30 11:07:04 +0000626 while (--field_width > 0)
Sonny Rao046a37b2011-11-02 09:52:08 +0000627 ADDCH(str, ' ');
wdenk153d5112002-08-30 11:07:04 +0000628 continue;
629
630 case 's':
Heinrich Schuchardtfbb3ea82018-08-31 21:31:25 +0200631/* U-Boot uses UTF-16 strings in the EFI context only. */
Simon Glassdeda5d52023-02-05 15:39:40 -0700632#if (CONFIG_IS_ENABLED(EFI_LOADER) || IS_ENABLED(CONFIG_EFI_APP)) && \
Simon Glass726cd982021-12-29 11:57:35 -0700633 !defined(API_BUILD)
Heinrich Schuchardtfbb3ea82018-08-31 21:31:25 +0200634 if (qualifier == 'l') {
Rob Clark274325c2017-09-09 06:47:41 -0400635 str = string16(str, end, va_arg(args, u16 *),
636 field_width, precision, flags);
Heinrich Schuchardtfbb3ea82018-08-31 21:31:25 +0200637 } else
638#endif
639 {
Rob Clark274325c2017-09-09 06:47:41 -0400640 str = string(str, end, va_arg(args, char *),
641 field_width, precision, flags);
642 }
wdenk153d5112002-08-30 11:07:04 +0000643 continue;
644
645 case 'p':
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000646 str = pointer(fmt + 1, str, end,
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500647 va_arg(args, void *),
648 field_width, precision, flags);
Heinrich Schuchardt256060e2018-01-10 18:06:08 +0100649 if (IS_ERR(str))
650 return PTR_ERR(str);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500651 /* Skip all alphanumeric pointer suffixes */
652 while (isalnum(fmt[1]))
653 fmt++;
wdenk153d5112002-08-30 11:07:04 +0000654 continue;
655
wdenk153d5112002-08-30 11:07:04 +0000656 case 'n':
657 if (qualifier == 'l') {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000658 long *ip = va_arg(args, long *);
wdenk153d5112002-08-30 11:07:04 +0000659 *ip = (str - buf);
660 } else {
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000661 int *ip = va_arg(args, int *);
wdenk153d5112002-08-30 11:07:04 +0000662 *ip = (str - buf);
663 }
664 continue;
665
666 case '%':
Sonny Rao046a37b2011-11-02 09:52:08 +0000667 ADDCH(str, '%');
wdenk153d5112002-08-30 11:07:04 +0000668 continue;
669
670 /* integer number formats - set up the flags and "break" */
671 case 'o':
672 base = 8;
673 break;
674
wdenk153d5112002-08-30 11:07:04 +0000675 case 'x':
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500676 flags |= SMALL;
Heinrich Schuchardt9ee32a72023-04-01 08:13:42 +0200677 /* fallthrough */
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500678 case 'X':
wdenk153d5112002-08-30 11:07:04 +0000679 base = 16;
680 break;
681
682 case 'd':
Simon Glass3a3543d2023-07-30 11:15:13 -0600683 if (fmt[1] == 'E') {
Simon Glass7f331942023-01-17 10:47:30 -0700684 flags |= ERRSTR;
Simon Glass3a3543d2023-07-30 11:15:13 -0600685 fmt++;
686 }
Heinrich Schuchardt9ee32a72023-04-01 08:13:42 +0200687 /* fallthrough */
wdenk153d5112002-08-30 11:07:04 +0000688 case 'i':
689 flags |= SIGN;
Heinrich Schuchardt9ee32a72023-04-01 08:13:42 +0200690 /* fallthrough */
wdenk153d5112002-08-30 11:07:04 +0000691 case 'u':
692 break;
693
694 default:
Sonny Rao046a37b2011-11-02 09:52:08 +0000695 ADDCH(str, '%');
wdenk153d5112002-08-30 11:07:04 +0000696 if (*fmt)
Sonny Rao046a37b2011-11-02 09:52:08 +0000697 ADDCH(str, *fmt);
wdenk153d5112002-08-30 11:07:04 +0000698 else
699 --fmt;
700 continue;
701 }
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500702 if (qualifier == 'L') /* "quad" for 64 bit variables */
wdenkc40b2952004-03-13 23:29:43 +0000703 num = va_arg(args, unsigned long long);
Heiko Schocher4b142fe2009-12-03 11:21:21 +0100704 else if (qualifier == 'l') {
wdenk153d5112002-08-30 11:07:04 +0000705 num = va_arg(args, unsigned long);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500706 if (flags & SIGN)
707 num = (signed long) num;
Jean-Christophe PLAGNIOL-VILLARDf354b732008-07-14 14:11:45 +0200708 } else if (qualifier == 'Z' || qualifier == 'z') {
709 num = va_arg(args, size_t);
710 } else if (qualifier == 't') {
711 num = va_arg(args, ptrdiff_t);
712 } else if (qualifier == 'h') {
wdenk153d5112002-08-30 11:07:04 +0000713 num = (unsigned short) va_arg(args, int);
714 if (flags & SIGN)
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500715 num = (signed short) num;
716 } else {
wdenk153d5112002-08-30 11:07:04 +0000717 num = va_arg(args, unsigned int);
Mike Frysinger6c6166f2009-02-16 23:21:36 -0500718 if (flags & SIGN)
719 num = (signed int) num;
720 }
Sonny Rao046a37b2011-11-02 09:52:08 +0000721 str = number(str, end, num, base, field_width, precision,
722 flags);
Simon Glass7f331942023-01-17 10:47:30 -0700723 if (IS_ENABLED(CONFIG_ERRNO_STR) && (flags & ERRSTR)) {
724 const char *p;
725
726 ADDCH(str, ':');
727 ADDCH(str, ' ');
728 for (p = errno_str(num); *p; p++)
729 ADDCH(str, *p);
Simon Glass7f331942023-01-17 10:47:30 -0700730 }
wdenk153d5112002-08-30 11:07:04 +0000731 }
Sonny Rao046a37b2011-11-02 09:52:08 +0000732
Sonny Rao046a37b2011-11-02 09:52:08 +0000733 if (size > 0) {
734 ADDCH(str, '\0');
735 if (str > end)
736 end[-1] = '\0';
Darwin Rambo686f60f2013-12-19 15:14:19 -0800737 --str;
Sonny Rao046a37b2011-11-02 09:52:08 +0000738 }
Sonny Rao046a37b2011-11-02 09:52:08 +0000739 /* the trailing null byte doesn't count towards the total */
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000740 return str - buf;
wdenk153d5112002-08-30 11:07:04 +0000741}
742
Sonny Rao046a37b2011-11-02 09:52:08 +0000743int vsnprintf(char *buf, size_t size, const char *fmt,
744 va_list args)
745{
746 return vsnprintf_internal(buf, size, fmt, args);
747}
748
Sonny Rao046a37b2011-11-02 09:52:08 +0000749int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
750{
751 int i;
752
753 i = vsnprintf(buf, size, fmt, args);
754
755 if (likely(i < size))
756 return i;
757 if (size != 0)
758 return size - 1;
759 return 0;
760}
761
Sonny Rao046a37b2011-11-02 09:52:08 +0000762int snprintf(char *buf, size_t size, const char *fmt, ...)
763{
764 va_list args;
765 int i;
766
767 va_start(args, fmt);
768 i = vsnprintf(buf, size, fmt, args);
769 va_end(args);
770
771 return i;
772}
773
Sonny Rao046a37b2011-11-02 09:52:08 +0000774int scnprintf(char *buf, size_t size, const char *fmt, ...)
775{
776 va_list args;
777 int i;
778
779 va_start(args, fmt);
780 i = vscnprintf(buf, size, fmt, args);
781 va_end(args);
782
783 return i;
784}
Sonny Rao046a37b2011-11-02 09:52:08 +0000785
786/**
787 * Format a string and place it in a buffer (va_list version)
788 *
789 * @param buf The buffer to place the result into
790 * @param fmt The format string to use
791 * @param args Arguments for the format string
792 *
793 * The function returns the number of characters written
794 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
795 * buffer overflows.
796 *
797 * If you're not already dealing with a va_list consider using sprintf().
798 */
799int vsprintf(char *buf, const char *fmt, va_list args)
800{
801 return vsnprintf_internal(buf, INT_MAX, fmt, args);
802}
803
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000804int sprintf(char *buf, const char *fmt, ...)
wdenk153d5112002-08-30 11:07:04 +0000805{
806 va_list args;
807 int i;
808
809 va_start(args, fmt);
Daniel Schwierzeck8acdae62012-09-16 06:55:03 +0000810 i = vsprintf(buf, fmt, args);
wdenk153d5112002-08-30 11:07:04 +0000811 va_end(args);
812 return i;
813}
814
Alex Kiernan4f1eed72018-04-19 04:32:55 +0000815#if CONFIG_IS_ENABLED(PRINTF)
Stefan Roese7d9cde12015-11-23 07:00:22 +0100816int printf(const char *fmt, ...)
817{
818 va_list args;
819 uint i;
Stefan Roese7d9cde12015-11-23 07:00:22 +0100820
821 va_start(args, fmt);
Rasmus Villemoes97587782021-05-28 00:20:44 +0200822 i = vprintf(fmt, args);
Stefan Roese7d9cde12015-11-23 07:00:22 +0100823 va_end(args);
824
Stefan Roese7d9cde12015-11-23 07:00:22 +0100825 return i;
826}
827
828int vprintf(const char *fmt, va_list args)
829{
830 uint i;
831 char printbuffer[CONFIG_SYS_PBSIZE];
832
833 /*
834 * For this to work, printbuffer must be larger than
835 * anything we ever want to print.
836 */
837 i = vscnprintf(printbuffer, sizeof(printbuffer), fmt, args);
838
Heinrich Schuchardt256060e2018-01-10 18:06:08 +0100839 /* Handle error */
840 if (i <= 0)
841 return i;
Stefan Roese7d9cde12015-11-23 07:00:22 +0100842 /* Print the string */
843 puts(printbuffer);
844 return i;
845}
Alex Kiernan4f1eed72018-04-19 04:32:55 +0000846#endif
Simon Glass66312372015-02-27 22:06:32 -0700847
Simon Glass4a255ea2021-10-14 12:48:07 -0600848static char local_toa[22];
849
Simon Glass3cce8a52011-10-21 18:51:33 +0000850char *simple_itoa(ulong i)
851{
852 /* 21 digits plus null terminator, good for 64-bit or smaller ints */
Simon Glass4a255ea2021-10-14 12:48:07 -0600853 char *p = &local_toa[21];
Simon Glass3cce8a52011-10-21 18:51:33 +0000854
855 *p-- = '\0';
856 do {
857 *p-- = '0' + i % 10;
858 i /= 10;
859 } while (i > 0);
860 return p + 1;
861}
Simon Glassb8bcaa32013-06-11 11:14:38 -0700862
Simon Glass4a255ea2021-10-14 12:48:07 -0600863char *simple_xtoa(ulong num)
864{
865 /* 16 digits plus nul terminator, good for 64-bit or smaller ints */
866 char *p = &local_toa[17];
867
868 *--p = '\0';
869 do {
870 p -= 2;
871 hex_byte_pack(p, num & 0xff);
872 num >>= 8;
873 } while (num > 0);
874
875 return p;
876}
877
Simon Glassb8bcaa32013-06-11 11:14:38 -0700878/* We don't seem to have %'d in U-Boot */
879void print_grouped_ull(unsigned long long int_val, int digits)
880{
881 char str[21], *s;
882 int grab = 3;
883
884 digits = (digits + 2) / 3;
885 sprintf(str, "%*llu", digits * 3, int_val);
886 for (s = str; *s; s += grab) {
887 if (s != str)
888 putc(s[-1] != ' ' ? ',' : ' ');
889 printf("%.*s", grab, s);
890 grab = 3;
891 }
892}
Heiko Schocher09c32802015-04-27 07:42:05 +0200893
894bool str2off(const char *p, loff_t *num)
895{
896 char *endptr;
897
898 *num = simple_strtoull(p, &endptr, 16);
899 return *p != '\0' && *endptr == '\0';
900}
901
902bool str2long(const char *p, ulong *num)
903{
904 char *endptr;
905
Simon Glass7e5f4602021-07-24 09:03:29 -0600906 *num = hextoul(p, &endptr);
Heiko Schocher09c32802015-04-27 07:42:05 +0200907 return *p != '\0' && *endptr == '\0';
908}
Simon Glass2189d5f2019-11-14 12:57:20 -0700909
910char *strmhz(char *buf, unsigned long hz)
911{
912 long l, n;
913 long m;
914
915 n = DIV_ROUND_CLOSEST(hz, 1000) / 1000L;
916 l = sprintf(buf, "%ld", n);
917
918 hz -= n * 1000000L;
919 m = DIV_ROUND_CLOSEST(hz, 1000L);
920 if (m != 0)
921 sprintf(buf + l, ".%03ld", m);
922
923 return buf;
924}