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