diff options
Diffstat (limited to 'lib')
-rw-r--r-- | lib/Kconfig | 3 | ||||
-rw-r--r-- | lib/vsprintf.c | 1005 |
2 files changed, 781 insertions, 227 deletions
diff --git a/lib/Kconfig b/lib/Kconfig index 2a9c69f3448..8ade0a7a91e 100644 --- a/lib/Kconfig +++ b/lib/Kconfig | |||
@@ -2,6 +2,9 @@ | |||
2 | # Library configuration | 2 | # Library configuration |
3 | # | 3 | # |
4 | 4 | ||
5 | config BINARY_PRINTF | ||
6 | def_bool n | ||
7 | |||
5 | menu "Library routines" | 8 | menu "Library routines" |
6 | 9 | ||
7 | config BITREVERSE | 10 | config BITREVERSE |
diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 0fbd0121d91..be3001f912e 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c | |||
@@ -396,7 +396,38 @@ static noinline char* put_dec(char *buf, unsigned long long num) | |||
396 | #define SMALL 32 /* Must be 32 == 0x20 */ | 396 | #define SMALL 32 /* Must be 32 == 0x20 */ |
397 | #define SPECIAL 64 /* 0x */ | 397 | #define SPECIAL 64 /* 0x */ |
398 | 398 | ||
399 | static char *number(char *buf, char *end, unsigned long long num, int base, int size, int precision, int type) | 399 | enum format_type { |
400 | FORMAT_TYPE_NONE, /* Just a string part */ | ||
401 | FORMAT_TYPE_WIDTH, | ||
402 | FORMAT_TYPE_PRECISION, | ||
403 | FORMAT_TYPE_CHAR, | ||
404 | FORMAT_TYPE_STR, | ||
405 | FORMAT_TYPE_PTR, | ||
406 | FORMAT_TYPE_PERCENT_CHAR, | ||
407 | FORMAT_TYPE_INVALID, | ||
408 | FORMAT_TYPE_LONG_LONG, | ||
409 | FORMAT_TYPE_ULONG, | ||
410 | FORMAT_TYPE_LONG, | ||
411 | FORMAT_TYPE_USHORT, | ||
412 | FORMAT_TYPE_SHORT, | ||
413 | FORMAT_TYPE_UINT, | ||
414 | FORMAT_TYPE_INT, | ||
415 | FORMAT_TYPE_NRCHARS, | ||
416 | FORMAT_TYPE_SIZE_T, | ||
417 | FORMAT_TYPE_PTRDIFF | ||
418 | }; | ||
419 | |||
420 | struct printf_spec { | ||
421 | enum format_type type; | ||
422 | int flags; /* flags to number() */ | ||
423 | int field_width; /* width of output field */ | ||
424 | int base; | ||
425 | int precision; /* # of digits/chars */ | ||
426 | int qualifier; | ||
427 | }; | ||
428 | |||
429 | static char *number(char *buf, char *end, unsigned long long num, | ||
430 | struct printf_spec spec) | ||
400 | { | 431 | { |
401 | /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ | 432 | /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ |
402 | static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ | 433 | static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ |
@@ -404,32 +435,32 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int | |||
404 | char tmp[66]; | 435 | char tmp[66]; |
405 | char sign; | 436 | char sign; |
406 | char locase; | 437 | char locase; |
407 | int need_pfx = ((type & SPECIAL) && base != 10); | 438 | int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10); |
408 | int i; | 439 | int i; |
409 | 440 | ||
410 | /* locase = 0 or 0x20. ORing digits or letters with 'locase' | 441 | /* locase = 0 or 0x20. ORing digits or letters with 'locase' |
411 | * produces same digits or (maybe lowercased) letters */ | 442 | * produces same digits or (maybe lowercased) letters */ |
412 | locase = (type & SMALL); | 443 | locase = (spec.flags & SMALL); |
413 | if (type & LEFT) | 444 | if (spec.flags & LEFT) |
414 | type &= ~ZEROPAD; | 445 | spec.flags &= ~ZEROPAD; |
415 | sign = 0; | 446 | sign = 0; |
416 | if (type & SIGN) { | 447 | if (spec.flags & SIGN) { |
417 | if ((signed long long) num < 0) { | 448 | if ((signed long long) num < 0) { |
418 | sign = '-'; | 449 | sign = '-'; |
419 | num = - (signed long long) num; | 450 | num = - (signed long long) num; |
420 | size--; | 451 | spec.field_width--; |
421 | } else if (type & PLUS) { | 452 | } else if (spec.flags & PLUS) { |
422 | sign = '+'; | 453 | sign = '+'; |
423 | size--; | 454 | spec.field_width--; |
424 | } else if (type & SPACE) { | 455 | } else if (spec.flags & SPACE) { |
425 | sign = ' '; | 456 | sign = ' '; |
426 | size--; | 457 | spec.field_width--; |
427 | } | 458 | } |
428 | } | 459 | } |
429 | if (need_pfx) { | 460 | if (need_pfx) { |
430 | size--; | 461 | spec.field_width--; |
431 | if (base == 16) | 462 | if (spec.base == 16) |
432 | size--; | 463 | spec.field_width--; |
433 | } | 464 | } |
434 | 465 | ||
435 | /* generate full string in tmp[], in reverse order */ | 466 | /* generate full string in tmp[], in reverse order */ |
@@ -441,10 +472,10 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int | |||
441 | tmp[i++] = (digits[do_div(num,base)] | locase); | 472 | tmp[i++] = (digits[do_div(num,base)] | locase); |
442 | } while (num != 0); | 473 | } while (num != 0); |
443 | */ | 474 | */ |
444 | else if (base != 10) { /* 8 or 16 */ | 475 | else if (spec.base != 10) { /* 8 or 16 */ |
445 | int mask = base - 1; | 476 | int mask = spec.base - 1; |
446 | int shift = 3; | 477 | int shift = 3; |
447 | if (base == 16) shift = 4; | 478 | if (spec.base == 16) shift = 4; |
448 | do { | 479 | do { |
449 | tmp[i++] = (digits[((unsigned char)num) & mask] | locase); | 480 | tmp[i++] = (digits[((unsigned char)num) & mask] | locase); |
450 | num >>= shift; | 481 | num >>= shift; |
@@ -454,12 +485,12 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int | |||
454 | } | 485 | } |
455 | 486 | ||
456 | /* printing 100 using %2d gives "100", not "00" */ | 487 | /* printing 100 using %2d gives "100", not "00" */ |
457 | if (i > precision) | 488 | if (i > spec.precision) |
458 | precision = i; | 489 | spec.precision = i; |
459 | /* leading space padding */ | 490 | /* leading space padding */ |
460 | size -= precision; | 491 | spec.field_width -= spec.precision; |
461 | if (!(type & (ZEROPAD+LEFT))) { | 492 | if (!(spec.flags & (ZEROPAD+LEFT))) { |
462 | while(--size >= 0) { | 493 | while(--spec.field_width >= 0) { |
463 | if (buf < end) | 494 | if (buf < end) |
464 | *buf = ' '; | 495 | *buf = ' '; |
465 | ++buf; | 496 | ++buf; |
@@ -476,23 +507,23 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int | |||
476 | if (buf < end) | 507 | if (buf < end) |
477 | *buf = '0'; | 508 | *buf = '0'; |
478 | ++buf; | 509 | ++buf; |
479 | if (base == 16) { | 510 | if (spec.base == 16) { |
480 | if (buf < end) | 511 | if (buf < end) |
481 | *buf = ('X' | locase); | 512 | *buf = ('X' | locase); |
482 | ++buf; | 513 | ++buf; |
483 | } | 514 | } |
484 | } | 515 | } |
485 | /* zero or space padding */ | 516 | /* zero or space padding */ |
486 | if (!(type & LEFT)) { | 517 | if (!(spec.flags & LEFT)) { |
487 | char c = (type & ZEROPAD) ? '0' : ' '; | 518 | char c = (spec.flags & ZEROPAD) ? '0' : ' '; |
488 | while (--size >= 0) { | 519 | while (--spec.field_width >= 0) { |
489 | if (buf < end) | 520 | if (buf < end) |
490 | *buf = c; | 521 | *buf = c; |
491 | ++buf; | 522 | ++buf; |
492 | } | 523 | } |
493 | } | 524 | } |
494 | /* hmm even more zero padding? */ | 525 | /* hmm even more zero padding? */ |
495 | while (i <= --precision) { | 526 | while (i <= --spec.precision) { |
496 | if (buf < end) | 527 | if (buf < end) |
497 | *buf = '0'; | 528 | *buf = '0'; |
498 | ++buf; | 529 | ++buf; |
@@ -504,7 +535,7 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int | |||
504 | ++buf; | 535 | ++buf; |
505 | } | 536 | } |
506 | /* trailing space padding */ | 537 | /* trailing space padding */ |
507 | while (--size >= 0) { | 538 | while (--spec.field_width >= 0) { |
508 | if (buf < end) | 539 | if (buf < end) |
509 | *buf = ' '; | 540 | *buf = ' '; |
510 | ++buf; | 541 | ++buf; |
@@ -512,17 +543,17 @@ static char *number(char *buf, char *end, unsigned long long num, int base, int | |||
512 | return buf; | 543 | return buf; |
513 | } | 544 | } |
514 | 545 | ||
515 | static char *string(char *buf, char *end, char *s, int field_width, int precision, int flags) | 546 | static char *string(char *buf, char *end, char *s, struct printf_spec spec) |
516 | { | 547 | { |
517 | int len, i; | 548 | int len, i; |
518 | 549 | ||
519 | if ((unsigned long)s < PAGE_SIZE) | 550 | if ((unsigned long)s < PAGE_SIZE) |
520 | s = "<NULL>"; | 551 | s = "<NULL>"; |
521 | 552 | ||
522 | len = strnlen(s, precision); | 553 | len = strnlen(s, spec.precision); |
523 | 554 | ||
524 | if (!(flags & LEFT)) { | 555 | if (!(spec.flags & LEFT)) { |
525 | while (len < field_width--) { | 556 | while (len < spec.field_width--) { |
526 | if (buf < end) | 557 | if (buf < end) |
527 | *buf = ' '; | 558 | *buf = ' '; |
528 | ++buf; | 559 | ++buf; |
@@ -533,7 +564,7 @@ static char *string(char *buf, char *end, char *s, int field_width, int precisio | |||
533 | *buf = *s; | 564 | *buf = *s; |
534 | ++buf; ++s; | 565 | ++buf; ++s; |
535 | } | 566 | } |
536 | while (len < field_width--) { | 567 | while (len < spec.field_width--) { |
537 | if (buf < end) | 568 | if (buf < end) |
538 | *buf = ' '; | 569 | *buf = ' '; |
539 | ++buf; | 570 | ++buf; |
@@ -541,21 +572,24 @@ static char *string(char *buf, char *end, char *s, int field_width, int precisio | |||
541 | return buf; | 572 | return buf; |
542 | } | 573 | } |
543 | 574 | ||
544 | static char *symbol_string(char *buf, char *end, void *ptr, int field_width, int precision, int flags) | 575 | static char *symbol_string(char *buf, char *end, void *ptr, |
576 | struct printf_spec spec) | ||
545 | { | 577 | { |
546 | unsigned long value = (unsigned long) ptr; | 578 | unsigned long value = (unsigned long) ptr; |
547 | #ifdef CONFIG_KALLSYMS | 579 | #ifdef CONFIG_KALLSYMS |
548 | char sym[KSYM_SYMBOL_LEN]; | 580 | char sym[KSYM_SYMBOL_LEN]; |
549 | sprint_symbol(sym, value); | 581 | sprint_symbol(sym, value); |
550 | return string(buf, end, sym, field_width, precision, flags); | 582 | return string(buf, end, sym, spec); |
551 | #else | 583 | #else |
552 | field_width = 2*sizeof(void *); | 584 | spec.field_width = 2*sizeof(void *); |
553 | flags |= SPECIAL | SMALL | ZEROPAD; | 585 | spec.flags |= SPECIAL | SMALL | ZEROPAD; |
554 | return number(buf, end, value, 16, field_width, precision, flags); | 586 | spec.base = 16; |
587 | return number(buf, end, value, spec); | ||
555 | #endif | 588 | #endif |
556 | } | 589 | } |
557 | 590 | ||
558 | static char *resource_string(char *buf, char *end, struct resource *res, int field_width, int precision, int flags) | 591 | static char *resource_string(char *buf, char *end, struct resource *res, |
592 | struct printf_spec spec) | ||
559 | { | 593 | { |
560 | #ifndef IO_RSRC_PRINTK_SIZE | 594 | #ifndef IO_RSRC_PRINTK_SIZE |
561 | #define IO_RSRC_PRINTK_SIZE 4 | 595 | #define IO_RSRC_PRINTK_SIZE 4 |
@@ -564,7 +598,11 @@ static char *resource_string(char *buf, char *end, struct resource *res, int fie | |||
564 | #ifndef MEM_RSRC_PRINTK_SIZE | 598 | #ifndef MEM_RSRC_PRINTK_SIZE |
565 | #define MEM_RSRC_PRINTK_SIZE 8 | 599 | #define MEM_RSRC_PRINTK_SIZE 8 |
566 | #endif | 600 | #endif |
567 | 601 | struct printf_spec num_spec = { | |
602 | .base = 16, | ||
603 | .precision = -1, | ||
604 | .flags = SPECIAL | SMALL | ZEROPAD, | ||
605 | }; | ||
568 | /* room for the actual numbers, the two "0x", -, [, ] and the final zero */ | 606 | /* room for the actual numbers, the two "0x", -, [, ] and the final zero */ |
569 | char sym[4*sizeof(resource_size_t) + 8]; | 607 | char sym[4*sizeof(resource_size_t) + 8]; |
570 | char *p = sym, *pend = sym + sizeof(sym); | 608 | char *p = sym, *pend = sym + sizeof(sym); |
@@ -576,17 +614,18 @@ static char *resource_string(char *buf, char *end, struct resource *res, int fie | |||
576 | size = MEM_RSRC_PRINTK_SIZE; | 614 | size = MEM_RSRC_PRINTK_SIZE; |
577 | 615 | ||
578 | *p++ = '['; | 616 | *p++ = '['; |
579 | p = number(p, pend, res->start, 16, size, -1, SPECIAL | SMALL | ZEROPAD); | 617 | num_spec.field_width = size; |
618 | p = number(p, pend, res->start, num_spec); | ||
580 | *p++ = '-'; | 619 | *p++ = '-'; |
581 | p = number(p, pend, res->end, 16, size, -1, SPECIAL | SMALL | ZEROPAD); | 620 | p = number(p, pend, res->end, num_spec); |
582 | *p++ = ']'; | 621 | *p++ = ']'; |
583 | *p = 0; | 622 | *p = 0; |
584 | 623 | ||
585 | return string(buf, end, sym, field_width, precision, flags); | 624 | return string(buf, end, sym, spec); |
586 | } | 625 | } |
587 | 626 | ||
588 | static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width, | 627 | static char *mac_address_string(char *buf, char *end, u8 *addr, |
589 | int precision, int flags) | 628 | struct printf_spec spec) |
590 | { | 629 | { |
591 | char mac_addr[6 * 3]; /* (6 * 2 hex digits), 5 colons and trailing zero */ | 630 | char mac_addr[6 * 3]; /* (6 * 2 hex digits), 5 colons and trailing zero */ |
592 | char *p = mac_addr; | 631 | char *p = mac_addr; |
@@ -594,16 +633,17 @@ static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width, | |||
594 | 633 | ||
595 | for (i = 0; i < 6; i++) { | 634 | for (i = 0; i < 6; i++) { |
596 | p = pack_hex_byte(p, addr[i]); | 635 | p = pack_hex_byte(p, addr[i]); |
597 | if (!(flags & SPECIAL) && i != 5) | 636 | if (!(spec.flags & SPECIAL) && i != 5) |
598 | *p++ = ':'; | 637 | *p++ = ':'; |
599 | } | 638 | } |
600 | *p = '\0'; | 639 | *p = '\0'; |
640 | spec.flags &= ~SPECIAL; | ||
601 | 641 | ||
602 | return string(buf, end, mac_addr, field_width, precision, flags & ~SPECIAL); | 642 | return string(buf, end, mac_addr, spec); |
603 | } | 643 | } |
604 | 644 | ||
605 | static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width, | 645 | static char *ip6_addr_string(char *buf, char *end, u8 *addr, |
606 | int precision, int flags) | 646 | struct printf_spec spec) |
607 | { | 647 | { |
608 | char ip6_addr[8 * 5]; /* (8 * 4 hex digits), 7 colons and trailing zero */ | 648 | char ip6_addr[8 * 5]; /* (8 * 4 hex digits), 7 colons and trailing zero */ |
609 | char *p = ip6_addr; | 649 | char *p = ip6_addr; |
@@ -612,16 +652,17 @@ static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width, | |||
612 | for (i = 0; i < 8; i++) { | 652 | for (i = 0; i < 8; i++) { |
613 | p = pack_hex_byte(p, addr[2 * i]); | 653 | p = pack_hex_byte(p, addr[2 * i]); |
614 | p = pack_hex_byte(p, addr[2 * i + 1]); | 654 | p = pack_hex_byte(p, addr[2 * i + 1]); |
615 | if (!(flags & SPECIAL) && i != 7) | 655 | if (!(spec.flags & SPECIAL) && i != 7) |
616 | *p++ = ':'; | 656 | *p++ = ':'; |
617 | } | 657 | } |
618 | *p = '\0'; | 658 | *p = '\0'; |
659 | spec.flags &= ~SPECIAL; | ||
619 | 660 | ||
620 | return string(buf, end, ip6_addr, field_width, precision, flags & ~SPECIAL); | 661 | return string(buf, end, ip6_addr, spec); |
621 | } | 662 | } |
622 | 663 | ||
623 | static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, | 664 | static char *ip4_addr_string(char *buf, char *end, u8 *addr, |
624 | int precision, int flags) | 665 | struct printf_spec spec) |
625 | { | 666 | { |
626 | char ip4_addr[4 * 4]; /* (4 * 3 decimal digits), 3 dots and trailing zero */ | 667 | char ip4_addr[4 * 4]; /* (4 * 3 decimal digits), 3 dots and trailing zero */ |
627 | char temp[3]; /* hold each IP quad in reverse order */ | 668 | char temp[3]; /* hold each IP quad in reverse order */ |
@@ -637,8 +678,9 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, | |||
637 | *p++ = '.'; | 678 | *p++ = '.'; |
638 | } | 679 | } |
639 | *p = '\0'; | 680 | *p = '\0'; |
681 | spec.flags &= ~SPECIAL; | ||
640 | 682 | ||
641 | return string(buf, end, ip4_addr, field_width, precision, flags & ~SPECIAL); | 683 | return string(buf, end, ip4_addr, spec); |
642 | } | 684 | } |
643 | 685 | ||
644 | /* | 686 | /* |
@@ -663,41 +705,233 @@ static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width, | |||
663 | * function pointers are really function descriptors, which contain a | 705 | * function pointers are really function descriptors, which contain a |
664 | * pointer to the real address. | 706 | * pointer to the real address. |
665 | */ | 707 | */ |
666 | static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field_width, int precision, int flags) | 708 | static char *pointer(const char *fmt, char *buf, char *end, void *ptr, |
709 | struct printf_spec spec) | ||
667 | { | 710 | { |
668 | if (!ptr) | 711 | if (!ptr) |
669 | return string(buf, end, "(null)", field_width, precision, flags); | 712 | return string(buf, end, "(null)", spec); |
670 | 713 | ||
671 | switch (*fmt) { | 714 | switch (*fmt) { |
672 | case 'F': | 715 | case 'F': |
673 | ptr = dereference_function_descriptor(ptr); | 716 | ptr = dereference_function_descriptor(ptr); |
674 | /* Fallthrough */ | 717 | /* Fallthrough */ |
675 | case 'S': | 718 | case 'S': |
676 | return symbol_string(buf, end, ptr, field_width, precision, flags); | 719 | return symbol_string(buf, end, ptr, spec); |
677 | case 'R': | 720 | case 'R': |
678 | return resource_string(buf, end, ptr, field_width, precision, flags); | 721 | return resource_string(buf, end, ptr, spec); |
679 | case 'm': | 722 | case 'm': |
680 | flags |= SPECIAL; | 723 | spec.flags |= SPECIAL; |
681 | /* Fallthrough */ | 724 | /* Fallthrough */ |
682 | case 'M': | 725 | case 'M': |
683 | return mac_address_string(buf, end, ptr, field_width, precision, flags); | 726 | return mac_address_string(buf, end, ptr, spec); |
684 | case 'i': | 727 | case 'i': |
685 | flags |= SPECIAL; | 728 | spec.flags |= SPECIAL; |
686 | /* Fallthrough */ | 729 | /* Fallthrough */ |
687 | case 'I': | 730 | case 'I': |
688 | if (fmt[1] == '6') | 731 | if (fmt[1] == '6') |
689 | return ip6_addr_string(buf, end, ptr, field_width, precision, flags); | 732 | return ip6_addr_string(buf, end, ptr, spec); |
690 | if (fmt[1] == '4') | 733 | if (fmt[1] == '4') |
691 | return ip4_addr_string(buf, end, ptr, field_width, precision, flags); | 734 | return ip4_addr_string(buf, end, ptr, spec); |
692 | flags &= ~SPECIAL; | 735 | spec.flags &= ~SPECIAL; |
736 | break; | ||
737 | } | ||
738 | spec.flags |= SMALL; | ||
739 | if (spec.field_width == -1) { | ||
740 | spec.field_width = 2*sizeof(void *); | ||
741 | spec.flags |= ZEROPAD; | ||
742 | } | ||
743 | spec.base = 16; | ||
744 | |||
745 | return number(buf, end, (unsigned long) ptr, spec); | ||
746 | } | ||
747 | |||
748 | /* | ||
749 | * Helper function to decode printf style format. | ||
750 | * Each call decode a token from the format and return the | ||
751 | * number of characters read (or likely the delta where it wants | ||
752 | * to go on the next call). | ||
753 | * The decoded token is returned through the parameters | ||
754 | * | ||
755 | * 'h', 'l', or 'L' for integer fields | ||
756 | * 'z' support added 23/7/1999 S.H. | ||
757 | * 'z' changed to 'Z' --davidm 1/25/99 | ||
758 | * 't' added for ptrdiff_t | ||
759 | * | ||
760 | * @fmt: the format string | ||
761 | * @type of the token returned | ||
762 | * @flags: various flags such as +, -, # tokens.. | ||
763 | * @field_width: overwritten width | ||
764 | * @base: base of the number (octal, hex, ...) | ||
765 | * @precision: precision of a number | ||
766 | * @qualifier: qualifier of a number (long, size_t, ...) | ||
767 | */ | ||
768 | static int format_decode(const char *fmt, struct printf_spec *spec) | ||
769 | { | ||
770 | const char *start = fmt; | ||
771 | |||
772 | /* we finished early by reading the field width */ | ||
773 | if (spec->type == FORMAT_TYPE_WIDTH) { | ||
774 | if (spec->field_width < 0) { | ||
775 | spec->field_width = -spec->field_width; | ||
776 | spec->flags |= LEFT; | ||
777 | } | ||
778 | spec->type = FORMAT_TYPE_NONE; | ||
779 | goto precision; | ||
780 | } | ||
781 | |||
782 | /* we finished early by reading the precision */ | ||
783 | if (spec->type == FORMAT_TYPE_PRECISION) { | ||
784 | if (spec->precision < 0) | ||
785 | spec->precision = 0; | ||
786 | |||
787 | spec->type = FORMAT_TYPE_NONE; | ||
788 | goto qualifier; | ||
789 | } | ||
790 | |||
791 | /* By default */ | ||
792 | spec->type = FORMAT_TYPE_NONE; | ||
793 | |||
794 | for (; *fmt ; ++fmt) { | ||
795 | if (*fmt == '%') | ||
796 | break; | ||
797 | } | ||
798 | |||
799 | /* Return the current non-format string */ | ||
800 | if (fmt != start || !*fmt) | ||
801 | return fmt - start; | ||
802 | |||
803 | /* Process flags */ | ||
804 | spec->flags = 0; | ||
805 | |||
806 | while (1) { /* this also skips first '%' */ | ||
807 | bool found = true; | ||
808 | |||
809 | ++fmt; | ||
810 | |||
811 | switch (*fmt) { | ||
812 | case '-': spec->flags |= LEFT; break; | ||
813 | case '+': spec->flags |= PLUS; break; | ||
814 | case ' ': spec->flags |= SPACE; break; | ||
815 | case '#': spec->flags |= SPECIAL; break; | ||
816 | case '0': spec->flags |= ZEROPAD; break; | ||
817 | default: found = false; | ||
818 | } | ||
819 | |||
820 | if (!found) | ||
821 | break; | ||
822 | } | ||
823 | |||
824 | /* get field width */ | ||
825 | spec->field_width = -1; | ||
826 | |||
827 | if (isdigit(*fmt)) | ||
828 | spec->field_width = skip_atoi(&fmt); | ||
829 | else if (*fmt == '*') { | ||
830 | /* it's the next argument */ | ||
831 | spec->type = FORMAT_TYPE_WIDTH; | ||
832 | return ++fmt - start; | ||
833 | } | ||
834 | |||
835 | precision: | ||
836 | /* get the precision */ | ||
837 | spec->precision = -1; | ||
838 | if (*fmt == '.') { | ||
839 | ++fmt; | ||
840 | if (isdigit(*fmt)) { | ||
841 | spec->precision = skip_atoi(&fmt); | ||
842 | if (spec->precision < 0) | ||
843 | spec->precision = 0; | ||
844 | } else if (*fmt == '*') { | ||
845 | /* it's the next argument */ | ||
846 | spec->type = FORMAT_TYPE_PRECISION; | ||
847 | return ++fmt - start; | ||
848 | } | ||
849 | } | ||
850 | |||
851 | qualifier: | ||
852 | /* get the conversion qualifier */ | ||
853 | spec->qualifier = -1; | ||
854 | if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || | ||
855 | *fmt == 'Z' || *fmt == 'z' || *fmt == 't') { | ||
856 | spec->qualifier = *fmt; | ||
857 | ++fmt; | ||
858 | if (spec->qualifier == 'l' && *fmt == 'l') { | ||
859 | spec->qualifier = 'L'; | ||
860 | ++fmt; | ||
861 | } | ||
862 | } | ||
863 | |||
864 | /* default base */ | ||
865 | spec->base = 10; | ||
866 | switch (*fmt) { | ||
867 | case 'c': | ||
868 | spec->type = FORMAT_TYPE_CHAR; | ||
869 | return ++fmt - start; | ||
870 | |||
871 | case 's': | ||
872 | spec->type = FORMAT_TYPE_STR; | ||
873 | return ++fmt - start; | ||
874 | |||
875 | case 'p': | ||
876 | spec->type = FORMAT_TYPE_PTR; | ||
877 | return fmt - start; | ||
878 | /* skip alnum */ | ||
879 | |||
880 | case 'n': | ||
881 | spec->type = FORMAT_TYPE_NRCHARS; | ||
882 | return ++fmt - start; | ||
883 | |||
884 | case '%': | ||
885 | spec->type = FORMAT_TYPE_PERCENT_CHAR; | ||
886 | return ++fmt - start; | ||
887 | |||
888 | /* integer number formats - set up the flags and "break" */ | ||
889 | case 'o': | ||
890 | spec->base = 8; | ||
693 | break; | 891 | break; |
892 | |||
893 | case 'x': | ||
894 | spec->flags |= SMALL; | ||
895 | |||
896 | case 'X': | ||
897 | spec->base = 16; | ||
898 | break; | ||
899 | |||
900 | case 'd': | ||
901 | case 'i': | ||
902 | spec->flags |= SIGN; | ||
903 | case 'u': | ||
904 | break; | ||
905 | |||
906 | default: | ||
907 | spec->type = FORMAT_TYPE_INVALID; | ||
908 | return fmt - start; | ||
694 | } | 909 | } |
695 | flags |= SMALL; | 910 | |
696 | if (field_width == -1) { | 911 | if (spec->qualifier == 'L') |
697 | field_width = 2*sizeof(void *); | 912 | spec->type = FORMAT_TYPE_LONG_LONG; |
698 | flags |= ZEROPAD; | 913 | else if (spec->qualifier == 'l') { |
914 | if (spec->flags & SIGN) | ||
915 | spec->type = FORMAT_TYPE_LONG; | ||
916 | else | ||
917 | spec->type = FORMAT_TYPE_ULONG; | ||
918 | } else if (spec->qualifier == 'Z' || spec->qualifier == 'z') { | ||
919 | spec->type = FORMAT_TYPE_SIZE_T; | ||
920 | } else if (spec->qualifier == 't') { | ||
921 | spec->type = FORMAT_TYPE_PTRDIFF; | ||
922 | } else if (spec->qualifier == 'h') { | ||
923 | if (spec->flags & SIGN) | ||
924 | spec->type = FORMAT_TYPE_SHORT; | ||
925 | else | ||
926 | spec->type = FORMAT_TYPE_USHORT; | ||
927 | } else { | ||
928 | if (spec->flags & SIGN) | ||
929 | spec->type = FORMAT_TYPE_INT; | ||
930 | else | ||
931 | spec->type = FORMAT_TYPE_UINT; | ||
699 | } | 932 | } |
700 | return number(buf, end, (unsigned long) ptr, 16, field_width, precision, flags); | 933 | |
934 | return ++fmt - start; | ||
701 | } | 935 | } |
702 | 936 | ||
703 | /** | 937 | /** |
@@ -726,18 +960,9 @@ static char *pointer(const char *fmt, char *buf, char *end, void *ptr, int field | |||
726 | int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) | 960 | int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) |
727 | { | 961 | { |
728 | unsigned long long num; | 962 | unsigned long long num; |
729 | int base; | ||
730 | char *str, *end, c; | 963 | char *str, *end, c; |
731 | 964 | int read; | |
732 | int flags; /* flags to number() */ | 965 | struct printf_spec spec = {0}; |
733 | |||
734 | int field_width; /* width of output field */ | ||
735 | int precision; /* min. # of digits for integers; max | ||
736 | number of chars for from string */ | ||
737 | int qualifier; /* 'h', 'l', or 'L' for integer fields */ | ||
738 | /* 'z' support added 23/7/1999 S.H. */ | ||
739 | /* 'z' changed to 'Z' --davidm 1/25/99 */ | ||
740 | /* 't' added for ptrdiff_t */ | ||
741 | 966 | ||
742 | /* Reject out-of-range values early. Large positive sizes are | 967 | /* Reject out-of-range values early. Large positive sizes are |
743 | used for unknown buffer sizes. */ | 968 | used for unknown buffer sizes. */ |
@@ -758,184 +983,144 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) | |||
758 | size = end - buf; | 983 | size = end - buf; |
759 | } | 984 | } |
760 | 985 | ||
761 | for (; *fmt ; ++fmt) { | 986 | while (*fmt) { |
762 | if (*fmt != '%') { | 987 | const char *old_fmt = fmt; |
763 | if (str < end) | ||
764 | *str = *fmt; | ||
765 | ++str; | ||
766 | continue; | ||
767 | } | ||
768 | 988 | ||
769 | /* process flags */ | 989 | read = format_decode(fmt, &spec); |
770 | flags = 0; | ||
771 | repeat: | ||
772 | ++fmt; /* this also skips first '%' */ | ||
773 | switch (*fmt) { | ||
774 | case '-': flags |= LEFT; goto repeat; | ||
775 | case '+': flags |= PLUS; goto repeat; | ||
776 | case ' ': flags |= SPACE; goto repeat; | ||
777 | case '#': flags |= SPECIAL; goto repeat; | ||
778 | case '0': flags |= ZEROPAD; goto repeat; | ||
779 | } | ||
780 | 990 | ||
781 | /* get field width */ | 991 | fmt += read; |
782 | field_width = -1; | ||
783 | if (isdigit(*fmt)) | ||
784 | field_width = skip_atoi(&fmt); | ||
785 | else if (*fmt == '*') { | ||
786 | ++fmt; | ||
787 | /* it's the next argument */ | ||
788 | field_width = va_arg(args, int); | ||
789 | if (field_width < 0) { | ||
790 | field_width = -field_width; | ||
791 | flags |= LEFT; | ||
792 | } | ||
793 | } | ||
794 | 992 | ||
795 | /* get the precision */ | 993 | switch (spec.type) { |
796 | precision = -1; | 994 | case FORMAT_TYPE_NONE: { |
797 | if (*fmt == '.') { | 995 | int copy = read; |
798 | ++fmt; | 996 | if (str < end) { |
799 | if (isdigit(*fmt)) | 997 | if (copy > end - str) |
800 | precision = skip_atoi(&fmt); | 998 | copy = end - str; |
801 | else if (*fmt == '*') { | 999 | memcpy(str, old_fmt, copy); |
802 | ++fmt; | ||
803 | /* it's the next argument */ | ||
804 | precision = va_arg(args, int); | ||
805 | } | 1000 | } |
806 | if (precision < 0) | 1001 | str += read; |
807 | precision = 0; | 1002 | break; |
808 | } | 1003 | } |
809 | 1004 | ||
810 | /* get the conversion qualifier */ | 1005 | case FORMAT_TYPE_WIDTH: |
811 | qualifier = -1; | 1006 | spec.field_width = va_arg(args, int); |
812 | if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || | 1007 | break; |
813 | *fmt =='Z' || *fmt == 'z' || *fmt == 't') { | ||
814 | qualifier = *fmt; | ||
815 | ++fmt; | ||
816 | if (qualifier == 'l' && *fmt == 'l') { | ||
817 | qualifier = 'L'; | ||
818 | ++fmt; | ||
819 | } | ||
820 | } | ||
821 | 1008 | ||
822 | /* default base */ | 1009 | case FORMAT_TYPE_PRECISION: |
823 | base = 10; | 1010 | spec.precision = va_arg(args, int); |
1011 | break; | ||
824 | 1012 | ||
825 | switch (*fmt) { | 1013 | case FORMAT_TYPE_CHAR: |
826 | case 'c': | 1014 | if (!(spec.flags & LEFT)) { |
827 | if (!(flags & LEFT)) { | 1015 | while (--spec.field_width > 0) { |
828 | while (--field_width > 0) { | ||
829 | if (str < end) | ||
830 | *str = ' '; | ||
831 | ++str; | ||
832 | } | ||
833 | } | ||
834 | c = (unsigned char) va_arg(args, int); | ||
835 | if (str < end) | ||
836 | *str = c; | ||
837 | ++str; | ||
838 | while (--field_width > 0) { | ||
839 | if (str < end) | 1016 | if (str < end) |
840 | *str = ' '; | 1017 | *str = ' '; |
841 | ++str; | 1018 | ++str; |
842 | } | ||
843 | continue; | ||
844 | |||
845 | case 's': | ||
846 | str = string(str, end, va_arg(args, char *), field_width, precision, flags); | ||
847 | continue; | ||
848 | |||
849 | case 'p': | ||
850 | str = pointer(fmt+1, str, end, | ||
851 | va_arg(args, void *), | ||
852 | field_width, precision, flags); | ||
853 | /* Skip all alphanumeric pointer suffixes */ | ||
854 | while (isalnum(fmt[1])) | ||
855 | fmt++; | ||
856 | continue; | ||
857 | |||
858 | case 'n': | ||
859 | /* FIXME: | ||
860 | * What does C99 say about the overflow case here? */ | ||
861 | if (qualifier == 'l') { | ||
862 | long * ip = va_arg(args, long *); | ||
863 | *ip = (str - buf); | ||
864 | } else if (qualifier == 'Z' || qualifier == 'z') { | ||
865 | size_t * ip = va_arg(args, size_t *); | ||
866 | *ip = (str - buf); | ||
867 | } else { | ||
868 | int * ip = va_arg(args, int *); | ||
869 | *ip = (str - buf); | ||
870 | } | ||
871 | continue; | ||
872 | 1019 | ||
873 | case '%': | 1020 | } |
1021 | } | ||
1022 | c = (unsigned char) va_arg(args, int); | ||
1023 | if (str < end) | ||
1024 | *str = c; | ||
1025 | ++str; | ||
1026 | while (--spec.field_width > 0) { | ||
874 | if (str < end) | 1027 | if (str < end) |
875 | *str = '%'; | 1028 | *str = ' '; |
876 | ++str; | 1029 | ++str; |
877 | continue; | 1030 | } |
1031 | break; | ||
878 | 1032 | ||
879 | /* integer number formats - set up the flags and "break" */ | 1033 | case FORMAT_TYPE_STR: |
880 | case 'o': | 1034 | str = string(str, end, va_arg(args, char *), spec); |
881 | base = 8; | 1035 | break; |
882 | break; | ||
883 | 1036 | ||
884 | case 'x': | 1037 | case FORMAT_TYPE_PTR: |
885 | flags |= SMALL; | 1038 | str = pointer(fmt+1, str, end, va_arg(args, void *), |
886 | case 'X': | 1039 | spec); |
887 | base = 16; | 1040 | while (isalnum(*fmt)) |
888 | break; | 1041 | fmt++; |
1042 | break; | ||
889 | 1043 | ||
890 | case 'd': | 1044 | case FORMAT_TYPE_PERCENT_CHAR: |
891 | case 'i': | 1045 | if (str < end) |
892 | flags |= SIGN; | 1046 | *str = '%'; |
893 | case 'u': | 1047 | ++str; |
894 | break; | 1048 | break; |
895 | 1049 | ||
896 | default: | 1050 | case FORMAT_TYPE_INVALID: |
1051 | if (str < end) | ||
1052 | *str = '%'; | ||
1053 | ++str; | ||
1054 | if (*fmt) { | ||
897 | if (str < end) | 1055 | if (str < end) |
898 | *str = '%'; | 1056 | *str = *fmt; |
899 | ++str; | 1057 | ++str; |
900 | if (*fmt) { | 1058 | } else { |
901 | if (str < end) | 1059 | --fmt; |
902 | *str = *fmt; | 1060 | } |
903 | ++str; | 1061 | break; |
904 | } else { | 1062 | |
905 | --fmt; | 1063 | case FORMAT_TYPE_NRCHARS: { |
906 | } | 1064 | int qualifier = spec.qualifier; |
907 | continue; | 1065 | |
1066 | if (qualifier == 'l') { | ||
1067 | long *ip = va_arg(args, long *); | ||
1068 | *ip = (str - buf); | ||
1069 | } else if (qualifier == 'Z' || | ||
1070 | qualifier == 'z') { | ||
1071 | size_t *ip = va_arg(args, size_t *); | ||
1072 | *ip = (str - buf); | ||
1073 | } else { | ||
1074 | int *ip = va_arg(args, int *); | ||
1075 | *ip = (str - buf); | ||
1076 | } | ||
1077 | break; | ||
908 | } | 1078 | } |
909 | if (qualifier == 'L') | 1079 | |
910 | num = va_arg(args, long long); | 1080 | default: |
911 | else if (qualifier == 'l') { | 1081 | switch (spec.type) { |
912 | num = va_arg(args, unsigned long); | 1082 | case FORMAT_TYPE_LONG_LONG: |
913 | if (flags & SIGN) | 1083 | num = va_arg(args, long long); |
914 | num = (signed long) num; | 1084 | break; |
915 | } else if (qualifier == 'Z' || qualifier == 'z') { | 1085 | case FORMAT_TYPE_ULONG: |
916 | num = va_arg(args, size_t); | 1086 | num = va_arg(args, unsigned long); |
917 | } else if (qualifier == 't') { | 1087 | break; |
918 | num = va_arg(args, ptrdiff_t); | 1088 | case FORMAT_TYPE_LONG: |
919 | } else if (qualifier == 'h') { | 1089 | num = va_arg(args, long); |
920 | num = (unsigned short) va_arg(args, int); | 1090 | break; |
921 | if (flags & SIGN) | 1091 | case FORMAT_TYPE_SIZE_T: |
922 | num = (signed short) num; | 1092 | num = va_arg(args, size_t); |
923 | } else { | 1093 | break; |
924 | num = va_arg(args, unsigned int); | 1094 | case FORMAT_TYPE_PTRDIFF: |
925 | if (flags & SIGN) | 1095 | num = va_arg(args, ptrdiff_t); |
926 | num = (signed int) num; | 1096 | break; |
1097 | case FORMAT_TYPE_USHORT: | ||
1098 | num = (unsigned short) va_arg(args, int); | ||
1099 | break; | ||
1100 | case FORMAT_TYPE_SHORT: | ||
1101 | num = (short) va_arg(args, int); | ||
1102 | break; | ||
1103 | case FORMAT_TYPE_INT: | ||
1104 | num = (int) va_arg(args, int); | ||
1105 | break; | ||
1106 | default: | ||
1107 | num = va_arg(args, unsigned int); | ||
1108 | } | ||
1109 | |||
1110 | str = number(str, end, num, spec); | ||
927 | } | 1111 | } |
928 | str = number(str, end, num, base, | ||
929 | field_width, precision, flags); | ||
930 | } | 1112 | } |
1113 | |||
931 | if (size > 0) { | 1114 | if (size > 0) { |
932 | if (str < end) | 1115 | if (str < end) |
933 | *str = '\0'; | 1116 | *str = '\0'; |
934 | else | 1117 | else |
935 | end[-1] = '\0'; | 1118 | end[-1] = '\0'; |
936 | } | 1119 | } |
1120 | |||
937 | /* the trailing null byte doesn't count towards the total */ | 1121 | /* the trailing null byte doesn't count towards the total */ |
938 | return str-buf; | 1122 | return str-buf; |
1123 | |||
939 | } | 1124 | } |
940 | EXPORT_SYMBOL(vsnprintf); | 1125 | EXPORT_SYMBOL(vsnprintf); |
941 | 1126 | ||
@@ -1058,6 +1243,372 @@ int sprintf(char * buf, const char *fmt, ...) | |||
1058 | } | 1243 | } |
1059 | EXPORT_SYMBOL(sprintf); | 1244 | EXPORT_SYMBOL(sprintf); |
1060 | 1245 | ||
1246 | #ifdef CONFIG_BINARY_PRINTF | ||
1247 | /* | ||
1248 | * bprintf service: | ||
1249 | * vbin_printf() - VA arguments to binary data | ||
1250 | * bstr_printf() - Binary data to text string | ||
1251 | */ | ||
1252 | |||
1253 | /** | ||
1254 | * vbin_printf - Parse a format string and place args' binary value in a buffer | ||
1255 | * @bin_buf: The buffer to place args' binary value | ||
1256 | * @size: The size of the buffer(by words(32bits), not characters) | ||
1257 | * @fmt: The format string to use | ||
1258 | * @args: Arguments for the format string | ||
1259 | * | ||
1260 | * The format follows C99 vsnprintf, except %n is ignored, and its argument | ||
1261 | * is skiped. | ||
1262 | * | ||
1263 | * The return value is the number of words(32bits) which would be generated for | ||
1264 | * the given input. | ||
1265 | * | ||
1266 | * NOTE: | ||
1267 | * If the return value is greater than @size, the resulting bin_buf is NOT | ||
1268 | * valid for bstr_printf(). | ||
1269 | */ | ||
1270 | int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args) | ||
1271 | { | ||
1272 | struct printf_spec spec = {0}; | ||
1273 | char *str, *end; | ||
1274 | int read; | ||
1275 | |||
1276 | str = (char *)bin_buf; | ||
1277 | end = (char *)(bin_buf + size); | ||
1278 | |||
1279 | #define save_arg(type) \ | ||
1280 | do { \ | ||
1281 | if (sizeof(type) == 8) { \ | ||
1282 | unsigned long long value; \ | ||
1283 | str = PTR_ALIGN(str, sizeof(u32)); \ | ||
1284 | value = va_arg(args, unsigned long long); \ | ||
1285 | if (str + sizeof(type) <= end) { \ | ||
1286 | *(u32 *)str = *(u32 *)&value; \ | ||
1287 | *(u32 *)(str + 4) = *((u32 *)&value + 1); \ | ||
1288 | } \ | ||
1289 | } else { \ | ||
1290 | unsigned long value; \ | ||
1291 | str = PTR_ALIGN(str, sizeof(type)); \ | ||
1292 | value = va_arg(args, int); \ | ||
1293 | if (str + sizeof(type) <= end) \ | ||
1294 | *(typeof(type) *)str = (type)value; \ | ||
1295 | } \ | ||
1296 | str += sizeof(type); \ | ||
1297 | } while (0) | ||
1298 | |||
1299 | |||
1300 | while (*fmt) { | ||
1301 | read = format_decode(fmt, &spec); | ||
1302 | |||
1303 | fmt += read; | ||
1304 | |||
1305 | switch (spec.type) { | ||
1306 | case FORMAT_TYPE_NONE: | ||
1307 | break; | ||
1308 | |||
1309 | case FORMAT_TYPE_WIDTH: | ||
1310 | case FORMAT_TYPE_PRECISION: | ||
1311 | save_arg(int); | ||
1312 | break; | ||
1313 | |||
1314 | case FORMAT_TYPE_CHAR: | ||
1315 | save_arg(char); | ||
1316 | break; | ||
1317 | |||
1318 | case FORMAT_TYPE_STR: { | ||
1319 | const char *save_str = va_arg(args, char *); | ||
1320 | size_t len; | ||
1321 | if ((unsigned long)save_str > (unsigned long)-PAGE_SIZE | ||
1322 | || (unsigned long)save_str < PAGE_SIZE) | ||
1323 | save_str = "<NULL>"; | ||
1324 | len = strlen(save_str); | ||
1325 | if (str + len + 1 < end) | ||
1326 | memcpy(str, save_str, len + 1); | ||
1327 | str += len + 1; | ||
1328 | break; | ||
1329 | } | ||
1330 | |||
1331 | case FORMAT_TYPE_PTR: | ||
1332 | save_arg(void *); | ||
1333 | /* skip all alphanumeric pointer suffixes */ | ||
1334 | while (isalnum(*fmt)) | ||
1335 | fmt++; | ||
1336 | break; | ||
1337 | |||
1338 | case FORMAT_TYPE_PERCENT_CHAR: | ||
1339 | break; | ||
1340 | |||
1341 | case FORMAT_TYPE_INVALID: | ||
1342 | if (!*fmt) | ||
1343 | --fmt; | ||
1344 | break; | ||
1345 | |||
1346 | case FORMAT_TYPE_NRCHARS: { | ||
1347 | /* skip %n 's argument */ | ||
1348 | int qualifier = spec.qualifier; | ||
1349 | void *skip_arg; | ||
1350 | if (qualifier == 'l') | ||
1351 | skip_arg = va_arg(args, long *); | ||
1352 | else if (qualifier == 'Z' || qualifier == 'z') | ||
1353 | skip_arg = va_arg(args, size_t *); | ||
1354 | else | ||
1355 | skip_arg = va_arg(args, int *); | ||
1356 | break; | ||
1357 | } | ||
1358 | |||
1359 | default: | ||
1360 | switch (spec.type) { | ||
1361 | |||
1362 | case FORMAT_TYPE_LONG_LONG: | ||
1363 | save_arg(long long); | ||
1364 | break; | ||
1365 | case FORMAT_TYPE_ULONG: | ||
1366 | case FORMAT_TYPE_LONG: | ||
1367 | save_arg(unsigned long); | ||
1368 | break; | ||
1369 | case FORMAT_TYPE_SIZE_T: | ||
1370 | save_arg(size_t); | ||
1371 | break; | ||
1372 | case FORMAT_TYPE_PTRDIFF: | ||
1373 | save_arg(ptrdiff_t); | ||
1374 | break; | ||
1375 | case FORMAT_TYPE_USHORT: | ||
1376 | case FORMAT_TYPE_SHORT: | ||
1377 | save_arg(short); | ||
1378 | break; | ||
1379 | default: | ||
1380 | save_arg(int); | ||
1381 | } | ||
1382 | } | ||
1383 | } | ||
1384 | return (u32 *)(PTR_ALIGN(str, sizeof(u32))) - bin_buf; | ||
1385 | |||
1386 | #undef save_arg | ||
1387 | } | ||
1388 | EXPORT_SYMBOL_GPL(vbin_printf); | ||
1389 | |||
1390 | /** | ||
1391 | * bstr_printf - Format a string from binary arguments and place it in a buffer | ||
1392 | * @buf: The buffer to place the result into | ||
1393 | * @size: The size of the buffer, including the trailing null space | ||
1394 | * @fmt: The format string to use | ||
1395 | * @bin_buf: Binary arguments for the format string | ||
1396 | * | ||
1397 | * This function like C99 vsnprintf, but the difference is that vsnprintf gets | ||
1398 | * arguments from stack, and bstr_printf gets arguments from @bin_buf which is | ||
1399 | * a binary buffer that generated by vbin_printf. | ||
1400 | * | ||
1401 | * The format follows C99 vsnprintf, but has some extensions: | ||
1402 | * %pS output the name of a text symbol | ||
1403 | * %pF output the name of a function pointer | ||
1404 | * %pR output the address range in a struct resource | ||
1405 | * %n is ignored | ||
1406 | * | ||
1407 | * The return value is the number of characters which would | ||
1408 | * be generated for the given input, excluding the trailing | ||
1409 | * '\0', as per ISO C99. If you want to have the exact | ||
1410 | * number of characters written into @buf as return value | ||
1411 | * (not including the trailing '\0'), use vscnprintf(). If the | ||
1412 | * return is greater than or equal to @size, the resulting | ||
1413 | * string is truncated. | ||
1414 | */ | ||
1415 | int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf) | ||
1416 | { | ||
1417 | unsigned long long num; | ||
1418 | char *str, *end, c; | ||
1419 | const char *args = (const char *)bin_buf; | ||
1420 | |||
1421 | struct printf_spec spec = {0}; | ||
1422 | |||
1423 | if (unlikely((int) size < 0)) { | ||
1424 | /* There can be only one.. */ | ||
1425 | static char warn = 1; | ||
1426 | WARN_ON(warn); | ||
1427 | warn = 0; | ||
1428 | return 0; | ||
1429 | } | ||
1430 | |||
1431 | str = buf; | ||
1432 | end = buf + size; | ||
1433 | |||
1434 | #define get_arg(type) \ | ||
1435 | ({ \ | ||
1436 | typeof(type) value; \ | ||
1437 | if (sizeof(type) == 8) { \ | ||
1438 | args = PTR_ALIGN(args, sizeof(u32)); \ | ||
1439 | *(u32 *)&value = *(u32 *)args; \ | ||
1440 | *((u32 *)&value + 1) = *(u32 *)(args + 4); \ | ||
1441 | } else { \ | ||
1442 | args = PTR_ALIGN(args, sizeof(type)); \ | ||
1443 | value = *(typeof(type) *)args; \ | ||
1444 | } \ | ||
1445 | args += sizeof(type); \ | ||
1446 | value; \ | ||
1447 | }) | ||
1448 | |||
1449 | /* Make sure end is always >= buf */ | ||
1450 | if (end < buf) { | ||
1451 | end = ((void *)-1); | ||
1452 | size = end - buf; | ||
1453 | } | ||
1454 | |||
1455 | while (*fmt) { | ||
1456 | int read; | ||
1457 | const char *old_fmt = fmt; | ||
1458 | |||
1459 | read = format_decode(fmt, &spec); | ||
1460 | |||
1461 | fmt += read; | ||
1462 | |||
1463 | switch (spec.type) { | ||
1464 | case FORMAT_TYPE_NONE: { | ||
1465 | int copy = read; | ||
1466 | if (str < end) { | ||
1467 | if (copy > end - str) | ||
1468 | copy = end - str; | ||
1469 | memcpy(str, old_fmt, copy); | ||
1470 | } | ||
1471 | str += read; | ||
1472 | break; | ||
1473 | } | ||
1474 | |||
1475 | case FORMAT_TYPE_WIDTH: | ||
1476 | spec.field_width = get_arg(int); | ||
1477 | break; | ||
1478 | |||
1479 | case FORMAT_TYPE_PRECISION: | ||
1480 | spec.precision = get_arg(int); | ||
1481 | break; | ||
1482 | |||
1483 | case FORMAT_TYPE_CHAR: | ||
1484 | if (!(spec.flags & LEFT)) { | ||
1485 | while (--spec.field_width > 0) { | ||
1486 | if (str < end) | ||
1487 | *str = ' '; | ||
1488 | ++str; | ||
1489 | } | ||
1490 | } | ||
1491 | c = (unsigned char) get_arg(char); | ||
1492 | if (str < end) | ||
1493 | *str = c; | ||
1494 | ++str; | ||
1495 | while (--spec.field_width > 0) { | ||
1496 | if (str < end) | ||
1497 | *str = ' '; | ||
1498 | ++str; | ||
1499 | } | ||
1500 | break; | ||
1501 | |||
1502 | case FORMAT_TYPE_STR: { | ||
1503 | const char *str_arg = args; | ||
1504 | size_t len = strlen(str_arg); | ||
1505 | args += len + 1; | ||
1506 | str = string(str, end, (char *)str_arg, spec); | ||
1507 | break; | ||
1508 | } | ||
1509 | |||
1510 | case FORMAT_TYPE_PTR: | ||
1511 | str = pointer(fmt+1, str, end, get_arg(void *), spec); | ||
1512 | while (isalnum(*fmt)) | ||
1513 | fmt++; | ||
1514 | break; | ||
1515 | |||
1516 | case FORMAT_TYPE_PERCENT_CHAR: | ||
1517 | if (str < end) | ||
1518 | *str = '%'; | ||
1519 | ++str; | ||
1520 | break; | ||
1521 | |||
1522 | case FORMAT_TYPE_INVALID: | ||
1523 | if (str < end) | ||
1524 | *str = '%'; | ||
1525 | ++str; | ||
1526 | if (*fmt) { | ||
1527 | if (str < end) | ||
1528 | *str = *fmt; | ||
1529 | ++str; | ||
1530 | } else { | ||
1531 | --fmt; | ||
1532 | } | ||
1533 | break; | ||
1534 | |||
1535 | case FORMAT_TYPE_NRCHARS: | ||
1536 | /* skip */ | ||
1537 | break; | ||
1538 | |||
1539 | default: | ||
1540 | switch (spec.type) { | ||
1541 | |||
1542 | case FORMAT_TYPE_LONG_LONG: | ||
1543 | num = get_arg(long long); | ||
1544 | break; | ||
1545 | case FORMAT_TYPE_ULONG: | ||
1546 | num = get_arg(unsigned long); | ||
1547 | break; | ||
1548 | case FORMAT_TYPE_LONG: | ||
1549 | num = get_arg(unsigned long); | ||
1550 | break; | ||
1551 | case FORMAT_TYPE_SIZE_T: | ||
1552 | num = get_arg(size_t); | ||
1553 | break; | ||
1554 | case FORMAT_TYPE_PTRDIFF: | ||
1555 | num = get_arg(ptrdiff_t); | ||
1556 | break; | ||
1557 | case FORMAT_TYPE_USHORT: | ||
1558 | num = get_arg(unsigned short); | ||
1559 | break; | ||
1560 | case FORMAT_TYPE_SHORT: | ||
1561 | num = get_arg(short); | ||
1562 | break; | ||
1563 | case FORMAT_TYPE_UINT: | ||
1564 | num = get_arg(unsigned int); | ||
1565 | break; | ||
1566 | default: | ||
1567 | num = get_arg(int); | ||
1568 | } | ||
1569 | |||
1570 | str = number(str, end, num, spec); | ||
1571 | } | ||
1572 | } | ||
1573 | |||
1574 | if (size > 0) { | ||
1575 | if (str < end) | ||
1576 | *str = '\0'; | ||
1577 | else | ||
1578 | end[-1] = '\0'; | ||
1579 | } | ||
1580 | |||
1581 | #undef get_arg | ||
1582 | |||
1583 | /* the trailing null byte doesn't count towards the total */ | ||
1584 | return str - buf; | ||
1585 | } | ||
1586 | EXPORT_SYMBOL_GPL(bstr_printf); | ||
1587 | |||
1588 | /** | ||
1589 | * bprintf - Parse a format string and place args' binary value in a buffer | ||
1590 | * @bin_buf: The buffer to place args' binary value | ||
1591 | * @size: The size of the buffer(by words(32bits), not characters) | ||
1592 | * @fmt: The format string to use | ||
1593 | * @...: Arguments for the format string | ||
1594 | * | ||
1595 | * The function returns the number of words(u32) written | ||
1596 | * into @bin_buf. | ||
1597 | */ | ||
1598 | int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) | ||
1599 | { | ||
1600 | va_list args; | ||
1601 | int ret; | ||
1602 | |||
1603 | va_start(args, fmt); | ||
1604 | ret = vbin_printf(bin_buf, size, fmt, args); | ||
1605 | va_end(args); | ||
1606 | return ret; | ||
1607 | } | ||
1608 | EXPORT_SYMBOL_GPL(bprintf); | ||
1609 | |||
1610 | #endif /* CONFIG_BINARY_PRINTF */ | ||
1611 | |||
1061 | /** | 1612 | /** |
1062 | * vsscanf - Unformat a buffer into a list of arguments | 1613 | * vsscanf - Unformat a buffer into a list of arguments |
1063 | * @buf: input buffer | 1614 | * @buf: input buffer |