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