kernel/debug/kdb/kdb_bp.c

   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 /* Initialize the breakpoint table and register breakpoint commands. */
 526
 527 void __init kdb_initbptab(void)
 528 {
 529         int i;
 530         kdb_bp_t *bp;
 531
 532         /*
 533          * First time initialization.
 534          */
 535         memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints));
 536
 537         for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
 538                 bp->bp_free = 1;
 539
 540         kdb_register_flags("bp", kdb_bp, "[<vaddr>]",
 541                 "Set/Display breakpoints", 0,
 542                 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
 543         kdb_register_flags("bl", kdb_bp, "[<vaddr>]",
 544                 "Display breakpoints", 0,
 545                 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
 546         if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
 547                 kdb_register_flags("bph", kdb_bp, "[<vaddr>]",
 548                 "[datar [length]|dataw [length]]   Set hw brk", 0,
 549                 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
 550         kdb_register_flags("bc", kdb_bc, "<bpnum>",
 551                 "Clear Breakpoint", 0,
 552                 KDB_ENABLE_FLOW_CTRL);
 553         kdb_register_flags("be", kdb_bc, "<bpnum>",
 554                 "Enable Breakpoint", 0,
 555                 KDB_ENABLE_FLOW_CTRL);
 556         kdb_register_flags("bd", kdb_bc, "<bpnum>",
 557                 "Disable Breakpoint", 0,
 558                 KDB_ENABLE_FLOW_CTRL);
 559
 560         kdb_register_flags("ss", kdb_ss, "",
 561                 "Single Step", 1,
 562                 KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
 563         /*
 564          * Architecture dependent initialization.
 565          */
 566 }