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