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/module.h>
21#include <linux/types.h>
22#include <linux/string.h>
23#include <linux/ctype.h>
24#include <linux/kernel.h>
25#include <linux/kallsyms.h>
26#include <linux/math64.h>
27#include <linux/uaccess.h>
28#include <linux/ioport.h>
29#include <linux/dcache.h>
30#include <net/addrconf.h>
31
32#include <asm/page.h>
33#include <asm/sections.h>
34
35#include "kstrtox.h"
36
37
38
39
40
41
42
43
44
45unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base)
46{
47 unsigned long long result;
48 unsigned int rv;
49
50 cp = _parse_integer_fixup_radix(cp, &base);
51 rv = _parse_integer(cp, base, &result);
52
53 cp += (rv & ~KSTRTOX_OVERFLOW);
54
55 if (endp)
56 *endp = (char *)cp;
57
58 return result;
59}
60EXPORT_SYMBOL(simple_strtoull);
61
62
63
64
65
66
67
68
69
70unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base)
71{
72 return simple_strtoull(cp, endp, base);
73}
74EXPORT_SYMBOL(simple_strtoul);
75
76
77
78
79
80
81
82
83
84long simple_strtol(const char *cp, char **endp, unsigned int base)
85{
86 if (*cp == '-')
87 return -simple_strtoul(cp + 1, endp, base);
88
89 return simple_strtoul(cp, endp, base);
90}
91EXPORT_SYMBOL(simple_strtol);
92
93
94
95
96
97
98
99
100
101long long simple_strtoll(const char *cp, char **endp, unsigned int base)
102{
103 if (*cp == '-')
104 return -simple_strtoull(cp + 1, endp, base);
105
106 return simple_strtoull(cp, endp, base);
107}
108EXPORT_SYMBOL(simple_strtoll);
109
110static noinline_for_stack
111int skip_atoi(const char **s)
112{
113 int i = 0;
114
115 while (isdigit(**s))
116 i = i*10 + *((*s)++) - '0';
117
118 return i;
119}
120
121
122
123
124
125
126
127
128#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
129
130static noinline_for_stack
131char *put_dec_full9(char *buf, unsigned q)
132{
133 unsigned r;
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154 r = (q * (uint64_t)0x1999999a) >> 32;
155 *buf++ = (q - 10 * r) + '0';
156 q = (r * (uint64_t)0x1999999a) >> 32;
157 *buf++ = (r - 10 * q) + '0';
158 r = (q * (uint64_t)0x1999999a) >> 32;
159 *buf++ = (q - 10 * r) + '0';
160 q = (r * (uint64_t)0x1999999a) >> 32;
161 *buf++ = (r - 10 * q) + '0';
162 r = (q * (uint64_t)0x1999999a) >> 32;
163 *buf++ = (q - 10 * r) + '0';
164
165 q = (r * 0x199a) >> 16;
166 *buf++ = (r - 10 * q) + '0';
167 r = (q * 0xcd) >> 11;
168 *buf++ = (q - 10 * r) + '0';
169 q = (r * 0xcd) >> 11;
170 *buf++ = (r - 10 * q) + '0';
171 *buf++ = q + '0';
172 return buf;
173}
174#endif
175
176
177
178
179
180static noinline_for_stack
181char *put_dec_trunc8(char *buf, unsigned r)
182{
183 unsigned q;
184
185
186 while (r >= 10000) {
187 q = r + '0';
188 r = (r * (uint64_t)0x1999999a) >> 32;
189 *buf++ = q - 10*r;
190 }
191
192 q = (r * 0x199a) >> 16;
193 *buf++ = (r - 10 * q) + '0';
194 if (q == 0)
195 return buf;
196 r = (q * 0xcd) >> 11;
197 *buf++ = (q - 10 * r) + '0';
198 if (r == 0)
199 return buf;
200 q = (r * 0xcd) >> 11;
201 *buf++ = (r - 10 * q) + '0';
202 if (q == 0)
203 return buf;
204 *buf++ = q + '0';
205 return buf;
206}
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225#if BITS_PER_LONG != 32 || BITS_PER_LONG_LONG != 64
226
227
228
229static
230char *put_dec(char *buf, unsigned long long n)
231{
232 if (n >= 100*1000*1000) {
233 while (n >= 1000*1000*1000)
234 buf = put_dec_full9(buf, do_div(n, 1000*1000*1000));
235 if (n >= 100*1000*1000)
236 return put_dec_full9(buf, n);
237 }
238 return put_dec_trunc8(buf, n);
239}
240
241#else
242
243
244
245
246static noinline_for_stack
247void put_dec_full4(char *buf, unsigned q)
248{
249 unsigned r;
250 r = (q * 0xccd) >> 15;
251 buf[0] = (q - 10 * r) + '0';
252 q = (r * 0xcd) >> 11;
253 buf[1] = (r - 10 * q) + '0';
254 r = (q * 0xcd) >> 11;
255 buf[2] = (q - 10 * r) + '0';
256 buf[3] = r + '0';
257}
258
259
260
261
262
263
264
265
266static
267unsigned put_dec_helper4(char *buf, unsigned x)
268{
269 uint32_t q = (x * (uint64_t)0x346DC5D7) >> 43;
270
271 put_dec_full4(buf, x - q * 10000);
272 return q;
273}
274
275
276
277
278
279
280static
281char *put_dec(char *buf, unsigned long long n)
282{
283 uint32_t d3, d2, d1, q, h;
284
285 if (n < 100*1000*1000)
286 return put_dec_trunc8(buf, n);
287
288 d1 = ((uint32_t)n >> 16);
289 h = (n >> 32);
290 d2 = (h ) & 0xffff;
291 d3 = (h >> 16);
292
293 q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff);
294 q = put_dec_helper4(buf, q);
295
296 q += 7671 * d3 + 9496 * d2 + 6 * d1;
297 q = put_dec_helper4(buf+4, q);
298
299 q += 4749 * d3 + 42 * d2;
300 q = put_dec_helper4(buf+8, q);
301
302 q += 281 * d3;
303 buf += 12;
304 if (q)
305 buf = put_dec_trunc8(buf, q);
306 else while (buf[-1] == '0')
307 --buf;
308
309 return buf;
310}
311
312#endif
313
314
315
316
317
318
319
320int num_to_str(char *buf, int size, unsigned long long num)
321{
322 char tmp[sizeof(num) * 3];
323 int idx, len;
324
325
326 if (num <= 9) {
327 tmp[0] = '0' + num;
328 len = 1;
329 } else {
330 len = put_dec(tmp, num) - tmp;
331 }
332
333 if (len > size)
334 return 0;
335 for (idx = 0; idx < len; ++idx)
336 buf[idx] = tmp[len - idx - 1];
337 return len;
338}
339
340#define ZEROPAD 1
341#define SIGN 2
342#define PLUS 4
343#define SPACE 8
344#define LEFT 16
345#define SMALL 32
346#define SPECIAL 64
347
348enum format_type {
349 FORMAT_TYPE_NONE,
350 FORMAT_TYPE_WIDTH,
351 FORMAT_TYPE_PRECISION,
352 FORMAT_TYPE_CHAR,
353 FORMAT_TYPE_STR,
354 FORMAT_TYPE_PTR,
355 FORMAT_TYPE_PERCENT_CHAR,
356 FORMAT_TYPE_INVALID,
357 FORMAT_TYPE_LONG_LONG,
358 FORMAT_TYPE_ULONG,
359 FORMAT_TYPE_LONG,
360 FORMAT_TYPE_UBYTE,
361 FORMAT_TYPE_BYTE,
362 FORMAT_TYPE_USHORT,
363 FORMAT_TYPE_SHORT,
364 FORMAT_TYPE_UINT,
365 FORMAT_TYPE_INT,
366 FORMAT_TYPE_NRCHARS,
367 FORMAT_TYPE_SIZE_T,
368 FORMAT_TYPE_PTRDIFF
369};
370
371struct printf_spec {
372 u8 type;
373 u8 flags;
374 u8 base;
375 u8 qualifier;
376 s16 field_width;
377 s16 precision;
378};
379
380static noinline_for_stack
381char *number(char *buf, char *end, unsigned long long num,
382 struct printf_spec spec)
383{
384
385 static const char digits[16] = "0123456789ABCDEF";
386
387 char tmp[66];
388 char sign;
389 char locase;
390 int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10);
391 int i;
392 bool is_zero = num == 0LL;
393
394
395
396 locase = (spec.flags & SMALL);
397 if (spec.flags & LEFT)
398 spec.flags &= ~ZEROPAD;
399 sign = 0;
400 if (spec.flags & SIGN) {
401 if ((signed long long)num < 0) {
402 sign = '-';
403 num = -(signed long long)num;
404 spec.field_width--;
405 } else if (spec.flags & PLUS) {
406 sign = '+';
407 spec.field_width--;
408 } else if (spec.flags & SPACE) {
409 sign = ' ';
410 spec.field_width--;
411 }
412 }
413 if (need_pfx) {
414 if (spec.base == 16)
415 spec.field_width -= 2;
416 else if (!is_zero)
417 spec.field_width--;
418 }
419
420
421 i = 0;
422 if (num < spec.base)
423 tmp[i++] = digits[num] | locase;
424
425
426
427
428
429 else if (spec.base != 10) {
430 int mask = spec.base - 1;
431 int shift = 3;
432
433 if (spec.base == 16)
434 shift = 4;
435 do {
436 tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
437 num >>= shift;
438 } while (num);
439 } else {
440 i = put_dec(tmp, num) - tmp;
441 }
442
443
444 if (i > spec.precision)
445 spec.precision = i;
446
447 spec.field_width -= spec.precision;
448 if (!(spec.flags & (ZEROPAD+LEFT))) {
449 while (--spec.field_width >= 0) {
450 if (buf < end)
451 *buf = ' ';
452 ++buf;
453 }
454 }
455
456 if (sign) {
457 if (buf < end)
458 *buf = sign;
459 ++buf;
460 }
461
462 if (need_pfx) {
463 if (spec.base == 16 || !is_zero) {
464 if (buf < end)
465 *buf = '0';
466 ++buf;
467 }
468 if (spec.base == 16) {
469 if (buf < end)
470 *buf = ('X' | locase);
471 ++buf;
472 }
473 }
474
475 if (!(spec.flags & LEFT)) {
476 char c = (spec.flags & ZEROPAD) ? '0' : ' ';
477 while (--spec.field_width >= 0) {
478 if (buf < end)
479 *buf = c;
480 ++buf;
481 }
482 }
483
484 while (i <= --spec.precision) {
485 if (buf < end)
486 *buf = '0';
487 ++buf;
488 }
489
490 while (--i >= 0) {
491 if (buf < end)
492 *buf = tmp[i];
493 ++buf;
494 }
495
496 while (--spec.field_width >= 0) {
497 if (buf < end)
498 *buf = ' ';
499 ++buf;
500 }
501
502 return buf;
503}
504
505static noinline_for_stack
506char *string(char *buf, char *end, const char *s, struct printf_spec spec)
507{
508 int len, i;
509
510 if ((unsigned long)s < PAGE_SIZE)
511 s = "(null)";
512
513 len = strnlen(s, spec.precision);
514
515 if (!(spec.flags & LEFT)) {
516 while (len < spec.field_width--) {
517 if (buf < end)
518 *buf = ' ';
519 ++buf;
520 }
521 }
522 for (i = 0; i < len; ++i) {
523 if (buf < end)
524 *buf = *s;
525 ++buf; ++s;
526 }
527 while (len < spec.field_width--) {
528 if (buf < end)
529 *buf = ' ';
530 ++buf;
531 }
532
533 return buf;
534}
535
536static void widen(char *buf, char *end, unsigned len, unsigned spaces)
537{
538 size_t size;
539 if (buf >= end)
540 return;
541 size = end - buf;
542 if (size <= spaces) {
543 memset(buf, ' ', size);
544 return;
545 }
546 if (len) {
547 if (len > size - spaces)
548 len = size - spaces;
549 memmove(buf + spaces, buf, len);
550 }
551 memset(buf, ' ', spaces);
552}
553
554static noinline_for_stack
555char *dentry_name(char *buf, char *end, const struct dentry *d, struct printf_spec spec,
556 const char *fmt)
557{
558 const char *array[4], *s;
559 const struct dentry *p;
560 int depth;
561 int i, n;
562
563 switch (fmt[1]) {
564 case '2': case '3': case '4':
565 depth = fmt[1] - '0';
566 break;
567 default:
568 depth = 1;
569 }
570
571 rcu_read_lock();
572 for (i = 0; i < depth; i++, d = p) {
573 p = ACCESS_ONCE(d->d_parent);
574 array[i] = ACCESS_ONCE(d->d_name.name);
575 if (p == d) {
576 if (i)
577 array[i] = "";
578 i++;
579 break;
580 }
581 }
582 s = array[--i];
583 for (n = 0; n != spec.precision; n++, buf++) {
584 char c = *s++;
585 if (!c) {
586 if (!i)
587 break;
588 c = '/';
589 s = array[--i];
590 }
591 if (buf < end)
592 *buf = c;
593 }
594 rcu_read_unlock();
595 if (n < spec.field_width) {
596
597 unsigned spaces = spec.field_width - n;
598 if (!(spec.flags & LEFT)) {
599 widen(buf - n, end, n, spaces);
600 return buf + spaces;
601 }
602 while (spaces--) {
603 if (buf < end)
604 *buf = ' ';
605 ++buf;
606 }
607 }
608 return buf;
609}
610
611static noinline_for_stack
612char *symbol_string(char *buf, char *end, void *ptr,
613 struct printf_spec spec, const char *fmt)
614{
615 unsigned long value;
616#ifdef CONFIG_KALLSYMS
617 char sym[KSYM_SYMBOL_LEN];
618#endif
619
620 if (fmt[1] == 'R')
621 ptr = __builtin_extract_return_addr(ptr);
622 value = (unsigned long)ptr;
623
624#ifdef CONFIG_KALLSYMS
625 if (*fmt == 'B')
626 sprint_backtrace(sym, value);
627 else if (*fmt != 'f' && *fmt != 's')
628 sprint_symbol(sym, value);
629 else
630 sprint_symbol_no_offset(sym, value);
631
632 return string(buf, end, sym, spec);
633#else
634 spec.field_width = 2 * sizeof(void *);
635 spec.flags |= SPECIAL | SMALL | ZEROPAD;
636 spec.base = 16;
637
638 return number(buf, end, value, spec);
639#endif
640}
641
642static noinline_for_stack
643char *resource_string(char *buf, char *end, struct resource *res,
644 struct printf_spec spec, const char *fmt)
645{
646#ifndef IO_RSRC_PRINTK_SIZE
647#define IO_RSRC_PRINTK_SIZE 6
648#endif
649
650#ifndef MEM_RSRC_PRINTK_SIZE
651#define MEM_RSRC_PRINTK_SIZE 10
652#endif
653 static const struct printf_spec io_spec = {
654 .base = 16,
655 .field_width = IO_RSRC_PRINTK_SIZE,
656 .precision = -1,
657 .flags = SPECIAL | SMALL | ZEROPAD,
658 };
659 static const struct printf_spec mem_spec = {
660 .base = 16,
661 .field_width = MEM_RSRC_PRINTK_SIZE,
662 .precision = -1,
663 .flags = SPECIAL | SMALL | ZEROPAD,
664 };
665 static const struct printf_spec bus_spec = {
666 .base = 16,
667 .field_width = 2,
668 .precision = -1,
669 .flags = SMALL | ZEROPAD,
670 };
671 static const struct printf_spec dec_spec = {
672 .base = 10,
673 .precision = -1,
674 .flags = 0,
675 };
676 static const struct printf_spec str_spec = {
677 .field_width = -1,
678 .precision = 10,
679 .flags = LEFT,
680 };
681 static const struct printf_spec flag_spec = {
682 .base = 16,
683 .precision = -1,
684 .flags = SPECIAL | SMALL,
685 };
686
687
688
689#define RSRC_BUF_SIZE ((2 * sizeof(resource_size_t)) + 4)
690#define FLAG_BUF_SIZE (2 * sizeof(res->flags))
691#define DECODED_BUF_SIZE sizeof("[mem - 64bit pref window disabled]")
692#define RAW_BUF_SIZE sizeof("[mem - flags 0x]")
693 char sym[max(2*RSRC_BUF_SIZE + DECODED_BUF_SIZE,
694 2*RSRC_BUF_SIZE + FLAG_BUF_SIZE + RAW_BUF_SIZE)];
695
696 char *p = sym, *pend = sym + sizeof(sym);
697 int decode = (fmt[0] == 'R') ? 1 : 0;
698 const struct printf_spec *specp;
699
700 *p++ = '[';
701 if (res->flags & IORESOURCE_IO) {
702 p = string(p, pend, "io ", str_spec);
703 specp = &io_spec;
704 } else if (res->flags & IORESOURCE_MEM) {
705 p = string(p, pend, "mem ", str_spec);
706 specp = &mem_spec;
707 } else if (res->flags & IORESOURCE_IRQ) {
708 p = string(p, pend, "irq ", str_spec);
709 specp = &dec_spec;
710 } else if (res->flags & IORESOURCE_DMA) {
711 p = string(p, pend, "dma ", str_spec);
712 specp = &dec_spec;
713 } else if (res->flags & IORESOURCE_BUS) {
714 p = string(p, pend, "bus ", str_spec);
715 specp = &bus_spec;
716 } else {
717 p = string(p, pend, "??? ", str_spec);
718 specp = &mem_spec;
719 decode = 0;
720 }
721 p = number(p, pend, res->start, *specp);
722 if (res->start != res->end) {
723 *p++ = '-';
724 p = number(p, pend, res->end, *specp);
725 }
726 if (decode) {
727 if (res->flags & IORESOURCE_MEM_64)
728 p = string(p, pend, " 64bit", str_spec);
729 if (res->flags & IORESOURCE_PREFETCH)
730 p = string(p, pend, " pref", str_spec);
731 if (res->flags & IORESOURCE_WINDOW)
732 p = string(p, pend, " window", str_spec);
733 if (res->flags & IORESOURCE_DISABLED)
734 p = string(p, pend, " disabled", str_spec);
735 } else {
736 p = string(p, pend, " flags ", str_spec);
737 p = number(p, pend, res->flags, flag_spec);
738 }
739 *p++ = ']';
740 *p = '\0';
741
742 return string(buf, end, sym, spec);
743}
744
745static noinline_for_stack
746char *hex_string(char *buf, char *end, u8 *addr, struct printf_spec spec,
747 const char *fmt)
748{
749 int i, len = 1;
750
751 char separator;
752
753 if (spec.field_width == 0)
754
755 return buf;
756
757 if (ZERO_OR_NULL_PTR(addr))
758
759 return string(buf, end, NULL, spec);
760
761 switch (fmt[1]) {
762 case 'C':
763 separator = ':';
764 break;
765 case 'D':
766 separator = '-';
767 break;
768 case 'N':
769 separator = 0;
770 break;
771 default:
772 separator = ' ';
773 break;
774 }
775
776 if (spec.field_width > 0)
777 len = min_t(int, spec.field_width, 64);
778
779 for (i = 0; i < len && buf < end - 1; i++) {
780 buf = hex_byte_pack(buf, addr[i]);
781
782 if (buf < end && separator && i != len - 1)
783 *buf++ = separator;
784 }
785
786 return buf;
787}
788
789static noinline_for_stack
790char *mac_address_string(char *buf, char *end, u8 *addr,
791 struct printf_spec spec, const char *fmt)
792{
793 char mac_addr[sizeof("xx:xx:xx:xx:xx:xx")];
794 char *p = mac_addr;
795 int i;
796 char separator;
797 bool reversed = false;
798
799 switch (fmt[1]) {
800 case 'F':
801 separator = '-';
802 break;
803
804 case 'R':
805 reversed = true;
806
807
808 default:
809 separator = ':';
810 break;
811 }
812
813 for (i = 0; i < 6; i++) {
814 if (reversed)
815 p = hex_byte_pack(p, addr[5 - i]);
816 else
817 p = hex_byte_pack(p, addr[i]);
818
819 if (fmt[0] == 'M' && i != 5)
820 *p++ = separator;
821 }
822 *p = '\0';
823
824 return string(buf, end, mac_addr, spec);
825}
826
827static noinline_for_stack
828char *ip4_string(char *p, const u8 *addr, const char *fmt)
829{
830 int i;
831 bool leading_zeros = (fmt[0] == 'i');
832 int index;
833 int step;
834
835 switch (fmt[2]) {
836 case 'h':
837#ifdef __BIG_ENDIAN
838 index = 0;
839 step = 1;
840#else
841 index = 3;
842 step = -1;
843#endif
844 break;
845 case 'l':
846 index = 3;
847 step = -1;
848 break;
849 case 'n':
850 case 'b':
851 default:
852 index = 0;
853 step = 1;
854 break;
855 }
856 for (i = 0; i < 4; i++) {
857 char temp[3];
858 int digits = put_dec_trunc8(temp, addr[index]) - temp;
859 if (leading_zeros) {
860 if (digits < 3)
861 *p++ = '0';
862 if (digits < 2)
863 *p++ = '0';
864 }
865
866 while (digits--)
867 *p++ = temp[digits];
868 if (i < 3)
869 *p++ = '.';
870 index += step;
871 }
872 *p = '\0';
873
874 return p;
875}
876
877static noinline_for_stack
878char *ip6_compressed_string(char *p, const char *addr)
879{
880 int i, j, range;
881 unsigned char zerolength[8];
882 int longest = 1;
883 int colonpos = -1;
884 u16 word;
885 u8 hi, lo;
886 bool needcolon = false;
887 bool useIPv4;
888 struct in6_addr in6;
889
890 memcpy(&in6, addr, sizeof(struct in6_addr));
891
892 useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
893
894 memset(zerolength, 0, sizeof(zerolength));
895
896 if (useIPv4)
897 range = 6;
898 else
899 range = 8;
900
901
902 for (i = 0; i < range; i++) {
903 for (j = i; j < range; j++) {
904 if (in6.s6_addr16[j] != 0)
905 break;
906 zerolength[i]++;
907 }
908 }
909 for (i = 0; i < range; i++) {
910 if (zerolength[i] > longest) {
911 longest = zerolength[i];
912 colonpos = i;
913 }
914 }
915 if (longest == 1)
916 colonpos = -1;
917
918
919 for (i = 0; i < range; i++) {
920 if (i == colonpos) {
921 if (needcolon || i == 0)
922 *p++ = ':';
923 *p++ = ':';
924 needcolon = false;
925 i += longest - 1;
926 continue;
927 }
928 if (needcolon) {
929 *p++ = ':';
930 needcolon = false;
931 }
932
933 word = ntohs(in6.s6_addr16[i]);
934 hi = word >> 8;
935 lo = word & 0xff;
936 if (hi) {
937 if (hi > 0x0f)
938 p = hex_byte_pack(p, hi);
939 else
940 *p++ = hex_asc_lo(hi);
941 p = hex_byte_pack(p, lo);
942 }
943 else if (lo > 0x0f)
944 p = hex_byte_pack(p, lo);
945 else
946 *p++ = hex_asc_lo(lo);
947 needcolon = true;
948 }
949
950 if (useIPv4) {
951 if (needcolon)
952 *p++ = ':';
953 p = ip4_string(p, &in6.s6_addr[12], "I4");
954 }
955 *p = '\0';
956
957 return p;
958}
959
960static noinline_for_stack
961char *ip6_string(char *p, const char *addr, const char *fmt)
962{
963 int i;
964
965 for (i = 0; i < 8; i++) {
966 p = hex_byte_pack(p, *addr++);
967 p = hex_byte_pack(p, *addr++);
968 if (fmt[0] == 'I' && i != 7)
969 *p++ = ':';
970 }
971 *p = '\0';
972
973 return p;
974}
975
976static noinline_for_stack
977char *ip6_addr_string(char *buf, char *end, const u8 *addr,
978 struct printf_spec spec, const char *fmt)
979{
980 char ip6_addr[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
981
982 if (fmt[0] == 'I' && fmt[2] == 'c')
983 ip6_compressed_string(ip6_addr, addr);
984 else
985 ip6_string(ip6_addr, addr, fmt);
986
987 return string(buf, end, ip6_addr, spec);
988}
989
990static noinline_for_stack
991char *ip4_addr_string(char *buf, char *end, const u8 *addr,
992 struct printf_spec spec, const char *fmt)
993{
994 char ip4_addr[sizeof("255.255.255.255")];
995
996 ip4_string(ip4_addr, addr, fmt);
997
998 return string(buf, end, ip4_addr, spec);
999}
1000
1001static noinline_for_stack
1002char *ip6_addr_string_sa(char *buf, char *end, const struct sockaddr_in6 *sa,
1003 struct printf_spec spec, const char *fmt)
1004{
1005 bool have_p = false, have_s = false, have_f = false, have_c = false;
1006 char ip6_addr[sizeof("[xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255]") +
1007 sizeof(":12345") + sizeof("/123456789") +
1008 sizeof("%1234567890")];
1009 char *p = ip6_addr, *pend = ip6_addr + sizeof(ip6_addr);
1010 const u8 *addr = (const u8 *) &sa->sin6_addr;
1011 char fmt6[2] = { fmt[0], '6' };
1012 u8 off = 0;
1013
1014 fmt++;
1015 while (isalpha(*++fmt)) {
1016 switch (*fmt) {
1017 case 'p':
1018 have_p = true;
1019 break;
1020 case 'f':
1021 have_f = true;
1022 break;
1023 case 's':
1024 have_s = true;
1025 break;
1026 case 'c':
1027 have_c = true;
1028 break;
1029 }
1030 }
1031
1032 if (have_p || have_s || have_f) {
1033 *p = '[';
1034 off = 1;
1035 }
1036
1037 if (fmt6[0] == 'I' && have_c)
1038 p = ip6_compressed_string(ip6_addr + off, addr);
1039 else
1040 p = ip6_string(ip6_addr + off, addr, fmt6);
1041
1042 if (have_p || have_s || have_f)
1043 *p++ = ']';
1044
1045 if (have_p) {
1046 *p++ = ':';
1047 p = number(p, pend, ntohs(sa->sin6_port), spec);
1048 }
1049 if (have_f) {
1050 *p++ = '/';
1051 p = number(p, pend, ntohl(sa->sin6_flowinfo &
1052 IPV6_FLOWINFO_MASK), spec);
1053 }
1054 if (have_s) {
1055 *p++ = '%';
1056 p = number(p, pend, sa->sin6_scope_id, spec);
1057 }
1058 *p = '\0';
1059
1060 return string(buf, end, ip6_addr, spec);
1061}
1062
1063static noinline_for_stack
1064char *ip4_addr_string_sa(char *buf, char *end, const struct sockaddr_in *sa,
1065 struct printf_spec spec, const char *fmt)
1066{
1067 bool have_p = false;
1068 char *p, ip4_addr[sizeof("255.255.255.255") + sizeof(":12345")];
1069 char *pend = ip4_addr + sizeof(ip4_addr);
1070 const u8 *addr = (const u8 *) &sa->sin_addr.s_addr;
1071 char fmt4[3] = { fmt[0], '4', 0 };
1072
1073 fmt++;
1074 while (isalpha(*++fmt)) {
1075 switch (*fmt) {
1076 case 'p':
1077 have_p = true;
1078 break;
1079 case 'h':
1080 case 'l':
1081 case 'n':
1082 case 'b':
1083 fmt4[2] = *fmt;
1084 break;
1085 }
1086 }
1087
1088 p = ip4_string(ip4_addr, addr, fmt4);
1089 if (have_p) {
1090 *p++ = ':';
1091 p = number(p, pend, ntohs(sa->sin_port), spec);
1092 }
1093 *p = '\0';
1094
1095 return string(buf, end, ip4_addr, spec);
1096}
1097
1098static noinline_for_stack
1099char *uuid_string(char *buf, char *end, const u8 *addr,
1100 struct printf_spec spec, const char *fmt)
1101{
1102 char uuid[sizeof("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
1103 char *p = uuid;
1104 int i;
1105 static const u8 be[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
1106 static const u8 le[16] = {3,2,1,0,5,4,7,6,8,9,10,11,12,13,14,15};
1107 const u8 *index = be;
1108 bool uc = false;
1109
1110 switch (*(++fmt)) {
1111 case 'L':
1112 uc = true;
1113 case 'l':
1114 index = le;
1115 break;
1116 case 'B':
1117 uc = true;
1118 break;
1119 }
1120
1121 for (i = 0; i < 16; i++) {
1122 p = hex_byte_pack(p, addr[index[i]]);
1123 switch (i) {
1124 case 3:
1125 case 5:
1126 case 7:
1127 case 9:
1128 *p++ = '-';
1129 break;
1130 }
1131 }
1132
1133 *p = 0;
1134
1135 if (uc) {
1136 p = uuid;
1137 do {
1138 *p = toupper(*p);
1139 } while (*(++p));
1140 }
1141
1142 return string(buf, end, uuid, spec);
1143}
1144
1145static
1146char *netdev_feature_string(char *buf, char *end, const u8 *addr,
1147 struct printf_spec spec)
1148{
1149 spec.flags |= SPECIAL | SMALL | ZEROPAD;
1150 if (spec.field_width == -1)
1151 spec.field_width = 2 + 2 * sizeof(netdev_features_t);
1152 spec.base = 16;
1153
1154 return number(buf, end, *(const netdev_features_t *)addr, spec);
1155}
1156
1157int kptr_restrict __read_mostly;
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226static noinline_for_stack
1227char *pointer(const char *fmt, char *buf, char *end, void *ptr,
1228 struct printf_spec spec)
1229{
1230 int default_width = 2 * sizeof(void *) + (spec.flags & SPECIAL ? 2 : 0);
1231
1232 if (!ptr && *fmt != 'K') {
1233
1234
1235
1236
1237 if (spec.field_width == -1)
1238 spec.field_width = default_width;
1239 return string(buf, end, "(null)", spec);
1240 }
1241
1242 switch (*fmt) {
1243 case 'F':
1244 case 'f':
1245 ptr = dereference_function_descriptor(ptr);
1246
1247 case 'S':
1248 case 's':
1249 case 'B':
1250 return symbol_string(buf, end, ptr, spec, fmt);
1251 case 'R':
1252 case 'r':
1253 return resource_string(buf, end, ptr, spec, fmt);
1254 case 'h':
1255 return hex_string(buf, end, ptr, spec, fmt);
1256 case 'M':
1257 case 'm':
1258
1259
1260 return mac_address_string(buf, end, ptr, spec, fmt);
1261 case 'I':
1262
1263
1264
1265
1266 case 'i':
1267
1268
1269
1270 switch (fmt[1]) {
1271 case '6':
1272 return ip6_addr_string(buf, end, ptr, spec, fmt);
1273 case '4':
1274 return ip4_addr_string(buf, end, ptr, spec, fmt);
1275 case 'S': {
1276 const union {
1277 struct sockaddr raw;
1278 struct sockaddr_in v4;
1279 struct sockaddr_in6 v6;
1280 } *sa = ptr;
1281
1282 switch (sa->raw.sa_family) {
1283 case AF_INET:
1284 return ip4_addr_string_sa(buf, end, &sa->v4, spec, fmt);
1285 case AF_INET6:
1286 return ip6_addr_string_sa(buf, end, &sa->v6, spec, fmt);
1287 default:
1288 return string(buf, end, "(invalid address)", spec);
1289 }}
1290 }
1291 break;
1292 case 'U':
1293 return uuid_string(buf, end, ptr, spec, fmt);
1294 case 'V':
1295 {
1296 va_list va;
1297
1298 va_copy(va, *((struct va_format *)ptr)->va);
1299 buf += vsnprintf(buf, end > buf ? end - buf : 0,
1300 ((struct va_format *)ptr)->fmt, va);
1301 va_end(va);
1302 return buf;
1303 }
1304 case 'K':
1305
1306
1307
1308
1309 if (kptr_restrict && (in_irq() || in_serving_softirq() ||
1310 in_nmi())) {
1311 if (spec.field_width == -1)
1312 spec.field_width = default_width;
1313 return string(buf, end, "pK-error", spec);
1314 }
1315 if (!((kptr_restrict == 0) ||
1316 (kptr_restrict == 1 &&
1317 has_capability_noaudit(current, CAP_SYSLOG))))
1318 ptr = NULL;
1319 break;
1320 case 'N':
1321 switch (fmt[1]) {
1322 case 'F':
1323 return netdev_feature_string(buf, end, ptr, spec);
1324 }
1325 break;
1326 case 'a':
1327 spec.flags |= SPECIAL | SMALL | ZEROPAD;
1328 spec.field_width = sizeof(phys_addr_t) * 2 + 2;
1329 spec.base = 16;
1330 return number(buf, end,
1331 (unsigned long long) *((phys_addr_t *)ptr), spec);
1332 case 'd':
1333 return dentry_name(buf, end, ptr, spec, fmt);
1334 case 'D':
1335 return dentry_name(buf, end,
1336 ((const struct file *)ptr)->f_path.dentry,
1337 spec, fmt);
1338 }
1339 spec.flags |= SMALL;
1340 if (spec.field_width == -1) {
1341 spec.field_width = default_width;
1342 spec.flags |= ZEROPAD;
1343 }
1344 spec.base = 16;
1345
1346 return number(buf, end, (unsigned long) ptr, spec);
1347}
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369static noinline_for_stack
1370int format_decode(const char *fmt, struct printf_spec *spec)
1371{
1372 const char *start = fmt;
1373
1374
1375 if (spec->type == FORMAT_TYPE_WIDTH) {
1376 if (spec->field_width < 0) {
1377 spec->field_width = -spec->field_width;
1378 spec->flags |= LEFT;
1379 }
1380 spec->type = FORMAT_TYPE_NONE;
1381 goto precision;
1382 }
1383
1384
1385 if (spec->type == FORMAT_TYPE_PRECISION) {
1386 if (spec->precision < 0)
1387 spec->precision = 0;
1388
1389 spec->type = FORMAT_TYPE_NONE;
1390 goto qualifier;
1391 }
1392
1393
1394 spec->type = FORMAT_TYPE_NONE;
1395
1396 for (; *fmt ; ++fmt) {
1397 if (*fmt == '%')
1398 break;
1399 }
1400
1401
1402 if (fmt != start || !*fmt)
1403 return fmt - start;
1404
1405
1406 spec->flags = 0;
1407
1408 while (1) {
1409 bool found = true;
1410
1411 ++fmt;
1412
1413 switch (*fmt) {
1414 case '-': spec->flags |= LEFT; break;
1415 case '+': spec->flags |= PLUS; break;
1416 case ' ': spec->flags |= SPACE; break;
1417 case '#': spec->flags |= SPECIAL; break;
1418 case '0': spec->flags |= ZEROPAD; break;
1419 default: found = false;
1420 }
1421
1422 if (!found)
1423 break;
1424 }
1425
1426
1427 spec->field_width = -1;
1428
1429 if (isdigit(*fmt))
1430 spec->field_width = skip_atoi(&fmt);
1431 else if (*fmt == '*') {
1432
1433 spec->type = FORMAT_TYPE_WIDTH;
1434 return ++fmt - start;
1435 }
1436
1437precision:
1438
1439 spec->precision = -1;
1440 if (*fmt == '.') {
1441 ++fmt;
1442 if (isdigit(*fmt)) {
1443 spec->precision = skip_atoi(&fmt);
1444 if (spec->precision < 0)
1445 spec->precision = 0;
1446 } else if (*fmt == '*') {
1447
1448 spec->type = FORMAT_TYPE_PRECISION;
1449 return ++fmt - start;
1450 }
1451 }
1452
1453qualifier:
1454
1455 spec->qualifier = -1;
1456 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
1457 _tolower(*fmt) == 'z' || *fmt == 't') {
1458 spec->qualifier = *fmt++;
1459 if (unlikely(spec->qualifier == *fmt)) {
1460 if (spec->qualifier == 'l') {
1461 spec->qualifier = 'L';
1462 ++fmt;
1463 } else if (spec->qualifier == 'h') {
1464 spec->qualifier = 'H';
1465 ++fmt;
1466 }
1467 }
1468 }
1469
1470
1471 spec->base = 10;
1472 switch (*fmt) {
1473 case 'c':
1474 spec->type = FORMAT_TYPE_CHAR;
1475 return ++fmt - start;
1476
1477 case 's':
1478 spec->type = FORMAT_TYPE_STR;
1479 return ++fmt - start;
1480
1481 case 'p':
1482 spec->type = FORMAT_TYPE_PTR;
1483 return fmt - start;
1484
1485
1486 case 'n':
1487 spec->type = FORMAT_TYPE_NRCHARS;
1488 return ++fmt - start;
1489
1490 case '%':
1491 spec->type = FORMAT_TYPE_PERCENT_CHAR;
1492 return ++fmt - start;
1493
1494
1495 case 'o':
1496 spec->base = 8;
1497 break;
1498
1499 case 'x':
1500 spec->flags |= SMALL;
1501
1502 case 'X':
1503 spec->base = 16;
1504 break;
1505
1506 case 'd':
1507 case 'i':
1508 spec->flags |= SIGN;
1509 case 'u':
1510 break;
1511
1512 default:
1513 spec->type = FORMAT_TYPE_INVALID;
1514 return fmt - start;
1515 }
1516
1517 if (spec->qualifier == 'L')
1518 spec->type = FORMAT_TYPE_LONG_LONG;
1519 else if (spec->qualifier == 'l') {
1520 if (spec->flags & SIGN)
1521 spec->type = FORMAT_TYPE_LONG;
1522 else
1523 spec->type = FORMAT_TYPE_ULONG;
1524 } else if (_tolower(spec->qualifier) == 'z') {
1525 spec->type = FORMAT_TYPE_SIZE_T;
1526 } else if (spec->qualifier == 't') {
1527 spec->type = FORMAT_TYPE_PTRDIFF;
1528 } else if (spec->qualifier == 'H') {
1529 if (spec->flags & SIGN)
1530 spec->type = FORMAT_TYPE_BYTE;
1531 else
1532 spec->type = FORMAT_TYPE_UBYTE;
1533 } else if (spec->qualifier == 'h') {
1534 if (spec->flags & SIGN)
1535 spec->type = FORMAT_TYPE_SHORT;
1536 else
1537 spec->type = FORMAT_TYPE_USHORT;
1538 } else {
1539 if (spec->flags & SIGN)
1540 spec->type = FORMAT_TYPE_INT;
1541 else
1542 spec->type = FORMAT_TYPE_UINT;
1543 }
1544
1545 return ++fmt - start;
1546}
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
1594{
1595 unsigned long long num;
1596 char *str, *end;
1597 struct printf_spec spec = {0};
1598
1599
1600
1601 if (WARN_ON_ONCE((int) size < 0))
1602 return 0;
1603
1604 str = buf;
1605 end = buf + size;
1606
1607
1608 if (end < buf) {
1609 end = ((void *)-1);
1610 size = end - buf;
1611 }
1612
1613 while (*fmt) {
1614 const char *old_fmt = fmt;
1615 int read = format_decode(fmt, &spec);
1616
1617 fmt += read;
1618
1619 switch (spec.type) {
1620 case FORMAT_TYPE_NONE: {
1621 int copy = read;
1622 if (str < end) {
1623 if (copy > end - str)
1624 copy = end - str;
1625 memcpy(str, old_fmt, copy);
1626 }
1627 str += read;
1628 break;
1629 }
1630
1631 case FORMAT_TYPE_WIDTH:
1632 spec.field_width = va_arg(args, int);
1633 break;
1634
1635 case FORMAT_TYPE_PRECISION:
1636 spec.precision = va_arg(args, int);
1637 break;
1638
1639 case FORMAT_TYPE_CHAR: {
1640 char c;
1641
1642 if (!(spec.flags & LEFT)) {
1643 while (--spec.field_width > 0) {
1644 if (str < end)
1645 *str = ' ';
1646 ++str;
1647
1648 }
1649 }
1650 c = (unsigned char) va_arg(args, int);
1651 if (str < end)
1652 *str = c;
1653 ++str;
1654 while (--spec.field_width > 0) {
1655 if (str < end)
1656 *str = ' ';
1657 ++str;
1658 }
1659 break;
1660 }
1661
1662 case FORMAT_TYPE_STR:
1663 str = string(str, end, va_arg(args, char *), spec);
1664 break;
1665
1666 case FORMAT_TYPE_PTR:
1667 str = pointer(fmt+1, str, end, va_arg(args, void *),
1668 spec);
1669 while (isalnum(*fmt))
1670 fmt++;
1671 break;
1672
1673 case FORMAT_TYPE_PERCENT_CHAR:
1674 if (str < end)
1675 *str = '%';
1676 ++str;
1677 break;
1678
1679 case FORMAT_TYPE_INVALID:
1680 if (str < end)
1681 *str = '%';
1682 ++str;
1683 break;
1684
1685 case FORMAT_TYPE_NRCHARS: {
1686 u8 qualifier = spec.qualifier;
1687
1688 if (qualifier == 'l') {
1689 long *ip = va_arg(args, long *);
1690 *ip = (str - buf);
1691 } else if (_tolower(qualifier) == 'z') {
1692 size_t *ip = va_arg(args, size_t *);
1693 *ip = (str - buf);
1694 } else {
1695 int *ip = va_arg(args, int *);
1696 *ip = (str - buf);
1697 }
1698 break;
1699 }
1700
1701 default:
1702 switch (spec.type) {
1703 case FORMAT_TYPE_LONG_LONG:
1704 num = va_arg(args, long long);
1705 break;
1706 case FORMAT_TYPE_ULONG:
1707 num = va_arg(args, unsigned long);
1708 break;
1709 case FORMAT_TYPE_LONG:
1710 num = va_arg(args, long);
1711 break;
1712 case FORMAT_TYPE_SIZE_T:
1713 if (spec.flags & SIGN)
1714 num = va_arg(args, ssize_t);
1715 else
1716 num = va_arg(args, size_t);
1717 break;
1718 case FORMAT_TYPE_PTRDIFF:
1719 num = va_arg(args, ptrdiff_t);
1720 break;
1721 case FORMAT_TYPE_UBYTE:
1722 num = (unsigned char) va_arg(args, int);
1723 break;
1724 case FORMAT_TYPE_BYTE:
1725 num = (signed char) va_arg(args, int);
1726 break;
1727 case FORMAT_TYPE_USHORT:
1728 num = (unsigned short) va_arg(args, int);
1729 break;
1730 case FORMAT_TYPE_SHORT:
1731 num = (short) va_arg(args, int);
1732 break;
1733 case FORMAT_TYPE_INT:
1734 num = (int) va_arg(args, int);
1735 break;
1736 default:
1737 num = va_arg(args, unsigned int);
1738 }
1739
1740 str = number(str, end, num, spec);
1741 }
1742 }
1743
1744 if (size > 0) {
1745 if (str < end)
1746 *str = '\0';
1747 else
1748 end[-1] = '\0';
1749 }
1750
1751
1752 return str-buf;
1753
1754}
1755EXPORT_SYMBOL(vsnprintf);
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
1773{
1774 int i;
1775
1776 i = vsnprintf(buf, size, fmt, args);
1777
1778 if (likely(i < size))
1779 return i;
1780 if (size != 0)
1781 return size - 1;
1782 return 0;
1783}
1784EXPORT_SYMBOL(vscnprintf);
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800int snprintf(char *buf, size_t size, const char *fmt, ...)
1801{
1802 va_list args;
1803 int i;
1804
1805 va_start(args, fmt);
1806 i = vsnprintf(buf, size, fmt, args);
1807 va_end(args);
1808
1809 return i;
1810}
1811EXPORT_SYMBOL(snprintf);
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824int scnprintf(char *buf, size_t size, const char *fmt, ...)
1825{
1826 va_list args;
1827 int i;
1828
1829 va_start(args, fmt);
1830 i = vscnprintf(buf, size, fmt, args);
1831 va_end(args);
1832
1833 return i;
1834}
1835EXPORT_SYMBOL(scnprintf);
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851int vsprintf(char *buf, const char *fmt, va_list args)
1852{
1853 return vsnprintf(buf, INT_MAX, fmt, args);
1854}
1855EXPORT_SYMBOL(vsprintf);
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869int sprintf(char *buf, const char *fmt, ...)
1870{
1871 va_list args;
1872 int i;
1873
1874 va_start(args, fmt);
1875 i = vsnprintf(buf, INT_MAX, fmt, args);
1876 va_end(args);
1877
1878 return i;
1879}
1880EXPORT_SYMBOL(sprintf);
1881
1882#ifdef CONFIG_BINARY_PRINTF
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args)
1907{
1908 struct printf_spec spec = {0};
1909 char *str, *end;
1910
1911 str = (char *)bin_buf;
1912 end = (char *)(bin_buf + size);
1913
1914#define save_arg(type) \
1915do { \
1916 if (sizeof(type) == 8) { \
1917 unsigned long long value; \
1918 str = PTR_ALIGN(str, sizeof(u32)); \
1919 value = va_arg(args, unsigned long long); \
1920 if (str + sizeof(type) <= end) { \
1921 *(u32 *)str = *(u32 *)&value; \
1922 *(u32 *)(str + 4) = *((u32 *)&value + 1); \
1923 } \
1924 } else { \
1925 unsigned long value; \
1926 str = PTR_ALIGN(str, sizeof(type)); \
1927 value = va_arg(args, int); \
1928 if (str + sizeof(type) <= end) \
1929 *(typeof(type) *)str = (type)value; \
1930 } \
1931 str += sizeof(type); \
1932} while (0)
1933
1934 while (*fmt) {
1935 int read = format_decode(fmt, &spec);
1936
1937 fmt += read;
1938
1939 switch (spec.type) {
1940 case FORMAT_TYPE_NONE:
1941 case FORMAT_TYPE_INVALID:
1942 case FORMAT_TYPE_PERCENT_CHAR:
1943 break;
1944
1945 case FORMAT_TYPE_WIDTH:
1946 case FORMAT_TYPE_PRECISION:
1947 save_arg(int);
1948 break;
1949
1950 case FORMAT_TYPE_CHAR:
1951 save_arg(char);
1952 break;
1953
1954 case FORMAT_TYPE_STR: {
1955 const char *save_str = va_arg(args, char *);
1956 size_t len;
1957
1958 if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE
1959 || (unsigned long)save_str < PAGE_SIZE)
1960 save_str = "(null)";
1961 len = strlen(save_str) + 1;
1962 if (str + len < end)
1963 memcpy(str, save_str, len);
1964 str += len;
1965 break;
1966 }
1967
1968 case FORMAT_TYPE_PTR:
1969 save_arg(void *);
1970
1971 while (isalnum(*fmt))
1972 fmt++;
1973 break;
1974
1975 case FORMAT_TYPE_NRCHARS: {
1976
1977 u8 qualifier = spec.qualifier;
1978 void *skip_arg;
1979 if (qualifier == 'l')
1980 skip_arg = va_arg(args, long *);
1981 else if (_tolower(qualifier) == 'z')
1982 skip_arg = va_arg(args, size_t *);
1983 else
1984 skip_arg = va_arg(args, int *);
1985 break;
1986 }
1987
1988 default:
1989 switch (spec.type) {
1990
1991 case FORMAT_TYPE_LONG_LONG:
1992 save_arg(long long);
1993 break;
1994 case FORMAT_TYPE_ULONG:
1995 case FORMAT_TYPE_LONG:
1996 save_arg(unsigned long);
1997 break;
1998 case FORMAT_TYPE_SIZE_T:
1999 save_arg(size_t);
2000 break;
2001 case FORMAT_TYPE_PTRDIFF:
2002 save_arg(ptrdiff_t);
2003 break;
2004 case FORMAT_TYPE_UBYTE:
2005 case FORMAT_TYPE_BYTE:
2006 save_arg(char);
2007 break;
2008 case FORMAT_TYPE_USHORT:
2009 case FORMAT_TYPE_SHORT:
2010 save_arg(short);
2011 break;
2012 default:
2013 save_arg(int);
2014 }
2015 }
2016 }
2017
2018 return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf;
2019#undef save_arg
2020}
2021EXPORT_SYMBOL_GPL(vbin_printf);
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf)
2046{
2047 struct printf_spec spec = {0};
2048 char *str, *end;
2049 const char *args = (const char *)bin_buf;
2050
2051 if (WARN_ON_ONCE((int) size < 0))
2052 return 0;
2053
2054 str = buf;
2055 end = buf + size;
2056
2057#define get_arg(type) \
2058({ \
2059 typeof(type) value; \
2060 if (sizeof(type) == 8) { \
2061 args = PTR_ALIGN(args, sizeof(u32)); \
2062 *(u32 *)&value = *(u32 *)args; \
2063 *((u32 *)&value + 1) = *(u32 *)(args + 4); \
2064 } else { \
2065 args = PTR_ALIGN(args, sizeof(type)); \
2066 value = *(typeof(type) *)args; \
2067 } \
2068 args += sizeof(type); \
2069 value; \
2070})
2071
2072
2073 if (end < buf) {
2074 end = ((void *)-1);
2075 size = end - buf;
2076 }
2077
2078 while (*fmt) {
2079 const char *old_fmt = fmt;
2080 int read = format_decode(fmt, &spec);
2081
2082 fmt += read;
2083
2084 switch (spec.type) {
2085 case FORMAT_TYPE_NONE: {
2086 int copy = read;
2087 if (str < end) {
2088 if (copy > end - str)
2089 copy = end - str;
2090 memcpy(str, old_fmt, copy);
2091 }
2092 str += read;
2093 break;
2094 }
2095
2096 case FORMAT_TYPE_WIDTH:
2097 spec.field_width = get_arg(int);
2098 break;
2099
2100 case FORMAT_TYPE_PRECISION:
2101 spec.precision = get_arg(int);
2102 break;
2103
2104 case FORMAT_TYPE_CHAR: {
2105 char c;
2106
2107 if (!(spec.flags & LEFT)) {
2108 while (--spec.field_width > 0) {
2109 if (str < end)
2110 *str = ' ';
2111 ++str;
2112 }
2113 }
2114 c = (unsigned char) get_arg(char);
2115 if (str < end)
2116 *str = c;
2117 ++str;
2118 while (--spec.field_width > 0) {
2119 if (str < end)
2120 *str = ' ';
2121 ++str;
2122 }
2123 break;
2124 }
2125
2126 case FORMAT_TYPE_STR: {
2127 const char *str_arg = args;
2128 args += strlen(str_arg) + 1;
2129 str = string(str, end, (char *)str_arg, spec);
2130 break;
2131 }
2132
2133 case FORMAT_TYPE_PTR:
2134 str = pointer(fmt+1, str, end, get_arg(void *), spec);
2135 while (isalnum(*fmt))
2136 fmt++;
2137 break;
2138
2139 case FORMAT_TYPE_PERCENT_CHAR:
2140 case FORMAT_TYPE_INVALID:
2141 if (str < end)
2142 *str = '%';
2143 ++str;
2144 break;
2145
2146 case FORMAT_TYPE_NRCHARS:
2147
2148 break;
2149
2150 default: {
2151 unsigned long long num;
2152
2153 switch (spec.type) {
2154
2155 case FORMAT_TYPE_LONG_LONG:
2156 num = get_arg(long long);
2157 break;
2158 case FORMAT_TYPE_ULONG:
2159 case FORMAT_TYPE_LONG:
2160 num = get_arg(unsigned long);
2161 break;
2162 case FORMAT_TYPE_SIZE_T:
2163 num = get_arg(size_t);
2164 break;
2165 case FORMAT_TYPE_PTRDIFF:
2166 num = get_arg(ptrdiff_t);
2167 break;
2168 case FORMAT_TYPE_UBYTE:
2169 num = get_arg(unsigned char);
2170 break;
2171 case FORMAT_TYPE_BYTE:
2172 num = get_arg(signed char);
2173 break;
2174 case FORMAT_TYPE_USHORT:
2175 num = get_arg(unsigned short);
2176 break;
2177 case FORMAT_TYPE_SHORT:
2178 num = get_arg(short);
2179 break;
2180 case FORMAT_TYPE_UINT:
2181 num = get_arg(unsigned int);
2182 break;
2183 default:
2184 num = get_arg(int);
2185 }
2186
2187 str = number(str, end, num, spec);
2188 }
2189 }
2190 }
2191
2192 if (size > 0) {
2193 if (str < end)
2194 *str = '\0';
2195 else
2196 end[-1] = '\0';
2197 }
2198
2199#undef get_arg
2200
2201
2202 return str - buf;
2203}
2204EXPORT_SYMBOL_GPL(bstr_printf);
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...)
2217{
2218 va_list args;
2219 int ret;
2220
2221 va_start(args, fmt);
2222 ret = vbin_printf(bin_buf, size, fmt, args);
2223 va_end(args);
2224
2225 return ret;
2226}
2227EXPORT_SYMBOL_GPL(bprintf);
2228
2229#endif
2230
2231
2232
2233
2234
2235
2236
2237int vsscanf(const char *buf, const char *fmt, va_list args)
2238{
2239 const char *str = buf;
2240 char *next;
2241 char digit;
2242 int num = 0;
2243 u8 qualifier;
2244 unsigned int base;
2245 union {
2246 long long s;
2247 unsigned long long u;
2248 } val;
2249 s16 field_width;
2250 bool is_sign;
2251
2252 while (*fmt) {
2253
2254
2255
2256
2257 if (isspace(*fmt)) {
2258 fmt = skip_spaces(++fmt);
2259 str = skip_spaces(str);
2260 }
2261
2262
2263 if (*fmt != '%' && *fmt) {
2264 if (*fmt++ != *str++)
2265 break;
2266 continue;
2267 }
2268
2269 if (!*fmt)
2270 break;
2271 ++fmt;
2272
2273
2274
2275
2276 if (*fmt == '*') {
2277 if (!*str)
2278 break;
2279 while (!isspace(*fmt) && *fmt != '%' && *fmt)
2280 fmt++;
2281 while (!isspace(*str) && *str)
2282 str++;
2283 continue;
2284 }
2285
2286
2287 field_width = -1;
2288 if (isdigit(*fmt)) {
2289 field_width = skip_atoi(&fmt);
2290 if (field_width <= 0)
2291 break;
2292 }
2293
2294
2295 qualifier = -1;
2296 if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
2297 _tolower(*fmt) == 'z') {
2298 qualifier = *fmt++;
2299 if (unlikely(qualifier == *fmt)) {
2300 if (qualifier == 'h') {
2301 qualifier = 'H';
2302 fmt++;
2303 } else if (qualifier == 'l') {
2304 qualifier = 'L';
2305 fmt++;
2306 }
2307 }
2308 }
2309
2310 if (!*fmt)
2311 break;
2312
2313 if (*fmt == 'n') {
2314
2315 *va_arg(args, int *) = str - buf;
2316 ++fmt;
2317 continue;
2318 }
2319
2320 if (!*str)
2321 break;
2322
2323 base = 10;
2324 is_sign = 0;
2325
2326 switch (*fmt++) {
2327 case 'c':
2328 {
2329 char *s = (char *)va_arg(args, char*);
2330 if (field_width == -1)
2331 field_width = 1;
2332 do {
2333 *s++ = *str++;
2334 } while (--field_width > 0 && *str);
2335 num++;
2336 }
2337 continue;
2338 case 's':
2339 {
2340 char *s = (char *)va_arg(args, char *);
2341 if (field_width == -1)
2342 field_width = SHRT_MAX;
2343
2344 str = skip_spaces(str);
2345
2346
2347 while (*str && !isspace(*str) && field_width--)
2348 *s++ = *str++;
2349 *s = '\0';
2350 num++;
2351 }
2352 continue;
2353 case 'o':
2354 base = 8;
2355 break;
2356 case 'x':
2357 case 'X':
2358 base = 16;
2359 break;
2360 case 'i':
2361 base = 0;
2362 case 'd':
2363 is_sign = 1;
2364 case 'u':
2365 break;
2366 case '%':
2367
2368 if (*str++ != '%')
2369 return num;
2370 continue;
2371 default:
2372
2373 return num;
2374 }
2375
2376
2377
2378
2379 str = skip_spaces(str);
2380
2381 digit = *str;
2382 if (is_sign && digit == '-')
2383 digit = *(str + 1);
2384
2385 if (!digit
2386 || (base == 16 && !isxdigit(digit))
2387 || (base == 10 && !isdigit(digit))
2388 || (base == 8 && (!isdigit(digit) || digit > '7'))
2389 || (base == 0 && !isdigit(digit)))
2390 break;
2391
2392 if (is_sign)
2393 val.s = qualifier != 'L' ?
2394 simple_strtol(str, &next, base) :
2395 simple_strtoll(str, &next, base);
2396 else
2397 val.u = qualifier != 'L' ?
2398 simple_strtoul(str, &next, base) :
2399 simple_strtoull(str, &next, base);
2400
2401 if (field_width > 0 && next - str > field_width) {
2402 if (base == 0)
2403 _parse_integer_fixup_radix(str, &base);
2404 while (next - str > field_width) {
2405 if (is_sign)
2406 val.s = div_s64(val.s, base);
2407 else
2408 val.u = div_u64(val.u, base);
2409 --next;
2410 }
2411 }
2412
2413 switch (qualifier) {
2414 case 'H':
2415 if (is_sign)
2416 *va_arg(args, signed char *) = val.s;
2417 else
2418 *va_arg(args, unsigned char *) = val.u;
2419 break;
2420 case 'h':
2421 if (is_sign)
2422 *va_arg(args, short *) = val.s;
2423 else
2424 *va_arg(args, unsigned short *) = val.u;
2425 break;
2426 case 'l':
2427 if (is_sign)
2428 *va_arg(args, long *) = val.s;
2429 else
2430 *va_arg(args, unsigned long *) = val.u;
2431 break;
2432 case 'L':
2433 if (is_sign)
2434 *va_arg(args, long long *) = val.s;
2435 else
2436 *va_arg(args, unsigned long long *) = val.u;
2437 break;
2438 case 'Z':
2439 case 'z':
2440 *va_arg(args, size_t *) = val.u;
2441 break;
2442 default:
2443 if (is_sign)
2444 *va_arg(args, int *) = val.s;
2445 else
2446 *va_arg(args, unsigned int *) = val.u;
2447 break;
2448 }
2449 num++;
2450
2451 if (!next)
2452 break;
2453 str = next;
2454 }
2455
2456 return num;
2457}
2458EXPORT_SYMBOL(vsscanf);
2459
2460
2461
2462
2463
2464
2465
2466int sscanf(const char *buf, const char *fmt, ...)
2467{
2468 va_list args;
2469 int i;
2470
2471 va_start(args, fmt);
2472 i = vsscanf(buf, fmt, args);
2473 va_end(args);
2474
2475 return i;
2476}
2477EXPORT_SYMBOL(sscanf);
2478