xref: /openbmc/linux/kernel/debug/kdb/kdb_bp.c (revision 234489ac)
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(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 
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);
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, 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(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, &nextarg, &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, 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(bptab, ARRAY_SIZE(bptab));
589 	if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
590 		kdb_register_table(&bphcmd, 1);
591 }
592