1 /* 2 * Kernel Debugger Architecture Independent Breakpoint Handler 3 * 4 * This file is subject to the terms and conditions of the GNU General Public 5 * License. See the file "COPYING" in the main directory of this archive 6 * for more details. 7 * 8 * Copyright (c) 1999-2004 Silicon Graphics, Inc. All Rights Reserved. 9 * Copyright (c) 2009 Wind River Systems, Inc. All Rights Reserved. 10 */ 11 12 #include <linux/string.h> 13 #include <linux/kernel.h> 14 #include <linux/init.h> 15 #include <linux/kdb.h> 16 #include <linux/kgdb.h> 17 #include <linux/smp.h> 18 #include <linux/sched.h> 19 #include <linux/interrupt.h> 20 #include "kdb_private.h" 21 22 /* 23 * Table of kdb_breakpoints 24 */ 25 kdb_bp_t kdb_breakpoints[KDB_MAXBPT]; 26 27 static void kdb_setsinglestep(struct pt_regs *regs) 28 { 29 KDB_STATE_SET(DOING_SS); 30 } 31 32 static char *kdb_rwtypes[] = { 33 "Instruction(i)", 34 "Instruction(Register)", 35 "Data Write", 36 "I/O", 37 "Data Access" 38 }; 39 40 static char *kdb_bptype(kdb_bp_t *bp) 41 { 42 if (bp->bp_type < 0 || bp->bp_type > 4) 43 return ""; 44 45 return kdb_rwtypes[bp->bp_type]; 46 } 47 48 static int kdb_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp) 49 { 50 int nextarg = *nextargp; 51 int diag; 52 53 bp->bph_length = 1; 54 if ((argc + 1) != nextarg) { 55 if (strncasecmp(argv[nextarg], "datar", sizeof("datar")) == 0) 56 bp->bp_type = BP_ACCESS_WATCHPOINT; 57 else if (strncasecmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) 58 bp->bp_type = BP_WRITE_WATCHPOINT; 59 else if (strncasecmp(argv[nextarg], "inst", sizeof("inst")) == 0) 60 bp->bp_type = BP_HARDWARE_BREAKPOINT; 61 else 62 return KDB_ARGCOUNT; 63 64 bp->bph_length = 1; 65 66 nextarg++; 67 68 if ((argc + 1) != nextarg) { 69 unsigned long len; 70 71 diag = kdbgetularg((char *)argv[nextarg], 72 &len); 73 if (diag) 74 return diag; 75 76 77 if (len > 8) 78 return KDB_BADLENGTH; 79 80 bp->bph_length = len; 81 nextarg++; 82 } 83 84 if ((argc + 1) != nextarg) 85 return KDB_ARGCOUNT; 86 } 87 88 *nextargp = nextarg; 89 return 0; 90 } 91 92 static int _kdb_bp_remove(kdb_bp_t *bp) 93 { 94 int ret = 1; 95 if (!bp->bp_installed) 96 return ret; 97 if (!bp->bp_type) 98 ret = dbg_remove_sw_break(bp->bp_addr); 99 else 100 ret = arch_kgdb_ops.remove_hw_breakpoint(bp->bp_addr, 101 bp->bph_length, 102 bp->bp_type); 103 if (ret == 0) 104 bp->bp_installed = 0; 105 return ret; 106 } 107 108 static void kdb_handle_bp(struct pt_regs *regs, kdb_bp_t *bp) 109 { 110 if (KDB_DEBUG(BP)) 111 kdb_printf("regs->ip = 0x%lx\n", instruction_pointer(regs)); 112 113 /* 114 * Setup single step 115 */ 116 kdb_setsinglestep(regs); 117 118 /* 119 * Reset delay attribute 120 */ 121 bp->bp_delay = 0; 122 bp->bp_delayed = 1; 123 } 124 125 static int _kdb_bp_install(struct pt_regs *regs, kdb_bp_t *bp) 126 { 127 int ret; 128 /* 129 * Install the breakpoint, if it is not already installed. 130 */ 131 132 if (KDB_DEBUG(BP)) 133 kdb_printf("%s: bp_installed %d\n", 134 __func__, bp->bp_installed); 135 if (!KDB_STATE(SSBPT)) 136 bp->bp_delay = 0; 137 if (bp->bp_installed) 138 return 1; 139 if (bp->bp_delay || (bp->bp_delayed && KDB_STATE(DOING_SS))) { 140 if (KDB_DEBUG(BP)) 141 kdb_printf("%s: delayed bp\n", __func__); 142 kdb_handle_bp(regs, bp); 143 return 0; 144 } 145 if (!bp->bp_type) 146 ret = dbg_set_sw_break(bp->bp_addr); 147 else 148 ret = arch_kgdb_ops.set_hw_breakpoint(bp->bp_addr, 149 bp->bph_length, 150 bp->bp_type); 151 if (ret == 0) { 152 bp->bp_installed = 1; 153 } else { 154 kdb_printf("%s: failed to set breakpoint at 0x%lx\n", 155 __func__, bp->bp_addr); 156 if (!bp->bp_type) { 157 kdb_printf("Software breakpoints are unavailable.\n" 158 " Boot the kernel with rodata=off\n" 159 " OR use hw breaks: help bph\n"); 160 } 161 return 1; 162 } 163 return 0; 164 } 165 166 /* 167 * kdb_bp_install 168 * 169 * Install kdb_breakpoints prior to returning from the 170 * kernel debugger. This allows the kdb_breakpoints to be set 171 * upon functions that are used internally by kdb, such as 172 * printk(). This function is only called once per kdb session. 173 */ 174 void kdb_bp_install(struct pt_regs *regs) 175 { 176 int i; 177 178 for (i = 0; i < KDB_MAXBPT; i++) { 179 kdb_bp_t *bp = &kdb_breakpoints[i]; 180 181 if (KDB_DEBUG(BP)) { 182 kdb_printf("%s: bp %d bp_enabled %d\n", 183 __func__, i, bp->bp_enabled); 184 } 185 if (bp->bp_enabled) 186 _kdb_bp_install(regs, bp); 187 } 188 } 189 190 /* 191 * kdb_bp_remove 192 * 193 * Remove kdb_breakpoints upon entry to the kernel debugger. 194 * 195 * Parameters: 196 * None. 197 * Outputs: 198 * None. 199 * Returns: 200 * None. 201 * Locking: 202 * None. 203 * Remarks: 204 */ 205 void kdb_bp_remove(void) 206 { 207 int i; 208 209 for (i = KDB_MAXBPT - 1; i >= 0; i--) { 210 kdb_bp_t *bp = &kdb_breakpoints[i]; 211 212 if (KDB_DEBUG(BP)) { 213 kdb_printf("%s: bp %d bp_enabled %d\n", 214 __func__, i, bp->bp_enabled); 215 } 216 if (bp->bp_enabled) 217 _kdb_bp_remove(bp); 218 } 219 } 220 221 222 /* 223 * kdb_printbp 224 * 225 * Internal function to format and print a breakpoint entry. 226 * 227 * Parameters: 228 * None. 229 * Outputs: 230 * None. 231 * Returns: 232 * None. 233 * Locking: 234 * None. 235 * Remarks: 236 */ 237 238 static void kdb_printbp(kdb_bp_t *bp, int i) 239 { 240 kdb_printf("%s ", kdb_bptype(bp)); 241 kdb_printf("BP #%d at ", i); 242 kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT); 243 244 if (bp->bp_enabled) 245 kdb_printf("\n is enabled "); 246 else 247 kdb_printf("\n is disabled"); 248 249 kdb_printf(" addr at %016lx, hardtype=%d installed=%d\n", 250 bp->bp_addr, bp->bp_type, bp->bp_installed); 251 252 kdb_printf("\n"); 253 } 254 255 /* 256 * kdb_bp 257 * 258 * Handle the bp commands. 259 * 260 * [bp|bph] <addr-expression> [DATAR|DATAW] 261 * 262 * Parameters: 263 * argc Count of arguments in argv 264 * argv Space delimited command line arguments 265 * Outputs: 266 * None. 267 * Returns: 268 * Zero for success, a kdb diagnostic if failure. 269 * Locking: 270 * None. 271 * Remarks: 272 * 273 * bp Set breakpoint on all cpus. Only use hardware assist if need. 274 * bph Set breakpoint on all cpus. Force hardware register 275 */ 276 277 static int kdb_bp(int argc, const char **argv) 278 { 279 int i, bpno; 280 kdb_bp_t *bp, *bp_check; 281 int diag; 282 char *symname = NULL; 283 long offset = 0ul; 284 int nextarg; 285 kdb_bp_t template = {0}; 286 287 if (argc == 0) { 288 /* 289 * Display breakpoint table 290 */ 291 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; 292 bpno++, bp++) { 293 if (bp->bp_free) 294 continue; 295 kdb_printbp(bp, bpno); 296 } 297 298 return 0; 299 } 300 301 nextarg = 1; 302 diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr, 303 &offset, &symname); 304 if (diag) 305 return diag; 306 if (!template.bp_addr) 307 return KDB_BADINT; 308 309 /* 310 * This check is redundant (since the breakpoint machinery should 311 * be doing the same check during kdb_bp_install) but gives the 312 * user immediate feedback. 313 */ 314 diag = kgdb_validate_break_address(template.bp_addr); 315 if (diag) 316 return diag; 317 318 /* 319 * Find an empty bp structure to allocate 320 */ 321 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) { 322 if (bp->bp_free) 323 break; 324 } 325 326 if (bpno == KDB_MAXBPT) 327 return KDB_TOOMANYBPT; 328 329 if (strcmp(argv[0], "bph") == 0) { 330 template.bp_type = BP_HARDWARE_BREAKPOINT; 331 diag = kdb_parsebp(argc, argv, &nextarg, &template); 332 if (diag) 333 return diag; 334 } else { 335 template.bp_type = BP_BREAKPOINT; 336 } 337 338 /* 339 * Check for clashing breakpoints. 340 * 341 * Note, in this design we can't have hardware breakpoints 342 * enabled for both read and write on the same address. 343 */ 344 for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT; 345 i++, bp_check++) { 346 if (!bp_check->bp_free && 347 bp_check->bp_addr == template.bp_addr) { 348 kdb_printf("You already have a breakpoint at " 349 kdb_bfd_vma_fmt0 "\n", template.bp_addr); 350 return KDB_DUPBPT; 351 } 352 } 353 354 template.bp_enabled = 1; 355 356 /* 357 * Actually allocate the breakpoint found earlier 358 */ 359 *bp = template; 360 bp->bp_free = 0; 361 362 kdb_printbp(bp, bpno); 363 364 return 0; 365 } 366 367 /* 368 * kdb_bc 369 * 370 * Handles the 'bc', 'be', and 'bd' commands 371 * 372 * [bd|bc|be] <breakpoint-number> 373 * [bd|bc|be] * 374 * 375 * Parameters: 376 * argc Count of arguments in argv 377 * argv Space delimited command line arguments 378 * Outputs: 379 * None. 380 * Returns: 381 * Zero for success, a kdb diagnostic for failure 382 * Locking: 383 * None. 384 * Remarks: 385 */ 386 static int kdb_bc(int argc, const char **argv) 387 { 388 unsigned long addr; 389 kdb_bp_t *bp = NULL; 390 int lowbp = KDB_MAXBPT; 391 int highbp = 0; 392 int done = 0; 393 int i; 394 int diag = 0; 395 396 int cmd; /* KDBCMD_B? */ 397 #define KDBCMD_BC 0 398 #define KDBCMD_BE 1 399 #define KDBCMD_BD 2 400 401 if (strcmp(argv[0], "be") == 0) 402 cmd = KDBCMD_BE; 403 else if (strcmp(argv[0], "bd") == 0) 404 cmd = KDBCMD_BD; 405 else 406 cmd = KDBCMD_BC; 407 408 if (argc != 1) 409 return KDB_ARGCOUNT; 410 411 if (strcmp(argv[1], "*") == 0) { 412 lowbp = 0; 413 highbp = KDB_MAXBPT; 414 } else { 415 diag = kdbgetularg(argv[1], &addr); 416 if (diag) 417 return diag; 418 419 /* 420 * For addresses less than the maximum breakpoint number, 421 * assume that the breakpoint number is desired. 422 */ 423 if (addr < KDB_MAXBPT) { 424 lowbp = highbp = addr; 425 highbp++; 426 } else { 427 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; 428 i++, bp++) { 429 if (bp->bp_addr == addr) { 430 lowbp = highbp = i; 431 highbp++; 432 break; 433 } 434 } 435 } 436 } 437 438 /* 439 * Now operate on the set of breakpoints matching the input 440 * criteria (either '*' for all, or an individual breakpoint). 441 */ 442 for (bp = &kdb_breakpoints[lowbp], i = lowbp; 443 i < highbp; 444 i++, bp++) { 445 if (bp->bp_free) 446 continue; 447 448 done++; 449 450 switch (cmd) { 451 case KDBCMD_BC: 452 bp->bp_enabled = 0; 453 454 kdb_printf("Breakpoint %d at " 455 kdb_bfd_vma_fmt " cleared\n", 456 i, bp->bp_addr); 457 458 bp->bp_addr = 0; 459 bp->bp_free = 1; 460 461 break; 462 case KDBCMD_BE: 463 bp->bp_enabled = 1; 464 465 kdb_printf("Breakpoint %d at " 466 kdb_bfd_vma_fmt " enabled", 467 i, bp->bp_addr); 468 469 kdb_printf("\n"); 470 break; 471 case KDBCMD_BD: 472 if (!bp->bp_enabled) 473 break; 474 475 bp->bp_enabled = 0; 476 477 kdb_printf("Breakpoint %d at " 478 kdb_bfd_vma_fmt " disabled\n", 479 i, bp->bp_addr); 480 481 break; 482 } 483 if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) { 484 bp->bp_delay = 0; 485 KDB_STATE_CLEAR(SSBPT); 486 } 487 } 488 489 return (!done) ? KDB_BPTNOTFOUND : 0; 490 } 491 492 /* 493 * kdb_ss 494 * 495 * Process the 'ss' (Single Step) command. 496 * 497 * ss 498 * 499 * Parameters: 500 * argc Argument count 501 * argv Argument vector 502 * Outputs: 503 * None. 504 * Returns: 505 * KDB_CMD_SS for success, a kdb error if failure. 506 * Locking: 507 * None. 508 * Remarks: 509 * 510 * Set the arch specific option to trigger a debug trap after the next 511 * instruction. 512 */ 513 514 static int kdb_ss(int argc, const char **argv) 515 { 516 if (argc != 0) 517 return KDB_ARGCOUNT; 518 /* 519 * Set trace flag and go. 520 */ 521 KDB_STATE_SET(DOING_SS); 522 return KDB_CMD_SS; 523 } 524 525 static kdbtab_t bptab[] = { 526 { .cmd_name = "bp", 527 .cmd_func = kdb_bp, 528 .cmd_usage = "[<vaddr>]", 529 .cmd_help = "Set/Display breakpoints", 530 .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 531 }, 532 { .cmd_name = "bl", 533 .cmd_func = kdb_bp, 534 .cmd_usage = "[<vaddr>]", 535 .cmd_help = "Display breakpoints", 536 .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 537 }, 538 { .cmd_name = "bc", 539 .cmd_func = kdb_bc, 540 .cmd_usage = "<bpnum>", 541 .cmd_help = "Clear Breakpoint", 542 .cmd_flags = KDB_ENABLE_FLOW_CTRL, 543 }, 544 { .cmd_name = "be", 545 .cmd_func = kdb_bc, 546 .cmd_usage = "<bpnum>", 547 .cmd_help = "Enable Breakpoint", 548 .cmd_flags = KDB_ENABLE_FLOW_CTRL, 549 }, 550 { .cmd_name = "bd", 551 .cmd_func = kdb_bc, 552 .cmd_usage = "<bpnum>", 553 .cmd_help = "Disable Breakpoint", 554 .cmd_flags = KDB_ENABLE_FLOW_CTRL, 555 }, 556 { .cmd_name = "ss", 557 .cmd_func = kdb_ss, 558 .cmd_usage = "", 559 .cmd_help = "Single Step", 560 .cmd_minlen = 1, 561 .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 562 }, 563 }; 564 565 static kdbtab_t bphcmd = { 566 .cmd_name = "bph", 567 .cmd_func = kdb_bp, 568 .cmd_usage = "[<vaddr>]", 569 .cmd_help = "[datar [length]|dataw [length]] Set hw brk", 570 .cmd_flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS, 571 }; 572 573 /* Initialize the breakpoint table and register breakpoint commands. */ 574 575 void __init kdb_initbptab(void) 576 { 577 int i; 578 kdb_bp_t *bp; 579 580 /* 581 * First time initialization. 582 */ 583 memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints)); 584 585 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) 586 bp->bp_free = 1; 587 588 kdb_register_table(bptab, ARRAY_SIZE(bptab)); 589 if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) 590 kdb_register_table(&bphcmd, 1); 591 } 592