Changes in kernel/arch/mips32/src/debugger.c [556f9892:63bdde6] in mainline
- File:
-
- 1 edited
-
kernel/arch/mips32/src/debugger.c (modified) (10 diffs)
Legend:
- Unmodified
- Added
- Removed
-
kernel/arch/mips32/src/debugger.c
r556f9892 r63bdde6 46 46 47 47 bpinfo_t breakpoints[BKPOINTS_MAX]; 48 SPINLOCK_INITIALIZE(bkpoint_lock);48 IRQ_SPINLOCK_STATIC_INITIALIZE(bkpoint_lock); 49 49 50 50 #ifdef CONFIG_KCONSOLE 51 51 52 static int cmd_print_breakpoints(cmd_arg_t *argv); 52 static int cmd_print_breakpoints(cmd_arg_t *); 53 static int cmd_del_breakpoint(cmd_arg_t *); 54 static int cmd_add_breakpoint(cmd_arg_t *); 55 53 56 static cmd_info_t bkpts_info = { 54 57 .name = "bkpts", … … 58 61 }; 59 62 60 static int cmd_del_breakpoint(cmd_arg_t *argv);61 63 static cmd_arg_t del_argv = { 62 64 .type = ARG_TYPE_INT 63 65 }; 66 64 67 static cmd_info_t delbkpt_info = { 65 68 .name = "delbkpt", 66 .description = " delbkpt <number> -Delete breakpoint.",69 .description = "Delete breakpoint.", 67 70 .func = cmd_del_breakpoint, 68 71 .argc = 1, … … 70 73 }; 71 74 72 static int cmd_add_breakpoint(cmd_arg_t *argv);73 75 static cmd_arg_t add_argv = { 74 76 .type = ARG_TYPE_INT 75 77 }; 78 76 79 static cmd_info_t addbkpt_info = { 77 80 .name = "addbkpt", 78 .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch " 79 "insts unsupported.", 81 .description = "Add bkpoint (break on J/Branch insts unsupported).", 80 82 .func = cmd_add_breakpoint, 81 83 .argc = 1, … … 89 91 static cmd_info_t addbkpte_info = { 90 92 .name = "addbkpte", 91 .description = "addebkpte <&symbol> <&func> - new bkpoint. Call " 92 "func(or Nothing if 0).", 93 .description = "Add bkpoint with a trigger function.", 93 94 .func = cmd_add_breakpoint, 94 95 .argc = 2, … … 100 101 uint32_t value; 101 102 } jmpinstr[] = { 102 {0xf3ff0000, 0x41000000}, /* BCzF */ 103 {0xf3ff0000, 0x41020000}, /* BCzFL */ 104 {0xf3ff0000, 0x41010000}, /* BCzT */ 105 {0xf3ff0000, 0x41030000}, /* BCzTL */ 106 {0xfc000000, 0x10000000}, /* BEQ */ 107 {0xfc000000, 0x50000000}, /* BEQL */ 108 {0xfc1f0000, 0x04010000}, /* BEQL */ 109 {0xfc1f0000, 0x04110000}, /* BGEZAL */ 110 {0xfc1f0000, 0x04130000}, /* BGEZALL */ 111 {0xfc1f0000, 0x04030000}, /* BGEZL */ 112 {0xfc1f0000, 0x1c000000}, /* BGTZ */ 113 {0xfc1f0000, 0x5c000000}, /* BGTZL */ 114 {0xfc1f0000, 0x18000000}, /* BLEZ */ 115 {0xfc1f0000, 0x58000000}, /* BLEZL */ 116 {0xfc1f0000, 0x04000000}, /* BLTZ */ 117 {0xfc1f0000, 0x04100000}, /* BLTZAL */ 118 {0xfc1f0000, 0x04120000}, /* BLTZALL */ 119 {0xfc1f0000, 0x04020000}, /* BLTZL */ 120 {0xfc000000, 0x14000000}, /* BNE */ 121 {0xfc000000, 0x54000000}, /* BNEL */ 122 {0xfc000000, 0x08000000}, /* J */ 123 {0xfc000000, 0x0c000000}, /* JAL */ 124 {0xfc1f07ff, 0x00000009}, /* JALR */ 125 {0, 0} /* EndOfTable */ 126 }; 127 103 {0xf3ff0000, 0x41000000}, /* BCzF */ 104 {0xf3ff0000, 0x41020000}, /* BCzFL */ 105 {0xf3ff0000, 0x41010000}, /* BCzT */ 106 {0xf3ff0000, 0x41030000}, /* BCzTL */ 107 {0xfc000000, 0x10000000}, /* BEQ */ 108 {0xfc000000, 0x50000000}, /* BEQL */ 109 {0xfc1f0000, 0x04010000}, /* BEQL */ 110 {0xfc1f0000, 0x04110000}, /* BGEZAL */ 111 {0xfc1f0000, 0x04130000}, /* BGEZALL */ 112 {0xfc1f0000, 0x04030000}, /* BGEZL */ 113 {0xfc1f0000, 0x1c000000}, /* BGTZ */ 114 {0xfc1f0000, 0x5c000000}, /* BGTZL */ 115 {0xfc1f0000, 0x18000000}, /* BLEZ */ 116 {0xfc1f0000, 0x58000000}, /* BLEZL */ 117 {0xfc1f0000, 0x04000000}, /* BLTZ */ 118 {0xfc1f0000, 0x04100000}, /* BLTZAL */ 119 {0xfc1f0000, 0x04120000}, /* BLTZALL */ 120 {0xfc1f0000, 0x04020000}, /* BLTZL */ 121 {0xfc000000, 0x14000000}, /* BNE */ 122 {0xfc000000, 0x54000000}, /* BNEL */ 123 {0xfc000000, 0x08000000}, /* J */ 124 {0xfc000000, 0x0c000000}, /* JAL */ 125 {0xfc1f07ff, 0x00000009}, /* JALR */ 126 {0, 0} /* end of table */ 127 }; 128 128 129 129 /** Test, if the given instruction is a jump or branch instruction 130 130 * 131 131 * @param instr Instruction code 132 * @return true - it is jump instruction, false otherwise 133 * 134 */ 135 static bool is_jump(unative_t instr) 136 { 137 int i; 138 132 * 133 * @return true if it is jump instruction, false otherwise 134 * 135 */ 136 bool is_jump(unative_t instr) 137 { 138 unsigned int i; 139 139 140 for (i = 0; jmpinstr[i].andmask; i++) { 140 141 if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value) 141 142 return true; 142 143 } 143 144 144 145 return false; 145 146 } 146 147 147 /** Add new breakpoint to table */ 148 /** Add new breakpoint to table 149 * 150 */ 148 151 int cmd_add_breakpoint(cmd_arg_t *argv) 149 152 { 150 bpinfo_t *cur = NULL;151 ipl_t ipl;152 int i;153 154 153 if (argv->intval & 0x3) { 155 154 printf("Not aligned instruction, forgot to use &symbol?\n"); 156 155 return 1; 157 156 } 158 ipl = interrupts_disable();159 spinlock_lock(&bkpoint_lock);160 157 158 irq_spinlock_lock(&bkpoint_lock, true); 159 161 160 /* Check, that the breakpoints do not conflict */ 161 unsigned int i; 162 162 for (i = 0; i < BKPOINTS_MAX; i++) { 163 if (breakpoints[i].address == (uintptr_t) argv->intval) {163 if (breakpoints[i].address == (uintptr_t) argv->intval) { 164 164 printf("Duplicate breakpoint %d.\n", i); 165 spinlock_unlock(&bkpoint_lock); 166 interrupts_restore(ipl); 165 irq_spinlock_unlock(&bkpoint_lock, true); 167 166 return 0; 168 } else if ( breakpoints[i].address == (uintptr_t)argv->intval +169 sizeof(unative_t) ||breakpoints[i].address ==170 (uintptr_t) argv->intval - sizeof(unative_t)) {167 } else if ((breakpoints[i].address == (uintptr_t) argv->intval + 168 sizeof(unative_t)) || (breakpoints[i].address == 169 (uintptr_t) argv->intval - sizeof(unative_t))) { 171 170 printf("Adjacent breakpoints not supported, conflict " 172 171 "with %d.\n", i); 173 spinlock_unlock(&bkpoint_lock); 174 interrupts_restore(ipl); 172 irq_spinlock_unlock(&bkpoint_lock, true); 175 173 return 0; 176 174 } 177 175 178 176 } 179 180 for (i = 0; i < BKPOINTS_MAX; i++) 177 178 bpinfo_t *cur = NULL; 179 180 for (i = 0; i < BKPOINTS_MAX; i++) { 181 181 if (!breakpoints[i].address) { 182 182 cur = &breakpoints[i]; 183 183 break; 184 184 } 185 } 186 185 187 if (!cur) { 186 188 printf("Too many breakpoints.\n"); 187 spinlock_unlock(&bkpoint_lock); 188 interrupts_restore(ipl); 189 irq_spinlock_unlock(&bkpoint_lock, true); 189 190 return 0; 190 191 } 192 193 printf("Adding breakpoint on address %p\n", argv->intval); 194 191 195 cur->address = (uintptr_t) argv->intval; 192 printf("Adding breakpoint on address: %p\n", argv->intval); 193 cur->instruction = ((unative_t *)cur->address)[0]; 194 cur->nextinstruction = ((unative_t *)cur->address)[1]; 196 cur->instruction = ((unative_t *) cur->address)[0]; 197 cur->nextinstruction = ((unative_t *) cur->address)[1]; 195 198 if (argv == &add_argv) { 196 199 cur->flags = 0; 197 } else { /* We are add extended */200 } else { /* We are add extended */ 198 201 cur->flags = BKPOINT_FUNCCALL; 199 202 cur->bkfunc = (void (*)(void *, istate_t *)) argv[1].intval; 200 203 } 204 201 205 if (is_jump(cur->instruction)) 202 206 cur->flags |= BKPOINT_ONESHOT; 207 203 208 cur->counter = 0; 204 209 205 210 /* Set breakpoint */ 206 *((unative_t *) cur->address) = 0x0d;211 *((unative_t *) cur->address) = 0x0d; 207 212 smc_coherence(cur->address); 208 209 spinlock_unlock(&bkpoint_lock); 210 interrupts_restore(ipl); 211 213 214 irq_spinlock_unlock(&bkpoint_lock, true); 215 212 216 return 1; 213 217 } 214 218 215 /** Remove breakpoint from table */ 219 /** Remove breakpoint from table 220 * 221 */ 216 222 int cmd_del_breakpoint(cmd_arg_t *argv) 217 223 { 218 bpinfo_t *cur;219 ipl_t ipl;220 221 224 if (argv->intval > BKPOINTS_MAX) { 222 225 printf("Invalid breakpoint number.\n"); 223 226 return 0; 224 227 } 225 ipl = interrupts_disable();226 spinlock_lock(&bkpoint_lock);227 228 cur = &breakpoints[argv->intval];228 229 irq_spinlock_lock(&bkpoint_lock, true); 230 231 bpinfo_t *cur = &breakpoints[argv->intval]; 229 232 if (!cur->address) { 230 233 printf("Breakpoint does not exist.\n"); 231 spinlock_unlock(&bkpoint_lock); 232 interrupts_restore(ipl); 234 irq_spinlock_unlock(&bkpoint_lock, true); 233 235 return 0; 234 236 } 237 235 238 if ((cur->flags & BKPOINT_INPROG) && (cur->flags & BKPOINT_ONESHOT)) { 236 239 printf("Cannot remove one-shot breakpoint in-progress\n"); 237 spinlock_unlock(&bkpoint_lock); 238 interrupts_restore(ipl); 240 irq_spinlock_unlock(&bkpoint_lock, true); 239 241 return 0; 240 242 } 241 ((uint32_t *)cur->address)[0] = cur->instruction; 242 smc_coherence(((uint32_t *)cur->address)[0]); 243 ((uint32_t *)cur->address)[1] = cur->nextinstruction; 244 smc_coherence(((uint32_t *)cur->address)[1]); 245 243 244 ((uint32_t *) cur->address)[0] = cur->instruction; 245 smc_coherence(((uint32_t *) cur->address)[0]); 246 ((uint32_t *) cur->address)[1] = cur->nextinstruction; 247 smc_coherence(((uint32_t *) cur->address)[1]); 248 246 249 cur->address = NULL; 247 248 spinlock_unlock(&bkpoint_lock); 249 interrupts_restore(ipl); 250 251 irq_spinlock_unlock(&bkpoint_lock, true); 250 252 return 1; 251 253 } 252 254 253 /** Print table of active breakpoints */ 255 /** Print table of active breakpoints 256 * 257 */ 254 258 int cmd_print_breakpoints(cmd_arg_t *argv) 255 259 { 256 260 unsigned int i; 257 261 258 printf("# Count Address INPROG ONESHOT FUNCCALL In symbol\n"); 259 printf("-- ----- ---------- ------ ------- -------- ---------\n"); 262 printf("[nr] [count] [address ] [inprog] [oneshot] [funccall] [in symbol\n"); 260 263 261 264 for (i = 0; i < BKPOINTS_MAX; i++) { … … 264 267 breakpoints[i].address); 265 268 266 printf("%- 2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,269 printf("%-4u %7" PRIs " %p %-8s %-9s %-10s %s\n", i, 267 270 breakpoints[i].counter, breakpoints[i].address, 268 271 ((breakpoints[i].flags & BKPOINT_INPROG) ? "true" : … … 276 279 } 277 280 278 #endif 279 280 /** Initialize debugger */ 281 #endif /* CONFIG_KCONSOLE */ 282 283 /** Initialize debugger 284 * 285 */ 281 286 void debugger_init() 282 287 { 283 int i;284 288 unsigned int i; 289 285 290 for (i = 0; i < BKPOINTS_MAX; i++) 286 291 breakpoints[i].address = NULL; 287 292 288 293 #ifdef CONFIG_KCONSOLE 289 294 cmd_initialize(&bkpts_info); 290 295 if (!cmd_register(&bkpts_info)) 291 296 printf("Cannot register command %s\n", bkpts_info.name); 292 297 293 298 cmd_initialize(&delbkpt_info); 294 299 if (!cmd_register(&delbkpt_info)) 295 300 printf("Cannot register command %s\n", delbkpt_info.name); 296 301 297 302 cmd_initialize(&addbkpt_info); 298 303 if (!cmd_register(&addbkpt_info)) 299 304 printf("Cannot register command %s\n", addbkpt_info.name); 300 305 301 306 cmd_initialize(&addbkpte_info); 302 307 if (!cmd_register(&addbkpte_info)) 303 308 printf("Cannot register command %s\n", addbkpte_info.name); 304 #endif 309 #endif /* CONFIG_KCONSOLE */ 305 310 } 306 311 307 312 /** Handle breakpoint 308 313 * 309 * Find breakpoint in breakpoint table. 314 * Find breakpoint in breakpoint table. 310 315 * If found, call kconsole, set break on next instruction and reexecute. 311 316 * If we are on "next instruction", set it back on the first and reexecute. 312 317 * If breakpoint not found in breakpoint table, call kconsole and start 313 318 * next instruction. 319 * 314 320 */ 315 321 void debugger_bpoint(istate_t *istate) 316 322 { 317 bpinfo_t *cur = NULL;318 uintptr_t fireaddr = istate->epc;319 int i;320 321 323 /* test branch delay slot */ 322 324 if (cp0_cause_read() & 0x80000000) 323 325 panic("Breakpoint in branch delay slot not supported."); 324 325 spinlock_lock(&bkpoint_lock); 326 327 irq_spinlock_lock(&bkpoint_lock, false); 328 329 bpinfo_t *cur = NULL; 330 uintptr_t fireaddr = istate->epc; 331 unsigned int i; 332 326 333 for (i = 0; i < BKPOINTS_MAX; i++) { 327 334 /* Normal breakpoint */ 328 if ( fireaddr == breakpoints[i].address&&329 !(breakpoints[i].flags & BKPOINT_REINST)) {335 if ((fireaddr == breakpoints[i].address) && 336 (!(breakpoints[i].flags & BKPOINT_REINST))) { 330 337 cur = &breakpoints[i]; 331 338 break; 332 339 } 340 333 341 /* Reinst only breakpoint */ 334 342 if ((breakpoints[i].flags & BKPOINT_REINST) && … … 338 346 } 339 347 } 348 340 349 if (cur) { 341 350 if (cur->flags & BKPOINT_REINST) { 342 351 /* Set breakpoint on first instruction */ 343 ((uint32_t *) cur->address)[0] = 0x0d;352 ((uint32_t *) cur->address)[0] = 0x0d; 344 353 smc_coherence(((uint32_t *)cur->address)[0]); 354 345 355 /* Return back the second */ 346 ((uint32_t *)cur->address)[1] = cur->nextinstruction; 347 smc_coherence(((uint32_t *)cur->address)[1]); 356 ((uint32_t *) cur->address)[1] = cur->nextinstruction; 357 smc_coherence(((uint32_t *) cur->address)[1]); 358 348 359 cur->flags &= ~BKPOINT_REINST; 349 spinlock_unlock(&bkpoint_lock);360 irq_spinlock_unlock(&bkpoint_lock, false); 350 361 return; 351 } 362 } 363 352 364 if (cur->flags & BKPOINT_INPROG) 353 365 printf("Warning: breakpoint recursion\n"); 354 366 355 367 if (!(cur->flags & BKPOINT_FUNCCALL)) { 356 printf("***Breakpoint % d: %p in %s.\n", i, fireaddr,357 symtab_fmt_name_lookup( istate->epc));358 } 359 368 printf("***Breakpoint %u: %p in %s.\n", i, fireaddr, 369 symtab_fmt_name_lookup(fireaddr)); 370 } 371 360 372 /* Return first instruction back */ 361 373 ((uint32_t *)cur->address)[0] = cur->instruction; … … 371 383 printf("***Breakpoint %d: %p in %s.\n", i, fireaddr, 372 384 symtab_fmt_name_lookup(fireaddr)); 373 385 374 386 /* Move on to next instruction */ 375 387 istate->epc += 4; 376 388 } 389 377 390 if (cur) 378 391 cur->counter++; 392 379 393 if (cur && (cur->flags & BKPOINT_FUNCCALL)) { 380 394 /* Allow zero bkfunc, just for counting */ … … 383 397 } else { 384 398 #ifdef CONFIG_KCONSOLE 385 /* This disables all other processors - we are not SMP, 399 /* 400 * This disables all other processors - we are not SMP, 386 401 * actually this gets us to cpu_halt, if scheduler() is run 387 402 * - we generally do not want scheduler to be run from debug, 388 403 * so this is a good idea 389 */ 404 */ 390 405 atomic_set(&haltstate, 1); 391 spinlock_unlock(&bkpoint_lock);406 irq_spinlock_unlock(&bkpoint_lock, false); 392 407 393 408 kconsole("debug", "Debug console ready.\n", false); 394 409 395 spinlock_lock(&bkpoint_lock);410 irq_spinlock_lock(&bkpoint_lock, false); 396 411 atomic_set(&haltstate, 0); 397 412 #endif 398 413 } 399 if (cur && cur->address == fireaddr && (cur->flags & BKPOINT_INPROG)) { 414 415 if ((cur) && (cur->address == fireaddr) 416 && ((cur->flags & BKPOINT_INPROG))) { 400 417 /* Remove one-shot breakpoint */ 401 418 if ((cur->flags & BKPOINT_ONESHOT)) 402 419 cur->address = NULL; 420 403 421 /* Remove in-progress flag */ 404 422 cur->flags &= ~BKPOINT_INPROG; 405 } 406 spinlock_unlock(&bkpoint_lock); 423 } 424 425 irq_spinlock_unlock(&bkpoint_lock, false); 407 426 } 408 427
Note:
See TracChangeset
for help on using the changeset viewer.
