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) { | |
55 | if (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0) | |
56 | bp->bp_type = BP_ACCESS_WATCHPOINT; | |
57 | else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) | |
58 | bp->bp_type = BP_WRITE_WATCHPOINT; | |
59 | else if (strnicmp(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); | |
1ba0c172 JW |
156 | #ifdef CONFIG_DEBUG_RODATA |
157 | if (!bp->bp_type) { | |
158 | kdb_printf("Software breakpoints are unavailable.\n" | |
159 | " Change the kernel CONFIG_DEBUG_RODATA=n\n" | |
160 | " OR use hw breaks: help bph\n"); | |
161 | } | |
162 | #endif | |
5d5314d6 JW |
163 | return 1; |
164 | } | |
165 | return 0; | |
166 | } | |
167 | ||
168 | /* | |
169 | * kdb_bp_install | |
170 | * | |
171 | * Install kdb_breakpoints prior to returning from the | |
172 | * kernel debugger. This allows the kdb_breakpoints to be set | |
173 | * upon functions that are used internally by kdb, such as | |
174 | * printk(). This function is only called once per kdb session. | |
175 | */ | |
176 | void kdb_bp_install(struct pt_regs *regs) | |
177 | { | |
178 | int i; | |
179 | ||
180 | for (i = 0; i < KDB_MAXBPT; i++) { | |
181 | kdb_bp_t *bp = &kdb_breakpoints[i]; | |
182 | ||
183 | if (KDB_DEBUG(BP)) { | |
184 | kdb_printf("%s: bp %d bp_enabled %d\n", | |
185 | __func__, i, bp->bp_enabled); | |
186 | } | |
187 | if (bp->bp_enabled) | |
188 | _kdb_bp_install(regs, bp); | |
189 | } | |
190 | } | |
191 | ||
192 | /* | |
193 | * kdb_bp_remove | |
194 | * | |
195 | * Remove kdb_breakpoints upon entry to the kernel debugger. | |
196 | * | |
197 | * Parameters: | |
198 | * None. | |
199 | * Outputs: | |
200 | * None. | |
201 | * Returns: | |
202 | * None. | |
203 | * Locking: | |
204 | * None. | |
205 | * Remarks: | |
206 | */ | |
207 | void kdb_bp_remove(void) | |
208 | { | |
209 | int i; | |
210 | ||
211 | for (i = KDB_MAXBPT - 1; i >= 0; i--) { | |
212 | kdb_bp_t *bp = &kdb_breakpoints[i]; | |
213 | ||
214 | if (KDB_DEBUG(BP)) { | |
215 | kdb_printf("%s: bp %d bp_enabled %d\n", | |
216 | __func__, i, bp->bp_enabled); | |
217 | } | |
218 | if (bp->bp_enabled) | |
219 | _kdb_bp_remove(bp); | |
220 | } | |
221 | } | |
222 | ||
223 | ||
224 | /* | |
225 | * kdb_printbp | |
226 | * | |
227 | * Internal function to format and print a breakpoint entry. | |
228 | * | |
229 | * Parameters: | |
230 | * None. | |
231 | * Outputs: | |
232 | * None. | |
233 | * Returns: | |
234 | * None. | |
235 | * Locking: | |
236 | * None. | |
237 | * Remarks: | |
238 | */ | |
239 | ||
240 | static void kdb_printbp(kdb_bp_t *bp, int i) | |
241 | { | |
242 | kdb_printf("%s ", kdb_bptype(bp)); | |
243 | kdb_printf("BP #%d at ", i); | |
244 | kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT); | |
245 | ||
246 | if (bp->bp_enabled) | |
247 | kdb_printf("\n is enabled"); | |
248 | else | |
249 | kdb_printf("\n is disabled"); | |
250 | ||
251 | kdb_printf("\taddr at %016lx, hardtype=%d installed=%d\n", | |
252 | bp->bp_addr, bp->bp_type, bp->bp_installed); | |
253 | ||
254 | kdb_printf("\n"); | |
255 | } | |
256 | ||
257 | /* | |
258 | * kdb_bp | |
259 | * | |
260 | * Handle the bp commands. | |
261 | * | |
262 | * [bp|bph] <addr-expression> [DATAR|DATAW] | |
263 | * | |
264 | * Parameters: | |
265 | * argc Count of arguments in argv | |
266 | * argv Space delimited command line arguments | |
267 | * Outputs: | |
268 | * None. | |
269 | * Returns: | |
270 | * Zero for success, a kdb diagnostic if failure. | |
271 | * Locking: | |
272 | * None. | |
273 | * Remarks: | |
274 | * | |
275 | * bp Set breakpoint on all cpus. Only use hardware assist if need. | |
276 | * bph Set breakpoint on all cpus. Force hardware register | |
277 | */ | |
278 | ||
279 | static int kdb_bp(int argc, const char **argv) | |
280 | { | |
281 | int i, bpno; | |
282 | kdb_bp_t *bp, *bp_check; | |
283 | int diag; | |
5d5314d6 JW |
284 | char *symname = NULL; |
285 | long offset = 0ul; | |
286 | int nextarg; | |
287 | kdb_bp_t template = {0}; | |
288 | ||
289 | if (argc == 0) { | |
290 | /* | |
291 | * Display breakpoint table | |
292 | */ | |
293 | for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; | |
294 | bpno++, bp++) { | |
295 | if (bp->bp_free) | |
296 | continue; | |
297 | kdb_printbp(bp, bpno); | |
298 | } | |
299 | ||
300 | return 0; | |
301 | } | |
302 | ||
303 | nextarg = 1; | |
304 | diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr, | |
305 | &offset, &symname); | |
306 | if (diag) | |
307 | return diag; | |
308 | if (!template.bp_addr) | |
309 | return KDB_BADINT; | |
310 | ||
311 | /* | |
312 | * Find an empty bp structure to allocate | |
313 | */ | |
5d5314d6 JW |
314 | for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) { |
315 | if (bp->bp_free) | |
316 | break; | |
317 | } | |
318 | ||
319 | if (bpno == KDB_MAXBPT) | |
320 | return KDB_TOOMANYBPT; | |
321 | ||
322 | if (strcmp(argv[0], "bph") == 0) { | |
323 | template.bp_type = BP_HARDWARE_BREAKPOINT; | |
324 | diag = kdb_parsebp(argc, argv, &nextarg, &template); | |
325 | if (diag) | |
326 | return diag; | |
327 | } else { | |
328 | template.bp_type = BP_BREAKPOINT; | |
329 | } | |
330 | ||
331 | /* | |
332 | * Check for clashing breakpoints. | |
333 | * | |
334 | * Note, in this design we can't have hardware breakpoints | |
335 | * enabled for both read and write on the same address. | |
336 | */ | |
337 | for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT; | |
338 | i++, bp_check++) { | |
339 | if (!bp_check->bp_free && | |
340 | bp_check->bp_addr == template.bp_addr) { | |
341 | kdb_printf("You already have a breakpoint at " | |
342 | kdb_bfd_vma_fmt0 "\n", template.bp_addr); | |
343 | return KDB_DUPBPT; | |
344 | } | |
345 | } | |
346 | ||
347 | template.bp_enabled = 1; | |
348 | ||
349 | /* | |
350 | * Actually allocate the breakpoint found earlier | |
351 | */ | |
352 | *bp = template; | |
353 | bp->bp_free = 0; | |
354 | ||
355 | kdb_printbp(bp, bpno); | |
356 | ||
357 | return 0; | |
358 | } | |
359 | ||
360 | /* | |
361 | * kdb_bc | |
362 | * | |
363 | * Handles the 'bc', 'be', and 'bd' commands | |
364 | * | |
365 | * [bd|bc|be] <breakpoint-number> | |
366 | * [bd|bc|be] * | |
367 | * | |
368 | * Parameters: | |
369 | * argc Count of arguments in argv | |
370 | * argv Space delimited command line arguments | |
371 | * Outputs: | |
372 | * None. | |
373 | * Returns: | |
374 | * Zero for success, a kdb diagnostic for failure | |
375 | * Locking: | |
376 | * None. | |
377 | * Remarks: | |
378 | */ | |
379 | static int kdb_bc(int argc, const char **argv) | |
380 | { | |
381 | unsigned long addr; | |
382 | kdb_bp_t *bp = NULL; | |
383 | int lowbp = KDB_MAXBPT; | |
384 | int highbp = 0; | |
385 | int done = 0; | |
386 | int i; | |
387 | int diag = 0; | |
388 | ||
389 | int cmd; /* KDBCMD_B? */ | |
390 | #define KDBCMD_BC 0 | |
391 | #define KDBCMD_BE 1 | |
392 | #define KDBCMD_BD 2 | |
393 | ||
394 | if (strcmp(argv[0], "be") == 0) | |
395 | cmd = KDBCMD_BE; | |
396 | else if (strcmp(argv[0], "bd") == 0) | |
397 | cmd = KDBCMD_BD; | |
398 | else | |
399 | cmd = KDBCMD_BC; | |
400 | ||
401 | if (argc != 1) | |
402 | return KDB_ARGCOUNT; | |
403 | ||
404 | if (strcmp(argv[1], "*") == 0) { | |
405 | lowbp = 0; | |
406 | highbp = KDB_MAXBPT; | |
407 | } else { | |
408 | diag = kdbgetularg(argv[1], &addr); | |
409 | if (diag) | |
410 | return diag; | |
411 | ||
412 | /* | |
413 | * For addresses less than the maximum breakpoint number, | |
414 | * assume that the breakpoint number is desired. | |
415 | */ | |
416 | if (addr < KDB_MAXBPT) { | |
417 | bp = &kdb_breakpoints[addr]; | |
418 | lowbp = highbp = addr; | |
419 | highbp++; | |
420 | } else { | |
421 | for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; | |
422 | i++, bp++) { | |
423 | if (bp->bp_addr == addr) { | |
424 | lowbp = highbp = i; | |
425 | highbp++; | |
426 | break; | |
427 | } | |
428 | } | |
429 | } | |
430 | } | |
431 | ||
432 | /* | |
433 | * Now operate on the set of breakpoints matching the input | |
434 | * criteria (either '*' for all, or an individual breakpoint). | |
435 | */ | |
436 | for (bp = &kdb_breakpoints[lowbp], i = lowbp; | |
437 | i < highbp; | |
438 | i++, bp++) { | |
439 | if (bp->bp_free) | |
440 | continue; | |
441 | ||
442 | done++; | |
443 | ||
444 | switch (cmd) { | |
445 | case KDBCMD_BC: | |
446 | bp->bp_enabled = 0; | |
447 | ||
448 | kdb_printf("Breakpoint %d at " | |
449 | kdb_bfd_vma_fmt " cleared\n", | |
450 | i, bp->bp_addr); | |
451 | ||
452 | bp->bp_addr = 0; | |
453 | bp->bp_free = 1; | |
454 | ||
455 | break; | |
456 | case KDBCMD_BE: | |
457 | bp->bp_enabled = 1; | |
458 | ||
459 | kdb_printf("Breakpoint %d at " | |
460 | kdb_bfd_vma_fmt " enabled", | |
461 | i, bp->bp_addr); | |
462 | ||
463 | kdb_printf("\n"); | |
464 | break; | |
465 | case KDBCMD_BD: | |
466 | if (!bp->bp_enabled) | |
467 | break; | |
468 | ||
469 | bp->bp_enabled = 0; | |
470 | ||
471 | kdb_printf("Breakpoint %d at " | |
472 | kdb_bfd_vma_fmt " disabled\n", | |
473 | i, bp->bp_addr); | |
474 | ||
475 | break; | |
476 | } | |
477 | if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) { | |
478 | bp->bp_delay = 0; | |
479 | KDB_STATE_CLEAR(SSBPT); | |
480 | } | |
481 | } | |
482 | ||
483 | return (!done) ? KDB_BPTNOTFOUND : 0; | |
484 | } | |
485 | ||
486 | /* | |
487 | * kdb_ss | |
488 | * | |
36dfea42 | 489 | * Process the 'ss' (Single Step) command. |
5d5314d6 JW |
490 | * |
491 | * ss | |
5d5314d6 JW |
492 | * |
493 | * Parameters: | |
494 | * argc Argument count | |
495 | * argv Argument vector | |
496 | * Outputs: | |
497 | * None. | |
498 | * Returns: | |
36dfea42 | 499 | * KDB_CMD_SS for success, a kdb error if failure. |
5d5314d6 JW |
500 | * Locking: |
501 | * None. | |
502 | * Remarks: | |
503 | * | |
504 | * Set the arch specific option to trigger a debug trap after the next | |
505 | * instruction. | |
5d5314d6 JW |
506 | */ |
507 | ||
508 | static int kdb_ss(int argc, const char **argv) | |
509 | { | |
5d5314d6 JW |
510 | if (argc != 0) |
511 | return KDB_ARGCOUNT; | |
512 | /* | |
513 | * Set trace flag and go. | |
514 | */ | |
515 | KDB_STATE_SET(DOING_SS); | |
5d5314d6 JW |
516 | return KDB_CMD_SS; |
517 | } | |
518 | ||
519 | /* Initialize the breakpoint table and register breakpoint commands. */ | |
520 | ||
521 | void __init kdb_initbptab(void) | |
522 | { | |
523 | int i; | |
524 | kdb_bp_t *bp; | |
525 | ||
526 | /* | |
527 | * First time initialization. | |
528 | */ | |
529 | memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints)); | |
530 | ||
531 | for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++) | |
532 | bp->bp_free = 1; | |
533 | ||
534 | kdb_register_repeat("bp", kdb_bp, "[<vaddr>]", | |
535 | "Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS); | |
536 | kdb_register_repeat("bl", kdb_bp, "[<vaddr>]", | |
537 | "Display breakpoints", 0, KDB_REPEAT_NO_ARGS); | |
538 | if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) | |
539 | kdb_register_repeat("bph", kdb_bp, "[<vaddr>]", | |
540 | "[datar [length]|dataw [length]] Set hw brk", 0, KDB_REPEAT_NO_ARGS); | |
541 | kdb_register_repeat("bc", kdb_bc, "<bpnum>", | |
542 | "Clear Breakpoint", 0, KDB_REPEAT_NONE); | |
543 | kdb_register_repeat("be", kdb_bc, "<bpnum>", | |
544 | "Enable Breakpoint", 0, KDB_REPEAT_NONE); | |
545 | kdb_register_repeat("bd", kdb_bc, "<bpnum>", | |
546 | "Disable Breakpoint", 0, KDB_REPEAT_NONE); | |
547 | ||
548 | kdb_register_repeat("ss", kdb_ss, "", | |
549 | "Single Step", 1, KDB_REPEAT_NO_ARGS); | |
5d5314d6 JW |
550 | /* |
551 | * Architecture dependent initialization. | |
552 | */ | |
553 | } |