projects/linux·blob v7.1 · refs

3739 lines · 89.9 KiB

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