1 /*
2  * Taken from Linux kernel's linux/lib/vsprintf.c
3  * and somewhat simplified.
4  *
5  * Copyright (C) 1991, 1992  Linus Torvalds
6  */
7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8 /*
9  * Wirzenius wrote this portably, Torvalds fucked it up :-)
10  */
11 
12 #include "defs.h"
13 
14 #if USE_CUSTOM_PRINTF
15 
16 #include <stdarg.h>
17 #include <limits.h>
18 
19 #ifndef HAVE_FPUTS_UNLOCKED
20 # define fputs_unlocked fputs
21 #endif
22 
23 #define noinline_for_stack /*nothing*/
24 #define likely(expr)       (expr)
25 #define unlikely(expr)     (expr)
26 
27 #define do_div(n, d)       ({ __typeof(num) t = n % d; n /= d; t; })
28 
29 #undef isdigit
30 #define isdigit(a) ((unsigned char)((a) - '0') <= 9)
31 
32 static inline
skip_atoi(const char ** s)33 int skip_atoi(const char **s)
34 {
35 	int i = 0;
36 	const char *p = *s;
37 
38 	while (isdigit(*p))
39 		i = i*10 + *p++ - '0';
40 
41 	*s = p;
42 	return i;
43 }
44 
45 /* Decimal conversion is by far the most typical, and is used
46  * for /proc and /sys data. This directly impacts e.g. top performance
47  * with many processes running. We optimize it for speed
48  * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
49  * (with permission from the author, Douglas W. Jones).
50  */
51 
52 #if LONG_MAX != 0x7fffffffUL || LLONG_MAX != 0x7fffffffffffffffULL
53 /* Formats correctly any integer in [0, 999999999] */
54 static noinline_for_stack
put_dec_full9(char * buf,unsigned q)55 char *put_dec_full9(char *buf, unsigned q)
56 {
57 	unsigned r;
58 
59 	/* Possible ways to approx. divide by 10
60 	 * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
61 	 * (x * 0xcccd) >> 19     x <      81920 (x < 262149 when 64-bit mul)
62 	 * (x * 0x6667) >> 18     x <      43699
63 	 * (x * 0x3334) >> 17     x <      16389
64 	 * (x * 0x199a) >> 16     x <      16389
65 	 * (x * 0x0ccd) >> 15     x <      16389
66 	 * (x * 0x0667) >> 14     x <       2739
67 	 * (x * 0x0334) >> 13     x <       1029
68 	 * (x * 0x019a) >> 12     x <       1029
69 	 * (x * 0x00cd) >> 11     x <       1029 shorter code than * 0x67 (on i386)
70 	 * (x * 0x0067) >> 10     x <        179
71 	 * (x * 0x0034) >>  9     x <         69 same
72 	 * (x * 0x001a) >>  8     x <         69 same
73 	 * (x * 0x000d) >>  7     x <         69 same, shortest code (on i386)
74 	 * (x * 0x0007) >>  6     x <         19
75 	 * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
76 	 */
77 	r      = (q * (uint64_t)0x1999999a) >> 32;
78 	*buf++ = (q - 10 * r) + '0'; /* 1 */
79 	q      = (r * (uint64_t)0x1999999a) >> 32;
80 	*buf++ = (r - 10 * q) + '0'; /* 2 */
81 	r      = (q * (uint64_t)0x1999999a) >> 32;
82 	*buf++ = (q - 10 * r) + '0'; /* 3 */
83 	q      = (r * (uint64_t)0x1999999a) >> 32;
84 	*buf++ = (r - 10 * q) + '0'; /* 4 */
85 	r      = (q * (uint64_t)0x1999999a) >> 32;
86 	*buf++ = (q - 10 * r) + '0'; /* 5 */
87 	/* Now value is under 10000, can avoid 64-bit multiply */
88 	q      = (r * 0x199a) >> 16;
89 	*buf++ = (r - 10 * q)  + '0'; /* 6 */
90 	r      = (q * 0xcd) >> 11;
91 	*buf++ = (q - 10 * r)  + '0'; /* 7 */
92 	q      = (r * 0xcd) >> 11;
93 	*buf++ = (r - 10 * q) + '0'; /* 8 */
94 	*buf++ = q + '0'; /* 9 */
95 	return buf;
96 }
97 #endif
98 
99 /* Similar to above but do not pad with zeros.
100  * Code can be easily arranged to print 9 digits too, but our callers
101  * always call put_dec_full9() instead when the number has 9 decimal digits.
102  */
103 static noinline_for_stack
put_dec_trunc8(char * buf,unsigned r)104 char *put_dec_trunc8(char *buf, unsigned r)
105 {
106 	unsigned q;
107 
108 	/* Copy of previous function's body with added early returns */
109 	q      = (r * (uint64_t)0x1999999a) >> 32;
110 	*buf++ = (r - 10 * q) + '0'; /* 2 */
111 	if (q == 0) return buf;
112 	r      = (q * (uint64_t)0x1999999a) >> 32;
113 	*buf++ = (q - 10 * r) + '0'; /* 3 */
114 	if (r == 0) return buf;
115 	q      = (r * (uint64_t)0x1999999a) >> 32;
116 	*buf++ = (r - 10 * q) + '0'; /* 4 */
117 	if (q == 0) return buf;
118 	r      = (q * (uint64_t)0x1999999a) >> 32;
119 	*buf++ = (q - 10 * r) + '0'; /* 5 */
120 	if (r == 0) return buf;
121 	q      = (r * 0x199a) >> 16;
122 	*buf++ = (r - 10 * q)  + '0'; /* 6 */
123 	if (q == 0) return buf;
124 	r      = (q * 0xcd) >> 11;
125 	*buf++ = (q - 10 * r)  + '0'; /* 7 */
126 	if (r == 0) return buf;
127 	q      = (r * 0xcd) >> 11;
128 	*buf++ = (r - 10 * q) + '0'; /* 8 */
129 	if (q == 0) return buf;
130 	*buf++ = q + '0'; /* 9 */
131 	return buf;
132 }
133 
134 /* There are two algorithms to print larger numbers.
135  * One is generic: divide by 1000000000 and repeatedly print
136  * groups of (up to) 9 digits. It's conceptually simple,
137  * but requires a (unsigned long long) / 1000000000 division.
138  *
139  * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
140  * manipulates them cleverly and generates groups of 4 decimal digits.
141  * It so happens that it does NOT require long long division.
142  *
143  * If long is > 32 bits, division of 64-bit values is relatively easy,
144  * and we will use the first algorithm.
145  * If long long is > 64 bits (strange architecture with VERY large long long),
146  * second algorithm can't be used, and we again use the first one.
147  *
148  * Else (if long is 32 bits and long long is 64 bits) we use second one.
149  */
150 
151 #if LONG_MAX != 0x7fffffffUL || LLONG_MAX != 0x7fffffffffffffffULL
152 
153 /* First algorithm: generic */
154 
155 static
put_dec(char * buf,unsigned long long n)156 char *put_dec(char *buf, unsigned long long n)
157 {
158 	if (n >= 100*1000*1000) {
159 		while (n >= 1000*1000*1000)
160 			buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
161 		if (n >= 100*1000*1000)
162 			return put_dec_full9(buf, n);
163 	}
164 	return put_dec_trunc8(buf, n);
165 }
166 
167 #else
168 
169 /* Second algorithm: valid only for 64-bit long longs */
170 
171 static noinline_for_stack
put_dec_full4(char * buf,unsigned q)172 char *put_dec_full4(char *buf, unsigned q)
173 {
174 	unsigned r;
175 	r      = (q * 0xcccd) >> 19;
176 	*buf++ = (q - 10 * r) + '0';
177 	q      = (r * 0x199a) >> 16;
178 	*buf++ = (r - 10 * q)  + '0';
179 	r      = (q * 0xcd) >> 11;
180 	*buf++ = (q - 10 * r)  + '0';
181 	*buf++ = r + '0';
182 	return buf;
183 }
184 
185 /* Based on code by Douglas W. Jones found at
186  * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
187  * (with permission from the author).
188  * Performs no 64-bit division and hence should be fast on 32-bit machines.
189  */
190 static
put_dec(char * buf,unsigned long long n)191 char *put_dec(char *buf, unsigned long long n)
192 {
193 	uint32_t d3, d2, d1, q, h;
194 
195 	if (n < 100*1000*1000)
196 		return put_dec_trunc8(buf, n);
197 
198 	d1  = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
199 	h   = (n >> 32);
200 	d2  = (h      ) & 0xffff;
201 	d3  = (h >> 16); /* implicit "& 0xffff" */
202 
203 	q   = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
204 
205 	buf = put_dec_full4(buf, q % 10000);
206 	q   = q / 10000;
207 
208 	d1  = q + 7671 * d3 + 9496 * d2 + 6 * d1;
209 	buf = put_dec_full4(buf, d1 % 10000);
210 	q   = d1 / 10000;
211 
212 	d2  = q + 4749 * d3 + 42 * d2;
213 	buf = put_dec_full4(buf, d2 % 10000);
214 	q   = d2 / 10000;
215 
216 	d3  = q + 281 * d3;
217 	if (!d3)
218 		goto done;
219 	buf = put_dec_full4(buf, d3 % 10000);
220 	q   = d3 / 10000;
221 	if (!q)
222 		goto done;
223 	buf = put_dec_full4(buf, q);
224  done:
225 	while (buf[-1] == '0')
226 		--buf;
227 
228 	return buf;
229 }
230 
231 #endif
232 
233 /*
234  * For strace, the following formats are not supported:
235  * %h[h]u, %zu, %tu  - use [unsigned] int/long/long long fmt instead
236  * %8.4u  - no precision field for integers allowed (ok for strings)
237  * %+d, % d  - no forced sign or force "space positive" sign
238  * %-07u  - use %-7u instead
239  * %X  - works as %x
240  */
241 
242 #define ZEROPAD	1		/* pad with zero */
243 #define SIGN	2		/* unsigned/signed long */
244 //#define PLUS	4		/* show plus */
245 //#define SPACE	8		/* space if plus */
246 #define LEFT	16		/* left justified */
247 //#deefine SMALL	32		/* use lowercase in hex (must be 32 == 0x20) */
248 #define SPECIAL	64		/* prefix hex with "0x", octal with "0" */
249 
250 enum format_type {
251 	FORMAT_TYPE_NONE, /* Just a string part */
252 	FORMAT_TYPE_WIDTH,
253 	FORMAT_TYPE_PRECISION,
254 	FORMAT_TYPE_CHAR,
255 	FORMAT_TYPE_STR,
256 	FORMAT_TYPE_PTR,
257 	FORMAT_TYPE_PERCENT_CHAR,
258 	FORMAT_TYPE_INVALID,
259 	FORMAT_TYPE_LONG_LONG,
260 	FORMAT_TYPE_ULONG,
261 	FORMAT_TYPE_LONG,
262 	FORMAT_TYPE_UINT,
263 	FORMAT_TYPE_INT,
264 };
265 
266 struct printf_spec {
267 	uint8_t	type;		/* format_type enum */
268 	uint8_t	flags;		/* flags to number() */
269 	uint8_t	base;		/* number base, 8, 10 or 16 only */
270 	uint8_t	qualifier;	/* number qualifier, one of 'hHlLtzZ' */
271 	int	field_width;	/* width of output field */
272 	int	precision;	/* # of digits/chars */
273 };
274 
275 static noinline_for_stack
number(char * buf,char * end,unsigned long long num,struct printf_spec spec)276 char *number(char *buf, char *end, unsigned long long num,
277 	     struct printf_spec spec)
278 {
279 	/* we are called with base 8, 10 or 16, only, thus don't need "G..."  */
280 	static const char digits[16] = "0123456789abcdef"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
281 
282 	char tmp[sizeof(long long)*3 + 4];
283 	char sign;
284 	int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
285 	int i;
286 
287 	/* We may overflow the buf. Crudely check for it */
288 	i = sizeof(long long)*3 + 4;
289 	if (i < spec.field_width)
290 		i = spec.field_width;
291 	if ((end - buf) <= i)
292 		return buf + i;
293 
294 //we don't use formats like "%-07u"
295 //	if (spec.flags & LEFT)
296 //		spec.flags &= ~ZEROPAD;
297 	sign = 0;
298 	if (spec.flags & SIGN) {
299 		if ((signed long long)num < 0) {
300 			sign = '-';
301 			num = -(signed long long)num;
302 			spec.field_width--;
303 //		} else if (spec.flags & PLUS) {
304 //			sign = '+';
305 //			spec.field_width--;
306 //		} else if (spec.flags & SPACE) {
307 //			sign = ' ';
308 //			spec.field_width--;
309 		}
310 	}
311 	if (need_pfx) {
312 		spec.field_width--;
313 		if (spec.base == 16)
314 			spec.field_width--;
315 	}
316 
317 	/* generate full string in tmp[], in reverse order */
318 	i = 0;
319 	if (num < spec.base)
320 		tmp[i++] = digits[num];
321 	/* Generic code, for any base:
322 	else do {
323 		tmp[i++] = (digits[do_div(num,base)]);
324 	} while (num != 0);
325 	*/
326 	else if (spec.base != 10) { /* 8 or 16 */
327 		int mask = spec.base - 1;
328 		int shift = 3;
329 
330 		if (spec.base == 16)
331 			shift = 4;
332 		do {
333 			tmp[i++] = digits[((unsigned char)num) & mask];
334 			num >>= shift;
335 		} while (num);
336 	} else { /* base 10 */
337 		i = put_dec(tmp, num) - tmp;
338 	}
339 
340 //spec.precision is assumed 0 ("not specified")
341 //	/* printing 100 using %2d gives "100", not "00" */
342 //	if (i > spec.precision)
343 //		spec.precision = i;
344 //	/* leading space padding */
345 //	spec.field_width -= spec.precision;
346 	spec.field_width -= i;
347 	if (!(spec.flags & (ZEROPAD+LEFT))) {
348 		while (--spec.field_width >= 0) {
349 			///if (buf < end)
350 				*buf = ' ';
351 			++buf;
352 		}
353 	}
354 	/* sign */
355 	if (sign) {
356 		///if (buf < end)
357 			*buf = sign;
358 		++buf;
359 	}
360 	/* "0x" / "0" prefix */
361 	if (need_pfx) {
362 		///if (buf < end)
363 			*buf = '0';
364 		++buf;
365 		if (spec.base == 16) {
366 			///if (buf < end)
367 				*buf = 'x';
368 			++buf;
369 		}
370 	}
371 	/* zero or space padding */
372 	if (!(spec.flags & LEFT)) {
373 		char c = (spec.flags & ZEROPAD) ? '0' : ' ';
374 		while (--spec.field_width >= 0) {
375 			///if (buf < end)
376 				*buf = c;
377 			++buf;
378 		}
379 	}
380 //	/* hmm even more zero padding? */
381 //	while (i <= --spec.precision) {
382 //		///if (buf < end)
383 //			*buf = '0';
384 //		++buf;
385 //	}
386 	/* actual digits of result */
387 	while (--i >= 0) {
388 		///if (buf < end)
389 			*buf = tmp[i];
390 		++buf;
391 	}
392 	/* trailing space padding */
393 	while (--spec.field_width >= 0) {
394 		///if (buf < end)
395 			*buf = ' ';
396 		++buf;
397 	}
398 
399 	return buf;
400 }
401 
402 static noinline_for_stack
string(char * buf,char * end,const char * s,struct printf_spec spec)403 char *string(char *buf, char *end, const char *s, struct printf_spec spec)
404 {
405 	int len, i;
406 
407 	if (!s)
408 		s = "(null)";
409 
410 	len = strnlen(s, spec.precision);
411 
412 	/* We may overflow the buf. Crudely check for it */
413 	i = len;
414 	if (i < spec.field_width)
415 		i = spec.field_width;
416 	if ((end - buf) <= i)
417 		return buf + i;
418 
419 	if (!(spec.flags & LEFT)) {
420 		while (len < spec.field_width--) {
421 			///if (buf < end)
422 				*buf = ' ';
423 			++buf;
424 		}
425 	}
426 	for (i = 0; i < len; ++i) {
427 		///if (buf < end)
428 			*buf = *s;
429 		++buf; ++s;
430 	}
431 	while (len < spec.field_width--) {
432 		///if (buf < end)
433 			*buf = ' ';
434 		++buf;
435 	}
436 
437 	return buf;
438 }
439 
440 static noinline_for_stack
pointer(const char * fmt,char * buf,char * end,void * ptr,struct printf_spec spec)441 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
442 	      struct printf_spec spec)
443 {
444 //	spec.flags |= SMALL;
445 	if (spec.field_width == -1) {
446 		spec.field_width = 2 * sizeof(void *);
447 		spec.flags |= ZEROPAD;
448 	}
449 	spec.base = 16;
450 
451 	return number(buf, end, (unsigned long) ptr, spec);
452 }
453 
454 /*
455  * Helper function to decode printf style format.
456  * Each call decode a token from the format and return the
457  * number of characters read (or likely the delta where it wants
458  * to go on the next call).
459  * The decoded token is returned through the parameters
460  *
461  * 'h', 'l', or 'L' for integer fields
462  * 'z' support added 23/7/1999 S.H.
463  * 'z' changed to 'Z' --davidm 1/25/99
464  * 't' added for ptrdiff_t
465  *
466  * @fmt: the format string
467  * @type of the token returned
468  * @flags: various flags such as +, -, # tokens..
469  * @field_width: overwritten width
470  * @base: base of the number (octal, hex, ...)
471  * @precision: precision of a number
472  * @qualifier: qualifier of a number (long, size_t, ...)
473  */
474 static noinline_for_stack
format_decode(const char * fmt,struct printf_spec * spec)475 int format_decode(const char *fmt, struct printf_spec *spec)
476 {
477 	const char *start = fmt;
478 
479 	/* we finished early by reading the field width */
480 	if (spec->type == FORMAT_TYPE_WIDTH) {
481 		if (spec->field_width < 0) {
482 			spec->field_width = -spec->field_width;
483 			spec->flags |= LEFT;
484 		}
485 		spec->type = FORMAT_TYPE_NONE;
486 		goto precision;
487 	}
488 
489 	/* we finished early by reading the precision */
490 	if (spec->type == FORMAT_TYPE_PRECISION) {
491 		if (spec->precision < 0)
492 			spec->precision = 0;
493 
494 		spec->type = FORMAT_TYPE_NONE;
495 		goto qualifier;
496 	}
497 
498 	/* By default */
499 	spec->type = FORMAT_TYPE_NONE;
500 
501 	for (;;) {
502 		if (*fmt == '\0')
503 			return fmt - start;
504 		if (*fmt == '%')
505 			break;
506 		++fmt;
507 	}
508 
509 	/* Return the current non-format string */
510 	if (fmt != start)
511 		return fmt - start;
512 
513 	/* Process flags */
514 	spec->flags = 0;
515 
516 	while (1) { /* this also skips first '%' */
517 		bool found = true;
518 
519 		++fmt;
520 
521 		switch (*fmt) {
522 		case '-': spec->flags |= LEFT;    break;
523 //		case '+': spec->flags |= PLUS;    break;
524 //		case ' ': spec->flags |= SPACE;   break;
525 		case '#': spec->flags |= SPECIAL; break;
526 		case '0': spec->flags |= ZEROPAD; break;
527 		default:  found = false;
528 		}
529 
530 		if (!found)
531 			break;
532 	}
533 
534 	/* get field width */
535 	spec->field_width = -1;
536 
537 	if (isdigit(*fmt))
538 		spec->field_width = skip_atoi(&fmt);
539 	else if (*fmt == '*') {
540 		/* it's the next argument */
541 		spec->type = FORMAT_TYPE_WIDTH;
542 		return ++fmt - start;
543 	}
544 
545 precision:
546 	/* get the precision */
547 	spec->precision = -1;
548 	if (*fmt == '.') {
549 		++fmt;
550 		if (isdigit(*fmt)) {
551 			spec->precision = skip_atoi(&fmt);
552 //			if (spec->precision < 0)
553 //				spec->precision = 0;
554 		} else if (*fmt == '*') {
555 			/* it's the next argument */
556 			spec->type = FORMAT_TYPE_PRECISION;
557 			return ++fmt - start;
558 		}
559 	}
560 
561 qualifier:
562 	/* get the conversion qualifier */
563 	spec->qualifier = -1;
564 	if (*fmt == 'l') {
565 		spec->qualifier = *fmt++;
566 		if (unlikely(spec->qualifier == *fmt)) {
567 			spec->qualifier = 'L';
568 			++fmt;
569 		}
570 	}
571 
572 	/* default base */
573 	spec->base = 10;
574 	switch (*fmt) {
575 	case 'c':
576 		spec->type = FORMAT_TYPE_CHAR;
577 		return ++fmt - start;
578 
579 	case 's':
580 		spec->type = FORMAT_TYPE_STR;
581 		return ++fmt - start;
582 
583 	case 'p':
584 		spec->type = FORMAT_TYPE_PTR;
585 		return ++fmt - start;
586 
587 	case '%':
588 		spec->type = FORMAT_TYPE_PERCENT_CHAR;
589 		return ++fmt - start;
590 
591 	/* integer number formats - set up the flags and "break" */
592 	case 'o':
593 		spec->base = 8;
594 		break;
595 
596 	case 'x':
597 //		spec->flags |= SMALL;
598 
599 	case 'X':
600 		spec->base = 16;
601 		break;
602 
603 	case 'd':
604 	case 'i':
605 		spec->flags |= SIGN;
606 	case 'u':
607 		break;
608 
609 	default:
610 		spec->type = FORMAT_TYPE_INVALID;
611 		return fmt - start;
612 	}
613 
614 	if (spec->qualifier == 'L')
615 		spec->type = FORMAT_TYPE_LONG_LONG;
616 	else if (spec->qualifier == 'l') {
617 		if (spec->flags & SIGN)
618 			spec->type = FORMAT_TYPE_LONG;
619 		else
620 			spec->type = FORMAT_TYPE_ULONG;
621 	} else {
622 		if (spec->flags & SIGN)
623 			spec->type = FORMAT_TYPE_INT;
624 		else
625 			spec->type = FORMAT_TYPE_UINT;
626 	}
627 
628 	return ++fmt - start;
629 }
630 
631 /**
632  * vsnprintf - Format a string and place it in a buffer
633  * @buf: The buffer to place the result into
634  * @size: The size of the buffer, including the trailing null space
635  * @fmt: The format string to use
636  * @args: Arguments for the format string
637  *
638  * The return value is the number of characters which would
639  * be generated for the given input, excluding the trailing
640  * '\0', as per ISO C99. If you want to have the exact
641  * number of characters written into @buf as return value
642  * (not including the trailing '\0'), use vscnprintf(). If the
643  * return is greater than or equal to @size, the resulting
644  * string is truncated.
645  *
646  * If you're not already dealing with a va_list consider using snprintf().
647  */
648 static
kernel_vsnprintf(char * buf,size_t size,const char * fmt,va_list args)649 int kernel_vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
650 {
651 	unsigned long long num;
652 	char *str, *end;
653 	struct printf_spec spec = {0};
654 
655 	str = buf;
656 	end = buf + size;
657 
658 	while (*fmt) {
659 		const char *old_fmt = fmt;
660 		int read = format_decode(fmt, &spec);
661 
662 		fmt += read;
663 
664 		switch (spec.type) {
665 		case FORMAT_TYPE_NONE: {
666 			int copy = read;
667 			if (str < end) {
668 				if (copy > end - str)
669 					copy = end - str;
670 				memcpy(str, old_fmt, copy);
671 			}
672 			str += read;
673 			break;
674 		}
675 
676 		case FORMAT_TYPE_WIDTH:
677 			spec.field_width = va_arg(args, int);
678 			break;
679 
680 		case FORMAT_TYPE_PRECISION:
681 			spec.precision = va_arg(args, int);
682 			break;
683 
684 		case FORMAT_TYPE_CHAR: {
685 			char c;
686 
687 			if (!(spec.flags & LEFT)) {
688 				while (--spec.field_width > 0) {
689 					if (str < end)
690 						*str = ' ';
691 					++str;
692 
693 				}
694 			}
695 			c = (unsigned char) va_arg(args, int);
696 			if (str < end)
697 				*str = c;
698 			++str;
699 			while (--spec.field_width > 0) {
700 				if (str < end)
701 					*str = ' ';
702 				++str;
703 			}
704 			break;
705 		}
706 
707 		case FORMAT_TYPE_STR:
708 			str = string(str, end, va_arg(args, char *), spec);
709 			break;
710 
711 		case FORMAT_TYPE_PTR:
712 			str = pointer(fmt+1, str, end, va_arg(args, void *),
713 				      spec);
714 //			while (isalnum(*fmt))
715 //				fmt++;
716 			break;
717 
718 		case FORMAT_TYPE_PERCENT_CHAR:
719 			if (str < end)
720 				*str = '%';
721 			++str;
722 			break;
723 
724 		case FORMAT_TYPE_INVALID:
725 			if (str < end)
726 				*str = '%';
727 			++str;
728 			break;
729 
730 		default:
731 			switch (spec.type) {
732 			case FORMAT_TYPE_LONG_LONG:
733 				num = va_arg(args, long long);
734 				break;
735 			case FORMAT_TYPE_ULONG:
736 				num = va_arg(args, unsigned long);
737 				break;
738 			case FORMAT_TYPE_LONG:
739 				num = va_arg(args, long);
740 				break;
741 			case FORMAT_TYPE_INT:
742 				num = (int) va_arg(args, int);
743 				break;
744 			default:
745 				num = va_arg(args, unsigned int);
746 			}
747 
748 			str = number(str, end, num, spec);
749 		}
750 	}
751 
752 //	if (size > 0) {
753 		if (str < end)
754 			*str = '\0';
755 //		else
756 //			end[-1] = '\0';
757 //	}
758 
759 	/* the trailing null byte doesn't count towards the total */
760 	return str-buf;
761 
762 }
763 
strace_vfprintf(FILE * fp,const char * fmt,va_list args)764 int strace_vfprintf(FILE *fp, const char *fmt, va_list args)
765 {
766 	static char *buf = NULL;
767 	static unsigned buflen = 0;
768 
769 	int r;
770 	va_list a1;
771 
772 	va_copy(a1, args);
773 	unsigned len = kernel_vsnprintf(buf, buflen, fmt, a1);
774 	va_end(a1);
775 
776 	if (len >= buflen) {
777 		buflen = len + 256;
778 		free(buf);
779 		buf = malloc(buflen);
780 		if (!buf)
781 			die_out_of_memory();
782 		/*len =*/ kernel_vsnprintf(buf, buflen, fmt, args);
783 	}
784 
785 	r = fputs_unlocked(buf, fp);
786 	if (r < 0) return r;
787 	return len;
788 }
789 
790 #endif /* USE_CUSTOM_PRINTF */
791