Commit | Line | Data |
---|---|---|
5d5314d6 JW |
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) { | |
f9f2bac2 | 55 | if (strncasecmp(argv[nextarg], "datar", sizeof("datar")) == 0) |
5d5314d6 | 56 | bp->bp_type = BP_ACCESS_WATCHPOINT; |
f9f2bac2 | 57 | else if (strncasecmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) |
5d5314d6 | 58 | bp->bp_type = BP_WRITE_WATCHPOINT; |
f9f2bac2 | 59 | else if (strncasecmp(argv[nextarg], "inst", sizeof("inst")) == 0) |
5d5314d6 JW |
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); | |
1ba0c172 JW |
156 | if (!bp->bp_type) { |
157 | kdb_printf("Software breakpoints are unavailable.\n" | |
d2aa1aca | 158 | " Boot the kernel with rodata=off\n" |
1ba0c172 JW |
159 | " OR use hw breaks: help bph\n"); |
160 | } | |
5d5314d6 JW |
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; | |
5d5314d6 JW |
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 | */ | |
5d5314d6 JW |
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 | * | |
36dfea42 | 487 | * Process the 'ss' (Single Step) command. |
5d5314d6 JW |
488 | * |
489 | * ss | |
5d5314d6 JW |
490 | * |
491 | * Parameters: | |
492 | * argc Argument count | |
493 | * argv Argument vector | |
494 | * Outputs: | |
495 | * None. | |
496 | * Returns: | |
36dfea42 | 497 | * KDB_CMD_SS for success, a kdb error if failure. |
5d5314d6 JW |
498 | * Locking: |
499 | * None. | |
500 | * Remarks: | |
501 | * | |
502 | * Set the arch specific option to trigger a debug trap after the next | |
503 | * instruction. | |
5d5314d6 JW |
504 | */ |
505 | ||
506 | static int kdb_ss(int argc, const char **argv) | |
507 | { | |
5d5314d6 JW |
508 | if (argc != 0) |
509 | return KDB_ARGCOUNT; | |
510 | /* | |
511 | * Set trace flag and go. | |
512 | */ | |
513 | KDB_STATE_SET(DOING_SS); | |
5d5314d6 JW |
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 | ||
42c884c1 | 532 | kdb_register_flags("bp", kdb_bp, "[<vaddr>]", |
9452e977 DT |
533 | "Set/Display breakpoints", 0, |
534 | KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); | |
42c884c1 | 535 | kdb_register_flags("bl", kdb_bp, "[<vaddr>]", |
9452e977 DT |
536 | "Display breakpoints", 0, |
537 | KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); | |
5d5314d6 | 538 | if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) |
42c884c1 | 539 | kdb_register_flags("bph", kdb_bp, "[<vaddr>]", |
9452e977 DT |
540 | "[datar [length]|dataw [length]] Set hw brk", 0, |
541 | KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); | |
42c884c1 | 542 | kdb_register_flags("bc", kdb_bc, "<bpnum>", |
9452e977 DT |
543 | "Clear Breakpoint", 0, |
544 | KDB_ENABLE_FLOW_CTRL); | |
42c884c1 | 545 | kdb_register_flags("be", kdb_bc, "<bpnum>", |
9452e977 DT |
546 | "Enable Breakpoint", 0, |
547 | KDB_ENABLE_FLOW_CTRL); | |
42c884c1 | 548 | kdb_register_flags("bd", kdb_bc, "<bpnum>", |
9452e977 DT |
549 | "Disable Breakpoint", 0, |
550 | KDB_ENABLE_FLOW_CTRL); | |
5d5314d6 | 551 | |
42c884c1 | 552 | kdb_register_flags("ss", kdb_ss, "", |
9452e977 DT |
553 | "Single Step", 1, |
554 | KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS); | |
5d5314d6 JW |
555 | /* |
556 | * Architecture dependent initialization. | |
557 | */ | |
558 | } |