Changes in kernel/arch/amd64/src/debugger.c [e16e0d59:7e752b2] in mainline

File:

• kernel/arch/amd64/src/debugger.c (modified) (10 diffs)

kernel/arch/amd64/src/debugger.c

@@ -46 +46 @@
 #include <symtab.h>
 
+#ifdef __64_BITS__
+        #define getip(x)  ((x)->rip)
+#endif
+
+#ifdef __32_BITS__
+        #define getip(x)  ((x)->eip)
+#endif
+
 typedef struct  {
-        uintptr_t address;      /**< Breakpoint address */
-        int flags;              /**< Flags regarding breakpoint */
-        int counter;            /**< How many times the exception occured */
+        uintptr_t address;   /**< Breakpoint address */
+        unsigned int flags;  /**< Flags regarding breakpoint */
+        size_t counter;      /**< How many times the exception occured */
 } bpinfo_t;
 
 static bpinfo_t breakpoints[BKPOINTS_MAX];
-SPINLOCK_INITIALIZE(bkpoint_lock);
+IRQ_SPINLOCK_STATIC_INITIALIZE(bkpoint_lock);
 
 #ifdef CONFIG_KCONSOLE
 
-static int cmd_print_breakpoints(cmd_arg_t *argv);
+static int cmd_print_breakpoints(cmd_arg_t *);
+static int cmd_del_breakpoint(cmd_arg_t *);
+static int cmd_add_breakpoint(cmd_arg_t *);
+
 static cmd_info_t bkpts_info = {
         .name = "bkpts",
@@ -65 +76 @@
 };
 
-static int cmd_del_breakpoint(cmd_arg_t *argv);
 static cmd_arg_t del_argv = {
         .type = ARG_TYPE_INT
 };
+
 static cmd_info_t delbkpt_info = {
         .name = "delbkpt",
-        .description = "delbkpt <number> - Delete breakpoint.",
+        .description = "Delete breakpoint.",
         .func = cmd_del_breakpoint,
         .argc = 1,
@@ -77 +88 @@
 };
 
-static int cmd_add_breakpoint(cmd_arg_t *argv);
 static cmd_arg_t add_argv = {
         .type = ARG_TYPE_INT
 };
+
 static cmd_info_t addbkpt_info = {
         .name = "addbkpt",
-        .description = "addbkpt <&symbol> - new breakpoint.",
+        .description = "Add breakpoint.",
         .func = cmd_add_breakpoint,
         .argc = 1,
@@ -92 +103 @@
         .type = ARG_TYPE_INT
 };
+
 static cmd_info_t addwatchp_info = {
         .name = "addwatchp",
-        .description = "addbwatchp <&symbol> - new write watchpoint.",
+        .description = "Add write watchpoint.",
         .func = cmd_add_breakpoint,
         .argc = 1,
@@ -102 +114 @@
 #endif /* CONFIG_KCONSOLE */
 
-/* Setup DR register according to table */
+/** Setup DR register according to table
+ *
+ */
 static void setup_dr(int curidx)
 {
-        unative_t dr7;
+        ASSERT(curidx >= 0);
+        
         bpinfo_t *cur = &breakpoints[curidx];
-        int flags = breakpoints[curidx].flags;
-
+        unsigned int flags = breakpoints[curidx].flags;
+        
         /* Disable breakpoint in DR7 */
-        dr7 = read_dr7();
-        dr7 &= ~(0x2 << (curidx*2));
-
-        if (cur->address) { /* Setup DR register */
+        unative_t dr7 = read_dr7();
+        dr7 &= ~(0x02U << (curidx * 2));
+        
+        /* Setup DR register */
+        if (cur->address) {
                 /* Set breakpoint to debug registers */
                 switch (curidx) {
@@ -129 +145 @@
                         break;
                 }
+                
                 /* Set type to requested breakpoint & length*/
-                dr7 &= ~ (0x3 << (16 + 4*curidx));
-                dr7 &= ~ (0x3 << (18 + 4*curidx));
-                if ((flags & BKPOINT_INSTR)) {
-                        ;
-                } else {
+                dr7 &= ~(0x03U << (16 + 4 * curidx));
+                dr7 &= ~(0x03U << (18 + 4 * curidx));
                 
+                if (!(flags & BKPOINT_INSTR)) {
 #ifdef __32_BITS__
-                        dr7 |= ((unative_t) 0x3) << (18 + 4 * curidx);
-#endif
-
+                        dr7 |= ((unative_t) 0x03U) << (18 + 4 * curidx);
+#endif
+                        
 #ifdef __64_BITS__
-                        dr7 |= ((unative_t) 0x2) << (18 + 4 * curidx);
+                        dr7 |= ((unative_t) 0x02U) << (18 + 4 * curidx);
 #endif
                         
                         if ((flags & BKPOINT_WRITE))
-                                dr7 |= ((unative_t) 0x1) << (16 + 4 * curidx);
+                                dr7 |= ((unative_t) 0x01U) << (16 + 4 * curidx);
                         else if ((flags & BKPOINT_READ_WRITE))
-                                dr7 |= ((unative_t) 0x3) << (16 + 4 * curidx);
-                }
-
+                                dr7 |= ((unative_t) 0x03U) << (16 + 4 * curidx);
+                }
+                
                 /* Enable global breakpoint */
-                dr7 |= 0x2 << (curidx * 2);
-
+                dr7 |= 0x02U << (curidx * 2);
+                
                 write_dr7(dr7);
-                
-        } 
-}
-        
+        }
+}
+
 /** Enable hardware breakpoint
  *
  * @param where Address of HW breakpoint
  * @param flags Type of breakpoint (EXECUTE, WRITE)
+ *
  * @return Debug slot on success, -1 - no available HW breakpoint
- */
-int breakpoint_add(const void *where, const int flags, int curidx)
-{
-        ipl_t ipl;
-        int i;
-        bpinfo_t *cur;
-
+ *
+ */
+int breakpoint_add(const void *where, const unsigned int flags, int curidx)
+{
         ASSERT(flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
-
-        ipl = interrupts_disable();
-        spinlock_lock(&bkpoint_lock);
+        
+        irq_spinlock_lock(&bkpoint_lock, true);
         
         if (curidx == -1) {
                 /* Find free space in slots */
-                for (i = 0; i < BKPOINTS_MAX; i++)
+                unsigned int i;
+                for (i = 0; i < BKPOINTS_MAX; i++) {
                         if (!breakpoints[i].address) {
                                 curidx = i;
                                 break;
                         }
+                }
+                
                 if (curidx == -1) {
                         /* Too many breakpoints */
-                        spinlock_unlock(&bkpoint_lock);
-                        interrupts_restore(ipl);
+                        irq_spinlock_unlock(&bkpoint_lock, true);
                         return -1;
                 }
         }
-        cur = &breakpoints[curidx];
-
+        
+        bpinfo_t *cur = &breakpoints[curidx];
+        
         cur->address = (uintptr_t) where;
         cur->flags = flags;
         cur->counter = 0;
-
+        
         setup_dr(curidx);
-
-        spinlock_unlock(&bkpoint_lock);
-        interrupts_restore(ipl);
-
+        
+        irq_spinlock_unlock(&bkpoint_lock, true);
+        
         /* Send IPI */
-#ifdef CONFIG_SMP
 //      ipi_broadcast(VECTOR_DEBUG_IPI);
-#endif  
-
+        
         return curidx;
 }
 
-#ifdef __64_BITS__
-        #define getip(x)  ((x)->rip)
-#else
-        #define getip(x)  ((x)->eip)
-#endif
-
 static void handle_exception(int slot, istate_t *istate)
 {
+        ASSERT(slot >= 0);
         ASSERT(breakpoints[slot].address);
-
+        
         /* Handle zero checker */
-        if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
+        if (!(breakpoints[slot].flags & BKPOINT_INSTR)) {
                 if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
                         if (*((unative_t *) breakpoints[slot].address) != 0)
                                 return;
-                        printf("*** Found ZERO on address %lx (slot %d) ***\n",
-                            breakpoints[slot].address, slot);
+                        
+                        printf("*** Found ZERO on address %p (slot %d) ***\n",
+                            (void *) breakpoints[slot].address, slot);
                 } else {
-                        printf("Data watchpoint - new data: %lx\n",
+                        printf("Data watchpoint - new data: %#" PRIxn "\n",
                             *((unative_t *) breakpoints[slot].address));
                 }
         }
-
-        printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),
-            symtab_fmt_name_lookup(getip(istate)));
-
+        
+        printf("Reached breakpoint %d:%p (%s)\n", slot,
+            (void *) getip(istate), symtab_fmt_name_lookup(getip(istate)));
+        
 #ifdef CONFIG_KCONSOLE
         atomic_set(&haltstate, 1);
@@ -243 +250 @@
 void breakpoint_del(int slot)
 {
-        bpinfo_t *cur;
-        ipl_t ipl;
-
-        ipl = interrupts_disable();
-        spinlock_lock(&bkpoint_lock);
-
-        cur = &breakpoints[slot];
+        ASSERT(slot >= 0);
+        
+        irq_spinlock_lock(&bkpoint_lock, true);
+        
+        bpinfo_t *cur = &breakpoints[slot];
         if (!cur->address) {
-                spinlock_unlock(&bkpoint_lock);
-                interrupts_restore(ipl);
+                irq_spinlock_unlock(&bkpoint_lock, true);
                 return;
         }
-
-        cur->address = NULL;
-
+        
+        cur->address = (uintptr_t) NULL;
+        
         setup_dr(slot);
-
-        spinlock_unlock(&bkpoint_lock);
-        interrupts_restore(ipl);
-#ifdef CONFIG_SMP
-//      ipi_broadcast(VECTOR_DEBUG_IPI);        
-#endif
-}
-
-
-
-static void debug_exception(int n __attribute__((unused)), istate_t *istate)
-{
-        unative_t dr6;
-        int i;
-        
+        
+        irq_spinlock_unlock(&bkpoint_lock, true);
+//      ipi_broadcast(VECTOR_DEBUG_IPI);
+}
+
+static void debug_exception(unsigned int n __attribute__((unused)), istate_t *istate)
+{
         /* Set RF to restart the instruction  */
 #ifdef __64_BITS__
         istate->rflags |= RFLAGS_RF;
-#else
+#endif
+        
+#ifdef __32_BITS__
         istate->eflags |= EFLAGS_RF;
 #endif
-
-        dr6 = read_dr6();
-        for (i=0; i < BKPOINTS_MAX; i++) {
+        
+        unative_t dr6 = read_dr6();
+        
+        unsigned int i;
+        for (i = 0; i < BKPOINTS_MAX; i++) {
                 if (dr6 & (1 << i)) {
                         dr6 &= ~ (1 << i);
@@ -293 +293 @@
 
 #ifdef CONFIG_SMP
-static void
-debug_ipi(int n __attribute__((unused)),
+static void debug_ipi(unsigned int n __attribute__((unused)),
     istate_t *istate __attribute__((unused)))
 {
-        int i;
-
-        spinlock_lock(&bkpoint_lock);
+        irq_spinlock_lock(&bkpoint_lock, false);
+        
+        unsigned int i;
         for (i = 0; i < BKPOINTS_MAX; i++)
                 setup_dr(i);
-        spinlock_unlock(&bkpoint_lock);
-}
-#endif
-
-/** Initialize debugger */
+        
+        irq_spinlock_unlock(&bkpoint_lock, false);
+}
+#endif /* CONFIG_SMP */
+
+/** Initialize debugger
+ *
+ */
 void debugger_init()
 {
-        int i;
-
+        unsigned int i;
         for (i = 0; i < BKPOINTS_MAX; i++)
-                breakpoints[i].address = NULL;
-
+                breakpoints[i].address = (uintptr_t) NULL;
+        
 #ifdef CONFIG_KCONSOLE
         cmd_initialize(&bkpts_info);
         if (!cmd_register(&bkpts_info))
                 printf("Cannot register command %s\n", bkpts_info.name);
-
+        
         cmd_initialize(&delbkpt_info);
         if (!cmd_register(&delbkpt_info))
                 printf("Cannot register command %s\n", delbkpt_info.name);
-
+        
         cmd_initialize(&addbkpt_info);
         if (!cmd_register(&addbkpt_info))
                 printf("Cannot register command %s\n", addbkpt_info.name);
-
+        
         cmd_initialize(&addwatchp_info);
         if (!cmd_register(&addwatchp_info))
@@ -332 +333 @@
 #endif /* CONFIG_KCONSOLE */
         
-        exc_register(VECTOR_DEBUG, "debugger", debug_exception);
+        exc_register(VECTOR_DEBUG, "debugger", true,
+            debug_exception);
+        
 #ifdef CONFIG_SMP
-        exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
-#endif
+        exc_register(VECTOR_DEBUG_IPI, "debugger_smp", true,
+            debug_ipi);
+#endif /* CONFIG_SMP */
 }
 
 #ifdef CONFIG_KCONSOLE
-/** Print table of active breakpoints */
+/** Print table of active breakpoints
+ *
+ */
 int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
 {
+#ifdef __32_BITS__
+        printf("[nr] [count] [address ] [in symbol\n");
+#endif
+        
+#ifdef __64_BITS__
+        printf("[nr] [count] [address         ] [in symbol\n");
+#endif
+        
         unsigned int i;
-        char *symbol;
-
+        for (i = 0; i < BKPOINTS_MAX; i++) {
+                if (breakpoints[i].address) {
+                        const char *symbol = symtab_fmt_name_lookup(
+                            breakpoints[i].address);
+                        
 #ifdef __32_BITS__
-        printf("#  Count Address    In symbol\n");
-        printf("-- ----- ---------- ---------\n");
-#endif
-
+                        printf("%-4u %7zu %p %s\n", i,
+                            breakpoints[i].counter, (void *) breakpoints[i].address,
+                            symbol);
+#endif
+                        
 #ifdef __64_BITS__
-        printf("#  Count Address            In symbol\n");
-        printf("-- ----- ------------------ ---------\n");
-#endif
-        
-        for (i = 0; i < BKPOINTS_MAX; i++)
-                if (breakpoints[i].address) {
-                        symbol = symtab_fmt_name_lookup(
-                            breakpoints[i].address);
-
-#ifdef __32_BITS__
-                        printf("%-2u %-5d %#10zx %s\n", i,
-                            breakpoints[i].counter, breakpoints[i].address,
+                        printf("%-4u %7zu %p %s\n", i,
+                            breakpoints[i].counter, (void *) breakpoints[i].address,
                             symbol);
 #endif
-
-#ifdef __64_BITS__
-                        printf("%-2u %-5d %#18zx %s\n", i,
-                            breakpoints[i].counter, breakpoints[i].address,
-                            symbol);
-#endif
-
-                }
+                }
+        }
+        
         return 1;
 }
 
-/** Remove breakpoint from table */
+/** Remove breakpoint from table
+ *
+ */
 int cmd_del_breakpoint(cmd_arg_t *argv)
 {
@@ -384 +389 @@
                 return 0;
         }
+        
         breakpoint_del(argv->intval);
         return 1;
 }
 
-/** Add new breakpoint to table */
+/** Add new breakpoint to table
+ *
+ */
 static int cmd_add_breakpoint(cmd_arg_t *argv)
 {
-        int flags;
-        int id;
-
-        if (argv == &add_argv) {
+        unsigned int flags;
+        if (argv == &add_argv)
                 flags = BKPOINT_INSTR;
-        } else { /* addwatchp */
+        else
                 flags = BKPOINT_WRITE;
-        }
-        printf("Adding breakpoint on address: %p\n", argv->intval);
-        id = breakpoint_add((void *)argv->intval, flags, -1);
+        
+        printf("Adding breakpoint on address: %p\n",
+            (void *) argv->intval);
+        
+        int id = breakpoint_add((void *) argv->intval, flags, -1);
         if (id < 0)
                 printf("Add breakpoint failed.\n");