vsprintf.c 53.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11
/*
 *  linux/lib/vsprintf.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
/*
 * Wirzenius wrote this portably, Torvalds fucked it up :-)
 */

12
/*
Linus Torvalds's avatar
Linus Torvalds committed
13 14 15 16 17 18 19
 * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
 * - changed to provide snprintf and vsnprintf functions
 * So Feb  1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>
 * - scnprintf and vscnprintf
 */

#include <stdarg.h>
20
#include <linux/module.h>	/* for KSYM_SYMBOL_LEN */
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/kernel.h>
25
#include <linux/kallsyms.h>
26
#include <linux/math64.h>
27
#include <linux/uaccess.h>
28
#include <linux/ioport.h>
29
#include <net/addrconf.h>
Linus Torvalds's avatar
Linus Torvalds committed
30

31
#include <asm/page.h>		/* for PAGE_SIZE */
32
#include <asm/sections.h>	/* for dereference_function_descriptor() */
Linus Torvalds's avatar
Linus Torvalds committed
33

34
#include "kstrtox.h"
35

Linus Torvalds's avatar
Linus Torvalds committed
36
/**
37
 * simple_strtoull - convert a string to an unsigned long long
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40
 * @cp: The start of the string
 * @endp: A pointer to the end of the parsed string will be placed here
 * @base: The number base to use
41 42
 *
 * This function is obsolete. Please use kstrtoull instead.
Linus Torvalds's avatar
Linus Torvalds committed
43
 */
44
unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
Linus Torvalds's avatar
Linus Torvalds committed
45
{
46 47
	unsigned long long result;
	unsigned int rv;
48

49 50 51 52
	cp = _parse_integer_fixup_radix(cp, &base);
	rv = _parse_integer(cp, base, &result);
	/* FIXME */
	cp += (rv & ~KSTRTOX_OVERFLOW);
53

Linus Torvalds's avatar
Linus Torvalds committed
54 55
	if (endp)
		*endp = (char *)cp;
56

Linus Torvalds's avatar
Linus Torvalds committed
57 58
	return result;
}
59
EXPORT_SYMBOL(simple_strtoull);
Linus Torvalds's avatar
Linus Torvalds committed
60 61

/**
62
 * simple_strtoul - convert a string to an unsigned long
Linus Torvalds's avatar
Linus Torvalds committed
63 64 65
 * @cp: The start of the string
 * @endp: A pointer to the end of the parsed string will be placed here
 * @base: The number base to use
66 67
 *
 * This function is obsolete. Please use kstrtoul instead.
Linus Torvalds's avatar
Linus Torvalds committed
68
 */
69
unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
Linus Torvalds's avatar
Linus Torvalds committed
70
{
71
	return simple_strtoull(cp, endp, base);
Linus Torvalds's avatar
Linus Torvalds committed
72
}
73
EXPORT_SYMBOL(simple_strtoul);
Linus Torvalds's avatar
Linus Torvalds committed
74 75

/**
76
 * simple_strtol - convert a string to a signed long
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79
 * @cp: The start of the string
 * @endp: A pointer to the end of the parsed string will be placed here
 * @base: The number base to use
80 81
 *
 * This function is obsolete. Please use kstrtol instead.
Linus Torvalds's avatar
Linus Torvalds committed
82
 */
83
long simple_strtol(const char *cp, char **endp, unsigned int base)
Linus Torvalds's avatar
Linus Torvalds committed
84
{
85 86
	if (*cp == '-')
		return -simple_strtoul(cp + 1, endp, base);
87

88
	return simple_strtoul(cp, endp, base);
Linus Torvalds's avatar
Linus Torvalds committed
89
}
90
EXPORT_SYMBOL(simple_strtol);
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93 94 95 96

/**
 * simple_strtoll - convert a string to a signed long long
 * @cp: The start of the string
 * @endp: A pointer to the end of the parsed string will be placed here
 * @base: The number base to use
97 98
 *
 * This function is obsolete. Please use kstrtoll instead.
Linus Torvalds's avatar
Linus Torvalds committed
99
 */
100
long long simple_strtoll(const char *cp, char **endp, unsigned int base)
Linus Torvalds's avatar
Linus Torvalds committed
101
{
102
	if (*cp == '-')
103
		return -simple_strtoull(cp + 1, endp, base);
104

105
	return simple_strtoull(cp, endp, base);
Linus Torvalds's avatar
Linus Torvalds committed
106
}
107
EXPORT_SYMBOL(simple_strtoll);
Linus Torvalds's avatar
Linus Torvalds committed
108

109 110
static noinline_for_stack
int skip_atoi(const char **s)
Linus Torvalds's avatar
Linus Torvalds committed
111
{
112
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
113 114 115

	while (isdigit(**s))
		i = i*10 + *((*s)++) - '0';
116

Linus Torvalds's avatar
Linus Torvalds committed
117 118 119
	return i;
}

120 121 122
/* Decimal conversion is by far the most typical, and is used
 * for /proc and /sys data. This directly impacts e.g. top performance
 * with many processes running. We optimize it for speed
123 124 125
 * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
 * (with permission from the author, Douglas W. Jones).
 */
126

127 128
#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
/* Formats correctly any integer in [0, 999999999] */
129
static noinline_for_stack
130
char *put_dec_full9(char *buf, unsigned q)
131
{
132
	unsigned r;
133

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
	/*
	 * Possible ways to approx. divide by 10
	 * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit)
	 * (x * 0xcccd) >> 19     x <      81920 (x < 262149 when 64-bit mul)
	 * (x * 0x6667) >> 18     x <      43699
	 * (x * 0x3334) >> 17     x <      16389
	 * (x * 0x199a) >> 16     x <      16389
	 * (x * 0x0ccd) >> 15     x <      16389
	 * (x * 0x0667) >> 14     x <       2739
	 * (x * 0x0334) >> 13     x <       1029
	 * (x * 0x019a) >> 12     x <       1029
	 * (x * 0x00cd) >> 11     x <       1029 shorter code than * 0x67 (on i386)
	 * (x * 0x0067) >> 10     x <        179
	 * (x * 0x0034) >>  9     x <         69 same
	 * (x * 0x001a) >>  8     x <         69 same
	 * (x * 0x000d) >>  7     x <         69 same, shortest code (on i386)
	 * (x * 0x0007) >>  6     x <         19
	 * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html>
	 */
	r      = (q * (uint64_t)0x1999999a) >> 32;
	*buf++ = (q - 10 * r) + '0'; /* 1 */
	q      = (r * (uint64_t)0x1999999a) >> 32;
	*buf++ = (r - 10 * q) + '0'; /* 2 */
	r      = (q * (uint64_t)0x1999999a) >> 32;
	*buf++ = (q - 10 * r) + '0'; /* 3 */
	q      = (r * (uint64_t)0x1999999a) >> 32;
	*buf++ = (r - 10 * q) + '0'; /* 4 */
	r      = (q * (uint64_t)0x1999999a) >> 32;
	*buf++ = (q - 10 * r) + '0'; /* 5 */
	/* Now value is under 10000, can avoid 64-bit multiply */
	q      = (r * 0x199a) >> 16;
	*buf++ = (r - 10 * q)  + '0'; /* 6 */
	r      = (q * 0xcd) >> 11;
	*buf++ = (q - 10 * r)  + '0'; /* 7 */
	q      = (r * 0xcd) >> 11;
	*buf++ = (r - 10 * q) + '0'; /* 8 */
	*buf++ = q + '0'; /* 9 */
171 172
	return buf;
}
173 174 175 176 177 178
#endif

/* Similar to above but do not pad with zeros.
 * Code can be easily arranged to print 9 digits too, but our callers
 * always call put_dec_full9() instead when the number has 9 decimal digits.
 */
179
static noinline_for_stack
180
char *put_dec_trunc8(char *buf, unsigned r)
181
{
182 183 184
	unsigned q;

	/* Copy of previous function's body with added early returns */
185 186 187 188 189 190
	while (r >= 10000) {
		q = r + '0';
		r  = (r * (uint64_t)0x1999999a) >> 32;
		*buf++ = q - 10*r;
	}

191 192
	q      = (r * 0x199a) >> 16;	/* r <= 9999 */
	*buf++ = (r - 10 * q)  + '0';
193 194
	if (q == 0)
		return buf;
195 196
	r      = (q * 0xcd) >> 11;	/* q <= 999 */
	*buf++ = (q - 10 * r)  + '0';
197 198
	if (r == 0)
		return buf;
199 200
	q      = (r * 0xcd) >> 11;	/* r <= 99 */
	*buf++ = (r - 10 * q) + '0';
201 202
	if (q == 0)
		return buf;
203
	*buf++ = q + '0';		 /* q <= 9 */
204 205
	return buf;
}
206

207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
/* There are two algorithms to print larger numbers.
 * One is generic: divide by 1000000000 and repeatedly print
 * groups of (up to) 9 digits. It's conceptually simple,
 * but requires a (unsigned long long) / 1000000000 division.
 *
 * Second algorithm splits 64-bit unsigned long long into 16-bit chunks,
 * manipulates them cleverly and generates groups of 4 decimal digits.
 * It so happens that it does NOT require long long division.
 *
 * If long is > 32 bits, division of 64-bit values is relatively easy,
 * and we will use the first algorithm.
 * If long long is > 64 bits (strange architecture with VERY large long long),
 * second algorithm can't be used, and we again use the first one.
 *
 * Else (if long is 32 bits and long long is 64 bits) we use second one.
 */
223

224 225 226 227 228 229 230 231 232 233 234 235 236 237
#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64

/* First algorithm: generic */

static
char *put_dec(char *buf, unsigned long long n)
{
	if (n >= 100*1000*1000) {
		while (n >= 1000*1000*1000)
			buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
		if (n >= 100*1000*1000)
			return put_dec_full9(buf, n);
	}
	return put_dec_trunc8(buf, n);
238
}
239 240 241 242 243

#else

/* Second algorithm: valid only for 64-bit long longs */

244
/* See comment in put_dec_full9 for choice of constants */
245
static noinline_for_stack
246
void put_dec_full4(char *buf, unsigned q)
247
{
248
	unsigned r;
249
	r      = (q * 0xccd) >> 15;
250
	buf[0] = (q - 10 * r) + '0';
251
	q      = (r * 0xcd) >> 11;
252
	buf[1] = (r - 10 * q)  + '0';
253
	r      = (q * 0xcd) >> 11;
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
	buf[2] = (q - 10 * r)  + '0';
	buf[3] = r + '0';
}

/*
 * Call put_dec_full4 on x % 10000, return x / 10000.
 * The approximation x/10000 == (x * 0x346DC5D7) >> 43
 * holds for all x < 1,128,869,999.  The largest value this
 * helper will ever be asked to convert is 1,125,520,955.
 * (d1 in the put_dec code, assuming n is all-ones).
 */
static
unsigned put_dec_helper4(char *buf, unsigned x)
{
        uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;

        put_dec_full4(buf, x - q * 10000);
        return q;
272 273
}

274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
/* Based on code by Douglas W. Jones found at
 * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
 * (with permission from the author).
 * Performs no 64-bit division and hence should be fast on 32-bit machines.
 */
static
char *put_dec(char *buf, unsigned long long n)
{
	uint32_t d3, d2, d1, q, h;

	if (n < 100*1000*1000)
		return put_dec_trunc8(buf, n);

	d1  = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
	h   = (n >> 32);
	d2  = (h      ) & 0xffff;
	d3  = (h >> 16); /* implicit "& 0xffff" */

	q   = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
293 294 295 296 297 298 299
	q = put_dec_helper4(buf, q);

	q += 7671 * d3 + 9496 * d2 + 6 * d1;
	q = put_dec_helper4(buf+4, q);

	q += 4749 * d3 + 42 * d2;
	q = put_dec_helper4(buf+8, q);
300

301 302 303 304 305
	q += 281 * d3;
	buf += 12;
	if (q)
		buf = put_dec_trunc8(buf, q);
	else while (buf[-1] == '0')
306 307 308 309 310 311 312
		--buf;

	return buf;
}

#endif

313 314 315 316 317 318 319 320
/*
 * Convert passed number to decimal string.
 * Returns the length of string.  On buffer overflow, returns 0.
 *
 * If speed is not important, use snprintf(). It's easy to read the code.
 */
int num_to_str(char *buf, int size, unsigned long long num)
{
321
	char tmp[sizeof(num) * 3];
322 323
	int idx, len;

324 325 326 327 328 329 330
	/* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
	if (num <= 9) {
		tmp[0] = '0' + num;
		len = 1;
	} else {
		len = put_dec(tmp, num) - tmp;
	}
331 332 333 334 335

	if (len > size)
		return 0;
	for (idx = 0; idx < len; ++idx)
		buf[idx] = tmp[len - idx - 1];
336
	return len;
337 338
}

Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343
#define ZEROPAD	1		/* pad with zero */
#define SIGN	2		/* unsigned/signed long */
#define PLUS	4		/* show plus */
#define SPACE	8		/* space if plus */
#define LEFT	16		/* left justified */
344 345
#define SMALL	32		/* use lowercase in hex (must be 32 == 0x20) */
#define SPECIAL	64		/* prefix hex with "0x", octal with "0" */
Linus Torvalds's avatar
Linus Torvalds committed
346

347 348
enum format_type {
	FORMAT_TYPE_NONE, /* Just a string part */
349
	FORMAT_TYPE_WIDTH,
350 351 352 353 354 355 356 357 358
	FORMAT_TYPE_PRECISION,
	FORMAT_TYPE_CHAR,
	FORMAT_TYPE_STR,
	FORMAT_TYPE_PTR,
	FORMAT_TYPE_PERCENT_CHAR,
	FORMAT_TYPE_INVALID,
	FORMAT_TYPE_LONG_LONG,
	FORMAT_TYPE_ULONG,
	FORMAT_TYPE_LONG,
359 360
	FORMAT_TYPE_UBYTE,
	FORMAT_TYPE_BYTE,
361 362 363 364 365 366 367 368 369 370
	FORMAT_TYPE_USHORT,
	FORMAT_TYPE_SHORT,
	FORMAT_TYPE_UINT,
	FORMAT_TYPE_INT,
	FORMAT_TYPE_NRCHARS,
	FORMAT_TYPE_SIZE_T,
	FORMAT_TYPE_PTRDIFF
};

struct printf_spec {
371
	u8	type;		/* format_type enum */
372
	u8	flags;		/* flags to number() */
373 374 375 376
	u8	base;		/* number base, 8, 10 or 16 only */
	u8	qualifier;	/* number qualifier, one of 'hHlLtzZ' */
	s16	field_width;	/* width of output field */
	s16	precision;	/* # of digits/chars */
377 378
};

379 380 381
static noinline_for_stack
char *number(char *buf, char *end, unsigned long long num,
	     struct printf_spec spec)
Linus Torvalds's avatar
Linus Torvalds committed
382
{
383 384 385 386 387 388
	/* we are called with base 8, 10 or 16, only, thus don't need "G..."  */
	static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */

	char tmp[66];
	char sign;
	char locase;
389
	int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
Linus Torvalds's avatar
Linus Torvalds committed
390
	int i;
391
	bool is_zero = num == 0LL;
Linus Torvalds's avatar
Linus Torvalds committed
392

393 394
	/* locase = 0 or 0x20. ORing digits or letters with 'locase'
	 * produces same digits or (maybe lowercased) letters */
395 396 397
	locase = (spec.flags & SMALL);
	if (spec.flags & LEFT)
		spec.flags &= ~ZEROPAD;
Linus Torvalds's avatar
Linus Torvalds committed
398
	sign = 0;
399
	if (spec.flags & SIGN) {
400
		if ((signed long long)num < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
401
			sign = '-';
402
			num = -(signed long long)num;
403 404
			spec.field_width--;
		} else if (spec.flags & PLUS) {
Linus Torvalds's avatar
Linus Torvalds committed
405
			sign = '+';
406 407
			spec.field_width--;
		} else if (spec.flags & SPACE) {
Linus Torvalds's avatar
Linus Torvalds committed
408
			sign = ' ';
409
			spec.field_width--;
Linus Torvalds's avatar
Linus Torvalds committed
410 411
		}
	}
412
	if (need_pfx) {
413
		if (spec.base == 16)
414 415
			spec.field_width -= 2;
		else if (!is_zero)
416
			spec.field_width--;
Linus Torvalds's avatar
Linus Torvalds committed
417
	}
418 419

	/* generate full string in tmp[], in reverse order */
Linus Torvalds's avatar
Linus Torvalds committed
420
	i = 0;
421 422
	if (num < spec.base)
		tmp[i++] = digits[num] | locase;
423 424
	/* Generic code, for any base:
	else do {
425
		tmp[i++] = (digits[do_div(num,base)] | locase);
426 427
	} while (num != 0);
	*/
428 429
	else if (spec.base != 10) { /* 8 or 16 */
		int mask = spec.base - 1;
430
		int shift = 3;
431 432 433

		if (spec.base == 16)
			shift = 4;
434
		do {
435
			tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
436 437
			num >>= shift;
		} while (num);
438 439 440
	} else { /* base 10 */
		i = put_dec(tmp, num) - tmp;
	}
441 442

	/* printing 100 using %2d gives "100", not "00" */
443 444
	if (i > spec.precision)
		spec.precision = i;
445
	/* leading space padding */
446 447
	spec.field_width -= spec.precision;
	if (!(spec.flags & (ZEROPAD+LEFT))) {
448
		while (--spec.field_width >= 0) {
449
			if (buf < end)
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453
				*buf = ' ';
			++buf;
		}
	}
454
	/* sign */
Linus Torvalds's avatar
Linus Torvalds committed
455
	if (sign) {
456
		if (buf < end)
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459
			*buf = sign;
		++buf;
	}
460 461
	/* "0x" / "0" prefix */
	if (need_pfx) {
462 463 464 465 466
		if (spec.base == 16 || !is_zero) {
			if (buf < end)
				*buf = '0';
			++buf;
		}
467
		if (spec.base == 16) {
468
			if (buf < end)
469
				*buf = ('X' | locase);
Linus Torvalds's avatar
Linus Torvalds committed
470 471 472
			++buf;
		}
	}
473
	/* zero or space padding */
474 475 476
	if (!(spec.flags & LEFT)) {
		char c = (spec.flags & ZEROPAD) ? '0' : ' ';
		while (--spec.field_width >= 0) {
477
			if (buf < end)
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480 481
				*buf = c;
			++buf;
		}
	}
482
	/* hmm even more zero padding? */
483
	while (i <= --spec.precision) {
484
		if (buf < end)
Linus Torvalds's avatar
Linus Torvalds committed
485 486 487
			*buf = '0';
		++buf;
	}
488 489
	/* actual digits of result */
	while (--i >= 0) {
490
		if (buf < end)
Linus Torvalds's avatar
Linus Torvalds committed
491 492 493
			*buf = tmp[i];
		++buf;
	}
494
	/* trailing space padding */
495
	while (--spec.field_width >= 0) {
496
		if (buf < end)
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499
			*buf = ' ';
		++buf;
	}
500

Linus Torvalds's avatar
Linus Torvalds committed
501 502 503
	return buf;
}

504 505
static noinline_for_stack
char *string(char *buf, char *end, const char *s, struct printf_spec spec)
506 507 508 509
{
	int len, i;

	if ((unsigned long)s < PAGE_SIZE)
510
		s = "(null)";
511

512
	len = strnlen(s, spec.precision);
513

514 515
	if (!(spec.flags & LEFT)) {
		while (len < spec.field_width--) {
516 517 518 519 520 521 522 523 524 525
			if (buf < end)
				*buf = ' ';
			++buf;
		}
	}
	for (i = 0; i < len; ++i) {
		if (buf < end)
			*buf = *s;
		++buf; ++s;
	}
526
	while (len < spec.field_width--) {
527 528 529 530
		if (buf < end)
			*buf = ' ';
		++buf;
	}
531

532 533 534
	return buf;
}

535 536
static noinline_for_stack
char *symbol_string(char *buf, char *end, void *ptr,
537
		    struct printf_spec spec, const char *fmt)
538
{
539
	unsigned long value;
540 541
#ifdef CONFIG_KALLSYMS
	char sym[KSYM_SYMBOL_LEN];
542 543 544 545 546 547 548 549
#endif

	if (fmt[1] == 'R')
		ptr = __builtin_extract_return_addr(ptr);
	value = (unsigned long)ptr;

#ifdef CONFIG_KALLSYMS
	if (*fmt == 'B')
550
		sprint_backtrace(sym, value);
551
	else if (*fmt != 'f' && *fmt != 's')
552 553
		sprint_symbol(sym, value);
	else
554
		sprint_symbol_no_offset(sym, value);
555

556
	return string(buf, end, sym, spec);
557
#else
558
	spec.field_width = 2 * sizeof(void *);
559 560
	spec.flags |= SPECIAL | SMALL | ZEROPAD;
	spec.base = 16;
561

562
	return number(buf, end, value, spec);
563 564 565
#endif
}

566 567 568
static noinline_for_stack
char *resource_string(char *buf, char *end, struct resource *res,
		      struct printf_spec spec, const char *fmt)
569 570
{
#ifndef IO_RSRC_PRINTK_SIZE
571
#define IO_RSRC_PRINTK_SIZE	6
572 573 574
#endif

#ifndef MEM_RSRC_PRINTK_SIZE
575
#define MEM_RSRC_PRINTK_SIZE	10
576
#endif
577
	static const struct printf_spec io_spec = {
578
		.base = 16,
579
		.field_width = IO_RSRC_PRINTK_SIZE,
580 581 582
		.precision = -1,
		.flags = SPECIAL | SMALL | ZEROPAD,
	};
583 584 585 586 587 588
	static const struct printf_spec mem_spec = {
		.base = 16,
		.field_width = MEM_RSRC_PRINTK_SIZE,
		.precision = -1,
		.flags = SPECIAL | SMALL | ZEROPAD,
	};
589 590 591 592 593 594
	static const struct printf_spec bus_spec = {
		.base = 16,
		.field_width = 2,
		.precision = -1,
		.flags = SMALL | ZEROPAD,
	};
595
	static const struct printf_spec dec_spec = {
596 597 598 599
		.base = 10,
		.precision = -1,
		.flags = 0,
	};
600
	static const struct printf_spec str_spec = {
601 602 603 604
		.field_width = -1,
		.precision = 10,
		.flags = LEFT,
	};
605
	static const struct printf_spec flag_spec = {
606 607 608 609
		.base = 16,
		.precision = -1,
		.flags = SPECIAL | SMALL,
	};
610 611 612 613 614

	/* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
	 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
#define RSRC_BUF_SIZE		((2 * sizeof(resource_size_t)) + 4)
#define FLAG_BUF_SIZE		(2 * sizeof(res->flags))
615
#define DECODED_BUF_SIZE	sizeof("[mem - 64bit pref window disabled]")
616 617 618 619
#define RAW_BUF_SIZE		sizeof("[mem - flags 0x]")
	char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
		     2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];

620
	char *p = sym, *pend = sym + sizeof(sym);
621
	int decode = (fmt[0] == 'R') ? 1 : 0;
622
	const struct printf_spec *specp;
623 624

	*p++ = '[';
625
	if (res->flags & IORESOURCE_IO) {
626
		p = string(p, pend, "io  ", str_spec);
627 628
		specp = &io_spec;
	} else if (res->flags & IORESOURCE_MEM) {
629
		p = string(p, pend, "mem ", str_spec);
630 631
		specp = &mem_spec;
	} else if (res->flags & IORESOURCE_IRQ) {
632
		p = string(p, pend, "irq ", str_spec);
633 634
		specp = &dec_spec;
	} else if (res->flags & IORESOURCE_DMA) {
635
		p = string(p, pend, "dma ", str_spec);
636
		specp = &dec_spec;
637 638 639
	} else if (res->flags & IORESOURCE_BUS) {
		p = string(p, pend, "bus ", str_spec);
		specp = &bus_spec;
640
	} else {
641
		p = string(p, pend, "??? ", str_spec);
642
		specp = &mem_spec;
643
		decode = 0;
644
	}
645
	p = number(p, pend, res->start, *specp);
646 647
	if (res->start != res->end) {
		*p++ = '-';
648
		p = number(p, pend, res->end, *specp);
649
	}
650
	if (decode) {
651 652 653 654
		if (res->flags & IORESOURCE_MEM_64)
			p = string(p, pend, " 64bit", str_spec);
		if (res->flags & IORESOURCE_PREFETCH)
			p = string(p, pend, " pref", str_spec);
655 656
		if (res->flags & IORESOURCE_WINDOW)
			p = string(p, pend, " window", str_spec);
657 658
		if (res->flags & IORESOURCE_DISABLED)
			p = string(p, pend, " disabled", str_spec);
659 660 661
	} else {
		p = string(p, pend, " flags ", str_spec);
		p = number(p, pend, res->flags, flag_spec);
662
	}
663
	*p++ = ']';
664
	*p = '\0';
665

666
	return string(buf, end, sym, spec);
667 668
}

669 670 671 672
static noinline_for_stack
char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
		 const char *fmt)
{
673
	int i, len = 1;		/* if we pass '%ph[CDN]', field width remains
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
				   negative value, fallback to the default */
	char separator;

	if (spec.field_width == 0)
		/* nothing to print */
		return buf;

	if (ZERO_OR_NULL_PTR(addr))
		/* NULL pointer */
		return string(buf, end, NULL, spec);

	switch (fmt[1]) {
	case 'C':
		separator = ':';
		break;
	case 'D':
		separator = '-';
		break;
	case 'N':
		separator = 0;
		break;
	default:
		separator = ' ';
		break;
	}

	if (spec.field_width > 0)
		len = min_t(int, spec.field_width, 64);

	for (i = 0; i < len && buf < end - 1; i++) {
		buf = hex_byte_pack(buf, addr[i]);

		if (buf < end && separator && i != len - 1)
			*buf++ = separator;
	}

	return buf;
}

713 714 715
static noinline_for_stack
char *mac_address_string(char *buf, char *end, u8 *addr,
			 struct printf_spec spec, const char *fmt)
716
{
717
	char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
718 719
	char *p = mac_addr;
	int i;
720
	char separator;
721
	bool reversed = false;
722

723 724
	switch (fmt[1]) {
	case 'F':
725
		separator = '-';
726 727 728 729 730 731 732
		break;

	case 'R':
		reversed = true;
		/* fall through */

	default:
733
		separator = ':';
734
		break;
735
	}
736 737

	for (i = 0; i < 6; i++) {
738 739 740 741 742
		if (reversed)
			p = hex_byte_pack(p, addr[5 - i]);
		else
			p = hex_byte_pack(p, addr[i]);

743
		if (fmt[0] == 'M' && i != 5)
744
			*p++ = separator;
745 746 747
	}
	*p = '\0';

748
	return string(buf, end, mac_addr, spec);
749 750
}

751 752
static noinline_for_stack
char *ip4_string(char *p, const u8 *addr, const char *fmt)
753 754
{
	int i;
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
	bool leading_zeros = (fmt[0] == 'i');
	int index;
	int step;

	switch (fmt[2]) {
	case 'h':
#ifdef __BIG_ENDIAN
		index = 0;
		step = 1;
#else
		index = 3;
		step = -1;
#endif
		break;
	case 'l':
		index = 3;
		step = -1;
		break;
	case 'n':
	case 'b':
	default:
		index = 0;
		step = 1;
		break;
	}
780 781
	for (i = 0; i < 4; i++) {
		char temp[3];	/* hold each IP quad in reverse order */
782
		int digits = put_dec_trunc8(temp, addr[index]) - temp;
783 784 785 786 787 788 789 790 791 792 793
		if (leading_zeros) {
			if (digits < 3)
				*p++ = '0';
			if (digits < 2)
				*p++ = '0';
		}
		/* reverse the digits in the quad */
		while (digits--)
			*p++ = temp[digits];
		if (i < 3)
			*p++ = '.';
794
		index += step;
795 796
	}
	*p = '\0';
797

798 799 800
	return p;
}

801 802
static noinline_for_stack
char *ip6_compressed_string(char *p, const char *addr)
803
{
804
	int i, j, range;
805 806 807 808
	unsigned char zerolength[8];
	int longest = 1;
	int colonpos = -1;
	u16 word;
809
	u8 hi, lo;
810
	bool needcolon = false;
811 812 813 814 815 816
	bool useIPv4;
	struct in6_addr in6;

	memcpy(&in6, addr, sizeof(struct in6_addr));

	useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
817 818 819 820 821 822 823 824 825 826 827

	memset(zerolength, 0, sizeof(zerolength));

	if (useIPv4)
		range = 6;
	else
		range = 8;

	/* find position of longest 0 run */
	for (i = 0; i < range; i++) {
		for (j = i; j < range; j++) {
828
			if (in6.s6_addr16[j] != 0)
829 830 831 832 833 834 835 836 837 838
				break;
			zerolength[i]++;
		}
	}
	for (i = 0; i < range; i++) {
		if (zerolength[i] > longest) {
			longest = zerolength[i];
			colonpos = i;
		}
	}
839 840
	if (longest == 1)		/* don't compress a single 0 */
		colonpos = -1;
841

842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
	/* emit address */
	for (i = 0; i < range; i++) {
		if (i == colonpos) {
			if (needcolon || i == 0)
				*p++ = ':';
			*p++ = ':';
			needcolon = false;
			i += longest - 1;
			continue;
		}
		if (needcolon) {
			*p++ = ':';
			needcolon = false;
		}
		/* hex u16 without leading 0s */
857
		word = ntohs(in6.s6_addr16[i]);
858 859 860 861
		hi = word >> 8;
		lo = word & 0xff;
		if (hi) {
			if (hi > 0x0f)
862
				p = hex_byte_pack(p, hi);
863 864
			else
				*p++ = hex_asc_lo(hi);
865
			p = hex_byte_pack(p, lo);
866
		}
867
		else if (lo > 0x0f)
868
			p = hex_byte_pack(p, lo);
869 870 871 872 873 874 875 876
		else
			*p++ = hex_asc_lo(lo);
		needcolon = true;
	}

	if (useIPv4) {
		if (needcolon)
			*p++ = ':';
877
		p = ip4_string(p, &in6.s6_addr[12], "I4");
878 879
	}
	*p = '\0';
880

881 882 883
	return p;
}

884 885
static noinline_for_stack
char *ip6_string(char *p, const char *addr, const char *fmt)
886 887
{
	int i;
888

889
	for (i = 0; i < 8; i++) {
890 891
		p = hex_byte_pack(p, *addr++);
		p = hex_byte_pack(p, *addr++);
892
		if (fmt[0] == 'I' && i != 7)
893 894 895
			*p++ = ':';
	}
	*p = '\0';
896

897 898 899
	return p;
}

900 901 902
static noinline_for_stack
char *ip6_addr_string(char *buf, char *end, const u8 *addr,
		      struct printf_spec spec, const char *fmt)
903 904 905 906
{
	char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];

	if (fmt[0] == 'I' && fmt[2] == 'c')
907
		ip6_compressed_string(ip6_addr, addr);
908
	else
909
		ip6_string(ip6_addr, addr, fmt);
910

911
	return string(buf, end, ip6_addr, spec);
912 913
}

914 915 916
static noinline_for_stack
char *ip4_addr_string(char *buf, char *end, const u8 *addr,
		      struct printf_spec spec, const char *fmt)
917
{
918
	char ip4_addr[sizeof("255.255.255.255")];
919

920
	ip4_string(ip4_addr, addr, fmt);
921

922
	return string(buf, end, ip4_addr, spec);
923 924
}

925 926 927
static noinline_for_stack
char *uuid_string(char *buf, char *end, const u8 *addr,
		  struct printf_spec spec, const char *fmt)
928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948
{
	char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
	char *p = uuid;
	int i;
	static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
	static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
	const u8 *index = be;
	bool uc = false;

	switch (*(++fmt)) {
	case 'L':
		uc = true;		/* fall-through */
	case 'l':
		index = le;
		break;
	case 'B':
		uc = true;
		break;
	}

	for (i = 0; i < 16; i++) {
949
		p = hex_byte_pack(p, addr[index[i]]);
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
		switch (i) {
		case 3:
		case 5:
		case 7:
		case 9:
			*p++ = '-';
			break;
		}
	}

	*p = 0;

	if (uc) {
		p = uuid;
		do {
			*p = toupper(*p);
		} while (*(++p));
	}

	return string(buf, end, uuid, spec);
}

972 973 974 975 976 977 978 979 980 981 982 983
static
char *netdev_feature_string(char *buf, char *end, const u8 *addr,
		      struct printf_spec spec)
{
	spec.flags |= SPECIAL | SMALL | ZEROPAD;
	if (spec.field_width == -1)
		spec.field_width = 2 + 2 * sizeof(netdev_features_t);
	spec.base = 16;

	return number(buf, end, *(const netdev_features_t *)addr, spec);
}

984
int kptr_restrict __read_mostly;
985

986 987 988 989 990
/*
 * Show a '%p' thing.  A kernel extension is that the '%p' is followed
 * by an extra set of alphanumeric characters that are extended format
 * specifiers.
 *
991 992
 * Right now we handle:
 *
993 994
 * - 'F' For symbolic function descriptor pointers with offset
 * - 'f' For simple symbolic function names without offset
995 996
 * - 'S' For symbolic direct pointers with offset
 * - 's' For symbolic direct pointers without offset
997
 * - '[FfSs]R' as above with __builtin_extract_return_addr() translation
998
 * - 'B' For backtraced symbolic direct pointers with offset
999 1000
 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
1001 1002
 * - 'M' For a 6-byte MAC address, it prints the address in the
 *       usual colon-separated hex notation
1003
 * - 'm' For a 6-byte MAC address, it prints the hex address without colons
1004
 * - 'MF' For a 6-byte MAC FDDI address, it prints the address
1005
 *       with a dash-separated hex notation
1006
 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)
1007 1008 1009 1010 1011 1012
 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
 *       IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
 *       IPv6 uses colon separated network-order 16 bit hex with leading 0's
 * - 'i' [46] for 'raw' IPv4/IPv6 addresses
 *       IPv6 omits the colons (01020304...0f)
 *       IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
1013
 * - '[Ii]4[hnbl]' IPv4 addresses in host, network, big or little endian order
1014
 * - 'I6c' for IPv6 addresses printed as specified by
1015
 *       http://tools.ietf.org/html/rfc5952
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
 *       "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
 *       Options for %pU are:
 *         b big endian lower case hex (default)
 *         B big endian UPPER case hex
 *         l little endian lower case hex
 *         L little endian UPPER case hex
 *           big endian output byte order is:
 *             [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
 *           little endian output byte order is:
 *             [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
1027 1028 1029 1030 1031
 * - 'V' For a struct va_format which contains a format string * and va_list *,
 *       call vsnprintf(->format, *->va_list).
 *       Implements a "recursive vsnprintf".
 *       Do not use this feature without some mechanism to verify the
 *       correctness of the format string and va_list arguments.
1032
 * - 'K' For a kernel pointer that should be hidden from unprivileged users
1033
 * - 'NF' For a netdev_features_t
1034 1035 1036 1037 1038 1039 1040
 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
 *            a certain separator (' ' by default):
 *              C colon
 *              D dash
 *              N no separator
 *            The maximum supported length is 64 bytes of the input. Consider
 *            to use print_hex_dump() for the larger input.
1041
 * - 'a' For a phys_addr_t type and its derivative types (passed by reference)
1042
 *
1043 1044 1045
 * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
 * function pointers are really function descriptors, which contain a
 * pointer to the real address.
1046
 */
1047 1048 1049
static noinline_for_stack
char *pointer(const char *fmt, char *buf, char *end, void *ptr,
	      struct printf_spec spec)
1050
{
1051 1052
	int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);

1053
	if (!ptr && *fmt != 'K') {
1054 1055 1056 1057 1058
		/*
		 * Print (null) with the same width as a pointer so it makes
		 * tabular output look nice.
		 */
		if (spec.field_width == -1)
1059
			spec.field_width = default_width;
1060
		return string(buf, end, "(null)", spec);
1061
	}
1062

1063 1064
	switch (*fmt) {
	case 'F':
1065
	case 'f':
1066 1067 1068
		ptr = dereference_function_descriptor(ptr);
		/* Fallthrough */
	case 'S':
1069
	case 's':
1070
	case 'B':
1071
		return symbol_string(buf, end, ptr, spec, fmt);
1072
	case 'R':
1073
	case 'r':
1074
		return resource_string(buf, end, ptr, spec, fmt);
1075 1076
	case 'h':
		return hex_string(buf, end, ptr, spec, fmt);
1077 1078
	case 'M':			/* Colon separated: 00:01:02:03:04:05 */
	case 'm':			/* Contiguous: 000102030405 */
1079 1080
					/* [mM]F (FDDI) */
					/* [mM]R (Reverse order; Bluetooth) */
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
		return mac_address_string(buf, end, ptr, spec, fmt);
	case 'I':			/* Formatted IP supported
					 * 4:	1.2.3.4
					 * 6:	0001:0203:...:0708
					 * 6c:	1::708 or 1::1.2.3.4
					 */
	case 'i':			/* Contiguous:
					 * 4:	001.002.003.004
					 * 6:   000102...0f
					 */
		switch (fmt[1]) {
		case '6':
			return ip6_addr_string(buf, end, ptr, spec, fmt);
		case '4':
			return ip4_addr_string(buf, end, ptr, spec, fmt);
		}
1097
		break;
1098 1099
	case 'U':
		return uuid_string(buf, end, ptr, spec, fmt);
1100
	case 'V':
1101 1102 1103 1104 1105 1106 1107 1108 1109
		{
			va_list va;

			va_copy(va, *((struct va_format *)ptr)->va);
			buf += vsnprintf(buf, end > buf ? end - buf : 0,
					 ((struct va_format *)ptr)->fmt, va);
			va_end(va);
			return buf;
		}
1110 1111 1112 1113 1114
	case 'K':
		/*
		 * %pK cannot be used in IRQ context because its test
		 * for CAP_SYSLOG would be meaningless.
		 */
1115 1116
		if (kptr_restrict && (in_irq() || in_serving_softirq() ||
				      in_nmi())) {
1117
			if (spec.field_width == -1)
1118
				spec.field_width = default_width;
1119 1120
			return string(buf, end, "pK-error", spec);
		}
1121 1122 1123 1124 1125
		if (!((kptr_restrict == 0) ||
		      (kptr_restrict == 1 &&
		       has_capability_noaudit(current, CAP_SYSLOG))))
			ptr = NULL;
		break;
1126 1127 1128 1129 1130 1131
	case 'N':
		switch (fmt[1]) {
		case 'F':
			return netdev_feature_string(buf, end, ptr, spec);
		}
		break;
1132 1133 1134 1135 1136 1137
	case 'a':
		spec.flags |= SPECIAL | SMALL | ZEROPAD;
		spec.field_width = sizeof(phys_addr_t) * 2 + 2;
		spec.base = 16;
		return number(buf, end,
			      (unsigned long long) *((phys_addr_t *)ptr), spec);
1138 1139 1140
	}
	spec.flags |= SMALL;
	if (spec.field_width == -1) {
1141
		spec.field_width = default_width;
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
		spec.flags |= ZEROPAD;
	}
	spec.base = 16;

	return number(buf, end, (unsigned long) ptr, spec);
}

/*
 * Helper function to decode printf style format.
 * Each call decode a token from the format and return the
 * number of characters read (or likely the delta where it wants
 * to go on the next call).
 * The decoded token is returned through the parameters
 *
 * 'h', 'l', or 'L' for integer fields
 * 'z' support added 23/7/1999 S.H.
 * 'z' changed to 'Z' --davidm 1/25/99
 * 't' added for ptrdiff_t
 *
 * @fmt: the format string
 * @type of the token returned
 * @flags: various flags such as +, -, # tokens..
 * @field_width: overwritten width
 * @base: base of the number (octal, hex, ...)
 * @precision: precision of a number
 * @qualifier: qualifier of a number (long, size_t, ...)
 */
1169 1170
static noinline_for_stack
int format_decode(const char *fmt, struct printf_spec *spec)
1171 1172 1173 1174
{
	const char *start = fmt;

	/* we finished early by reading the field width */
1175
	if (spec->type == FORMAT_TYPE_WIDTH) {
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
		if (spec->field_width < 0) {
			spec->field_width = -spec->field_width;
			spec->flags |= LEFT;
		}
		spec->type = FORMAT_TYPE_NONE;
		goto precision;
	}

	/* we finished early by reading the precision */
	if (spec->type == FORMAT_TYPE_PRECISION) {
		if (spec->precision < 0)
			spec->precision = 0;

		spec->type = FORMAT_TYPE_NONE;
		goto qualifier;
	}

	/* By default */
	spec->type = FORMAT_TYPE_NONE;

	for (; *fmt ; ++fmt) {
		if (*fmt == '%')
			break;
	}

	/* Return the current non-format string */
	if (fmt != start || !*fmt)
		return fmt - start;

	/* Process flags */
	spec->flags = 0;

	while (1) { /* this also skips first '%' */
		bool found = true;

		++fmt;

		switch (*fmt) {
		case '-': spec->flags |= LEFT;    break;
		case '+': spec->flags |= PLUS;    break;
		case ' ': spec->flags |= SPACE;   break;
		case '#': spec->flags |= SPECIAL; break;
		case '0': spec->flags |= ZEROPAD; break;
		default:  found = false;
		}

		if (!found)
			break;
	}

	/* get field width */
	spec->field_width = -1;

	if (isdigit(*fmt))
		spec->field_width = skip_atoi(&fmt);
	else if (*fmt == '*') {
		/* it's the next argument */
1233
		spec->type = FORMAT_TYPE_WIDTH;
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
		return ++fmt - start;
	}

precision:
	/* get the precision */
	spec->precision = -1;
	if (*fmt == '.') {
		++fmt;
		if (isdigit(*fmt)) {
			spec->precision = skip_atoi(&fmt);
			if (spec->precision < 0)
				spec->precision = 0;
		} else if (*fmt == '*') {
			/* it's the next argument */
1248
			spec->type = FORMAT_TYPE_PRECISION;
1249 1250 1251 1252 1253 1254 1255
			return ++fmt - start;
		}
	}

qualifier:
	/* get the conversion qualifier */
	spec->qualifier = -1;
1256 1257
	if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
	    _tolower(*fmt) == 'z' || *fmt == 't') {
1258 1259 1260 1261 1262 1263 1264 1265 1266
		spec->qualifier = *fmt++;
		if (unlikely(spec->qualifier == *fmt)) {
			if (spec->qualifier == 'l') {
				spec->qualifier = 'L';
				++fmt;
			} else if (spec->qualifier == 'h') {
				spec->qualifier = 'H';
				++fmt;
			}
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
		}
	}

	/* default base */
	spec->base = 10;
	switch (*fmt) {
	case 'c':
		spec->type = FORMAT_TYPE_CHAR;
		return ++fmt - start;

	case 's':
		spec->type = FORMAT_TYPE_STR;
		return ++fmt - start;

	case 'p':
		spec->type = FORMAT_TYPE_PTR;
		return fmt - start;
		/* skip alnum */

	case 'n':
		spec->type = FORMAT_TYPE_NRCHARS;
		return ++fmt - start;

	case '%':
		spec->type = FORMAT_TYPE_PERCENT_CHAR;
		return ++fmt - start;

	/* integer number formats - set up the flags and "break" */
	case 'o':
		spec->base = 8;
		break;

	case 'x':
		spec->flags |= SMALL;

	case 'X':
		spec->base = 16;
		break;

	case 'd':
	case 'i':
1308
		spec->flags |= SIGN;
1309
	case 'u':
1310
		break;
1311 1312 1313 1314

	default:
		spec->type = FORMAT_TYPE_INVALID;
		return fmt - start;
1315
	}
1316 1317 1318 1319

	if (spec->qualifier == 'L')
		spec->type = FORMAT_TYPE_LONG_LONG;
	else if (spec->qualifier == 'l') {
1320
		if (spec->flags & SIGN)
1321 1322 1323
			spec->type = FORMAT_TYPE_LONG;
		else
			spec->type = FORMAT_TYPE_ULONG;
1324
	} else if (_tolower(spec->qualifier) == 'z') {
1325 1326 1327
		spec->type = FORMAT_TYPE_SIZE_T;
	} else if (spec->qualifier == 't') {
		spec->type = FORMAT_TYPE_PTRDIFF;
1328 1329 1330 1331 1332
	} else if (spec->qualifier == 'H') {
		if (spec->flags & SIGN)
			spec->type = FORMAT_TYPE_BYTE;
		else
			spec->type = FORMAT_TYPE_UBYTE;
1333
	} else if (spec->qualifier == 'h') {
1334
		if (spec->flags & SIGN)
1335 1336 1337 1338
			spec->type = FORMAT_TYPE_SHORT;
		else
			spec->type = FORMAT_TYPE_USHORT;
	} else {
1339
		if (spec->flags & SIGN)
1340 1341 1342
			spec->type = FORMAT_TYPE_INT;
		else
			spec->type = FORMAT_TYPE_UINT;
1343
	}
1344 1345

	return ++fmt - start;
1346 1347
}

Linus Torvalds's avatar
Linus Torvalds committed
1348 1349 1350 1351 1352 1353 1354
/**
 * vsnprintf - Format a string and place it in a buffer
 * @buf: The buffer to place the result into
 * @size: The size of the buffer, including the trailing null space
 * @fmt: The format string to use
 * @args: Arguments for the format string
 *
1355
 * This function follows C99 vsnprintf, but has some extensions:
1356 1357
 * %pS output the name of a text symbol with offset
 * %ps output the name of a text symbol without offset
1358 1359
 * %pF output the name of a function pointer with its offset
 * %pf output the name of a function pointer without its offset
1360
 * %pB output the name of a backtrace symbol with its offset
1361 1362 1363
 * %pR output the address range in a struct resource with decoded flags
 * %pr output the address range in a struct resource with raw flags
 * %pM output a 6-byte MAC address with colons
1364 1365
 * %pMR output a 6-byte MAC address with colons in reversed order
 * %pMF output a 6-byte MAC address with dashes
1366
 * %pm output a 6-byte MAC address without colons
1367
 * %pmR output a 6-byte MAC address without colons in reversed order
1368 1369 1370 1371
 * %pI4 print an IPv4 address without leading zeros
 * %pi4 print an IPv4 address with leading zeros
 * %pI6 print an IPv6 address with colons
 * %pi6 print an IPv6 address without colons
1372
 * %pI6c print an IPv6 address as specified by RFC 5952
1373 1374
 * %pU[bBlL] print a UUID/GUID in big or little endian using lower or upper
 *   case.