Subversion Repositories HelenOS

Rev

Rev 4055 | Rev 4201 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4055 Rev 4156
Line 51... Line 51...
51
#include <config.h>
51
#include <config.h>
52
#include <func.h>
52
#include <func.h>
53
#include <string.h>
53
#include <string.h>
54
#include <macros.h>
54
#include <macros.h>
55
#include <debug.h>
55
#include <debug.h>
56
#include <symtab.h>
-
 
57
#include <cpu.h>
56
#include <cpu.h>
58
#include <mm/tlb.h>
57
#include <mm/tlb.h>
59
#include <arch/mm/tlb.h>
58
#include <arch/mm/tlb.h>
60
#include <mm/frame.h>
59
#include <mm/frame.h>
61
#include <main/version.h>
60
#include <main/version.h>
Line 63... Line 62...
63
#include <proc/scheduler.h>
62
#include <proc/scheduler.h>
64
#include <proc/thread.h>
63
#include <proc/thread.h>
65
#include <proc/task.h>
64
#include <proc/task.h>
66
#include <ipc/ipc.h>
65
#include <ipc/ipc.h>
67
#include <ipc/irq.h>
66
#include <ipc/irq.h>
-
 
67
#include <symtab.h>
-
 
68
#include <errno.h>
68
 
69
 
69
#ifdef CONFIG_TEST
70
#ifdef CONFIG_TEST
70
#include <test.h>
71
#include <test.h>
71
#endif
72
#endif
72
 
73
 
Line 77... Line 78...
77
    .description = "List of supported commands.",
78
    .description = "List of supported commands.",
78
    .func = cmd_help,
79
    .func = cmd_help,
79
    .argc = 0
80
    .argc = 0
80
};
81
};
81
 
82
 
82
static cmd_info_t exit_info = {
-
 
83
    .name = "exit",
-
 
84
    .description = "Exit kconsole.",
-
 
85
    .argc = 0
-
 
86
};
-
 
87
 
-
 
88
static int cmd_reboot(cmd_arg_t *argv);
83
static int cmd_reboot(cmd_arg_t *argv);
89
static cmd_info_t reboot_info = {
84
static cmd_info_t reboot_info = {
90
    .name = "reboot",
85
    .name = "reboot",
91
    .description = "Reboot.",
86
    .description = "Reboot.",
92
    .func = cmd_reboot,
87
    .func = cmd_reboot,
Line 455... Line 450...
455
    &call2_info,
450
    &call2_info,
456
    &call3_info,
451
    &call3_info,
457
    &continue_info,
452
    &continue_info,
458
    &cpus_info,
453
    &cpus_info,
459
    &desc_info,
454
    &desc_info,
460
    &exit_info,
-
 
461
    &reboot_info,
455
    &reboot_info,
462
    &uptime_info,
456
    &uptime_info,
463
    &halt_info,
457
    &halt_info,
464
    &help_info,
458
    &help_info,
465
    &ipc_info,
459
    &ipc_info,
Line 625... Line 619...
625
{
619
{
626
    uintptr_t symaddr;
620
    uintptr_t symaddr;
627
    char *symbol;
621
    char *symbol;
628
    unative_t (*fnc)(void);
622
    unative_t (*fnc)(void);
629
    fncptr_t fptr;
623
    fncptr_t fptr;
-
 
624
    int rc;
630
   
625
 
631
    symaddr = get_symbol_addr((char *) argv->buffer);
626
    symbol = (char *) argv->buffer;
-
 
627
    rc = symtab_addr_lookup(symbol, &symaddr);
-
 
628
 
632
    if (!symaddr)
629
    if (rc == ENOENT)
633
        printf("Symbol %s not found.\n", argv->buffer);
630
        printf("Symbol %s not found.\n", symbol);
634
    else if (symaddr == (uintptr_t) -1) {
631
    else if (rc == EOVERFLOW) {
635
        symtab_print_search((char *) argv->buffer);
632
        symtab_print_search(symbol);
636
        printf("Duplicate symbol, be more specific.\n");
633
        printf("Duplicate symbol, be more specific.\n");
637
    } else {
634
    } else if (rc == EOK) {
638
        symbol = get_symtab_entry(symaddr);
635
        fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
639
        fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
636
            (void *) symaddr, (void *) cmd_call0);
640
        printf("Calling %s() (%p)\n", symbol, symaddr);
637
        printf("Calling %s() (%p)\n", symbol, symaddr);
641
        printf("Result: %#" PRIxn "\n", fnc());
638
        printf("Result: %#" PRIxn "\n", fnc());
-
 
639
    } else {
-
 
640
        printf("No symbol information available.\n");
642
    }
641
    }
643
   
-
 
644
    return 1;
642
    return 1;
645
}
643
}
646
 
644
 
647
/** Call function with zero parameters on each CPU */
645
/** Call function with zero parameters on each CPU */
648
int cmd_mcall0(cmd_arg_t *argv)
646
int cmd_mcall0(cmd_arg_t *argv)
Line 679... Line 677...
679
    uintptr_t symaddr;
677
    uintptr_t symaddr;
680
    char *symbol;
678
    char *symbol;
681
    unative_t (*fnc)(unative_t, ...);
679
    unative_t (*fnc)(unative_t, ...);
682
    unative_t arg1 = argv[1].intval;
680
    unative_t arg1 = argv[1].intval;
683
    fncptr_t fptr;
681
    fncptr_t fptr;
-
 
682
    int rc;
684
   
683
 
685
    symaddr = get_symbol_addr((char *) argv->buffer);
684
    symbol = (char *) argv->buffer;
-
 
685
    rc = symtab_addr_lookup(symbol, &symaddr);
-
 
686
 
686
    if (!symaddr)
687
    if (rc == ENOENT) {
687
        printf("Symbol %s not found.\n", argv->buffer);
688
        printf("Symbol %s not found.\n", symbol);
688
    else if (symaddr == (uintptr_t) -1) {
689
    } else if (rc == EOVERFLOW) {
689
        symtab_print_search((char *) argv->buffer);
690
        symtab_print_search(symbol);
690
        printf("Duplicate symbol, be more specific.\n");
691
        printf("Duplicate symbol, be more specific.\n");
691
    } else {
692
    } else if (rc == EOK) {
692
        symbol = get_symtab_entry(symaddr);
-
 
693
        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);
694
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
694
        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
695
        printf("Result: %#" PRIxn "\n", fnc(arg1));
695
        printf("Result: %#" PRIxn "\n", fnc(arg1));
-
 
696
    } else {
-
 
697
        printf("No symbol information available.\n");
696
    }
698
    }
697
   
699
 
698
    return 1;
700
    return 1;
699
}
701
}
700
 
702
 
701
/** Call function with two parameters */
703
/** Call function with two parameters */
702
int cmd_call2(cmd_arg_t *argv)
704
int cmd_call2(cmd_arg_t *argv)
Line 705... Line 707...
705
    char *symbol;
707
    char *symbol;
706
    unative_t (*fnc)(unative_t, unative_t, ...);
708
    unative_t (*fnc)(unative_t, unative_t, ...);
707
    unative_t arg1 = argv[1].intval;
709
    unative_t arg1 = argv[1].intval;
708
    unative_t arg2 = argv[2].intval;
710
    unative_t arg2 = argv[2].intval;
709
    fncptr_t fptr;
711
    fncptr_t fptr;
-
 
712
    int rc;
710
   
713
 
711
    symaddr = get_symbol_addr((char *) argv->buffer);
714
    symbol = (char *) argv->buffer;
-
 
715
    rc = symtab_addr_lookup(symbol, &symaddr);
-
 
716
 
712
    if (!symaddr)
717
    if (rc == ENOENT) {
713
        printf("Symbol %s not found.\n", argv->buffer);
718
        printf("Symbol %s not found.\n", symbol);
714
    else if (symaddr == (uintptr_t) -1) {
719
    } else if (rc == EOVERFLOW) {
715
        symtab_print_search((char *) argv->buffer);
720
        symtab_print_search(symbol);
716
        printf("Duplicate symbol, be more specific.\n");
721
        printf("Duplicate symbol, be more specific.\n");
717
    } else {
722
    } else if (rc == EOK) {
718
        symbol = get_symtab_entry(symaddr);
-
 
719
        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);
720
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
724
        printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
721
               arg1, arg2, symaddr, symbol);
725
               arg1, arg2, symaddr, symbol);
722
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
726
        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
-
 
727
    } else {
-
 
728
        printf("No symbol information available.\n");
723
    }
729
    }
724
   
-
 
725
    return 1;
730
    return 1;
726
}
731
}
727
 
732
 
728
/** Call function with three parameters */
733
/** Call function with three parameters */
729
int cmd_call3(cmd_arg_t *argv)
734
int cmd_call3(cmd_arg_t *argv)
Line 733... Line 738...
733
    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
738
    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
734
    unative_t arg1 = argv[1].intval;
739
    unative_t arg1 = argv[1].intval;
735
    unative_t arg2 = argv[2].intval;
740
    unative_t arg2 = argv[2].intval;
736
    unative_t arg3 = argv[3].intval;
741
    unative_t arg3 = argv[3].intval;
737
    fncptr_t fptr;
742
    fncptr_t fptr;
-
 
743
    int rc;
738
   
744
   
739
    symaddr = get_symbol_addr((char *) argv->buffer);
745
    symbol = (char *) argv->buffer;
-
 
746
    rc = symtab_addr_lookup(symbol, &symaddr);
-
 
747
 
740
    if (!symaddr)
748
    if (rc == ENOENT) {
741
        printf("Symbol %s not found.\n", argv->buffer);
749
        printf("Symbol %s not found.\n", symbol);
742
    else if (symaddr == (uintptr_t) -1) {
750
    } else if (rc == EOVERFLOW) {
743
        symtab_print_search((char *) argv->buffer);
751
        symtab_print_search(symbol);
744
        printf("Duplicate symbol, be more specific.\n");
752
        printf("Duplicate symbol, be more specific.\n");
745
    } else {
753
    } else if (rc == EOK) {
746
        symbol = get_symtab_entry(symaddr);
-
 
747
        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);
748
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
755
        printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
749
               arg1, arg2, arg3, symaddr, symbol);
756
               arg1, arg2, arg3, symaddr, symbol);
750
        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");
751
    }
760
    }
752
   
-
 
753
    return 1;
761
    return 1;
754
}
762
}
755
 
763
 
756
 
764
 
757
/** Print detailed description of 'describe' command. */
765
/** Print detailed description of 'describe' command. */
Line 797... Line 805...
797
}
805
}
798
 
806
 
799
/** Write 4 byte value to address */
807
/** Write 4 byte value to address */
800
int cmd_set4(cmd_arg_t *argv)
808
int cmd_set4(cmd_arg_t *argv)
801
{
809
{
802
    uint32_t *addr;
810
    uintptr_t addr;
803
    uint32_t arg1 = argv[1].intval;
811
    uint32_t arg1 = argv[1].intval;
804
    bool pointer = false;
812
    bool pointer = false;
-
 
813
    int rc;
805
 
814
 
806
    if (((char *)argv->buffer)[0] == '*') {
815
    if (((char *)argv->buffer)[0] == '*') {
807
        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
816
        rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
808
        pointer = true;
817
        pointer = true;
809
    } else if (((char *) argv->buffer)[0] >= '0' &&
818
    } else if (((char *) argv->buffer)[0] >= '0' &&
810
           ((char *)argv->buffer)[0] <= '9')
819
           ((char *)argv->buffer)[0] <= '9') {
-
 
820
        rc = EOK;
811
        addr = (uint32_t *)atoi((char *)argv->buffer);
821
        addr = atoi((char *)argv->buffer);
812
    else
822
    } else {
813
        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
823
        rc = symtab_addr_lookup((char *) argv->buffer, &addr);
-
 
824
    }
814
 
825
 
815
    if (!addr)
826
    if (rc == ENOENT)
816
        printf("Symbol %s not found.\n", argv->buffer);
827
        printf("Symbol %s not found.\n", argv->buffer);
817
    else if (addr == (uint32_t *) -1) {
828
    else if (rc == EOVERFLOW) {
818
        symtab_print_search((char *) argv->buffer);
829
        symtab_print_search((char *) argv->buffer);
819
        printf("Duplicate symbol, be more specific.\n");
830
        printf("Duplicate symbol, be more specific.\n");
820
    } else {
831
    } else if (rc == EOK) {
821
        if (pointer)
832
        if (pointer)
822
            addr = (uint32_t *)(*(unative_t *)addr);
833
            addr = *(uintptr_t *) addr;
823
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
834
        printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
824
        *addr = arg1;
835
        *(uint32_t *) addr = arg1;
825
       
836
    } else {
-
 
837
        printf("No symbol information available.\n");
826
    }
838
    }
827
   
839
   
828
    return 1;
840
    return 1;
829
}
841
}
830
 
842