This source file includes following definitions.
- simple_strtoull
- simple_strtoul
- simple_strtol
- simple_strtoll
- skip_atoi
- put_dec_trunc8
- put_dec_full8
- put_dec
- put_dec_full4
- put_dec_helper4
- put_dec
- num_to_str
- number
- special_hex_number
- move_right
- widen_string
- string_nocheck
- error_string
- check_pointer_msg
- check_pointer
- string
- pointer_string
- debug_boot_weak_hash_enable
- enable_ptr_key_workfn
- fill_random_ptr_key
- initialize_ptr_random
- ptr_to_id
- restricted_pointer
- dentry_name
- file_dentry_name
- bdev_name
- symbol_string
- resource_string
- hex_string
- bitmap_string
- bitmap_list_string
- mac_address_string
- ip4_string
- ip6_compressed_string
- ip6_string
- ip6_addr_string
- ip4_addr_string
- ip6_addr_string_sa
- ip4_addr_string_sa
- ip_addr_string
- escaped_string
- va_format
- uuid_string
- netdev_bits
- address_val
- date_str
- time_str
- rtc_str
- time_and_date
- clock
- format_flags
- flags_string
- device_node_name_for_depth
- device_node_gen_full_name
- device_node_string
- kobject_string
- pointer
- format_decode
- set_field_width
- set_precision
- vsnprintf
- vscnprintf
- snprintf
- scnprintf
- vsprintf
- sprintf
- vbin_printf
- bstr_printf
- bprintf
- vsscanf
- sscanf
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
61 unsigned 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 }
76 EXPORT_SYMBOL(simple_strtoull);
77
78
79
80
81
82
83
84
85
86 unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
87 {
88 return simple_strtoull(cp, endp, base);
89 }
90 EXPORT_SYMBOL(simple_strtoul);
91
92
93
94
95
96
97
98
99
100 long 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 }
107 EXPORT_SYMBOL(simple_strtol);
108
109
110
111
112
113
114
115
116
117 long 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 }
124 EXPORT_SYMBOL(simple_strtoll);
125
126 static noinline_for_stack
127 int 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
163 static 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
184 static noinline_for_stack
185 char *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;
215 out_q:
216
217 r = q;
218 out_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
226 static noinline_for_stack
227 char *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
252 static noinline_for_stack
253 char *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
266 static void
267 put_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
286 static noinline_for_stack
287 unsigned 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
300 static
301 char *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
342 int 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
381 enum 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
403 struct 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;
410 static_assert(sizeof(struct printf_spec) == 8);
411
412 #define FIELD_WIDTH_MAX ((1 << 23) - 1)
413 #define PRECISION_MAX ((1 << 15) - 1)
414
415 static noinline_for_stack
416 char *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
536 static noinline_for_stack
537 char *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
550 static 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
576 static noinline_for_stack
577 char *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
598 static 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
617 static 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
636 static 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
647 static 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
661 static noinline_for_stack
662 char *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
671 static 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
686 static int debug_boot_weak_hash __ro_after_init;
687
688 static 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 }
694 early_param("debug_boot_weak_hash", debug_boot_weak_hash_enable);
695
696 static DEFINE_STATIC_KEY_TRUE(not_filled_random_ptr_key);
697 static siphash_key_t ptr_key __read_mostly;
698
699 static 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
706 static DECLARE_WORK(enable_ptr_key_work, enable_ptr_key_workfn);
707
708 static void fill_random_ptr_key(struct random_ready_callback *unused)
709 {
710
711 queue_work(system_unbound_wq, &enable_ptr_key_work);
712 }
713
714 static struct random_ready_callback random_ready = {
715 .func = fill_random_ptr_key
716 };
717
718 static 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 }
740 early_initcall(initialize_ptr_random);
741
742
743 static 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
751
752
753 if (IS_ERR_OR_NULL(ptr))
754 return pointer_string(buf, end, ptr, spec);
755
756
757 if (unlikely(debug_boot_weak_hash)) {
758 hashval = hash_long((unsigned long)ptr, 32);
759 return pointer_string(buf, end, (const void *)hashval, spec);
760 }
761
762 if (static_branch_unlikely(¬_filled_random_ptr_key)) {
763 spec.field_width = 2 * sizeof(ptr);
764
765 return error_string(buf, end, str, spec);
766 }
767
768 #ifdef CONFIG_64BIT
769 hashval = (unsigned long)siphash_1u64((u64)ptr, &ptr_key);
770
771
772
773
774 hashval = hashval & 0xffffffff;
775 #else
776 hashval = (unsigned long)siphash_1u32((u32)ptr, &ptr_key);
777 #endif
778 return pointer_string(buf, end, (const void *)hashval, spec);
779 }
780
781 int kptr_restrict __read_mostly;
782
783 static noinline_for_stack
784 char *restricted_pointer(char *buf, char *end, const void *ptr,
785 struct printf_spec spec)
786 {
787 switch (kptr_restrict) {
788 case 0:
789
790 return ptr_to_id(buf, end, ptr, spec);
791 case 1: {
792 const struct cred *cred;
793
794
795
796
797
798 if (in_irq() || in_serving_softirq() || in_nmi()) {
799 if (spec.field_width == -1)
800 spec.field_width = 2 * sizeof(ptr);
801 return error_string(buf, end, "pK-error", spec);
802 }
803
804
805
806
807
808
809
810
811
812
813 cred = current_cred();
814 if (!has_capability_noaudit(current, CAP_SYSLOG) ||
815 !uid_eq(cred->euid, cred->uid) ||
816 !gid_eq(cred->egid, cred->gid))
817 ptr = NULL;
818 break;
819 }
820 case 2:
821 default:
822
823 ptr = NULL;
824 break;
825 }
826
827 return pointer_string(buf, end, ptr, spec);
828 }
829
830 static noinline_for_stack
831 char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,
832 const char *fmt)
833 {
834 const char *array[4], *s;
835 const struct dentry *p;
836 int depth;
837 int i, n;
838
839 switch (fmt[1]) {
840 case '2': case '3': case '4':
841 depth = fmt[1] - '0';
842 break;
843 default:
844 depth = 1;
845 }
846
847 rcu_read_lock();
848 for (i = 0; i < depth; i++, d = p) {
849 if (check_pointer(&buf, end, d, spec)) {
850 rcu_read_unlock();
851 return buf;
852 }
853
854 p = READ_ONCE(d->d_parent);
855 array[i] = READ_ONCE(d->d_name.name);
856 if (p == d) {
857 if (i)
858 array[i] = "";
859 i++;
860 break;
861 }
862 }
863 s = array[--i];
864 for (n = 0; n != spec.precision; n++, buf++) {
865 char c = *s++;
866 if (!c) {
867 if (!i)
868 break;
869 c = '/';
870 s = array[--i];
871 }
872 if (buf < end)
873 *buf = c;
874 }
875 rcu_read_unlock();
876 return widen_string(buf, n, end, spec);
877 }
878
879 static noinline_for_stack
880 char *file_dentry_name(char *buf, char *end, const struct file *f,
881 struct printf_spec spec, const char *fmt)
882 {
883 if (check_pointer(&buf, end, f, spec))
884 return buf;
885
886 return dentry_name(buf, end, f->f_path.dentry, spec, fmt);
887 }
888 #ifdef CONFIG_BLOCK
889 static noinline_for_stack
890 char *bdev_name(char *buf, char *end, struct block_device *bdev,
891 struct printf_spec spec, const char *fmt)
892 {
893 struct gendisk *hd;
894
895 if (check_pointer(&buf, end, bdev, spec))
896 return buf;
897
898 hd = bdev->bd_disk;
899 buf = string(buf, end, hd->disk_name, spec);
900 if (bdev->bd_part->partno) {
901 if (isdigit(hd->disk_name[strlen(hd->disk_name)-1])) {
902 if (buf < end)
903 *buf = 'p';
904 buf++;
905 }
906 buf = number(buf, end, bdev->bd_part->partno, spec);
907 }
908 return buf;
909 }
910 #endif
911
912 static noinline_for_stack
913 char *symbol_string(char *buf, char *end, void *ptr,
914 struct printf_spec spec, const char *fmt)
915 {
916 unsigned long value;
917 #ifdef CONFIG_KALLSYMS
918 char sym[KSYM_SYMBOL_LEN];
919 #endif
920
921 if (fmt[1] == 'R')
922 ptr = __builtin_extract_return_addr(ptr);
923 value = (unsigned long)ptr;
924
925 #ifdef CONFIG_KALLSYMS
926 if (*fmt == 'B')
927 sprint_backtrace(sym, value);
928 else if (*fmt != 'f' && *fmt != 's')
929 sprint_symbol(sym, value);
930 else
931 sprint_symbol_no_offset(sym, value);
932
933 return string_nocheck(buf, end, sym, spec);
934 #else
935 return special_hex_number(buf, end, value, sizeof(void *));
936 #endif
937 }
938
939 static const struct printf_spec default_str_spec = {
940 .field_width = -1,
941 .precision = -1,
942 };
943
944 static const struct printf_spec default_flag_spec = {
945 .base = 16,
946 .precision = -1,
947 .flags = SPECIAL | SMALL,
948 };
949
950 static const struct printf_spec default_dec_spec = {
951 .base = 10,
952 .precision = -1,
953 };
954
955 static const struct printf_spec default_dec02_spec = {
956 .base = 10,
957 .field_width = 2,
958 .precision = -1,
959 .flags = ZEROPAD,
960 };
961
962 static const struct printf_spec default_dec04_spec = {
963 .base = 10,
964 .field_width = 4,
965 .precision = -1,
966 .flags = ZEROPAD,
967 };
968
969 static noinline_for_stack
970 char *resource_string(char *buf, char *end, struct resource *res,
971 struct printf_spec spec, const char *fmt)
972 {
973 #ifndef IO_RSRC_PRINTK_SIZE
974 #define IO_RSRC_PRINTK_SIZE 6
975 #endif
976
977 #ifndef MEM_RSRC_PRINTK_SIZE
978 #define MEM_RSRC_PRINTK_SIZE 10
979 #endif
980 static const struct printf_spec io_spec = {
981 .base = 16,
982 .field_width = IO_RSRC_PRINTK_SIZE,
983 .precision = -1,
984 .flags = SPECIAL | SMALL | ZEROPAD,
985 };
986 static const struct printf_spec mem_spec = {
987 .base = 16,
988 .field_width = MEM_RSRC_PRINTK_SIZE,
989 .precision = -1,
990 .flags = SPECIAL | SMALL | ZEROPAD,
991 };
992 static const struct printf_spec bus_spec = {
993 .base = 16,
994 .field_width = 2,
995 .precision = -1,
996 .flags = SMALL | ZEROPAD,
997 };
998 static const struct printf_spec str_spec = {
999 .field_width = -1,
1000 .precision = 10,
1001 .flags = LEFT,
1002 };
1003
1004
1005
1006 #define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
1007 #define FLAG_BUF_SIZE (2 * sizeof(res->flags))
1008 #define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
1009 #define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
1010 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
1011 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
1012
1013 char *p = sym, *pend = sym + sizeof(sym);
1014 int decode = (fmt[0] == 'R') ? 1 : 0;
1015 const struct printf_spec *specp;
1016
1017 if (check_pointer(&buf, end, res, spec))
1018 return buf;
1019
1020 *p++ = '[';
1021 if (res->flags & IORESOURCE_IO) {
1022 p = string_nocheck(p, pend, "io ", str_spec);
1023 specp = &io_spec;
1024 } else if (res->flags & IORESOURCE_MEM) {
1025 p = string_nocheck(p, pend, "mem ", str_spec);
1026 specp = &mem_spec;
1027 } else if (res->flags & IORESOURCE_IRQ) {
1028 p = string_nocheck(p, pend, "irq ", str_spec);
1029 specp = &default_dec_spec;
1030 } else if (res->flags & IORESOURCE_DMA) {
1031 p = string_nocheck(p, pend, "dma ", str_spec);
1032 specp = &default_dec_spec;
1033 } else if (res->flags & IORESOURCE_BUS) {
1034 p = string_nocheck(p, pend, "bus ", str_spec);
1035 specp = &bus_spec;
1036 } else {
1037 p = string_nocheck(p, pend, "??? ", str_spec);
1038 specp = &mem_spec;
1039 decode = 0;
1040 }
1041 if (decode && res->flags & IORESOURCE_UNSET) {
1042 p = string_nocheck(p, pend, "size ", str_spec);
1043 p = number(p, pend, resource_size(res), *specp);
1044 } else {
1045 p = number(p, pend, res->start, *specp);
1046 if (res->start != res->end) {
1047 *p++ = '-';
1048 p = number(p, pend, res->end, *specp);
1049 }
1050 }
1051 if (decode) {
1052 if (res->flags & IORESOURCE_MEM_64)
1053 p = string_nocheck(p, pend, " 64bit", str_spec);
1054 if (res->flags & IORESOURCE_PREFETCH)
1055 p = string_nocheck(p, pend, " pref", str_spec);
1056 if (res->flags & IORESOURCE_WINDOW)
1057 p = string_nocheck(p, pend, " window", str_spec);
1058 if (res->flags & IORESOURCE_DISABLED)
1059 p = string_nocheck(p, pend, " disabled", str_spec);
1060 } else {
1061 p = string_nocheck(p, pend, " flags ", str_spec);
1062 p = number(p, pend, res->flags, default_flag_spec);
1063 }
1064 *p++ = ']';
1065 *p = '\0';
1066
1067 return string_nocheck(buf, end, sym, spec);
1068 }
1069
1070 static noinline_for_stack
1071 char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
1072 const char *fmt)
1073 {
1074 int i, len = 1;
1075
1076 char separator;
1077
1078 if (spec.field_width == 0)
1079
1080 return buf;
1081
1082 if (check_pointer(&buf, end, addr, spec))
1083 return buf;
1084
1085 switch (fmt[1]) {
1086 case 'C':
1087 separator = ':';
1088 break;
1089 case 'D':
1090 separator = '-';
1091 break;
1092 case 'N':
1093 separator = 0;
1094 break;
1095 default:
1096 separator = ' ';
1097 break;
1098 }
1099
1100 if (spec.field_width > 0)
1101 len = min_t(int, spec.field_width, 64);
1102
1103 for (i = 0; i < len; ++i) {
1104 if (buf < end)
1105 *buf = hex_asc_hi(addr[i]);
1106 ++buf;
1107 if (buf < end)
1108 *buf = hex_asc_lo(addr[i]);
1109 ++buf;
1110
1111 if (separator && i != len - 1) {
1112 if (buf < end)
1113 *buf = separator;
1114 ++buf;
1115 }
1116 }
1117
1118 return buf;
1119 }
1120
1121 static noinline_for_stack
1122 char *bitmap_string(char *buf, char *end, unsigned long *bitmap,
1123 struct printf_spec spec, const char *fmt)
1124 {
1125 const int CHUNKSZ = 32;
1126 int nr_bits = max_t(int, spec.field_width, 0);
1127 int i, chunksz;
1128 bool first = true;
1129
1130 if (check_pointer(&buf, end, bitmap, spec))
1131 return buf;
1132
1133
1134 spec = (struct printf_spec){ .flags = SMALL | ZEROPAD, .base = 16 };
1135
1136 chunksz = nr_bits & (CHUNKSZ - 1);
1137 if (chunksz == 0)
1138 chunksz = CHUNKSZ;
1139
1140 i = ALIGN(nr_bits, CHUNKSZ) - CHUNKSZ;
1141 for (; i >= 0; i -= CHUNKSZ) {
1142 u32 chunkmask, val;
1143 int word, bit;
1144
1145 chunkmask = ((1ULL << chunksz) - 1);
1146 word = i / BITS_PER_LONG;
1147 bit = i % BITS_PER_LONG;
1148 val = (bitmap[word] >> bit) & chunkmask;
1149
1150 if (!first) {
1151 if (buf < end)
1152 *buf = ',';
1153 buf++;
1154 }
1155 first = false;
1156
1157 spec.field_width = DIV_ROUND_UP(chunksz, 4);
1158 buf = number(buf, end, val, spec);
1159
1160 chunksz = CHUNKSZ;
1161 }
1162 return buf;
1163 }
1164
1165 static noinline_for_stack
1166 char *bitmap_list_string(char *buf, char *end, unsigned long *bitmap,
1167 struct printf_spec spec, const char *fmt)
1168 {
1169 int nr_bits = max_t(int, spec.field_width, 0);
1170
1171 int cur, rbot, rtop;
1172 bool first = true;
1173
1174 if (check_pointer(&buf, end, bitmap, spec))
1175 return buf;
1176
1177 rbot = cur = find_first_bit(bitmap, nr_bits);
1178 while (cur < nr_bits) {
1179 rtop = cur;
1180 cur = find_next_bit(bitmap, nr_bits, cur + 1);
1181 if (cur < nr_bits && cur <= rtop + 1)
1182 continue;
1183
1184 if (!first) {
1185 if (buf < end)
1186 *buf = ',';
1187 buf++;
1188 }
1189 first = false;
1190
1191 buf = number(buf, end, rbot, default_dec_spec);
1192 if (rbot < rtop) {
1193 if (buf < end)
1194 *buf = '-';
1195 buf++;
1196
1197 buf = number(buf, end, rtop, default_dec_spec);
1198 }
1199
1200 rbot = cur;
1201 }
1202 return buf;
1203 }
1204
1205 static noinline_for_stack
1206 char *mac_address_string(char *buf, char *end, u8 *addr,
1207 struct printf_spec spec, const char *fmt)
1208 {
1209 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
1210 char *p = mac_addr;
1211 int i;
1212 char separator;
1213 bool reversed = false;
1214
1215 if (check_pointer(&buf, end, addr, spec))
1216 return buf;
1217
1218 switch (fmt[1]) {
1219 case 'F':
1220 separator = '-';
1221 break;
1222
1223 case 'R':
1224 reversed = true;
1225
1226
1227 default:
1228 separator = ':';
1229 break;
1230 }
1231
1232 for (i = 0; i < 6; i++) {
1233 if (reversed)
1234 p = hex_byte_pack(p, addr[5 - i]);
1235 else
1236 p = hex_byte_pack(p, addr[i]);
1237
1238 if (fmt[0] == 'M' && i != 5)
1239 *p++ = separator;
1240 }
1241 *p = '\0';
1242
1243 return string_nocheck(buf, end, mac_addr, spec);
1244 }
1245
1246 static noinline_for_stack
1247 char *ip4_string(char *p, const u8 *addr, const char *fmt)
1248 {
1249 int i;
1250 bool leading_zeros = (fmt[0] == 'i');
1251 int index;
1252 int step;
1253
1254 switch (fmt[2]) {
1255 case 'h':
1256 #ifdef __BIG_ENDIAN
1257 index = 0;
1258 step = 1;
1259 #else
1260 index = 3;
1261 step = -1;
1262 #endif
1263 break;
1264 case 'l':
1265 index = 3;
1266 step = -1;
1267 break;
1268 case 'n':
1269 case 'b':
1270 default:
1271 index = 0;
1272 step = 1;
1273 break;
1274 }
1275 for (i = 0; i < 4; i++) {
1276 char temp[4] __aligned(2);
1277 int digits = put_dec_trunc8(temp, addr[index]) - temp;
1278 if (leading_zeros) {
1279 if (digits < 3)
1280 *p++ = '0';
1281 if (digits < 2)
1282 *p++ = '0';
1283 }
1284
1285 while (digits--)
1286 *p++ = temp[digits];
1287 if (i < 3)
1288 *p++ = '.';
1289 index += step;
1290 }
1291 *p = '\0';
1292
1293 return p;
1294 }
1295
1296 static noinline_for_stack
1297 char *ip6_compressed_string(char *p, const char *addr)
1298 {
1299 int i, j, range;
1300 unsigned char zerolength[8];
1301 int longest = 1;
1302 int colonpos = -1;
1303 u16 word;
1304 u8 hi, lo;
1305 bool needcolon = false;
1306 bool useIPv4;
1307 struct in6_addr in6;
1308
1309 memcpy(&in6, addr, sizeof(struct in6_addr));
1310
1311 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
1312
1313 memset(zerolength, 0, sizeof(zerolength));
1314
1315 if (useIPv4)
1316 range = 6;
1317 else
1318 range = 8;
1319
1320
1321 for (i = 0; i < range; i++) {
1322 for (j = i; j < range; j++) {
1323 if (in6.s6_addr16[j] != 0)
1324 break;
1325 zerolength[i]++;
1326 }
1327 }
1328 for (i = 0; i < range; i++) {
1329 if (zerolength[i] > longest) {
1330 longest = zerolength[i];
1331 colonpos = i;
1332 }
1333 }
1334 if (longest == 1)
1335 colonpos = -1;
1336
1337
1338 for (i = 0; i < range; i++) {
1339 if (i == colonpos) {
1340 if (needcolon || i == 0)
1341 *p++ = ':';
1342 *p++ = ':';
1343 needcolon = false;
1344 i += longest - 1;
1345 continue;
1346 }
1347 if (needcolon) {
1348 *p++ = ':';
1349 needcolon = false;
1350 }
1351
1352 word = ntohs(in6.s6_addr16[i]);
1353 hi = word >> 8;
1354 lo = word & 0xff;
1355 if (hi) {
1356 if (hi > 0x0f)
1357 p = hex_byte_pack(p, hi);
1358 else
1359 *p++ = hex_asc_lo(hi);
1360 p = hex_byte_pack(p, lo);
1361 }
1362 else if (lo > 0x0f)
1363 p = hex_byte_pack(p, lo);
1364 else
1365 *p++ = hex_asc_lo(lo);
1366 needcolon = true;
1367 }
1368
1369 if (useIPv4) {
1370 if (needcolon)
1371 *p++ = ':';
1372 p = ip4_string(p, &in6.s6_addr[12], "I4");
1373 }
1374 *p = '\0';
1375
1376 return p;
1377 }
1378
1379 static noinline_for_stack
1380 char *ip6_string(char *p, const char *addr, const char *fmt)
1381 {
1382 int i;
1383
1384 for (i = 0; i < 8; i++) {
1385 p = hex_byte_pack(p, *addr++);
1386 p = hex_byte_pack(p, *addr++);
1387 if (fmt[0] == 'I' && i != 7)
1388 *p++ = ':';
1389 }
1390 *p = '\0';
1391
1392 return p;
1393 }
1394
1395 static noinline_for_stack
1396 char *ip6_addr_string(char *buf, char *end, const u8 *addr,
1397 struct printf_spec spec, const char *fmt)
1398 {
1399 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
1400
1401 if (fmt[0] == 'I' && fmt[2] == 'c')
1402 ip6_compressed_string(ip6_addr, addr);
1403 else
1404 ip6_string(ip6_addr, addr, fmt);
1405
1406 return string_nocheck(buf, end, ip6_addr, spec);
1407 }
1408
1409 static noinline_for_stack
1410 char *ip4_addr_string(char *buf, char *end, const u8 *addr,
1411 struct printf_spec spec, const char *fmt)
1412 {
1413 char ip4_addr[sizeof("255.255.255.255")];
1414
1415 ip4_string(ip4_addr, addr, fmt);
1416
1417 return string_nocheck(buf, end, ip4_addr, spec);
1418 }
1419
1420 static noinline_for_stack
1421 char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
1422 struct printf_spec spec, const char *fmt)
1423 {
1424 bool have_p = false, have_s = false, have_f = false, have_c = false;
1425 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
1426 sizeof(":12345") + sizeof("/123456789") +
1427 sizeof("%1234567890")];
1428 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);
1429 const u8 *addr = (const u8 *) &sa->sin6_addr;
1430 char fmt6[2] = { fmt[0], '6' };
1431 u8 off = 0;
1432
1433 fmt++;
1434 while (isalpha(*++fmt)) {
1435 switch (*fmt) {
1436 case 'p':
1437 have_p = true;
1438 break;
1439 case 'f':
1440 have_f = true;
1441 break;
1442 case 's':
1443 have_s = true;
1444 break;
1445 case 'c':
1446 have_c = true;
1447 break;
1448 }
1449 }
1450
1451 if (have_p || have_s || have_f) {
1452 *p = '[';
1453 off = 1;
1454 }
1455
1456 if (fmt6[0] == 'I' && have_c)
1457 p = ip6_compressed_string(ip6_addr + off, addr);
1458 else
1459 p = ip6_string(ip6_addr + off, addr, fmt6);
1460
1461 if (have_p || have_s || have_f)
1462 *p++ = ']';
1463
1464 if (have_p) {
1465 *p++ = ':';
1466 p = number(p, pend, ntohs(sa->sin6_port), spec);
1467 }
1468 if (have_f) {
1469 *p++ = '/';
1470 p = number(p, pend, ntohl(sa->sin6_flowinfo &
1471 IPV6_FLOWINFO_MASK), spec);
1472 }
1473 if (have_s) {
1474 *p++ = '%';
1475 p = number(p, pend, sa->sin6_scope_id, spec);
1476 }
1477 *p = '\0';
1478
1479 return string_nocheck(buf, end, ip6_addr, spec);
1480 }
1481
1482 static noinline_for_stack
1483 char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
1484 struct printf_spec spec, const char *fmt)
1485 {
1486 bool have_p = false;
1487 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];
1488 char *pend = ip4_addr + sizeof(ip4_addr);
1489 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
1490 char fmt4[3] = { fmt[0], '4', 0 };
1491
1492 fmt++;
1493 while (isalpha(*++fmt)) {
1494 switch (*fmt) {
1495 case 'p':
1496 have_p = true;
1497 break;
1498 case 'h':
1499 case 'l':
1500 case 'n':
1501 case 'b':
1502 fmt4[2] = *fmt;
1503 break;
1504 }
1505 }
1506
1507 p = ip4_string(ip4_addr, addr, fmt4);
1508 if (have_p) {
1509 *p++ = ':';
1510 p = number(p, pend, ntohs(sa->sin_port), spec);
1511 }
1512 *p = '\0';
1513
1514 return string_nocheck(buf, end, ip4_addr, spec);
1515 }
1516
1517 static noinline_for_stack
1518 char *ip_addr_string(char *buf, char *end, const void *ptr,
1519 struct printf_spec spec, const char *fmt)
1520 {
1521 char *err_fmt_msg;
1522
1523 if (check_pointer(&buf, end, ptr, spec))
1524 return buf;
1525
1526 switch (fmt[1]) {
1527 case '6':
1528 return ip6_addr_string(buf, end, ptr, spec, fmt);
1529 case '4':
1530 return ip4_addr_string(buf, end, ptr, spec, fmt);
1531 case 'S': {
1532 const union {
1533 struct sockaddr raw;
1534 struct sockaddr_in v4;
1535 struct sockaddr_in6 v6;
1536 } *sa = ptr;
1537
1538 switch (sa->raw.sa_family) {
1539 case AF_INET:
1540 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
1541 case AF_INET6:
1542 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
1543 default:
1544 return error_string(buf, end, "(einval)", spec);
1545 }}
1546 }
1547
1548 err_fmt_msg = fmt[0] == 'i' ? "(%pi?)" : "(%pI?)";
1549 return error_string(buf, end, err_fmt_msg, spec);
1550 }
1551
1552 static noinline_for_stack
1553 char *escaped_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
1554 const char *fmt)
1555 {
1556 bool found = true;
1557 int count = 1;
1558 unsigned int flags = 0;
1559 int len;
1560
1561 if (spec.field_width == 0)
1562 return buf;
1563
1564 if (check_pointer(&buf, end, addr, spec))
1565 return buf;
1566
1567 do {
1568 switch (fmt[count++]) {
1569 case 'a':
1570 flags |= ESCAPE_ANY;
1571 break;
1572 case 'c':
1573 flags |= ESCAPE_SPECIAL;
1574 break;
1575 case 'h':
1576 flags |= ESCAPE_HEX;
1577 break;
1578 case 'n':
1579 flags |= ESCAPE_NULL;
1580 break;
1581 case 'o':
1582 flags |= ESCAPE_OCTAL;
1583 break;
1584 case 'p':
1585 flags |= ESCAPE_NP;
1586 break;
1587 case 's':
1588 flags |= ESCAPE_SPACE;
1589 break;
1590 default:
1591 found = false;
1592 break;
1593 }
1594 } while (found);
1595
1596 if (!flags)
1597 flags = ESCAPE_ANY_NP;
1598
1599 len = spec.field_width < 0 ? 1 : spec.field_width;
1600
1601
1602
1603
1604
1605
1606 buf += string_escape_mem(addr, len, buf, buf < end ? end - buf : 0, flags, NULL);
1607
1608 return buf;
1609 }
1610
1611 static char *va_format(char *buf, char *end, struct va_format *va_fmt,
1612 struct printf_spec spec, const char *fmt)
1613 {
1614 va_list va;
1615
1616 if (check_pointer(&buf, end, va_fmt, spec))
1617 return buf;
1618
1619 va_copy(va, *va_fmt->va);
1620 buf += vsnprintf(buf, end > buf ? end - buf : 0, va_fmt->fmt, va);
1621 va_end(va);
1622
1623 return buf;
1624 }
1625
1626 static noinline_for_stack
1627 char *uuid_string(char *buf, char *end, const u8 *addr,
1628 struct printf_spec spec, const char *fmt)
1629 {
1630 char uuid[UUID_STRING_LEN + 1];
1631 char *p = uuid;
1632 int i;
1633 const u8 *index = uuid_index;
1634 bool uc = false;
1635
1636 if (check_pointer(&buf, end, addr, spec))
1637 return buf;
1638
1639 switch (*(++fmt)) {
1640 case 'L':
1641 uc = true;
1642 case 'l':
1643 index = guid_index;
1644 break;
1645 case 'B':
1646 uc = true;
1647 break;
1648 }
1649
1650 for (i = 0; i < 16; i++) {
1651 if (uc)
1652 p = hex_byte_pack_upper(p, addr[index[i]]);
1653 else
1654 p = hex_byte_pack(p, addr[index[i]]);
1655 switch (i) {
1656 case 3:
1657 case 5:
1658 case 7:
1659 case 9:
1660 *p++ = '-';
1661 break;
1662 }
1663 }
1664
1665 *p = 0;
1666
1667 return string_nocheck(buf, end, uuid, spec);
1668 }
1669
1670 static noinline_for_stack
1671 char *netdev_bits(char *buf, char *end, const void *addr,
1672 struct printf_spec spec, const char *fmt)
1673 {
1674 unsigned long long num;
1675 int size;
1676
1677 if (check_pointer(&buf, end, addr, spec))
1678 return buf;
1679
1680 switch (fmt[1]) {
1681 case 'F':
1682 num = *(const netdev_features_t *)addr;
1683 size = sizeof(netdev_features_t);
1684 break;
1685 default:
1686 return error_string(buf, end, "(%pN?)", spec);
1687 }
1688
1689 return special_hex_number(buf, end, num, size);
1690 }
1691
1692 static noinline_for_stack
1693 char *address_val(char *buf, char *end, const void *addr,
1694 struct printf_spec spec, const char *fmt)
1695 {
1696 unsigned long long num;
1697 int size;
1698
1699 if (check_pointer(&buf, end, addr, spec))
1700 return buf;
1701
1702 switch (fmt[1]) {
1703 case 'd':
1704 num = *(const dma_addr_t *)addr;
1705 size = sizeof(dma_addr_t);
1706 break;
1707 case 'p':
1708 default:
1709 num = *(const phys_addr_t *)addr;
1710 size = sizeof(phys_addr_t);
1711 break;
1712 }
1713
1714 return special_hex_number(buf, end, num, size);
1715 }
1716
1717 static noinline_for_stack
1718 char *date_str(char *buf, char *end, const struct rtc_time *tm, bool r)
1719 {
1720 int year = tm->tm_year + (r ? 0 : 1900);
1721 int mon = tm->tm_mon + (r ? 0 : 1);
1722
1723 buf = number(buf, end, year, default_dec04_spec);
1724 if (buf < end)
1725 *buf = '-';
1726 buf++;
1727
1728 buf = number(buf, end, mon, default_dec02_spec);
1729 if (buf < end)
1730 *buf = '-';
1731 buf++;
1732
1733 return number(buf, end, tm->tm_mday, default_dec02_spec);
1734 }
1735
1736 static noinline_for_stack
1737 char *time_str(char *buf, char *end, const struct rtc_time *tm, bool r)
1738 {
1739 buf = number(buf, end, tm->tm_hour, default_dec02_spec);
1740 if (buf < end)
1741 *buf = ':';
1742 buf++;
1743
1744 buf = number(buf, end, tm->tm_min, default_dec02_spec);
1745 if (buf < end)
1746 *buf = ':';
1747 buf++;
1748
1749 return number(buf, end, tm->tm_sec, default_dec02_spec);
1750 }
1751
1752 static noinline_for_stack
1753 char *rtc_str(char *buf, char *end, const struct rtc_time *tm,
1754 struct printf_spec spec, const char *fmt)
1755 {
1756 bool have_t = true, have_d = true;
1757 bool raw = false;
1758 int count = 2;
1759
1760 if (check_pointer(&buf, end, tm, spec))
1761 return buf;
1762
1763 switch (fmt[count]) {
1764 case 'd':
1765 have_t = false;
1766 count++;
1767 break;
1768 case 't':
1769 have_d = false;
1770 count++;
1771 break;
1772 }
1773
1774 raw = fmt[count] == 'r';
1775
1776 if (have_d)
1777 buf = date_str(buf, end, tm, raw);
1778 if (have_d && have_t) {
1779
1780 if (buf < end)
1781 *buf = 'T';
1782 buf++;
1783 }
1784 if (have_t)
1785 buf = time_str(buf, end, tm, raw);
1786
1787 return buf;
1788 }
1789
1790 static noinline_for_stack
1791 char *time_and_date(char *buf, char *end, void *ptr, struct printf_spec spec,
1792 const char *fmt)
1793 {
1794 switch (fmt[1]) {
1795 case 'R':
1796 return rtc_str(buf, end, (const struct rtc_time *)ptr, spec, fmt);
1797 default:
1798 return error_string(buf, end, "(%ptR?)", spec);
1799 }
1800 }
1801
1802 static noinline_for_stack
1803 char *clock(char *buf, char *end, struct clk *clk, struct printf_spec spec,
1804 const char *fmt)
1805 {
1806 if (!IS_ENABLED(CONFIG_HAVE_CLK))
1807 return error_string(buf, end, "(%pC?)", spec);
1808
1809 if (check_pointer(&buf, end, clk, spec))
1810 return buf;
1811
1812 switch (fmt[1]) {
1813 case 'n':
1814 default:
1815 #ifdef CONFIG_COMMON_CLK
1816 return string(buf, end, __clk_get_name(clk), spec);
1817 #else
1818 return ptr_to_id(buf, end, clk, spec);
1819 #endif
1820 }
1821 }
1822
1823 static
1824 char *format_flags(char *buf, char *end, unsigned long flags,
1825 const struct trace_print_flags *names)
1826 {
1827 unsigned long mask;
1828
1829 for ( ; flags && names->name; names++) {
1830 mask = names->mask;
1831 if ((flags & mask) != mask)
1832 continue;
1833
1834 buf = string(buf, end, names->name, default_str_spec);
1835
1836 flags &= ~mask;
1837 if (flags) {
1838 if (buf < end)
1839 *buf = '|';
1840 buf++;
1841 }
1842 }
1843
1844 if (flags)
1845 buf = number(buf, end, flags, default_flag_spec);
1846
1847 return buf;
1848 }
1849
1850 static noinline_for_stack
1851 char *flags_string(char *buf, char *end, void *flags_ptr,
1852 struct printf_spec spec, const char *fmt)
1853 {
1854 unsigned long flags;
1855 const struct trace_print_flags *names;
1856
1857 if (check_pointer(&buf, end, flags_ptr, spec))
1858 return buf;
1859
1860 switch (fmt[1]) {
1861 case 'p':
1862 flags = *(unsigned long *)flags_ptr;
1863
1864 flags &= (1UL << NR_PAGEFLAGS) - 1;
1865 names = pageflag_names;
1866 break;
1867 case 'v':
1868 flags = *(unsigned long *)flags_ptr;
1869 names = vmaflag_names;
1870 break;
1871 case 'g':
1872 flags = *(gfp_t *)flags_ptr;
1873 names = gfpflag_names;
1874 break;
1875 default:
1876 return error_string(buf, end, "(%pG?)", spec);
1877 }
1878
1879 return format_flags(buf, end, flags, names);
1880 }
1881
1882 static const char *device_node_name_for_depth(const struct device_node *np, int depth)
1883 {
1884 for ( ; np && depth; depth--)
1885 np = np->parent;
1886
1887 return kbasename(np->full_name);
1888 }
1889
1890 static noinline_for_stack
1891 char *device_node_gen_full_name(const struct device_node *np, char *buf, char *end)
1892 {
1893 int depth;
1894 const struct device_node *parent = np->parent;
1895
1896
1897 if (!parent)
1898 return string_nocheck(buf, end, "/", default_str_spec);
1899
1900 for (depth = 0; parent->parent; depth++)
1901 parent = parent->parent;
1902
1903 for ( ; depth >= 0; depth--) {
1904 buf = string_nocheck(buf, end, "/", default_str_spec);
1905 buf = string(buf, end, device_node_name_for_depth(np, depth),
1906 default_str_spec);
1907 }
1908 return buf;
1909 }
1910
1911 static noinline_for_stack
1912 char *device_node_string(char *buf, char *end, struct device_node *dn,
1913 struct printf_spec spec, const char *fmt)
1914 {
1915 char tbuf[sizeof("xxxx") + 1];
1916 const char *p;
1917 int ret;
1918 char *buf_start = buf;
1919 struct property *prop;
1920 bool has_mult, pass;
1921 static const struct printf_spec num_spec = {
1922 .flags = SMALL,
1923 .field_width = -1,
1924 .precision = -1,
1925 .base = 10,
1926 };
1927
1928 struct printf_spec str_spec = spec;
1929 str_spec.field_width = -1;
1930
1931 if (!IS_ENABLED(CONFIG_OF))
1932 return error_string(buf, end, "(%pOF?)", spec);
1933
1934 if (check_pointer(&buf, end, dn, spec))
1935 return buf;
1936
1937
1938 fmt++;
1939 if (fmt[0] == '\0' || strcspn(fmt,"fnpPFcC") > 0)
1940 fmt = "f";
1941
1942 for (pass = false; strspn(fmt,"fnpPFcC"); fmt++, pass = true) {
1943 int precision;
1944 if (pass) {
1945 if (buf < end)
1946 *buf = ':';
1947 buf++;
1948 }
1949
1950 switch (*fmt) {
1951 case 'f':
1952 buf = device_node_gen_full_name(dn, buf, end);
1953 break;
1954 case 'n':
1955 p = kbasename(of_node_full_name(dn));
1956 precision = str_spec.precision;
1957 str_spec.precision = strchrnul(p, '@') - p;
1958 buf = string(buf, end, p, str_spec);
1959 str_spec.precision = precision;
1960 break;
1961 case 'p':
1962 buf = number(buf, end, (unsigned int)dn->phandle, num_spec);
1963 break;
1964 case 'P':
1965 p = kbasename(of_node_full_name(dn));
1966 if (!p[1])
1967 p = "/";
1968 buf = string(buf, end, p, str_spec);
1969 break;
1970 case 'F':
1971 tbuf[0] = of_node_check_flag(dn, OF_DYNAMIC) ? 'D' : '-';
1972 tbuf[1] = of_node_check_flag(dn, OF_DETACHED) ? 'd' : '-';
1973 tbuf[2] = of_node_check_flag(dn, OF_POPULATED) ? 'P' : '-';
1974 tbuf[3] = of_node_check_flag(dn, OF_POPULATED_BUS) ? 'B' : '-';
1975 tbuf[4] = 0;
1976 buf = string_nocheck(buf, end, tbuf, str_spec);
1977 break;
1978 case 'c':
1979 ret = of_property_read_string(dn, "compatible", &p);
1980 if (!ret)
1981 buf = string(buf, end, p, str_spec);
1982 break;
1983 case 'C':
1984 has_mult = false;
1985 of_property_for_each_string(dn, "compatible", prop, p) {
1986 if (has_mult)
1987 buf = string_nocheck(buf, end, ",", str_spec);
1988 buf = string_nocheck(buf, end, "\"", str_spec);
1989 buf = string(buf, end, p, str_spec);
1990 buf = string_nocheck(buf, end, "\"", str_spec);
1991
1992 has_mult = true;
1993 }
1994 break;
1995 default:
1996 break;
1997 }
1998 }
1999
2000 return widen_string(buf, buf - buf_start, end, spec);
2001 }
2002
2003 static char *kobject_string(char *buf, char *end, void *ptr,
2004 struct printf_spec spec, const char *fmt)
2005 {
2006 switch (fmt[1]) {
2007 case 'F':
2008 return device_node_string(buf, end, ptr, spec, fmt + 1);
2009 }
2010
2011 return error_string(buf, end, "(%pO?)", spec);
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
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126 static noinline_for_stack
2127 char *pointer(const char *fmt, char *buf, char *end, void *ptr,
2128 struct printf_spec spec)
2129 {
2130 switch (*fmt) {
2131 case 'F':
2132 case 'f':
2133 case 'S':
2134 case 's':
2135 ptr = dereference_symbol_descriptor(ptr);
2136
2137 case 'B':
2138 return symbol_string(buf, end, ptr, spec, fmt);
2139 case 'R':
2140 case 'r':
2141 return resource_string(buf, end, ptr, spec, fmt);
2142 case 'h':
2143 return hex_string(buf, end, ptr, spec, fmt);
2144 case 'b':
2145 switch (fmt[1]) {
2146 case 'l':
2147 return bitmap_list_string(buf, end, ptr, spec, fmt);
2148 default:
2149 return bitmap_string(buf, end, ptr, spec, fmt);
2150 }
2151 case 'M':
2152 case 'm':
2153
2154
2155 return mac_address_string(buf, end, ptr, spec, fmt);
2156 case 'I':
2157
2158
2159
2160
2161 case 'i':
2162
2163
2164
2165 return ip_addr_string(buf, end, ptr, spec, fmt);
2166 case 'E':
2167 return escaped_string(buf, end, ptr, spec, fmt);
2168 case 'U':
2169 return uuid_string(buf, end, ptr, spec, fmt);
2170 case 'V':
2171 return va_format(buf, end, ptr, spec, fmt);
2172 case 'K':
2173 return restricted_pointer(buf, end, ptr, spec);
2174 case 'N':
2175 return netdev_bits(buf, end, ptr, spec, fmt);
2176 case 'a':
2177 return address_val(buf, end, ptr, spec, fmt);
2178 case 'd':
2179 return dentry_name(buf, end, ptr, spec, fmt);
2180 case 't':
2181 return time_and_date(buf, end, ptr, spec, fmt);
2182 case 'C':
2183 return clock(buf, end, ptr, spec, fmt);
2184 case 'D':
2185 return file_dentry_name(buf, end, ptr, spec, fmt);
2186 #ifdef CONFIG_BLOCK
2187 case 'g':
2188 return bdev_name(buf, end, ptr, spec, fmt);
2189 #endif
2190
2191 case 'G':
2192 return flags_string(buf, end, ptr, spec, fmt);
2193 case 'O':
2194 return kobject_string(buf, end, ptr, spec, fmt);
2195 case 'x':
2196 return pointer_string(buf, end, ptr, spec);
2197 }
2198
2199
2200 return ptr_to_id(buf, end, ptr, spec);
2201 }
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224 static noinline_for_stack
2225 int format_decode(const char *fmt, struct printf_spec *spec)
2226 {
2227 const char *start = fmt;
2228 char qualifier;
2229
2230
2231 if (spec->type == FORMAT_TYPE_WIDTH) {
2232 if (spec->field_width < 0) {
2233 spec->field_width = -spec->field_width;
2234 spec->flags |= LEFT;
2235 }
2236 spec->type = FORMAT_TYPE_NONE;
2237 goto precision;
2238 }
2239
2240
2241 if (spec->type == FORMAT_TYPE_PRECISION) {
2242 if (spec->precision < 0)
2243 spec->precision = 0;
2244
2245 spec->type = FORMAT_TYPE_NONE;
2246 goto qualifier;
2247 }
2248
2249
2250 spec->type = FORMAT_TYPE_NONE;
2251
2252 for (; *fmt ; ++fmt) {
2253 if (*fmt == '%')
2254 break;
2255 }
2256
2257
2258 if (fmt != start || !*fmt)
2259 return fmt - start;
2260
2261
2262 spec->flags = 0;
2263
2264 while (1) {
2265 bool found = true;
2266
2267 ++fmt;
2268
2269 switch (*fmt) {
2270 case '-': spec->flags |= LEFT; break;
2271 case '+': spec->flags |= PLUS; break;
2272 case ' ': spec->flags |= SPACE; break;
2273 case '#': spec->flags |= SPECIAL; break;
2274 case '0': spec->flags |= ZEROPAD; break;
2275 default: found = false;
2276 }
2277
2278 if (!found)
2279 break;
2280 }
2281
2282
2283 spec->field_width = -1;
2284
2285 if (isdigit(*fmt))
2286 spec->field_width = skip_atoi(&fmt);
2287 else if (*fmt == '*') {
2288
2289 spec->type = FORMAT_TYPE_WIDTH;
2290 return ++fmt - start;
2291 }
2292
2293 precision:
2294
2295 spec->precision = -1;
2296 if (*fmt == '.') {
2297 ++fmt;
2298 if (isdigit(*fmt)) {
2299 spec->precision = skip_atoi(&fmt);
2300 if (spec->precision < 0)
2301 spec->precision = 0;
2302 } else if (*fmt == '*') {
2303
2304 spec->type = FORMAT_TYPE_PRECISION;
2305 return ++fmt - start;
2306 }
2307 }
2308
2309 qualifier:
2310
2311 qualifier = 0;
2312 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2313 *fmt == 'z' || *fmt == 't') {
2314 qualifier = *fmt++;
2315 if (unlikely(qualifier == *fmt)) {
2316 if (qualifier == 'l') {
2317 qualifier = 'L';
2318 ++fmt;
2319 } else if (qualifier == 'h') {
2320 qualifier = 'H';
2321 ++fmt;
2322 }
2323 }
2324 }
2325
2326
2327 spec->base = 10;
2328 switch (*fmt) {
2329 case 'c':
2330 spec->type = FORMAT_TYPE_CHAR;
2331 return ++fmt - start;
2332
2333 case 's':
2334 spec->type = FORMAT_TYPE_STR;
2335 return ++fmt - start;
2336
2337 case 'p':
2338 spec->type = FORMAT_TYPE_PTR;
2339 return ++fmt - start;
2340
2341 case '%':
2342 spec->type = FORMAT_TYPE_PERCENT_CHAR;
2343 return ++fmt - start;
2344
2345
2346 case 'o':
2347 spec->base = 8;
2348 break;
2349
2350 case 'x':
2351 spec->flags |= SMALL;
2352
2353
2354 case 'X':
2355 spec->base = 16;
2356 break;
2357
2358 case 'd':
2359 case 'i':
2360 spec->flags |= SIGN;
2361 case 'u':
2362 break;
2363
2364 case 'n':
2365
2366
2367
2368
2369
2370
2371
2372 default:
2373 WARN_ONCE(1, "Please remove unsupported %%%c in format string\n", *fmt);
2374 spec->type = FORMAT_TYPE_INVALID;
2375 return fmt - start;
2376 }
2377
2378 if (qualifier == 'L')
2379 spec->type = FORMAT_TYPE_LONG_LONG;
2380 else if (qualifier == 'l') {
2381 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG);
2382 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN);
2383 } else if (qualifier == 'z') {
2384 spec->type = FORMAT_TYPE_SIZE_T;
2385 } else if (qualifier == 't') {
2386 spec->type = FORMAT_TYPE_PTRDIFF;
2387 } else if (qualifier == 'H') {
2388 BUILD_BUG_ON(FORMAT_TYPE_UBYTE + SIGN != FORMAT_TYPE_BYTE);
2389 spec->type = FORMAT_TYPE_UBYTE + (spec->flags & SIGN);
2390 } else if (qualifier == 'h') {
2391 BUILD_BUG_ON(FORMAT_TYPE_USHORT + SIGN != FORMAT_TYPE_SHORT);
2392 spec->type = FORMAT_TYPE_USHORT + (spec->flags & SIGN);
2393 } else {
2394 BUILD_BUG_ON(FORMAT_TYPE_UINT + SIGN != FORMAT_TYPE_INT);
2395 spec->type = FORMAT_TYPE_UINT + (spec->flags & SIGN);
2396 }
2397
2398 return ++fmt - start;
2399 }
2400
2401 static void
2402 set_field_width(struct printf_spec *spec, int width)
2403 {
2404 spec->field_width = width;
2405 if (WARN_ONCE(spec->field_width != width, "field width %d too large", width)) {
2406 spec->field_width = clamp(width, -FIELD_WIDTH_MAX, FIELD_WIDTH_MAX);
2407 }
2408 }
2409
2410 static void
2411 set_precision(struct printf_spec *spec, int prec)
2412 {
2413 spec->precision = prec;
2414 if (WARN_ONCE(spec->precision != prec, "precision %d too large", prec)) {
2415 spec->precision = clamp(prec, 0, PRECISION_MAX);
2416 }
2417 }
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
2448 {
2449 unsigned long long num;
2450 char *str, *end;
2451 struct printf_spec spec = {0};
2452
2453
2454
2455 if (WARN_ON_ONCE(size > INT_MAX))
2456 return 0;
2457
2458 str = buf;
2459 end = buf + size;
2460
2461
2462 if (end < buf) {
2463 end = ((void *)-1);
2464 size = end - buf;
2465 }
2466
2467 while (*fmt) {
2468 const char *old_fmt = fmt;
2469 int read = format_decode(fmt, &spec);
2470
2471 fmt += read;
2472
2473 switch (spec.type) {
2474 case FORMAT_TYPE_NONE: {
2475 int copy = read;
2476 if (str < end) {
2477 if (copy > end - str)
2478 copy = end - str;
2479 memcpy(str, old_fmt, copy);
2480 }
2481 str += read;
2482 break;
2483 }
2484
2485 case FORMAT_TYPE_WIDTH:
2486 set_field_width(&spec, va_arg(args, int));
2487 break;
2488
2489 case FORMAT_TYPE_PRECISION:
2490 set_precision(&spec, va_arg(args, int));
2491 break;
2492
2493 case FORMAT_TYPE_CHAR: {
2494 char c;
2495
2496 if (!(spec.flags & LEFT)) {
2497 while (--spec.field_width > 0) {
2498 if (str < end)
2499 *str = ' ';
2500 ++str;
2501
2502 }
2503 }
2504 c = (unsigned char) va_arg(args, int);
2505 if (str < end)
2506 *str = c;
2507 ++str;
2508 while (--spec.field_width > 0) {
2509 if (str < end)
2510 *str = ' ';
2511 ++str;
2512 }
2513 break;
2514 }
2515
2516 case FORMAT_TYPE_STR:
2517 str = string(str, end, va_arg(args, char *), spec);
2518 break;
2519
2520 case FORMAT_TYPE_PTR:
2521 str = pointer(fmt, str, end, va_arg(args, void *),
2522 spec);
2523 while (isalnum(*fmt))
2524 fmt++;
2525 break;
2526
2527 case FORMAT_TYPE_PERCENT_CHAR:
2528 if (str < end)
2529 *str = '%';
2530 ++str;
2531 break;
2532
2533 case FORMAT_TYPE_INVALID:
2534
2535
2536
2537
2538
2539
2540
2541
2542 goto out;
2543
2544 default:
2545 switch (spec.type) {
2546 case FORMAT_TYPE_LONG_LONG:
2547 num = va_arg(args, long long);
2548 break;
2549 case FORMAT_TYPE_ULONG:
2550 num = va_arg(args, unsigned long);
2551 break;
2552 case FORMAT_TYPE_LONG:
2553 num = va_arg(args, long);
2554 break;
2555 case FORMAT_TYPE_SIZE_T:
2556 if (spec.flags & SIGN)
2557 num = va_arg(args, ssize_t);
2558 else
2559 num = va_arg(args, size_t);
2560 break;
2561 case FORMAT_TYPE_PTRDIFF:
2562 num = va_arg(args, ptrdiff_t);
2563 break;
2564 case FORMAT_TYPE_UBYTE:
2565 num = (unsigned char) va_arg(args, int);
2566 break;
2567 case FORMAT_TYPE_BYTE:
2568 num = (signed char) va_arg(args, int);
2569 break;
2570 case FORMAT_TYPE_USHORT:
2571 num = (unsigned short) va_arg(args, int);
2572 break;
2573 case FORMAT_TYPE_SHORT:
2574 num = (short) va_arg(args, int);
2575 break;
2576 case FORMAT_TYPE_INT:
2577 num = (int) va_arg(args, int);
2578 break;
2579 default:
2580 num = va_arg(args, unsigned int);
2581 }
2582
2583 str = number(str, end, num, spec);
2584 }
2585 }
2586
2587 out:
2588 if (size > 0) {
2589 if (str < end)
2590 *str = '\0';
2591 else
2592 end[-1] = '\0';
2593 }
2594
2595
2596 return str-buf;
2597
2598 }
2599 EXPORT_SYMBOL(vsnprintf);
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
2617 {
2618 int i;
2619
2620 i = vsnprintf(buf, size, fmt, args);
2621
2622 if (likely(i < size))
2623 return i;
2624 if (size != 0)
2625 return size - 1;
2626 return 0;
2627 }
2628 EXPORT_SYMBOL(vscnprintf);
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644 int snprintf(char *buf, size_t size, const char *fmt, ...)
2645 {
2646 va_list args;
2647 int i;
2648
2649 va_start(args, fmt);
2650 i = vsnprintf(buf, size, fmt, args);
2651 va_end(args);
2652
2653 return i;
2654 }
2655 EXPORT_SYMBOL(snprintf);
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668 int scnprintf(char *buf, size_t size, const char *fmt, ...)
2669 {
2670 va_list args;
2671 int i;
2672
2673 va_start(args, fmt);
2674 i = vscnprintf(buf, size, fmt, args);
2675 va_end(args);
2676
2677 return i;
2678 }
2679 EXPORT_SYMBOL(scnprintf);
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695 int vsprintf(char *buf, const char *fmt, va_list args)
2696 {
2697 return vsnprintf(buf, INT_MAX, fmt, args);
2698 }
2699 EXPORT_SYMBOL(vsprintf);
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713 int sprintf(char *buf, const char *fmt, ...)
2714 {
2715 va_list args;
2716 int i;
2717
2718 va_start(args, fmt);
2719 i = vsnprintf(buf, INT_MAX, fmt, args);
2720 va_end(args);
2721
2722 return i;
2723 }
2724 EXPORT_SYMBOL(sprintf);
2725
2726 #ifdef CONFIG_BINARY_PRINTF
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
2751 {
2752 struct printf_spec spec = {0};
2753 char *str, *end;
2754 int width;
2755
2756 str = (char *)bin_buf;
2757 end = (char *)(bin_buf + size);
2758
2759 #define save_arg(type) \
2760 ({ \
2761 unsigned long long value; \
2762 if (sizeof(type) == 8) { \
2763 unsigned long long val8; \
2764 str = PTR_ALIGN(str, sizeof(u32)); \
2765 val8 = va_arg(args, unsigned long long); \
2766 if (str + sizeof(type) <= end) { \
2767 *(u32 *)str = *(u32 *)&val8; \
2768 *(u32 *)(str + 4) = *((u32 *)&val8 + 1); \
2769 } \
2770 value = val8; \
2771 } else { \
2772 unsigned int val4; \
2773 str = PTR_ALIGN(str, sizeof(type)); \
2774 val4 = va_arg(args, int); \
2775 if (str + sizeof(type) <= end) \
2776 *(typeof(type) *)str = (type)(long)val4; \
2777 value = (unsigned long long)val4; \
2778 } \
2779 str += sizeof(type); \
2780 value; \
2781 })
2782
2783 while (*fmt) {
2784 int read = format_decode(fmt, &spec);
2785
2786 fmt += read;
2787
2788 switch (spec.type) {
2789 case FORMAT_TYPE_NONE:
2790 case FORMAT_TYPE_PERCENT_CHAR:
2791 break;
2792 case FORMAT_TYPE_INVALID:
2793 goto out;
2794
2795 case FORMAT_TYPE_WIDTH:
2796 case FORMAT_TYPE_PRECISION:
2797 width = (int)save_arg(int);
2798
2799 if (*fmt == 'p')
2800 set_field_width(&spec, width);
2801 break;
2802
2803 case FORMAT_TYPE_CHAR:
2804 save_arg(char);
2805 break;
2806
2807 case FORMAT_TYPE_STR: {
2808 const char *save_str = va_arg(args, char *);
2809 const char *err_msg;
2810 size_t len;
2811
2812 err_msg = check_pointer_msg(save_str);
2813 if (err_msg)
2814 save_str = err_msg;
2815
2816 len = strlen(save_str) + 1;
2817 if (str + len < end)
2818 memcpy(str, save_str, len);
2819 str += len;
2820 break;
2821 }
2822
2823 case FORMAT_TYPE_PTR:
2824
2825 switch (*fmt) {
2826
2827 case 'S':
2828 case 's':
2829 case 'F':
2830 case 'f':
2831 case 'x':
2832 case 'K':
2833 save_arg(void *);
2834 break;
2835 default:
2836 if (!isalnum(*fmt)) {
2837 save_arg(void *);
2838 break;
2839 }
2840 str = pointer(fmt, str, end, va_arg(args, void *),
2841 spec);
2842 if (str + 1 < end)
2843 *str++ = '\0';
2844 else
2845 end[-1] = '\0';
2846 }
2847
2848 while (isalnum(*fmt))
2849 fmt++;
2850 break;
2851
2852 default:
2853 switch (spec.type) {
2854
2855 case FORMAT_TYPE_LONG_LONG:
2856 save_arg(long long);
2857 break;
2858 case FORMAT_TYPE_ULONG:
2859 case FORMAT_TYPE_LONG:
2860 save_arg(unsigned long);
2861 break;
2862 case FORMAT_TYPE_SIZE_T:
2863 save_arg(size_t);
2864 break;
2865 case FORMAT_TYPE_PTRDIFF:
2866 save_arg(ptrdiff_t);
2867 break;
2868 case FORMAT_TYPE_UBYTE:
2869 case FORMAT_TYPE_BYTE:
2870 save_arg(char);
2871 break;
2872 case FORMAT_TYPE_USHORT:
2873 case FORMAT_TYPE_SHORT:
2874 save_arg(short);
2875 break;
2876 default:
2877 save_arg(int);
2878 }
2879 }
2880 }
2881
2882 out:
2883 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
2884 #undef save_arg
2885 }
2886 EXPORT_SYMBOL_GPL(vbin_printf);
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910 int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
2911 {
2912 struct printf_spec spec = {0};
2913 char *str, *end;
2914 const char *args = (const char *)bin_buf;
2915
2916 if (WARN_ON_ONCE(size > INT_MAX))
2917 return 0;
2918
2919 str = buf;
2920 end = buf + size;
2921
2922 #define get_arg(type) \
2923 ({ \
2924 typeof(type) value; \
2925 if (sizeof(type) == 8) { \
2926 args = PTR_ALIGN(args, sizeof(u32)); \
2927 *(u32 *)&value = *(u32 *)args; \
2928 *((u32 *)&value + 1) = *(u32 *)(args + 4); \
2929 } else { \
2930 args = PTR_ALIGN(args, sizeof(type)); \
2931 value = *(typeof(type) *)args; \
2932 } \
2933 args += sizeof(type); \
2934 value; \
2935 })
2936
2937
2938 if (end < buf) {
2939 end = ((void *)-1);
2940 size = end - buf;
2941 }
2942
2943 while (*fmt) {
2944 const char *old_fmt = fmt;
2945 int read = format_decode(fmt, &spec);
2946
2947 fmt += read;
2948
2949 switch (spec.type) {
2950 case FORMAT_TYPE_NONE: {
2951 int copy = read;
2952 if (str < end) {
2953 if (copy > end - str)
2954 copy = end - str;
2955 memcpy(str, old_fmt, copy);
2956 }
2957 str += read;
2958 break;
2959 }
2960
2961 case FORMAT_TYPE_WIDTH:
2962 set_field_width(&spec, get_arg(int));
2963 break;
2964
2965 case FORMAT_TYPE_PRECISION:
2966 set_precision(&spec, get_arg(int));
2967 break;
2968
2969 case FORMAT_TYPE_CHAR: {
2970 char c;
2971
2972 if (!(spec.flags & LEFT)) {
2973 while (--spec.field_width > 0) {
2974 if (str < end)
2975 *str = ' ';
2976 ++str;
2977 }
2978 }
2979 c = (unsigned char) get_arg(char);
2980 if (str < end)
2981 *str = c;
2982 ++str;
2983 while (--spec.field_width > 0) {
2984 if (str < end)
2985 *str = ' ';
2986 ++str;
2987 }
2988 break;
2989 }
2990
2991 case FORMAT_TYPE_STR: {
2992 const char *str_arg = args;
2993 args += strlen(str_arg) + 1;
2994 str = string(str, end, (char *)str_arg, spec);
2995 break;
2996 }
2997
2998 case FORMAT_TYPE_PTR: {
2999 bool process = false;
3000 int copy, len;
3001
3002 switch (*fmt) {
3003 case 'S':
3004 case 's':
3005 case 'F':
3006 case 'f':
3007 case 'x':
3008 case 'K':
3009 process = true;
3010 break;
3011 default:
3012 if (!isalnum(*fmt)) {
3013 process = true;
3014 break;
3015 }
3016
3017 if (str < end) {
3018 len = copy = strlen(args);
3019 if (copy > end - str)
3020 copy = end - str;
3021 memcpy(str, args, copy);
3022 str += len;
3023 args += len + 1;
3024 }
3025 }
3026 if (process)
3027 str = pointer(fmt, str, end, get_arg(void *), spec);
3028
3029 while (isalnum(*fmt))
3030 fmt++;
3031 break;
3032 }
3033
3034 case FORMAT_TYPE_PERCENT_CHAR:
3035 if (str < end)
3036 *str = '%';
3037 ++str;
3038 break;
3039
3040 case FORMAT_TYPE_INVALID:
3041 goto out;
3042
3043 default: {
3044 unsigned long long num;
3045
3046 switch (spec.type) {
3047
3048 case FORMAT_TYPE_LONG_LONG:
3049 num = get_arg(long long);
3050 break;
3051 case FORMAT_TYPE_ULONG:
3052 case FORMAT_TYPE_LONG:
3053 num = get_arg(unsigned long);
3054 break;
3055 case FORMAT_TYPE_SIZE_T:
3056 num = get_arg(size_t);
3057 break;
3058 case FORMAT_TYPE_PTRDIFF:
3059 num = get_arg(ptrdiff_t);
3060 break;
3061 case FORMAT_TYPE_UBYTE:
3062 num = get_arg(unsigned char);
3063 break;
3064 case FORMAT_TYPE_BYTE:
3065 num = get_arg(signed char);
3066 break;
3067 case FORMAT_TYPE_USHORT:
3068 num = get_arg(unsigned short);
3069 break;
3070 case FORMAT_TYPE_SHORT:
3071 num = get_arg(short);
3072 break;
3073 case FORMAT_TYPE_UINT:
3074 num = get_arg(unsigned int);
3075 break;
3076 default:
3077 num = get_arg(int);
3078 }
3079
3080 str = number(str, end, num, spec);
3081 }
3082 }
3083 }
3084
3085 out:
3086 if (size > 0) {
3087 if (str < end)
3088 *str = '\0';
3089 else
3090 end[-1] = '\0';
3091 }
3092
3093 #undef get_arg
3094
3095
3096 return str - buf;
3097 }
3098 EXPORT_SYMBOL_GPL(bstr_printf);
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110 int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
3111 {
3112 va_list args;
3113 int ret;
3114
3115 va_start(args, fmt);
3116 ret = vbin_printf(bin_buf, size, fmt, args);
3117 va_end(args);
3118
3119 return ret;
3120 }
3121 EXPORT_SYMBOL_GPL(bprintf);
3122
3123 #endif
3124
3125
3126
3127
3128
3129
3130
3131 int vsscanf(const char *buf, const char *fmt, va_list args)
3132 {
3133 const char *str = buf;
3134 char *next;
3135 char digit;
3136 int num = 0;
3137 u8 qualifier;
3138 unsigned int base;
3139 union {
3140 long long s;
3141 unsigned long long u;
3142 } val;
3143 s16 field_width;
3144 bool is_sign;
3145
3146 while (*fmt) {
3147
3148
3149
3150
3151 if (isspace(*fmt)) {
3152 fmt = skip_spaces(++fmt);
3153 str = skip_spaces(str);
3154 }
3155
3156
3157 if (*fmt != '%' && *fmt) {
3158 if (*fmt++ != *str++)
3159 break;
3160 continue;
3161 }
3162
3163 if (!*fmt)
3164 break;
3165 ++fmt;
3166
3167
3168
3169
3170 if (*fmt == '*') {
3171 if (!*str)
3172 break;
3173 while (!isspace(*fmt) && *fmt != '%' && *fmt) {
3174
3175 if (*fmt == '[')
3176 return num;
3177 fmt++;
3178 }
3179 while (!isspace(*str) && *str)
3180 str++;
3181 continue;
3182 }
3183
3184
3185 field_width = -1;
3186 if (isdigit(*fmt)) {
3187 field_width = skip_atoi(&fmt);
3188 if (field_width <= 0)
3189 break;
3190 }
3191
3192
3193 qualifier = -1;
3194 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
3195 *fmt == 'z') {
3196 qualifier = *fmt++;
3197 if (unlikely(qualifier == *fmt)) {
3198 if (qualifier == 'h') {
3199 qualifier = 'H';
3200 fmt++;
3201 } else if (qualifier == 'l') {
3202 qualifier = 'L';
3203 fmt++;
3204 }
3205 }
3206 }
3207
3208 if (!*fmt)
3209 break;
3210
3211 if (*fmt == 'n') {
3212
3213 *va_arg(args, int *) = str - buf;
3214 ++fmt;
3215 continue;
3216 }
3217
3218 if (!*str)
3219 break;
3220
3221 base = 10;
3222 is_sign = false;
3223
3224 switch (*fmt++) {
3225 case 'c':
3226 {
3227 char *s = (char *)va_arg(args, char*);
3228 if (field_width == -1)
3229 field_width = 1;
3230 do {
3231 *s++ = *str++;
3232 } while (--field_width > 0 && *str);
3233 num++;
3234 }
3235 continue;
3236 case 's':
3237 {
3238 char *s = (char *)va_arg(args, char *);
3239 if (field_width == -1)
3240 field_width = SHRT_MAX;
3241
3242 str = skip_spaces(str);
3243
3244
3245 while (*str && !isspace(*str) && field_width--)
3246 *s++ = *str++;
3247 *s = '\0';
3248 num++;
3249 }
3250 continue;
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266 case '[':
3267 {
3268 char *s = (char *)va_arg(args, char *);
3269 DECLARE_BITMAP(set, 256) = {0};
3270 unsigned int len = 0;
3271 bool negate = (*fmt == '^');
3272
3273
3274 if (field_width == -1)
3275 return num;
3276
3277 if (negate)
3278 ++fmt;
3279
3280 for ( ; *fmt && *fmt != ']'; ++fmt, ++len)
3281 set_bit((u8)*fmt, set);
3282
3283
3284 if (!*fmt || !len)
3285 return num;
3286 ++fmt;
3287
3288 if (negate) {
3289 bitmap_complement(set, set, 256);
3290
3291 clear_bit(0, set);
3292 }
3293
3294
3295 if (!test_bit((u8)*str, set))
3296 return num;
3297
3298 while (test_bit((u8)*str, set) && field_width--)
3299 *s++ = *str++;
3300 *s = '\0';
3301 ++num;
3302 }
3303 continue;
3304 case 'o':
3305 base = 8;
3306 break;
3307 case 'x':
3308 case 'X':
3309 base = 16;
3310 break;
3311 case 'i':
3312 base = 0;
3313
3314 case 'd':
3315 is_sign = true;
3316
3317 case 'u':
3318 break;
3319 case '%':
3320
3321 if (*str++ != '%')
3322 return num;
3323 continue;
3324 default:
3325
3326 return num;
3327 }
3328
3329
3330
3331
3332 str = skip_spaces(str);
3333
3334 digit = *str;
3335 if (is_sign && digit == '-')
3336 digit = *(str + 1);
3337
3338 if (!digit
3339 || (base == 16 && !isxdigit(digit))
3340 || (base == 10 && !isdigit(digit))
3341 || (base == 8 && (!isdigit(digit) || digit > '7'))
3342 || (base == 0 && !isdigit(digit)))
3343 break;
3344
3345 if (is_sign)
3346 val.s = qualifier != 'L' ?
3347 simple_strtol(str, &next, base) :
3348 simple_strtoll(str, &next, base);
3349 else
3350 val.u = qualifier != 'L' ?
3351 simple_strtoul(str, &next, base) :
3352 simple_strtoull(str, &next, base);
3353
3354 if (field_width > 0 && next - str > field_width) {
3355 if (base == 0)
3356 _parse_integer_fixup_radix(str, &base);
3357 while (next - str > field_width) {
3358 if (is_sign)
3359 val.s = div_s64(val.s, base);
3360 else
3361 val.u = div_u64(val.u, base);
3362 --next;
3363 }
3364 }
3365
3366 switch (qualifier) {
3367 case 'H':
3368 if (is_sign)
3369 *va_arg(args, signed char *) = val.s;
3370 else
3371 *va_arg(args, unsigned char *) = val.u;
3372 break;
3373 case 'h':
3374 if (is_sign)
3375 *va_arg(args, short *) = val.s;
3376 else
3377 *va_arg(args, unsigned short *) = val.u;
3378 break;
3379 case 'l':
3380 if (is_sign)
3381 *va_arg(args, long *) = val.s;
3382 else
3383 *va_arg(args, unsigned long *) = val.u;
3384 break;
3385 case 'L':
3386 if (is_sign)
3387 *va_arg(args, long long *) = val.s;
3388 else
3389 *va_arg(args, unsigned long long *) = val.u;
3390 break;
3391 case 'z':
3392 *va_arg(args, size_t *) = val.u;
3393 break;
3394 default:
3395 if (is_sign)
3396 *va_arg(args, int *) = val.s;
3397 else
3398 *va_arg(args, unsigned int *) = val.u;
3399 break;
3400 }
3401 num++;
3402
3403 if (!next)
3404 break;
3405 str = next;
3406 }
3407
3408 return num;
3409 }
3410 EXPORT_SYMBOL(vsscanf);
3411
3412
3413
3414
3415
3416
3417
3418 int sscanf(const char *buf, const char *fmt, ...)
3419 {
3420 va_list args;
3421 int i;
3422
3423 va_start(args, fmt);
3424 i = vsscanf(buf, fmt, args);
3425 va_end(args);
3426
3427 return i;
3428 }
3429 EXPORT_SYMBOL(sscanf);