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