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