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