1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 *  linux/lib/vsprintf.c
4 *
5 *  Copyright (C) 1991, 1992  Linus Torvalds
6 */
7
8/* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
9/*
10 * Wirzenius wrote this portably, Torvalds fucked it up :-)
11 */
12
13/*
14 * Fri Jul 13 2001 Crutcher Dunnavant <crutcher+kernel@datastacks.com>
15 * - changed to provide snprintf and vsnprintf functions
16 * So Feb  1 16:51:32 CET 2004 Juergen Quade <quade@hsnr.de>
17 * - scnprintf and vscnprintf
18 */
19
20#include <linux/stdarg.h>
21#include <linux/build_bug.h>
22#include <linux/clk.h>
23#include <linux/clk-provider.h>
24#include <linux/errname.h>
25#include <linux/module.h>	/* for KSYM_SYMBOL_LEN */
26#include <linux/types.h>
27#include <linux/string.h>
28#include <linux/ctype.h>
29#include <linux/kernel.h>
30#include <linux/kallsyms.h>
31#include <linux/math64.h>
32#include <linux/uaccess.h>
33#include <linux/ioport.h>
34#include <linux/dcache.h>
35#include <linux/cred.h>
36#include <linux/rtc.h>
37#include <linux/time.h>
38#include <linux/uuid.h>
39#include <linux/of.h>
40#include <net/addrconf.h>
41#include <linux/siphash.h>
42#include <linux/compiler.h>
43#include <linux/property.h>
44#ifdef CONFIG_BLOCK
45#include <linux/blkdev.h>
46#endif
47
48#include "../mm/internal.h"	/* For the trace_print_flags arrays */
49
50#include <asm/page.h>		/* for PAGE_SIZE */
51#include <asm/byteorder.h>	/* cpu_to_le16 */
52#include <asm/unaligned.h>
53
54#include <linux/string_helpers.h>
55#include "kstrtox.h"
56
57/* Disable pointer hashing if requested */
58bool no_hash_pointers __ro_after_init;
59EXPORT_SYMBOL_GPL(no_hash_pointers);
60
61static noinline unsigned long long simple_strntoull(const char *startp, size_t max_chars, char **endp, unsigned int base)
62{
63	const char *cp;
64	unsigned long long result = 0ULL;
65	size_t prefix_chars;
66	unsigned int rv;
67
68	cp = _parse_integer_fixup_radix(startp, &base);
69	prefix_chars = cp - startp;
70	if (prefix_chars < max_chars) {
71		rv = _parse_integer_limit(cp, base, &result, max_chars - prefix_chars);
72		/* FIXME */
73		cp += (rv & ~KSTRTOX_OVERFLOW);
74	} else {
75		/* Field too short for prefix + digit, skip over without converting */
76		cp = startp + max_chars;
77	}
78
79	if (endp)
80		*endp = (char *)cp;
81
82	return result;
83}
84
85/**
86 * simple_strtoull - convert a string to an unsigned long long
87 * @cp: The start of the string
88 * @endp: A pointer to the end of the parsed string will be placed here
89 * @base: The number base to use
90 *
91 * This function has caveats. Please use kstrtoull instead.
92 */
93noinline
94unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
95{
96	return simple_strntoull(cp, INT_MAX, endp, base);
97}
98EXPORT_SYMBOL(simple_strtoull);
99
100/**
101 * simple_strtoul - convert a string to an unsigned long
102 * @cp: The start of the string
103 * @endp: A pointer to the end of the parsed string will be placed here
104 * @base: The number base to use
105 *
106 * This function has caveats. Please use kstrtoul instead.
107 */
108unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
109{
110	return simple_strtoull(cp, endp, base);
111}
112EXPORT_SYMBOL(simple_strtoul);
113
114/**
115 * simple_strtol - convert a string to a signed long
116 * @cp: The start of the string
117 * @endp: A pointer to the end of the parsed string will be placed here
118 * @base: The number base to use
119 *
120 * This function has caveats. Please use kstrtol instead.
121 */
122long simple_strtol(const char *cp, char **endp, unsigned int base)
123{
124	if (*cp == '-')
125		return -simple_strtoul(cp + 1, endp, base);
126
127	return simple_strtoul(cp, endp, base);
128}
129EXPORT_SYMBOL(simple_strtol);
130
131static long long simple_strntoll(const char *cp, size_t max_chars, char **endp,
132				 unsigned int base)
133{
134	/*
135	 * simple_strntoull() safely handles receiving max_chars==0 in the
136	 * case cp[0] == '-' && max_chars == 1.
137	 * If max_chars == 0 we can drop through and pass it to simple_strntoull()
138	 * and the content of *cp is irrelevant.
139	 */
140	if (*cp == '-' && max_chars > 0)
141		return -simple_strntoull(cp + 1, max_chars - 1, endp, base);
142
143	return simple_strntoull(cp, max_chars, endp, base);
144}
145
146/**
147 * simple_strtoll - convert a string to a signed long long
148 * @cp: The start of the string
149 * @endp: A pointer to the end of the parsed string will be placed here
150 * @base: The number base to use
151 *
152 * This function has caveats. Please use kstrtoll instead.
153 */
154long long simple_strtoll(const char *cp, char **endp, unsigned int base)
155{
156	return simple_strntoll(cp, INT_MAX, endp, base);
157}
158EXPORT_SYMBOL(simple_strtoll);
159
160static noinline_for_stack
161int skip_atoi(const char **s)
162{
163	int i = 0;
164
165	do {
166		i = i*10 + *((*s)++) - '0';
167	} while (isdigit(**s));
168
169	return i;
170}
171
172/*
173 * Decimal conversion is by far the most typical, and is used for
174 * /proc and /sys data. This directly impacts e.g. top performance
175 * with many processes running. We optimize it for speed by emitting
176 * two characters at a time, using a 200 byte lookup table. This
177 * roughly halves the number of multiplications compared to computing
178 * the digits one at a time. Implementation strongly inspired by the
179 * previous version, which in turn used ideas described at
180 * <http://www.cs.uiowa.edu/~jones/bcd/divide.html> (with permission
181 * from the author, Douglas W. Jones).
182 *
183 * It turns out there is precisely one 26 bit fixed-point
184 * approximation a of 64/100 for which x/100 == (x * (u64)a) >> 32
185 * holds for all x in [0, 10^8-1], namely a = 0x28f5c29. The actual
186 * range happens to be somewhat larger (x <= 1073741898), but that's
187 * irrelevant for our purpose.
188 *
189 * For dividing a number in the range [10^4, 10^6-1] by 100, we still
190 * need a 32x32->64 bit multiply, so we simply use the same constant.
191 *
192 * For dividing a number in the range [100, 10^4-1] by 100, there are
193 * several options. The simplest is (x * 0x147b) >> 19, which is valid
194 * for all x <= 43698.
195 */
196
197static const u16 decpair[100] = {
198#define _(x) (__force u16) cpu_to_le16(((x % 10) | ((x / 10) << 8)) + 0x3030)
199	_( 0), _( 1), _( 2), _( 3), _( 4), _( 5), _( 6), _( 7), _( 8), _( 9),
200	_(10), _(11), _(12), _(13), _(14), _(15), _(16), _(17), _(18), _(19),
201	_(20), _(21), _(22), _(23), _(24), _(25), _(26), _(27), _(28), _(29),
202	_(30), _(31), _(32), _(33), _(34), _(35), _(36), _(37), _(38), _(39),
203	_(40), _(41), _(42), _(43), _(44), _(45), _(46), _(47), _(48), _(49),
204	_(50), _(51), _(52), _(53), _(54), _(55), _(56), _(57), _(58), _(59),
205	_(60), _(61), _(62), _(63), _(64), _(65), _(66), _(67), _(68), _(69),
206	_(70), _(71), _(72), _(73), _(74), _(75), _(76), _(77), _(78), _(79),
207	_(80), _(81), _(82), _(83), _(84), _(85), _(86), _(87), _(88), _(89),
208	_(90), _(91), _(92), _(93), _(94), _(95), _(96), _(97), _(98), _(99),
209#undef _
210};
211
212/*
213 * This will print a single '0' even if r == 0, since we would
214 * immediately jump to out_r where two 0s would be written but only
215 * one of them accounted for in buf. This is needed by ip4_string
216 * below. All other callers pass a non-zero value of r.
217*/
218static noinline_for_stack
219char *put_dec_trunc8(char *buf, unsigned r)
220{
221	unsigned q;
222
223	/* 1 <= r < 10^8 */
224	if (r < 100)
225		goto out_r;
226
227	/* 100 <= r < 10^8 */
228	q = (r * (u64)0x28f5c29) >> 32;
229	*((u16 *)buf) = decpair[r - 100*q];
230	buf += 2;
231
232	/* 1 <= q < 10^6 */
233	if (q < 100)
234		goto out_q;
235
236	/*  100 <= q < 10^6 */
237	r = (q * (u64)0x28f5c29) >> 32;
238	*((u16 *)buf) = decpair[q - 100*r];
239	buf += 2;
240
241	/* 1 <= r < 10^4 */
242	if (r < 100)
243		goto out_r;
244
245	/* 100 <= r < 10^4 */
246	q = (r * 0x147b) >> 19;
247	*((u16 *)buf) = decpair[r - 100*q];
248	buf += 2;
249out_q:
250	/* 1 <= q < 100 */
251	r = q;
252out_r:
253	/* 1 <= r < 100 */
254	*((u16 *)buf) = decpair[r];
255	buf += r < 10 ? 1 : 2;
256	return buf;
257}
258
259#if BITS_PER_LONG == 64 && BITS_PER_LONG_LONG == 64
260static noinline_for_stack
261char *put_dec_full8(char *buf, unsigned r)
262{
263	unsigned q;
264
265	/* 0 <= r < 10^8 */
266	q = (r * (u64)0x28f5c29) >> 32;
267	*((u16 *)buf) = decpair[r - 100*q];
268	buf += 2;
269
270	/* 0 <= q < 10^6 */
271	r = (q * (u64)0x28f5c29) >> 32;
272	*((u16 *)buf) = decpair[q - 100*r];
273	buf += 2;
274
275	/* 0 <= r < 10^4 */
276	q = (r * 0x147b) >> 19;
277	*((u16 *)buf) = decpair[r - 100*q];
278	buf += 2;
279
280	/* 0 <= q < 100 */
281	*((u16 *)buf) = decpair[q];
282	buf += 2;
283	return buf;
284}
285
286static noinline_for_stack
287char *put_dec(char *buf, unsigned long long n)
288{
289	if (n >= 100*1000*1000)
290		buf = put_dec_full8(buf, do_div(n, 100*1000*1000));
291	/* 1 <= n <= 1.6e11 */
292	if (n >= 100*1000*1000)
293		buf = put_dec_full8(buf, do_div(n, 100*1000*1000));
294	/* 1 <= n < 1e8 */
295	return put_dec_trunc8(buf, n);
296}
297
298#elif BITS_PER_LONG == 32 && BITS_PER_LONG_LONG == 64
299
300static void
301put_dec_full4(char *buf, unsigned r)
302{
303	unsigned q;
304
305	/* 0 <= r < 10^4 */
306	q = (r * 0x147b) >> 19;
307	*((u16 *)buf) = decpair[r - 100*q];
308	buf += 2;
309	/* 0 <= q < 100 */
310	*((u16 *)buf) = decpair[q];
311}
312
313/*
314 * Call put_dec_full4 on x % 10000, return x / 10000.
315 * The approximation x/10000 == (x * 0x346DC5D7) >> 43
316 * holds for all x < 1,128,869,999.  The largest value this
317 * helper will ever be asked to convert is 1,125,520,955.
318 * (second call in the put_dec code, assuming n is all-ones).
319 */
320static noinline_for_stack
321unsigned put_dec_helper4(char *buf, unsigned x)
322{
323        uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
324
325        put_dec_full4(buf, x - q * 10000);
326        return q;
327}
328
329/* Based on code by Douglas W. Jones found at
330 * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour>
331 * (with permission from the author).
332 * Performs no 64-bit division and hence should be fast on 32-bit machines.
333 */
334static
335char *put_dec(char *buf, unsigned long long n)
336{
337	uint32_t d3, d2, d1, q, h;
338
339	if (n < 100*1000*1000)
340		return put_dec_trunc8(buf, n);
341
342	d1  = ((uint32_t)n >> 16); /* implicit "& 0xffff" */
343	h   = (n >> 32);
344	d2  = (h      ) & 0xffff;
345	d3  = (h >> 16); /* implicit "& 0xffff" */
346
347	/* n = 2^48 d3 + 2^32 d2 + 2^16 d1 + d0
348	     = 281_4749_7671_0656 d3 + 42_9496_7296 d2 + 6_5536 d1 + d0 */
349	q   = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
350	q = put_dec_helper4(buf, q);
351
352	q += 7671 * d3 + 9496 * d2 + 6 * d1;
353	q = put_dec_helper4(buf+4, q);
354
355	q += 4749 * d3 + 42 * d2;
356	q = put_dec_helper4(buf+8, q);
357
358	q += 281 * d3;
359	buf += 12;
360	if (q)
361		buf = put_dec_trunc8(buf, q);
362	else while (buf[-1] == '0')
363		--buf;
364
365	return buf;
366}
367
368#endif
369
370/*
371 * Convert passed number to decimal string.
372 * Returns the length of string.  On buffer overflow, returns 0.
373 *
374 * If speed is not important, use snprintf(). It's easy to read the code.
375 */
376int num_to_str(char *buf, int size, unsigned long long num, unsigned int width)
377{
378	/* put_dec requires 2-byte alignment of the buffer. */
379	char tmp[sizeof(num) * 3] __aligned(2);
380	int idx, len;
381
382	/* put_dec() may work incorrectly for num = 0 (generate "", not "0") */
383	if (num <= 9) {
384		tmp[0] = '0' + num;
385		len = 1;
386	} else {
387		len = put_dec(tmp, num) - tmp;
388	}
389
390	if (len > size || width > size)
391		return 0;
392
393	if (width > len) {
394		width = width - len;
395		for (idx = 0; idx < width; idx++)
396			buf[idx] = ' ';
397	} else {
398		width = 0;
399	}
400
401	for (idx = 0; idx < len; ++idx)
402		buf[idx + width] = tmp[len - idx - 1];
403
404	return len + width;
405}
406
407#define SIGN	1		/* unsigned/signed, must be 1 */
408#define LEFT	2		/* left justified */
409#define PLUS	4		/* show plus */
410#define SPACE	8		/* space if plus */
411#define ZEROPAD	16		/* pad with zero, must be 16 == '0' - ' ' */
412#define SMALL	32		/* use lowercase in hex (must be 32 == 0x20) */
413#define SPECIAL	64		/* prefix hex with "0x", octal with "0" */
414
415static_assert(SIGN == 1);
416static_assert(ZEROPAD == ('0' - ' '));
417static_assert(SMALL == ('a' ^ 'A'));
418
419enum format_type {
420	FORMAT_TYPE_NONE, /* Just a string part */
421	FORMAT_TYPE_WIDTH,
422	FORMAT_TYPE_PRECISION,
423	FORMAT_TYPE_CHAR,
424	FORMAT_TYPE_STR,
425	FORMAT_TYPE_PTR,
426	FORMAT_TYPE_PERCENT_CHAR,
427	FORMAT_TYPE_INVALID,
428	FORMAT_TYPE_LONG_LONG,
429	FORMAT_TYPE_ULONG,
430	FORMAT_TYPE_LONG,
431	FORMAT_TYPE_UBYTE,
432	FORMAT_TYPE_BYTE,
433	FORMAT_TYPE_USHORT,
434	FORMAT_TYPE_SHORT,
435	FORMAT_TYPE_UINT,
436	FORMAT_TYPE_INT,
437	FORMAT_TYPE_SIZE_T,
438	FORMAT_TYPE_PTRDIFF
439};
440
441struct printf_spec {
442	unsigned int	type:8;		/* format_type enum */
443	signed int	field_width:24;	/* width of output field */
444	unsigned int	flags:8;	/* flags to number() */
445	unsigned int	base:8;		/* number base, 8, 10 or 16 only */
446	signed int	precision:16;	/* # of digits/chars */
447} __packed;
448static_assert(sizeof(struct printf_spec) == 8);
449
450#define FIELD_WIDTH_MAX ((1 << 23) - 1)
451#define PRECISION_MAX ((1 << 15) - 1)
452
453static noinline_for_stack
454char *number(char *buf, char *end, unsigned long long num,
455	     struct printf_spec spec)
456{
457	/* put_dec requires 2-byte alignment of the buffer. */
458	char tmp[3 * sizeof(num)] __aligned(2);
459	char sign;
460	char locase;
461	int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
462	int i;
463	bool is_zero = num == 0LL;
464	int field_width = spec.field_width;
465	int precision = spec.precision;
466
467	/* locase = 0 or 0x20. ORing digits or letters with 'locase'
468	 * produces same digits or (maybe lowercased) letters */
469	locase = (spec.flags & SMALL);
470	if (spec.flags & LEFT)
471		spec.flags &= ~ZEROPAD;
472	sign = 0;
473	if (spec.flags & SIGN) {
474		if ((signed long long)num < 0) {
475			sign = '-';
476			num = -(signed long long)num;
477			field_width--;
478		} else if (spec.flags & PLUS) {
479			sign = '+';
480			field_width--;
481		} else if (spec.flags & SPACE) {
482			sign = ' ';
483			field_width--;
484		}
485	}
486	if (need_pfx) {
487		if (spec.base == 16)
488			field_width -= 2;
489		else if (!is_zero)
490			field_width--;
491	}
492
493	/* generate full string in tmp[], in reverse order */
494	i = 0;
495	if (num < spec.base)
496		tmp[i++] = hex_asc_upper[num] | locase;
497	else if (spec.base != 10) { /* 8 or 16 */
498		int mask = spec.base - 1;
499		int shift = 3;
500
501		if (spec.base == 16)
502			shift = 4;
503		do {
504			tmp[i++] = (hex_asc_upper[((unsigned char)num) & mask] | locase);
505			num >>= shift;
506		} while (num);
507	} else { /* base 10 */
508		i = put_dec(tmp, num) - tmp;
509	}
510
511	/* printing 100 using %2d gives "100", not "00" */
512	if (i > precision)
513		precision = i;
514	/* leading space padding */
515	field_width -= precision;
516	if (!(spec.flags & (ZEROPAD | LEFT))) {
517		while (--field_width >= 0) {
518			if (buf < end)
519				*buf = ' ';
520			++buf;
521		}
522	}
523	/* sign */
524	if (sign) {
525		if (buf < end)
526			*buf = sign;
527		++buf;
528	}
529	/* "0x" / "0" prefix */
530	if (need_pfx) {
531		if (spec.base == 16 || !is_zero) {
532			if (buf < end)
533				*buf = '0';
534			++buf;
535		}
536		if (spec.base == 16) {
537			if (buf < end)
538				*buf = ('X' | locase);
539			++buf;
540		}
541	}
542	/* zero or space padding */
543	if (!(spec.flags & LEFT)) {
544		char c = ' ' + (spec.flags & ZEROPAD);
545
546		while (--field_width >= 0) {
547			if (buf < end)
548				*buf = c;
549			++buf;
550		}
551	}
552	/* hmm even more zero padding? */
553	while (i <= --precision) {
554		if (buf < end)
555			*buf = '0';
556		++buf;
557	}
558	/* actual digits of result */
559	while (--i >= 0) {
560		if (buf < end)
561			*buf = tmp[i];
562		++buf;
563	}
564	/* trailing space padding */
565	while (--field_width >= 0) {
566		if (buf < end)
567			*buf = ' ';
568		++buf;
569	}
570
571	return buf;
572}
573
574static noinline_for_stack
575char *special_hex_number(char *buf, char *end, unsigned long long num, int size)
576{
577	struct printf_spec spec;
578
579	spec.type = FORMAT_TYPE_PTR;
580	spec.field_width = 2 + 2 * size;	/* 0x + hex */
581	spec.flags = SPECIAL | SMALL | ZEROPAD;
582	spec.base = 16;
583	spec.precision = -1;
584
585	return number(buf, end, num, spec);
586}
587
588static void move_right(char *buf, char *end, unsigned len, unsigned spaces)
589{
590	size_t size;
591	if (buf >= end)	/* nowhere to put anything */
592		return;
593	size = end - buf;
594	if (size <= spaces) {
595		memset(buf, ' ', size);
596		return;
597	}
598	if (len) {
599		if (len > size - spaces)
600			len = size - spaces;
601		memmove(buf + spaces, buf, len);
602	}
603	memset(buf, ' ', spaces);
604}
605
606/*
607 * Handle field width padding for a string.
608 * @buf: current buffer position
609 * @n: length of string
610 * @end: end of output buffer
611 * @spec: for field width and flags
612 * Returns: new buffer position after padding.
613 */
614static noinline_for_stack
615char *widen_string(char *buf, int n, char *end, struct printf_spec spec)
616{
617	unsigned spaces;
618
619	if (likely(n >= spec.field_width))
620		return buf;
621	/* we want to pad the sucker */
622	spaces = spec.field_width - n;
623	if (!(spec.flags & LEFT)) {
624		move_right(buf - n, end, n, spaces);
625		return buf + spaces;
626	}
627	while (spaces--) {
628		if (buf < end)
629			*buf = ' ';
630		++buf;
631	}
632	return buf;
633}
634
635/* Handle string from a well known address. */
636static char *string_nocheck(char *buf, char *end, const char *s,
637			    struct printf_spec spec)
638{
639	int len = 0;
640	int lim = spec.precision;
641
642	while (lim--) {
643		char c = *s++;
644		if (!c)
645			break;
646		if (buf < end)
647			*buf = c;
648		++buf;
649		++len;
650	}
651	return widen_string(buf, len, end, spec);
652}
653
654static char *err_ptr(char *buf, char *end, void *ptr,
655		     struct printf_spec spec)
656{
657	int err = PTR_ERR(ptr);
658	const char *sym = errname(err);
659
660	if (sym)
661		return string_nocheck(buf, end, sym, spec);
662
663	/*
664	 * Somebody passed ERR_PTR(-1234) or some other non-existing
665	 * Efoo - or perhaps CONFIG_SYMBOLIC_ERRNAME=n. Fall back to
666	 * printing it as its decimal representation.
667	 */
668	spec.flags |= SIGN;
669	spec.base = 10;
670	return number(buf, end, err, spec);
671}
672
673/* Be careful: error messages must fit into the given buffer. */
674static char *error_string(char *buf, char *end, const char *s,
675			  struct printf_spec spec)
676{
677	/*
678	 * Hard limit to avoid a completely insane messages. It actually
679	 * works pretty well because most error messages are in
680	 * the many pointer format modifiers.
681	 */
682	if (spec.precision == -1)
683		spec.precision = 2 * sizeof(void *);
684
685	return string_nocheck(buf, end, s, spec);
686}
687
688/*
689 * Do not call any complex external code here. Nested printk()/vsprintf()
690 * might cause infinite loops. Failures might break printk() and would
691 * be hard to debug.
692 */
693static const char *check_pointer_msg(const void *ptr)
694{
695	if (!ptr)
696		return "(null)";
697
698	if ((unsigned long)ptr < PAGE_SIZE || IS_ERR_VALUE(ptr))
699		return "(efault)";
700
701	return NULL;
702}
703
704static int check_pointer(char **buf, char *end, const void *ptr,
705			 struct printf_spec spec)
706{
707	const char *err_msg;
708
709	err_msg = check_pointer_msg(ptr);
710	if (err_msg) {
711		*buf = error_string(*buf, end, err_msg, spec);
712		return -EFAULT;
713	}
714
715	return 0;
716}
717
718static noinline_for_stack
719char *string(char *buf, char *end, const char *s,
720	     struct printf_spec spec)
721{
722	if (check_pointer(&buf, end, s, spec))
723		return buf;
724
725	return string_nocheck(buf, end, s, spec);
726}
727
728static char *pointer_string(char *buf, char *end,
729			    const void *ptr,
730			    struct printf_spec spec)
731{
732	spec.base = 16;
733	spec.flags |= SMALL;
734	if (spec.field_width == -1) {
735		spec.field_width = 2 * sizeof(ptr);
736		spec.flags |= ZEROPAD;
737	}
738
739	return number(buf, end, (unsigned long int)ptr, spec);
740}
741
742/* Make pointers available for printing early in the boot sequence. */
743static int debug_boot_weak_hash __ro_after_init;
744
745static int __init debug_boot_weak_hash_enable(char *str)
746{
747	debug_boot_weak_hash = 1;
748	pr_info("debug_boot_weak_hash enabled\n");
749	return 0;
750}
751early_param("debug_boot_weak_hash", debug_boot_weak_hash_enable);
752
753static DEFINE_STATIC_KEY_FALSE(filled_random_ptr_key);
754
755static void enable_ptr_key_workfn(struct work_struct *work)
756{
757	static_branch_enable(&filled_random_ptr_key);
758}
759
760/* Maps a pointer to a 32 bit unique identifier. */
761static inline int __ptr_to_hashval(const void *ptr, unsigned long *hashval_out)
762{
763	static siphash_key_t ptr_key __read_mostly;
764	unsigned long hashval;
765
766	if (!static_branch_likely(&filled_random_ptr_key)) {
767		static bool filled = false;
768		static DEFINE_SPINLOCK(filling);
769		static DECLARE_WORK(enable_ptr_key_work, enable_ptr_key_workfn);
770		unsigned long flags;
771
772		if (!system_unbound_wq || !rng_is_initialized() ||
773		    !spin_trylock_irqsave(&filling, flags))
774			return -EAGAIN;
775
776		if (!filled) {
777			get_random_bytes(&ptr_key, sizeof(ptr_key));
778			queue_work(system_unbound_wq, &enable_ptr_key_work);
779			filled = true;
780		}
781		spin_unlock_irqrestore(&filling, flags);
782	}
783
784
785#ifdef CONFIG_64BIT
786	hashval = (unsigned long)siphash_1u64((u64)ptr, &ptr_key);
787	/*
788	 * Mask off the first 32 bits, this makes explicit that we have
789	 * modified the address (and 32 bits is plenty for a unique ID).
790	 */
791	hashval = hashval & 0xffffffff;
792#else
793	hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key);
794#endif
795	*hashval_out = hashval;
796	return 0;
797}
798
799int ptr_to_hashval(const void *ptr, unsigned long *hashval_out)
800{
801	return __ptr_to_hashval(ptr, hashval_out);
802}
803
804static char *ptr_to_id(char *buf, char *end, const void *ptr,
805		       struct printf_spec spec)
806{
807	const char *str = sizeof(ptr) == 8 ? "(____ptrval____)" : "(ptrval)";
808	unsigned long hashval;
809	int ret;
810
811	/*
812	 * Print the real pointer value for NULL and error pointers,
813	 * as they are not actual addresses.
814	 */
815	if (IS_ERR_OR_NULL(ptr))
816		return pointer_string(buf, end, ptr, spec);
817
818	/* When debugging early boot use non-cryptographically secure hash. */
819	if (unlikely(debug_boot_weak_hash)) {
820		hashval = hash_long((unsigned long)ptr, 32);
821		return pointer_string(buf, end, (const void *)hashval, spec);
822	}
823
824	ret = __ptr_to_hashval(ptr, &hashval);
825	if (ret) {
826		spec.field_width = 2 * sizeof(ptr);
827		/* string length must be less than default_width */
828		return error_string(buf, end, str, spec);
829	}
830
831	return pointer_string(buf, end, (const void *)hashval, spec);
832}
833
834static char *default_pointer(char *buf, char *end, const void *ptr,
835			     struct printf_spec spec)
836{
837	/*
838	 * default is to _not_ leak addresses, so hash before printing,
839	 * unless no_hash_pointers is specified on the command line.
840	 */
841	if (unlikely(no_hash_pointers))
842		return pointer_string(buf, end, ptr, spec);
843
844	return ptr_to_id(buf, end, ptr, spec);
845}
846
847int kptr_restrict __read_mostly;
848
849static noinline_for_stack
850char *restricted_pointer(char *buf, char *end, const void *ptr,
851			 struct printf_spec spec)
852{
853	switch (kptr_restrict) {
854	case 0:
855		/* Handle as %p, hash and do _not_ leak addresses. */
856		return default_pointer(buf, end, ptr, spec);
857	case 1: {
858		const struct cred *cred;
859
860		/*
861		 * kptr_restrict==1 cannot be used in IRQ context
862		 * because its test for CAP_SYSLOG would be meaningless.
863		 */
864		if (in_irq() || in_serving_softirq() || in_nmi()) {
865			if (spec.field_width == -1)
866				spec.field_width = 2 * sizeof(ptr);
867			return error_string(buf, end, "pK-error", spec);
868		}
869
870		/*
871		 * Only print the real pointer value if the current
872		 * process has CAP_SYSLOG and is running with the
873		 * same credentials it started with. This is because
874		 * access to files is checked at open() time, but %pK
875		 * checks permission at read() time. We don't want to
876		 * leak pointer values if a binary opens a file using
877		 * %pK and then elevates privileges before reading it.
878		 */
879		cred = current_cred();
880		if (!has_capability_noaudit(current, CAP_SYSLOG) ||
881		    !uid_eq(cred->euid, cred->uid) ||
882		    !gid_eq(cred->egid, cred->gid))
883			ptr = NULL;
884		break;
885	}
886	case 2:
887	default:
888		/* Always print 0's for %pK */
889		ptr = NULL;
890		break;
891	}
892
893	return pointer_string(buf, end, ptr, spec);
894}
895
896static noinline_for_stack
897char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,
898		  const char *fmt)
899{
900	const char *array[4], *s;
901	const struct dentry *p;
902	int depth;
903	int i, n;
904
905	switch (fmt[1]) {
906		case '2': case '3': case '4':
907			depth = fmt[1] - '0';
908			break;
909		default:
910			depth = 1;
911	}
912
913	rcu_read_lock();
914	for (i = 0; i < depth; i++, d = p) {
915		if (check_pointer(&buf, end, d, spec)) {
916			rcu_read_unlock();
917			return buf;
918		}
919
920		p = READ_ONCE(d->d_parent);
921		array[i] = READ_ONCE(d->d_name.name);
922		if (p == d) {
923			if (i)
924				array[i] = "";
925			i++;
926			break;
927		}
928	}
929	s = array[--i];
930	for (n = 0; n != spec.precision; n++, buf++) {
931		char c = *s++;
932		if (!c) {
933			if (!i)
934				break;
935			c = '/';
936			s = array[--i];
937		}
938		if (buf < end)
939			*buf = c;
940	}
941	rcu_read_unlock();
942	return widen_string(buf, n, end, spec);
943}
944
945static noinline_for_stack
946char *file_dentry_name(char *buf, char *end, const struct file *f,
947			struct printf_spec spec, const char *fmt)
948{
949	if (check_pointer(&buf, end, f, spec))
950		return buf;
951
952	return dentry_name(buf, end, f->f_path.dentry, spec, fmt);
953}
954#ifdef CONFIG_BLOCK
955static noinline_for_stack
956char *bdev_name(char *buf, char *end, struct block_device *bdev,
957		struct printf_spec spec, const char *fmt)
958{
959	struct gendisk *hd;
960
961	if (check_pointer(&buf, end, bdev, spec))
962		return buf;
963
964	hd = bdev->bd_disk;
965	buf = string(buf, end, hd->disk_name, spec);
966	if (bdev->bd_partno) {
967		if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) {
968			if (buf < end)
969				*buf = 'p';
970			buf++;
971		}
972		buf = number(buf, end, bdev->bd_partno, spec);
973	}
974	return buf;
975}
976#endif
977
978static noinline_for_stack
979char *symbol_string(char *buf, char *end, void *ptr,
980		    struct printf_spec spec, const char *fmt)
981{
982	unsigned long value;
983#ifdef CONFIG_KALLSYMS
984	char sym[KSYM_SYMBOL_LEN];
985#endif
986
987	if (fmt[1] == 'R')
988		ptr = __builtin_extract_return_addr(ptr);
989	value = (unsigned long)ptr;
990
991#ifdef CONFIG_KALLSYMS
992	if (*fmt == 'B' && fmt[1] == 'b')
993		sprint_backtrace_build_id(sym, value);
994	else if (*fmt == 'B')
995		sprint_backtrace(sym, value);
996	else if (*fmt == 'S' && (fmt[1] == 'b' || (fmt[1] == 'R' && fmt[2] == 'b')))
997		sprint_symbol_build_id(sym, value);
998	else if (*fmt != 's')
999		sprint_symbol(sym, value);
1000	else
1001		sprint_symbol_no_offset(sym, value);
1002
1003	return string_nocheck(buf, end, sym, spec);
1004#else
1005	return special_hex_number(buf, end, value, sizeof(void *));
1006#endif
1007}
1008
1009static const struct printf_spec default_str_spec = {
1010	.field_width = -1,
1011	.precision = -1,
1012};
1013
1014static const struct printf_spec default_flag_spec = {
1015	.base = 16,
1016	.precision = -1,
1017	.flags = SPECIAL | SMALL,
1018};
1019
1020static const struct printf_spec default_dec_spec = {
1021	.base = 10,
1022	.precision = -1,
1023};
1024
1025static const struct printf_spec default_dec02_spec = {
1026	.base = 10,
1027	.field_width = 2,
1028	.precision = -1,
1029	.flags = ZEROPAD,
1030};
1031
1032static const struct printf_spec default_dec04_spec = {
1033	.base = 10,
1034	.field_width = 4,
1035	.precision = -1,
1036	.flags = ZEROPAD,
1037};
1038
1039static noinline_for_stack
1040char *resource_string(char *buf, char *end, struct resource *res,
1041		      struct printf_spec spec, const char *fmt)
1042{
1043#ifndef IO_RSRC_PRINTK_SIZE
1044#define IO_RSRC_PRINTK_SIZE	6
1045#endif
1046
1047#ifndef MEM_RSRC_PRINTK_SIZE
1048#define MEM_RSRC_PRINTK_SIZE	10
1049#endif
1050	static const struct printf_spec io_spec = {
1051		.base = 16,
1052		.field_width = IO_RSRC_PRINTK_SIZE,
1053		.precision = -1,
1054		.flags = SPECIAL | SMALL | ZEROPAD,
1055	};
1056	static const struct printf_spec mem_spec = {
1057		.base = 16,
1058		.field_width = MEM_RSRC_PRINTK_SIZE,
1059		.precision = -1,
1060		.flags = SPECIAL | SMALL | ZEROPAD,
1061	};
1062	static const struct printf_spec bus_spec = {
1063		.base = 16,
1064		.field_width = 2,
1065		.precision = -1,
1066		.flags = SMALL | ZEROPAD,
1067	};
1068	static const struct printf_spec str_spec = {
1069		.field_width = -1,
1070		.precision = 10,
1071		.flags = LEFT,
1072	};
1073
1074	/* 32-bit res (sizeof==4): 10 chars in dec, 10 in hex ("0x" + 8)
1075	 * 64-bit res (sizeof==8): 20 chars in dec, 18 in hex ("0x" + 16) */
1076#define RSRC_BUF_SIZE		((2 * sizeof(resource_size_t)) + 4)
1077#define FLAG_BUF_SIZE		(2 * sizeof(res->flags))
1078#define DECODED_BUF_SIZE	sizeof("[mem - 64bit pref window disabled]")
1079#define RAW_BUF_SIZE		sizeof("[mem - flags 0x]")
1080	char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
1081		     2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
1082
1083	char *p = sym, *pend = sym + sizeof(sym);
1084	int decode = (fmt[0] == 'R') ? 1 : 0;
1085	const struct printf_spec *specp;
1086
1087	if (check_pointer(&buf, end, res, spec))
1088		return buf;
1089
1090	*p++ = '[';
1091	if (res->flags & IORESOURCE_IO) {
1092		p = string_nocheck(p, pend, "io  ", str_spec);
1093		specp = &io_spec;
1094	} else if (res->flags & IORESOURCE_MEM) {
1095		p = string_nocheck(p, pend, "mem ", str_spec);
1096		specp = &mem_spec;
1097	} else if (res->flags & IORESOURCE_IRQ) {
1098		p = string_nocheck(p, pend, "irq ", str_spec);
1099		specp = &default_dec_spec;
1100	} else if (res->flags & IORESOURCE_DMA) {
1101		p = string_nocheck(p, pend, "dma ", str_spec);
1102		specp = &default_dec_spec;
1103	} else if (res->flags & IORESOURCE_BUS) {
1104		p = string_nocheck(p, pend, "bus ", str_spec);
1105		specp = &bus_spec;
1106	} else {
1107		p = string_nocheck(p, pend, "??? ", str_spec);
1108		specp = &mem_spec;
1109		decode = 0;
1110	}
1111	if (decode && res->flags & IORESOURCE_UNSET) {
1112		p = string_nocheck(p, pend, "size ", str_spec);
1113		p = number(p, pend, resource_size(res), *specp);
1114	} else {
1115		p = number(p, pend, res->start, *specp);
1116		if (res->start != res->end) {
1117			*p++ = '-';
1118			p = number(p, pend, res->end, *specp);
1119		}
1120	}
1121	if (decode) {
1122		if (res->flags & IORESOURCE_MEM_64)
1123			p = string_nocheck(p, pend, " 64bit", str_spec);
1124		if (res->flags & IORESOURCE_PREFETCH)
1125			p = string_nocheck(p, pend, " pref", str_spec);
1126		if (res->flags & IORESOURCE_WINDOW)
1127			p = string_nocheck(p, pend, " window", str_spec);
1128		if (res->flags & IORESOURCE_DISABLED)
1129			p = string_nocheck(p, pend, " disabled", str_spec);
1130	} else {
1131		p = string_nocheck(p, pend, " flags ", str_spec);
1132		p = number(p, pend, res->flags, default_flag_spec);
1133	}
1134	*p++ = ']';
1135	*p = '\0';
1136
1137	return string_nocheck(buf, end, sym, spec);
1138}
1139
1140static noinline_for_stack
1141char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
1142		 const char *fmt)
1143{
1144	int i, len = 1;		/* if we pass '%ph[CDN]', field width remains
1145				   negative value, fallback to the default */
1146	char separator;
1147
1148	if (spec.field_width == 0)
1149		/* nothing to print */
1150		return buf;
1151
1152	if (check_pointer(&buf, end, addr, spec))
1153		return buf;
1154
1155	switch (fmt[1]) {
1156	case 'C':
1157		separator = ':';
1158		break;
1159	case 'D':
1160		separator = '-';
1161		break;
1162	case 'N':
1163		separator = 0;
1164		break;
1165	default:
1166		separator = ' ';
1167		break;
1168	}
1169
1170	if (spec.field_width > 0)
1171		len = min_t(int, spec.field_width, 64);
1172
1173	for (i = 0; i < len; ++i) {
1174		if (buf < end)
1175			*buf = hex_asc_hi(addr[i]);
1176		++buf;
1177		if (buf < end)
1178			*buf = hex_asc_lo(addr[i]);
1179		++buf;
1180
1181		if (separator && i != len - 1) {
1182			if (buf < end)
1183				*buf = separator;
1184			++buf;
1185		}
1186	}
1187
1188	return buf;
1189}
1190
1191static noinline_for_stack
1192char *bitmap_string(char *buf, char *end, unsigned long *bitmap,
1193		    struct printf_spec spec, const char *fmt)
1194{
1195	const int CHUNKSZ = 32;
1196	int nr_bits = max_t(int, spec.field_width, 0);
1197	int i, chunksz;
1198	bool first = true;
1199
1200	if (check_pointer(&buf, end, bitmap, spec))
1201		return buf;
1202
1203	/* reused to print numbers */
1204	spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };
1205
1206	chunksz = nr_bits & (CHUNKSZ - 1);
1207	if (chunksz == 0)
1208		chunksz = CHUNKSZ;
1209
1210	i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ;
1211	for (; i >= 0; i -= CHUNKSZ) {
1212		u32 chunkmask, val;
1213		int word, bit;
1214
1215		chunkmask = ((1ULL << chunksz) - 1);
1216		word = i / BITS_PER_LONG;
1217		bit = i % BITS_PER_LONG;
1218		val = (bitmap[word] >> bit) & chunkmask;
1219
1220		if (!first) {
1221			if (buf < end)
1222				*buf = ',';
1223			buf++;
1224		}
1225		first = false;
1226
1227		spec.field_width = DIV_ROUND_UP(chunksz, 4);
1228		buf = number(buf, end, val, spec);
1229
1230		chunksz = CHUNKSZ;
1231	}
1232	return buf;
1233}
1234
1235static noinline_for_stack
1236char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,
1237			 struct printf_spec spec, const char *fmt)
1238{
1239	int nr_bits = max_t(int, spec.field_width, 0);
1240	bool first = true;
1241	int rbot, rtop;
1242
1243	if (check_pointer(&buf, end, bitmap, spec))
1244		return buf;
1245
1246	for_each_set_bitrange(rbot, rtop, bitmap, nr_bits) {
1247		if (!first) {
1248			if (buf < end)
1249				*buf = ',';
1250			buf++;
1251		}
1252		first = false;
1253
1254		buf = number(buf, end, rbot, default_dec_spec);
1255		if (rtop == rbot + 1)
1256			continue;
1257
1258		if (buf < end)
1259			*buf = '-';
1260		buf = number(++buf, end, rtop - 1, default_dec_spec);
1261	}
1262	return buf;
1263}
1264
1265static noinline_for_stack
1266char *mac_address_string(char *buf, char *end, u8 *addr,
1267			 struct printf_spec spec, const char *fmt)
1268{
1269	char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
1270	char *p = mac_addr;
1271	int i;
1272	char separator;
1273	bool reversed = false;
1274
1275	if (check_pointer(&buf, end, addr, spec))
1276		return buf;
1277
1278	switch (fmt[1]) {
1279	case 'F':
1280		separator = '-';
1281		break;
1282
1283	case 'R':
1284		reversed = true;
1285		fallthrough;
1286
1287	default:
1288		separator = ':';
1289		break;
1290	}
1291
1292	for (i = 0; i < 6; i++) {
1293		if (reversed)
1294			p = hex_byte_pack(p, addr[5 - i]);
1295		else
1296			p = hex_byte_pack(p, addr[i]);
1297
1298		if (fmt[0] == 'M' && i != 5)
1299			*p++ = separator;
1300	}
1301	*p = '\0';
1302
1303	return string_nocheck(buf, end, mac_addr, spec);
1304}
1305
1306static noinline_for_stack
1307char *ip4_string(char *p, const u8 *addr, const char *fmt)
1308{
1309	int i;
1310	bool leading_zeros = (fmt[0] == 'i');
1311	int index;
1312	int step;
1313
1314	switch (fmt[2]) {
1315	case 'h':
1316#ifdef __BIG_ENDIAN
1317		index = 0;
1318		step = 1;
1319#else
1320		index = 3;
1321		step = -1;
1322#endif
1323		break;
1324	case 'l':
1325		index = 3;
1326		step = -1;
1327		break;
1328	case 'n':
1329	case 'b':
1330	default:
1331		index = 0;
1332		step = 1;
1333		break;
1334	}
1335	for (i = 0; i < 4; i++) {
1336		char temp[4] __aligned(2);	/* hold each IP quad in reverse order */
1337		int digits = put_dec_trunc8(temp, addr[index]) - temp;
1338		if (leading_zeros) {
1339			if (digits < 3)
1340				*p++ = '0';
1341			if (digits < 2)
1342				*p++ = '0';
1343		}
1344		/* reverse the digits in the quad */
1345		while (digits--)
1346			*p++ = temp[digits];
1347		if (i < 3)
1348			*p++ = '.';
1349		index += step;
1350	}
1351	*p = '\0';
1352
1353	return p;
1354}
1355
1356static noinline_for_stack
1357char *ip6_compressed_string(char *p, const char *addr)
1358{
1359	int i, j, range;
1360	unsigned char zerolength[8];
1361	int longest = 1;
1362	int colonpos = -1;
1363	u16 word;
1364	u8 hi, lo;
1365	bool needcolon = false;
1366	bool useIPv4;
1367	struct in6_addr in6;
1368
1369	memcpy(&in6, addr, sizeof(struct in6_addr));
1370
1371	useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
1372
1373	memset(zerolength, 0, sizeof(zerolength));
1374
1375	if (useIPv4)
1376		range = 6;
1377	else
1378		range = 8;
1379
1380	/* find position of longest 0 run */
1381	for (i = 0; i < range; i++) {
1382		for (j = i; j < range; j++) {
1383			if (in6.s6_addr16[j] != 0)
1384				break;
1385			zerolength[i]++;
1386		}
1387	}
1388	for (i = 0; i < range; i++) {
1389		if (zerolength[i] > longest) {
1390			longest = zerolength[i];
1391			colonpos = i;
1392		}
1393	}
1394	if (longest == 1)		/* don't compress a single 0 */
1395		colonpos = -1;
1396
1397	/* emit address */
1398	for (i = 0; i < range; i++) {
1399		if (i == colonpos) {
1400			if (needcolon || i == 0)
1401				*p++ = ':';
1402			*p++ = ':';
1403			needcolon = false;
1404			i += longest - 1;
1405			continue;
1406		}
1407		if (needcolon) {
1408			*p++ = ':';
1409			needcolon = false;
1410		}
1411		/* hex u16 without leading 0s */
1412		word = ntohs(in6.s6_addr16[i]);
1413		hi = word >> 8;
1414		lo = word & 0xff;
1415		if (hi) {
1416			if (hi > 0x0f)
1417				p = hex_byte_pack(p, hi);
1418			else
1419				*p++ = hex_asc_lo(hi);
1420			p = hex_byte_pack(p, lo);
1421		}
1422		else if (lo > 0x0f)
1423			p = hex_byte_pack(p, lo);
1424		else
1425			*p++ = hex_asc_lo(lo);
1426		needcolon = true;
1427	}
1428
1429	if (useIPv4) {
1430		if (needcolon)
1431			*p++ = ':';
1432		p = ip4_string(p, &in6.s6_addr[12], "I4");
1433	}
1434	*p = '\0';
1435
1436	return p;
1437}
1438
1439static noinline_for_stack
1440char *ip6_string(char *p, const char *addr, const char *fmt)
1441{
1442	int i;
1443
1444	for (i = 0; i < 8; i++) {
1445		p = hex_byte_pack(p, *addr++);
1446		p = hex_byte_pack(p, *addr++);
1447		if (fmt[0] == 'I' && i != 7)
1448			*p++ = ':';
1449	}
1450	*p = '\0';
1451
1452	return p;
1453}
1454
1455static noinline_for_stack
1456char *ip6_addr_string(char *buf, char *end, const u8 *addr,
1457		      struct printf_spec spec, const char *fmt)
1458{
1459	char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
1460
1461	if (fmt[0] == 'I' && fmt[2] == 'c')
1462		ip6_compressed_string(ip6_addr, addr);
1463	else
1464		ip6_string(ip6_addr, addr, fmt);
1465
1466	return string_nocheck(buf, end, ip6_addr, spec);
1467}
1468
1469static noinline_for_stack
1470char *ip4_addr_string(char *buf, char *end, const u8 *addr,
1471		      struct printf_spec spec, const char *fmt)
1472{
1473	char ip4_addr[sizeof("255.255.255.255")];
1474
1475	ip4_string(ip4_addr, addr, fmt);
1476
1477	return string_nocheck(buf, end, ip4_addr, spec);
1478}
1479
1480static noinline_for_stack
1481char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
1482			 struct printf_spec spec, const char *fmt)
1483{
1484	bool have_p = false, have_s = false, have_f = false, have_c = false;
1485	char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
1486		      sizeof(":12345") + sizeof("/123456789") +
1487		      sizeof("%1234567890")];
1488	char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);
1489	const u8 *addr = (const u8 *) &sa->sin6_addr;
1490	char fmt6[2] = { fmt[0], '6' };
1491	u8 off = 0;
1492
1493	fmt++;
1494	while (isalpha(*++fmt)) {
1495		switch (*fmt) {
1496		case 'p':
1497			have_p = true;
1498			break;
1499		case 'f':
1500			have_f = true;
1501			break;
1502		case 's':
1503			have_s = true;
1504			break;
1505		case 'c':
1506			have_c = true;
1507			break;
1508		}
1509	}
1510
1511	if (have_p || have_s || have_f) {
1512		*p = '[';
1513		off = 1;
1514	}
1515
1516	if (fmt6[0] == 'I' && have_c)
1517		p = ip6_compressed_string(ip6_addr + off, addr);
1518	else
1519		p = ip6_string(ip6_addr + off, addr, fmt6);
1520
1521	if (have_p || have_s || have_f)
1522		*p++ = ']';
1523
1524	if (have_p) {
1525		*p++ = ':';
1526		p = number(p, pend, ntohs(sa->sin6_port), spec);
1527	}
1528	if (have_f) {
1529		*p++ = '/';
1530		p = number(p, pend, ntohl(sa->sin6_flowinfo &
1531					  IPV6_FLOWINFO_MASK), spec);
1532	}
1533	if (have_s) {
1534		*p++ = '%';
1535		p = number(p, pend, sa->sin6_scope_id, spec);
1536	}
1537	*p = '\0';
1538
1539	return string_nocheck(buf, end, ip6_addr, spec);
1540}
1541
1542static noinline_for_stack
1543char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
1544			 struct printf_spec spec, const char *fmt)
1545{
1546	bool have_p = false;
1547	char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];
1548	char *pend = ip4_addr + sizeof(ip4_addr);
1549	const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
1550	char fmt4[3] = { fmt[0], '4', 0 };
1551
1552	fmt++;
1553	while (isalpha(*++fmt)) {
1554		switch (*fmt) {
1555		case 'p':
1556			have_p = true;
1557			break;
1558		case 'h':
1559		case 'l':
1560		case 'n':
1561		case 'b':
1562			fmt4[2] = *fmt;
1563			break;
1564		}
1565	}
1566
1567	p = ip4_string(ip4_addr, addr, fmt4);
1568	if (have_p) {
1569		*p++ = ':';
1570		p = number(p, pend, ntohs(sa->sin_port), spec);
1571	}
1572	*p = '\0';
1573
1574	return string_nocheck(buf, end, ip4_addr, spec);
1575}
1576
1577static noinline_for_stack
1578char *ip_addr_string(char *buf, char *end, const void *ptr,
1579		     struct printf_spec spec, const char *fmt)
1580{
1581	char *err_fmt_msg;
1582
1583	if (check_pointer(&buf, end, ptr, spec))
1584		return buf;
1585
1586	switch (fmt[1]) {
1587	case '6':
1588		return ip6_addr_string(buf, end, ptr, spec, fmt);
1589	case '4':
1590		return ip4_addr_string(buf, end, ptr, spec, fmt);
1591	case 'S': {
1592		const union {
1593			struct sockaddr		raw;
1594			struct sockaddr_in	v4;
1595			struct sockaddr_in6	v6;
1596		} *sa = ptr;
1597
1598		switch (sa->raw.sa_family) {
1599		case AF_INET:
1600			return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
1601		case AF_INET6:
1602			return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
1603		default:
1604			return error_string(buf, end, "(einval)", spec);
1605		}}
1606	}
1607
1608	err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)";
1609	return error_string(buf, end, err_fmt_msg, spec);
1610}
1611
1612static noinline_for_stack
1613char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
1614		     const char *fmt)
1615{
1616	bool found = true;
1617	int count = 1;
1618	unsigned int flags = 0;
1619	int len;
1620
1621	if (spec.field_width == 0)
1622		return buf;				/* nothing to print */
1623
1624	if (check_pointer(&buf, end, addr, spec))
1625		return buf;
1626
1627	do {
1628		switch (fmt[count++]) {
1629		case 'a':
1630			flags |= ESCAPE_ANY;
1631			break;
1632		case 'c':
1633			flags |= ESCAPE_SPECIAL;
1634			break;
1635		case 'h':
1636			flags |= ESCAPE_HEX;
1637			break;
1638		case 'n':
1639			flags |= ESCAPE_NULL;
1640			break;
1641		case 'o':
1642			flags |= ESCAPE_OCTAL;
1643			break;
1644		case 'p':
1645			flags |= ESCAPE_NP;
1646			break;
1647		case 's':
1648			flags |= ESCAPE_SPACE;
1649			break;
1650		default:
1651			found = false;
1652			break;
1653		}
1654	} while (found);
1655
1656	if (!flags)
1657		flags = ESCAPE_ANY_NP;
1658
1659	len = spec.field_width < 0 ? 1 : spec.field_width;
1660
1661	/*
1662	 * string_escape_mem() writes as many characters as it can to
1663	 * the given buffer, and returns the total size of the output
1664	 * had the buffer been big enough.
1665	 */
1666	buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL);
1667
1668	return buf;
1669}
1670
1671static char *va_format(char *buf, char *end, struct va_format *va_fmt,
1672		       struct printf_spec spec, const char *fmt)
1673{
1674	va_list va;
1675
1676	if (check_pointer(&buf, end, va_fmt, spec))
1677		return buf;
1678
1679	va_copy(va, *va_fmt->va);
1680	buf += vsnprintf(buf, end > buf ? end - buf : 0, va_fmt->fmt, va);
1681	va_end(va);
1682
1683	return buf;
1684}
1685
1686static noinline_for_stack
1687char *uuid_string(char *buf, char *end, const u8 *addr,
1688		  struct printf_spec spec, const char *fmt)
1689{
1690	char uuid[UUID_STRING_LEN + 1];
1691	char *p = uuid;
1692	int i;
1693	const u8 *index = uuid_index;
1694	bool uc = false;
1695
1696	if (check_pointer(&buf, end, addr, spec))
1697		return buf;
1698
1699	switch (*(++fmt)) {
1700	case 'L':
1701		uc = true;
1702		fallthrough;
1703	case 'l':
1704		index = guid_index;
1705		break;
1706	case 'B':
1707		uc = true;
1708		break;
1709	}
1710
1711	for (i = 0; i < 16; i++) {
1712		if (uc)
1713			p = hex_byte_pack_upper(p, addr[index[i]]);
1714		else
1715			p = hex_byte_pack(p, addr[index[i]]);
1716		switch (i) {
1717		case 3:
1718		case 5:
1719		case 7:
1720		case 9:
1721			*p++ = '-';
1722			break;
1723		}
1724	}
1725
1726	*p = 0;
1727
1728	return string_nocheck(buf, end, uuid, spec);
1729}
1730
1731static noinline_for_stack
1732char *netdev_bits(char *buf, char *end, const void *addr,
1733		  struct printf_spec spec,  const char *fmt)
1734{
1735	unsigned long long num;
1736	int size;
1737
1738	if (check_pointer(&buf, end, addr, spec))
1739		return buf;
1740
1741	switch (fmt[1]) {
1742	case 'F':
1743		num = *(const netdev_features_t *)addr;
1744		size = sizeof(netdev_features_t);
1745		break;
1746	default:
1747		return error_string(buf, end, "(%pN?)", spec);
1748	}
1749
1750	return special_hex_number(buf, end, num, size);
1751}
1752
1753static noinline_for_stack
1754char *fourcc_string(char *buf, char *end, const u32 *fourcc,
1755		    struct printf_spec spec, const char *fmt)
1756{
1757	char output[sizeof("0123 little-endian (0x01234567)")];
1758	char *p = output;
1759	unsigned int i;
1760	u32 orig, val;
1761
1762	if (fmt[1] != 'c' || fmt[2] != 'c')
1763		return error_string(buf, end, "(%p4?)", spec);
1764
1765	if (check_pointer(&buf, end, fourcc, spec))
1766		return buf;
1767
1768	orig = get_unaligned(fourcc);
1769	val = orig & ~BIT(31);
1770
1771	for (i = 0; i < sizeof(u32); i++) {
1772		unsigned char c = val >> (i * 8);
1773
1774		/* Print non-control ASCII characters as-is, dot otherwise */
1775		*p++ = isascii(c) && isprint(c) ? c : '.';
1776	}
1777
1778	*p++ = ' ';
1779	strcpy(p, orig & BIT(31) ? "big-endian" : "little-endian");
1780	p += strlen(p);
1781
1782	*p++ = ' ';
1783	*p++ = '(';
1784	p = special_hex_number(p, output + sizeof(output) - 2, orig, sizeof(u32));
1785	*p++ = ')';
1786	*p = '\0';
1787
1788	return string(buf, end, output, spec);
1789}
1790
1791static noinline_for_stack
1792char *address_val(char *buf, char *end, const void *addr,
1793		  struct printf_spec spec, const char *fmt)
1794{
1795	unsigned long long num;
1796	int size;
1797
1798	if (check_pointer(&buf, end, addr, spec))
1799		return buf;
1800
1801	switch (fmt[1]) {
1802	case 'd':
1803		num = *(const dma_addr_t *)addr;
1804		size = sizeof(dma_addr_t);
1805		break;
1806	case 'p':
1807	default:
1808		num = *(const phys_addr_t *)addr;
1809		size = sizeof(phys_addr_t);
1810		break;
1811	}
1812
1813	return special_hex_number(buf, end, num, size);
1814}
1815
1816static noinline_for_stack
1817char *date_str(char *buf, char *end, const struct rtc_time *tm, bool r)
1818{
1819	int year = tm->tm_year + (r ? 0 : 1900);
1820	int mon = tm->tm_mon + (r ? 0 : 1);
1821
1822	buf = number(buf, end, year, default_dec04_spec);
1823	if (buf < end)
1824		*buf = '-';
1825	buf++;
1826
1827	buf = number(buf, end, mon, default_dec02_spec);
1828	if (buf < end)
1829		*buf = '-';
1830	buf++;
1831
1832	return number(buf, end, tm->tm_mday, default_dec02_spec);
1833}
1834
1835static noinline_for_stack
1836char *time_str(char *buf, char *end, const struct rtc_time *tm, bool r)
1837{
1838	buf = number(buf, end, tm->tm_hour, default_dec02_spec);
1839	if (buf < end)
1840		*buf = ':';
1841	buf++;
1842
1843	buf = number(buf, end, tm->tm_min, default_dec02_spec);
1844	if (buf < end)
1845		*buf = ':';
1846	buf++;
1847
1848	return number(buf, end, tm->tm_sec, default_dec02_spec);
1849}
1850
1851static noinline_for_stack
1852char *rtc_str(char *buf, char *end, const struct rtc_time *tm,
1853	      struct printf_spec spec, const char *fmt)
1854{
1855	bool have_t = true, have_d = true;
1856	bool raw = false, iso8601_separator = true;
1857	bool found = true;
1858	int count = 2;
1859
1860	if (check_pointer(&buf, end, tm, spec))
1861		return buf;
1862
1863	switch (fmt[count]) {
1864	case 'd':
1865		have_t = false;
1866		count++;
1867		break;
1868	case 't':
1869		have_d = false;
1870		count++;
1871		break;
1872	}
1873
1874	do {
1875		switch (fmt[count++]) {
1876		case 'r':
1877			raw = true;
1878			break;
1879		case 's':
1880			iso8601_separator = false;
1881			break;
1882		default:
1883			found = false;
1884			break;
1885		}
1886	} while (found);
1887
1888	if (have_d)
1889		buf = date_str(buf, end, tm, raw);
1890	if (have_d && have_t) {
1891		if (buf < end)
1892			*buf = iso8601_separator ? 'T' : ' ';
1893		buf++;
1894	}
1895	if (have_t)
1896		buf = time_str(buf, end, tm, raw);
1897
1898	return buf;
1899}
1900
1901static noinline_for_stack
1902char *time64_str(char *buf, char *end, const time64_t time,
1903		 struct printf_spec spec, const char *fmt)
1904{
1905	struct rtc_time rtc_time;
1906	struct tm tm;
1907
1908	time64_to_tm(time, 0, &tm);
1909
1910	rtc_time.tm_sec = tm.tm_sec;
1911	rtc_time.tm_min = tm.tm_min;
1912	rtc_time.tm_hour = tm.tm_hour;
1913	rtc_time.tm_mday = tm.tm_mday;
1914	rtc_time.tm_mon = tm.tm_mon;
1915	rtc_time.tm_year = tm.tm_year;
1916	rtc_time.tm_wday = tm.tm_wday;
1917	rtc_time.tm_yday = tm.tm_yday;
1918
1919	rtc_time.tm_isdst = 0;
1920
1921	return rtc_str(buf, end, &rtc_time, spec, fmt);
1922}
1923
1924static noinline_for_stack
1925char *time_and_date(char *buf, char *end, void *ptr, struct printf_spec spec,
1926		    const char *fmt)
1927{
1928	switch (fmt[1]) {
1929	case 'R':
1930		return rtc_str(buf, end, (const struct rtc_time *)ptr, spec, fmt);
1931	case 'T':
1932		return time64_str(buf, end, *(const time64_t *)ptr, spec, fmt);
1933	default:
1934		return error_string(buf, end, "(%pt?)", spec);
1935	}
1936}
1937
1938static noinline_for_stack
1939char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec,
1940	    const char *fmt)
1941{
1942	if (!IS_ENABLED(CONFIG_HAVE_CLK))
1943		return error_string(buf, end, "(%pC?)", spec);
1944
1945	if (check_pointer(&buf, end, clk, spec))
1946		return buf;
1947
1948	switch (fmt[1]) {
1949	case 'n':
1950	default:
1951#ifdef CONFIG_COMMON_CLK
1952		return string(buf, end, __clk_get_name(clk), spec);
1953#else
1954		return ptr_to_id(buf, end, clk, spec);
1955#endif
1956	}
1957}
1958
1959static
1960char *format_flags(char *buf, char *end, unsigned long flags,
1961					const struct trace_print_flags *names)
1962{
1963	unsigned long mask;
1964
1965	for ( ; flags && names->name; names++) {
1966		mask = names->mask;
1967		if ((flags & mask) != mask)
1968			continue;
1969
1970		buf = string(buf, end, names->name, default_str_spec);
1971
1972		flags &= ~mask;
1973		if (flags) {
1974			if (buf < end)
1975				*buf = '|';
1976			buf++;
1977		}
1978	}
1979
1980	if (flags)
1981		buf = number(buf, end, flags, default_flag_spec);
1982
1983	return buf;
1984}
1985
1986struct page_flags_fields {
1987	int width;
1988	int shift;
1989	int mask;
1990	const struct printf_spec *spec;
1991	const char *name;
1992};
1993
1994static const struct page_flags_fields pff[] = {
1995	{SECTIONS_WIDTH, SECTIONS_PGSHIFT, SECTIONS_MASK,
1996	 &default_dec_spec, "section"},
1997	{NODES_WIDTH, NODES_PGSHIFT, NODES_MASK,
1998	 &default_dec_spec, "node"},
1999	{ZONES_WIDTH, ZONES_PGSHIFT, ZONES_MASK,
2000	 &default_dec_spec, "zone"},
2001	{LAST_CPUPID_WIDTH, LAST_CPUPID_PGSHIFT, LAST_CPUPID_MASK,
2002	 &default_flag_spec, "lastcpupid"},
2003	{KASAN_TAG_WIDTH, KASAN_TAG_PGSHIFT, KASAN_TAG_MASK,
2004	 &default_flag_spec, "kasantag"},
2005};
2006
2007static
2008char *format_page_flags(char *buf, char *end, unsigned long flags)
2009{
2010	unsigned long main_flags = flags & PAGEFLAGS_MASK;
2011	bool append = false;
2012	int i;
2013
2014	buf = number(buf, end, flags, default_flag_spec);
2015	if (buf < end)
2016		*buf = '(';
2017	buf++;
2018
2019	/* Page flags from the main area. */
2020	if (main_flags) {
2021		buf = format_flags(buf, end, main_flags, pageflag_names);
2022		append = true;
2023	}
2024
2025	/* Page flags from the fields area */
2026	for (i = 0; i < ARRAY_SIZE(pff); i++) {
2027		/* Skip undefined fields. */
2028		if (!pff[i].width)
2029			continue;
2030
2031		/* Format: Flag Name + '=' (equals sign) + Number + '|' (separator) */
2032		if (append) {
2033			if (buf < end)
2034				*buf = '|';
2035			buf++;
2036		}
2037
2038		buf = string(buf, end, pff[i].name, default_str_spec);
2039		if (buf < end)
2040			*buf = '=';
2041		buf++;
2042		buf = number(buf, end, (flags >> pff[i].shift) & pff[i].mask,
2043			     *pff[i].spec);
2044
2045		append = true;
2046	}
2047	if (buf < end)
2048		*buf = ')';
2049	buf++;
2050
2051	return buf;
2052}
2053
2054static noinline_for_stack
2055char *flags_string(char *buf, char *end, void *flags_ptr,
2056		   struct printf_spec spec, const char *fmt)
2057{
2058	unsigned long flags;
2059	const struct trace_print_flags *names;
2060
2061	if (check_pointer(&buf, end, flags_ptr, spec))
2062		return buf;
2063
2064	switch (fmt[1]) {
2065	case 'p':
2066		return format_page_flags(buf, end, *(unsigned long *)flags_ptr);
2067	case 'v':
2068		flags = *(unsigned long *)flags_ptr;
2069		names = vmaflag_names;
2070		break;
2071	case 'g':
2072		flags = (__force unsigned long)(*(gfp_t *)flags_ptr);
2073		names = gfpflag_names;
2074		break;
2075	default:
2076		return error_string(buf, end, "(%pG?)", spec);
2077	}
2078
2079	return format_flags(buf, end, flags, names);
2080}
2081
2082static noinline_for_stack
2083char *fwnode_full_name_string(struct fwnode_handle *fwnode, char *buf,
2084			      char *end)
2085{
2086	int depth;
2087
2088	/* Loop starting from the root node to the current node. */
2089	for (depth = fwnode_count_parents(fwnode); depth >= 0; depth--) {
2090		struct fwnode_handle *__fwnode =
2091			fwnode_get_nth_parent(fwnode, depth);
2092
2093		buf = string(buf, end, fwnode_get_name_prefix(__fwnode),
2094			     default_str_spec);
2095		buf = string(buf, end, fwnode_get_name(__fwnode),
2096			     default_str_spec);
2097
2098		fwnode_handle_put(__fwnode);
2099	}
2100
2101	return buf;
2102}
2103
2104static noinline_for_stack
2105char *device_node_string(char *buf, char *end, struct device_node *dn,
2106			 struct printf_spec spec, const char *fmt)
2107{
2108	char tbuf[sizeof("xxxx") + 1];
2109	const char *p;
2110	int ret;
2111	char *buf_start = buf;
2112	struct property *prop;
2113	bool has_mult, pass;
2114
2115	struct printf_spec str_spec = spec;
2116	str_spec.field_width = -1;
2117
2118	if (fmt[0] != 'F')
2119		return error_string(buf, end, "(%pO?)", spec);
2120
2121	if (!IS_ENABLED(CONFIG_OF))
2122		return error_string(buf, end, "(%pOF?)", spec);
2123
2124	if (check_pointer(&buf, end, dn, spec))
2125		return buf;
2126
2127	/* simple case without anything any more format specifiers */
2128	fmt++;
2129	if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0)
2130		fmt = "f";
2131
2132	for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) {
2133		int precision;
2134		if (pass) {
2135			if (buf < end)
2136				*buf = ':';
2137			buf++;
2138		}
2139
2140		switch (*fmt) {
2141		case 'f':	/* full_name */
2142			buf = fwnode_full_name_string(of_fwnode_handle(dn), buf,
2143						      end);
2144			break;
2145		case 'n':	/* name */
2146			p = fwnode_get_name(of_fwnode_handle(dn));
2147			precision = str_spec.precision;
2148			str_spec.precision = strchrnul(p, '@') - p;
2149			buf = string(buf, end, p, str_spec);
2150			str_spec.precision = precision;
2151			break;
2152		case 'p':	/* phandle */
2153			buf = number(buf, end, (unsigned int)dn->phandle, default_dec_spec);
2154			break;
2155		case 'P':	/* path-spec */
2156			p = fwnode_get_name(of_fwnode_handle(dn));
2157			if (!p[1])
2158				p = "/";
2159			buf = string(buf, end, p, str_spec);
2160			break;
2161		case 'F':	/* flags */
2162			tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';
2163			tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-';
2164			tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-';
2165			tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-';
2166			tbuf[4] = 0;
2167			buf = string_nocheck(buf, end, tbuf, str_spec);
2168			break;
2169		case 'c':	/* major compatible string */
2170			ret = of_property_read_string(dn, "compatible", &p);
2171			if (!ret)
2172				buf = string(buf, end, p, str_spec);
2173			break;
2174		case 'C':	/* full compatible string */
2175			has_mult = false;
2176			of_property_for_each_string(dn, "compatible", prop, p) {
2177				if (has_mult)
2178					buf = string_nocheck(buf, end, ",", str_spec);
2179				buf = string_nocheck(buf, end, "\"", str_spec);
2180				buf = string(buf, end, p, str_spec);
2181				buf = string_nocheck(buf, end, "\"", str_spec);
2182
2183				has_mult = true;
2184			}
2185			break;
2186		default:
2187			break;
2188		}
2189	}
2190
2191	return widen_string(buf, buf - buf_start, end, spec);
2192}
2193
2194static noinline_for_stack
2195char *fwnode_string(char *buf, char *end, struct fwnode_handle *fwnode,
2196		    struct printf_spec spec, const char *fmt)
2197{
2198	struct printf_spec str_spec = spec;
2199	char *buf_start = buf;
2200
2201	str_spec.field_width = -1;
2202
2203	if (*fmt != 'w')
2204		return error_string(buf, end, "(%pf?)", spec);
2205
2206	if (check_pointer(&buf, end, fwnode, spec))
2207		return buf;
2208
2209	fmt++;
2210
2211	switch (*fmt) {
2212	case 'P':	/* name */
2213		buf = string(buf, end, fwnode_get_name(fwnode), str_spec);
2214		break;
2215	case 'f':	/* full_name */
2216	default:
2217		buf = fwnode_full_name_string(fwnode, buf, end);
2218		break;
2219	}
2220
2221	return widen_string(buf, buf - buf_start, end, spec);
2222}
2223
2224int __init no_hash_pointers_enable(char *str)
2225{
2226	if (no_hash_pointers)
2227		return 0;
2228
2229	no_hash_pointers = true;
2230
2231	pr_warn("**********************************************************\n");
2232	pr_warn("**   NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE   **\n");
2233	pr_warn("**                                                      **\n");
2234	pr_warn("** This system shows unhashed kernel memory addresses   **\n");
2235	pr_warn("** via the console, logs, and other interfaces. This    **\n");
2236	pr_warn("** might reduce the security of your system.            **\n");
2237	pr_warn("**                                                      **\n");
2238	pr_warn("** If you see this message and you are not debugging    **\n");
2239	pr_warn("** the kernel, report this immediately to your system   **\n");
2240	pr_warn("** administrator!                                       **\n");
2241	pr_warn("**                                                      **\n");
2242	pr_warn("**   NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE   **\n");
2243	pr_warn("**********************************************************\n");
2244
2245	return 0;
2246}
2247early_param("no_hash_pointers", no_hash_pointers_enable);
2248
2249/*
2250 * Show a '%p' thing.  A kernel extension is that the '%p' is followed
2251 * by an extra set of alphanumeric characters that are extended format
2252 * specifiers.
2253 *
2254 * Please update scripts/checkpatch.pl when adding/removing conversion
2255 * characters.  (Search for "check for vsprintf extension").
2256 *
2257 * Right now we handle:
2258 *
2259 * - 'S' For symbolic direct pointers (or function descriptors) with offset
2260 * - 's' For symbolic direct pointers (or function descriptors) without offset
2261 * - '[Ss]R' as above with __builtin_extract_return_addr() translation
2262 * - 'S[R]b' as above with module build ID (for use in backtraces)
2263 * - '[Ff]' %pf and %pF were obsoleted and later removed in favor of
2264 *	    %ps and %pS. Be careful when re-using these specifiers.
2265 * - 'B' For backtraced symbolic direct pointers with offset
2266 * - 'Bb' as above with module build ID (for use in backtraces)
2267 * - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
2268 * - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
2269 * - 'b[l]' For a bitmap, the number of bits is determined by the field
2270 *       width which must be explicitly specified either as part of the
2271 *       format string '%32b[l]' or through '%*b[l]', [l] selects
2272 *       range-list format instead of hex format
2273 * - 'M' For a 6-byte MAC address, it prints the address in the
2274 *       usual colon-separated hex notation
2275 * - 'm' For a 6-byte MAC address, it prints the hex address without colons
2276 * - 'MF' For a 6-byte MAC FDDI address, it prints the address
2277 *       with a dash-separated hex notation
2278 * - '[mM]R' For a 6-byte MAC address, Reverse order (Bluetooth)
2279 * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way
2280 *       IPv4 uses dot-separated decimal without leading 0's (1.2.3.4)
2281 *       IPv6 uses colon separated network-order 16 bit hex with leading 0's
2282 *       [S][pfs]
2283 *       Generic IPv4/IPv6 address (struct sockaddr *) that falls back to
2284 *       [4] or [6] and is able to print port [p], flowinfo [f], scope [s]
2285 * - 'i' [46] for 'raw' IPv4/IPv6 addresses
2286 *       IPv6 omits the colons (01020304...0f)
2287 *       IPv4 uses dot-separated decimal with leading 0's (010.123.045.006)
2288 *       [S][pfs]
2289 *       Generic IPv4/IPv6 address (struct sockaddr *) that falls back to
2290 *       [4] or [6] and is able to print port [p], flowinfo [f], scope [s]
2291 * - '[Ii][4S][hnbl]' IPv4 addresses in host, network, big or little endian order
2292 * - 'I[6S]c' for IPv6 addresses printed as specified by
2293 *       https://tools.ietf.org/html/rfc5952
2294 * - 'E[achnops]' For an escaped buffer, where rules are defined by combination
2295 *                of the following flags (see string_escape_mem() for the
2296 *                details):
2297 *                  a - ESCAPE_ANY
2298 *                  c - ESCAPE_SPECIAL
2299 *                  h - ESCAPE_HEX
2300 *                  n - ESCAPE_NULL
2301 *                  o - ESCAPE_OCTAL
2302 *                  p - ESCAPE_NP
2303 *                  s - ESCAPE_SPACE
2304 *                By default ESCAPE_ANY_NP is used.
2305 * - 'U' For a 16 byte UUID/GUID, it prints the UUID/GUID in the form
2306 *       "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
2307 *       Options for %pU are:
2308 *         b big endian lower case hex (default)
2309 *         B big endian UPPER case hex
2310 *         l little endian lower case hex
2311 *         L little endian UPPER case hex
2312 *           big endian output byte order is:
2313 *             [0][1][2][3]-[4][5]-[6][7]-[8][9]-[10][11][12][13][14][15]
2314 *           little endian output byte order is:
2315 *             [3][2][1][0]-[5][4]-[7][6]-[8][9]-[10][11][12][13][14][15]
2316 * - 'V' For a struct va_format which contains a format string * and va_list *,
2317 *       call vsnprintf(->format, *->va_list).
2318 *       Implements a "recursive vsnprintf".
2319 *       Do not use this feature without some mechanism to verify the
2320 *       correctness of the format string and va_list arguments.
2321 * - 'K' For a kernel pointer that should be hidden from unprivileged users.
2322 *       Use only for procfs, sysfs and similar files, not printk(); please
2323 *       read the documentation (path below) first.
2324 * - 'NF' For a netdev_features_t
2325 * - '4cc' V4L2 or DRM FourCC code, with endianness and raw numerical value.
2326 * - 'h[CDN]' For a variable-length buffer, it prints it as a hex string with
2327 *            a certain separator (' ' by default):
2328 *              C colon
2329 *              D dash
2330 *              N no separator
2331 *            The maximum supported length is 64 bytes of the input. Consider
2332 *            to use print_hex_dump() for the larger input.
2333 * - 'a[pd]' For address types [p] phys_addr_t, [d] dma_addr_t and derivatives
2334 *           (default assumed to be phys_addr_t, passed by reference)
2335 * - 'd[234]' For a dentry name (optionally 2-4 last components)
2336 * - 'D[234]' Same as 'd' but for a struct file
2337 * - 'g' For block_device name (gendisk + partition number)
2338 * - 't[RT][dt][r][s]' For time and date as represented by:
2339 *      R    struct rtc_time
2340 *      T    time64_t
2341 * - 'C' For a clock, it prints the name (Common Clock Framework) or address
2342 *       (legacy clock framework) of the clock
2343 * - 'Cn' For a clock, it prints the name (Common Clock Framework) or address
2344 *        (legacy clock framework) of the clock
2345 * - 'G' For flags to be printed as a collection of symbolic strings that would
2346 *       construct the specific value. Supported flags given by option:
2347 *       p page flags (see struct page) given as pointer to unsigned long
2348 *       g gfp flags (GFP_* and __GFP_*) given as pointer to gfp_t
2349 *       v vma flags (VM_*) given as pointer to unsigned long
2350 * - 'OF[fnpPcCF]'  For a device tree object
2351 *                  Without any optional arguments prints the full_name
2352 *                  f device node full_name
2353 *                  n device node name
2354 *                  p device node phandle
2355 *                  P device node path spec (name + @unit)
2356 *                  F device node flags
2357 *                  c major compatible string
2358 *                  C full compatible string
2359 * - 'fw[fP]'	For a firmware node (struct fwnode_handle) pointer
2360 *		Without an option prints the full name of the node
2361 *		f full name
2362 *		P node name, including a possible unit address
2363 * - 'x' For printing the address unmodified. Equivalent to "%lx".
2364 *       Please read the documentation (path below) before using!
2365 * - '[ku]s' For a BPF/tracing related format specifier, e.g. used out of
2366 *           bpf_trace_printk() where [ku] prefix specifies either kernel (k)
2367 *           or user (u) memory to probe, and:
2368 *              s a string, equivalent to "%s" on direct vsnprintf() use
2369 *
2370 * ** When making changes please also update:
2371 *	Documentation/core-api/printk-formats.rst
2372 *
2373 * Note: The default behaviour (unadorned %p) is to hash the address,
2374 * rendering it useful as a unique identifier.
2375 */
2376static noinline_for_stack
2377char *pointer(const char *fmt, char *buf, char *end, void *ptr,
2378	      struct printf_spec spec)
2379{
2380	switch (*fmt) {
2381	case 'S':
2382	case 's':
2383		ptr = dereference_symbol_descriptor(ptr);
2384		fallthrough;
2385	case 'B':
2386		return symbol_string(buf, end, ptr, spec, fmt);
2387	case 'R':
2388	case 'r':
2389		return resource_string(buf, end, ptr, spec, fmt);
2390	case 'h':
2391		return hex_string(buf, end, ptr, spec, fmt);
2392	case 'b':
2393		switch (fmt[1]) {
2394		case 'l':
2395			return bitmap_list_string(buf, end, ptr, spec, fmt);
2396		default:
2397			return bitmap_string(buf, end, ptr, spec, fmt);
2398		}
2399	case 'M':			/* Colon separated: 00:01:02:03:04:05 */
2400	case 'm':			/* Contiguous: 000102030405 */
2401					/* [mM]F (FDDI) */
2402					/* [mM]R (Reverse order; Bluetooth) */
2403		return mac_address_string(buf, end, ptr, spec, fmt);
2404	case 'I':			/* Formatted IP supported
2405					 * 4:	1.2.3.4
2406					 * 6:	0001:0203:...:0708
2407					 * 6c:	1::708 or 1::1.2.3.4
2408					 */
2409	case 'i':			/* Contiguous:
2410					 * 4:	001.002.003.004
2411					 * 6:   000102...0f
2412					 */
2413		return ip_addr_string(buf, end, ptr, spec, fmt);
2414	case 'E':
2415		return escaped_string(buf, end, ptr, spec, fmt);
2416	case 'U':
2417		return uuid_string(buf, end, ptr, spec, fmt);
2418	case 'V':
2419		return va_format(buf, end, ptr, spec, fmt);
2420	case 'K':
2421		return restricted_pointer(buf, end, ptr, spec);
2422	case 'N':
2423		return netdev_bits(buf, end, ptr, spec, fmt);
2424	case '4':
2425		return fourcc_string(buf, end, ptr, spec, fmt);
2426	case 'a':
2427		return address_val(buf, end, ptr, spec, fmt);
2428	case 'd':
2429		return dentry_name(buf, end, ptr, spec, fmt);
2430	case 't':
2431		return time_and_date(buf, end, ptr, spec, fmt);
2432	case 'C':
2433		return clock(buf, end, ptr, spec, fmt);
2434	case 'D':
2435		return file_dentry_name(buf, end, ptr, spec, fmt);
2436#ifdef CONFIG_BLOCK
2437	case 'g':
2438		return bdev_name(buf, end, ptr, spec, fmt);
2439#endif
2440
2441	case 'G':
2442		return flags_string(buf, end, ptr, spec, fmt);
2443	case 'O':
2444		return device_node_string(buf, end, ptr, spec, fmt + 1);
2445	case 'f':
2446		return fwnode_string(buf, end, ptr, spec, fmt + 1);
2447	case 'x':
2448		return pointer_string(buf, end, ptr, spec);
2449	case 'e':
2450		/* %pe with a non-ERR_PTR gets treated as plain %p */
2451		if (!IS_ERR(ptr))
2452			return default_pointer(buf, end, ptr, spec);
2453		return err_ptr(buf, end, ptr, spec);
2454	case 'u':
2455	case 'k':
2456		switch (fmt[1]) {
2457		case 's':
2458			return string(buf, end, ptr, spec);
2459		default:
2460			return error_string(buf, end, "(einval)", spec);
2461		}
2462	default:
2463		return default_pointer(buf, end, ptr, spec);
2464	}
2465}
2466
2467/*
2468 * Helper function to decode printf style format.
2469 * Each call decode a token from the format and return the
2470 * number of characters read (or likely the delta where it wants
2471 * to go on the next call).
2472 * The decoded token is returned through the parameters
2473 *
2474 * 'h', 'l', or 'L' for integer fields
2475 * 'z' support added 23/7/1999 S.H.
2476 * 'z' changed to 'Z' --davidm 1/25/99
2477 * 'Z' changed to 'z' --adobriyan 2017-01-25
2478 * 't' added for ptrdiff_t
2479 *
2480 * @fmt: the format string
2481 * @type of the token returned
2482 * @flags: various flags such as +, -, # tokens..
2483 * @field_width: overwritten width
2484 * @base: base of the number (octal, hex, ...)
2485 * @precision: precision of a number
2486 * @qualifier: qualifier of a number (long, size_t, ...)
2487 */
2488static noinline_for_stack
2489int format_decode(const char *fmt, struct printf_spec *spec)
2490{
2491	const char *start = fmt;
2492	char qualifier;
2493
2494	/* we finished early by reading the field width */
2495	if (spec->type == FORMAT_TYPE_WIDTH) {
2496		if (spec->field_width < 0) {
2497			spec->field_width = -spec->field_width;
2498			spec->flags |= LEFT;
2499		}
2500		spec->type = FORMAT_TYPE_NONE;
2501		goto precision;
2502	}
2503
2504	/* we finished early by reading the precision */
2505	if (spec->type == FORMAT_TYPE_PRECISION) {
2506		if (spec->precision < 0)
2507			spec->precision = 0;
2508
2509		spec->type = FORMAT_TYPE_NONE;
2510		goto qualifier;
2511	}
2512
2513	/* By default */
2514	spec->type = FORMAT_TYPE_NONE;
2515
2516	for (; *fmt ; ++fmt) {
2517		if (*fmt == '%')
2518			break;
2519	}
2520
2521	/* Return the current non-format string */
2522	if (fmt != start || !*fmt)
2523		return fmt - start;
2524
2525	/* Process flags */
2526	spec->flags = 0;
2527
2528	while (1) { /* this also skips first '%' */
2529		bool found = true;
2530
2531		++fmt;
2532
2533		switch (*fmt) {
2534		case '-': spec->flags |= LEFT;    break;
2535		case '+': spec->flags |= PLUS;    break;
2536		case ' ': spec->flags |= SPACE;   break;
2537		case '#': spec->flags |= SPECIAL; break;
2538		case '0': spec->flags |= ZEROPAD; break;
2539		default:  found = false;
2540		}
2541
2542		if (!found)
2543			break;
2544	}
2545
2546	/* get field width */
2547	spec->field_width = -1;
2548
2549	if (isdigit(*fmt))
2550		spec->field_width = skip_atoi(&fmt);
2551	else if (*fmt == '*') {
2552		/* it's the next argument */
2553		spec->type = FORMAT_TYPE_WIDTH;
2554		return ++fmt - start;
2555	}
2556
2557precision:
2558	/* get the precision */
2559	spec->precision = -1;
2560	if (*fmt == '.') {
2561		++fmt;
2562		if (isdigit(*fmt)) {
2563			spec->precision = skip_atoi(&fmt);
2564			if (spec->precision < 0)
2565				spec->precision = 0;
2566		} else if (*fmt == '*') {
2567			/* it's the next argument */
2568			spec->type = FORMAT_TYPE_PRECISION;
2569			return ++fmt - start;
2570		}
2571	}
2572
2573qualifier:
2574	/* get the conversion qualifier */
2575	qualifier = 0;
2576	if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2577	    *fmt == 'z' || *fmt == 't') {
2578		qualifier = *fmt++;
2579		if (unlikely(qualifier == *fmt)) {
2580			if (qualifier == 'l') {
2581				qualifier = 'L';
2582				++fmt;
2583			} else if (qualifier == 'h') {
2584				qualifier = 'H';
2585				++fmt;
2586			}
2587		}
2588	}
2589
2590	/* default base */
2591	spec->base = 10;
2592	switch (*fmt) {
2593	case 'c':
2594		spec->type = FORMAT_TYPE_CHAR;
2595		return ++fmt - start;
2596
2597	case 's':
2598		spec->type = FORMAT_TYPE_STR;
2599		return ++fmt - start;
2600
2601	case 'p':
2602		spec->type = FORMAT_TYPE_PTR;
2603		return ++fmt - start;
2604
2605	case '%':
2606		spec->type = FORMAT_TYPE_PERCENT_CHAR;
2607		return ++fmt - start;
2608
2609	/* integer number formats - set up the flags and "break" */
2610	case 'o':
2611		spec->base = 8;
2612		break;
2613
2614	case 'x':
2615		spec->flags |= SMALL;
2616		fallthrough;
2617
2618	case 'X':
2619		spec->base = 16;
2620		break;
2621
2622	case 'd':
2623	case 'i':
2624		spec->flags |= SIGN;
2625		break;
2626	case 'u':
2627		break;
2628
2629	case 'n':
2630		/*
2631		 * Since %n poses a greater security risk than
2632		 * utility, treat it as any other invalid or
2633		 * unsupported format specifier.
2634		 */
2635		fallthrough;
2636
2637	default:
2638		WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt);
2639		spec->type = FORMAT_TYPE_INVALID;
2640		return fmt - start;
2641	}
2642
2643	if (qualifier == 'L')
2644		spec->type = FORMAT_TYPE_LONG_LONG;
2645	else if (qualifier == 'l') {
2646		BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG);
2647		spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN);
2648	} else if (qualifier == 'z') {
2649		spec->type = FORMAT_TYPE_SIZE_T;
2650	} else if (qualifier == 't') {
2651		spec->type = FORMAT_TYPE_PTRDIFF;
2652	} else if (qualifier == 'H') {
2653		BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE);
2654		spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN);
2655	} else if (qualifier == 'h') {
2656		BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT);
2657		spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN);
2658	} else {
2659		BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT);
2660		spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN);
2661	}
2662
2663	return ++fmt - start;
2664}
2665
2666static void
2667set_field_width(struct printf_spec *spec, int width)
2668{
2669	spec->field_width = width;
2670	if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) {
2671		spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX);
2672	}
2673}
2674
2675static void
2676set_precision(struct printf_spec *spec, int prec)
2677{
2678	spec->precision = prec;
2679	if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) {
2680		spec->precision = clamp(prec, 0, PRECISION_MAX);
2681	}
2682}
2683
2684/**
2685 * vsnprintf - Format a string and place it in a buffer
2686 * @buf: The buffer to place the result into
2687 * @size: The size of the buffer, including the trailing null space
2688 * @fmt: The format string to use
2689 * @args: Arguments for the format string
2690 *
2691 * This function generally follows C99 vsnprintf, but has some
2692 * extensions and a few limitations:
2693 *
2694 *  - ``%n`` is unsupported
2695 *  - ``%p*`` is handled by pointer()
2696 *
2697 * See pointer() or Documentation/core-api/printk-formats.rst for more
2698 * extensive description.
2699 *
2700 * **Please update the documentation in both places when making changes**
2701 *
2702 * The return value is the number of characters which would
2703 * be generated for the given input, excluding the trailing
2704 * '\0', as per ISO C99. If you want to have the exact
2705 * number of characters written into @buf as return value
2706 * (not including the trailing '\0'), use vscnprintf(). If the
2707 * return is greater than or equal to @size, the resulting
2708 * string is truncated.
2709 *
2710 * If you're not already dealing with a va_list consider using snprintf().
2711 */
2712int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
2713{
2714	unsigned long long num;
2715	char *str, *end;
2716	struct printf_spec spec = {0};
2717
2718	/* Reject out-of-range values early.  Large positive sizes are
2719	   used for unknown buffer sizes. */
2720	if (WARN_ON_ONCE(size > INT_MAX))
2721		return 0;
2722
2723	str = buf;
2724	end = buf + size;
2725
2726	/* Make sure end is always >= buf */
2727	if (end < buf) {
2728		end = ((void *)-1);
2729		size = end - buf;
2730	}
2731
2732	while (*fmt) {
2733		const char *old_fmt = fmt;
2734		int read = format_decode(fmt, &spec);
2735
2736		fmt += read;
2737
2738		switch (spec.type) {
2739		case FORMAT_TYPE_NONE: {
2740			int copy = read;
2741			if (str < end) {
2742				if (copy > end - str)
2743					copy = end - str;
2744				memcpy(str, old_fmt, copy);
2745			}
2746			str += read;
2747			break;
2748		}
2749
2750		case FORMAT_TYPE_WIDTH:
2751			set_field_width(&spec, va_arg(args, int));
2752			break;
2753
2754		case FORMAT_TYPE_PRECISION:
2755			set_precision(&spec, va_arg(args, int));
2756			break;
2757
2758		case FORMAT_TYPE_CHAR: {
2759			char c;
2760
2761			if (!(spec.flags & LEFT)) {
2762				while (--spec.field_width > 0) {
2763					if (str < end)
2764						*str = ' ';
2765					++str;
2766
2767				}
2768			}
2769			c = (unsigned char) va_arg(args, int);
2770			if (str < end)
2771				*str = c;
2772			++str;
2773			while (--spec.field_width > 0) {
2774				if (str < end)
2775					*str = ' ';
2776				++str;
2777			}
2778			break;
2779		}
2780
2781		case FORMAT_TYPE_STR:
2782			str = string(str, end, va_arg(args, char *), spec);
2783			break;
2784
2785		case FORMAT_TYPE_PTR:
2786			str = pointer(fmt, str, end, va_arg(args, void *),
2787				      spec);
2788			while (isalnum(*fmt))
2789				fmt++;
2790			break;
2791
2792		case FORMAT_TYPE_PERCENT_CHAR:
2793			if (str < end)
2794				*str = '%';
2795			++str;
2796			break;
2797
2798		case FORMAT_TYPE_INVALID:
2799			/*
2800			 * Presumably the arguments passed gcc's type
2801			 * checking, but there is no safe or sane way
2802			 * for us to continue parsing the format and
2803			 * fetching from the va_list; the remaining
2804			 * specifiers and arguments would be out of
2805			 * sync.
2806			 */
2807			goto out;
2808
2809		default:
2810			switch (spec.type) {
2811			case FORMAT_TYPE_LONG_LONG:
2812				num = va_arg(args, long long);
2813				break;
2814			case FORMAT_TYPE_ULONG:
2815				num = va_arg(args, unsigned long);
2816				break;
2817			case FORMAT_TYPE_LONG:
2818				num = va_arg(args, long);
2819				break;
2820			case FORMAT_TYPE_SIZE_T:
2821				if (spec.flags & SIGN)
2822					num = va_arg(args, ssize_t);
2823				else
2824					num = va_arg(args, size_t);
2825				break;
2826			case FORMAT_TYPE_PTRDIFF:
2827				num = va_arg(args, ptrdiff_t);
2828				break;
2829			case FORMAT_TYPE_UBYTE:
2830				num = (unsigned char) va_arg(args, int);
2831				break;
2832			case FORMAT_TYPE_BYTE:
2833				num = (signed char) va_arg(args, int);
2834				break;
2835			case FORMAT_TYPE_USHORT:
2836				num = (unsigned short) va_arg(args, int);
2837				break;
2838			case FORMAT_TYPE_SHORT:
2839				num = (short) va_arg(args, int);
2840				break;
2841			case FORMAT_TYPE_INT:
2842				num = (int) va_arg(args, int);
2843				break;
2844			default:
2845				num = va_arg(args, unsigned int);
2846			}
2847
2848			str = number(str, end, num, spec);
2849		}
2850	}
2851
2852out:
2853	if (size > 0) {
2854		if (str < end)
2855			*str = '\0';
2856		else
2857			end[-1] = '\0';
2858	}
2859
2860	/* the trailing null byte doesn't count towards the total */
2861	return str-buf;
2862
2863}
2864EXPORT_SYMBOL(vsnprintf);
2865
2866/**
2867 * vscnprintf - Format a string and place it in a buffer
2868 * @buf: The buffer to place the result into
2869 * @size: The size of the buffer, including the trailing null space
2870 * @fmt: The format string to use
2871 * @args: Arguments for the format string
2872 *
2873 * The return value is the number of characters which have been written into
2874 * the @buf not including the trailing '\0'. If @size is == 0 the function
2875 * returns 0.
2876 *
2877 * If you're not already dealing with a va_list consider using scnprintf().
2878 *
2879 * See the vsnprintf() documentation for format string extensions over C99.
2880 */
2881int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
2882{
2883	int i;
2884
2885	if (unlikely(!size))
2886		return 0;
2887
2888	i = vsnprintf(buf, size, fmt, args);
2889
2890	if (likely(i < size))
2891		return i;
2892
2893	return size - 1;
2894}
2895EXPORT_SYMBOL(vscnprintf);
2896
2897/**
2898 * snprintf - Format a string and place it in a buffer
2899 * @buf: The buffer to place the result into
2900 * @size: The size of the buffer, including the trailing null space
2901 * @fmt: The format string to use
2902 * @...: Arguments for the format string
2903 *
2904 * The return value is the number of characters which would be
2905 * generated for the given input, excluding the trailing null,
2906 * as per ISO C99.  If the return is greater than or equal to
2907 * @size, the resulting string is truncated.
2908 *
2909 * See the vsnprintf() documentation for format string extensions over C99.
2910 */
2911int snprintf(char *buf, size_t size, const char *fmt, ...)
2912{
2913	va_list args;
2914	int i;
2915
2916	va_start(args, fmt);
2917	i = vsnprintf(buf, size, fmt, args);
2918	va_end(args);
2919
2920	return i;
2921}
2922EXPORT_SYMBOL(snprintf);
2923
2924/**
2925 * scnprintf - Format a string and place it in a buffer
2926 * @buf: The buffer to place the result into
2927 * @size: The size of the buffer, including the trailing null space
2928 * @fmt: The format string to use
2929 * @...: Arguments for the format string
2930 *
2931 * The return value is the number of characters written into @buf not including
2932 * the trailing '\0'. If @size is == 0 the function returns 0.
2933 */
2934
2935int scnprintf(char *buf, size_t size, const char *fmt, ...)
2936{
2937	va_list args;
2938	int i;
2939
2940	va_start(args, fmt);
2941	i = vscnprintf(buf, size, fmt, args);
2942	va_end(args);
2943
2944	return i;
2945}
2946EXPORT_SYMBOL(scnprintf);
2947
2948/**
2949 * vsprintf - Format a string and place it in a buffer
2950 * @buf: The buffer to place the result into
2951 * @fmt: The format string to use
2952 * @args: Arguments for the format string
2953 *
2954 * The function returns the number of characters written
2955 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
2956 * buffer overflows.
2957 *
2958 * If you're not already dealing with a va_list consider using sprintf().
2959 *
2960 * See the vsnprintf() documentation for format string extensions over C99.
2961 */
2962int vsprintf(char *buf, const char *fmt, va_list args)
2963{
2964	return vsnprintf(buf, INT_MAX, fmt, args);
2965}
2966EXPORT_SYMBOL(vsprintf);
2967
2968/**
2969 * sprintf - Format a string and place it in a buffer
2970 * @buf: The buffer to place the result into
2971 * @fmt: The format string to use
2972 * @...: Arguments for the format string
2973 *
2974 * The function returns the number of characters written
2975 * into @buf. Use snprintf() or scnprintf() in order to avoid
2976 * buffer overflows.
2977 *
2978 * See the vsnprintf() documentation for format string extensions over C99.
2979 */
2980int sprintf(char *buf, const char *fmt, ...)
2981{
2982	va_list args;
2983	int i;
2984
2985	va_start(args, fmt);
2986	i = vsnprintf(buf, INT_MAX, fmt, args);
2987	va_end(args);
2988
2989	return i;
2990}
2991EXPORT_SYMBOL(sprintf);
2992
2993#ifdef CONFIG_BINARY_PRINTF
2994/*
2995 * bprintf service:
2996 * vbin_printf() - VA arguments to binary data
2997 * bstr_printf() - Binary data to text string
2998 */
2999
3000/**
3001 * vbin_printf - Parse a format string and place args' binary value in a buffer
3002 * @bin_buf: The buffer to place args' binary value
3003 * @size: The size of the buffer(by words(32bits), not characters)
3004 * @fmt: The format string to use
3005 * @args: Arguments for the format string
3006 *
3007 * The format follows C99 vsnprintf, except %n is ignored, and its argument
3008 * is skipped.
3009 *
3010 * The return value is the number of words(32bits) which would be generated for
3011 * the given input.
3012 *
3013 * NOTE:
3014 * If the return value is greater than @size, the resulting bin_buf is NOT
3015 * valid for bstr_printf().
3016 */
3017int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
3018{
3019	struct printf_spec spec = {0};
3020	char *str, *end;
3021	int width;
3022
3023	str = (char *)bin_buf;
3024	end = (char *)(bin_buf + size);
3025
3026#define save_arg(type)							\
3027({									\
3028	unsigned long long value;					\
3029	if (sizeof(type) == 8) {					\
3030		unsigned long long val8;				\
3031		str = PTR_ALIGN(str, sizeof(u32));			\
3032		val8 = va_arg(args, unsigned long long);		\
3033		if (str + sizeof(type) <= end) {			\
3034			*(u32 *)str = *(u32 *)&val8;			\
3035			*(u32 *)(str + 4) = *((u32 *)&val8 + 1);	\
3036		}							\
3037		value = val8;						\
3038	} else {							\
3039		unsigned int val4;					\
3040		str = PTR_ALIGN(str, sizeof(type));			\
3041		val4 = va_arg(args, int);				\
3042		if (str + sizeof(type) <= end)				\
3043			*(typeof(type) *)str = (type)(long)val4;	\
3044		value = (unsigned long long)val4;			\
3045	}								\
3046	str += sizeof(type);						\
3047	value;								\
3048})
3049
3050	while (*fmt) {
3051		int read = format_decode(fmt, &spec);
3052
3053		fmt += read;
3054
3055		switch (spec.type) {
3056		case FORMAT_TYPE_NONE:
3057		case FORMAT_TYPE_PERCENT_CHAR:
3058			break;
3059		case FORMAT_TYPE_INVALID:
3060			goto out;
3061
3062		case FORMAT_TYPE_WIDTH:
3063		case FORMAT_TYPE_PRECISION:
3064			width = (int)save_arg(int);
3065			/* Pointers may require the width */
3066			if (*fmt == 'p')
3067				set_field_width(&spec, width);
3068			break;
3069
3070		case FORMAT_TYPE_CHAR:
3071			save_arg(char);
3072			break;
3073
3074		case FORMAT_TYPE_STR: {
3075			const char *save_str = va_arg(args, char *);
3076			const char *err_msg;
3077			size_t len;
3078
3079			err_msg = check_pointer_msg(save_str);
3080			if (err_msg)
3081				save_str = err_msg;
3082
3083			len = strlen(save_str) + 1;
3084			if (str + len < end)
3085				memcpy(str, save_str, len);
3086			str += len;
3087			break;
3088		}
3089
3090		case FORMAT_TYPE_PTR:
3091			/* Dereferenced pointers must be done now */
3092			switch (*fmt) {
3093			/* Dereference of functions is still OK */
3094			case 'S':
3095			case 's':
3096			case 'x':
3097			case 'K':
3098			case 'e':
3099				save_arg(void *);
3100				break;
3101			default:
3102				if (!isalnum(*fmt)) {
3103					save_arg(void *);
3104					break;
3105				}
3106				str = pointer(fmt, str, end, va_arg(args, void *),
3107					      spec);
3108				if (str + 1 < end)
3109					*str++ = '\0';
3110				else
3111					end[-1] = '\0'; /* Must be nul terminated */
3112			}
3113			/* skip all alphanumeric pointer suffixes */
3114			while (isalnum(*fmt))
3115				fmt++;
3116			break;
3117
3118		default:
3119			switch (spec.type) {
3120
3121			case FORMAT_TYPE_LONG_LONG:
3122				save_arg(long long);
3123				break;
3124			case FORMAT_TYPE_ULONG:
3125			case FORMAT_TYPE_LONG:
3126				save_arg(unsigned long);
3127				break;
3128			case FORMAT_TYPE_SIZE_T:
3129				save_arg(size_t);
3130				break;
3131			case FORMAT_TYPE_PTRDIFF:
3132				save_arg(ptrdiff_t);
3133				break;
3134			case FORMAT_TYPE_UBYTE:
3135			case FORMAT_TYPE_BYTE:
3136				save_arg(char);
3137				break;
3138			case FORMAT_TYPE_USHORT:
3139			case FORMAT_TYPE_SHORT:
3140				save_arg(short);
3141				break;
3142			default:
3143				save_arg(int);
3144			}
3145		}
3146	}
3147
3148out:
3149	return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
3150#undef save_arg
3151}
3152EXPORT_SYMBOL_GPL(vbin_printf);
3153
3154/**
3155 * bstr_printf - Format a string from binary arguments and place it in a buffer
3156 * @buf: The buffer to place the result into
3157 * @size: The size of the buffer, including the trailing null space
3158 * @fmt: The format string to use
3159 * @bin_buf: Binary arguments for the format string
3160 *
3161 * This function like C99 vsnprintf, but the difference is that vsnprintf gets
3162 * arguments from stack, and bstr_printf gets arguments from @bin_buf which is
3163 * a binary buffer that generated by vbin_printf.
3164 *
3165 * The format follows C99 vsnprintf, but has some extensions:
3166 *  see vsnprintf comment for details.
3167 *
3168 * The return value is the number of characters which would
3169 * be generated for the given input, excluding the trailing
3170 * '\0', as per ISO C99. If you want to have the exact
3171 * number of characters written into @buf as return value
3172 * (not including the trailing '\0'), use vscnprintf(). If the
3173 * return is greater than or equal to @size, the resulting
3174 * string is truncated.
3175 */
3176int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
3177{
3178	struct printf_spec spec = {0};
3179	char *str, *end;
3180	const char *args = (const char *)bin_buf;
3181
3182	if (WARN_ON_ONCE(size > INT_MAX))
3183		return 0;
3184
3185	str = buf;
3186	end = buf + size;
3187
3188#define get_arg(type)							\
3189({									\
3190	typeof(type) value;						\
3191	if (sizeof(type) == 8) {					\
3192		args = PTR_ALIGN(args, sizeof(u32));			\
3193		*(u32 *)&value = *(u32 *)args;				\
3194		*((u32 *)&value + 1) = *(u32 *)(args + 4);		\
3195	} else {							\
3196		args = PTR_ALIGN(args, sizeof(type));			\
3197		value = *(typeof(type) *)args;				\
3198	}								\
3199	args += sizeof(type);						\
3200	value;								\
3201})
3202
3203	/* Make sure end is always >= buf */
3204	if (end < buf) {
3205		end = ((void *)-1);
3206		size = end - buf;
3207	}
3208
3209	while (*fmt) {
3210		const char *old_fmt = fmt;
3211		int read = format_decode(fmt, &spec);
3212
3213		fmt += read;
3214
3215		switch (spec.type) {
3216		case FORMAT_TYPE_NONE: {
3217			int copy = read;
3218			if (str < end) {
3219				if (copy > end - str)
3220					copy = end - str;
3221				memcpy(str, old_fmt, copy);
3222			}
3223			str += read;
3224			break;
3225		}
3226
3227		case FORMAT_TYPE_WIDTH:
3228			set_field_width(&spec, get_arg(int));
3229			break;
3230
3231		case FORMAT_TYPE_PRECISION:
3232			set_precision(&spec, get_arg(int));
3233			break;
3234
3235		case FORMAT_TYPE_CHAR: {
3236			char c;
3237
3238			if (!(spec.flags & LEFT)) {
3239				while (--spec.field_width > 0) {
3240					if (str < end)
3241						*str = ' ';
3242					++str;
3243				}
3244			}
3245			c = (unsigned char) get_arg(char);
3246			if (str < end)
3247				*str = c;
3248			++str;
3249			while (--spec.field_width > 0) {
3250				if (str < end)
3251					*str = ' ';
3252				++str;
3253			}
3254			break;
3255		}
3256
3257		case FORMAT_TYPE_STR: {
3258			const char *str_arg = args;
3259			args += strlen(str_arg) + 1;
3260			str = string(str, end, (char *)str_arg, spec);
3261			break;
3262		}
3263
3264		case FORMAT_TYPE_PTR: {
3265			bool process = false;
3266			int copy, len;
3267			/* Non function dereferences were already done */
3268			switch (*fmt) {
3269			case 'S':
3270			case 's':
3271			case 'x':
3272			case 'K':
3273			case 'e':
3274				process = true;
3275				break;
3276			default:
3277				if (!isalnum(*fmt)) {
3278					process = true;
3279					break;
3280				}
3281				/* Pointer dereference was already processed */
3282				if (str < end) {
3283					len = copy = strlen(args);
3284					if (copy > end - str)
3285						copy = end - str;
3286					memcpy(str, args, copy);
3287					str += len;
3288					args += len + 1;
3289				}
3290			}
3291			if (process)
3292				str = pointer(fmt, str, end, get_arg(void *), spec);
3293
3294			while (isalnum(*fmt))
3295				fmt++;
3296			break;
3297		}
3298
3299		case FORMAT_TYPE_PERCENT_CHAR:
3300			if (str < end)
3301				*str = '%';
3302			++str;
3303			break;
3304
3305		case FORMAT_TYPE_INVALID:
3306			goto out;
3307
3308		default: {
3309			unsigned long long num;
3310
3311			switch (spec.type) {
3312
3313			case FORMAT_TYPE_LONG_LONG:
3314				num = get_arg(long long);
3315				break;
3316			case FORMAT_TYPE_ULONG:
3317			case FORMAT_TYPE_LONG:
3318				num = get_arg(unsigned long);
3319				break;
3320			case FORMAT_TYPE_SIZE_T:
3321				num = get_arg(size_t);
3322				break;
3323			case FORMAT_TYPE_PTRDIFF:
3324				num = get_arg(ptrdiff_t);
3325				break;
3326			case FORMAT_TYPE_UBYTE:
3327				num = get_arg(unsigned char);
3328				break;
3329			case FORMAT_TYPE_BYTE:
3330				num = get_arg(signed char);
3331				break;
3332			case FORMAT_TYPE_USHORT:
3333				num = get_arg(unsigned short);
3334				break;
3335			case FORMAT_TYPE_SHORT:
3336				num = get_arg(short);
3337				break;
3338			case FORMAT_TYPE_UINT:
3339				num = get_arg(unsigned int);
3340				break;
3341			default:
3342				num = get_arg(int);
3343			}
3344
3345			str = number(str, end, num, spec);
3346		} /* default: */
3347		} /* switch(spec.type) */
3348	} /* while(*fmt) */
3349
3350out:
3351	if (size > 0) {
3352		if (str < end)
3353			*str = '\0';
3354		else
3355			end[-1] = '\0';
3356	}
3357
3358#undef get_arg
3359
3360	/* the trailing null byte doesn't count towards the total */
3361	return str - buf;
3362}
3363EXPORT_SYMBOL_GPL(bstr_printf);
3364
3365/**
3366 * bprintf - Parse a format string and place args' binary value in a buffer
3367 * @bin_buf: The buffer to place args' binary value
3368 * @size: The size of the buffer(by words(32bits), not characters)
3369 * @fmt: The format string to use
3370 * @...: Arguments for the format string
3371 *
3372 * The function returns the number of words(u32) written
3373 * into @bin_buf.
3374 */
3375int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
3376{
3377	va_list args;
3378	int ret;
3379
3380	va_start(args, fmt);
3381	ret = vbin_printf(bin_buf, size, fmt, args);
3382	va_end(args);
3383
3384	return ret;
3385}
3386EXPORT_SYMBOL_GPL(bprintf);
3387
3388#endif /* CONFIG_BINARY_PRINTF */
3389
3390/**
3391 * vsscanf - Unformat a buffer into a list of arguments
3392 * @buf:	input buffer
3393 * @fmt:	format of buffer
3394 * @args:	arguments
3395 */
3396int vsscanf(const char *buf, const char *fmt, va_list args)
3397{
3398	const char *str = buf;
3399	char *next;
3400	char digit;
3401	int num = 0;
3402	u8 qualifier;
3403	unsigned int base;
3404	union {
3405		long long s;
3406		unsigned long long u;
3407	} val;
3408	s16 field_width;
3409	bool is_sign;
3410
3411	while (*fmt) {
3412		/* skip any white space in format */
3413		/* white space in format matches any amount of
3414		 * white space, including none, in the input.
3415		 */
3416		if (isspace(*fmt)) {
3417			fmt = skip_spaces(++fmt);
3418			str = skip_spaces(str);
3419		}
3420
3421		/* anything that is not a conversion must match exactly */
3422		if (*fmt != '%' && *fmt) {
3423			if (*fmt++ != *str++)
3424				break;
3425			continue;
3426		}
3427
3428		if (!*fmt)
3429			break;
3430		++fmt;
3431
3432		/* skip this conversion.
3433		 * advance both strings to next white space
3434		 */
3435		if (*fmt == '*') {
3436			if (!*str)
3437				break;
3438			while (!isspace(*fmt) && *fmt != '%' && *fmt) {
3439				/* '%*[' not yet supported, invalid format */
3440				if (*fmt == '[')
3441					return num;
3442				fmt++;
3443			}
3444			while (!isspace(*str) && *str)
3445				str++;
3446			continue;
3447		}
3448
3449		/* get field width */
3450		field_width = -1;
3451		if (isdigit(*fmt)) {
3452			field_width = skip_atoi(&fmt);
3453			if (field_width <= 0)
3454				break;
3455		}
3456
3457		/* get conversion qualifier */
3458		qualifier = -1;
3459		if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
3460		    *fmt == 'z') {
3461			qualifier = *fmt++;
3462			if (unlikely(qualifier == *fmt)) {
3463				if (qualifier == 'h') {
3464					qualifier = 'H';
3465					fmt++;
3466				} else if (qualifier == 'l') {
3467					qualifier = 'L';
3468					fmt++;
3469				}
3470			}
3471		}
3472
3473		if (!*fmt)
3474			break;
3475
3476		if (*fmt == 'n') {
3477			/* return number of characters read so far */
3478			*va_arg(args, int *) = str - buf;
3479			++fmt;
3480			continue;
3481		}
3482
3483		if (!*str)
3484			break;
3485
3486		base = 10;
3487		is_sign = false;
3488
3489		switch (*fmt++) {
3490		case 'c':
3491		{
3492			char *s = (char *)va_arg(args, char*);
3493			if (field_width == -1)
3494				field_width = 1;
3495			do {
3496				*s++ = *str++;
3497			} while (--field_width > 0 && *str);
3498			num++;
3499		}
3500		continue;
3501		case 's':
3502		{
3503			char *s = (char *)va_arg(args, char *);
3504			if (field_width == -1)
3505				field_width = SHRT_MAX;
3506			/* first, skip leading white space in buffer */
3507			str = skip_spaces(str);
3508
3509			/* now copy until next white space */
3510			while (*str && !isspace(*str) && field_width--)
3511				*s++ = *str++;
3512			*s = '\0';
3513			num++;
3514		}
3515		continue;
3516		/*
3517		 * Warning: This implementation of the '[' conversion specifier
3518		 * deviates from its glibc counterpart in the following ways:
3519		 * (1) It does NOT support ranges i.e. '-' is NOT a special
3520		 *     character
3521		 * (2) It cannot match the closing bracket ']' itself
3522		 * (3) A field width is required
3523		 * (4) '%*[' (discard matching input) is currently not supported
3524		 *
3525		 * Example usage:
3526		 * ret = sscanf("00:0a:95","%2[^:]:%2[^:]:%2[^:]",
3527		 *		buf1, buf2, buf3);
3528		 * if (ret < 3)
3529		 *    // etc..
3530		 */
3531		case '[':
3532		{
3533			char *s = (char *)va_arg(args, char *);
3534			DECLARE_BITMAP(set, 256) = {0};
3535			unsigned int len = 0;
3536			bool negate = (*fmt == '^');
3537
3538			/* field width is required */
3539			if (field_width == -1)
3540				return num;
3541
3542			if (negate)
3543				++fmt;
3544
3545			for ( ; *fmt && *fmt != ']'; ++fmt, ++len)
3546				__set_bit((u8)*fmt, set);
3547
3548			/* no ']' or no character set found */
3549			if (!*fmt || !len)
3550				return num;
3551			++fmt;
3552
3553			if (negate) {
3554				bitmap_complement(set, set, 256);
3555				/* exclude null '\0' byte */
3556				__clear_bit(0, set);
3557			}
3558
3559			/* match must be non-empty */
3560			if (!test_bit((u8)*str, set))
3561				return num;
3562
3563			while (test_bit((u8)*str, set) && field_width--)
3564				*s++ = *str++;
3565			*s = '\0';
3566			++num;
3567		}
3568		continue;
3569		case 'o':
3570			base = 8;
3571			break;
3572		case 'x':
3573		case 'X':
3574			base = 16;
3575			break;
3576		case 'i':
3577			base = 0;
3578			fallthrough;
3579		case 'd':
3580			is_sign = true;
3581			fallthrough;
3582		case 'u':
3583			break;
3584		case '%':
3585			/* looking for '%' in str */
3586			if (*str++ != '%')
3587				return num;
3588			continue;
3589		default:
3590			/* invalid format; stop here */
3591			return num;
3592		}
3593
3594		/* have some sort of integer conversion.
3595		 * first, skip white space in buffer.
3596		 */
3597		str = skip_spaces(str);
3598
3599		digit = *str;
3600		if (is_sign && digit == '-') {
3601			if (field_width == 1)
3602				break;
3603
3604			digit = *(str + 1);
3605		}
3606
3607		if (!digit
3608		    || (base == 16 && !isxdigit(digit))
3609		    || (base == 10 && !isdigit(digit))
3610		    || (base == 8 && (!isdigit(digit) || digit > '7'))
3611		    || (base == 0 && !isdigit(digit)))
3612			break;
3613
3614		if (is_sign)
3615			val.s = simple_strntoll(str,
3616						field_width >= 0 ? field_width : INT_MAX,
3617						&next, base);
3618		else
3619			val.u = simple_strntoull(str,
3620						 field_width >= 0 ? field_width : INT_MAX,
3621						 &next, base);
3622
3623		switch (qualifier) {
3624		case 'H':	/* that's 'hh' in format */
3625			if (is_sign)
3626				*va_arg(args, signed char *) = val.s;
3627			else
3628				*va_arg(args, unsigned char *) = val.u;
3629			break;
3630		case 'h':
3631			if (is_sign)
3632				*va_arg(args, short *) = val.s;
3633			else
3634				*va_arg(args, unsigned short *) = val.u;
3635			break;
3636		case 'l':
3637			if (is_sign)
3638				*va_arg(args, long *) = val.s;
3639			else
3640				*va_arg(args, unsigned long *) = val.u;
3641			break;
3642		case 'L':
3643			if (is_sign)
3644				*va_arg(args, long long *) = val.s;
3645			else
3646				*va_arg(args, unsigned long long *) = val.u;
3647			break;
3648		case 'z':
3649			*va_arg(args, size_t *) = val.u;
3650			break;
3651		default:
3652			if (is_sign)
3653				*va_arg(args, int *) = val.s;
3654			else
3655				*va_arg(args, unsigned int *) = val.u;
3656			break;
3657		}
3658		num++;
3659
3660		if (!next)
3661			break;
3662		str = next;
3663	}
3664
3665	return num;
3666}
3667EXPORT_SYMBOL(vsscanf);
3668
3669/**
3670 * sscanf - Unformat a buffer into a list of arguments
3671 * @buf:	input buffer
3672 * @fmt:	formatting of buffer
3673 * @...:	resulting arguments
3674 */
3675int sscanf(const char *buf, const char *fmt, ...)
3676{
3677	va_list args;
3678	int i;
3679
3680	va_start(args, fmt);
3681	i = vsscanf(buf, fmt, args);
3682	va_end(args);
3683
3684	return i;
3685}
3686EXPORT_SYMBOL(sscanf);
3687