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