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