Loading...
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 */
25kdb_bp_t kdb_breakpoints[KDB_MAXBPT];
26
27static void kdb_setsinglestep(struct pt_regs *regs)
28{
29 KDB_STATE_SET(DOING_SS);
30}
31
32static char *kdb_rwtypes[] = {
33 "Instruction(i)",
34 "Instruction(Register)",
35 "Data Write",
36 "I/O",
37 "Data Access"
38};
39
40static 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
48static 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
92static 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
108static 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
125static 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#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
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 */
176void 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 */
207void 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
240static 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
279static int kdb_bp(int argc, const char **argv)
280{
281 int i, bpno;
282 kdb_bp_t *bp, *bp_check;
283 int diag;
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 */
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 */
379static 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 *
489 * Process the 'ss' (Single Step) and 'ssb' (Single Step to Branch)
490 * commands.
491 *
492 * ss
493 * ssb
494 *
495 * Parameters:
496 * argc Argument count
497 * argv Argument vector
498 * Outputs:
499 * None.
500 * Returns:
501 * KDB_CMD_SS[B] for success, a kdb error if failure.
502 * Locking:
503 * None.
504 * Remarks:
505 *
506 * Set the arch specific option to trigger a debug trap after the next
507 * instruction.
508 *
509 * For 'ssb', set the trace flag in the debug trap handler
510 * after printing the current insn and return directly without
511 * invoking the kdb command processor, until a branch instruction
512 * is encountered.
513 */
514
515static int kdb_ss(int argc, const char **argv)
516{
517 int ssb = 0;
518
519 ssb = (strcmp(argv[0], "ssb") == 0);
520 if (argc != 0)
521 return KDB_ARGCOUNT;
522 /*
523 * Set trace flag and go.
524 */
525 KDB_STATE_SET(DOING_SS);
526 if (ssb) {
527 KDB_STATE_SET(DOING_SSB);
528 return KDB_CMD_SSB;
529 }
530 return KDB_CMD_SS;
531}
532
533/* Initialize the breakpoint table and register breakpoint commands. */
534
535void __init kdb_initbptab(void)
536{
537 int i;
538 kdb_bp_t *bp;
539
540 /*
541 * First time initialization.
542 */
543 memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints));
544
545 for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
546 bp->bp_free = 1;
547
548 kdb_register_repeat("bp", kdb_bp, "[<vaddr>]",
549 "Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
550 kdb_register_repeat("bl", kdb_bp, "[<vaddr>]",
551 "Display breakpoints", 0, KDB_REPEAT_NO_ARGS);
552 if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
553 kdb_register_repeat("bph", kdb_bp, "[<vaddr>]",
554 "[datar [length]|dataw [length]] Set hw brk", 0, KDB_REPEAT_NO_ARGS);
555 kdb_register_repeat("bc", kdb_bc, "<bpnum>",
556 "Clear Breakpoint", 0, KDB_REPEAT_NONE);
557 kdb_register_repeat("be", kdb_bc, "<bpnum>",
558 "Enable Breakpoint", 0, KDB_REPEAT_NONE);
559 kdb_register_repeat("bd", kdb_bc, "<bpnum>",
560 "Disable Breakpoint", 0, KDB_REPEAT_NONE);
561
562 kdb_register_repeat("ss", kdb_ss, "",
563 "Single Step", 1, KDB_REPEAT_NO_ARGS);
564 kdb_register_repeat("ssb", kdb_ss, "",
565 "Single step to branch/call", 0, KDB_REPEAT_NO_ARGS);
566 /*
567 * Architecture dependent initialization.
568 */
569}