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 { .name = "bp",
527 .func = kdb_bp,
528 .usage = "[<vaddr>]",
529 .help = "Set/Display breakpoints",
530 .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS,
531 },
532 { .name = "bl",
533 .func = kdb_bp,
534 .usage = "[<vaddr>]",
535 .help = "Display breakpoints",
536 .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS,
537 },
538 { .name = "bc",
539 .func = kdb_bc,
540 .usage = "<bpnum>",
541 .help = "Clear Breakpoint",
542 .flags = KDB_ENABLE_FLOW_CTRL,
543 },
544 { .name = "be",
545 .func = kdb_bc,
546 .usage = "<bpnum>",
547 .help = "Enable Breakpoint",
548 .flags = KDB_ENABLE_FLOW_CTRL,
549 },
550 { .name = "bd",
551 .func = kdb_bc,
552 .usage = "<bpnum>",
553 .help = "Disable Breakpoint",
554 .flags = KDB_ENABLE_FLOW_CTRL,
555 },
556 { .name = "ss",
557 .func = kdb_ss,
558 .usage = "",
559 .help = "Single Step",
560 .minlen = 1,
561 .flags = KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS,
562 },
563 };
564
565 static kdbtab_t bphcmd = {
566 .name = "bph",
567 .func = kdb_bp,
568 .usage = "[<vaddr>]",
569 .help = "[datar [length]|dataw [length]] Set hw brk",
570 .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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.