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 |