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#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) command.
490 *
491 *	ss
492 *
493 * Parameters:
494 *	argc	Argument count
495 *	argv	Argument vector
496 * Outputs:
497 *	None.
498 * Returns:
499 *	KDB_CMD_SS for success, a kdb error if failure.
500 * Locking:
501 *	None.
502 * Remarks:
503 *
504 *	Set the arch specific option to trigger a debug trap after the next
505 *	instruction.
506 */
507
508static int kdb_ss(int argc, const char **argv)
509{
510	if (argc != 0)
511		return KDB_ARGCOUNT;
512	/*
513	 * Set trace flag and go.
514	 */
515	KDB_STATE_SET(DOING_SS);
516	return KDB_CMD_SS;
517}
518
519/* Initialize the breakpoint table and register	breakpoint commands. */
520
521void __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);
550	/*
551	 * Architecture dependent initialization.
552	 */
553}
554