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

 /** @addtogroup genericconsole
  * @{
  */
 /**
- * @file    cmd.c
+ * @file  cmd.c
- * @brief   Kernel console command wrappers.
+ * @brief Kernel console command wrappers.
+ *
  * This file is meant to contain all wrapper functions for
  * all kconsole commands. The point is in separating
  * kconsole specific wrappers from kconsole-unaware functions
  * from other subsystems.
 #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 <ipc/event.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,
     &call2_info,
     &call3_info,
     &continue_info,
     &cpus_info,
     &desc_info,
-    &exit_info,
     &reboot_info,
     &uptime_info,
     &halt_info,
     &help_info,
     &ipc_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;
+    count_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 (str_length(hlp->name) > len)
+            len = str_length(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.
  * @return 0 on failure, 1 on success.
  */
 int cmd_desc(cmd_arg_t *argv)
+{
     link_t *cur;
     spinlock_lock(&cmd_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);
-        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
+        if (str_lcmp(hlp->name, (const char *) argv->buffer, str_length(hlp->name)) == 0) {
             printf("%s - %s\n", hlp->name, hlp->description);
             if (hlp->help)
                 hlp->help();
             spinlock_unlock(&hlp->lock);
             break;
+        }
         spinlock_unlock(&hlp->lock);
+    }
     spinlock_unlock(&cmd_lock);
     return 1;
+}
 /** Search symbol table */
 int cmd_symaddr(cmd_arg_t *argv)
 /** 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;
+}
  * return Always 1.
  */
 int cmd_continue(cmd_arg_t *argv)
+{
     printf("The kernel will now relinquish the console.\n");
-    printf("Use userspace controls to redraw the screen.\n");
-    arch_release_console();
+    release_console();
+    event_notify_0(EVENT_KCONSOLE);
+    indev_pop_character(stdin);
     return 1;
+}
 #ifdef CONFIG_TEST
 /** Command for printing kernel tests list.
+ *
  * return Always 1.
  */
 int cmd_tests(cmd_arg_t *argv)
+{
+    count_t len = 0;
     test_t *test;
+    for (test = tests; test->name != NULL; test++) {
+        if (str_length(test->name) > len)
+            len = str_length(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);
     uint64_t t0 = task_get_accounting(TASK);
     spinlock_unlock(&TASK->lock);
     interrupts_restore(ipl);
     /* Execute the test */
+    test_quiet = false;
-    char * ret = test->entry(false);
+    char *ret = test->entry();
     /* Update and read thread accounting */
     ipl = interrupts_disable();
     spinlock_lock(&TASK->lock);
     uint64_t dt = task_get_accounting(TASK) - t0;
         uint64_t t0 = task_get_accounting(TASK);
         spinlock_unlock(&TASK->lock);
         interrupts_restore(ipl);
         /* Execute the test */
+        test_quiet = true;
-        char * ret = test->entry(true);
+        char * ret = test->entry();
         /* Update and read thread accounting */
         ipl = interrupts_disable();
         spinlock_lock(&TASK->lock);
         uint64_t dt = task_get_accounting(TASK) - t0;
  */
 int cmd_test(cmd_arg_t *argv)
+{
     test_t *test;
-    if (strcmp((char *) argv->buffer, "*") == 0) {
+    if (str_cmp((char *) argv->buffer, "*") == 0) {
         for (test = tests; test->name != NULL; test++) {
             if (test->safe) {
                 printf("\n");
                 if (!run_test(test))
                     break;
+        }
     } else {
         bool fnd = false;
         for (test = tests; test->name != NULL; test++) {
-            if (strcmp(test->name, (char *) argv->buffer) == 0) {
+            if (str_cmp(test->name, (char *) argv->buffer) == 0) {
                 fnd = true;
                 run_test(test);
                 break;
+            }
+        }
 int cmd_bench(cmd_arg_t *argv)
+{
     test_t *test;
     uint32_t cnt = argv[1].intval;
-    bool fnd = false;
+    if (str_cmp((char *) argv->buffer, "*") == 0) {
-    for (test = tests; test->name != NULL; test++) {
+        for (test = tests; test->name != NULL; test++) {
-        if (strcmp(test->name, (char *) argv->buffer) == 0) {
-            fnd = true;
-            if (test->safe)
+            if (test->safe) {
-                run_bench(test, cnt);
+                if (!run_bench(test, cnt))
-            else
+                    break;
-                printf("Unsafe test\n");
+            }
-            break;
+        }
-    }
+    } else {
+        bool fnd = false;
+        for (test = tests; test->name != NULL; test++) {
+            if (str_cmp(test->name, (char *) argv->buffer) == 0) {
+                fnd = true;
+                if (test->safe)
+                    run_bench(test, cnt);
+                else
+                    printf("Unsafe test\n");
+                break;
+            }
+        }
-    if (!fnd)
+        if (!fnd)
-        printf("Unknown test\n");
+            printf("Unknown test\n");
+    }
     return 1;
+}
 #endif

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/generic/src/console/cmd.c @ 4692 – Rev 3471 → 4377