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

 #include <print.h>
 #include <panic.h>
 #include <arch/types.h>
 #include <adt/list.h>
 #include <arch.h>
+#include <config.h>
 #include <func.h>
 #include <macros.h>
 #include <debug.h>
 #include <symtab.h>
 #include <cpu.h>
     .argc = 0
 };
 static cmd_info_t exit_info = {
     .name = "exit",
-    .description = "Exit kconsole",
+    .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,
+    .argc = 0
+};
+static int cmd_uptime(cmd_arg_t *argv);
+static cmd_info_t uptime_info = {
+    .name = "uptime",
+    .description = "Print uptime information.",
+    .func = cmd_uptime,
     .argc = 0
 };
 static int cmd_continue(cmd_arg_t *argv);
 static cmd_info_t continue_info = {
     .argc = 2,
     .argv = set4_argv
 };
 /* Data and methods for 'call0' command. */
-static char call0_buf[MAX_CMDLINE+1];
+static char call0_buf[MAX_CMDLINE + 1];
-static char carg1_buf[MAX_CMDLINE+1];
+static char carg1_buf[MAX_CMDLINE + 1];
-static char carg2_buf[MAX_CMDLINE+1];
+static char carg2_buf[MAX_CMDLINE + 1];
-static char carg3_buf[MAX_CMDLINE+1];
+static char carg3_buf[MAX_CMDLINE + 1];
 static int cmd_call0(cmd_arg_t *argv);
 static cmd_arg_t call0_argv = {
     .type = ARG_TYPE_STRING,
     .buffer = call0_buf,
     .func = cmd_call0,
     .argc = 1,
     .argv = &call0_argv
 };
+/* Data and methods for 'mcall0' command. */
+static int cmd_mcall0(cmd_arg_t *argv);
+static cmd_arg_t mcall0_argv = {
+    .type = ARG_TYPE_STRING,
+    .buffer = call0_buf,
+    .len = sizeof(call0_buf)
+};
+static cmd_info_t mcall0_info = {
+    .name = "mcall0",
+    .description = "mcall0 <function> -> call function() on each CPU.",
+    .func = cmd_mcall0,
+    .argc = 1,
+    .argv = &mcall0_argv
+};
 /* Data and methods for 'call1' command. */
 static int cmd_call1(cmd_arg_t *argv);
 static cmd_arg_t call1_argv[] = {
+    {
         .type = ARG_TYPE_STRING,
     .argv = NULL
 };
 static cmd_info_t *basic_commands[] = {
     &call0_info,
+    &mcall0_info,
     &call1_info,
     &call2_info,
     &call3_info,
     &continue_info,
     &cpus_info,
     &desc_info,
     &exit_info,
+    &reboot_info,
+    &uptime_info,
     &halt_info,
     &help_info,
     &ipc_task_info,
     &set4_info,
     &slabs_info,
     spinlock_unlock(&cmd_lock);
     return 1;
+}
+/** Reboot the system.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+int cmd_reboot(cmd_arg_t *argv)
+{
+    reboot();
+    /* Not reached */
+    return 1;
+}
+/** Print system uptime information.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+int cmd_uptime(cmd_arg_t *argv)
+{
+    ASSERT(uptime);
+    /* This doesn't have to be very accurate */
+    unative_t sec = uptime->seconds1;
+    printf("Up %u days, %u hours, %u minutes, %u seconds\n",
+        sec / 86400, (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
+    return 1;
+}
 /** Describe specified command.
+ *
  * @param argv Argument vector.
+ *
  * @return 0 on failure, 1 on success.
     unative_t (*f)(void);
 #ifdef ia64
     struct {
         unative_t f;
         unative_t gp;
-    }fptr;
+    } fptr;
 #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);
         printf("Duplicate symbol, be more specific.\n");
     } else {
         symbol = get_symtab_entry(symaddr);
-        printf("Calling f(): %.*p: %s\n", sizeof(uintptr_t) * 2, symaddr, symbol);
+        printf("Calling %s() (%.*p)\n", symbol, sizeof(uintptr_t) * 2, symaddr);
 #ifdef ia64
         fptr.f = symaddr;
         fptr.gp = ((unative_t *)cmd_call2)[1];
         f =  (unative_t (*)(void)) &fptr;
 #else
+    }
     return 1;
+}
+/** Call function with zero parameters on each CPU */
+int cmd_mcall0(cmd_arg_t *argv)
+{
+    /*
+     * For each CPU, create a thread which will
+     * call the function.
+     */
+    count_t i;
+    for (i = 0; i < config.cpu_count; i++) {
+        thread_t *t;
+        if ((t = thread_create((void (*)(void *)) cmd_call0, (void *) argv, TASK, THREAD_FLAG_WIRED, "call0", false))) {
+            spinlock_lock(&t->lock);
+            t->cpu = &cpus[i];
+            spinlock_unlock(&t->lock);
+            printf("cpu%u: ", i);
+            thread_ready(t);
+            thread_join(t);
+            thread_detach(t);
+        } else
+            printf("Unable to create thread for cpu%u\n", i);
+    }
+    return 1;
+}
 /** Call function with one parameter */
 int cmd_call1(cmd_arg_t *argv)
+{
     uintptr_t symaddr;
     char *symbol;
+}
 /** Write 4 byte value to address */
 int cmd_set4(cmd_arg_t *argv)
+{
-    uint32_t *addr ;
+    uint32_t *addr;
     uint32_t arg1 = argv[1].intval;
     bool pointer = false;
     if (((char *)argv->buffer)[0] == '*') {
         addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);

Subversion Repositories HelenOS

(root)//branches/rcu/kernel/generic/src/console/cmd.c – Rev 2131 → 2307