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("\taddr 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 bp = &kdb_breakpoints[addr]; 416 lowbp = highbp = addr; 417 highbp++; 418 } else { 419 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; 420 i++, bp++) { 421 if (bp->bp_addr == addr) { 422 lowbp = highbp = i; 423 highbp++; 424 break; 425 } 426 } 427 } 428 } 429 430 /* 431 * Now operate on the set of breakpoints matching the input 432 * criteria (either '*' for all, or an individual breakpoint). 433 */ 434 for (bp = &kdb_breakpoints[lowbp], i = lowbp; 435 i < highbp; 436 i++, bp++) { 437 if (bp->bp_free) 438 continue; 439 440 done++; 441 442 switch (cmd) { 443 case KDBCMD_BC: 444 bp->bp_enabled = 0; 445 446 kdb_printf("Breakpoint %d at " 447 kdb_bfd_vma_fmt " cleared\n", 448 i, bp->bp_addr); 449 450 bp->bp_addr = 0; 451 bp->bp_free = 1; 452 453 break; 454 case KDBCMD_BE: 455 bp->bp_enabled = 1; 456 457 kdb_printf("Breakpoint %d at " 458 kdb_bfd_vma_fmt " enabled", 459 i, bp->bp_addr); 460 461 kdb_printf("\n"); 462 break; 463 case KDBCMD_BD: 464 if (!bp->bp_enabled) 465 break; 466 467 bp->bp_enabled = 0; 468 469 kdb_printf("Breakpoint %d at " 470 kdb_bfd_vma_fmt " disabled\n", 471 i, bp->bp_addr); 472 473 break; 474 } 475 if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) { 476 bp->bp_delay = 0; 477 KDB_STATE_CLEAR(SSBPT); 478 } 479 } 480 481 return (!done) ? KDB_BPTNOTFOUND : 0; 482 } 483 484 /* 485 * kdb_ss 486 * 487 * Process the 'ss' (Single Step) command. 488 * 489 * ss 490 * 491 * Parameters: 492 * argc Argument count 493 * argv Argument vector 494 * Outputs: 495 * None. 496 * Returns: 497 * KDB_CMD_SS for success, a kdb error if failure. 498 * Locking: 499 * None. 500 * Remarks: 501 * 502 * Set the arch specific option to trigger a debug trap after the next 503 * instruction. 504 */ 505 506 static int kdb_ss(int argc, const char **argv) 507 { 508 if (argc != 0) 509 return KDB_ARGCOUNT; 510 /* 511 * Set trace flag and go. 512 */ 513 KDB_STATE_SET(DOING_SS); 514 return KDB_CMD_SS; 515 } 516 517 /* Initialize the breakpoint table and register breakpoint commands. */ 518 519 void __init kdb_initbptab(void) 520 { 521 int i; 522 kdb_bp_t *bp; 523 524 /* 525 * First time initialization. 526 */ 527 memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints)); 528 529 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) 530 bp->bp_free = 1; 531 532 kdb_register_flags("bp", kdb_bp, "[<vaddr>]", 533 "Set/Display breakpoints", 0, 534 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 535 kdb_register_flags("bl", kdb_bp, "[<vaddr>]", 536 "Display breakpoints", 0, 537 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 538 if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) 539 kdb_register_flags("bph", kdb_bp, "[<vaddr>]", 540 "[datar [length]|dataw [length]] Set hw brk", 0, 541 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 542 kdb_register_flags("bc", kdb_bc, "<bpnum>", 543 "Clear Breakpoint", 0, 544 KDB_ENABLE_FLOW_CTRL); 545 kdb_register_flags("be", kdb_bc, "<bpnum>", 546 "Enable Breakpoint", 0, 547 KDB_ENABLE_FLOW_CTRL); 548 kdb_register_flags("bd", kdb_bc, "<bpnum>", 549 "Disable Breakpoint", 0, 550 KDB_ENABLE_FLOW_CTRL); 551 552 kdb_register_flags("ss", kdb_ss, "", 553 "Single Step", 1, 554 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); 555 /* 556 * Architecture dependent initialization. 557 */ 558 } 559