WebSVN – HelenOS – Diff – /branches/dd/kernel/arch/mips32/src/debugger.c

  */
 /** @file
  */
 #include <arch/debugger.h>
+#include <arch/barrier.h>
 #include <memstr.h>
 #include <console/kconsole.h>
 #include <console/cmd.h>
 #include <symtab.h>
 #include <print.h>
 #include <func.h>
 bpinfo_t breakpoints[BKPOINTS_MAX];
 SPINLOCK_INITIALIZE(bkpoint_lock);
+#ifdef CONFIG_KCONSOLE
 static int cmd_print_breakpoints(cmd_arg_t *argv);
 static cmd_info_t bkpts_info = {
     .name = "bkpts",
     .description = "Print breakpoint table.",
     .func = cmd_print_breakpoints,
 static cmd_arg_t add_argv = {
     .type = ARG_TYPE_INT
 };
 static cmd_info_t addbkpt_info = {
     .name = "addbkpt",
-    .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch insts unsupported.",
+    .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch "
+        "insts unsupported.",
     .func = cmd_add_breakpoint,
     .argc = 1,
     .argv = &add_argv
 };
     { .type = ARG_TYPE_INT },
     { .type = ARG_TYPE_INT }
 };
 static cmd_info_t addbkpte_info = {
     .name = "addbkpte",
-    .description = "addebkpte <&symbol> <&func> - new bkpoint. Call func(or Nothing if 0).",
+    .description = "addebkpte <&symbol> <&func> - new bkpoint. Call "
+        "func(or Nothing if 0).",
     .func = cmd_add_breakpoint,
     .argc = 2,
     .argv = adde_argv
 };
 static struct {
     uint32_t andmask;
     uint32_t value;
-}jmpinstr[] = {
+} jmpinstr[] = {
     {0xf3ff0000, 0x41000000}, /* BCzF */
     {0xf3ff0000, 0x41020000}, /* BCzFL */
     {0xf3ff0000, 0x41010000}, /* BCzT */
     {0xf3ff0000, 0x41030000}, /* BCzTL */
     {0xfc000000, 0x10000000}, /* BEQ */
     {0xfc000000, 0x14000000}, /* BNE */
     {0xfc000000, 0x54000000}, /* BNEL */
     {0xfc000000, 0x08000000}, /* J */
     {0xfc000000, 0x0c000000}, /* JAL */
     {0xfc1f07ff, 0x00000009}, /* JALR */
-    {0,0} /* EndOfTable */
+    {0, 0} /* EndOfTable */
 };
 /** Test, if the given instruction is a jump or branch instruction
+ *
  * @param instr Instruction code
  * @return true - it is jump instruction, false otherwise
+ *
  */
 static bool is_jump(unative_t instr)
+{
     int i;
-    for (i=0;jmpinstr[i].andmask;i++) {
+    for (i = 0; jmpinstr[i].andmask; i++) {
         if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value)
             return true;
+    }
     return false;
+    }
     ipl = interrupts_disable();
     spinlock_lock(&bkpoint_lock);
     /* Check, that the breakpoints do not conflict */
-    for (i=0; i<BKPOINTS_MAX; i++) {
+    for (i = 0; i < BKPOINTS_MAX; i++) {
         if (breakpoints[i].address == (uintptr_t)argv->intval) {
             printf("Duplicate breakpoint %d.\n", i);
-            spinlock_unlock(&bkpoints_lock);
+            spinlock_unlock(&bkpoint_lock);
             return 0;
-        } else if (breakpoints[i].address == (uintptr_t)argv->intval + sizeof(unative_t) || \
+        } else if (breakpoints[i].address == (uintptr_t)argv->intval +
+            sizeof(unative_t) || breakpoints[i].address ==
-               breakpoints[i].address == (uintptr_t)argv->intval - sizeof(unative_t)) {
+            (uintptr_t)argv->intval - sizeof(unative_t)) {
-            printf("Adjacent breakpoints not supported, conflict with %d.\n", i);
+            printf("Adjacent breakpoints not supported, conflict "
+                "with %d.\n", i);
-            spinlock_unlock(&bkpoints_lock);
+            spinlock_unlock(&bkpoint_lock);
             return 0;
+        }
+    }
-    for (i=0; i<BKPOINTS_MAX; i++)
+    for (i = 0; i < BKPOINTS_MAX; i++)
         if (!breakpoints[i].address) {
             cur = &breakpoints[i];
             break;
+        }
     if (!cur) {
     cur->nextinstruction = ((unative_t *)cur->address)[1];
     if (argv == &add_argv) {
         cur->flags = 0;
     } else { /* We are add extended */
         cur->flags = BKPOINT_FUNCCALL;
-        cur->bkfunc =   (void (*)(void *, istate_t *)) argv[1].intval;
+        cur->bkfunc = (void (*)(void *, istate_t *)) argv[1].intval;
+    }
     if (is_jump(cur->instruction))
         cur->flags |= BKPOINT_ONESHOT;
     cur->counter = 0;
     /* Set breakpoint */
     *((unative_t *)cur->address) = 0x0d;
+    smc_coherence(cur->address);
     spinlock_unlock(&bkpoint_lock);
     interrupts_restore(ipl);
     return 1;
+}
 /** Remove breakpoint from table */
 int cmd_del_breakpoint(cmd_arg_t *argv)
+{
     bpinfo_t *cur;
     ipl_t ipl;
         spinlock_unlock(&bkpoint_lock);
         interrupts_restore(ipl);
         return 0;
+    }
     ((uint32_t *)cur->address)[0] = cur->instruction;
+    smc_coherence(((uint32_t *)cur->address)[0]);
     ((uint32_t *)cur->address)[1] = cur->nextinstruction;
+    smc_coherence(((uint32_t *)cur->address)[1]);
     cur->address = NULL;
     spinlock_unlock(&bkpoint_lock);
     interrupts_restore(ipl);
     for (i = 0; i < BKPOINTS_MAX; i++)
         if (breakpoints[i].address) {
             symbol = get_symtab_entry(breakpoints[i].address);
             printf("%-2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,
                 breakpoints[i].counter, breakpoints[i].address,
-                ((breakpoints[i].flags & BKPOINT_INPROG) ? "true" : "false"),
+                ((breakpoints[i].flags & BKPOINT_INPROG) ? "true" :
-                ((breakpoints[i].flags & BKPOINT_ONESHOT) ? "true" : "false"),
+                "false"), ((breakpoints[i].flags & BKPOINT_ONESHOT)
+                ? "true" : "false"), ((breakpoints[i].flags &
-                ((breakpoints[i].flags & BKPOINT_FUNCCALL) ? "true" : "false"),
+                BKPOINT_FUNCCALL) ? "true" : "false"), symbol);
-                symbol);
+        }
     return 1;
+}
+#endif
 /** Initialize debugger */
 void debugger_init()
+{
     int i;
-    for (i=0; i<BKPOINTS_MAX; i++)
+    for (i = 0; i < BKPOINTS_MAX; i++)
         breakpoints[i].address = NULL;
+#ifdef CONFIG_KCONSOLE
     cmd_initialize(&bkpts_info);
     if (!cmd_register(&bkpts_info))
-        panic("could not register command %s\n", bkpts_info.name);
+        printf("Cannot register command %s\n", bkpts_info.name);
     cmd_initialize(&delbkpt_info);
     if (!cmd_register(&delbkpt_info))
-        panic("could not register command %s\n", delbkpt_info.name);
+        printf("Cannot register command %s\n", delbkpt_info.name);
     cmd_initialize(&addbkpt_info);
     if (!cmd_register(&addbkpt_info))
-        panic("could not register command %s\n", addbkpt_info.name);
+        printf("Cannot register command %s\n", addbkpt_info.name);
     cmd_initialize(&addbkpte_info);
     if (!cmd_register(&addbkpte_info))
-        panic("could not register command %s\n", addbkpte_info.name);
+        printf("Cannot register command %s\n", addbkpte_info.name);
+#endif
+}
 /** Handle breakpoint
+ *
  * Find breakpoint in breakpoint table.
     uintptr_t fireaddr = istate->epc;
     int i;
     /* test branch delay slot */
     if (cp0_cause_read() & 0x80000000)
-        panic("Breakpoint in branch delay slot not supported.\n");
+        panic("Breakpoint in branch delay slot not supported.");
     spinlock_lock(&bkpoint_lock);
-    for (i=0; i<BKPOINTS_MAX; i++) {
+    for (i = 0; i < BKPOINTS_MAX; i++) {
         /* Normal breakpoint */
-        if (fireaddr == breakpoints[i].address \
+        if (fireaddr == breakpoints[i].address &&
-            && !(breakpoints[i].flags & BKPOINT_REINST)) {
+            !(breakpoints[i].flags & BKPOINT_REINST)) {
             cur = &breakpoints[i];
             break;
+        }
         /* Reinst only breakpoint */
-        if ((breakpoints[i].flags & BKPOINT_REINST) \
+        if ((breakpoints[i].flags & BKPOINT_REINST) &&
-            && (fireaddr ==breakpoints[i].address+sizeof(unative_t))) {
+            (fireaddr == breakpoints[i].address + sizeof(unative_t))) {
             cur = &breakpoints[i];
             break;
+        }
+    }
     if (cur) {
         if (cur->flags & BKPOINT_REINST) {
             /* Set breakpoint on first instruction */
             ((uint32_t *)cur->address)[0] = 0x0d;
+            smc_coherence(((uint32_t *)cur->address)[0]);
             /* Return back the second */
             ((uint32_t *)cur->address)[1] = cur->nextinstruction;
+            smc_coherence(((uint32_t *)cur->address)[1]);
             cur->flags &= ~BKPOINT_REINST;
             spinlock_unlock(&bkpoint_lock);
             return;
+        }
         if (cur->flags & BKPOINT_INPROG)
             printf("Warning: breakpoint recursion\n");
         if (!(cur->flags & BKPOINT_FUNCCALL))
-            printf("***Breakpoint %d: %p in %s.\n", i,
+            printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
-                   fireaddr, get_symtab_entry(istate->epc));
+                get_symtab_entry(istate->epc));
         /* Return first instruction back */
         ((uint32_t *)cur->address)[0] = cur->instruction;
+        smc_coherence(cur->address);
         if (! (cur->flags & BKPOINT_ONESHOT)) {
             /* Set Breakpoint on next instruction */
             ((uint32_t *)cur->address)[1] = 0x0d;
             cur->flags |= BKPOINT_REINST;
     if (cur && (cur->flags & BKPOINT_FUNCCALL)) {
         /* Allow zero bkfunc, just for counting */
         if (cur->bkfunc)
             cur->bkfunc(cur, istate);
     } else {
-        printf("***Type 'exit' to exit kconsole.\n");
+#ifdef CONFIG_KCONSOLE
         /* This disables all other processors - we are not SMP,
          * actually this gets us to cpu_halt, if scheduler() is run
          * - we generally do not want scheduler to be run from debug,
          *   so this is a good idea
          */
-        atomic_set(&haltstate,1);
+        atomic_set(&haltstate, 1);
         spinlock_unlock(&bkpoint_lock);
-        kconsole("debug");
+        kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);
         spinlock_lock(&bkpoint_lock);
-        atomic_set(&haltstate,0);
+        atomic_set(&haltstate, 0);
+#endif
+    }
     if (cur && cur->address == fireaddr && (cur->flags & BKPOINT_INPROG)) {
         /* Remove one-shot breakpoint */
         if ((cur->flags & BKPOINT_ONESHOT))
             cur->address = NULL;

Subversion Repositories HelenOS

(root)/branches/dd/kernel/arch/mips32/src/debugger.c – Rev 3022 → 4055