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 * Find an empty bp structure to allocate 311 */ 312 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) { 313 if (bp->bp_free) 314 break; 315 } 316 317 if (bpno == KDB_MAXBPT) 318 return KDB_TOOMANYBPT; 319 320 if (strcmp(argv[0], "bph") == 0) { 321 template.bp_type = BP_HARDWARE_BREAKPOINT; 322 diag = kdb_parsebp(argc, argv, &nextarg, &template); 323 if (diag) 324 return diag; 325 } else { 326 template.bp_type = BP_BREAKPOINT; 327 } 328 329 /* 330 * Check for clashing breakpoints. 331 * 332 * Note, in this design we can't have hardware breakpoints 333 * enabled for both read and write on the same address. 334 */ 335 for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT; 336 i++, bp_check++) { 337 if (!bp_check->bp_free && 338 bp_check->bp_addr == template.bp_addr) { 339 kdb_printf("You already have a breakpoint at " 340 kdb_bfd_vma_fmt0 "\n", template.bp_addr); 341 return KDB_DUPBPT; 342 } 343 } 344 345 template.bp_enabled = 1; 346 347 /* 348 * Actually allocate the breakpoint found earlier 349 */ 350 *bp = template; 351 bp->bp_free = 0; 352 353 kdb_printbp(bp, bpno); 354 355 return 0; 356 } 357 358 /* 359 * kdb_bc 360 * 361 * Handles the 'bc', 'be', and 'bd' commands 362 * 363 * [bd|bc|be] <breakpoint-number> 364 * [bd|bc|be] * 365 * 366 * Parameters: 367 * argc Count of arguments in argv 368 * argv Space delimited command line arguments 369 * Outputs: 370 * None. 371 * Returns: 372 * Zero for success, a kdb diagnostic for failure 373 * Locking: 374 * None. 375 * Remarks: 376 */ 377 static int kdb_bc(int argc, const char **argv) 378 { 379 unsigned long addr; 380 kdb_bp_t *bp = NULL; 381 int lowbp = KDB_MAXBPT; 382 int highbp = 0; 383 int done = 0; 384 int i; 385 int diag = 0; 386 387 int cmd; /* KDBCMD_B? */ 388 #define KDBCMD_BC 0 389 #define KDBCMD_BE 1 390 #define KDBCMD_BD 2 391 392 if (strcmp(argv[0], "be") == 0) 393 cmd = KDBCMD_BE; 394 else if (strcmp(argv[0], "bd") == 0) 395 cmd = KDBCMD_BD; 396 else 397 cmd = KDBCMD_BC; 398 399 if (argc != 1) 400 return KDB_ARGCOUNT; 401 402 if (strcmp(argv[1], "*") == 0) { 403 lowbp = 0; 404 highbp = KDB_MAXBPT; 405 } else { 406 diag = kdbgetularg(argv[1], &addr); 407 if (diag) 408 return diag; 409 410 /* 411 * For addresses less than the maximum breakpoint number, 412 * assume that the breakpoint number is desired. 413 */ 414 if (addr < KDB_MAXBPT) { 415 lowbp = highbp = addr; 416 highbp++; 417 } else { 418 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; 419 i++, bp++) { 420 if (bp->bp_addr == addr) { 421 lowbp = highbp = i; 422 highbp++; 423 break; 424 } 425 } 426 } 427 } 428 429 /* 430 * Now operate on the set of breakpoints matching the input 431 * criteria (either '*' for all, or an individual breakpoint). 432 */ 433 for (bp = &kdb_breakpoints[lowbp], i = lowbp; 434 i < highbp; 435 i++, bp++) { 436 if (bp->bp_free) 437 continue; 438 439 done++; 440 441 switch (cmd) { 442 case KDBCMD_BC: 443 bp->bp_enabled = 0; 444 445 kdb_printf("Breakpoint %d at " 446 kdb_bfd_vma_fmt " cleared\n", 447 i, bp->bp_addr); 448 449 bp->bp_addr = 0; 450 bp->bp_free = 1; 451 452 break; 453 case KDBCMD_BE: 454 bp->bp_enabled = 1; 455 456 kdb_printf("Breakpoint %d at " 457 kdb_bfd_vma_fmt " enabled", 458 i, bp->bp_addr); 459 460 kdb_printf("\n"); 461 break; 462 case KDBCMD_BD: 463 if (!bp->bp_enabled) 464 break; 465 466 bp->bp_enabled = 0; 467 468 kdb_printf("Breakpoint %d at " 469 kdb_bfd_vma_fmt " disabled\n", 470 i, bp->bp_addr); 471 472 break; 473 } 474 if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) { 475 bp->bp_delay = 0; 476 KDB_STATE_CLEAR(SSBPT); 477 } 478 } 479 480 return (!done) ? KDB_BPTNOTFOUND : 0; 481 } 482 483 /* 484 * kdb_ss 485 * 486 * Process the 'ss' (Single Step) command. 487 * 488 * ss 489 * 490 * Parameters: 491 * argc Argument count 492 * argv Argument vector 493 * Outputs: 494 * None. 495 * Returns: 496 * KDB_CMD_SS for success, a kdb error if failure. 497 * Locking: 498 * None. 499 * Remarks: 500 * 501 * Set the arch specific option to trigger a debug trap after the next 502 * instruction. 503 */ 504 505 static int kdb_ss(int argc, const char **argv) 506 { 507 if (argc != 0) 508 return KDB_ARGCOUNT; 509 /* 510 * Set trace flag and go. 511 */ 512 KDB_STATE_SET(DOING_SS); 513 return KDB_CMD_SS; 514 } 515 516 /* Initialize the breakpoint table and register breakpoint commands. */ 517 518 void __init kdb_initbptab(void) 519 { 520 int i; 521 kdb_bp_t *bp; 522 523 /* 524 * First time initialization. 525 */ 526 memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints)); 527 528 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) 529 bp->bp_free = 1; 530 531 kdb_register_flags("bp", kdb_bp, "[<vaddr>]", 532 "Set/Display breakpoints", 0, 533 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 534 kdb_register_flags("bl", kdb_bp, "[<vaddr>]", 535 "Display breakpoints", 0, 536 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 537 if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) 538 kdb_register_flags("bph", kdb_bp, "[<vaddr>]", 539 "[datar [length]|dataw [length]] Set hw brk", 0, 540 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 541 kdb_register_flags("bc", kdb_bc, "<bpnum>", 542 "Clear Breakpoint", 0, 543 KDB_ENABLE_FLOW_CTRL); 544 kdb_register_flags("be", kdb_bc, "<bpnum>", 545 "Enable Breakpoint", 0, 546 KDB_ENABLE_FLOW_CTRL); 547 kdb_register_flags("bd", kdb_bc, "<bpnum>", 548 "Disable Breakpoint", 0, 549 KDB_ENABLE_FLOW_CTRL); 550 551 kdb_register_flags("ss", kdb_ss, "", 552 "Single Step", 1, 553 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 554 /* 555 * Architecture dependent initialization. 556 */ 557 } 558