1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <stdarg.h>
20#include <linux/clk.h>
21#include <linux/clk-provider.h>
22#include <linux/module.h>
23#include <linux/types.h>
24#include <linux/string.h>
25#include <linux/ctype.h>
26#include <linux/kernel.h>
27#include <linux/kallsyms.h>
28#include <linux/math64.h>
29#include <linux/uaccess.h>
30#include <linux/ioport.h>
31#include <linux/dcache.h>
32#include <linux/cred.h>
33#include <linux/uuid.h>
34#include <linux/of.h>
35#include <net/addrconf.h>
36#include <linux/siphash.h>
37#include <linux/compiler.h>
38#ifdef CONFIG_BLOCK
39#include <linux/blkdev.h>
40#endif
41
42#include "../mm/internal.h"
43
44#include <asm/page.h>
45#include <asm/byteorder.h>
46
47#include <linux/string_helpers.h>
48#include "kstrtox.h"
49
50
51
52
53
54
55
56
57
58unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
59{
60 unsigned long long result;
61 unsigned int rv;
62
63 cp = _parse_integer_fixup_radix(cp, &base);
64 rv = _parse_integer(cp, base, &result);
65
66 cp += (rv & ~KSTRTOX_OVERFLOW);
67
68 if (endp)
69 *endp = (char *)cp;
70
71 return result;
72}
73EXPORT_SYMBOL(simple_strtoull);
74
75
76
77
78
79
80
81
82
83unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
84{
85 return simple_strtoull(cp, endp, base);
86}
87EXPORT_SYMBOL(simple_strtoul);
88
89
90
91
92
93
94
95
96
97long simple_strtol(const char *cp, char **endp, unsigned int base)
98{
99 if (*cp == '-')
100 return -simple_strtoul(cp + 1, endp, base);
101
102 return simple_strtoul(cp, endp, base);
103}
104EXPORT_SYMBOL(simple_strtol);
105
106
107
108
109
110
111
112
113
114long long simple_strtoll(const char *cp, char **endp, unsigned int base)
115{
116 if (*cp == '-')
117 return -simple_strtoull(cp + 1, endp, base);
118
119 return simple_strtoull(cp, endp, base);
120}
121EXPORT_SYMBOL(simple_strtoll);
122
123static noinline_for_stack
124int skip_atoi(const char **s)
125{
126 int i = 0;
127
128 do {
129 i = i*10 + *((*s)++) - '0';
130 } while (isdigit(**s));
131
132 return i;
133}
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160static const u16 decpair[100] = {
161#define _(x) (__force u16) cpu_to_le16(((x % 10) | ((x / 10) << 8)) + 0x3030)
162 _( 0), _( 1), _( 2), _( 3), _( 4), _( 5), _( 6), _( 7), _( 8), _( 9),
163 _(10), _(11), _(12), _(13), _(14), _(15), _(16), _(17), _(18), _(19),
164 _(20), _(21), _(22), _(23), _(24), _(25), _(26), _(27), _(28), _(29),
165 _(30), _(31), _(32), _(33), _(34), _(35), _(36), _(37), _(38), _(39),
166 _(40), _(41), _(42), _(43), _(44), _(45), _(46), _(47), _(48), _(49),
167 _(50), _(51), _(52), _(53), _(54), _(55), _(56), _(57), _(58), _(59),
168 _(60), _(61), _(62), _(63), _(64), _(65), _(66), _(67), _(68), _(69),
169 _(70), _(71), _(72), _(73), _(74), _(75), _(76), _(77), _(78), _(79),
170 _(80), _(81), _(82), _(83), _(84), _(85), _(86), _(87), _(88), _(89),
171 _(90), _(91), _(92), _(93), _(94), _(95), _(96), _(97), _(98), _(99),
172#undef _
173};
174
175
176
177
178
179
180
181static noinline_for_stack
182char *put_dec_trunc8(char *buf, unsigned r)
183{
184 unsigned q;
185
186
187 if (r < 100)
188 goto out_r;
189
190
191 q = (r * (u64)0x28f5c29) >> 32;
192 *((u16 *)buf) = decpair[r - 100*q];
193 buf += 2;
194
195
196 if (q < 100)
197 goto out_q;
198
199
200 r = (q * (u64)0x28f5c29) >> 32;
201 *((u16 *)buf) = decpair[q - 100*r];
202 buf += 2;
203
204
205 if (r < 100)
206 goto out_r;
207
208
209 q = (r * 0x147b) >> 19;
210 *((u16 *)buf) = decpair[r - 100*q];
211 buf += 2;
212out_q:
213
214 r = q;
215out_r:
216
217 *((u16 *)buf) = decpair[r];
218 buf += r < 10 ? 1 : 2;
219 return buf;
220}
221
222#if BITS_PER_LONG == 64 && BITS_PER_LONG_LONG == 64
223static noinline_for_stack
224char *put_dec_full8(char *buf, unsigned r)
225{
226 unsigned q;
227
228
229 q = (r * (u64)0x28f5c29) >> 32;
230 *((u16 *)buf) = decpair[r - 100*q];
231 buf += 2;
232
233
234 r = (q * (u64)0x28f5c29) >> 32;
235 *((u16 *)buf) = decpair[q - 100*r];
236 buf += 2;
237
238
239 q = (r * 0x147b) >> 19;
240 *((u16 *)buf) = decpair[r - 100*q];
241 buf += 2;
242
243
244 *((u16 *)buf) = decpair[q];
245 buf += 2;
246 return buf;
247}
248
249static noinline_for_stack
250char *put_dec(char *buf, unsigned long long n)
251{
252 if (n >= 100*1000*1000)
253 buf = put_dec_full8(buf, do_div(n, 100*1000*1000));
254
255 if (n >= 100*1000*1000)
256 buf = put_dec_full8(buf, do_div(n, 100*1000*1000));
257
258 return put_dec_trunc8(buf, n);
259}
260
261#elif BITS_PER_LONG == 32 && BITS_PER_LONG_LONG == 64
262
263static void
264put_dec_full4(char *buf, unsigned r)
265{
266 unsigned q;
267
268
269 q = (r * 0x147b) >> 19;
270 *((u16 *)buf) = decpair[r - 100*q];
271 buf += 2;
272
273 *((u16 *)buf) = decpair[q];
274}
275
276
277
278
279
280
281
282
283static noinline_for_stack
284unsigned put_dec_helper4(char *buf, unsigned x)
285{
286 uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
287
288 put_dec_full4(buf, x - q * 10000);
289 return q;
290}
291
292
293
294
295
296
297static
298char *put_dec(char *buf, unsigned long long n)
299{
300 uint32_t d3, d2, d1, q, h;
301
302 if (n < 100*1000*1000)
303 return put_dec_trunc8(buf, n);
304
305 d1 = ((uint32_t)n >> 16);
306 h = (n >> 32);
307 d2 = (h ) & 0xffff;
308 d3 = (h >> 16);
309
310
311
312 q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
313 q = put_dec_helper4(buf, q);
314
315 q += 7671 * d3 + 9496 * d2 + 6 * d1;
316 q = put_dec_helper4(buf+4, q);
317
318 q += 4749 * d3 + 42 * d2;
319 q = put_dec_helper4(buf+8, q);
320
321 q += 281 * d3;
322 buf += 12;
323 if (q)
324 buf = put_dec_trunc8(buf, q);
325 else while (buf[-1] == '0')
326 --buf;
327
328 return buf;
329}
330
331#endif
332
333
334
335
336
337
338
339int num_to_str(char *buf, int size, unsigned long long num, unsigned int width)
340{
341
342 char tmp[sizeof(num) * 3] __aligned(2);
343 int idx, len;
344
345
346 if (num <= 9) {
347 tmp[0] = '0' + num;
348 len = 1;
349 } else {
350 len = put_dec(tmp, num) - tmp;
351 }
352
353 if (len > size || width > size)
354 return 0;
355
356 if (width > len) {
357 width = width - len;
358 for (idx = 0; idx < width; idx++)
359 buf[idx] = ' ';
360 } else {
361 width = 0;
362 }
363
364 for (idx = 0; idx < len; ++idx)
365 buf[idx + width] = tmp[len - idx - 1];
366
367 return len + width;
368}
369
370#define SIGN 1
371#define LEFT 2
372#define PLUS 4
373#define SPACE 8
374#define ZEROPAD 16
375#define SMALL 32
376#define SPECIAL 64
377
378enum format_type {
379 FORMAT_TYPE_NONE,
380 FORMAT_TYPE_WIDTH,
381 FORMAT_TYPE_PRECISION,
382 FORMAT_TYPE_CHAR,
383 FORMAT_TYPE_STR,
384 FORMAT_TYPE_PTR,
385 FORMAT_TYPE_PERCENT_CHAR,
386 FORMAT_TYPE_INVALID,
387 FORMAT_TYPE_LONG_LONG,
388 FORMAT_TYPE_ULONG,
389 FORMAT_TYPE_LONG,
390 FORMAT_TYPE_UBYTE,
391 FORMAT_TYPE_BYTE,
392 FORMAT_TYPE_USHORT,
393 FORMAT_TYPE_SHORT,
394 FORMAT_TYPE_UINT,
395 FORMAT_TYPE_INT,
396 FORMAT_TYPE_SIZE_T,
397 FORMAT_TYPE_PTRDIFF
398};
399
400struct printf_spec {
401 unsigned int type:8;
402 signed int field_width:24;
403 unsigned int flags:8;
404 unsigned int base:8;
405 signed int precision:16;
406} __packed;
407#define FIELD_WIDTH_MAX ((1 << 23) - 1)
408#define PRECISION_MAX ((1 << 15) - 1)
409
410static noinline_for_stack
411char *number(char *buf, char *end, unsigned long long num,
412 struct printf_spec spec)
413{
414
415 char tmp[3 * sizeof(num)] __aligned(2);
416 char sign;
417 char locase;
418 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
419 int i;
420 bool is_zero = num == 0LL;
421 int field_width = spec.field_width;
422 int precision = spec.precision;
423
424 BUILD_BUG_ON(sizeof(struct printf_spec) != 8);
425
426
427
428 locase = (spec.flags & SMALL);
429 if (spec.flags & LEFT)
430 spec.flags &= ~ZEROPAD;
431 sign = 0;
432 if (spec.flags & SIGN) {
433 if ((signed long long)num < 0) {
434 sign = '-';
435 num = -(signed long long)num;
436 field_width--;
437 } else if (spec.flags & PLUS) {
438 sign = '+';
439 field_width--;
440 } else if (spec.flags & SPACE) {
441 sign = ' ';
442 field_width--;
443 }
444 }
445 if (need_pfx) {
446 if (spec.base == 16)
447 field_width -= 2;
448 else if (!is_zero)
449 field_width--;
450 }
451
452
453 i = 0;
454 if (num < spec.base)
455 tmp[i++] = hex_asc_upper[num] | locase;
456 else if (spec.base != 10) {
457 int mask = spec.base - 1;
458 int shift = 3;
459
460 if (spec.base == 16)
461 shift = 4;
462 do {
463 tmp[i++] = (hex_asc_upper[((unsigned char)num) & mask] | locase);
464 num >>= shift;
465 } while (num);
466 } else {
467 i = put_dec(tmp, num) - tmp;
468 }
469
470
471 if (i > precision)
472 precision = i;
473
474 field_width -= precision;
475 if (!(spec.flags & (ZEROPAD | LEFT))) {
476 while (--field_width >= 0) {
477 if (buf < end)
478 *buf = ' ';
479 ++buf;
480 }
481 }
482
483 if (sign) {
484 if (buf < end)
485 *buf = sign;
486 ++buf;
487 }
488
489 if (need_pfx) {
490 if (spec.base == 16 || !is_zero) {
491 if (buf < end)
492 *buf = '0';
493 ++buf;
494 }
495 if (spec.base == 16) {
496 if (buf < end)
497 *buf = ('X' | locase);
498 ++buf;
499 }
500 }
501
502 if (!(spec.flags & LEFT)) {
503 char c = ' ' + (spec.flags & ZEROPAD);
504 BUILD_BUG_ON(' ' + ZEROPAD != '0');
505 while (--field_width >= 0) {
506 if (buf < end)
507 *buf = c;
508 ++buf;
509 }
510 }
511
512 while (i <= --precision) {
513 if (buf < end)
514 *buf = '0';
515 ++buf;
516 }
517
518 while (--i >= 0) {
519 if (buf < end)
520 *buf = tmp[i];
521 ++buf;
522 }
523
524 while (--field_width >= 0) {
525 if (buf < end)
526 *buf = ' ';
527 ++buf;
528 }
529
530 return buf;
531}
532
533static noinline_for_stack
534char *special_hex_number(char *buf, char *end, unsigned long long num, int size)
535{
536 struct printf_spec spec;
537
538 spec.type = FORMAT_TYPE_PTR;
539 spec.field_width = 2 + 2 * size;
540 spec.flags = SPECIAL | SMALL | ZEROPAD;
541 spec.base = 16;
542 spec.precision = -1;
543
544 return number(buf, end, num, spec);
545}
546
547static void move_right(char *buf, char *end, unsigned len, unsigned spaces)
548{
549 size_t size;
550 if (buf >= end)
551 return;
552 size = end - buf;
553 if (size <= spaces) {
554 memset(buf, ' ', size);
555 return;
556 }
557 if (len) {
558 if (len > size - spaces)
559 len = size - spaces;
560 memmove(buf + spaces, buf, len);
561 }
562 memset(buf, ' ', spaces);
563}
564
565
566
567
568
569
570
571
572
573static noinline_for_stack
574char *widen_string(char *buf, int n, char *end, struct printf_spec spec)
575{
576 unsigned spaces;
577
578 if (likely(n >= spec.field_width))
579 return buf;
580
581 spaces = spec.field_width - n;
582 if (!(spec.flags & LEFT)) {
583 move_right(buf - n, end, n, spaces);
584 return buf + spaces;
585 }
586 while (spaces--) {
587 if (buf < end)
588 *buf = ' ';
589 ++buf;
590 }
591 return buf;
592}
593
594static noinline_for_stack
595char *string(char *buf, char *end, const char *s, struct printf_spec spec)
596{
597 int len = 0;
598 size_t lim = spec.precision;
599
600 if ((unsigned long)s < PAGE_SIZE)
601 s = "(null)";
602
603 while (lim--) {
604 char c = *s++;
605 if (!c)
606 break;
607 if (buf < end)
608 *buf = c;
609 ++buf;
610 ++len;
611 }
612 return widen_string(buf, len, end, spec);
613}
614
615static noinline_for_stack
616char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,
617 const char *fmt)
618{
619 const char *array[4], *s;
620 const struct dentry *p;
621 int depth;
622 int i, n;
623
624 switch (fmt[1]) {
625 case '2': case '3': case '4':
626 depth = fmt[1] - '0';
627 break;
628 default:
629 depth = 1;
630 }
631
632 rcu_read_lock();
633 for (i = 0; i < depth; i++, d = p) {
634 p = READ_ONCE(d->d_parent);
635 array[i] = READ_ONCE(d->d_name.name);
636 if (p == d) {
637 if (i)
638 array[i] = "";
639 i++;
640 break;
641 }
642 }
643 s = array[--i];
644 for (n = 0; n != spec.precision; n++, buf++) {
645 char c = *s++;
646 if (!c) {
647 if (!i)
648 break;
649 c = '/';
650 s = array[--i];
651 }
652 if (buf < end)
653 *buf = c;
654 }
655 rcu_read_unlock();
656 return widen_string(buf, n, end, spec);
657}
658
659#ifdef CONFIG_BLOCK
660static noinline_for_stack
661char *bdev_name(char *buf, char *end, struct block_device *bdev,
662 struct printf_spec spec, const char *fmt)
663{
664 struct gendisk *hd = bdev->bd_disk;
665
666 buf = string(buf, end, hd->disk_name, spec);
667 if (bdev->bd_part->partno) {
668 if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) {
669 if (buf < end)
670 *buf = 'p';
671 buf++;
672 }
673 buf = number(buf, end, bdev->bd_part->partno, spec);
674 }
675 return buf;
676}
677#endif
678
679static noinline_for_stack
680char *symbol_string(char *buf, char *end, void *ptr,
681 struct printf_spec spec, const char *fmt)
682{
683 unsigned long value;
684#ifdef CONFIG_KALLSYMS
685 char sym[KSYM_SYMBOL_LEN];
686#endif
687
688 if (fmt[1] == 'R')
689 ptr = __builtin_extract_return_addr(ptr);
690 value = (unsigned long)ptr;
691
692#ifdef CONFIG_KALLSYMS
693 if (*fmt == 'B')
694 sprint_backtrace(sym, value);
695 else if (*fmt != 'f' && *fmt != 's')
696 sprint_symbol(sym, value);
697 else
698 sprint_symbol_no_offset(sym, value);
699
700 return string(buf, end, sym, spec);
701#else
702 return special_hex_number(buf, end, value, sizeof(void *));
703#endif
704}
705
706static const struct printf_spec default_str_spec = {
707 .field_width = -1,
708 .precision = -1,
709};
710
711static const struct printf_spec default_flag_spec = {
712 .base = 16,
713 .precision = -1,
714 .flags = SPECIAL | SMALL,
715};
716
717static const struct printf_spec default_dec_spec = {
718 .base = 10,
719 .precision = -1,
720};
721
722static noinline_for_stack
723char *resource_string(char *buf, char *end, struct resource *res,
724 struct printf_spec spec, const char *fmt)
725{
726#ifndef IO_RSRC_PRINTK_SIZE
727#define IO_RSRC_PRINTK_SIZE 6
728#endif
729
730#ifndef MEM_RSRC_PRINTK_SIZE
731#define MEM_RSRC_PRINTK_SIZE 10
732#endif
733 static const struct printf_spec io_spec = {
734 .base = 16,
735 .field_width = IO_RSRC_PRINTK_SIZE,
736 .precision = -1,
737 .flags = SPECIAL | SMALL | ZEROPAD,
738 };
739 static const struct printf_spec mem_spec = {
740 .base = 16,
741 .field_width = MEM_RSRC_PRINTK_SIZE,
742 .precision = -1,
743 .flags = SPECIAL | SMALL | ZEROPAD,
744 };
745 static const struct printf_spec bus_spec = {
746 .base = 16,
747 .field_width = 2,
748 .precision = -1,
749 .flags = SMALL | ZEROPAD,
750 };
751 static const struct printf_spec str_spec = {
752 .field_width = -1,
753 .precision = 10,
754 .flags = LEFT,
755 };
756
757
758
759#define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
760#define FLAG_BUF_SIZE (2 * sizeof(res->flags))
761#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
762#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
763 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
764 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
765
766 char *p = sym, *pend = sym + sizeof(sym);
767 int decode = (fmt[0] == 'R') ? 1 : 0;
768 const struct printf_spec *specp;
769
770 *p++ = '[';
771 if (res->flags & IORESOURCE_IO) {
772 p = string(p, pend, "io ", str_spec);
773 specp = &io_spec;
774 } else if (res->flags & IORESOURCE_MEM) {
775 p = string(p, pend, "mem ", str_spec);
776 specp = &mem_spec;
777 } else if (res->flags & IORESOURCE_IRQ) {
778 p = string(p, pend, "irq ", str_spec);
779 specp = &default_dec_spec;
780 } else if (res->flags & IORESOURCE_DMA) {
781 p = string(p, pend, "dma ", str_spec);
782 specp = &default_dec_spec;
783 } else if (res->flags & IORESOURCE_BUS) {
784 p = string(p, pend, "bus ", str_spec);
785 specp = &bus_spec;
786 } else {
787 p = string(p, pend, "??? ", str_spec);
788 specp = &mem_spec;
789 decode = 0;
790 }
791 if (decode && res->flags & IORESOURCE_UNSET) {
792 p = string(p, pend, "size ", str_spec);
793 p = number(p, pend, resource_size(res), *specp);
794 } else {
795 p = number(p, pend, res->start, *specp);
796 if (res->start != res->end) {
797 *p++ = '-';
798 p = number(p, pend, res->end, *specp);
799 }
800 }
801 if (decode) {
802 if (res->flags & IORESOURCE_MEM_64)
803 p = string(p, pend, " 64bit", str_spec);
804 if (res->flags & IORESOURCE_PREFETCH)
805 p = string(p, pend, " pref", str_spec);
806 if (res->flags & IORESOURCE_WINDOW)
807 p = string(p, pend, " window", str_spec);
808 if (res->flags & IORESOURCE_DISABLED)
809 p = string(p, pend, " disabled", str_spec);
810 } else {
811 p = string(p, pend, " flags ", str_spec);
812 p = number(p, pend, res->flags, default_flag_spec);
813 }
814 *p++ = ']';
815 *p = '\0';
816
817 return string(buf, end, sym, spec);
818}
819
820static noinline_for_stack
821char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
822 const char *fmt)
823{
824 int i, len = 1;
825
826 char separator;
827
828 if (spec.field_width == 0)
829
830 return buf;
831
832 if (ZERO_OR_NULL_PTR(addr))
833
834 return string(buf, end, NULL, spec);
835
836 switch (fmt[1]) {
837 case 'C':
838 separator = ':';
839 break;
840 case 'D':
841 separator = '-';
842 break;
843 case 'N':
844 separator = 0;
845 break;
846 default:
847 separator = ' ';
848 break;
849 }
850
851 if (spec.field_width > 0)
852 len = min_t(int, spec.field_width, 64);
853
854 for (i = 0; i < len; ++i) {
855 if (buf < end)
856 *buf = hex_asc_hi(addr[i]);
857 ++buf;
858 if (buf < end)
859 *buf = hex_asc_lo(addr[i]);
860 ++buf;
861
862 if (separator && i != len - 1) {
863 if (buf < end)
864 *buf = separator;
865 ++buf;
866 }
867 }
868
869 return buf;
870}
871
872static noinline_for_stack
873char *bitmap_string(char *buf, char *end, unsigned long *bitmap,
874 struct printf_spec spec, const char *fmt)
875{
876 const int CHUNKSZ = 32;
877 int nr_bits = max_t(int, spec.field_width, 0);
878 int i, chunksz;
879 bool first = true;
880
881
882 spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };
883
884 chunksz = nr_bits & (CHUNKSZ - 1);
885 if (chunksz == 0)
886 chunksz = CHUNKSZ;
887
888 i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ;
889 for (; i >= 0; i -= CHUNKSZ) {
890 u32 chunkmask, val;
891 int word, bit;
892
893 chunkmask = ((1ULL << chunksz) - 1);
894 word = i / BITS_PER_LONG;
895 bit = i % BITS_PER_LONG;
896 val = (bitmap[word] >> bit) & chunkmask;
897
898 if (!first) {
899 if (buf < end)
900 *buf = ',';
901 buf++;
902 }
903 first = false;
904
905 spec.field_width = DIV_ROUND_UP(chunksz, 4);
906 buf = number(buf, end, val, spec);
907
908 chunksz = CHUNKSZ;
909 }
910 return buf;
911}
912
913static noinline_for_stack
914char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,
915 struct printf_spec spec, const char *fmt)
916{
917 int nr_bits = max_t(int, spec.field_width, 0);
918
919 int cur, rbot, rtop;
920 bool first = true;
921
922 rbot = cur = find_first_bit(bitmap, nr_bits);
923 while (cur < nr_bits) {
924 rtop = cur;
925 cur = find_next_bit(bitmap, nr_bits, cur + 1);
926 if (cur < nr_bits && cur <= rtop + 1)
927 continue;
928
929 if (!first) {
930 if (buf < end)
931 *buf = ',';
932 buf++;
933 }
934 first = false;
935
936 buf = number(buf, end, rbot, default_dec_spec);
937 if (rbot < rtop) {
938 if (buf < end)
939 *buf = '-';
940 buf++;
941
942 buf = number(buf, end, rtop, default_dec_spec);
943 }
944
945 rbot = cur;
946 }
947 return buf;
948}
949
950static noinline_for_stack
951char *mac_address_string(char *buf, char *end, u8 *addr,
952 struct printf_spec spec, const char *fmt)
953{
954 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
955 char *p = mac_addr;
956 int i;
957 char separator;
958 bool reversed = false;
959
960 switch (fmt[1]) {
961 case 'F':
962 separator = '-';
963 break;
964
965 case 'R':
966 reversed = true;
967
968
969 default:
970 separator = ':';
971 break;
972 }
973
974 for (i = 0; i < 6; i++) {
975 if (reversed)
976 p = hex_byte_pack(p, addr[5 - i]);
977 else
978 p = hex_byte_pack(p, addr[i]);
979
980 if (fmt[0] == 'M' && i != 5)
981 *p++ = separator;
982 }
983 *p = '\0';
984
985 return string(buf, end, mac_addr, spec);
986}
987
988static noinline_for_stack
989char *ip4_string(char *p, const u8 *addr, const char *fmt)
990{
991 int i;
992 bool leading_zeros = (fmt[0] == 'i');
993 int index;
994 int step;
995
996 switch (fmt[2]) {
997 case 'h':
998#ifdef __BIG_ENDIAN
999 index = 0;
1000 step = 1;
1001#else
1002 index = 3;
1003 step = -1;
1004#endif
1005 break;
1006 case 'l':
1007 index = 3;
1008 step = -1;
1009 break;
1010 case 'n':
1011 case 'b':
1012 default:
1013 index = 0;
1014 step = 1;
1015 break;
1016 }
1017 for (i = 0; i < 4; i++) {
1018 char temp[4] __aligned(2);
1019 int digits = put_dec_trunc8(temp, addr[index]) - temp;
1020 if (leading_zeros) {
1021 if (digits < 3)
1022 *p++ = '0';
1023 if (digits < 2)
1024 *p++ = '0';
1025 }
1026
1027 while (digits--)
1028 *p++ = temp[digits];
1029 if (i < 3)
1030 *p++ = '.';
1031 index += step;
1032 }
1033 *p = '\0';
1034
1035 return p;
1036}
1037
1038static noinline_for_stack
1039char *ip6_compressed_string(char *p, const char *addr)
1040{
1041 int i, j, range;
1042 unsigned char zerolength[8];
1043 int longest = 1;
1044 int colonpos = -1;
1045 u16 word;
1046 u8 hi, lo;
1047 bool needcolon = false;
1048 bool useIPv4;
1049 struct in6_addr in6;
1050
1051 memcpy(&in6, addr, sizeof(struct in6_addr));
1052
1053 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
1054
1055 memset(zerolength, 0, sizeof(zerolength));
1056
1057 if (useIPv4)
1058 range = 6;
1059 else
1060 range = 8;
1061
1062
1063 for (i = 0; i < range; i++) {
1064 for (j = i; j < range; j++) {
1065 if (in6.s6_addr16[j] != 0)
1066 break;
1067 zerolength[i]++;
1068 }
1069 }
1070 for (i = 0; i < range; i++) {
1071 if (zerolength[i] > longest) {
1072 longest = zerolength[i];
1073 colonpos = i;
1074 }
1075 }
1076 if (longest == 1)
1077 colonpos = -1;
1078
1079
1080 for (i = 0; i < range; i++) {
1081 if (i == colonpos) {
1082 if (needcolon || i == 0)
1083 *p++ = ':';
1084 *p++ = ':';
1085 needcolon = false;
1086 i += longest - 1;
1087 continue;
1088 }
1089 if (needcolon) {
1090 *p++ = ':';
1091 needcolon = false;
1092 }
1093
1094 word = ntohs(in6.s6_addr16[i]);
1095 hi = word >> 8;
1096 lo = word & 0xff;
1097 if (hi) {
1098 if (hi > 0x0f)
1099 p = hex_byte_pack(p, hi);
1100 else
1101 *p++ = hex_asc_lo(hi);
1102 p = hex_byte_pack(p, lo);
1103 }
1104 else if (lo > 0x0f)
1105 p = hex_byte_pack(p, lo);
1106 else
1107 *p++ = hex_asc_lo(lo);
1108 needcolon = true;
1109 }
1110
1111 if (useIPv4) {
1112 if (needcolon)
1113 *p++ = ':';
1114 p = ip4_string(p, &in6.s6_addr[12], "I4");
1115 }
1116 *p = '\0';
1117
1118 return p;
1119}
1120
1121static noinline_for_stack
1122char *ip6_string(char *p, const char *addr, const char *fmt)
1123{
1124 int i;
1125
1126 for (i = 0; i < 8; i++) {
1127 p = hex_byte_pack(p, *addr++);
1128 p = hex_byte_pack(p, *addr++);
1129 if (fmt[0] == 'I' && i != 7)
1130 *p++ = ':';
1131 }
1132 *p = '\0';
1133
1134 return p;
1135}
1136
1137static noinline_for_stack
1138char *ip6_addr_string(char *buf, char *end, const u8 *addr,
1139 struct printf_spec spec, const char *fmt)
1140{
1141 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
1142
1143 if (fmt[0] == 'I' && fmt[2] == 'c')
1144 ip6_compressed_string(ip6_addr, addr);
1145 else
1146 ip6_string(ip6_addr, addr, fmt);
1147
1148 return string(buf, end, ip6_addr, spec);
1149}
1150
1151static noinline_for_stack
1152char *ip4_addr_string(char *buf, char *end, const u8 *addr,
1153 struct printf_spec spec, const char *fmt)
1154{
1155 char ip4_addr[sizeof("255.255.255.255")];
1156
1157 ip4_string(ip4_addr, addr, fmt);
1158
1159 return string(buf, end, ip4_addr, spec);
1160}
1161
1162static noinline_for_stack
1163char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
1164 struct printf_spec spec, const char *fmt)
1165{
1166 bool have_p = false, have_s = false, have_f = false, have_c = false;
1167 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
1168 sizeof(":12345") + sizeof("/123456789") +
1169 sizeof("%1234567890")];
1170 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);
1171 const u8 *addr = (const u8 *) &sa->sin6_addr;
1172 char fmt6[2] = { fmt[0], '6' };
1173 u8 off = 0;
1174
1175 fmt++;
1176 while (isalpha(*++fmt)) {
1177 switch (*fmt) {
1178 case 'p':
1179 have_p = true;
1180 break;
1181 case 'f':
1182 have_f = true;
1183 break;
1184 case 's':
1185 have_s = true;
1186 break;
1187 case 'c':
1188 have_c = true;
1189 break;
1190 }
1191 }
1192
1193 if (have_p || have_s || have_f) {
1194 *p = '[';
1195 off = 1;
1196 }
1197
1198 if (fmt6[0] == 'I' && have_c)
1199 p = ip6_compressed_string(ip6_addr + off, addr);
1200 else
1201 p = ip6_string(ip6_addr + off, addr, fmt6);
1202
1203 if (have_p || have_s || have_f)
1204 *p++ = ']';
1205
1206 if (have_p) {
1207 *p++ = ':';
1208 p = number(p, pend, ntohs(sa->sin6_port), spec);
1209 }
1210 if (have_f) {
1211 *p++ = '/';
1212 p = number(p, pend, ntohl(sa->sin6_flowinfo &
1213 IPV6_FLOWINFO_MASK), spec);
1214 }
1215 if (have_s) {
1216 *p++ = '%';
1217 p = number(p, pend, sa->sin6_scope_id, spec);
1218 }
1219 *p = '\0';
1220
1221 return string(buf, end, ip6_addr, spec);
1222}
1223
1224static noinline_for_stack
1225char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
1226 struct printf_spec spec, const char *fmt)
1227{
1228 bool have_p = false;
1229 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];
1230 char *pend = ip4_addr + sizeof(ip4_addr);
1231 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
1232 char fmt4[3] = { fmt[0], '4', 0 };
1233
1234 fmt++;
1235 while (isalpha(*++fmt)) {
1236 switch (*fmt) {
1237 case 'p':
1238 have_p = true;
1239 break;
1240 case 'h':
1241 case 'l':
1242 case 'n':
1243 case 'b':
1244 fmt4[2] = *fmt;
1245 break;
1246 }
1247 }
1248
1249 p = ip4_string(ip4_addr, addr, fmt4);
1250 if (have_p) {
1251 *p++ = ':';
1252 p = number(p, pend, ntohs(sa->sin_port), spec);
1253 }
1254 *p = '\0';
1255
1256 return string(buf, end, ip4_addr, spec);
1257}
1258
1259static noinline_for_stack
1260char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
1261 const char *fmt)
1262{
1263 bool found = true;
1264 int count = 1;
1265 unsigned int flags = 0;
1266 int len;
1267
1268 if (spec.field_width == 0)
1269 return buf;
1270
1271 if (ZERO_OR_NULL_PTR(addr))
1272 return string(buf, end, NULL, spec);
1273
1274
1275 do {
1276 switch (fmt[count++]) {
1277 case 'a':
1278 flags |= ESCAPE_ANY;
1279 break;
1280 case 'c':
1281 flags |= ESCAPE_SPECIAL;
1282 break;
1283 case 'h':
1284 flags |= ESCAPE_HEX;
1285 break;
1286 case 'n':
1287 flags |= ESCAPE_NULL;
1288 break;
1289 case 'o':
1290 flags |= ESCAPE_OCTAL;
1291 break;
1292 case 'p':
1293 flags |= ESCAPE_NP;
1294 break;
1295 case 's':
1296 flags |= ESCAPE_SPACE;
1297 break;
1298 default:
1299 found = false;
1300 break;
1301 }
1302 } while (found);
1303
1304 if (!flags)
1305 flags = ESCAPE_ANY_NP;
1306
1307 len = spec.field_width < 0 ? 1 : spec.field_width;
1308
1309
1310
1311
1312
1313
1314 buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL);
1315
1316 return buf;
1317}
1318
1319static noinline_for_stack
1320char *uuid_string(char *buf, char *end, const u8 *addr,
1321 struct printf_spec spec, const char *fmt)
1322{
1323 char uuid[UUID_STRING_LEN + 1];
1324 char *p = uuid;
1325 int i;
1326 const u8 *index = uuid_index;
1327 bool uc = false;
1328
1329 switch (*(++fmt)) {
1330 case 'L':
1331 uc = true;
1332 case 'l':
1333 index = guid_index;
1334 break;
1335 case 'B':
1336 uc = true;
1337 break;
1338 }
1339
1340 for (i = 0; i < 16; i++) {
1341 if (uc)
1342 p = hex_byte_pack_upper(p, addr[index[i]]);
1343 else
1344 p = hex_byte_pack(p, addr[index[i]]);
1345 switch (i) {
1346 case 3:
1347 case 5:
1348 case 7:
1349 case 9:
1350 *p++ = '-';
1351 break;
1352 }
1353 }
1354
1355 *p = 0;
1356
1357 return string(buf, end, uuid, spec);
1358}
1359
1360static noinline_for_stack
1361char *pointer_string(char *buf, char *end, const void *ptr,
1362 struct printf_spec spec)
1363{
1364 spec.base = 16;
1365 spec.flags |= SMALL;
1366 if (spec.field_width == -1) {
1367 spec.field_width = 2 * sizeof(ptr);
1368 spec.flags |= ZEROPAD;
1369 }
1370
1371 return number(buf, end, (unsigned long int)ptr, spec);
1372}
1373
1374int kptr_restrict __read_mostly;
1375
1376static noinline_for_stack
1377char *restricted_pointer(char *buf, char *end, const void *ptr,
1378 struct printf_spec spec)
1379{
1380 switch (kptr_restrict) {
1381 case 0:
1382
1383 break;
1384 case 1: {
1385 const struct cred *cred;
1386
1387
1388
1389
1390
1391 if (in_irq() || in_serving_softirq() || in_nmi()) {
1392 if (spec.field_width == -1)
1393 spec.field_width = 2 * sizeof(ptr);
1394 return string(buf, end, "pK-error", spec);
1395 }
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406 cred = current_cred();
1407 if (!has_capability_noaudit(current, CAP_SYSLOG) ||
1408 !uid_eq(cred->euid, cred->uid) ||
1409 !gid_eq(cred->egid, cred->gid))
1410 ptr = NULL;
1411 break;
1412 }
1413 case 2:
1414 default:
1415
1416 ptr = NULL;
1417 break;
1418 }
1419
1420 return pointer_string(buf, end, ptr, spec);
1421}
1422
1423static noinline_for_stack
1424char *netdev_bits(char *buf, char *end, const void *addr, const char *fmt)
1425{
1426 unsigned long long num;
1427 int size;
1428
1429 switch (fmt[1]) {
1430 case 'F':
1431 num = *(const netdev_features_t *)addr;
1432 size = sizeof(netdev_features_t);
1433 break;
1434 default:
1435 num = (unsigned long)addr;
1436 size = sizeof(unsigned long);
1437 break;
1438 }
1439
1440 return special_hex_number(buf, end, num, size);
1441}
1442
1443static noinline_for_stack
1444char *address_val(char *buf, char *end, const void *addr, const char *fmt)
1445{
1446 unsigned long long num;
1447 int size;
1448
1449 switch (fmt[1]) {
1450 case 'd':
1451 num = *(const dma_addr_t *)addr;
1452 size = sizeof(dma_addr_t);
1453 break;
1454 case 'p':
1455 default:
1456 num = *(const phys_addr_t *)addr;
1457 size = sizeof(phys_addr_t);
1458 break;
1459 }
1460
1461 return special_hex_number(buf, end, num, size);
1462}
1463
1464static noinline_for_stack
1465char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec,
1466 const char *fmt)
1467{
1468 if (!IS_ENABLED(CONFIG_HAVE_CLK) || !clk)
1469 return string(buf, end, NULL, spec);
1470
1471 switch (fmt[1]) {
1472 case 'n':
1473 default:
1474#ifdef CONFIG_COMMON_CLK
1475 return string(buf, end, __clk_get_name(clk), spec);
1476#else
1477 return special_hex_number(buf, end, (unsigned long)clk, sizeof(unsigned long));
1478#endif
1479 }
1480}
1481
1482static
1483char *format_flags(char *buf, char *end, unsigned long flags,
1484 const struct trace_print_flags *names)
1485{
1486 unsigned long mask;
1487
1488 for ( ; flags && names->name; names++) {
1489 mask = names->mask;
1490 if ((flags & mask) != mask)
1491 continue;
1492
1493 buf = string(buf, end, names->name, default_str_spec);
1494
1495 flags &= ~mask;
1496 if (flags) {
1497 if (buf < end)
1498 *buf = '|';
1499 buf++;
1500 }
1501 }
1502
1503 if (flags)
1504 buf = number(buf, end, flags, default_flag_spec);
1505
1506 return buf;
1507}
1508
1509static noinline_for_stack
1510char *flags_string(char *buf, char *end, void *flags_ptr, const char *fmt)
1511{
1512 unsigned long flags;
1513 const struct trace_print_flags *names;
1514
1515 switch (fmt[1]) {
1516 case 'p':
1517 flags = *(unsigned long *)flags_ptr;
1518
1519 flags &= (1UL << NR_PAGEFLAGS) - 1;
1520 names = pageflag_names;
1521 break;
1522 case 'v':
1523 flags = *(unsigned long *)flags_ptr;
1524 names = vmaflag_names;
1525 break;
1526 case 'g':
1527 flags = *(gfp_t *)flags_ptr;
1528 names = gfpflag_names;
1529 break;
1530 default:
1531 WARN_ONCE(1, "Unsupported flags modifier: %c\n", fmt[1]);
1532 return buf;
1533 }
1534
1535 return format_flags(buf, end, flags, names);
1536}
1537
1538static const char *device_node_name_for_depth(const struct device_node *np, int depth)
1539{
1540 for ( ; np && depth; depth--)
1541 np = np->parent;
1542
1543 return kbasename(np->full_name);
1544}
1545
1546static noinline_for_stack
1547char *device_node_gen_full_name(const struct device_node *np, char *buf, char *end)
1548{
1549 int depth;
1550 const struct device_node *parent = np->parent;
1551
1552
1553 if (!parent)
1554 return string(buf, end, "/", default_str_spec);
1555
1556 for (depth = 0; parent->parent; depth++)
1557 parent = parent->parent;
1558
1559 for ( ; depth >= 0; depth--) {
1560 buf = string(buf, end, "/", default_str_spec);
1561 buf = string(buf, end, device_node_name_for_depth(np, depth),
1562 default_str_spec);
1563 }
1564 return buf;
1565}
1566
1567static noinline_for_stack
1568char *device_node_string(char *buf, char *end, struct device_node *dn,
1569 struct printf_spec spec, const char *fmt)
1570{
1571 char tbuf[sizeof("xxxx") + 1];
1572 const char *p;
1573 int ret;
1574 char *buf_start = buf;
1575 struct property *prop;
1576 bool has_mult, pass;
1577 static const struct printf_spec num_spec = {
1578 .flags = SMALL,
1579 .field_width = -1,
1580 .precision = -1,
1581 .base = 10,
1582 };
1583
1584 struct printf_spec str_spec = spec;
1585 str_spec.field_width = -1;
1586
1587 if (!IS_ENABLED(CONFIG_OF))
1588 return string(buf, end, "(!OF)", spec);
1589
1590 if ((unsigned long)dn < PAGE_SIZE)
1591 return string(buf, end, "(null)", spec);
1592
1593
1594 fmt++;
1595 if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0)
1596 fmt = "f";
1597
1598 for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) {
1599 if (pass) {
1600 if (buf < end)
1601 *buf = ':';
1602 buf++;
1603 }
1604
1605 switch (*fmt) {
1606 case 'f':
1607 buf = device_node_gen_full_name(dn, buf, end);
1608 break;
1609 case 'n':
1610 buf = string(buf, end, dn->name, str_spec);
1611 break;
1612 case 'p':
1613 buf = number(buf, end, (unsigned int)dn->phandle, num_spec);
1614 break;
1615 case 'P':
1616 p = kbasename(of_node_full_name(dn));
1617 if (!p[1])
1618 p = "/";
1619 buf = string(buf, end, p, str_spec);
1620 break;
1621 case 'F':
1622 tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';
1623 tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-';
1624 tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-';
1625 tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-';
1626 tbuf[4] = 0;
1627 buf = string(buf, end, tbuf, str_spec);
1628 break;
1629 case 'c':
1630 ret = of_property_read_string(dn, "compatible", &p);
1631 if (!ret)
1632 buf = string(buf, end, p, str_spec);
1633 break;
1634 case 'C':
1635 has_mult = false;
1636 of_property_for_each_string(dn, "compatible", prop, p) {
1637 if (has_mult)
1638 buf = string(buf, end, ",", str_spec);
1639 buf = string(buf, end, "\"", str_spec);
1640 buf = string(buf, end, p, str_spec);
1641 buf = string(buf, end, "\"", str_spec);
1642
1643 has_mult = true;
1644 }
1645 break;
1646 default:
1647 break;
1648 }
1649 }
1650
1651 return widen_string(buf, buf - buf_start, end, spec);
1652}
1653
1654
1655static int debug_boot_weak_hash __ro_after_init;
1656
1657static int __init debug_boot_weak_hash_enable(char *str)
1658{
1659 debug_boot_weak_hash = 1;
1660 pr_info("debug_boot_weak_hash enabled\n");
1661 return 0;
1662}
1663early_param("debug_boot_weak_hash", debug_boot_weak_hash_enable);
1664
1665static DEFINE_STATIC_KEY_TRUE(not_filled_random_ptr_key);
1666static siphash_key_t ptr_key __read_mostly;
1667
1668static void enable_ptr_key_workfn(struct work_struct *work)
1669{
1670 get_random_bytes(&ptr_key, sizeof(ptr_key));
1671
1672 static_branch_disable(¬_filled_random_ptr_key);
1673}
1674
1675static DECLARE_WORK(enable_ptr_key_work, enable_ptr_key_workfn);
1676
1677static void fill_random_ptr_key(struct random_ready_callback *unused)
1678{
1679
1680 queue_work(system_unbound_wq, &enable_ptr_key_work);
1681}
1682
1683static struct random_ready_callback random_ready = {
1684 .func = fill_random_ptr_key
1685};
1686
1687static int __init initialize_ptr_random(void)
1688{
1689 int key_size = sizeof(ptr_key);
1690 int ret;
1691
1692
1693 if (get_random_bytes_arch(&ptr_key, key_size) == key_size) {
1694 static_branch_disable(¬_filled_random_ptr_key);
1695 return 0;
1696 }
1697
1698 ret = add_random_ready_callback(&random_ready);
1699 if (!ret) {
1700 return 0;
1701 } else if (ret == -EALREADY) {
1702
1703 enable_ptr_key_workfn(&enable_ptr_key_work);
1704 return 0;
1705 }
1706
1707 return ret;
1708}
1709early_initcall(initialize_ptr_random);
1710
1711
1712static char *ptr_to_id(char *buf, char *end, void *ptr, struct printf_spec spec)
1713{
1714 const char *str = sizeof(ptr) == 8 ? "(____ptrval____)" : "(ptrval)";
1715 unsigned long hashval;
1716
1717
1718 if (unlikely(debug_boot_weak_hash)) {
1719 hashval = hash_long((unsigned long)ptr, 32);
1720 return pointer_string(buf, end, (const void *)hashval, spec);
1721 }
1722
1723 if (static_branch_unlikely(¬_filled_random_ptr_key)) {
1724 spec.field_width = 2 * sizeof(ptr);
1725
1726 return string(buf, end, str, spec);
1727 }
1728
1729#ifdef CONFIG_64BIT
1730 hashval = (unsigned long)siphash_1u64((u64)ptr, &ptr_key);
1731
1732
1733
1734
1735 hashval = hashval & 0xffffffff;
1736#else
1737 hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key);
1738#endif
1739 return pointer_string(buf, end, (const void *)hashval, spec);
1740}
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855static noinline_for_stack
1856char *pointer(const char *fmt, char *buf, char *end, void *ptr,
1857 struct printf_spec spec)
1858{
1859 const int default_width = 2 * sizeof(void *);
1860
1861 if (!ptr && *fmt != 'K' && *fmt != 'x') {
1862
1863
1864
1865
1866 if (spec.field_width == -1)
1867 spec.field_width = default_width;
1868 return string(buf, end, "(null)", spec);
1869 }
1870
1871 switch (*fmt) {
1872 case 'F':
1873 case 'f':
1874 case 'S':
1875 case 's':
1876 ptr = dereference_symbol_descriptor(ptr);
1877
1878 case 'B':
1879 return symbol_string(buf, end, ptr, spec, fmt);
1880 case 'R':
1881 case 'r':
1882 return resource_string(buf, end, ptr, spec, fmt);
1883 case 'h':
1884 return hex_string(buf, end, ptr, spec, fmt);
1885 case 'b':
1886 switch (fmt[1]) {
1887 case 'l':
1888 return bitmap_list_string(buf, end, ptr, spec, fmt);
1889 default:
1890 return bitmap_string(buf, end, ptr, spec, fmt);
1891 }
1892 case 'M':
1893 case 'm':
1894
1895
1896 return mac_address_string(buf, end, ptr, spec, fmt);
1897 case 'I':
1898
1899
1900
1901
1902 case 'i':
1903
1904
1905
1906 switch (fmt[1]) {
1907 case '6':
1908 return ip6_addr_string(buf, end, ptr, spec, fmt);
1909 case '4':
1910 return ip4_addr_string(buf, end, ptr, spec, fmt);
1911 case 'S': {
1912 const union {
1913 struct sockaddr raw;
1914 struct sockaddr_in v4;
1915 struct sockaddr_in6 v6;
1916 } *sa = ptr;
1917
1918 switch (sa->raw.sa_family) {
1919 case AF_INET:
1920 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
1921 case AF_INET6:
1922 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
1923 default:
1924 return string(buf, end, "(invalid address)", spec);
1925 }}
1926 }
1927 break;
1928 case 'E':
1929 return escaped_string(buf, end, ptr, spec, fmt);
1930 case 'U':
1931 return uuid_string(buf, end, ptr, spec, fmt);
1932 case 'V':
1933 {
1934 va_list va;
1935
1936 va_copy(va, *((struct va_format *)ptr)->va);
1937 buf += vsnprintf(buf, end > buf ? end - buf : 0,
1938 ((struct va_format *)ptr)->fmt, va);
1939 va_end(va);
1940 return buf;
1941 }
1942 case 'K':
1943 if (!kptr_restrict)
1944 break;
1945 return restricted_pointer(buf, end, ptr, spec);
1946 case 'N':
1947 return netdev_bits(buf, end, ptr, fmt);
1948 case 'a':
1949 return address_val(buf, end, ptr, fmt);
1950 case 'd':
1951 return dentry_name(buf, end, ptr, spec, fmt);
1952 case 'C':
1953 return clock(buf, end, ptr, spec, fmt);
1954 case 'D':
1955 return dentry_name(buf, end,
1956 ((const struct file *)ptr)->f_path.dentry,
1957 spec, fmt);
1958#ifdef CONFIG_BLOCK
1959 case 'g':
1960 return bdev_name(buf, end, ptr, spec, fmt);
1961#endif
1962
1963 case 'G':
1964 return flags_string(buf, end, ptr, fmt);
1965 case 'O':
1966 switch (fmt[1]) {
1967 case 'F':
1968 return device_node_string(buf, end, ptr, spec, fmt + 1);
1969 }
1970 break;
1971 case 'x':
1972 return pointer_string(buf, end, ptr, spec);
1973 }
1974
1975
1976 return ptr_to_id(buf, end, ptr, spec);
1977}
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000static noinline_for_stack
2001int format_decode(const char *fmt, struct printf_spec *spec)
2002{
2003 const char *start = fmt;
2004 char qualifier;
2005
2006
2007 if (spec->type == FORMAT_TYPE_WIDTH) {
2008 if (spec->field_width < 0) {
2009 spec->field_width = -spec->field_width;
2010 spec->flags |= LEFT;
2011 }
2012 spec->type = FORMAT_TYPE_NONE;
2013 goto precision;
2014 }
2015
2016
2017 if (spec->type == FORMAT_TYPE_PRECISION) {
2018 if (spec->precision < 0)
2019 spec->precision = 0;
2020
2021 spec->type = FORMAT_TYPE_NONE;
2022 goto qualifier;
2023 }
2024
2025
2026 spec->type = FORMAT_TYPE_NONE;
2027
2028 for (; *fmt ; ++fmt) {
2029 if (*fmt == '%')
2030 break;
2031 }
2032
2033
2034 if (fmt != start || !*fmt)
2035 return fmt - start;
2036
2037
2038 spec->flags = 0;
2039
2040 while (1) {
2041 bool found = true;
2042
2043 ++fmt;
2044
2045 switch (*fmt) {
2046 case '-': spec->flags |= LEFT; break;
2047 case '+': spec->flags |= PLUS; break;
2048 case ' ': spec->flags |= SPACE; break;
2049 case '#': spec->flags |= SPECIAL; break;
2050 case '0': spec->flags |= ZEROPAD; break;
2051 default: found = false;
2052 }
2053
2054 if (!found)
2055 break;
2056 }
2057
2058
2059 spec->field_width = -1;
2060
2061 if (isdigit(*fmt))
2062 spec->field_width = skip_atoi(&fmt);
2063 else if (*fmt == '*') {
2064
2065 spec->type = FORMAT_TYPE_WIDTH;
2066 return ++fmt - start;
2067 }
2068
2069precision:
2070
2071 spec->precision = -1;
2072 if (*fmt == '.') {
2073 ++fmt;
2074 if (isdigit(*fmt)) {
2075 spec->precision = skip_atoi(&fmt);
2076 if (spec->precision < 0)
2077 spec->precision = 0;
2078 } else if (*fmt == '*') {
2079
2080 spec->type = FORMAT_TYPE_PRECISION;
2081 return ++fmt - start;
2082 }
2083 }
2084
2085qualifier:
2086
2087 qualifier = 0;
2088 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2089 *fmt == 'z' || *fmt == 't') {
2090 qualifier = *fmt++;
2091 if (unlikely(qualifier == *fmt)) {
2092 if (qualifier == 'l') {
2093 qualifier = 'L';
2094 ++fmt;
2095 } else if (qualifier == 'h') {
2096 qualifier = 'H';
2097 ++fmt;
2098 }
2099 }
2100 }
2101
2102
2103 spec->base = 10;
2104 switch (*fmt) {
2105 case 'c':
2106 spec->type = FORMAT_TYPE_CHAR;
2107 return ++fmt - start;
2108
2109 case 's':
2110 spec->type = FORMAT_TYPE_STR;
2111 return ++fmt - start;
2112
2113 case 'p':
2114 spec->type = FORMAT_TYPE_PTR;
2115 return ++fmt - start;
2116
2117 case '%':
2118 spec->type = FORMAT_TYPE_PERCENT_CHAR;
2119 return ++fmt - start;
2120
2121
2122 case 'o':
2123 spec->base = 8;
2124 break;
2125
2126 case 'x':
2127 spec->flags |= SMALL;
2128
2129
2130 case 'X':
2131 spec->base = 16;
2132 break;
2133
2134 case 'd':
2135 case 'i':
2136 spec->flags |= SIGN;
2137 case 'u':
2138 break;
2139
2140 case 'n':
2141
2142
2143
2144
2145
2146
2147
2148 default:
2149 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt);
2150 spec->type = FORMAT_TYPE_INVALID;
2151 return fmt - start;
2152 }
2153
2154 if (qualifier == 'L')
2155 spec->type = FORMAT_TYPE_LONG_LONG;
2156 else if (qualifier == 'l') {
2157 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG);
2158 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN);
2159 } else if (qualifier == 'z') {
2160 spec->type = FORMAT_TYPE_SIZE_T;
2161 } else if (qualifier == 't') {
2162 spec->type = FORMAT_TYPE_PTRDIFF;
2163 } else if (qualifier == 'H') {
2164 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE);
2165 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN);
2166 } else if (qualifier == 'h') {
2167 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT);
2168 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN);
2169 } else {
2170 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT);
2171 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN);
2172 }
2173
2174 return ++fmt - start;
2175}
2176
2177static void
2178set_field_width(struct printf_spec *spec, int width)
2179{
2180 spec->field_width = width;
2181 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) {
2182 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX);
2183 }
2184}
2185
2186static void
2187set_precision(struct printf_spec *spec, int prec)
2188{
2189 spec->precision = prec;
2190 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) {
2191 spec->precision = clamp(prec, 0, PRECISION_MAX);
2192 }
2193}
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
2224{
2225 unsigned long long num;
2226 char *str, *end;
2227 struct printf_spec spec = {0};
2228
2229
2230
2231 if (WARN_ON_ONCE(size > INT_MAX))
2232 return 0;
2233
2234 str = buf;
2235 end = buf + size;
2236
2237
2238 if (end < buf) {
2239 end = ((void *)-1);
2240 size = end - buf;
2241 }
2242
2243 while (*fmt) {
2244 const char *old_fmt = fmt;
2245 int read = format_decode(fmt, &spec);
2246
2247 fmt += read;
2248
2249 switch (spec.type) {
2250 case FORMAT_TYPE_NONE: {
2251 int copy = read;
2252 if (str < end) {
2253 if (copy > end - str)
2254 copy = end - str;
2255 memcpy(str, old_fmt, copy);
2256 }
2257 str += read;
2258 break;
2259 }
2260
2261 case FORMAT_TYPE_WIDTH:
2262 set_field_width(&spec, va_arg(args, int));
2263 break;
2264
2265 case FORMAT_TYPE_PRECISION:
2266 set_precision(&spec, va_arg(args, int));
2267 break;
2268
2269 case FORMAT_TYPE_CHAR: {
2270 char c;
2271
2272 if (!(spec.flags & LEFT)) {
2273 while (--spec.field_width > 0) {
2274 if (str < end)
2275 *str = ' ';
2276 ++str;
2277
2278 }
2279 }
2280 c = (unsigned char) va_arg(args, int);
2281 if (str < end)
2282 *str = c;
2283 ++str;
2284 while (--spec.field_width > 0) {
2285 if (str < end)
2286 *str = ' ';
2287 ++str;
2288 }
2289 break;
2290 }
2291
2292 case FORMAT_TYPE_STR:
2293 str = string(str, end, va_arg(args, char *), spec);
2294 break;
2295
2296 case FORMAT_TYPE_PTR:
2297 str = pointer(fmt, str, end, va_arg(args, void *),
2298 spec);
2299 while (isalnum(*fmt))
2300 fmt++;
2301 break;
2302
2303 case FORMAT_TYPE_PERCENT_CHAR:
2304 if (str < end)
2305 *str = '%';
2306 ++str;
2307 break;
2308
2309 case FORMAT_TYPE_INVALID:
2310
2311
2312
2313
2314
2315
2316
2317
2318 goto out;
2319
2320 default:
2321 switch (spec.type) {
2322 case FORMAT_TYPE_LONG_LONG:
2323 num = va_arg(args, long long);
2324 break;
2325 case FORMAT_TYPE_ULONG:
2326 num = va_arg(args, unsigned long);
2327 break;
2328 case FORMAT_TYPE_LONG:
2329 num = va_arg(args, long);
2330 break;
2331 case FORMAT_TYPE_SIZE_T:
2332 if (spec.flags & SIGN)
2333 num = va_arg(args, ssize_t);
2334 else
2335 num = va_arg(args, size_t);
2336 break;
2337 case FORMAT_TYPE_PTRDIFF:
2338 num = va_arg(args, ptrdiff_t);
2339 break;
2340 case FORMAT_TYPE_UBYTE:
2341 num = (unsigned char) va_arg(args, int);
2342 break;
2343 case FORMAT_TYPE_BYTE:
2344 num = (signed char) va_arg(args, int);
2345 break;
2346 case FORMAT_TYPE_USHORT:
2347 num = (unsigned short) va_arg(args, int);
2348 break;
2349 case FORMAT_TYPE_SHORT:
2350 num = (short) va_arg(args, int);
2351 break;
2352 case FORMAT_TYPE_INT:
2353 num = (int) va_arg(args, int);
2354 break;
2355 default:
2356 num = va_arg(args, unsigned int);
2357 }
2358
2359 str = number(str, end, num, spec);
2360 }
2361 }
2362
2363out:
2364 if (size > 0) {
2365 if (str < end)
2366 *str = '\0';
2367 else
2368 end[-1] = '\0';
2369 }
2370
2371
2372 return str-buf;
2373
2374}
2375EXPORT_SYMBOL(vsnprintf);
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
2393{
2394 int i;
2395
2396 i = vsnprintf(buf, size, fmt, args);
2397
2398 if (likely(i < size))
2399 return i;
2400 if (size != 0)
2401 return size - 1;
2402 return 0;
2403}
2404EXPORT_SYMBOL(vscnprintf);
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420int snprintf(char *buf, size_t size, const char *fmt, ...)
2421{
2422 va_list args;
2423 int i;
2424
2425 va_start(args, fmt);
2426 i = vsnprintf(buf, size, fmt, args);
2427 va_end(args);
2428
2429 return i;
2430}
2431EXPORT_SYMBOL(snprintf);
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444int scnprintf(char *buf, size_t size, const char *fmt, ...)
2445{
2446 va_list args;
2447 int i;
2448
2449 va_start(args, fmt);
2450 i = vscnprintf(buf, size, fmt, args);
2451 va_end(args);
2452
2453 return i;
2454}
2455EXPORT_SYMBOL(scnprintf);
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471int vsprintf(char *buf, const char *fmt, va_list args)
2472{
2473 return vsnprintf(buf, INT_MAX, fmt, args);
2474}
2475EXPORT_SYMBOL(vsprintf);
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489int sprintf(char *buf, const char *fmt, ...)
2490{
2491 va_list args;
2492 int i;
2493
2494 va_start(args, fmt);
2495 i = vsnprintf(buf, INT_MAX, fmt, args);
2496 va_end(args);
2497
2498 return i;
2499}
2500EXPORT_SYMBOL(sprintf);
2501
2502#ifdef CONFIG_BINARY_PRINTF
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
2527{
2528 struct printf_spec spec = {0};
2529 char *str, *end;
2530 int width;
2531
2532 str = (char *)bin_buf;
2533 end = (char *)(bin_buf + size);
2534
2535#define save_arg(type) \
2536({ \
2537 unsigned long long value; \
2538 if (sizeof(type) == 8) { \
2539 unsigned long long val8; \
2540 str = PTR_ALIGN(str, sizeof(u32)); \
2541 val8 = va_arg(args, unsigned long long); \
2542 if (str + sizeof(type) <= end) { \
2543 *(u32 *)str = *(u32 *)&val8; \
2544 *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \
2545 } \
2546 value = val8; \
2547 } else { \
2548 unsigned int val4; \
2549 str = PTR_ALIGN(str, sizeof(type)); \
2550 val4 = va_arg(args, int); \
2551 if (str + sizeof(type) <= end) \
2552 *(typeof(type) *)str = (type)(long)val4; \
2553 value = (unsigned long long)val4; \
2554 } \
2555 str += sizeof(type); \
2556 value; \
2557})
2558
2559 while (*fmt) {
2560 int read = format_decode(fmt, &spec);
2561
2562 fmt += read;
2563
2564 switch (spec.type) {
2565 case FORMAT_TYPE_NONE:
2566 case FORMAT_TYPE_PERCENT_CHAR:
2567 break;
2568 case FORMAT_TYPE_INVALID:
2569 goto out;
2570
2571 case FORMAT_TYPE_WIDTH:
2572 case FORMAT_TYPE_PRECISION:
2573 width = (int)save_arg(int);
2574
2575 if (*fmt == 'p')
2576 set_field_width(&spec, width);
2577 break;
2578
2579 case FORMAT_TYPE_CHAR:
2580 save_arg(char);
2581 break;
2582
2583 case FORMAT_TYPE_STR: {
2584 const char *save_str = va_arg(args, char *);
2585 size_t len;
2586
2587 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
2588 || (unsigned long)save_str < PAGE_SIZE)
2589 save_str = "(null)";
2590 len = strlen(save_str) + 1;
2591 if (str + len < end)
2592 memcpy(str, save_str, len);
2593 str += len;
2594 break;
2595 }
2596
2597 case FORMAT_TYPE_PTR:
2598
2599 switch (*fmt) {
2600
2601 case 'S':
2602 case 's':
2603 case 'F':
2604 case 'f':
2605 case 'x':
2606 case 'K':
2607 save_arg(void *);
2608 break;
2609 default:
2610 if (!isalnum(*fmt)) {
2611 save_arg(void *);
2612 break;
2613 }
2614 str = pointer(fmt, str, end, va_arg(args, void *),
2615 spec);
2616 if (str + 1 < end)
2617 *str++ = '\0';
2618 else
2619 end[-1] = '\0';
2620 }
2621
2622 while (isalnum(*fmt))
2623 fmt++;
2624 break;
2625
2626 default:
2627 switch (spec.type) {
2628
2629 case FORMAT_TYPE_LONG_LONG:
2630 save_arg(long long);
2631 break;
2632 case FORMAT_TYPE_ULONG:
2633 case FORMAT_TYPE_LONG:
2634 save_arg(unsigned long);
2635 break;
2636 case FORMAT_TYPE_SIZE_T:
2637 save_arg(size_t);
2638 break;
2639 case FORMAT_TYPE_PTRDIFF:
2640 save_arg(ptrdiff_t);
2641 break;
2642 case FORMAT_TYPE_UBYTE:
2643 case FORMAT_TYPE_BYTE:
2644 save_arg(char);
2645 break;
2646 case FORMAT_TYPE_USHORT:
2647 case FORMAT_TYPE_SHORT:
2648 save_arg(short);
2649 break;
2650 default:
2651 save_arg(int);
2652 }
2653 }
2654 }
2655
2656out:
2657 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
2658#undef save_arg
2659}
2660EXPORT_SYMBOL_GPL(vbin_printf);
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
2685{
2686 struct printf_spec spec = {0};
2687 char *str, *end;
2688 const char *args = (const char *)bin_buf;
2689
2690 if (WARN_ON_ONCE(size > INT_MAX))
2691 return 0;
2692
2693 str = buf;
2694 end = buf + size;
2695
2696#define get_arg(type) \
2697({ \
2698 typeof(type) value; \
2699 if (sizeof(type) == 8) { \
2700 args = PTR_ALIGN(args, sizeof(u32)); \
2701 *(u32 *)&value = *(u32 *)args; \
2702 *((u32 *)&value + 1) = *(u32 *)(args + 4); \
2703 } else { \
2704 args = PTR_ALIGN(args, sizeof(type)); \
2705 value = *(typeof(type) *)args; \
2706 } \
2707 args += sizeof(type); \
2708 value; \
2709})
2710
2711
2712 if (end < buf) {
2713 end = ((void *)-1);
2714 size = end - buf;
2715 }
2716
2717 while (*fmt) {
2718 const char *old_fmt = fmt;
2719 int read = format_decode(fmt, &spec);
2720
2721 fmt += read;
2722
2723 switch (spec.type) {
2724 case FORMAT_TYPE_NONE: {
2725 int copy = read;
2726 if (str < end) {
2727 if (copy > end - str)
2728 copy = end - str;
2729 memcpy(str, old_fmt, copy);
2730 }
2731 str += read;
2732 break;
2733 }
2734
2735 case FORMAT_TYPE_WIDTH:
2736 set_field_width(&spec, get_arg(int));
2737 break;
2738
2739 case FORMAT_TYPE_PRECISION:
2740 set_precision(&spec, get_arg(int));
2741 break;
2742
2743 case FORMAT_TYPE_CHAR: {
2744 char c;
2745
2746 if (!(spec.flags & LEFT)) {
2747 while (--spec.field_width > 0) {
2748 if (str < end)
2749 *str = ' ';
2750 ++str;
2751 }
2752 }
2753 c = (unsigned char) get_arg(char);
2754 if (str < end)
2755 *str = c;
2756 ++str;
2757 while (--spec.field_width > 0) {
2758 if (str < end)
2759 *str = ' ';
2760 ++str;
2761 }
2762 break;
2763 }
2764
2765 case FORMAT_TYPE_STR: {
2766 const char *str_arg = args;
2767 args += strlen(str_arg) + 1;
2768 str = string(str, end, (char *)str_arg, spec);
2769 break;
2770 }
2771
2772 case FORMAT_TYPE_PTR: {
2773 bool process = false;
2774 int copy, len;
2775
2776 switch (*fmt) {
2777 case 'S':
2778 case 's':
2779 case 'F':
2780 case 'f':
2781 case 'x':
2782 case 'K':
2783 process = true;
2784 break;
2785 default:
2786 if (!isalnum(*fmt)) {
2787 process = true;
2788 break;
2789 }
2790
2791 if (str < end) {
2792 len = copy = strlen(args);
2793 if (copy > end - str)
2794 copy = end - str;
2795 memcpy(str, args, copy);
2796 str += len;
2797 args += len + 1;
2798 }
2799 }
2800 if (process)
2801 str = pointer(fmt, str, end, get_arg(void *), spec);
2802
2803 while (isalnum(*fmt))
2804 fmt++;
2805 break;
2806 }
2807
2808 case FORMAT_TYPE_PERCENT_CHAR:
2809 if (str < end)
2810 *str = '%';
2811 ++str;
2812 break;
2813
2814 case FORMAT_TYPE_INVALID:
2815 goto out;
2816
2817 default: {
2818 unsigned long long num;
2819
2820 switch (spec.type) {
2821
2822 case FORMAT_TYPE_LONG_LONG:
2823 num = get_arg(long long);
2824 break;
2825 case FORMAT_TYPE_ULONG:
2826 case FORMAT_TYPE_LONG:
2827 num = get_arg(unsigned long);
2828 break;
2829 case FORMAT_TYPE_SIZE_T:
2830 num = get_arg(size_t);
2831 break;
2832 case FORMAT_TYPE_PTRDIFF:
2833 num = get_arg(ptrdiff_t);
2834 break;
2835 case FORMAT_TYPE_UBYTE:
2836 num = get_arg(unsigned char);
2837 break;
2838 case FORMAT_TYPE_BYTE:
2839 num = get_arg(signed char);
2840 break;
2841 case FORMAT_TYPE_USHORT:
2842 num = get_arg(unsigned short);
2843 break;
2844 case FORMAT_TYPE_SHORT:
2845 num = get_arg(short);
2846 break;
2847 case FORMAT_TYPE_UINT:
2848 num = get_arg(unsigned int);
2849 break;
2850 default:
2851 num = get_arg(int);
2852 }
2853
2854 str = number(str, end, num, spec);
2855 }
2856 }
2857 }
2858
2859out:
2860 if (size > 0) {
2861 if (str < end)
2862 *str = '\0';
2863 else
2864 end[-1] = '\0';
2865 }
2866
2867#undef get_arg
2868
2869
2870 return str - buf;
2871}
2872EXPORT_SYMBOL_GPL(bstr_printf);
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
2885{
2886 va_list args;
2887 int ret;
2888
2889 va_start(args, fmt);
2890 ret = vbin_printf(bin_buf, size, fmt, args);
2891 va_end(args);
2892
2893 return ret;
2894}
2895EXPORT_SYMBOL_GPL(bprintf);
2896
2897#endif
2898
2899
2900
2901
2902
2903
2904
2905int vsscanf(const char *buf, const char *fmt, va_list args)
2906{
2907 const char *str = buf;
2908 char *next;
2909 char digit;
2910 int num = 0;
2911 u8 qualifier;
2912 unsigned int base;
2913 union {
2914 long long s;
2915 unsigned long long u;
2916 } val;
2917 s16 field_width;
2918 bool is_sign;
2919
2920 while (*fmt) {
2921
2922
2923
2924
2925 if (isspace(*fmt)) {
2926 fmt = skip_spaces(++fmt);
2927 str = skip_spaces(str);
2928 }
2929
2930
2931 if (*fmt != '%' && *fmt) {
2932 if (*fmt++ != *str++)
2933 break;
2934 continue;
2935 }
2936
2937 if (!*fmt)
2938 break;
2939 ++fmt;
2940
2941
2942
2943
2944 if (*fmt == '*') {
2945 if (!*str)
2946 break;
2947 while (!isspace(*fmt) && *fmt != '%' && *fmt) {
2948
2949 if (*fmt == '[')
2950 return num;
2951 fmt++;
2952 }
2953 while (!isspace(*str) && *str)
2954 str++;
2955 continue;
2956 }
2957
2958
2959 field_width = -1;
2960 if (isdigit(*fmt)) {
2961 field_width = skip_atoi(&fmt);
2962 if (field_width <= 0)
2963 break;
2964 }
2965
2966
2967 qualifier = -1;
2968 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2969 *fmt == 'z') {
2970 qualifier = *fmt++;
2971 if (unlikely(qualifier == *fmt)) {
2972 if (qualifier == 'h') {
2973 qualifier = 'H';
2974 fmt++;
2975 } else if (qualifier == 'l') {
2976 qualifier = 'L';
2977 fmt++;
2978 }
2979 }
2980 }
2981
2982 if (!*fmt)
2983 break;
2984
2985 if (*fmt == 'n') {
2986
2987 *va_arg(args, int *) = str - buf;
2988 ++fmt;
2989 continue;
2990 }
2991
2992 if (!*str)
2993 break;
2994
2995 base = 10;
2996 is_sign = false;
2997
2998 switch (*fmt++) {
2999 case 'c':
3000 {
3001 char *s = (char *)va_arg(args, char*);
3002 if (field_width == -1)
3003 field_width = 1;
3004 do {
3005 *s++ = *str++;
3006 } while (--field_width > 0 && *str);
3007 num++;
3008 }
3009 continue;
3010 case 's':
3011 {
3012 char *s = (char *)va_arg(args, char *);
3013 if (field_width == -1)
3014 field_width = SHRT_MAX;
3015
3016 str = skip_spaces(str);
3017
3018
3019 while (*str && !isspace(*str) && field_width--)
3020 *s++ = *str++;
3021 *s = '\0';
3022 num++;
3023 }
3024 continue;
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040 case '[':
3041 {
3042 char *s = (char *)va_arg(args, char *);
3043 DECLARE_BITMAP(set, 256) = {0};
3044 unsigned int len = 0;
3045 bool negate = (*fmt == '^');
3046
3047
3048 if (field_width == -1)
3049 return num;
3050
3051 if (negate)
3052 ++fmt;
3053
3054 for ( ; *fmt && *fmt != ']'; ++fmt, ++len)
3055 set_bit((u8)*fmt, set);
3056
3057
3058 if (!*fmt || !len)
3059 return num;
3060 ++fmt;
3061
3062 if (negate) {
3063 bitmap_complement(set, set, 256);
3064
3065 clear_bit(0, set);
3066 }
3067
3068
3069 if (!test_bit((u8)*str, set))
3070 return num;
3071
3072 while (test_bit((u8)*str, set) && field_width--)
3073 *s++ = *str++;
3074 *s = '\0';
3075 ++num;
3076 }
3077 continue;
3078 case 'o':
3079 base = 8;
3080 break;
3081 case 'x':
3082 case 'X':
3083 base = 16;
3084 break;
3085 case 'i':
3086 base = 0;
3087
3088 case 'd':
3089 is_sign = true;
3090
3091 case 'u':
3092 break;
3093 case '%':
3094
3095 if (*str++ != '%')
3096 return num;
3097 continue;
3098 default:
3099
3100 return num;
3101 }
3102
3103
3104
3105
3106 str = skip_spaces(str);
3107
3108 digit = *str;
3109 if (is_sign && digit == '-')
3110 digit = *(str + 1);
3111
3112 if (!digit
3113 || (base == 16 && !isxdigit(digit))
3114 || (base == 10 && !isdigit(digit))
3115 || (base == 8 && (!isdigit(digit) || digit > '7'))
3116 || (base == 0 && !isdigit(digit)))
3117 break;
3118
3119 if (is_sign)
3120 val.s = qualifier != 'L' ?
3121 simple_strtol(str, &next, base) :
3122 simple_strtoll(str, &next, base);
3123 else
3124 val.u = qualifier != 'L' ?
3125 simple_strtoul(str, &next, base) :
3126 simple_strtoull(str, &next, base);
3127
3128 if (field_width > 0 && next - str > field_width) {
3129 if (base == 0)
3130 _parse_integer_fixup_radix(str, &base);
3131 while (next - str > field_width) {
3132 if (is_sign)
3133 val.s = div_s64(val.s, base);
3134 else
3135 val.u = div_u64(val.u, base);
3136 --next;
3137 }
3138 }
3139
3140 switch (qualifier) {
3141 case 'H':
3142 if (is_sign)
3143 *va_arg(args, signed char *) = val.s;
3144 else
3145 *va_arg(args, unsigned char *) = val.u;
3146 break;
3147 case 'h':
3148 if (is_sign)
3149 *va_arg(args, short *) = val.s;
3150 else
3151 *va_arg(args, unsigned short *) = val.u;
3152 break;
3153 case 'l':
3154 if (is_sign)
3155 *va_arg(args, long *) = val.s;
3156 else
3157 *va_arg(args, unsigned long *) = val.u;
3158 break;
3159 case 'L':
3160 if (is_sign)
3161 *va_arg(args, long long *) = val.s;
3162 else
3163 *va_arg(args, unsigned long long *) = val.u;
3164 break;
3165 case 'z':
3166 *va_arg(args, size_t *) = val.u;
3167 break;
3168 default:
3169 if (is_sign)
3170 *va_arg(args, int *) = val.s;
3171 else
3172 *va_arg(args, unsigned int *) = val.u;
3173 break;
3174 }
3175 num++;
3176
3177 if (!next)
3178 break;
3179 str = next;
3180 }
3181
3182 return num;
3183}
3184EXPORT_SYMBOL(vsscanf);
3185
3186
3187
3188
3189
3190
3191
3192int sscanf(const char *buf, const char *fmt, ...)
3193{
3194 va_list args;
3195 int i;
3196
3197 va_start(args, fmt);
3198 i = vsscanf(buf, fmt, args);
3199 va_end(args);
3200
3201 return i;
3202}
3203EXPORT_SYMBOL(sscanf);
3204