WebSVN – HelenOS – Diff – //branches/network/kernel/generic/src/console/cmd.c

 #include <arch/types.h>
 #include <adt/list.h>
 #include <arch.h>
 #include <config.h>
 #include <func.h>
+#include <string.h>
 #include <macros.h>
 #include <debug.h>
-#include <symtab.h>
 #include <cpu.h>
 #include <mm/tlb.h>
 #include <arch/mm/tlb.h>
 #include <mm/frame.h>
 #include <main/version.h>
 #include <proc/scheduler.h>
 #include <proc/thread.h>
 #include <proc/task.h>
 #include <ipc/ipc.h>
 #include <ipc/irq.h>
+#include <symtab.h>
+#include <errno.h>
 #ifdef CONFIG_TEST
 #include <test.h>
 #endif
     .description = "List of supported commands.",
     .func = cmd_help,
     .argc = 0
 };
-static cmd_info_t exit_info = {
-    .name = "exit",
-    .description = "Exit kconsole.",
-    .argc = 0
-};
 static int cmd_reboot(cmd_arg_t *argv);
 static cmd_info_t reboot_info = {
     .name = "reboot",
     .description = "Reboot.",
     .func = cmd_reboot,
     .description = "List of memory zones.",
     .func = cmd_zones,
     .argc = 0
 };
-/* Data and methods for 'ipc_task' command */
+/* Data and methods for 'ipc' command */
-static int cmd_ipc_task(cmd_arg_t *argv);
+static int cmd_ipc(cmd_arg_t *argv);
-static cmd_arg_t ipc_task_argv = {
+static cmd_arg_t ipc_argv = {
     .type = ARG_TYPE_INT,
 };
-static cmd_info_t ipc_task_info = {
+static cmd_info_t ipc_info = {
-    .name = "ipc_task",
+    .name = "ipc",
-    .description = "ipc_task <taskid> Show IPC information of given task.",
+    .description = "ipc <taskid> Show IPC information of given task.",
-    .func = cmd_ipc_task,
+    .func = cmd_ipc,
     .argc = 1,
-    .argv = &ipc_task_argv
+    .argv = &ipc_argv
 };
 /* Data and methods for 'zone' command */
 static int cmd_zone(cmd_arg_t *argv);
 static cmd_arg_t zone_argv = {
     &call2_info,
     &call3_info,
     &continue_info,
     &cpus_info,
     &desc_info,
-    &exit_info,
     &reboot_info,
     &uptime_info,
     &halt_info,
     &help_info,
-    &ipc_task_info,
+    &ipc_info,
     &set4_info,
     &slabs_info,
     &symaddr_info,
     &sched_info,
     &threads_info,
     unsigned int i;
     for (i = 0; basic_commands[i]; i++) {
         cmd_initialize(basic_commands[i]);
         if (!cmd_register(basic_commands[i]))
-            panic("could not register command %s\n", basic_commands[i]->name);
+            printf("Cannot register command %s\n", basic_commands[i]->name);
+    }
+}
 /** List supported commands.
+ *
  * @return 0 on failure, 1 on success.
  */
 int cmd_help(cmd_arg_t *argv)
+{
-    link_t *cur;
     spinlock_lock(&cmd_lock);
+    link_t *cur;
+    size_t len = 0;
     for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
         cmd_info_t *hlp;
         hlp = list_get_instance(cur, cmd_info_t, link);
         spinlock_lock(&hlp->lock);
+        if (strlen(hlp->name) > len)
+            len = strlen(hlp->name);
+        spinlock_unlock(&hlp->lock);
+    }
+    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
+        cmd_info_t *hlp;
+        hlp = list_get_instance(cur, cmd_info_t, link);
+        spinlock_lock(&hlp->lock);
-        printf("%s - %s\n", hlp->name, hlp->description);
+        printf("%-*s %s\n", len, hlp->name, hlp->description);
         spinlock_unlock(&hlp->lock);
+    }
     spinlock_unlock(&cmd_lock);
     return 1;
+}
 /** Reboot the system.
 /** Call function with zero parameters */
 int cmd_call0(cmd_arg_t *argv)
+{
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(void);
+    unative_t (*fnc)(void);
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
+    fncptr_t fptr;
-    } fptr;
+    int rc;
-#endif
-    symaddr = get_symbol_addr((char *) argv->buffer);
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
-    if (!symaddr)
+    if (rc == ENOENT)
-        printf("Symbol %s not found.\n", argv->buffer);
+        printf("Symbol %s not found.\n", symbol);
-    else if (symaddr == (uintptr_t) -1) {
+    else if (rc == EOVERFLOW) {
-        symtab_print_search((char *) argv->buffer);
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
+    } else if (rc == EOK) {
+        fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
-        symbol = get_symtab_entry(symaddr);
+            (void *) symaddr, (void *) cmd_call0);
         printf("Calling %s() (%p)\n", symbol, symaddr);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
+        printf("Result: %#" PRIxn "\n", fnc());
-        f =  (unative_t (*)(void)) &fptr;
-#else
+    } else {
-        f =  (unative_t (*)(void)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f());
+        printf("No symbol information available.\n");
+    }
     return 1;
+}
 /** Call function with zero parameters on each CPU */
 int cmd_mcall0(cmd_arg_t *argv)
 /** Call function with one parameter */
 int cmd_call1(cmd_arg_t *argv)
+{
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(unative_t,...);
+    unative_t (*fnc)(unative_t, ...);
     unative_t arg1 = argv[1].intval;
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
+    fncptr_t fptr;
-    } fptr;
+    int rc;
-#endif
-    symaddr = get_symbol_addr((char *) argv->buffer);
-    if (!symaddr)
-        printf("Symbol %s not found.\n", argv->buffer);
-    else if (symaddr == (uintptr_t) -1) {
-        symtab_print_search((char *) argv->buffer);
+    symbol = (char *) argv->buffer;
-        printf("Duplicate symbol, be more specific.\n");
-    } else {
-        symbol = get_symtab_entry(symaddr);
+    rc = symtab_addr_lookup(symbol, &symaddr);
+    if (rc == ENOENT) {
+        printf("Symbol %s not found.\n", symbol);
+    } else if (rc == EOVERFLOW) {
+        symtab_print_search(symbol);
+        printf("Duplicate symbol, be more specific.\n");
+    } else if (rc == EOK) {
+        fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
         printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
-        f =  (unative_t (*)(unative_t,...)) &fptr;
+        printf("Result: %#" PRIxn "\n", fnc(arg1));
-#else
+    } else {
-        f =  (unative_t (*)(unative_t,...)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f(arg1));
+        printf("No symbol information available.\n");
+    }
     return 1;
+}
 /** Call function with two parameters */
 int cmd_call2(cmd_arg_t *argv)
+{
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(unative_t,unative_t,...);
+    unative_t (*fnc)(unative_t, unative_t, ...);
     unative_t arg1 = argv[1].intval;
     unative_t arg2 = argv[2].intval;
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
+    fncptr_t fptr;
-    }fptr;
+    int rc;
-#endif
-    symaddr = get_symbol_addr((char *) argv->buffer);
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
-    if (!symaddr)
+    if (rc == ENOENT) {
-        printf("Symbol %s not found.\n", argv->buffer);
+        printf("Symbol %s not found.\n", symbol);
-    else if (symaddr == (uintptr_t) -1) {
+    } else if (rc == EOVERFLOW) {
-        symtab_print_search((char *) argv->buffer);
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
+    } else if (rc == EOK) {
-        symbol = get_symtab_entry(symaddr);
+        fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
         printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
                arg1, arg2, symaddr, symbol);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
+        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
-        f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
-#else
+    } else {
-        f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f(arg1, arg2));
+        printf("No symbol information available.\n");
+    }
     return 1;
+}
 /** Call function with three parameters */
 int cmd_call3(cmd_arg_t *argv)
+{
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(unative_t,unative_t,unative_t,...);
+    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
     unative_t arg1 = argv[1].intval;
     unative_t arg2 = argv[2].intval;
     unative_t arg3 = argv[3].intval;
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
+    fncptr_t fptr;
-    }fptr;
+    int rc;
-#endif
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
-    symaddr = get_symbol_addr((char *) argv->buffer);
-    if (!symaddr)
+    if (rc == ENOENT) {
-        printf("Symbol %s not found.\n", argv->buffer);
+        printf("Symbol %s not found.\n", symbol);
-    else if (symaddr == (uintptr_t) -1) {
+    } else if (rc == EOVERFLOW) {
-        symtab_print_search((char *) argv->buffer);
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
+    } else if (rc == EOK) {
-        symbol = get_symtab_entry(symaddr);
+        fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
         printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
                arg1, arg2, arg3, symaddr, symbol);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
-        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
+        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
-#else
+    } else {
-        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f(arg1, arg2, arg3));
+        printf("No symbol information available.\n");
+    }
     return 1;
+}
 /** Print detailed description of 'describe' command. */
+}
 /** Write 4 byte value to address */
 int cmd_set4(cmd_arg_t *argv)
+{
-    uint32_t *addr;
+    uintptr_t addr;
     uint32_t arg1 = argv[1].intval;
     bool pointer = false;
+    int rc;
     if (((char *)argv->buffer)[0] == '*') {
-        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
+        rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
         pointer = true;
     } else if (((char *) argv->buffer)[0] >= '0' &&
-           ((char *)argv->buffer)[0] <= '9')
+           ((char *)argv->buffer)[0] <= '9') {
+        rc = EOK;
-        addr = (uint32_t *)atoi((char *)argv->buffer);
+        addr = atoi((char *)argv->buffer);
-    else
+    } else {
-        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
+        rc = symtab_addr_lookup((char *) argv->buffer, &addr);
+    }
-    if (!addr)
+    if (rc == ENOENT)
         printf("Symbol %s not found.\n", argv->buffer);
-    else if (addr == (uint32_t *) -1) {
+    else if (rc == EOVERFLOW) {
         symtab_print_search((char *) argv->buffer);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
+    } else if (rc == EOK) {
         if (pointer)
-            addr = (uint32_t *)(*(unative_t *)addr);
+            addr = *(uintptr_t *) addr;
         printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
-        *addr = arg1;
+        *(uint32_t *) addr = arg1;
+    } else {
+        printf("No symbol information available.\n");
+    }
     return 1;
+}
+ *
  * @param argv Integer argument from cmdline expected
+ *
  * return Always 1
  */
-int cmd_ipc_task(cmd_arg_t * argv) {
+int cmd_ipc(cmd_arg_t * argv) {
     ipc_print_task(argv[0].intval);
     return 1;
+}
  * return Always 1.
  */
 int cmd_continue(cmd_arg_t *argv)
+{
     printf("The kernel will now relinquish the console.\n");
+    release_console();
-    printf("Use userspace controls to redraw the screen.\n");
+    if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
-    arch_release_console();
+        ipc_irq_send_msg_0(&kconsole_irq);
     return 1;
+}
 #ifdef CONFIG_TEST
 /** Command for printing kernel tests list.
+ *
  * return Always 1.
  */
 int cmd_tests(cmd_arg_t *argv)
+{
+    size_t len = 0;
     test_t *test;
+    for (test = tests; test->name != NULL; test++) {
+        if (strlen(test->name) > len)
+            len = strlen(test->name);
+    }
     for (test = tests; test->name != NULL; test++)
-        printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
+        printf("%-*s %s%s\n", len, test->name, test->desc, (test->safe ? "" : " (unsafe)"));
-    printf("*\t\tRun all safe tests\n");
+    printf("%-*s Run all safe tests\n", len, "*");
     return 1;
+}
 static bool run_test(const test_t *test)
+{
-    printf("%s\t\t%s\n", test->name, test->desc);
+    printf("%s (%s)\n", test->name, test->desc);
     /* Update and read thread accounting
        for benchmarking */
     ipl_t ipl = interrupts_disable();
     spinlock_lock(&TASK->lock);

Subversion Repositories HelenOS

(root)//branches/network/kernel/generic/src/console/cmd.c – Rev 3386 → 4153