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