Rev 4132 | Rev 4173 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
| Rev 4132 | Rev 4137 | ||
|---|---|---|---|
| Line 62... | Line 62... | ||
| 62 | #include <proc/scheduler.h> |
62 | #include <proc/scheduler.h> |
| 63 | #include <proc/thread.h> |
63 | #include <proc/thread.h> |
| 64 | #include <proc/task.h> |
64 | #include <proc/task.h> |
| 65 | #include <ipc/ipc.h> |
65 | #include <ipc/ipc.h> |
| 66 | #include <ipc/irq.h> |
66 | #include <ipc/irq.h> |
| 67 | - | ||
| 68 | #ifdef CONFIG_SYMTAB |
- | |
| 69 | #include <symtab.h> |
67 | #include <symtab.h> |
| 70 | #endif |
68 | #include <errno.h> |
| 71 | 69 | ||
| 72 | #ifdef CONFIG_TEST |
70 | #ifdef CONFIG_TEST |
| 73 | #include <test.h> |
71 | #include <test.h> |
| 74 | #endif |
72 | #endif |
| 75 | 73 | ||
| Line 168... | Line 166... | ||
| 168 | .func = cmd_desc, |
166 | .func = cmd_desc, |
| 169 | .argc = 1, |
167 | .argc = 1, |
| 170 | .argv = &desc_argv |
168 | .argv = &desc_argv |
| 171 | }; |
169 | }; |
| 172 | 170 | ||
| 173 | #ifdef CONFIG_SYMTAB |
- | |
| 174 | /* Data and methods for 'symaddr' command. */ |
171 | /* Data and methods for 'symaddr' command. */ |
| 175 | static int cmd_symaddr(cmd_arg_t *argv); |
172 | static int cmd_symaddr(cmd_arg_t *argv); |
| 176 | static char symaddr_buf[MAX_CMDLINE+1]; |
173 | static char symaddr_buf[MAX_CMDLINE+1]; |
| 177 | static cmd_arg_t symaddr_argv = { |
174 | static cmd_arg_t symaddr_argv = { |
| 178 | .type = ARG_TYPE_STRING, |
175 | .type = ARG_TYPE_STRING, |
| Line 184... | Line 181... | ||
| 184 | .description = "Return symbol address.", |
181 | .description = "Return symbol address.", |
| 185 | .func = cmd_symaddr, |
182 | .func = cmd_symaddr, |
| 186 | .argc = 1, |
183 | .argc = 1, |
| 187 | .argv = &symaddr_argv |
184 | .argv = &symaddr_argv |
| 188 | }; |
185 | }; |
| 189 | #endif |
- | |
| 190 | 186 | ||
| 191 | static char set_buf[MAX_CMDLINE+1]; |
187 | static char set_buf[MAX_CMDLINE+1]; |
| 192 | static int cmd_set4(cmd_arg_t *argv); |
188 | static int cmd_set4(cmd_arg_t *argv); |
| 193 | static cmd_arg_t set4_argv[] = { |
189 | static cmd_arg_t set4_argv[] = { |
| 194 | { |
190 | { |
| Line 461... | Line 457... | ||
| 461 | &halt_info, |
457 | &halt_info, |
| 462 | &help_info, |
458 | &help_info, |
| 463 | &ipc_info, |
459 | &ipc_info, |
| 464 | &set4_info, |
460 | &set4_info, |
| 465 | &slabs_info, |
461 | &slabs_info, |
| 466 | #ifdef CONFIG_SYMTAB |
- | |
| 467 | &symaddr_info, |
462 | &symaddr_info, |
| 468 | #endif |
- | |
| 469 | &sched_info, |
463 | &sched_info, |
| 470 | &threads_info, |
464 | &threads_info, |
| 471 | &tasks_info, |
465 | &tasks_info, |
| 472 | &physmem_info, |
466 | &physmem_info, |
| 473 | &tlb_info, |
467 | &tlb_info, |
| Line 610... | Line 604... | ||
| 610 | spinlock_unlock(&cmd_lock); |
604 | spinlock_unlock(&cmd_lock); |
| 611 | 605 | ||
| 612 | return 1; |
606 | return 1; |
| 613 | } |
607 | } |
| 614 | 608 | ||
| 615 | #ifdef CONFIG_SYMTAB |
- | |
| 616 | - | ||
| 617 | /** Search symbol table */ |
609 | /** Search symbol table */ |
| 618 | int cmd_symaddr(cmd_arg_t *argv) |
610 | int cmd_symaddr(cmd_arg_t *argv) |
| 619 | { |
611 | { |
| 620 | symtab_print_search((char *) argv->buffer); |
612 | symtab_print_search((char *) argv->buffer); |
| 621 | 613 | ||
| 622 | return 1; |
614 | return 1; |
| 623 | } |
615 | } |
| 624 | 616 | ||
| 625 | #endif |
- | |
| 626 | - | ||
| 627 | /** Call function with zero parameters */ |
617 | /** Call function with zero parameters */ |
| 628 | int cmd_call0(cmd_arg_t *argv) |
618 | int cmd_call0(cmd_arg_t *argv) |
| 629 | { |
619 | { |
| 630 | #ifdef CONFIG_SYMTAB |
- | |
| 631 | uintptr_t symaddr; |
620 | uintptr_t symaddr; |
| - | 621 | char *symbol; |
|
| 632 | unative_t (*fnc)(void); |
622 | unative_t (*fnc)(void); |
| 633 | fncptr_t fptr; |
623 | fncptr_t fptr; |
| - | 624 | int rc; |
|
| 634 | 625 | ||
| 635 | symaddr = get_symbol_addr((char *) argv->buffer); |
626 | symbol = (char *) argv->buffer; |
| - | 627 | rc = symtab_addr_lookup(symbol, &symaddr); |
|
| - | 628 | ||
| 636 | if (!symaddr) |
629 | if (rc == ENOENT) |
| 637 | printf("Symbol %s not found.\n", argv->buffer); |
630 | printf("Symbol %s not found.\n", symbol); |
| 638 | else if (symaddr == (uintptr_t) -1) { |
631 | else if (rc == EOVERFLOW) { |
| 639 | symtab_print_search((char *) argv->buffer); |
632 | symtab_print_search(symbol); |
| 640 | printf("Duplicate symbol, be more specific.\n"); |
633 | printf("Duplicate symbol, be more specific.\n"); |
| 641 | } else { |
634 | } else if (rc == EOK) { |
| 642 | fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0); |
635 | fnc = (unative_t (*)(void)) arch_construct_function(&fptr, |
| - | 636 | (void *) symaddr, (void *) cmd_call0); |
|
| 643 | printf("Calling %s() (%p)\n", argv->buffer, symaddr); |
637 | printf("Calling %s() (%p)\n", symbol, symaddr); |
| 644 | printf("Result: %#" PRIxn "\n", fnc()); |
638 | printf("Result: %#" PRIxn "\n", fnc()); |
| - | 639 | } else { |
|
| - | 640 | printf("No symbol information available.\n"); |
|
| 645 | } |
641 | } |
| 646 | #endif |
- | |
| 647 | return 1; |
642 | return 1; |
| 648 | } |
643 | } |
| 649 | 644 | ||
| 650 | /** Call function with zero parameters on each CPU */ |
645 | /** Call function with zero parameters on each CPU */ |
| 651 | int cmd_mcall0(cmd_arg_t *argv) |
646 | int cmd_mcall0(cmd_arg_t *argv) |
| Line 677... | Line 672... | ||
| 677 | } |
672 | } |
| 678 | 673 | ||
| 679 | /** Call function with one parameter */ |
674 | /** Call function with one parameter */ |
| 680 | int cmd_call1(cmd_arg_t *argv) |
675 | int cmd_call1(cmd_arg_t *argv) |
| 681 | { |
676 | { |
| 682 | #ifdef CONFIG_SYMTAB |
- | |
| 683 | uintptr_t symaddr; |
677 | uintptr_t symaddr; |
| 684 | char *symbol; |
678 | char *symbol; |
| 685 | unative_t (*fnc)(unative_t, ...); |
679 | unative_t (*fnc)(unative_t, ...); |
| 686 | unative_t arg1 = argv[1].intval; |
680 | unative_t arg1 = argv[1].intval; |
| 687 | fncptr_t fptr; |
681 | fncptr_t fptr; |
| 688 | 682 | int rc; |
|
| 689 | symaddr = get_symbol_addr((char *) argv->buffer); |
- | |
| 690 | 683 | ||
| - | 684 | symbol = (char *) argv->buffer; |
|
| - | 685 | rc = symtab_addr_lookup(symbol, &symaddr); |
|
| - | 686 | ||
| 691 | if (!symaddr) |
687 | if (rc == ENOENT) { |
| 692 | printf("Symbol %s not found.\n", argv->buffer); |
688 | printf("Symbol %s not found.\n", symbol); |
| 693 | else if (symaddr == (uintptr_t) -1) { |
689 | } else if (rc == EOVERFLOW) { |
| 694 | symtab_print_search((char *) argv->buffer); |
690 | symtab_print_search(symbol); |
| 695 | printf("Duplicate symbol, be more specific.\n"); |
691 | printf("Duplicate symbol, be more specific.\n"); |
| 696 | } else { |
692 | } else if (rc == EOK) { |
| 697 | symbol = get_symtab_entry(symaddr); |
- | |
| 698 | fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1); |
693 | fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1); |
| 699 | printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol); |
694 | printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol); |
| 700 | printf("Result: %#" PRIxn "\n", fnc(arg1)); |
695 | printf("Result: %#" PRIxn "\n", fnc(arg1)); |
| - | 696 | } else { |
|
| - | 697 | printf("No symbol information available.\n"); |
|
| 701 | } |
698 | } |
| 702 | #endif |
699 | |
| 703 | return 1; |
700 | return 1; |
| 704 | } |
701 | } |
| 705 | 702 | ||
| 706 | /** Call function with two parameters */ |
703 | /** Call function with two parameters */ |
| 707 | int cmd_call2(cmd_arg_t *argv) |
704 | int cmd_call2(cmd_arg_t *argv) |
| 708 | { |
705 | { |
| 709 | #ifdef CONFIG_SYMTAB |
- | |
| 710 | uintptr_t symaddr; |
706 | uintptr_t symaddr; |
| 711 | char *symbol; |
707 | char *symbol; |
| 712 | unative_t (*fnc)(unative_t, unative_t, ...); |
708 | unative_t (*fnc)(unative_t, unative_t, ...); |
| 713 | unative_t arg1 = argv[1].intval; |
709 | unative_t arg1 = argv[1].intval; |
| 714 | unative_t arg2 = argv[2].intval; |
710 | unative_t arg2 = argv[2].intval; |
| 715 | fncptr_t fptr; |
711 | fncptr_t fptr; |
| - | 712 | int rc; |
|
| 716 | 713 | ||
| 717 | symaddr = get_symbol_addr((char *) argv->buffer); |
714 | symbol = (char *) argv->buffer; |
| - | 715 | rc = symtab_addr_lookup(symbol, &symaddr); |
|
| - | 716 | ||
| 718 | if (!symaddr) |
717 | if (rc == ENOENT) { |
| 719 | printf("Symbol %s not found.\n", argv->buffer); |
718 | printf("Symbol %s not found.\n", symbol); |
| 720 | else if (symaddr == (uintptr_t) -1) { |
719 | } else if (rc == EOVERFLOW) { |
| 721 | symtab_print_search((char *) argv->buffer); |
720 | symtab_print_search(symbol); |
| 722 | printf("Duplicate symbol, be more specific.\n"); |
721 | printf("Duplicate symbol, be more specific.\n"); |
| 723 | } else { |
722 | } else if (rc == EOK) { |
| 724 | symbol = get_symtab_entry(symaddr); |
- | |
| 725 | fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2); |
723 | fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2); |
| 726 | printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n", |
724 | printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n", |
| 727 | arg1, arg2, symaddr, symbol); |
725 | arg1, arg2, symaddr, symbol); |
| 728 | printf("Result: %#" PRIxn "\n", fnc(arg1, arg2)); |
726 | printf("Result: %#" PRIxn "\n", fnc(arg1, arg2)); |
| - | 727 | } else { |
|
| - | 728 | printf("No symbol information available.\n"); |
|
| 729 | } |
729 | } |
| 730 | #endif |
- | |
| 731 | return 1; |
730 | return 1; |
| 732 | } |
731 | } |
| 733 | 732 | ||
| 734 | /** Call function with three parameters */ |
733 | /** Call function with three parameters */ |
| 735 | int cmd_call3(cmd_arg_t *argv) |
734 | int cmd_call3(cmd_arg_t *argv) |
| 736 | { |
735 | { |
| 737 | #ifdef CONFIG_SYMTAB |
- | |
| 738 | uintptr_t symaddr; |
736 | uintptr_t symaddr; |
| 739 | char *symbol; |
737 | char *symbol; |
| 740 | unative_t (*fnc)(unative_t, unative_t, unative_t, ...); |
738 | unative_t (*fnc)(unative_t, unative_t, unative_t, ...); |
| 741 | unative_t arg1 = argv[1].intval; |
739 | unative_t arg1 = argv[1].intval; |
| 742 | unative_t arg2 = argv[2].intval; |
740 | unative_t arg2 = argv[2].intval; |
| 743 | unative_t arg3 = argv[3].intval; |
741 | unative_t arg3 = argv[3].intval; |
| 744 | fncptr_t fptr; |
742 | fncptr_t fptr; |
| - | 743 | int rc; |
|
| 745 | 744 | ||
| 746 | symaddr = get_symbol_addr((char *) argv->buffer); |
745 | symbol = (char *) argv->buffer; |
| - | 746 | rc = symtab_addr_lookup(symbol, &symaddr); |
|
| - | 747 | ||
| 747 | if (!symaddr) |
748 | if (rc == ENOENT) { |
| 748 | printf("Symbol %s not found.\n", argv->buffer); |
749 | printf("Symbol %s not found.\n", symbol); |
| 749 | else if (symaddr == (uintptr_t) -1) { |
750 | } else if (rc == EOVERFLOW) { |
| 750 | symtab_print_search((char *) argv->buffer); |
751 | symtab_print_search(symbol); |
| 751 | printf("Duplicate symbol, be more specific.\n"); |
752 | printf("Duplicate symbol, be more specific.\n"); |
| 752 | } else { |
753 | } else if (rc == EOK) { |
| 753 | symbol = get_symtab_entry(symaddr); |
- | |
| 754 | fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3); |
754 | fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3); |
| 755 | printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n", |
755 | printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n", |
| 756 | arg1, arg2, arg3, symaddr, symbol); |
756 | arg1, arg2, arg3, symaddr, symbol); |
| 757 | printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3)); |
757 | printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3)); |
| - | 758 | } else { |
|
| - | 759 | printf("No symbol information available.\n"); |
|
| 758 | } |
760 | } |
| 759 | #endif |
- | |
| 760 | return 1; |
761 | return 1; |
| 761 | } |
762 | } |
| 762 | 763 | ||
| 763 | 764 | ||
| 764 | /** Print detailed description of 'describe' command. */ |
765 | /** Print detailed description of 'describe' command. */ |
| Line 804... | Line 805... | ||
| 804 | } |
805 | } |
| 805 | 806 | ||
| 806 | /** Write 4 byte value to address */ |
807 | /** Write 4 byte value to address */ |
| 807 | int cmd_set4(cmd_arg_t *argv) |
808 | int cmd_set4(cmd_arg_t *argv) |
| 808 | { |
809 | { |
| 809 | uint32_t *addr; |
810 | uintptr_t addr; |
| 810 | uint32_t arg1 = argv[1].intval; |
811 | uint32_t arg1 = argv[1].intval; |
| 811 | bool pointer = false; |
812 | bool pointer = false; |
| - | 813 | int rc; |
|
| 812 | 814 | ||
| 813 | if (((char *)argv->buffer)[0] == '*') { |
815 | if (((char *)argv->buffer)[0] == '*') { |
| 814 | #ifdef CONFIG_SYMTAB |
- | |
| 815 | addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1); |
816 | rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr); |
| 816 | #else |
- | |
| 817 | addr = 0; |
- | |
| 818 | #endif |
- | |
| 819 | pointer = true; |
817 | pointer = true; |
| 820 | } else if (((char *) argv->buffer)[0] >= '0' && |
818 | } else if (((char *) argv->buffer)[0] >= '0' && |
| 821 | ((char *)argv->buffer)[0] <= '9') { |
819 | ((char *)argv->buffer)[0] <= '9') { |
| - | 820 | rc = EOK; |
|
| 822 | addr = (uint32_t *)atoi((char *)argv->buffer); |
821 | addr = atoi((char *)argv->buffer); |
| 823 | } else { |
822 | } else { |
| 824 | #ifdef CONFIG_SYMTAB |
- | |
| 825 | addr = (uint32_t *)get_symbol_addr((char *) argv->buffer); |
823 | rc = symtab_addr_lookup((char *) argv->buffer, &addr); |
| 826 | #else |
- | |
| 827 | addr = 0; |
- | |
| 828 | #endif |
- | |
| 829 | } |
824 | } |
| 830 | 825 | ||
| 831 | if (!addr) |
826 | if (rc == ENOENT) |
| 832 | printf("Symbol %s not found.\n", argv->buffer); |
827 | printf("Symbol %s not found.\n", argv->buffer); |
| 833 | else if (addr == (uint32_t *) -1) { |
828 | else if (rc == EOVERFLOW) { |
| 834 | #ifdef CONFIG_SYMTAB |
- | |
| 835 | symtab_print_search((char *) argv->buffer); |
829 | symtab_print_search((char *) argv->buffer); |
| 836 | #endif |
- | |
| 837 | printf("Duplicate symbol, be more specific.\n"); |
830 | printf("Duplicate symbol, be more specific.\n"); |
| 838 | } else { |
831 | } else if (rc == EOK) { |
| 839 | if (pointer) |
832 | if (pointer) |
| 840 | addr = (uint32_t *)(*(unative_t *)addr); |
833 | addr = *(uintptr_t *) addr; |
| 841 | printf("Writing %#" PRIx64 " -> %p\n", arg1, addr); |
834 | printf("Writing %#" PRIx64 " -> %p\n", arg1, addr); |
| 842 | *addr = arg1; |
835 | *(uint32_t *) addr = arg1; |
| 843 | 836 | } else { |
|
| - | 837 | printf("No symbol information available.\n"); |
|
| 844 | } |
838 | } |
| 845 | 839 | ||
| 846 | return 1; |
840 | return 1; |
| 847 | } |
841 | } |
| 848 | 842 | ||