xref: /openbmc/linux/lib/vsprintf.c (revision 9ac8d3fb)
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 
12 /*
13  * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
14  * - changed to provide snprintf and vsnprintf functions
15  * So Feb  1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>
16  * - scnprintf and vscnprintf
17  */
18 
19 #include <stdarg.h>
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/string.h>
23 #include <linux/ctype.h>
24 #include <linux/kernel.h>
25 #include <linux/kallsyms.h>
26 #include <linux/uaccess.h>
27 #include <linux/ioport.h>
28 
29 #include <asm/page.h>		/* for PAGE_SIZE */
30 #include <asm/div64.h>
31 #include <asm/sections.h>	/* for dereference_function_descriptor() */
32 
33 /* Works only for digits and letters, but small and fast */
34 #define TOLOWER(x) ((x) | 0x20)
35 
36 static unsigned int simple_guess_base(const char *cp)
37 {
38 	if (cp[0] == '0') {
39 		if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
40 			return 16;
41 		else
42 			return 8;
43 	} else {
44 		return 10;
45 	}
46 }
47 
48 /**
49  * simple_strtoul - convert a string to an unsigned long
50  * @cp: The start of the string
51  * @endp: A pointer to the end of the parsed string will be placed here
52  * @base: The number base to use
53  */
54 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
55 {
56 	unsigned long result = 0;
57 
58 	if (!base)
59 		base = simple_guess_base(cp);
60 
61 	if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
62 		cp += 2;
63 
64 	while (isxdigit(*cp)) {
65 		unsigned int value;
66 
67 		value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
68 		if (value >= base)
69 			break;
70 		result = result * base + value;
71 		cp++;
72 	}
73 
74 	if (endp)
75 		*endp = (char *)cp;
76 	return result;
77 }
78 EXPORT_SYMBOL(simple_strtoul);
79 
80 /**
81  * simple_strtol - convert a string to a signed long
82  * @cp: The start of the string
83  * @endp: A pointer to the end of the parsed string will be placed here
84  * @base: The number base to use
85  */
86 long simple_strtol(const char *cp, char **endp, unsigned int base)
87 {
88 	if(*cp == '-')
89 		return -simple_strtoul(cp + 1, endp, base);
90 	return simple_strtoul(cp, endp, base);
91 }
92 EXPORT_SYMBOL(simple_strtol);
93 
94 /**
95  * simple_strtoull - convert a string to an unsigned long long
96  * @cp: The start of the string
97  * @endp: A pointer to the end of the parsed string will be placed here
98  * @base: The number base to use
99  */
100 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
101 {
102 	unsigned long long result = 0;
103 
104 	if (!base)
105 		base = simple_guess_base(cp);
106 
107 	if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
108 		cp += 2;
109 
110 	while (isxdigit(*cp)) {
111 		unsigned int value;
112 
113 		value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
114 		if (value >= base)
115 			break;
116 		result = result * base + value;
117 		cp++;
118 	}
119 
120 	if (endp)
121 		*endp = (char *)cp;
122 	return result;
123 }
124 EXPORT_SYMBOL(simple_strtoull);
125 
126 /**
127  * simple_strtoll - convert a string to a signed long long
128  * @cp: The start of the string
129  * @endp: A pointer to the end of the parsed string will be placed here
130  * @base: The number base to use
131  */
132 long long simple_strtoll(const char *cp, char **endp, unsigned int base)
133 {
134 	if(*cp=='-')
135 		return -simple_strtoull(cp + 1, endp, base);
136 	return simple_strtoull(cp, endp, base);
137 }
138 
139 /**
140  * strict_strtoul - convert a string to an unsigned long strictly
141  * @cp: The string to be converted
142  * @base: The number base to use
143  * @res: The converted result value
144  *
145  * strict_strtoul converts a string to an unsigned long only if the
146  * string is really an unsigned long string, any string containing
147  * any invalid char at the tail will be rejected and -EINVAL is returned,
148  * only a newline char at the tail is acceptible because people generally
149  * change a module parameter in the following way:
150  *
151  * 	echo 1024 > /sys/module/e1000/parameters/copybreak
152  *
153  * echo will append a newline to the tail.
154  *
155  * It returns 0 if conversion is successful and *res is set to the converted
156  * value, otherwise it returns -EINVAL and *res is set to 0.
157  *
158  * simple_strtoul just ignores the successive invalid characters and
159  * return the converted value of prefix part of the string.
160  */
161 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
162 {
163 	char *tail;
164 	unsigned long val;
165 	size_t len;
166 
167 	*res = 0;
168 	len = strlen(cp);
169 	if (len == 0)
170 		return -EINVAL;
171 
172 	val = simple_strtoul(cp, &tail, base);
173 	if ((*tail == '\0') ||
174 		((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
175 		*res = val;
176 		return 0;
177 	}
178 
179 	return -EINVAL;
180 }
181 EXPORT_SYMBOL(strict_strtoul);
182 
183 /**
184  * strict_strtol - convert a string to a long strictly
185  * @cp: The string to be converted
186  * @base: The number base to use
187  * @res: The converted result value
188  *
189  * strict_strtol is similiar to strict_strtoul, but it allows the first
190  * character of a string is '-'.
191  *
192  * It returns 0 if conversion is successful and *res is set to the converted
193  * value, otherwise it returns -EINVAL and *res is set to 0.
194  */
195 int strict_strtol(const char *cp, unsigned int base, long *res)
196 {
197 	int ret;
198 	if (*cp == '-') {
199 		ret = strict_strtoul(cp + 1, base, (unsigned long *)res);
200 		if (!ret)
201 			*res = -(*res);
202 	} else {
203 		ret = strict_strtoul(cp, base, (unsigned long *)res);
204 	}
205 
206 	return ret;
207 }
208 EXPORT_SYMBOL(strict_strtol);
209 
210 /**
211  * strict_strtoull - convert a string to an unsigned long long strictly
212  * @cp: The string to be converted
213  * @base: The number base to use
214  * @res: The converted result value
215  *
216  * strict_strtoull converts a string to an unsigned long long only if the
217  * string is really an unsigned long long string, any string containing
218  * any invalid char at the tail will be rejected and -EINVAL is returned,
219  * only a newline char at the tail is acceptible because people generally
220  * change a module parameter in the following way:
221  *
222  * 	echo 1024 > /sys/module/e1000/parameters/copybreak
223  *
224  * echo will append a newline to the tail of the string.
225  *
226  * It returns 0 if conversion is successful and *res is set to the converted
227  * value, otherwise it returns -EINVAL and *res is set to 0.
228  *
229  * simple_strtoull just ignores the successive invalid characters and
230  * return the converted value of prefix part of the string.
231  */
232 int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res)
233 {
234 	char *tail;
235 	unsigned long long val;
236 	size_t len;
237 
238 	*res = 0;
239 	len = strlen(cp);
240 	if (len == 0)
241 		return -EINVAL;
242 
243 	val = simple_strtoull(cp, &tail, base);
244 	if ((*tail == '\0') ||
245 		((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
246 		*res = val;
247 		return 0;
248 	}
249 
250 	return -EINVAL;
251 }
252 EXPORT_SYMBOL(strict_strtoull);
253 
254 /**
255  * strict_strtoll - convert a string to a long long strictly
256  * @cp: The string to be converted
257  * @base: The number base to use
258  * @res: The converted result value
259  *
260  * strict_strtoll is similiar to strict_strtoull, but it allows the first
261  * character of a string is '-'.
262  *
263  * It returns 0 if conversion is successful and *res is set to the converted
264  * value, otherwise it returns -EINVAL and *res is set to 0.
265  */
266 int strict_strtoll(const char *cp, unsigned int base, long long *res)
267 {
268 	int ret;
269 	if (*cp == '-') {
270 		ret = strict_strtoull(cp + 1, base, (unsigned long long *)res);
271 		if (!ret)
272 			*res = -(*res);
273 	} else {
274 		ret = strict_strtoull(cp, base, (unsigned long long *)res);
275 	}
276 
277 	return ret;
278 }
279 EXPORT_SYMBOL(strict_strtoll);
280 
281 static int skip_atoi(const char **s)
282 {
283 	int i=0;
284 
285 	while (isdigit(**s))
286 		i = i*10 + *((*s)++) - '0';
287 	return i;
288 }
289 
290 /* Decimal conversion is by far the most typical, and is used
291  * for /proc and /sys data. This directly impacts e.g. top performance
292  * with many processes running. We optimize it for speed
293  * using code from
294  * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
295  * (with permission from the author, Douglas W. Jones). */
296 
297 /* Formats correctly any integer in [0,99999].
298  * Outputs from one to five digits depending on input.
299  * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
300 static char* put_dec_trunc(char *buf, unsigned q)
301 {
302 	unsigned d3, d2, d1, d0;
303 	d1 = (q>>4) & 0xf;
304 	d2 = (q>>8) & 0xf;
305 	d3 = (q>>12);
306 
307 	d0 = 6*(d3 + d2 + d1) + (q & 0xf);
308 	q = (d0 * 0xcd) >> 11;
309 	d0 = d0 - 10*q;
310 	*buf++ = d0 + '0'; /* least significant digit */
311 	d1 = q + 9*d3 + 5*d2 + d1;
312 	if (d1 != 0) {
313 		q = (d1 * 0xcd) >> 11;
314 		d1 = d1 - 10*q;
315 		*buf++ = d1 + '0'; /* next digit */
316 
317 		d2 = q + 2*d2;
318 		if ((d2 != 0) || (d3 != 0)) {
319 			q = (d2 * 0xd) >> 7;
320 			d2 = d2 - 10*q;
321 			*buf++ = d2 + '0'; /* next digit */
322 
323 			d3 = q + 4*d3;
324 			if (d3 != 0) {
325 				q = (d3 * 0xcd) >> 11;
326 				d3 = d3 - 10*q;
327 				*buf++ = d3 + '0';  /* next digit */
328 				if (q != 0)
329 					*buf++ = q + '0';  /* most sign. digit */
330 			}
331 		}
332 	}
333 	return buf;
334 }
335 /* Same with if's removed. Always emits five digits */
336 static char* put_dec_full(char *buf, unsigned q)
337 {
338 	/* BTW, if q is in [0,9999], 8-bit ints will be enough, */
339 	/* but anyway, gcc produces better code with full-sized ints */
340 	unsigned d3, d2, d1, d0;
341 	d1 = (q>>4) & 0xf;
342 	d2 = (q>>8) & 0xf;
343 	d3 = (q>>12);
344 
345 	/* Possible ways to approx. divide by 10 */
346 	/* gcc -O2 replaces multiply with shifts and adds */
347 	// (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
348 	// (x * 0x67) >> 10:  1100111
349 	// (x * 0x34) >> 9:    110100 - same
350 	// (x * 0x1a) >> 8:     11010 - same
351 	// (x * 0x0d) >> 7:      1101 - same, shortest code (on i386)
352 
353 	d0 = 6*(d3 + d2 + d1) + (q & 0xf);
354 	q = (d0 * 0xcd) >> 11;
355 	d0 = d0 - 10*q;
356 	*buf++ = d0 + '0';
357 	d1 = q + 9*d3 + 5*d2 + d1;
358 		q = (d1 * 0xcd) >> 11;
359 		d1 = d1 - 10*q;
360 		*buf++ = d1 + '0';
361 
362 		d2 = q + 2*d2;
363 			q = (d2 * 0xd) >> 7;
364 			d2 = d2 - 10*q;
365 			*buf++ = d2 + '0';
366 
367 			d3 = q + 4*d3;
368 				q = (d3 * 0xcd) >> 11; /* - shorter code */
369 				/* q = (d3 * 0x67) >> 10; - would also work */
370 				d3 = d3 - 10*q;
371 				*buf++ = d3 + '0';
372 					*buf++ = q + '0';
373 	return buf;
374 }
375 /* No inlining helps gcc to use registers better */
376 static noinline char* put_dec(char *buf, unsigned long long num)
377 {
378 	while (1) {
379 		unsigned rem;
380 		if (num < 100000)
381 			return put_dec_trunc(buf, num);
382 		rem = do_div(num, 100000);
383 		buf = put_dec_full(buf, rem);
384 	}
385 }
386 
387 #define ZEROPAD	1		/* pad with zero */
388 #define SIGN	2		/* unsigned/signed long */
389 #define PLUS	4		/* show plus */
390 #define SPACE	8		/* space if plus */
391 #define LEFT	16		/* left justified */
392 #define SMALL	32		/* Must be 32 == 0x20 */
393 #define SPECIAL	64		/* 0x */
394 
395 static char *number(char *buf, char *end, unsigned long long num, int base, int size, int precision, int type)
396 {
397 	/* we are called with base 8, 10 or 16, only, thus don't need "G..."  */
398 	static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
399 
400 	char tmp[66];
401 	char sign;
402 	char locase;
403 	int need_pfx = ((type & SPECIAL) && base != 10);
404 	int i;
405 
406 	/* locase = 0 or 0x20. ORing digits or letters with 'locase'
407 	 * produces same digits or (maybe lowercased) letters */
408 	locase = (type & SMALL);
409 	if (type & LEFT)
410 		type &= ~ZEROPAD;
411 	sign = 0;
412 	if (type & SIGN) {
413 		if ((signed long long) num < 0) {
414 			sign = '-';
415 			num = - (signed long long) num;
416 			size--;
417 		} else if (type & PLUS) {
418 			sign = '+';
419 			size--;
420 		} else if (type & SPACE) {
421 			sign = ' ';
422 			size--;
423 		}
424 	}
425 	if (need_pfx) {
426 		size--;
427 		if (base == 16)
428 			size--;
429 	}
430 
431 	/* generate full string in tmp[], in reverse order */
432 	i = 0;
433 	if (num == 0)
434 		tmp[i++] = '0';
435 	/* Generic code, for any base:
436 	else do {
437 		tmp[i++] = (digits[do_div(num,base)] | locase);
438 	} while (num != 0);
439 	*/
440 	else if (base != 10) { /* 8 or 16 */
441 		int mask = base - 1;
442 		int shift = 3;
443 		if (base == 16) shift = 4;
444 		do {
445 			tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
446 			num >>= shift;
447 		} while (num);
448 	} else { /* base 10 */
449 		i = put_dec(tmp, num) - tmp;
450 	}
451 
452 	/* printing 100 using %2d gives "100", not "00" */
453 	if (i > precision)
454 		precision = i;
455 	/* leading space padding */
456 	size -= precision;
457 	if (!(type & (ZEROPAD+LEFT))) {
458 		while(--size >= 0) {
459 			if (buf < end)
460 				*buf = ' ';
461 			++buf;
462 		}
463 	}
464 	/* sign */
465 	if (sign) {
466 		if (buf < end)
467 			*buf = sign;
468 		++buf;
469 	}
470 	/* "0x" / "0" prefix */
471 	if (need_pfx) {
472 		if (buf < end)
473 			*buf = '0';
474 		++buf;
475 		if (base == 16) {
476 			if (buf < end)
477 				*buf = ('X' | locase);
478 			++buf;
479 		}
480 	}
481 	/* zero or space padding */
482 	if (!(type & LEFT)) {
483 		char c = (type & ZEROPAD) ? '0' : ' ';
484 		while (--size >= 0) {
485 			if (buf < end)
486 				*buf = c;
487 			++buf;
488 		}
489 	}
490 	/* hmm even more zero padding? */
491 	while (i <= --precision) {
492 		if (buf < end)
493 			*buf = '0';
494 		++buf;
495 	}
496 	/* actual digits of result */
497 	while (--i >= 0) {
498 		if (buf < end)
499 			*buf = tmp[i];
500 		++buf;
501 	}
502 	/* trailing space padding */
503 	while (--size >= 0) {
504 		if (buf < end)
505 			*buf = ' ';
506 		++buf;
507 	}
508 	return buf;
509 }
510 
511 static char *string(char *buf, char *end, char *s, int field_width, int precision, int flags)
512 {
513 	int len, i;
514 
515 	if ((unsigned long)s < PAGE_SIZE)
516 		s = "<NULL>";
517 
518 	len = strnlen(s, precision);
519 
520 	if (!(flags & LEFT)) {
521 		while (len < field_width--) {
522 			if (buf < end)
523 				*buf = ' ';
524 			++buf;
525 		}
526 	}
527 	for (i = 0; i < len; ++i) {
528 		if (buf < end)
529 			*buf = *s;
530 		++buf; ++s;
531 	}
532 	while (len < field_width--) {
533 		if (buf < end)
534 			*buf = ' ';
535 		++buf;
536 	}
537 	return buf;
538 }
539 
540 static char *symbol_string(char *buf, char *end, void *ptr, int field_width, int precision, int flags)
541 {
542 	unsigned long value = (unsigned long) ptr;
543 #ifdef CONFIG_KALLSYMS
544 	char sym[KSYM_SYMBOL_LEN];
545 	sprint_symbol(sym, value);
546 	return string(buf, end, sym, field_width, precision, flags);
547 #else
548 	field_width = 2*sizeof(void *);
549 	flags |= SPECIAL | SMALL | ZEROPAD;
550 	return number(buf, end, value, 16, field_width, precision, flags);
551 #endif
552 }
553 
554 static char *resource_string(char *buf, char *end, struct resource *res, int field_width, int precision, int flags)
555 {
556 #ifndef IO_RSRC_PRINTK_SIZE
557 #define IO_RSRC_PRINTK_SIZE	4
558 #endif
559 
560 #ifndef MEM_RSRC_PRINTK_SIZE
561 #define MEM_RSRC_PRINTK_SIZE	8
562 #endif
563 
564 	/* room for the actual numbers, the two "0x", -, [, ] and the final zero */
565 	char sym[4*sizeof(resource_size_t) + 8];
566 	char *p = sym, *pend = sym + sizeof(sym);
567 	int size = -1;
568 
569 	if (res->flags & IORESOURCE_IO)
570 		size = IO_RSRC_PRINTK_SIZE;
571 	else if (res->flags & IORESOURCE_MEM)
572 		size = MEM_RSRC_PRINTK_SIZE;
573 
574 	*p++ = '[';
575 	p = number(p, pend, res->start, 16, size, -1, SPECIAL | SMALL | ZEROPAD);
576 	*p++ = '-';
577 	p = number(p, pend, res->end, 16, size, -1, SPECIAL | SMALL | ZEROPAD);
578 	*p++ = ']';
579 	*p = 0;
580 
581 	return string(buf, end, sym, field_width, precision, flags);
582 }
583 
584 /*
585  * Show a '%p' thing.  A kernel extension is that the '%p' is followed
586  * by an extra set of alphanumeric characters that are extended format
587  * specifiers.
588  *
589  * Right now we handle:
590  *
591  * - 'F' For symbolic function descriptor pointers
592  * - 'S' For symbolic direct pointers
593  * - 'R' For a struct resource pointer, it prints the range of
594  *       addresses (not the name nor the flags)
595  *
596  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
597  * function pointers are really function descriptors, which contain a
598  * pointer to the real address.
599  */
600 static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field_width, int precision, int flags)
601 {
602 	switch (*fmt) {
603 	case 'F':
604 		ptr = dereference_function_descriptor(ptr);
605 		/* Fallthrough */
606 	case 'S':
607 		return symbol_string(buf, end, ptr, field_width, precision, flags);
608 	case 'R':
609 		return resource_string(buf, end, ptr, field_width, precision, flags);
610 	}
611 	flags |= SMALL;
612 	if (field_width == -1) {
613 		field_width = 2*sizeof(void *);
614 		flags |= ZEROPAD;
615 	}
616 	return number(buf, end, (unsigned long) ptr, 16, field_width, precision, flags);
617 }
618 
619 /**
620  * vsnprintf - Format a string and place it in a buffer
621  * @buf: The buffer to place the result into
622  * @size: The size of the buffer, including the trailing null space
623  * @fmt: The format string to use
624  * @args: Arguments for the format string
625  *
626  * This function follows C99 vsnprintf, but has some extensions:
627  * %pS output the name of a text symbol
628  * %pF output the name of a function pointer
629  * %pR output the address range in a struct resource
630  *
631  * The return value is the number of characters which would
632  * be generated for the given input, excluding the trailing
633  * '\0', as per ISO C99. If you want to have the exact
634  * number of characters written into @buf as return value
635  * (not including the trailing '\0'), use vscnprintf(). If the
636  * return is greater than or equal to @size, the resulting
637  * string is truncated.
638  *
639  * Call this function if you are already dealing with a va_list.
640  * You probably want snprintf() instead.
641  */
642 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
643 {
644 	unsigned long long num;
645 	int base;
646 	char *str, *end, c;
647 
648 	int flags;		/* flags to number() */
649 
650 	int field_width;	/* width of output field */
651 	int precision;		/* min. # of digits for integers; max
652 				   number of chars for from string */
653 	int qualifier;		/* 'h', 'l', or 'L' for integer fields */
654 				/* 'z' support added 23/7/1999 S.H.    */
655 				/* 'z' changed to 'Z' --davidm 1/25/99 */
656 				/* 't' added for ptrdiff_t */
657 
658 	/* Reject out-of-range values early.  Large positive sizes are
659 	   used for unknown buffer sizes. */
660 	if (unlikely((int) size < 0)) {
661 		/* There can be only one.. */
662 		static char warn = 1;
663 		WARN_ON(warn);
664 		warn = 0;
665 		return 0;
666 	}
667 
668 	str = buf;
669 	end = buf + size;
670 
671 	/* Make sure end is always >= buf */
672 	if (end < buf) {
673 		end = ((void *)-1);
674 		size = end - buf;
675 	}
676 
677 	for (; *fmt ; ++fmt) {
678 		if (*fmt != '%') {
679 			if (str < end)
680 				*str = *fmt;
681 			++str;
682 			continue;
683 		}
684 
685 		/* process flags */
686 		flags = 0;
687 		repeat:
688 			++fmt;		/* this also skips first '%' */
689 			switch (*fmt) {
690 				case '-': flags |= LEFT; goto repeat;
691 				case '+': flags |= PLUS; goto repeat;
692 				case ' ': flags |= SPACE; goto repeat;
693 				case '#': flags |= SPECIAL; goto repeat;
694 				case '0': flags |= ZEROPAD; goto repeat;
695 			}
696 
697 		/* get field width */
698 		field_width = -1;
699 		if (isdigit(*fmt))
700 			field_width = skip_atoi(&fmt);
701 		else if (*fmt == '*') {
702 			++fmt;
703 			/* it's the next argument */
704 			field_width = va_arg(args, int);
705 			if (field_width < 0) {
706 				field_width = -field_width;
707 				flags |= LEFT;
708 			}
709 		}
710 
711 		/* get the precision */
712 		precision = -1;
713 		if (*fmt == '.') {
714 			++fmt;
715 			if (isdigit(*fmt))
716 				precision = skip_atoi(&fmt);
717 			else if (*fmt == '*') {
718 				++fmt;
719 				/* it's the next argument */
720 				precision = va_arg(args, int);
721 			}
722 			if (precision < 0)
723 				precision = 0;
724 		}
725 
726 		/* get the conversion qualifier */
727 		qualifier = -1;
728 		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
729 		    *fmt =='Z' || *fmt == 'z' || *fmt == 't') {
730 			qualifier = *fmt;
731 			++fmt;
732 			if (qualifier == 'l' && *fmt == 'l') {
733 				qualifier = 'L';
734 				++fmt;
735 			}
736 		}
737 
738 		/* default base */
739 		base = 10;
740 
741 		switch (*fmt) {
742 			case 'c':
743 				if (!(flags & LEFT)) {
744 					while (--field_width > 0) {
745 						if (str < end)
746 							*str = ' ';
747 						++str;
748 					}
749 				}
750 				c = (unsigned char) va_arg(args, int);
751 				if (str < end)
752 					*str = c;
753 				++str;
754 				while (--field_width > 0) {
755 					if (str < end)
756 						*str = ' ';
757 					++str;
758 				}
759 				continue;
760 
761 			case 's':
762 				str = string(str, end, va_arg(args, char *), field_width, precision, flags);
763 				continue;
764 
765 			case 'p':
766 				str = pointer(fmt+1, str, end,
767 						va_arg(args, void *),
768 						field_width, precision, flags);
769 				/* Skip all alphanumeric pointer suffixes */
770 				while (isalnum(fmt[1]))
771 					fmt++;
772 				continue;
773 
774 			case 'n':
775 				/* FIXME:
776 				* What does C99 say about the overflow case here? */
777 				if (qualifier == 'l') {
778 					long * ip = va_arg(args, long *);
779 					*ip = (str - buf);
780 				} else if (qualifier == 'Z' || qualifier == 'z') {
781 					size_t * ip = va_arg(args, size_t *);
782 					*ip = (str - buf);
783 				} else {
784 					int * ip = va_arg(args, int *);
785 					*ip = (str - buf);
786 				}
787 				continue;
788 
789 			case '%':
790 				if (str < end)
791 					*str = '%';
792 				++str;
793 				continue;
794 
795 				/* integer number formats - set up the flags and "break" */
796 			case 'o':
797 				base = 8;
798 				break;
799 
800 			case 'x':
801 				flags |= SMALL;
802 			case 'X':
803 				base = 16;
804 				break;
805 
806 			case 'd':
807 			case 'i':
808 				flags |= SIGN;
809 			case 'u':
810 				break;
811 
812 			default:
813 				if (str < end)
814 					*str = '%';
815 				++str;
816 				if (*fmt) {
817 					if (str < end)
818 						*str = *fmt;
819 					++str;
820 				} else {
821 					--fmt;
822 				}
823 				continue;
824 		}
825 		if (qualifier == 'L')
826 			num = va_arg(args, long long);
827 		else if (qualifier == 'l') {
828 			num = va_arg(args, unsigned long);
829 			if (flags & SIGN)
830 				num = (signed long) num;
831 		} else if (qualifier == 'Z' || qualifier == 'z') {
832 			num = va_arg(args, size_t);
833 		} else if (qualifier == 't') {
834 			num = va_arg(args, ptrdiff_t);
835 		} else if (qualifier == 'h') {
836 			num = (unsigned short) va_arg(args, int);
837 			if (flags & SIGN)
838 				num = (signed short) num;
839 		} else {
840 			num = va_arg(args, unsigned int);
841 			if (flags & SIGN)
842 				num = (signed int) num;
843 		}
844 		str = number(str, end, num, base,
845 				field_width, precision, flags);
846 	}
847 	if (size > 0) {
848 		if (str < end)
849 			*str = '\0';
850 		else
851 			end[-1] = '\0';
852 	}
853 	/* the trailing null byte doesn't count towards the total */
854 	return str-buf;
855 }
856 EXPORT_SYMBOL(vsnprintf);
857 
858 /**
859  * vscnprintf - Format a string and place it in a buffer
860  * @buf: The buffer to place the result into
861  * @size: The size of the buffer, including the trailing null space
862  * @fmt: The format string to use
863  * @args: Arguments for the format string
864  *
865  * The return value is the number of characters which have been written into
866  * the @buf not including the trailing '\0'. If @size is <= 0 the function
867  * returns 0.
868  *
869  * Call this function if you are already dealing with a va_list.
870  * You probably want scnprintf() instead.
871  *
872  * See the vsnprintf() documentation for format string extensions over C99.
873  */
874 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
875 {
876 	int i;
877 
878 	i=vsnprintf(buf,size,fmt,args);
879 	return (i >= size) ? (size - 1) : i;
880 }
881 EXPORT_SYMBOL(vscnprintf);
882 
883 /**
884  * snprintf - Format a string and place it in a buffer
885  * @buf: The buffer to place the result into
886  * @size: The size of the buffer, including the trailing null space
887  * @fmt: The format string to use
888  * @...: Arguments for the format string
889  *
890  * The return value is the number of characters which would be
891  * generated for the given input, excluding the trailing null,
892  * as per ISO C99.  If the return is greater than or equal to
893  * @size, the resulting string is truncated.
894  *
895  * See the vsnprintf() documentation for format string extensions over C99.
896  */
897 int snprintf(char * buf, size_t size, const char *fmt, ...)
898 {
899 	va_list args;
900 	int i;
901 
902 	va_start(args, fmt);
903 	i=vsnprintf(buf,size,fmt,args);
904 	va_end(args);
905 	return i;
906 }
907 EXPORT_SYMBOL(snprintf);
908 
909 /**
910  * scnprintf - Format a string and place it in a buffer
911  * @buf: The buffer to place the result into
912  * @size: The size of the buffer, including the trailing null space
913  * @fmt: The format string to use
914  * @...: Arguments for the format string
915  *
916  * The return value is the number of characters written into @buf not including
917  * the trailing '\0'. If @size is <= 0 the function returns 0.
918  */
919 
920 int scnprintf(char * buf, size_t size, const char *fmt, ...)
921 {
922 	va_list args;
923 	int i;
924 
925 	va_start(args, fmt);
926 	i = vsnprintf(buf, size, fmt, args);
927 	va_end(args);
928 	return (i >= size) ? (size - 1) : i;
929 }
930 EXPORT_SYMBOL(scnprintf);
931 
932 /**
933  * vsprintf - Format a string and place it in a buffer
934  * @buf: The buffer to place the result into
935  * @fmt: The format string to use
936  * @args: Arguments for the format string
937  *
938  * The function returns the number of characters written
939  * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
940  * buffer overflows.
941  *
942  * Call this function if you are already dealing with a va_list.
943  * You probably want sprintf() instead.
944  *
945  * See the vsnprintf() documentation for format string extensions over C99.
946  */
947 int vsprintf(char *buf, const char *fmt, va_list args)
948 {
949 	return vsnprintf(buf, INT_MAX, fmt, args);
950 }
951 EXPORT_SYMBOL(vsprintf);
952 
953 /**
954  * sprintf - Format a string and place it in a buffer
955  * @buf: The buffer to place the result into
956  * @fmt: The format string to use
957  * @...: Arguments for the format string
958  *
959  * The function returns the number of characters written
960  * into @buf. Use snprintf() or scnprintf() in order to avoid
961  * buffer overflows.
962  *
963  * See the vsnprintf() documentation for format string extensions over C99.
964  */
965 int sprintf(char * buf, const char *fmt, ...)
966 {
967 	va_list args;
968 	int i;
969 
970 	va_start(args, fmt);
971 	i=vsnprintf(buf, INT_MAX, fmt, args);
972 	va_end(args);
973 	return i;
974 }
975 EXPORT_SYMBOL(sprintf);
976 
977 /**
978  * vsscanf - Unformat a buffer into a list of arguments
979  * @buf:	input buffer
980  * @fmt:	format of buffer
981  * @args:	arguments
982  */
983 int vsscanf(const char * buf, const char * fmt, va_list args)
984 {
985 	const char *str = buf;
986 	char *next;
987 	char digit;
988 	int num = 0;
989 	int qualifier;
990 	int base;
991 	int field_width;
992 	int is_sign = 0;
993 
994 	while(*fmt && *str) {
995 		/* skip any white space in format */
996 		/* white space in format matchs any amount of
997 		 * white space, including none, in the input.
998 		 */
999 		if (isspace(*fmt)) {
1000 			while (isspace(*fmt))
1001 				++fmt;
1002 			while (isspace(*str))
1003 				++str;
1004 		}
1005 
1006 		/* anything that is not a conversion must match exactly */
1007 		if (*fmt != '%' && *fmt) {
1008 			if (*fmt++ != *str++)
1009 				break;
1010 			continue;
1011 		}
1012 
1013 		if (!*fmt)
1014 			break;
1015 		++fmt;
1016 
1017 		/* skip this conversion.
1018 		 * advance both strings to next white space
1019 		 */
1020 		if (*fmt == '*') {
1021 			while (!isspace(*fmt) && *fmt)
1022 				fmt++;
1023 			while (!isspace(*str) && *str)
1024 				str++;
1025 			continue;
1026 		}
1027 
1028 		/* get field width */
1029 		field_width = -1;
1030 		if (isdigit(*fmt))
1031 			field_width = skip_atoi(&fmt);
1032 
1033 		/* get conversion qualifier */
1034 		qualifier = -1;
1035 		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
1036 		    *fmt == 'Z' || *fmt == 'z') {
1037 			qualifier = *fmt++;
1038 			if (unlikely(qualifier == *fmt)) {
1039 				if (qualifier == 'h') {
1040 					qualifier = 'H';
1041 					fmt++;
1042 				} else if (qualifier == 'l') {
1043 					qualifier = 'L';
1044 					fmt++;
1045 				}
1046 			}
1047 		}
1048 		base = 10;
1049 		is_sign = 0;
1050 
1051 		if (!*fmt || !*str)
1052 			break;
1053 
1054 		switch(*fmt++) {
1055 		case 'c':
1056 		{
1057 			char *s = (char *) va_arg(args,char*);
1058 			if (field_width == -1)
1059 				field_width = 1;
1060 			do {
1061 				*s++ = *str++;
1062 			} while (--field_width > 0 && *str);
1063 			num++;
1064 		}
1065 		continue;
1066 		case 's':
1067 		{
1068 			char *s = (char *) va_arg(args, char *);
1069 			if(field_width == -1)
1070 				field_width = INT_MAX;
1071 			/* first, skip leading white space in buffer */
1072 			while (isspace(*str))
1073 				str++;
1074 
1075 			/* now copy until next white space */
1076 			while (*str && !isspace(*str) && field_width--) {
1077 				*s++ = *str++;
1078 			}
1079 			*s = '\0';
1080 			num++;
1081 		}
1082 		continue;
1083 		case 'n':
1084 			/* return number of characters read so far */
1085 		{
1086 			int *i = (int *)va_arg(args,int*);
1087 			*i = str - buf;
1088 		}
1089 		continue;
1090 		case 'o':
1091 			base = 8;
1092 			break;
1093 		case 'x':
1094 		case 'X':
1095 			base = 16;
1096 			break;
1097 		case 'i':
1098                         base = 0;
1099 		case 'd':
1100 			is_sign = 1;
1101 		case 'u':
1102 			break;
1103 		case '%':
1104 			/* looking for '%' in str */
1105 			if (*str++ != '%')
1106 				return num;
1107 			continue;
1108 		default:
1109 			/* invalid format; stop here */
1110 			return num;
1111 		}
1112 
1113 		/* have some sort of integer conversion.
1114 		 * first, skip white space in buffer.
1115 		 */
1116 		while (isspace(*str))
1117 			str++;
1118 
1119 		digit = *str;
1120 		if (is_sign && digit == '-')
1121 			digit = *(str + 1);
1122 
1123 		if (!digit
1124                     || (base == 16 && !isxdigit(digit))
1125                     || (base == 10 && !isdigit(digit))
1126                     || (base == 8 && (!isdigit(digit) || digit > '7'))
1127                     || (base == 0 && !isdigit(digit)))
1128 				break;
1129 
1130 		switch(qualifier) {
1131 		case 'H':	/* that's 'hh' in format */
1132 			if (is_sign) {
1133 				signed char *s = (signed char *) va_arg(args,signed char *);
1134 				*s = (signed char) simple_strtol(str,&next,base);
1135 			} else {
1136 				unsigned char *s = (unsigned char *) va_arg(args, unsigned char *);
1137 				*s = (unsigned char) simple_strtoul(str, &next, base);
1138 			}
1139 			break;
1140 		case 'h':
1141 			if (is_sign) {
1142 				short *s = (short *) va_arg(args,short *);
1143 				*s = (short) simple_strtol(str,&next,base);
1144 			} else {
1145 				unsigned short *s = (unsigned short *) va_arg(args, unsigned short *);
1146 				*s = (unsigned short) simple_strtoul(str, &next, base);
1147 			}
1148 			break;
1149 		case 'l':
1150 			if (is_sign) {
1151 				long *l = (long *) va_arg(args,long *);
1152 				*l = simple_strtol(str,&next,base);
1153 			} else {
1154 				unsigned long *l = (unsigned long*) va_arg(args,unsigned long*);
1155 				*l = simple_strtoul(str,&next,base);
1156 			}
1157 			break;
1158 		case 'L':
1159 			if (is_sign) {
1160 				long long *l = (long long*) va_arg(args,long long *);
1161 				*l = simple_strtoll(str,&next,base);
1162 			} else {
1163 				unsigned long long *l = (unsigned long long*) va_arg(args,unsigned long long*);
1164 				*l = simple_strtoull(str,&next,base);
1165 			}
1166 			break;
1167 		case 'Z':
1168 		case 'z':
1169 		{
1170 			size_t *s = (size_t*) va_arg(args,size_t*);
1171 			*s = (size_t) simple_strtoul(str,&next,base);
1172 		}
1173 		break;
1174 		default:
1175 			if (is_sign) {
1176 				int *i = (int *) va_arg(args, int*);
1177 				*i = (int) simple_strtol(str,&next,base);
1178 			} else {
1179 				unsigned int *i = (unsigned int*) va_arg(args, unsigned int*);
1180 				*i = (unsigned int) simple_strtoul(str,&next,base);
1181 			}
1182 			break;
1183 		}
1184 		num++;
1185 
1186 		if (!next)
1187 			break;
1188 		str = next;
1189 	}
1190 
1191 	/*
1192 	 * Now we've come all the way through so either the input string or the
1193 	 * format ended. In the former case, there can be a %n at the current
1194 	 * position in the format that needs to be filled.
1195 	 */
1196 	if (*fmt == '%' && *(fmt + 1) == 'n') {
1197 		int *p = (int *)va_arg(args, int *);
1198 		*p = str - buf;
1199 	}
1200 
1201 	return num;
1202 }
1203 EXPORT_SYMBOL(vsscanf);
1204 
1205 /**
1206  * sscanf - Unformat a buffer into a list of arguments
1207  * @buf:	input buffer
1208  * @fmt:	formatting of buffer
1209  * @...:	resulting arguments
1210  */
1211 int sscanf(const char * buf, const char * fmt, ...)
1212 {
1213 	va_list args;
1214 	int i;
1215 
1216 	va_start(args,fmt);
1217 	i = vsscanf(buf,fmt,args);
1218 	va_end(args);
1219 	return i;
1220 }
1221 EXPORT_SYMBOL(sscanf);
1222