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 */ 25kdb_bp_t kdb_breakpoints[KDB_MAXBPT]; 26 27static void kdb_setsinglestep(struct pt_regs *regs) 28{ 29 KDB_STATE_SET(DOING_SS); 30} 31 32static char *kdb_rwtypes[] = { 33 "Instruction(i)", 34 "Instruction(Register)", 35 "Data Write", 36 "I/O", 37 "Data Access" 38}; 39 40static 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 48static 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 (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0) 56 bp->bp_type = BP_ACCESS_WATCHPOINT; 57 else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) 58 bp->bp_type = BP_WRITE_WATCHPOINT; 59 else if (strnicmp(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 92static 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 108static 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 125static 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 return 1; 157 } 158 return 0; 159} 160 161/* 162 * kdb_bp_install 163 * 164 * Install kdb_breakpoints prior to returning from the 165 * kernel debugger. This allows the kdb_breakpoints to be set 166 * upon functions that are used internally by kdb, such as 167 * printk(). This function is only called once per kdb session. 168 */ 169void kdb_bp_install(struct pt_regs *regs) 170{ 171 int i; 172 173 for (i = 0; i < KDB_MAXBPT; i++) { 174 kdb_bp_t *bp = &kdb_breakpoints[i]; 175 176 if (KDB_DEBUG(BP)) { 177 kdb_printf("%s: bp %d bp_enabled %d\n", 178 __func__, i, bp->bp_enabled); 179 } 180 if (bp->bp_enabled) 181 _kdb_bp_install(regs, bp); 182 } 183} 184 185/* 186 * kdb_bp_remove 187 * 188 * Remove kdb_breakpoints upon entry to the kernel debugger. 189 * 190 * Parameters: 191 * None. 192 * Outputs: 193 * None. 194 * Returns: 195 * None. 196 * Locking: 197 * None. 198 * Remarks: 199 */ 200void kdb_bp_remove(void) 201{ 202 int i; 203 204 for (i = KDB_MAXBPT - 1; i >= 0; i--) { 205 kdb_bp_t *bp = &kdb_breakpoints[i]; 206 207 if (KDB_DEBUG(BP)) { 208 kdb_printf("%s: bp %d bp_enabled %d\n", 209 __func__, i, bp->bp_enabled); 210 } 211 if (bp->bp_enabled) 212 _kdb_bp_remove(bp); 213 } 214} 215 216 217/* 218 * kdb_printbp 219 * 220 * Internal function to format and print a breakpoint entry. 221 * 222 * Parameters: 223 * None. 224 * Outputs: 225 * None. 226 * Returns: 227 * None. 228 * Locking: 229 * None. 230 * Remarks: 231 */ 232 233static void kdb_printbp(kdb_bp_t *bp, int i) 234{ 235 kdb_printf("%s ", kdb_bptype(bp)); 236 kdb_printf("BP #%d at ", i); 237 kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT); 238 239 if (bp->bp_enabled) 240 kdb_printf("\n is enabled"); 241 else 242 kdb_printf("\n is disabled"); 243 244 kdb_printf("\taddr at %016lx, hardtype=%d installed=%d\n", 245 bp->bp_addr, bp->bp_type, bp->bp_installed); 246 247 kdb_printf("\n"); 248} 249 250/* 251 * kdb_bp 252 * 253 * Handle the bp commands. 254 * 255 * [bp|bph] <addr-expression> [DATAR|DATAW] 256 * 257 * Parameters: 258 * argc Count of arguments in argv 259 * argv Space delimited command line arguments 260 * Outputs: 261 * None. 262 * Returns: 263 * Zero for success, a kdb diagnostic if failure. 264 * Locking: 265 * None. 266 * Remarks: 267 * 268 * bp Set breakpoint on all cpus. Only use hardware assist if need. 269 * bph Set breakpoint on all cpus. Force hardware register 270 */ 271 272static int kdb_bp(int argc, const char **argv) 273{ 274 int i, bpno; 275 kdb_bp_t *bp, *bp_check; 276 int diag; 277 char *symname = NULL; 278 long offset = 0ul; 279 int nextarg; 280 kdb_bp_t template = {0}; 281 282 if (argc == 0) { 283 /* 284 * Display breakpoint table 285 */ 286 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; 287 bpno++, bp++) { 288 if (bp->bp_free) 289 continue; 290 kdb_printbp(bp, bpno); 291 } 292 293 return 0; 294 } 295 296 nextarg = 1; 297 diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr, 298 &offset, &symname); 299 if (diag) 300 return diag; 301 if (!template.bp_addr) 302 return KDB_BADINT; 303 304 /* 305 * Find an empty bp structure to allocate 306 */ 307 for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) { 308 if (bp->bp_free) 309 break; 310 } 311 312 if (bpno == KDB_MAXBPT) 313 return KDB_TOOMANYBPT; 314 315 if (strcmp(argv[0], "bph") == 0) { 316 template.bp_type = BP_HARDWARE_BREAKPOINT; 317 diag = kdb_parsebp(argc, argv, &nextarg, &template); 318 if (diag) 319 return diag; 320 } else { 321 template.bp_type = BP_BREAKPOINT; 322 } 323 324 /* 325 * Check for clashing breakpoints. 326 * 327 * Note, in this design we can't have hardware breakpoints 328 * enabled for both read and write on the same address. 329 */ 330 for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT; 331 i++, bp_check++) { 332 if (!bp_check->bp_free && 333 bp_check->bp_addr == template.bp_addr) { 334 kdb_printf("You already have a breakpoint at " 335 kdb_bfd_vma_fmt0 "\n", template.bp_addr); 336 return KDB_DUPBPT; 337 } 338 } 339 340 template.bp_enabled = 1; 341 342 /* 343 * Actually allocate the breakpoint found earlier 344 */ 345 *bp = template; 346 bp->bp_free = 0; 347 348 kdb_printbp(bp, bpno); 349 350 return 0; 351} 352 353/* 354 * kdb_bc 355 * 356 * Handles the 'bc', 'be', and 'bd' commands 357 * 358 * [bd|bc|be] <breakpoint-number> 359 * [bd|bc|be] * 360 * 361 * Parameters: 362 * argc Count of arguments in argv 363 * argv Space delimited command line arguments 364 * Outputs: 365 * None. 366 * Returns: 367 * Zero for success, a kdb diagnostic for failure 368 * Locking: 369 * None. 370 * Remarks: 371 */ 372static int kdb_bc(int argc, const char **argv) 373{ 374 unsigned long addr; 375 kdb_bp_t *bp = NULL; 376 int lowbp = KDB_MAXBPT; 377 int highbp = 0; 378 int done = 0; 379 int i; 380 int diag = 0; 381 382 int cmd; /* KDBCMD_B? */ 383#define KDBCMD_BC 0 384#define KDBCMD_BE 1 385#define KDBCMD_BD 2 386 387 if (strcmp(argv[0], "be") == 0) 388 cmd = KDBCMD_BE; 389 else if (strcmp(argv[0], "bd") == 0) 390 cmd = KDBCMD_BD; 391 else 392 cmd = KDBCMD_BC; 393 394 if (argc != 1) 395 return KDB_ARGCOUNT; 396 397 if (strcmp(argv[1], "*") == 0) { 398 lowbp = 0; 399 highbp = KDB_MAXBPT; 400 } else { 401 diag = kdbgetularg(argv[1], &addr); 402 if (diag) 403 return diag; 404 405 /* 406 * For addresses less than the maximum breakpoint number, 407 * assume that the breakpoint number is desired. 408 */ 409 if (addr < KDB_MAXBPT) { 410 bp = &kdb_breakpoints[addr]; 411 lowbp = highbp = addr; 412 highbp++; 413 } else { 414 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; 415 i++, bp++) { 416 if (bp->bp_addr == addr) { 417 lowbp = highbp = i; 418 highbp++; 419 break; 420 } 421 } 422 } 423 } 424 425 /* 426 * Now operate on the set of breakpoints matching the input 427 * criteria (either '*' for all, or an individual breakpoint). 428 */ 429 for (bp = &kdb_breakpoints[lowbp], i = lowbp; 430 i < highbp; 431 i++, bp++) { 432 if (bp->bp_free) 433 continue; 434 435 done++; 436 437 switch (cmd) { 438 case KDBCMD_BC: 439 bp->bp_enabled = 0; 440 441 kdb_printf("Breakpoint %d at " 442 kdb_bfd_vma_fmt " cleared\n", 443 i, bp->bp_addr); 444 445 bp->bp_addr = 0; 446 bp->bp_free = 1; 447 448 break; 449 case KDBCMD_BE: 450 bp->bp_enabled = 1; 451 452 kdb_printf("Breakpoint %d at " 453 kdb_bfd_vma_fmt " enabled", 454 i, bp->bp_addr); 455 456 kdb_printf("\n"); 457 break; 458 case KDBCMD_BD: 459 if (!bp->bp_enabled) 460 break; 461 462 bp->bp_enabled = 0; 463 464 kdb_printf("Breakpoint %d at " 465 kdb_bfd_vma_fmt " disabled\n", 466 i, bp->bp_addr); 467 468 break; 469 } 470 if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) { 471 bp->bp_delay = 0; 472 KDB_STATE_CLEAR(SSBPT); 473 } 474 } 475 476 return (!done) ? KDB_BPTNOTFOUND : 0; 477} 478 479/* 480 * kdb_ss 481 * 482 * Process the 'ss' (Single Step) and 'ssb' (Single Step to Branch) 483 * commands. 484 * 485 * ss 486 * ssb 487 * 488 * Parameters: 489 * argc Argument count 490 * argv Argument vector 491 * Outputs: 492 * None. 493 * Returns: 494 * KDB_CMD_SS[B] for success, a kdb error if failure. 495 * Locking: 496 * None. 497 * Remarks: 498 * 499 * Set the arch specific option to trigger a debug trap after the next 500 * instruction. 501 * 502 * For 'ssb', set the trace flag in the debug trap handler 503 * after printing the current insn and return directly without 504 * invoking the kdb command processor, until a branch instruction 505 * is encountered. 506 */ 507 508static int kdb_ss(int argc, const char **argv) 509{ 510 int ssb = 0; 511 512 ssb = (strcmp(argv[0], "ssb") == 0); 513 if (argc != 0) 514 return KDB_ARGCOUNT; 515 /* 516 * Set trace flag and go. 517 */ 518 KDB_STATE_SET(DOING_SS); 519 if (ssb) { 520 KDB_STATE_SET(DOING_SSB); 521 return KDB_CMD_SSB; 522 } 523 return KDB_CMD_SS; 524} 525 526/* Initialize the breakpoint table and register breakpoint commands. */ 527 528void __init kdb_initbptab(void) 529{ 530 int i; 531 kdb_bp_t *bp; 532 533 /* 534 * First time initialization. 535 */ 536 memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints)); 537 538 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) 539 bp->bp_free = 1; 540 541 kdb_register_repeat("bp", kdb_bp, "[<vaddr>]", 542 "Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS); 543 kdb_register_repeat("bl", kdb_bp, "[<vaddr>]", 544 "Display breakpoints", 0, KDB_REPEAT_NO_ARGS); 545 if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) 546 kdb_register_repeat("bph", kdb_bp, "[<vaddr>]", 547 "[datar [length]|dataw [length]] Set hw brk", 0, KDB_REPEAT_NO_ARGS); 548 kdb_register_repeat("bc", kdb_bc, "<bpnum>", 549 "Clear Breakpoint", 0, KDB_REPEAT_NONE); 550 kdb_register_repeat("be", kdb_bc, "<bpnum>", 551 "Enable Breakpoint", 0, KDB_REPEAT_NONE); 552 kdb_register_repeat("bd", kdb_bc, "<bpnum>", 553 "Disable Breakpoint", 0, KDB_REPEAT_NONE); 554 555 kdb_register_repeat("ss", kdb_ss, "", 556 "Single Step", 1, KDB_REPEAT_NO_ARGS); 557 kdb_register_repeat("ssb", kdb_ss, "", 558 "Single step to branch/call", 0, KDB_REPEAT_NO_ARGS); 559 /* 560 * Architecture dependent initialization. 561 */ 562} 563