Rev 1072 | Rev 1077 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1072 | palkovsky | 1 | /* |
| 2 | * Copyright (C) 2006 Ondrej Palkovsky |
||
| 3 | * All rights reserved. |
||
| 4 | * |
||
| 5 | * Redistribution and use in source and binary forms, with or without |
||
| 6 | * modification, are permitted provided that the following conditions |
||
| 7 | * are met: |
||
| 8 | * |
||
| 9 | * - Redistributions of source code must retain the above copyright |
||
| 10 | * notice, this list of conditions and the following disclaimer. |
||
| 11 | * - Redistributions in binary form must reproduce the above copyright |
||
| 12 | * notice, this list of conditions and the following disclaimer in the |
||
| 13 | * documentation and/or other materials provided with the distribution. |
||
| 14 | * - The name of the author may not be used to endorse or promote products |
||
| 15 | * derived from this software without specific prior written permission. |
||
| 16 | * |
||
| 17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
| 18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
| 19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
| 20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
| 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
| 22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
| 23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
| 24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
| 25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
| 26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
| 27 | */ |
||
| 28 | |||
| 29 | #include <arch/debugger.h> |
||
| 30 | #include <console/kconsole.h> |
||
| 31 | #include <console/cmd.h> |
||
| 32 | #include <symtab.h> |
||
| 33 | #include <print.h> |
||
| 34 | #include <panic.h> |
||
| 35 | #include <interrupt.h> |
||
| 36 | #include <arch/asm.h> |
||
| 37 | #include <arch/cpu.h> |
||
| 38 | #include <debug.h> |
||
| 39 | #include <func.h> |
||
| 40 | |||
| 41 | typedef struct { |
||
| 42 | __address address; /**< Breakpoint address */ |
||
| 43 | int flags; /**< Flags regarding breakpoint */ |
||
| 44 | int counter; /**< How many times the exception occured */ |
||
| 45 | } bpinfo_t; |
||
| 46 | |||
| 47 | static bpinfo_t breakpoints[BKPOINTS_MAX]; |
||
| 48 | SPINLOCK_INITIALIZE(bkpoint_lock); |
||
| 49 | |||
| 50 | static int cmd_print_breakpoints(cmd_arg_t *argv); |
||
| 51 | static cmd_info_t bkpts_info = { |
||
| 52 | .name = "bkpts", |
||
| 53 | .description = "Print breakpoint table.", |
||
| 54 | .func = cmd_print_breakpoints, |
||
| 55 | .argc = 0, |
||
| 56 | }; |
||
| 57 | |||
| 58 | static int cmd_del_breakpoint(cmd_arg_t *argv); |
||
| 59 | static cmd_arg_t del_argv = { |
||
| 60 | .type = ARG_TYPE_INT |
||
| 61 | }; |
||
| 62 | static cmd_info_t delbkpt_info = { |
||
| 63 | .name = "delbkpt", |
||
| 64 | .description = "delbkpt <number> - Delete breakpoint.", |
||
| 65 | .func = cmd_del_breakpoint, |
||
| 66 | .argc = 1, |
||
| 67 | .argv = &del_argv |
||
| 68 | }; |
||
| 69 | |||
| 70 | static int cmd_add_breakpoint(cmd_arg_t *argv); |
||
| 71 | static cmd_arg_t add_argv = { |
||
| 72 | .type = ARG_TYPE_INT |
||
| 73 | }; |
||
| 74 | static cmd_info_t addbkpt_info = { |
||
| 75 | .name = "addbkpt", |
||
| 76 | .description = "addbkpt <&symbol> - new breakpoint.", |
||
| 77 | .func = cmd_add_breakpoint, |
||
| 78 | .argc = 1, |
||
| 79 | .argv = &add_argv |
||
| 80 | }; |
||
| 81 | |||
| 82 | static cmd_arg_t addw_argv = { |
||
| 83 | .type = ARG_TYPE_INT |
||
| 84 | }; |
||
| 85 | static cmd_info_t addwatchp_info = { |
||
| 86 | .name = "addwatchp", |
||
| 87 | .description = "addbwatchp <&symbol> - new write watchpoint.", |
||
| 88 | .func = cmd_add_breakpoint, |
||
| 89 | .argc = 1, |
||
| 90 | .argv = &addw_argv |
||
| 91 | }; |
||
| 92 | |||
| 93 | |||
| 94 | /** Print table of active breakpoints */ |
||
| 95 | int cmd_print_breakpoints(cmd_arg_t *argv) |
||
| 96 | { |
||
| 97 | int i; |
||
| 98 | char *symbol; |
||
| 99 | |||
| 100 | printf("Breakpoint table.\n"); |
||
| 101 | for (i=0; i < BKPOINTS_MAX; i++) |
||
| 102 | if (breakpoints[i].address) { |
||
| 103 | symbol = get_symtab_entry(breakpoints[i].address); |
||
| 104 | printf("%d. 0x%p in %s\n",i, |
||
| 105 | breakpoints[i].address, symbol); |
||
| 106 | printf(" Count(%d) ", breakpoints[i].counter); |
||
| 107 | printf("\n"); |
||
| 108 | } |
||
| 109 | return 1; |
||
| 110 | } |
||
| 111 | |||
| 112 | /** Enable hardware breakpoint |
||
| 113 | * |
||
| 114 | * |
||
| 115 | * @param where Address of HW breakpoint |
||
| 116 | * @param flags Type of breakpoint (EXECUTE, WRITE) |
||
| 117 | * @return Debug slot on success, -1 - no available HW breakpoint |
||
| 118 | */ |
||
| 119 | int breakpoint_add(void * where, int flags) |
||
| 120 | { |
||
| 121 | bpinfo_t *cur = NULL; |
||
| 122 | int curidx; |
||
| 123 | ipl_t ipl; |
||
| 124 | int i; |
||
| 125 | __native dr7; |
||
| 126 | |||
| 127 | ASSERT( flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE)); |
||
| 128 | |||
| 129 | ipl = interrupts_disable(); |
||
| 130 | spinlock_lock(&bkpoint_lock); |
||
| 131 | |||
| 132 | /* Find free space in slots */ |
||
| 133 | for (i=0; i<BKPOINTS_MAX; i++) |
||
| 134 | if (!breakpoints[i].address) { |
||
| 135 | cur = &breakpoints[i]; |
||
| 136 | curidx = i; |
||
| 137 | break; |
||
| 138 | } |
||
| 139 | if (!cur) { |
||
| 140 | /* Too many breakpoints */ |
||
| 141 | spinlock_unlock(&bkpoint_lock); |
||
| 142 | interrupts_restore(ipl); |
||
| 143 | return -1; |
||
| 144 | } |
||
| 145 | cur->address = (__address) where; |
||
| 146 | cur->flags = flags; |
||
| 147 | cur->counter = 0; |
||
| 148 | |||
| 149 | /* Set breakpoint to debug registers */ |
||
| 150 | switch (curidx) { |
||
| 151 | case 0: |
||
| 152 | write_dr0(cur->address); |
||
| 153 | break; |
||
| 154 | case 1: |
||
| 155 | write_dr1(cur->address); |
||
| 156 | break; |
||
| 157 | case 2: |
||
| 158 | write_dr2(cur->address); |
||
| 159 | break; |
||
| 160 | case 3: |
||
| 161 | write_dr3(cur->address); |
||
| 162 | break; |
||
| 163 | } |
||
| 164 | dr7 = read_dr7(); |
||
| 165 | /* Set type to requested breakpoint & length*/ |
||
| 166 | dr7 &= ~ (0x3 << (16 + 4*curidx)); |
||
| 167 | dr7 &= ~ (0x3 << (18 + 4*curidx)); |
||
| 168 | if ((flags & BKPOINT_INSTR)) { |
||
| 169 | printf("Instr breakpoint\n"); |
||
| 170 | ; |
||
| 171 | } else { |
||
| 172 | if (sizeof(int) == 4) |
||
| 173 | dr7 |= 0x3 << (18 + 4*curidx); |
||
| 174 | else /* 8 */ |
||
| 175 | dr7 |= 0x2 << (18 + 4*curidx); |
||
| 176 | |||
| 177 | if ((flags & BKPOINT_WRITE)) |
||
| 178 | dr7 |= 0x1 << (16 + 4*curidx); |
||
| 179 | else if ((flags & BKPOINT_READ_WRITE)) |
||
| 180 | dr7 |= 0x3 << (16 + 4*curidx); |
||
| 181 | } |
||
| 182 | |||
| 183 | /* Enable global breakpoint */ |
||
| 184 | dr7 |= 0x2 << (curidx*2); |
||
| 185 | |||
| 186 | write_dr7(dr7); |
||
| 187 | |||
| 188 | spinlock_unlock(&bkpoint_lock); |
||
| 189 | interrupts_restore(ipl); |
||
| 190 | |||
| 191 | return curidx; |
||
| 192 | } |
||
| 193 | |||
| 1074 | palkovsky | 194 | #ifdef amd64 |
| 195 | # define getip(x) ((x)->rip) |
||
| 196 | #else |
||
| 197 | # define getip(x) ((x)->eip) |
||
| 198 | #endif |
||
| 199 | |||
| 1072 | palkovsky | 200 | static void handle_exception(int slot, istate_t *istate) |
| 201 | { |
||
| 202 | ASSERT(breakpoints[slot].address); |
||
| 203 | |||
| 204 | /* Handle zero checker */ |
||
| 205 | if (! (breakpoints[slot].flags & BKPOINT_INSTR)) { |
||
| 206 | if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) { |
||
| 207 | if (*((__native *) breakpoints[slot].address) != 0) |
||
| 208 | return; |
||
| 209 | printf("**** Found ZERO on address %P ****\n", |
||
| 210 | slot, breakpoints[slot].address); |
||
| 211 | } else { |
||
| 212 | printf("Data watchpoint - new data: %P\n", |
||
| 213 | *((__native *) breakpoints[slot].address)); |
||
| 214 | } |
||
| 215 | } |
||
| 1074 | palkovsky | 216 | printf("Reached breakpoint %d:%P(%s)\n", slot, getip(istate), |
| 217 | get_symtab_entry(getip(istate))); |
||
| 1072 | palkovsky | 218 | printf("***Type 'exit' to exit kconsole.\n"); |
| 219 | atomic_set(&haltstate,1); |
||
| 220 | kconsole("debug"); |
||
| 221 | atomic_set(&haltstate,0); |
||
| 222 | } |
||
| 223 | |||
| 224 | static void debug_exception(int n, istate_t *istate) |
||
| 225 | { |
||
| 226 | __native dr6; |
||
| 227 | int i; |
||
| 228 | |||
| 229 | /* Set RF to restart the instruction */ |
||
| 1074 | palkovsky | 230 | #ifdef amd64 |
| 1072 | palkovsky | 231 | istate->rflags |= RFLAGS_RF; |
| 1074 | palkovsky | 232 | #else |
| 233 | istate->eflags |= EFLAGS_RF; |
||
| 234 | #endif |
||
| 1072 | palkovsky | 235 | |
| 236 | dr6 = read_dr6(); |
||
| 237 | for (i=0; i < BKPOINTS_MAX; i++) { |
||
| 238 | if (dr6 & (1 << i)) { |
||
| 239 | dr6 &= ~ (1 << i); |
||
| 240 | write_dr6(dr6); |
||
| 241 | |||
| 242 | handle_exception(i, istate); |
||
| 243 | } |
||
| 244 | } |
||
| 245 | } |
||
| 246 | |||
| 247 | void breakpoint_del(int slot) |
||
| 248 | { |
||
| 249 | bpinfo_t *cur; |
||
| 250 | ipl_t ipl; |
||
| 251 | __native dr7; |
||
| 252 | |||
| 253 | ipl = interrupts_disable(); |
||
| 254 | spinlock_lock(&bkpoint_lock); |
||
| 255 | |||
| 256 | cur = &breakpoints[slot]; |
||
| 257 | if (!cur->address) { |
||
| 258 | spinlock_unlock(&bkpoint_lock); |
||
| 259 | interrupts_restore(ipl); |
||
| 260 | return; |
||
| 261 | } |
||
| 262 | |||
| 263 | cur->address = NULL; |
||
| 264 | |||
| 265 | /* Disable breakpoint in DR7 */ |
||
| 266 | dr7 = read_dr7(); |
||
| 267 | dr7 &= ~(0x2 << (slot*2)); |
||
| 268 | write_dr7(dr7); |
||
| 269 | |||
| 270 | spinlock_unlock(&bkpoint_lock); |
||
| 271 | interrupts_restore(ipl); |
||
| 272 | } |
||
| 273 | |||
| 274 | /** Remove breakpoint from table */ |
||
| 275 | int cmd_del_breakpoint(cmd_arg_t *argv) |
||
| 276 | { |
||
| 277 | if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) { |
||
| 278 | printf("Invalid breakpoint number.\n"); |
||
| 279 | return 0; |
||
| 280 | } |
||
| 281 | breakpoint_del(argv->intval); |
||
| 282 | return 1; |
||
| 283 | } |
||
| 284 | |||
| 285 | /** Add new breakpoint to table */ |
||
| 286 | static int cmd_add_breakpoint(cmd_arg_t *argv) |
||
| 287 | { |
||
| 288 | int flags; |
||
| 289 | |||
| 290 | if (argv == &add_argv) { |
||
| 291 | flags = BKPOINT_INSTR; |
||
| 292 | } else { /* addwatchp */ |
||
| 293 | flags = BKPOINT_WRITE; |
||
| 294 | } |
||
| 295 | printf("Adding breakpoint on address: %p\n", argv->intval); |
||
| 296 | if (breakpoint_add((void *)argv->intval, flags)) |
||
| 297 | printf("Add breakpoint failed.\n"); |
||
| 298 | |||
| 299 | return 1; |
||
| 300 | } |
||
| 301 | |||
| 302 | /** Initialize debugger */ |
||
| 303 | void debugger_init() |
||
| 304 | { |
||
| 305 | int i; |
||
| 306 | |||
| 307 | for (i=0; i<BKPOINTS_MAX; i++) |
||
| 308 | breakpoints[i].address = NULL; |
||
| 309 | |||
| 310 | cmd_initialize(&bkpts_info); |
||
| 311 | if (!cmd_register(&bkpts_info)) |
||
| 312 | panic("could not register command %s\n", bkpts_info.name); |
||
| 313 | |||
| 314 | cmd_initialize(&delbkpt_info); |
||
| 315 | if (!cmd_register(&delbkpt_info)) |
||
| 316 | panic("could not register command %s\n", delbkpt_info.name); |
||
| 317 | |||
| 318 | cmd_initialize(&addbkpt_info); |
||
| 319 | if (!cmd_register(&addbkpt_info)) |
||
| 320 | panic("could not register command %s\n", addbkpt_info.name); |
||
| 321 | |||
| 322 | cmd_initialize(&addwatchp_info); |
||
| 323 | if (!cmd_register(&addwatchp_info)) |
||
| 324 | panic("could not register command %s\n", addwatchp_info.name); |
||
| 325 | |||
| 326 | exc_register(VECTOR_DEBUG, "debugger", |
||
| 327 | debug_exception); |
||
| 328 | } |