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 #include <net/addrconf.h>
29 
30 #include <asm/page.h>		/* for PAGE_SIZE */
31 #include <asm/div64.h>
32 #include <asm/sections.h>	/* for dereference_function_descriptor() */
33 
34 /* Works only for digits and letters, but small and fast */
35 #define TOLOWER(x) ((x) | 0x20)
36 
simple_guess_base(const char * cp)37 static unsigned int simple_guess_base(const char *cp)
38 {
39 	if (cp[0] == '0') {
40 		if (TOLOWER(cp[1]) == 'x' && isxdigit(cp[2]))
41 			return 16;
42 		else
43 			return 8;
44 	} else {
45 		return 10;
46 	}
47 }
48 
49 /**
50  * simple_strtoull - convert a string to an unsigned long long
51  * @cp: The start of the string
52  * @endp: A pointer to the end of the parsed string will be placed here
53  * @base: The number base to use
54  */
simple_strtoull(const char * cp,char ** endp,unsigned int base)55 unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
56 {
57 	unsigned long long result = 0;
58 
59 	if (!base)
60 		base = simple_guess_base(cp);
61 
62 	if (base == 16 && cp[0] == '0' && TOLOWER(cp[1]) == 'x')
63 		cp += 2;
64 
65 	while (isxdigit(*cp)) {
66 		unsigned int value;
67 
68 		value = isdigit(*cp) ? *cp - '0' : TOLOWER(*cp) - 'a' + 10;
69 		if (value >= base)
70 			break;
71 		result = result * base + value;
72 		cp++;
73 	}
74 	if (endp)
75 		*endp = (char *)cp;
76 
77 	return result;
78 }
79 EXPORT_SYMBOL(simple_strtoull);
80 
81 /**
82  * simple_strtoul - convert a string to an unsigned long
83  * @cp: The start of the string
84  * @endp: A pointer to the end of the parsed string will be placed here
85  * @base: The number base to use
86  */
simple_strtoul(const char * cp,char ** endp,unsigned int base)87 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
88 {
89 	return simple_strtoull(cp, endp, base);
90 }
91 EXPORT_SYMBOL(simple_strtoul);
92 
93 /**
94  * simple_strtol - convert a string to a signed long
95  * @cp: The start of the string
96  * @endp: A pointer to the end of the parsed string will be placed here
97  * @base: The number base to use
98  */
simple_strtol(const char * cp,char ** endp,unsigned int base)99 long simple_strtol(const char *cp, char **endp, unsigned int base)
100 {
101 	if (*cp == '-')
102 		return -simple_strtoul(cp + 1, endp, base);
103 
104 	return simple_strtoul(cp, endp, base);
105 }
106 EXPORT_SYMBOL(simple_strtol);
107 
108 /**
109  * simple_strtoll - convert a string to a signed long long
110  * @cp: The start of the string
111  * @endp: A pointer to the end of the parsed string will be placed here
112  * @base: The number base to use
113  */
simple_strtoll(const char * cp,char ** endp,unsigned int base)114 long long simple_strtoll(const char *cp, char **endp, unsigned int base)
115 {
116 	if (*cp == '-')
117 		return -simple_strtoull(cp + 1, endp, base);
118 
119 	return simple_strtoull(cp, endp, base);
120 }
121 EXPORT_SYMBOL(simple_strtoll);
122 
123 static noinline_for_stack
skip_atoi(const char ** s)124 int skip_atoi(const char **s)
125 {
126 	int i = 0;
127 
128 	while (isdigit(**s))
129 		i = i*10 + *((*s)++) - '0';
130 
131 	return i;
132 }
133 
134 /* Decimal conversion is by far the most typical, and is used
135  * for /proc and /sys data. This directly impacts e.g. top performance
136  * with many processes running. We optimize it for speed
137  * using code from
138  * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
139  * (with permission from the author, Douglas W. Jones). */
140 
141 /* Formats correctly any integer in [0,99999].
142  * Outputs from one to five digits depending on input.
143  * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
144 static noinline_for_stack
put_dec_trunc(char * buf,unsigned q)145 char *put_dec_trunc(char *buf, unsigned q)
146 {
147 	unsigned d3, d2, d1, d0;
148 	d1 = (q>>4) & 0xf;
149 	d2 = (q>>8) & 0xf;
150 	d3 = (q>>12);
151 
152 	d0 = 6*(d3 + d2 + d1) + (q & 0xf);
153 	q = (d0 * 0xcd) >> 11;
154 	d0 = d0 - 10*q;
155 	*buf++ = d0 + '0'; /* least significant digit */
156 	d1 = q + 9*d3 + 5*d2 + d1;
157 	if (d1 != 0) {
158 		q = (d1 * 0xcd) >> 11;
159 		d1 = d1 - 10*q;
160 		*buf++ = d1 + '0'; /* next digit */
161 
162 		d2 = q + 2*d2;
163 		if ((d2 != 0) || (d3 != 0)) {
164 			q = (d2 * 0xd) >> 7;
165 			d2 = d2 - 10*q;
166 			*buf++ = d2 + '0'; /* next digit */
167 
168 			d3 = q + 4*d3;
169 			if (d3 != 0) {
170 				q = (d3 * 0xcd) >> 11;
171 				d3 = d3 - 10*q;
172 				*buf++ = d3 + '0';  /* next digit */
173 				if (q != 0)
174 					*buf++ = q + '0'; /* most sign. digit */
175 			}
176 		}
177 	}
178 
179 	return buf;
180 }
181 /* Same with if's removed. Always emits five digits */
182 static noinline_for_stack
put_dec_full(char * buf,unsigned q)183 char *put_dec_full(char *buf, unsigned q)
184 {
185 	/* BTW, if q is in [0,9999], 8-bit ints will be enough, */
186 	/* but anyway, gcc produces better code with full-sized ints */
187 	unsigned d3, d2, d1, d0;
188 	d1 = (q>>4) & 0xf;
189 	d2 = (q>>8) & 0xf;
190 	d3 = (q>>12);
191 
192 	/*
193 	 * Possible ways to approx. divide by 10
194 	 * gcc -O2 replaces multiply with shifts and adds
195 	 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
196 	 * (x * 0x67) >> 10:  1100111
197 	 * (x * 0x34) >> 9:    110100 - same
198 	 * (x * 0x1a) >> 8:     11010 - same
199 	 * (x * 0x0d) >> 7:      1101 - same, shortest code (on i386)
200 	 */
201 	d0 = 6*(d3 + d2 + d1) + (q & 0xf);
202 	q = (d0 * 0xcd) >> 11;
203 	d0 = d0 - 10*q;
204 	*buf++ = d0 + '0';
205 	d1 = q + 9*d3 + 5*d2 + d1;
206 		q = (d1 * 0xcd) >> 11;
207 		d1 = d1 - 10*q;
208 		*buf++ = d1 + '0';
209 
210 		d2 = q + 2*d2;
211 			q = (d2 * 0xd) >> 7;
212 			d2 = d2 - 10*q;
213 			*buf++ = d2 + '0';
214 
215 			d3 = q + 4*d3;
216 				q = (d3 * 0xcd) >> 11; /* - shorter code */
217 				/* q = (d3 * 0x67) >> 10; - would also work */
218 				d3 = d3 - 10*q;
219 				*buf++ = d3 + '0';
220 					*buf++ = q + '0';
221 
222 	return buf;
223 }
224 /* No inlining helps gcc to use registers better */
225 static noinline_for_stack
put_dec(char * buf,unsigned long long num)226 char *put_dec(char *buf, unsigned long long num)
227 {
228 	while (1) {
229 		unsigned rem;
230 		if (num < 100000)
231 			return put_dec_trunc(buf, num);
232 		rem = do_div(num, 100000);
233 		buf = put_dec_full(buf, rem);
234 	}
235 }
236 
237 #define ZEROPAD	1		/* pad with zero */
238 #define SIGN	2		/* unsigned/signed long */
239 #define PLUS	4		/* show plus */
240 #define SPACE	8		/* space if plus */
241 #define LEFT	16		/* left justified */
242 #define SMALL	32		/* use lowercase in hex (must be 32 == 0x20) */
243 #define SPECIAL	64		/* prefix hex with "0x", octal with "0" */
244 
245 enum format_type {
246 	FORMAT_TYPE_NONE, /* Just a string part */
247 	FORMAT_TYPE_WIDTH,
248 	FORMAT_TYPE_PRECISION,
249 	FORMAT_TYPE_CHAR,
250 	FORMAT_TYPE_STR,
251 	FORMAT_TYPE_PTR,
252 	FORMAT_TYPE_PERCENT_CHAR,
253 	FORMAT_TYPE_INVALID,
254 	FORMAT_TYPE_LONG_LONG,
255 	FORMAT_TYPE_ULONG,
256 	FORMAT_TYPE_LONG,
257 	FORMAT_TYPE_UBYTE,
258 	FORMAT_TYPE_BYTE,
259 	FORMAT_TYPE_USHORT,
260 	FORMAT_TYPE_SHORT,
261 	FORMAT_TYPE_UINT,
262 	FORMAT_TYPE_INT,
263 	FORMAT_TYPE_NRCHARS,
264 	FORMAT_TYPE_SIZE_T,
265 	FORMAT_TYPE_PTRDIFF
266 };
267 
268 struct printf_spec {
269 	u8	type;		/* format_type enum */
270 	u8	flags;		/* flags to number() */
271 	u8	base;		/* number base, 8, 10 or 16 only */
272 	u8	qualifier;	/* number qualifier, one of 'hHlLtzZ' */
273 	s16	field_width;	/* width of output field */
274 	s16	precision;	/* # of digits/chars */
275 };
276 
277 static noinline_for_stack
number(char * buf,char * end,unsigned long long num,struct printf_spec spec)278 char *number(char *buf, char *end, unsigned long long num,
279 	     struct printf_spec spec)
280 {
281 	/* we are called with base 8, 10 or 16, only, thus don't need "G..."  */
282 	static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
283 
284 	char tmp[66];
285 	char sign;
286 	char locase;
287 	int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
288 	int i;
289 
290 	/* locase = 0 or 0x20. ORing digits or letters with 'locase'
291 	 * produces same digits or (maybe lowercased) letters */
292 	locase = (spec.flags & SMALL);
293 	if (spec.flags & LEFT)
294 		spec.flags &= ~ZEROPAD;
295 	sign = 0;
296 	if (spec.flags & SIGN) {
297 		if ((signed long long)num < 0) {
298 			sign = '-';
299 			num = -(signed long long)num;
300 			spec.field_width--;
301 		} else if (spec.flags & PLUS) {
302 			sign = '+';
303 			spec.field_width--;
304 		} else if (spec.flags & SPACE) {
305 			sign = ' ';
306 			spec.field_width--;
307 		}
308 	}
309 	if (need_pfx) {
310 		spec.field_width--;
311 		if (spec.base == 16)
312 			spec.field_width--;
313 	}
314 
315 	/* generate full string in tmp[], in reverse order */
316 	i = 0;
317 	if (num == 0)
318 		tmp[i++] = '0';
319 	/* Generic code, for any base:
320 	else do {
321 		tmp[i++] = (digits[do_div(num,base)] | locase);
322 	} while (num != 0);
323 	*/
324 	else if (spec.base != 10) { /* 8 or 16 */
325 		int mask = spec.base - 1;
326 		int shift = 3;
327 
328 		if (spec.base == 16)
329 			shift = 4;
330 		do {
331 			tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
332 			num >>= shift;
333 		} while (num);
334 	} else { /* base 10 */
335 		i = put_dec(tmp, num) - tmp;
336 	}
337 
338 	/* printing 100 using %2d gives "100", not "00" */
339 	if (i > spec.precision)
340 		spec.precision = i;
341 	/* leading space padding */
342 	spec.field_width -= spec.precision;
343 	if (!(spec.flags & (ZEROPAD+LEFT))) {
344 		while (--spec.field_width >= 0) {
345 			if (buf < end)
346 				*buf = ' ';
347 			++buf;
348 		}
349 	}
350 	/* sign */
351 	if (sign) {
352 		if (buf < end)
353 			*buf = sign;
354 		++buf;
355 	}
356 	/* "0x" / "0" prefix */
357 	if (need_pfx) {
358 		if (buf < end)
359 			*buf = '0';
360 		++buf;
361 		if (spec.base == 16) {
362 			if (buf < end)
363 				*buf = ('X' | locase);
364 			++buf;
365 		}
366 	}
367 	/* zero or space padding */
368 	if (!(spec.flags & LEFT)) {
369 		char c = (spec.flags & ZEROPAD) ? '0' : ' ';
370 		while (--spec.field_width >= 0) {
371 			if (buf < end)
372 				*buf = c;
373 			++buf;
374 		}
375 	}
376 	/* hmm even more zero padding? */
377 	while (i <= --spec.precision) {
378 		if (buf < end)
379 			*buf = '0';
380 		++buf;
381 	}
382 	/* actual digits of result */
383 	while (--i >= 0) {
384 		if (buf < end)
385 			*buf = tmp[i];
386 		++buf;
387 	}
388 	/* trailing space padding */
389 	while (--spec.field_width >= 0) {
390 		if (buf < end)
391 			*buf = ' ';
392 		++buf;
393 	}
394 
395 	return buf;
396 }
397 
398 static noinline_for_stack
string(char * buf,char * end,const char * s,struct printf_spec spec)399 char *string(char *buf, char *end, const char *s, struct printf_spec spec)
400 {
401 	int len, i;
402 
403 	if ((unsigned long)s < PAGE_SIZE)
404 		s = "(null)";
405 
406 	len = strnlen(s, spec.precision);
407 
408 	if (!(spec.flags & LEFT)) {
409 		while (len < spec.field_width--) {
410 			if (buf < end)
411 				*buf = ' ';
412 			++buf;
413 		}
414 	}
415 	for (i = 0; i < len; ++i) {
416 		if (buf < end)
417 			*buf = *s;
418 		++buf; ++s;
419 	}
420 	while (len < spec.field_width--) {
421 		if (buf < end)
422 			*buf = ' ';
423 		++buf;
424 	}
425 
426 	return buf;
427 }
428 
429 static noinline_for_stack
symbol_string(char * buf,char * end,void * ptr,struct printf_spec spec,char ext)430 char *symbol_string(char *buf, char *end, void *ptr,
431 		    struct printf_spec spec, char ext)
432 {
433 	unsigned long value = (unsigned long) ptr;
434 #ifdef CONFIG_KALLSYMS
435 	char sym[KSYM_SYMBOL_LEN];
436 	if (ext == 'B')
437 		sprint_backtrace(sym, value);
438 	else if (ext != 'f' && ext != 's')
439 		sprint_symbol(sym, value);
440 	else
441 		kallsyms_lookup(value, NULL, NULL, NULL, sym);
442 
443 	return string(buf, end, sym, spec);
444 #else
445 	spec.field_width = 2 * sizeof(void *);
446 	spec.flags |= SPECIAL | SMALL | ZEROPAD;
447 	spec.base = 16;
448 
449 	return number(buf, end, value, spec);
450 #endif
451 }
452 
453 static noinline_for_stack
resource_string(char * buf,char * end,struct resource * res,struct printf_spec spec,const char * fmt)454 char *resource_string(char *buf, char *end, struct resource *res,
455 		      struct printf_spec spec, const char *fmt)
456 {
457 #ifndef IO_RSRC_PRINTK_SIZE
458 #define IO_RSRC_PRINTK_SIZE	6
459 #endif
460 
461 #ifndef MEM_RSRC_PRINTK_SIZE
462 #define MEM_RSRC_PRINTK_SIZE	10
463 #endif
464 	static const struct printf_spec io_spec = {
465 		.base = 16,
466 		.field_width = IO_RSRC_PRINTK_SIZE,
467 		.precision = -1,
468 		.flags = SPECIAL | SMALL | ZEROPAD,
469 	};
470 	static const struct printf_spec mem_spec = {
471 		.base = 16,
472 		.field_width = MEM_RSRC_PRINTK_SIZE,
473 		.precision = -1,
474 		.flags = SPECIAL | SMALL | ZEROPAD,
475 	};
476 	static const struct printf_spec bus_spec = {
477 		.base = 16,
478 		.field_width = 2,
479 		.precision = -1,
480 		.flags = SMALL | ZEROPAD,
481 	};
482 	static const struct printf_spec dec_spec = {
483 		.base = 10,
484 		.precision = -1,
485 		.flags = 0,
486 	};
487 	static const struct printf_spec str_spec = {
488 		.field_width = -1,
489 		.precision = 10,
490 		.flags = LEFT,
491 	};
492 	static const struct printf_spec flag_spec = {
493 		.base = 16,
494 		.precision = -1,
495 		.flags = SPECIAL | SMALL,
496 	};
497 
498 	/* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
499 	 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
500 #define RSRC_BUF_SIZE		((2 * sizeof(resource_size_t)) + 4)
501 #define FLAG_BUF_SIZE		(2 * sizeof(res->flags))
502 #define DECODED_BUF_SIZE	sizeof("[mem - 64bit pref window disabled]")
503 #define RAW_BUF_SIZE		sizeof("[mem - flags 0x]")
504 	char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
505 		     2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
506 
507 	char *p = sym, *pend = sym + sizeof(sym);
508 	int decode = (fmt[0] == 'R') ? 1 : 0;
509 	const struct printf_spec *specp;
510 
511 	*p++ = '[';
512 	if (res->flags & IORESOURCE_IO) {
513 		p = string(p, pend, "io  ", str_spec);
514 		specp = &io_spec;
515 	} else if (res->flags & IORESOURCE_MEM) {
516 		p = string(p, pend, "mem ", str_spec);
517 		specp = &mem_spec;
518 	} else if (res->flags & IORESOURCE_IRQ) {
519 		p = string(p, pend, "irq ", str_spec);
520 		specp = &dec_spec;
521 	} else if (res->flags & IORESOURCE_DMA) {
522 		p = string(p, pend, "dma ", str_spec);
523 		specp = &dec_spec;
524 	} else if (res->flags & IORESOURCE_BUS) {
525 		p = string(p, pend, "bus ", str_spec);
526 		specp = &bus_spec;
527 	} else {
528 		p = string(p, pend, "??? ", str_spec);
529 		specp = &mem_spec;
530 		decode = 0;
531 	}
532 	p = number(p, pend, res->start, *specp);
533 	if (res->start != res->end) {
534 		*p++ = '-';
535 		p = number(p, pend, res->end, *specp);
536 	}
537 	if (decode) {
538 		if (res->flags & IORESOURCE_MEM_64)
539 			p = string(p, pend, " 64bit", str_spec);
540 		if (res->flags & IORESOURCE_PREFETCH)
541 			p = string(p, pend, " pref", str_spec);
542 		if (res->flags & IORESOURCE_WINDOW)
543 			p = string(p, pend, " window", str_spec);
544 		if (res->flags & IORESOURCE_DISABLED)
545 			p = string(p, pend, " disabled", str_spec);
546 	} else {
547 		p = string(p, pend, " flags ", str_spec);
548 		p = number(p, pend, res->flags, flag_spec);
549 	}
550 	*p++ = ']';
551 	*p = '\0';
552 
553 	return string(buf, end, sym, spec);
554 }
555 
556 static noinline_for_stack
mac_address_string(char * buf,char * end,u8 * addr,struct printf_spec spec,const char * fmt)557 char *mac_address_string(char *buf, char *end, u8 *addr,
558 			 struct printf_spec spec, const char *fmt)
559 {
560 	char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
561 	char *p = mac_addr;
562 	int i;
563 	char separator;
564 
565 	if (fmt[1] == 'F') {		/* FDDI canonical format */
566 		separator = '-';
567 	} else {
568 		separator = ':';
569 	}
570 
571 	for (i = 0; i < 6; i++) {
572 		p = pack_hex_byte(p, addr[i]);
573 		if (fmt[0] == 'M' && i != 5)
574 			*p++ = separator;
575 	}
576 	*p = '\0';
577 
578 	return string(buf, end, mac_addr, spec);
579 }
580 
581 static noinline_for_stack
ip4_string(char * p,const u8 * addr,const char * fmt)582 char *ip4_string(char *p, const u8 *addr, const char *fmt)
583 {
584 	int i;
585 	bool leading_zeros = (fmt[0] == 'i');
586 	int index;
587 	int step;
588 
589 	switch (fmt[2]) {
590 	case 'h':
591 #ifdef __BIG_ENDIAN
592 		index = 0;
593 		step = 1;
594 #else
595 		index = 3;
596 		step = -1;
597 #endif
598 		break;
599 	case 'l':
600 		index = 3;
601 		step = -1;
602 		break;
603 	case 'n':
604 	case 'b':
605 	default:
606 		index = 0;
607 		step = 1;
608 		break;
609 	}
610 	for (i = 0; i < 4; i++) {
611 		char temp[3];	/* hold each IP quad in reverse order */
612 		int digits = put_dec_trunc(temp, addr[index]) - temp;
613 		if (leading_zeros) {
614 			if (digits < 3)
615 				*p++ = '0';
616 			if (digits < 2)
617 				*p++ = '0';
618 		}
619 		/* reverse the digits in the quad */
620 		while (digits--)
621 			*p++ = temp[digits];
622 		if (i < 3)
623 			*p++ = '.';
624 		index += step;
625 	}
626 	*p = '\0';
627 
628 	return p;
629 }
630 
631 static noinline_for_stack
ip6_compressed_string(char * p,const char * addr)632 char *ip6_compressed_string(char *p, const char *addr)
633 {
634 	int i, j, range;
635 	unsigned char zerolength[8];
636 	int longest = 1;
637 	int colonpos = -1;
638 	u16 word;
639 	u8 hi, lo;
640 	bool needcolon = false;
641 	bool useIPv4;
642 	struct in6_addr in6;
643 
644 	memcpy(&in6, addr, sizeof(struct in6_addr));
645 
646 	useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
647 
648 	memset(zerolength, 0, sizeof(zerolength));
649 
650 	if (useIPv4)
651 		range = 6;
652 	else
653 		range = 8;
654 
655 	/* find position of longest 0 run */
656 	for (i = 0; i < range; i++) {
657 		for (j = i; j < range; j++) {
658 			if (in6.s6_addr16[j] != 0)
659 				break;
660 			zerolength[i]++;
661 		}
662 	}
663 	for (i = 0; i < range; i++) {
664 		if (zerolength[i] > longest) {
665 			longest = zerolength[i];
666 			colonpos = i;
667 		}
668 	}
669 
670 	/* emit address */
671 	for (i = 0; i < range; i++) {
672 		if (i == colonpos) {
673 			if (needcolon || i == 0)
674 				*p++ = ':';
675 			*p++ = ':';
676 			needcolon = false;
677 			i += longest - 1;
678 			continue;
679 		}
680 		if (needcolon) {
681 			*p++ = ':';
682 			needcolon = false;
683 		}
684 		/* hex u16 without leading 0s */
685 		word = ntohs(in6.s6_addr16[i]);
686 		hi = word >> 8;
687 		lo = word & 0xff;
688 		if (hi) {
689 			if (hi > 0x0f)
690 				p = pack_hex_byte(p, hi);
691 			else
692 				*p++ = hex_asc_lo(hi);
693 			p = pack_hex_byte(p, lo);
694 		}
695 		else if (lo > 0x0f)
696 			p = pack_hex_byte(p, lo);
697 		else
698 			*p++ = hex_asc_lo(lo);
699 		needcolon = true;
700 	}
701 
702 	if (useIPv4) {
703 		if (needcolon)
704 			*p++ = ':';
705 		p = ip4_string(p, &in6.s6_addr[12], "I4");
706 	}
707 	*p = '\0';
708 
709 	return p;
710 }
711 
712 static noinline_for_stack
ip6_string(char * p,const char * addr,const char * fmt)713 char *ip6_string(char *p, const char *addr, const char *fmt)
714 {
715 	int i;
716 
717 	for (i = 0; i < 8; i++) {
718 		p = pack_hex_byte(p, *addr++);
719 		p = pack_hex_byte(p, *addr++);
720 		if (fmt[0] == 'I' && i != 7)
721 			*p++ = ':';
722 	}
723 	*p = '\0';
724 
725 	return p;
726 }
727 
728 static noinline_for_stack
ip6_addr_string(char * buf,char * end,const u8 * addr,struct printf_spec spec,const char * fmt)729 char *ip6_addr_string(char *buf, char *end, const u8 *addr,
730 		      struct printf_spec spec, const char *fmt)
731 {
732 	char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
733 
734 	if (fmt[0] == 'I' && fmt[2] == 'c')
735 		ip6_compressed_string(ip6_addr, addr);
736 	else
737 		ip6_string(ip6_addr, addr, fmt);
738 
739 	return string(buf, end, ip6_addr, spec);
740 }
741 
742 static noinline_for_stack
ip4_addr_string(char * buf,char * end,const u8 * addr,struct printf_spec spec,const char * fmt)743 char *ip4_addr_string(char *buf, char *end, const u8 *addr,
744 		      struct printf_spec spec, const char *fmt)
745 {
746 	char ip4_addr[sizeof("255.255.255.255")];
747 
748 	ip4_string(ip4_addr, addr, fmt);
749 
750 	return string(buf, end, ip4_addr, spec);
751 }
752 
753 static noinline_for_stack
uuid_string(char * buf,char * end,const u8 * addr,struct printf_spec spec,const char * fmt)754 char *uuid_string(char *buf, char *end, const u8 *addr,
755 		  struct printf_spec spec, const char *fmt)
756 {
757 	char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
758 	char *p = uuid;
759 	int i;
760 	static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
761 	static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
762 	const u8 *index = be;
763 	bool uc = false;
764 
765 	switch (*(++fmt)) {
766 	case 'L':
767 		uc = true;		/* fall-through */
768 	case 'l':
769 		index = le;
770 		break;
771 	case 'B':
772 		uc = true;
773 		break;
774 	}
775 
776 	for (i = 0; i < 16; i++) {
777 		p = pack_hex_byte(p, addr[index[i]]);
778 		switch (i) {
779 		case 3:
780 		case 5:
781 		case 7:
782 		case 9:
783 			*p++ = '-';
784 			break;
785 		}
786 	}
787 
788 	*p = 0;
789 
790 	if (uc) {
791 		p = uuid;
792 		do {
793 			*p = toupper(*p);
794 		} while (*(++p));
795 	}
796 
797 	return string(buf, end, uuid, spec);
798 }
799 
800 int kptr_restrict __read_mostly;
801 
802 /*
803  * Show a '%p' thing.  A kernel extension is that the '%p' is followed
804  * by an extra set of alphanumeric characters that are extended format
805  * specifiers.
806  *
807  * Right now we handle:
808  *
809  * - 'F' For symbolic function descriptor pointers with offset
810  * - 'f' For simple symbolic function names without offset
811  * - 'S' For symbolic direct pointers with offset
812  * - 's' For symbolic direct pointers without offset
813  * - 'B' For backtraced symbolic direct pointers with offset
814  * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
815  * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
816  * - 'M' For a 6-byte MAC address, it prints the address in the
817  *       usual colon-separated hex notation
818  * - 'm' For a 6-byte MAC address, it prints the hex address without colons
819  * - 'MF' For a 6-byte MAC FDDI address, it prints the address
820  *       with a dash-separated hex notation
821  * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
822  *       IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
823  *       IPv6 uses colon separated network-order 16 bit hex with leading 0's
824  * - 'i' [46] for 'raw' IPv4/IPv6 addresses
825  *       IPv6 omits the colons (01020304...0f)
826  *       IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
827  * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order
828  * - 'I6c' for IPv6 addresses printed as specified by
829  *       http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
830  * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
831  *       "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
832  *       Options for %pU are:
833  *         b big endian lower case hex (default)
834  *         B big endian UPPER case hex
835  *         l little endian lower case hex
836  *         L little endian UPPER case hex
837  *           big endian output byte order is:
838  *             [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
839  *           little endian output byte order is:
840  *             [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
841  * - 'V' For a struct va_format which contains a format string * and va_list *,
842  *       call vsnprintf(->format, *->va_list).
843  *       Implements a "recursive vsnprintf".
844  *       Do not use this feature without some mechanism to verify the
845  *       correctness of the format string and va_list arguments.
846  * - 'K' For a kernel pointer that should be hidden from unprivileged users
847  *
848  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
849  * function pointers are really function descriptors, which contain a
850  * pointer to the real address.
851  */
852 static noinline_for_stack
pointer(const char * fmt,char * buf,char * end,void * ptr,struct printf_spec spec)853 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
854 	      struct printf_spec spec)
855 {
856 	if (!ptr && *fmt != 'K') {
857 		/*
858 		 * Print (null) with the same width as a pointer so it makes
859 		 * tabular output look nice.
860 		 */
861 		if (spec.field_width == -1)
862 			spec.field_width = 2 * sizeof(void *);
863 		return string(buf, end, "(null)", spec);
864 	}
865 
866 	switch (*fmt) {
867 	case 'F':
868 	case 'f':
869 		ptr = dereference_function_descriptor(ptr);
870 		/* Fallthrough */
871 	case 'S':
872 	case 's':
873 	case 'B':
874 		return symbol_string(buf, end, ptr, spec, *fmt);
875 	case 'R':
876 	case 'r':
877 		return resource_string(buf, end, ptr, spec, fmt);
878 	case 'M':			/* Colon separated: 00:01:02:03:04:05 */
879 	case 'm':			/* Contiguous: 000102030405 */
880 					/* [mM]F (FDDI, bit reversed) */
881 		return mac_address_string(buf, end, ptr, spec, fmt);
882 	case 'I':			/* Formatted IP supported
883 					 * 4:	1.2.3.4
884 					 * 6:	0001:0203:...:0708
885 					 * 6c:	1::708 or 1::1.2.3.4
886 					 */
887 	case 'i':			/* Contiguous:
888 					 * 4:	001.002.003.004
889 					 * 6:   000102...0f
890 					 */
891 		switch (fmt[1]) {
892 		case '6':
893 			return ip6_addr_string(buf, end, ptr, spec, fmt);
894 		case '4':
895 			return ip4_addr_string(buf, end, ptr, spec, fmt);
896 		}
897 		break;
898 	case 'U':
899 		return uuid_string(buf, end, ptr, spec, fmt);
900 	case 'V':
901 		return buf + vsnprintf(buf, end - buf,
902 				       ((struct va_format *)ptr)->fmt,
903 				       *(((struct va_format *)ptr)->va));
904 	case 'K':
905 		/*
906 		 * %pK cannot be used in IRQ context because its test
907 		 * for CAP_SYSLOG would be meaningless.
908 		 */
909 		if (in_irq() || in_serving_softirq() || in_nmi()) {
910 			if (spec.field_width == -1)
911 				spec.field_width = 2 * sizeof(void *);
912 			return string(buf, end, "pK-error", spec);
913 		}
914 		if (!((kptr_restrict == 0) ||
915 		      (kptr_restrict == 1 &&
916 		       has_capability_noaudit(current, CAP_SYSLOG))))
917 			ptr = NULL;
918 		break;
919 	}
920 	spec.flags |= SMALL;
921 	if (spec.field_width == -1) {
922 		spec.field_width = 2 * sizeof(void *);
923 		spec.flags |= ZEROPAD;
924 	}
925 	spec.base = 16;
926 
927 	return number(buf, end, (unsigned long) ptr, spec);
928 }
929 
930 /*
931  * Helper function to decode printf style format.
932  * Each call decode a token from the format and return the
933  * number of characters read (or likely the delta where it wants
934  * to go on the next call).
935  * The decoded token is returned through the parameters
936  *
937  * 'h', 'l', or 'L' for integer fields
938  * 'z' support added 23/7/1999 S.H.
939  * 'z' changed to 'Z' --davidm 1/25/99
940  * 't' added for ptrdiff_t
941  *
942  * @fmt: the format string
943  * @type of the token returned
944  * @flags: various flags such as +, -, # tokens..
945  * @field_width: overwritten width
946  * @base: base of the number (octal, hex, ...)
947  * @precision: precision of a number
948  * @qualifier: qualifier of a number (long, size_t, ...)
949  */
950 static noinline_for_stack
format_decode(const char * fmt,struct printf_spec * spec)951 int format_decode(const char *fmt, struct printf_spec *spec)
952 {
953 	const char *start = fmt;
954 
955 	/* we finished early by reading the field width */
956 	if (spec->type == FORMAT_TYPE_WIDTH) {
957 		if (spec->field_width < 0) {
958 			spec->field_width = -spec->field_width;
959 			spec->flags |= LEFT;
960 		}
961 		spec->type = FORMAT_TYPE_NONE;
962 		goto precision;
963 	}
964 
965 	/* we finished early by reading the precision */
966 	if (spec->type == FORMAT_TYPE_PRECISION) {
967 		if (spec->precision < 0)
968 			spec->precision = 0;
969 
970 		spec->type = FORMAT_TYPE_NONE;
971 		goto qualifier;
972 	}
973 
974 	/* By default */
975 	spec->type = FORMAT_TYPE_NONE;
976 
977 	for (; *fmt ; ++fmt) {
978 		if (*fmt == '%')
979 			break;
980 	}
981 
982 	/* Return the current non-format string */
983 	if (fmt != start || !*fmt)
984 		return fmt - start;
985 
986 	/* Process flags */
987 	spec->flags = 0;
988 
989 	while (1) { /* this also skips first '%' */
990 		bool found = true;
991 
992 		++fmt;
993 
994 		switch (*fmt) {
995 		case '-': spec->flags |= LEFT;    break;
996 		case '+': spec->flags |= PLUS;    break;
997 		case ' ': spec->flags |= SPACE;   break;
998 		case '#': spec->flags |= SPECIAL; break;
999 		case '0': spec->flags |= ZEROPAD; break;
1000 		default:  found = false;
1001 		}
1002 
1003 		if (!found)
1004 			break;
1005 	}
1006 
1007 	/* get field width */
1008 	spec->field_width = -1;
1009 
1010 	if (isdigit(*fmt))
1011 		spec->field_width = skip_atoi(&fmt);
1012 	else if (*fmt == '*') {
1013 		/* it's the next argument */
1014 		spec->type = FORMAT_TYPE_WIDTH;
1015 		return ++fmt - start;
1016 	}
1017 
1018 precision:
1019 	/* get the precision */
1020 	spec->precision = -1;
1021 	if (*fmt == '.') {
1022 		++fmt;
1023 		if (isdigit(*fmt)) {
1024 			spec->precision = skip_atoi(&fmt);
1025 			if (spec->precision < 0)
1026 				spec->precision = 0;
1027 		} else if (*fmt == '*') {
1028 			/* it's the next argument */
1029 			spec->type = FORMAT_TYPE_PRECISION;
1030 			return ++fmt - start;
1031 		}
1032 	}
1033 
1034 qualifier:
1035 	/* get the conversion qualifier */
1036 	spec->qualifier = -1;
1037 	if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1038 	    TOLOWER(*fmt) == 'z' || *fmt == 't') {
1039 		spec->qualifier = *fmt++;
1040 		if (unlikely(spec->qualifier == *fmt)) {
1041 			if (spec->qualifier == 'l') {
1042 				spec->qualifier = 'L';
1043 				++fmt;
1044 			} else if (spec->qualifier == 'h') {
1045 				spec->qualifier = 'H';
1046 				++fmt;
1047 			}
1048 		}
1049 	}
1050 
1051 	/* default base */
1052 	spec->base = 10;
1053 	switch (*fmt) {
1054 	case 'c':
1055 		spec->type = FORMAT_TYPE_CHAR;
1056 		return ++fmt - start;
1057 
1058 	case 's':
1059 		spec->type = FORMAT_TYPE_STR;
1060 		return ++fmt - start;
1061 
1062 	case 'p':
1063 		spec->type = FORMAT_TYPE_PTR;
1064 		return fmt - start;
1065 		/* skip alnum */
1066 
1067 	case 'n':
1068 		spec->type = FORMAT_TYPE_NRCHARS;
1069 		return ++fmt - start;
1070 
1071 	case '%':
1072 		spec->type = FORMAT_TYPE_PERCENT_CHAR;
1073 		return ++fmt - start;
1074 
1075 	/* integer number formats - set up the flags and "break" */
1076 	case 'o':
1077 		spec->base = 8;
1078 		break;
1079 
1080 	case 'x':
1081 		spec->flags |= SMALL;
1082 
1083 	case 'X':
1084 		spec->base = 16;
1085 		break;
1086 
1087 	case 'd':
1088 	case 'i':
1089 		spec->flags |= SIGN;
1090 	case 'u':
1091 		break;
1092 
1093 	default:
1094 		spec->type = FORMAT_TYPE_INVALID;
1095 		return fmt - start;
1096 	}
1097 
1098 	if (spec->qualifier == 'L')
1099 		spec->type = FORMAT_TYPE_LONG_LONG;
1100 	else if (spec->qualifier == 'l') {
1101 		if (spec->flags & SIGN)
1102 			spec->type = FORMAT_TYPE_LONG;
1103 		else
1104 			spec->type = FORMAT_TYPE_ULONG;
1105 	} else if (TOLOWER(spec->qualifier) == 'z') {
1106 		spec->type = FORMAT_TYPE_SIZE_T;
1107 	} else if (spec->qualifier == 't') {
1108 		spec->type = FORMAT_TYPE_PTRDIFF;
1109 	} else if (spec->qualifier == 'H') {
1110 		if (spec->flags & SIGN)
1111 			spec->type = FORMAT_TYPE_BYTE;
1112 		else
1113 			spec->type = FORMAT_TYPE_UBYTE;
1114 	} else if (spec->qualifier == 'h') {
1115 		if (spec->flags & SIGN)
1116 			spec->type = FORMAT_TYPE_SHORT;
1117 		else
1118 			spec->type = FORMAT_TYPE_USHORT;
1119 	} else {
1120 		if (spec->flags & SIGN)
1121 			spec->type = FORMAT_TYPE_INT;
1122 		else
1123 			spec->type = FORMAT_TYPE_UINT;
1124 	}
1125 
1126 	return ++fmt - start;
1127 }
1128 
1129 /**
1130  * vsnprintf - Format a string and place it in a buffer
1131  * @buf: The buffer to place the result into
1132  * @size: The size of the buffer, including the trailing null space
1133  * @fmt: The format string to use
1134  * @args: Arguments for the format string
1135  *
1136  * This function follows C99 vsnprintf, but has some extensions:
1137  * %pS output the name of a text symbol with offset
1138  * %ps output the name of a text symbol without offset
1139  * %pF output the name of a function pointer with its offset
1140  * %pf output the name of a function pointer without its offset
1141  * %pB output the name of a backtrace symbol with its offset
1142  * %pR output the address range in a struct resource with decoded flags
1143  * %pr output the address range in a struct resource with raw flags
1144  * %pM output a 6-byte MAC address with colons
1145  * %pm output a 6-byte MAC address without colons
1146  * %pI4 print an IPv4 address without leading zeros
1147  * %pi4 print an IPv4 address with leading zeros
1148  * %pI6 print an IPv6 address with colons
1149  * %pi6 print an IPv6 address without colons
1150  * %pI6c print an IPv6 address as specified by
1151  *   http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-00
1152  * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
1153  *   case.
1154  * %n is ignored
1155  *
1156  * The return value is the number of characters which would
1157  * be generated for the given input, excluding the trailing
1158  * '\0', as per ISO C99. If you want to have the exact
1159  * number of characters written into @buf as return value
1160  * (not including the trailing '\0'), use vscnprintf(). If the
1161  * return is greater than or equal to @size, the resulting
1162  * string is truncated.
1163  *
1164  * Call this function if you are already dealing with a va_list.
1165  * You probably want snprintf() instead.
1166  */
vsnprintf(char * buf,size_t size,const char * fmt,va_list args)1167 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1168 {
1169 	unsigned long long num;
1170 	char *str, *end;
1171 	struct printf_spec spec = {0};
1172 
1173 	/* Reject out-of-range values early.  Large positive sizes are
1174 	   used for unknown buffer sizes. */
1175 	if (WARN_ON_ONCE((int) size < 0))
1176 		return 0;
1177 
1178 	str = buf;
1179 	end = buf + size;
1180 
1181 	/* Make sure end is always >= buf */
1182 	if (end < buf) {
1183 		end = ((void *)-1);
1184 		size = end - buf;
1185 	}
1186 
1187 	while (*fmt) {
1188 		const char *old_fmt = fmt;
1189 		int read = format_decode(fmt, &spec);
1190 
1191 		fmt += read;
1192 
1193 		switch (spec.type) {
1194 		case FORMAT_TYPE_NONE: {
1195 			int copy = read;
1196 			if (str < end) {
1197 				if (copy > end - str)
1198 					copy = end - str;
1199 				memcpy(str, old_fmt, copy);
1200 			}
1201 			str += read;
1202 			break;
1203 		}
1204 
1205 		case FORMAT_TYPE_WIDTH:
1206 			spec.field_width = va_arg(args, int);
1207 			break;
1208 
1209 		case FORMAT_TYPE_PRECISION:
1210 			spec.precision = va_arg(args, int);
1211 			break;
1212 
1213 		case FORMAT_TYPE_CHAR: {
1214 			char c;
1215 
1216 			if (!(spec.flags & LEFT)) {
1217 				while (--spec.field_width > 0) {
1218 					if (str < end)
1219 						*str = ' ';
1220 					++str;
1221 
1222 				}
1223 			}
1224 			c = (unsigned char) va_arg(args, int);
1225 			if (str < end)
1226 				*str = c;
1227 			++str;
1228 			while (--spec.field_width > 0) {
1229 				if (str < end)
1230 					*str = ' ';
1231 				++str;
1232 			}
1233 			break;
1234 		}
1235 
1236 		case FORMAT_TYPE_STR:
1237 			str = string(str, end, va_arg(args, char *), spec);
1238 			break;
1239 
1240 		case FORMAT_TYPE_PTR:
1241 			str = pointer(fmt+1, str, end, va_arg(args, void *),
1242 				      spec);
1243 			while (isalnum(*fmt))
1244 				fmt++;
1245 			break;
1246 
1247 		case FORMAT_TYPE_PERCENT_CHAR:
1248 			if (str < end)
1249 				*str = '%';
1250 			++str;
1251 			break;
1252 
1253 		case FORMAT_TYPE_INVALID:
1254 			if (str < end)
1255 				*str = '%';
1256 			++str;
1257 			break;
1258 
1259 		case FORMAT_TYPE_NRCHARS: {
1260 			u8 qualifier = spec.qualifier;
1261 
1262 			if (qualifier == 'l') {
1263 				long *ip = va_arg(args, long *);
1264 				*ip = (str - buf);
1265 			} else if (TOLOWER(qualifier) == 'z') {
1266 				size_t *ip = va_arg(args, size_t *);
1267 				*ip = (str - buf);
1268 			} else {
1269 				int *ip = va_arg(args, int *);
1270 				*ip = (str - buf);
1271 			}
1272 			break;
1273 		}
1274 
1275 		default:
1276 			switch (spec.type) {
1277 			case FORMAT_TYPE_LONG_LONG:
1278 				num = va_arg(args, long long);
1279 				break;
1280 			case FORMAT_TYPE_ULONG:
1281 				num = va_arg(args, unsigned long);
1282 				break;
1283 			case FORMAT_TYPE_LONG:
1284 				num = va_arg(args, long);
1285 				break;
1286 			case FORMAT_TYPE_SIZE_T:
1287 				num = va_arg(args, size_t);
1288 				break;
1289 			case FORMAT_TYPE_PTRDIFF:
1290 				num = va_arg(args, ptrdiff_t);
1291 				break;
1292 			case FORMAT_TYPE_UBYTE:
1293 				num = (unsigned char) va_arg(args, int);
1294 				break;
1295 			case FORMAT_TYPE_BYTE:
1296 				num = (signed char) va_arg(args, int);
1297 				break;
1298 			case FORMAT_TYPE_USHORT:
1299 				num = (unsigned short) va_arg(args, int);
1300 				break;
1301 			case FORMAT_TYPE_SHORT:
1302 				num = (short) va_arg(args, int);
1303 				break;
1304 			case FORMAT_TYPE_INT:
1305 				num = (int) va_arg(args, int);
1306 				break;
1307 			default:
1308 				num = va_arg(args, unsigned int);
1309 			}
1310 
1311 			str = number(str, end, num, spec);
1312 		}
1313 	}
1314 
1315 	if (size > 0) {
1316 		if (str < end)
1317 			*str = '\0';
1318 		else
1319 			end[-1] = '\0';
1320 	}
1321 
1322 	/* the trailing null byte doesn't count towards the total */
1323 	return str-buf;
1324 
1325 }
1326 EXPORT_SYMBOL(vsnprintf);
1327 
1328 /**
1329  * vscnprintf - Format a string and place it in a buffer
1330  * @buf: The buffer to place the result into
1331  * @size: The size of the buffer, including the trailing null space
1332  * @fmt: The format string to use
1333  * @args: Arguments for the format string
1334  *
1335  * The return value is the number of characters which have been written into
1336  * the @buf not including the trailing '\0'. If @size is == 0 the function
1337  * returns 0.
1338  *
1339  * Call this function if you are already dealing with a va_list.
1340  * You probably want scnprintf() instead.
1341  *
1342  * See the vsnprintf() documentation for format string extensions over C99.
1343  */
vscnprintf(char * buf,size_t size,const char * fmt,va_list args)1344 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1345 {
1346 	int i;
1347 
1348 	i = vsnprintf(buf, size, fmt, args);
1349 
1350 	if (likely(i < size))
1351 		return i;
1352 	if (size != 0)
1353 		return size - 1;
1354 	return 0;
1355 }
1356 EXPORT_SYMBOL(vscnprintf);
1357 
1358 /**
1359  * snprintf - Format a string and place it in a buffer
1360  * @buf: The buffer to place the result into
1361  * @size: The size of the buffer, including the trailing null space
1362  * @fmt: The format string to use
1363  * @...: Arguments for the format string
1364  *
1365  * The return value is the number of characters which would be
1366  * generated for the given input, excluding the trailing null,
1367  * as per ISO C99.  If the return is greater than or equal to
1368  * @size, the resulting string is truncated.
1369  *
1370  * See the vsnprintf() documentation for format string extensions over C99.
1371  */
snprintf(char * buf,size_t size,const char * fmt,...)1372 int snprintf(char *buf, size_t size, const char *fmt, ...)
1373 {
1374 	va_list args;
1375 	int i;
1376 
1377 	va_start(args, fmt);
1378 	i = vsnprintf(buf, size, fmt, args);
1379 	va_end(args);
1380 
1381 	return i;
1382 }
1383 EXPORT_SYMBOL(snprintf);
1384 
1385 /**
1386  * scnprintf - Format a string and place it in a buffer
1387  * @buf: The buffer to place the result into
1388  * @size: The size of the buffer, including the trailing null space
1389  * @fmt: The format string to use
1390  * @...: Arguments for the format string
1391  *
1392  * The return value is the number of characters written into @buf not including
1393  * the trailing '\0'. If @size is == 0 the function returns 0.
1394  */
1395 
scnprintf(char * buf,size_t size,const char * fmt,...)1396 int scnprintf(char *buf, size_t size, const char *fmt, ...)
1397 {
1398 	va_list args;
1399 	int i;
1400 
1401 	va_start(args, fmt);
1402 	i = vscnprintf(buf, size, fmt, args);
1403 	va_end(args);
1404 
1405 	return i;
1406 }
1407 EXPORT_SYMBOL(scnprintf);
1408 
1409 /**
1410  * vsprintf - Format a string and place it in a buffer
1411  * @buf: The buffer to place the result into
1412  * @fmt: The format string to use
1413  * @args: Arguments for the format string
1414  *
1415  * The function returns the number of characters written
1416  * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
1417  * buffer overflows.
1418  *
1419  * Call this function if you are already dealing with a va_list.
1420  * You probably want sprintf() instead.
1421  *
1422  * See the vsnprintf() documentation for format string extensions over C99.
1423  */
vsprintf(char * buf,const char * fmt,va_list args)1424 int vsprintf(char *buf, const char *fmt, va_list args)
1425 {
1426 	return vsnprintf(buf, INT_MAX, fmt, args);
1427 }
1428 EXPORT_SYMBOL(vsprintf);
1429 
1430 /**
1431  * sprintf - Format a string and place it in a buffer
1432  * @buf: The buffer to place the result into
1433  * @fmt: The format string to use
1434  * @...: Arguments for the format string
1435  *
1436  * The function returns the number of characters written
1437  * into @buf. Use snprintf() or scnprintf() in order to avoid
1438  * buffer overflows.
1439  *
1440  * See the vsnprintf() documentation for format string extensions over C99.
1441  */
sprintf(char * buf,const char * fmt,...)1442 int sprintf(char *buf, const char *fmt, ...)
1443 {
1444 	va_list args;
1445 	int i;
1446 
1447 	va_start(args, fmt);
1448 	i = vsnprintf(buf, INT_MAX, fmt, args);
1449 	va_end(args);
1450 
1451 	return i;
1452 }
1453 EXPORT_SYMBOL(sprintf);
1454 
1455 #ifdef CONFIG_BINARY_PRINTF
1456 /*
1457  * bprintf service:
1458  * vbin_printf() - VA arguments to binary data
1459  * bstr_printf() - Binary data to text string
1460  */
1461 
1462 /**
1463  * vbin_printf - Parse a format string and place args' binary value in a buffer
1464  * @bin_buf: The buffer to place args' binary value
1465  * @size: The size of the buffer(by words(32bits), not characters)
1466  * @fmt: The format string to use
1467  * @args: Arguments for the format string
1468  *
1469  * The format follows C99 vsnprintf, except %n is ignored, and its argument
1470  * is skiped.
1471  *
1472  * The return value is the number of words(32bits) which would be generated for
1473  * the given input.
1474  *
1475  * NOTE:
1476  * If the return value is greater than @size, the resulting bin_buf is NOT
1477  * valid for bstr_printf().
1478  */
vbin_printf(u32 * bin_buf,size_t size,const char * fmt,va_list args)1479 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
1480 {
1481 	struct printf_spec spec = {0};
1482 	char *str, *end;
1483 
1484 	str = (char *)bin_buf;
1485 	end = (char *)(bin_buf + size);
1486 
1487 #define save_arg(type)							\
1488 do {									\
1489 	if (sizeof(type) == 8) {					\
1490 		unsigned long long value;				\
1491 		str = PTR_ALIGN(str, sizeof(u32));			\
1492 		value = va_arg(args, unsigned long long);		\
1493 		if (str + sizeof(type) <= end) {			\
1494 			*(u32 *)str = *(u32 *)&value;			\
1495 			*(u32 *)(str + 4) = *((u32 *)&value + 1);	\
1496 		}							\
1497 	} else {							\
1498 		unsigned long value;					\
1499 		str = PTR_ALIGN(str, sizeof(type));			\
1500 		value = va_arg(args, int);				\
1501 		if (str + sizeof(type) <= end)				\
1502 			*(typeof(type) *)str = (type)value;		\
1503 	}								\
1504 	str += sizeof(type);						\
1505 } while (0)
1506 
1507 	while (*fmt) {
1508 		int read = format_decode(fmt, &spec);
1509 
1510 		fmt += read;
1511 
1512 		switch (spec.type) {
1513 		case FORMAT_TYPE_NONE:
1514 		case FORMAT_TYPE_INVALID:
1515 		case FORMAT_TYPE_PERCENT_CHAR:
1516 			break;
1517 
1518 		case FORMAT_TYPE_WIDTH:
1519 		case FORMAT_TYPE_PRECISION:
1520 			save_arg(int);
1521 			break;
1522 
1523 		case FORMAT_TYPE_CHAR:
1524 			save_arg(char);
1525 			break;
1526 
1527 		case FORMAT_TYPE_STR: {
1528 			const char *save_str = va_arg(args, char *);
1529 			size_t len;
1530 
1531 			if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
1532 					|| (unsigned long)save_str < PAGE_SIZE)
1533 				save_str = "(null)";
1534 			len = strlen(save_str) + 1;
1535 			if (str + len < end)
1536 				memcpy(str, save_str, len);
1537 			str += len;
1538 			break;
1539 		}
1540 
1541 		case FORMAT_TYPE_PTR:
1542 			save_arg(void *);
1543 			/* skip all alphanumeric pointer suffixes */
1544 			while (isalnum(*fmt))
1545 				fmt++;
1546 			break;
1547 
1548 		case FORMAT_TYPE_NRCHARS: {
1549 			/* skip %n 's argument */
1550 			u8 qualifier = spec.qualifier;
1551 			void *skip_arg;
1552 			if (qualifier == 'l')
1553 				skip_arg = va_arg(args, long *);
1554 			else if (TOLOWER(qualifier) == 'z')
1555 				skip_arg = va_arg(args, size_t *);
1556 			else
1557 				skip_arg = va_arg(args, int *);
1558 			break;
1559 		}
1560 
1561 		default:
1562 			switch (spec.type) {
1563 
1564 			case FORMAT_TYPE_LONG_LONG:
1565 				save_arg(long long);
1566 				break;
1567 			case FORMAT_TYPE_ULONG:
1568 			case FORMAT_TYPE_LONG:
1569 				save_arg(unsigned long);
1570 				break;
1571 			case FORMAT_TYPE_SIZE_T:
1572 				save_arg(size_t);
1573 				break;
1574 			case FORMAT_TYPE_PTRDIFF:
1575 				save_arg(ptrdiff_t);
1576 				break;
1577 			case FORMAT_TYPE_UBYTE:
1578 			case FORMAT_TYPE_BYTE:
1579 				save_arg(char);
1580 				break;
1581 			case FORMAT_TYPE_USHORT:
1582 			case FORMAT_TYPE_SHORT:
1583 				save_arg(short);
1584 				break;
1585 			default:
1586 				save_arg(int);
1587 			}
1588 		}
1589 	}
1590 
1591 	return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
1592 #undef save_arg
1593 }
1594 EXPORT_SYMBOL_GPL(vbin_printf);
1595 
1596 /**
1597  * bstr_printf - Format a string from binary arguments and place it in a buffer
1598  * @buf: The buffer to place the result into
1599  * @size: The size of the buffer, including the trailing null space
1600  * @fmt: The format string to use
1601  * @bin_buf: Binary arguments for the format string
1602  *
1603  * This function like C99 vsnprintf, but the difference is that vsnprintf gets
1604  * arguments from stack, and bstr_printf gets arguments from @bin_buf which is
1605  * a binary buffer that generated by vbin_printf.
1606  *
1607  * The format follows C99 vsnprintf, but has some extensions:
1608  *  see vsnprintf comment for details.
1609  *
1610  * The return value is the number of characters which would
1611  * be generated for the given input, excluding the trailing
1612  * '\0', as per ISO C99. If you want to have the exact
1613  * number of characters written into @buf as return value
1614  * (not including the trailing '\0'), use vscnprintf(). If the
1615  * return is greater than or equal to @size, the resulting
1616  * string is truncated.
1617  */
bstr_printf(char * buf,size_t size,const char * fmt,const u32 * bin_buf)1618 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
1619 {
1620 	struct printf_spec spec = {0};
1621 	char *str, *end;
1622 	const char *args = (const char *)bin_buf;
1623 
1624 	if (WARN_ON_ONCE((int) size < 0))
1625 		return 0;
1626 
1627 	str = buf;
1628 	end = buf + size;
1629 
1630 #define get_arg(type)							\
1631 ({									\
1632 	typeof(type) value;						\
1633 	if (sizeof(type) == 8) {					\
1634 		args = PTR_ALIGN(args, sizeof(u32));			\
1635 		*(u32 *)&value = *(u32 *)args;				\
1636 		*((u32 *)&value + 1) = *(u32 *)(args + 4);		\
1637 	} else {							\
1638 		args = PTR_ALIGN(args, sizeof(type));			\
1639 		value = *(typeof(type) *)args;				\
1640 	}								\
1641 	args += sizeof(type);						\
1642 	value;								\
1643 })
1644 
1645 	/* Make sure end is always >= buf */
1646 	if (end < buf) {
1647 		end = ((void *)-1);
1648 		size = end - buf;
1649 	}
1650 
1651 	while (*fmt) {
1652 		const char *old_fmt = fmt;
1653 		int read = format_decode(fmt, &spec);
1654 
1655 		fmt += read;
1656 
1657 		switch (spec.type) {
1658 		case FORMAT_TYPE_NONE: {
1659 			int copy = read;
1660 			if (str < end) {
1661 				if (copy > end - str)
1662 					copy = end - str;
1663 				memcpy(str, old_fmt, copy);
1664 			}
1665 			str += read;
1666 			break;
1667 		}
1668 
1669 		case FORMAT_TYPE_WIDTH:
1670 			spec.field_width = get_arg(int);
1671 			break;
1672 
1673 		case FORMAT_TYPE_PRECISION:
1674 			spec.precision = get_arg(int);
1675 			break;
1676 
1677 		case FORMAT_TYPE_CHAR: {
1678 			char c;
1679 
1680 			if (!(spec.flags & LEFT)) {
1681 				while (--spec.field_width > 0) {
1682 					if (str < end)
1683 						*str = ' ';
1684 					++str;
1685 				}
1686 			}
1687 			c = (unsigned char) get_arg(char);
1688 			if (str < end)
1689 				*str = c;
1690 			++str;
1691 			while (--spec.field_width > 0) {
1692 				if (str < end)
1693 					*str = ' ';
1694 				++str;
1695 			}
1696 			break;
1697 		}
1698 
1699 		case FORMAT_TYPE_STR: {
1700 			const char *str_arg = args;
1701 			args += strlen(str_arg) + 1;
1702 			str = string(str, end, (char *)str_arg, spec);
1703 			break;
1704 		}
1705 
1706 		case FORMAT_TYPE_PTR:
1707 			str = pointer(fmt+1, str, end, get_arg(void *), spec);
1708 			while (isalnum(*fmt))
1709 				fmt++;
1710 			break;
1711 
1712 		case FORMAT_TYPE_PERCENT_CHAR:
1713 		case FORMAT_TYPE_INVALID:
1714 			if (str < end)
1715 				*str = '%';
1716 			++str;
1717 			break;
1718 
1719 		case FORMAT_TYPE_NRCHARS:
1720 			/* skip */
1721 			break;
1722 
1723 		default: {
1724 			unsigned long long num;
1725 
1726 			switch (spec.type) {
1727 
1728 			case FORMAT_TYPE_LONG_LONG:
1729 				num = get_arg(long long);
1730 				break;
1731 			case FORMAT_TYPE_ULONG:
1732 			case FORMAT_TYPE_LONG:
1733 				num = get_arg(unsigned long);
1734 				break;
1735 			case FORMAT_TYPE_SIZE_T:
1736 				num = get_arg(size_t);
1737 				break;
1738 			case FORMAT_TYPE_PTRDIFF:
1739 				num = get_arg(ptrdiff_t);
1740 				break;
1741 			case FORMAT_TYPE_UBYTE:
1742 				num = get_arg(unsigned char);
1743 				break;
1744 			case FORMAT_TYPE_BYTE:
1745 				num = get_arg(signed char);
1746 				break;
1747 			case FORMAT_TYPE_USHORT:
1748 				num = get_arg(unsigned short);
1749 				break;
1750 			case FORMAT_TYPE_SHORT:
1751 				num = get_arg(short);
1752 				break;
1753 			case FORMAT_TYPE_UINT:
1754 				num = get_arg(unsigned int);
1755 				break;
1756 			default:
1757 				num = get_arg(int);
1758 			}
1759 
1760 			str = number(str, end, num, spec);
1761 		} /* default: */
1762 		} /* switch(spec.type) */
1763 	} /* while(*fmt) */
1764 
1765 	if (size > 0) {
1766 		if (str < end)
1767 			*str = '\0';
1768 		else
1769 			end[-1] = '\0';
1770 	}
1771 
1772 #undef get_arg
1773 
1774 	/* the trailing null byte doesn't count towards the total */
1775 	return str - buf;
1776 }
1777 EXPORT_SYMBOL_GPL(bstr_printf);
1778 
1779 /**
1780  * bprintf - Parse a format string and place args' binary value in a buffer
1781  * @bin_buf: The buffer to place args' binary value
1782  * @size: The size of the buffer(by words(32bits), not characters)
1783  * @fmt: The format string to use
1784  * @...: Arguments for the format string
1785  *
1786  * The function returns the number of words(u32) written
1787  * into @bin_buf.
1788  */
bprintf(u32 * bin_buf,size_t size,const char * fmt,...)1789 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
1790 {
1791 	va_list args;
1792 	int ret;
1793 
1794 	va_start(args, fmt);
1795 	ret = vbin_printf(bin_buf, size, fmt, args);
1796 	va_end(args);
1797 
1798 	return ret;
1799 }
1800 EXPORT_SYMBOL_GPL(bprintf);
1801 
1802 #endif /* CONFIG_BINARY_PRINTF */
1803 
1804 /**
1805  * vsscanf - Unformat a buffer into a list of arguments
1806  * @buf:	input buffer
1807  * @fmt:	format of buffer
1808  * @args:	arguments
1809  */
vsscanf(const char * buf,const char * fmt,va_list args)1810 int vsscanf(const char *buf, const char *fmt, va_list args)
1811 {
1812 	const char *str = buf;
1813 	char *next;
1814 	char digit;
1815 	int num = 0;
1816 	u8 qualifier;
1817 	u8 base;
1818 	s16 field_width;
1819 	bool is_sign;
1820 
1821 	while (*fmt && *str) {
1822 		/* skip any white space in format */
1823 		/* white space in format matchs any amount of
1824 		 * white space, including none, in the input.
1825 		 */
1826 		if (isspace(*fmt)) {
1827 			fmt = skip_spaces(++fmt);
1828 			str = skip_spaces(str);
1829 		}
1830 
1831 		/* anything that is not a conversion must match exactly */
1832 		if (*fmt != '%' && *fmt) {
1833 			if (*fmt++ != *str++)
1834 				break;
1835 			continue;
1836 		}
1837 
1838 		if (!*fmt)
1839 			break;
1840 		++fmt;
1841 
1842 		/* skip this conversion.
1843 		 * advance both strings to next white space
1844 		 */
1845 		if (*fmt == '*') {
1846 			while (!isspace(*fmt) && *fmt != '%' && *fmt)
1847 				fmt++;
1848 			while (!isspace(*str) && *str)
1849 				str++;
1850 			continue;
1851 		}
1852 
1853 		/* get field width */
1854 		field_width = -1;
1855 		if (isdigit(*fmt))
1856 			field_width = skip_atoi(&fmt);
1857 
1858 		/* get conversion qualifier */
1859 		qualifier = -1;
1860 		if (*fmt == 'h' || TOLOWER(*fmt) == 'l' ||
1861 		    TOLOWER(*fmt) == 'z') {
1862 			qualifier = *fmt++;
1863 			if (unlikely(qualifier == *fmt)) {
1864 				if (qualifier == 'h') {
1865 					qualifier = 'H';
1866 					fmt++;
1867 				} else if (qualifier == 'l') {
1868 					qualifier = 'L';
1869 					fmt++;
1870 				}
1871 			}
1872 		}
1873 
1874 		if (!*fmt || !*str)
1875 			break;
1876 
1877 		base = 10;
1878 		is_sign = 0;
1879 
1880 		switch (*fmt++) {
1881 		case 'c':
1882 		{
1883 			char *s = (char *)va_arg(args, char*);
1884 			if (field_width == -1)
1885 				field_width = 1;
1886 			do {
1887 				*s++ = *str++;
1888 			} while (--field_width > 0 && *str);
1889 			num++;
1890 		}
1891 		continue;
1892 		case 's':
1893 		{
1894 			char *s = (char *)va_arg(args, char *);
1895 			if (field_width == -1)
1896 				field_width = SHRT_MAX;
1897 			/* first, skip leading white space in buffer */
1898 			str = skip_spaces(str);
1899 
1900 			/* now copy until next white space */
1901 			while (*str && !isspace(*str) && field_width--)
1902 				*s++ = *str++;
1903 			*s = '\0';
1904 			num++;
1905 		}
1906 		continue;
1907 		case 'n':
1908 			/* return number of characters read so far */
1909 		{
1910 			int *i = (int *)va_arg(args, int*);
1911 			*i = str - buf;
1912 		}
1913 		continue;
1914 		case 'o':
1915 			base = 8;
1916 			break;
1917 		case 'x':
1918 		case 'X':
1919 			base = 16;
1920 			break;
1921 		case 'i':
1922 			base = 0;
1923 		case 'd':
1924 			is_sign = 1;
1925 		case 'u':
1926 			break;
1927 		case '%':
1928 			/* looking for '%' in str */
1929 			if (*str++ != '%')
1930 				return num;
1931 			continue;
1932 		default:
1933 			/* invalid format; stop here */
1934 			return num;
1935 		}
1936 
1937 		/* have some sort of integer conversion.
1938 		 * first, skip white space in buffer.
1939 		 */
1940 		str = skip_spaces(str);
1941 
1942 		digit = *str;
1943 		if (is_sign && digit == '-')
1944 			digit = *(str + 1);
1945 
1946 		if (!digit
1947 		    || (base == 16 && !isxdigit(digit))
1948 		    || (base == 10 && !isdigit(digit))
1949 		    || (base == 8 && (!isdigit(digit) || digit > '7'))
1950 		    || (base == 0 && !isdigit(digit)))
1951 			break;
1952 
1953 		switch (qualifier) {
1954 		case 'H':	/* that's 'hh' in format */
1955 			if (is_sign) {
1956 				signed char *s = (signed char *)va_arg(args, signed char *);
1957 				*s = (signed char)simple_strtol(str, &next, base);
1958 			} else {
1959 				unsigned char *s = (unsigned char *)va_arg(args, unsigned char *);
1960 				*s = (unsigned char)simple_strtoul(str, &next, base);
1961 			}
1962 			break;
1963 		case 'h':
1964 			if (is_sign) {
1965 				short *s = (short *)va_arg(args, short *);
1966 				*s = (short)simple_strtol(str, &next, base);
1967 			} else {
1968 				unsigned short *s = (unsigned short *)va_arg(args, unsigned short *);
1969 				*s = (unsigned short)simple_strtoul(str, &next, base);
1970 			}
1971 			break;
1972 		case 'l':
1973 			if (is_sign) {
1974 				long *l = (long *)va_arg(args, long *);
1975 				*l = simple_strtol(str, &next, base);
1976 			} else {
1977 				unsigned long *l = (unsigned long *)va_arg(args, unsigned long *);
1978 				*l = simple_strtoul(str, &next, base);
1979 			}
1980 			break;
1981 		case 'L':
1982 			if (is_sign) {
1983 				long long *l = (long long *)va_arg(args, long long *);
1984 				*l = simple_strtoll(str, &next, base);
1985 			} else {
1986 				unsigned long long *l = (unsigned long long *)va_arg(args, unsigned long long *);
1987 				*l = simple_strtoull(str, &next, base);
1988 			}
1989 			break;
1990 		case 'Z':
1991 		case 'z':
1992 		{
1993 			size_t *s = (size_t *)va_arg(args, size_t *);
1994 			*s = (size_t)simple_strtoul(str, &next, base);
1995 		}
1996 		break;
1997 		default:
1998 			if (is_sign) {
1999 				int *i = (int *)va_arg(args, int *);
2000 				*i = (int)simple_strtol(str, &next, base);
2001 			} else {
2002 				unsigned int *i = (unsigned int *)va_arg(args, unsigned int*);
2003 				*i = (unsigned int)simple_strtoul(str, &next, base);
2004 			}
2005 			break;
2006 		}
2007 		num++;
2008 
2009 		if (!next)
2010 			break;
2011 		str = next;
2012 	}
2013 
2014 	/*
2015 	 * Now we've come all the way through so either the input string or the
2016 	 * format ended. In the former case, there can be a %n at the current
2017 	 * position in the format that needs to be filled.
2018 	 */
2019 	if (*fmt == '%' && *(fmt + 1) == 'n') {
2020 		int *p = (int *)va_arg(args, int *);
2021 		*p = str - buf;
2022 	}
2023 
2024 	return num;
2025 }
2026 EXPORT_SYMBOL(vsscanf);
2027 
2028 /**
2029  * sscanf - Unformat a buffer into a list of arguments
2030  * @buf:	input buffer
2031  * @fmt:	formatting of buffer
2032  * @...:	resulting arguments
2033  */
sscanf(const char * buf,const char * fmt,...)2034 int sscanf(const char *buf, const char *fmt, ...)
2035 {
2036 	va_list args;
2037 	int i;
2038 
2039 	va_start(args, fmt);
2040 	i = vsscanf(buf, fmt, args);
2041 	va_end(args);
2042 
2043 	return i;
2044 }
2045 EXPORT_SYMBOL(sscanf);
2046