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(s1: argv[nextarg], s2: "datar" , n: sizeof("datar" )) == 0) |
56 | bp->bp_type = BP_ACCESS_WATCHPOINT; |
57 | else if (strncasecmp(s1: argv[nextarg], s2: "dataw" , n: sizeof("dataw" )) == 0) |
58 | bp->bp_type = BP_WRITE_WATCHPOINT; |
59 | else if (strncasecmp(s1: argv[nextarg], s2: "inst" , n: 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(addr: 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(addr: 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, i: 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(addr: 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, nextargp: &nextarg, bp: &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, i: 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(kp: bptab, ARRAY_SIZE(bptab)); |
589 | if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) |
590 | kdb_register_table(kp: &bphcmd, len: 1); |
591 | } |
592 | |