[deliverable/linux.git] / kernel / debug / kdb / kdb_bp.c

/*
 * Kernel Debugger Architecture Independent Breakpoint Handler
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
 */

#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kdb.h>
#include <linux/kgdb.h>
#include <linux/smp.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include "kdb_private.h"

/*
 * Table of kdb_breakpoints
 */
kdb_bp_t kdb_breakpoints[KDB_MAXBPT];

static void kdb_setsinglestep(struct pt_regs *regs)
{
	KDB_STATE_SET(DOING_SS);
}

static char *kdb_rwtypes[] = {
	"Instruction(i)",
	"Instruction(Register)",
	"Data Write",
	"I/O",
	"Data Access"
};

static char *kdb_bptype(kdb_bp_t *bp)
{
	if (bp->bp_type < 0 || bp->bp_type > 4)
		return "";

	return kdb_rwtypes[bp->bp_type];
}

static int kdb_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp)
{
	int nextarg = *nextargp;
	int diag;

	bp->bph_length = 1;
	if ((argc + 1) != nextarg) {
		if (strncasecmp(argv[nextarg], "datar", sizeof("datar")) == 0)
			bp->bp_type = BP_ACCESS_WATCHPOINT;
		else if (strncasecmp(argv[nextarg], "dataw", sizeof("dataw")) == 0)
			bp->bp_type = BP_WRITE_WATCHPOINT;
		else if (strncasecmp(argv[nextarg], "inst", sizeof("inst")) == 0)
			bp->bp_type = BP_HARDWARE_BREAKPOINT;
		else
			return KDB_ARGCOUNT;

		bp->bph_length = 1;

		nextarg++;

		if ((argc + 1) != nextarg) {
			unsigned long len;

			diag = kdbgetularg((char *)argv[nextarg],
					   &len);
			if (diag)
				return diag;


			if (len > 8)
				return KDB_BADLENGTH;

			bp->bph_length = len;
			nextarg++;
		}

		if ((argc + 1) != nextarg)
			return KDB_ARGCOUNT;
	}

	*nextargp = nextarg;
	return 0;
}

static int _kdb_bp_remove(kdb_bp_t *bp)
{
	int ret = 1;
	if (!bp->bp_installed)
		return ret;
	if (!bp->bp_type)
		ret = dbg_remove_sw_break(bp->bp_addr);
	else
		ret = arch_kgdb_ops.remove_hw_breakpoint(bp->bp_addr,
			 bp->bph_length,
			 bp->bp_type);
	if (ret == 0)
		bp->bp_installed = 0;
	return ret;
}

static void kdb_handle_bp(struct pt_regs *regs, kdb_bp_t *bp)
{
	if (KDB_DEBUG(BP))
		kdb_printf("regs->ip = 0x%lx\n", instruction_pointer(regs));

	/*
	 * Setup single step
	 */
	kdb_setsinglestep(regs);

	/*
	 * Reset delay attribute
	 */
	bp->bp_delay = 0;
	bp->bp_delayed = 1;
}

static int _kdb_bp_install(struct pt_regs *regs, kdb_bp_t *bp)
{
	int ret;
	/*
	 * Install the breakpoint, if it is not already installed.
	 */

	if (KDB_DEBUG(BP))
		kdb_printf("%s: bp_installed %d\n",
			   __func__, bp->bp_installed);
	if (!KDB_STATE(SSBPT))
		bp->bp_delay = 0;
	if (bp->bp_installed)
		return 1;
	if (bp->bp_delay || (bp->bp_delayed && KDB_STATE(DOING_SS))) {
		if (KDB_DEBUG(BP))
			kdb_printf("%s: delayed bp\n", __func__);
		kdb_handle_bp(regs, bp);
		return 0;
	}
	if (!bp->bp_type)
		ret = dbg_set_sw_break(bp->bp_addr);
	else
		ret = arch_kgdb_ops.set_hw_breakpoint(bp->bp_addr,
			 bp->bph_length,
			 bp->bp_type);
	if (ret == 0) {
		bp->bp_installed = 1;
	} else {
		kdb_printf("%s: failed to set breakpoint at 0x%lx\n",
			   __func__, bp->bp_addr);
		if (!bp->bp_type) {
			kdb_printf("Software breakpoints are unavailable.\n"
				   "  Boot the kernel with rodata=off\n"
				   "  OR use hw breaks: help bph\n");
		}
		return 1;
	}
	return 0;
}

/*
 * kdb_bp_install
 *
 *	Install kdb_breakpoints prior to returning from the
 *	kernel debugger.  This allows the kdb_breakpoints to be set
 *	upon functions that are used internally by kdb, such as
 *	printk().  This function is only called once per kdb session.
 */
void kdb_bp_install(struct pt_regs *regs)
{
	int i;

	for (i = 0; i < KDB_MAXBPT; i++) {
		kdb_bp_t *bp = &kdb_breakpoints[i];

		if (KDB_DEBUG(BP)) {
			kdb_printf("%s: bp %d bp_enabled %d\n",
				   __func__, i, bp->bp_enabled);
		}
		if (bp->bp_enabled)
			_kdb_bp_install(regs, bp);
	}
}

/*
 * kdb_bp_remove
 *
 *	Remove kdb_breakpoints upon entry to the kernel debugger.
 *
 * Parameters:
 *	None.
 * Outputs:
 *	None.
 * Returns:
 *	None.
 * Locking:
 *	None.
 * Remarks:
 */
void kdb_bp_remove(void)
{
	int i;

	for (i = KDB_MAXBPT - 1; i >= 0; i--) {
		kdb_bp_t *bp = &kdb_breakpoints[i];

		if (KDB_DEBUG(BP)) {
			kdb_printf("%s: bp %d bp_enabled %d\n",
				   __func__, i, bp->bp_enabled);
		}
		if (bp->bp_enabled)
			_kdb_bp_remove(bp);
	}
}


/*
 * kdb_printbp
 *
 *	Internal function to format and print a breakpoint entry.
 *
 * Parameters:
 *	None.
 * Outputs:
 *	None.
 * Returns:
 *	None.
 * Locking:
 *	None.
 * Remarks:
 */

static void kdb_printbp(kdb_bp_t *bp, int i)
{
	kdb_printf("%s ", kdb_bptype(bp));
	kdb_printf("BP #%d at ", i);
	kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT);

	if (bp->bp_enabled)
		kdb_printf("\n    is enabled");
	else
		kdb_printf("\n    is disabled");

	kdb_printf("\taddr at %016lx, hardtype=%d installed=%d\n",
		   bp->bp_addr, bp->bp_type, bp->bp_installed);

	kdb_printf("\n");
}

/*
 * kdb_bp
 *
 *	Handle the bp commands.
 *
 *	[bp|bph] <addr-expression> [DATAR|DATAW]
 *
 * Parameters:
 *	argc	Count of arguments in argv
 *	argv	Space delimited command line arguments
 * Outputs:
 *	None.
 * Returns:
 *	Zero for success, a kdb diagnostic if failure.
 * Locking:
 *	None.
 * Remarks:
 *
 *	bp	Set breakpoint on all cpus.  Only use hardware assist if need.
 *	bph	Set breakpoint on all cpus.  Force hardware register
 */

static int kdb_bp(int argc, const char **argv)
{
	int i, bpno;
	kdb_bp_t *bp, *bp_check;
	int diag;
	char *symname = NULL;
	long offset = 0ul;
	int nextarg;
	kdb_bp_t template = {0};

	if (argc == 0) {
		/*
		 * Display breakpoint table
		 */
		for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT;
		     bpno++, bp++) {
			if (bp->bp_free)
				continue;
			kdb_printbp(bp, bpno);
		}

		return 0;
	}

	nextarg = 1;
	diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr,
			     &offset, &symname);
	if (diag)
		return diag;
	if (!template.bp_addr)
		return KDB_BADINT;

	/*
	 * Find an empty bp structure to allocate
	 */
	for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) {
		if (bp->bp_free)
			break;
	}

	if (bpno == KDB_MAXBPT)
		return KDB_TOOMANYBPT;

	if (strcmp(argv[0], "bph") == 0) {
		template.bp_type = BP_HARDWARE_BREAKPOINT;
		diag = kdb_parsebp(argc, argv, &nextarg, &template);
		if (diag)
			return diag;
	} else {
		template.bp_type = BP_BREAKPOINT;
	}

	/*
	 * Check for clashing breakpoints.
	 *
	 * Note, in this design we can't have hardware breakpoints
	 * enabled for both read and write on the same address.
	 */
	for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT;
	     i++, bp_check++) {
		if (!bp_check->bp_free &&
		    bp_check->bp_addr == template.bp_addr) {
			kdb_printf("You already have a breakpoint at "
				   kdb_bfd_vma_fmt0 "\n", template.bp_addr);
			return KDB_DUPBPT;
		}
	}

	template.bp_enabled = 1;

	/*
	 * Actually allocate the breakpoint found earlier
	 */
	*bp = template;
	bp->bp_free = 0;

	kdb_printbp(bp, bpno);

	return 0;
}

/*
 * kdb_bc
 *
 *	Handles the 'bc', 'be', and 'bd' commands
 *
 *	[bd|bc|be] <breakpoint-number>
 *	[bd|bc|be] *
 *
 * Parameters:
 *	argc	Count of arguments in argv
 *	argv	Space delimited command line arguments
 * Outputs:
 *	None.
 * Returns:
 *	Zero for success, a kdb diagnostic for failure
 * Locking:
 *	None.
 * Remarks:
 */
static int kdb_bc(int argc, const char **argv)
{
	unsigned long addr;
	kdb_bp_t *bp = NULL;
	int lowbp = KDB_MAXBPT;
	int highbp = 0;
	int done = 0;
	int i;
	int diag = 0;

	int cmd;			/* KDBCMD_B? */
#define KDBCMD_BC	0
#define KDBCMD_BE	1
#define KDBCMD_BD	2

	if (strcmp(argv[0], "be") == 0)
		cmd = KDBCMD_BE;
	else if (strcmp(argv[0], "bd") == 0)
		cmd = KDBCMD_BD;
	else
		cmd = KDBCMD_BC;

	if (argc != 1)
		return KDB_ARGCOUNT;

	if (strcmp(argv[1], "*") == 0) {
		lowbp = 0;
		highbp = KDB_MAXBPT;
	} else {
		diag = kdbgetularg(argv[1], &addr);
		if (diag)
			return diag;

		/*
		 * For addresses less than the maximum breakpoint number,
		 * assume that the breakpoint number is desired.
		 */
		if (addr < KDB_MAXBPT) {
			bp = &kdb_breakpoints[addr];
			lowbp = highbp = addr;
			highbp++;
		} else {
			for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT;
			    i++, bp++) {
				if (bp->bp_addr == addr) {
					lowbp = highbp = i;
					highbp++;
					break;
				}
			}
		}
	}

	/*
	 * Now operate on the set of breakpoints matching the input
	 * criteria (either '*' for all, or an individual breakpoint).
	 */
	for (bp = &kdb_breakpoints[lowbp], i = lowbp;
	    i < highbp;
	    i++, bp++) {
		if (bp->bp_free)
			continue;

		done++;

		switch (cmd) {
		case KDBCMD_BC:
			bp->bp_enabled = 0;

			kdb_printf("Breakpoint %d at "
				   kdb_bfd_vma_fmt " cleared\n",
				   i, bp->bp_addr);

			bp->bp_addr = 0;
			bp->bp_free = 1;

			break;
		case KDBCMD_BE:
			bp->bp_enabled = 1;

			kdb_printf("Breakpoint %d at "
				   kdb_bfd_vma_fmt " enabled",
				   i, bp->bp_addr);

			kdb_printf("\n");
			break;
		case KDBCMD_BD:
			if (!bp->bp_enabled)
				break;

			bp->bp_enabled = 0;

			kdb_printf("Breakpoint %d at "
				   kdb_bfd_vma_fmt " disabled\n",
				   i, bp->bp_addr);

			break;
		}
		if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) {
			bp->bp_delay = 0;
			KDB_STATE_CLEAR(SSBPT);
		}
	}

	return (!done) ? KDB_BPTNOTFOUND : 0;
}

/*
 * kdb_ss
 *
 *	Process the 'ss' (Single Step) command.
 *
 *	ss
 *
 * Parameters:
 *	argc	Argument count
 *	argv	Argument vector
 * Outputs:
 *	None.
 * Returns:
 *	KDB_CMD_SS for success, a kdb error if failure.
 * Locking:
 *	None.
 * Remarks:
 *
 *	Set the arch specific option to trigger a debug trap after the next
 *	instruction.
 */

static int kdb_ss(int argc, const char **argv)
{
	if (argc != 0)
		return KDB_ARGCOUNT;
	/*
	 * Set trace flag and go.
	 */
	KDB_STATE_SET(DOING_SS);
	return KDB_CMD_SS;
}

/* Initialize the breakpoint table and register	breakpoint commands. */

void __init kdb_initbptab(void)
{
	int i;
	kdb_bp_t *bp;

	/*
	 * First time initialization.
	 */
	memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints));

	for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
		bp->bp_free = 1;

	kdb_register_flags("bp", kdb_bp, "[<vaddr>]",
		"Set/Display breakpoints", 0,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	kdb_register_flags("bl", kdb_bp, "[<vaddr>]",
		"Display breakpoints", 0,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
		kdb_register_flags("bph", kdb_bp, "[<vaddr>]",
		"[datar [length]|dataw [length]]   Set hw brk", 0,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	kdb_register_flags("bc", kdb_bc, "<bpnum>",
		"Clear Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);
	kdb_register_flags("be", kdb_bc, "<bpnum>",
		"Enable Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);
	kdb_register_flags("bd", kdb_bc, "<bpnum>",
		"Disable Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);

	kdb_register_flags("ss", kdb_ss, "",
		"Single Step", 1,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	/*
	 * Architecture dependent initialization.
	 */
}
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) {
f9f2bac2	55	if (strncasecmp(argv[nextarg], "datar", sizeof("datar")) == 0)
5d5314d6	56	bp->bp_type = BP_ACCESS_WATCHPOINT;
f9f2bac2	57	else if (strncasecmp(argv[nextarg], "dataw", sizeof("dataw")) == 0)
5d5314d6	58	bp->bp_type = BP_WRITE_WATCHPOINT;
f9f2bac2	59	else if (strncasecmp(argv[nextarg], "inst", sizeof("inst")) == 0)
5d5314d6 JW	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	if (!bp->bp_type) {
1ba0c172 JW	157	kdb_printf("Software breakpoints are unavailable.\n"
d2aa1aca	158	" Boot the kernel with rodata=off\n"
1ba0c172 JW	159	" OR use hw breaks: help bph\n");
1ba0c172 JW	160	}
5d5314d6 JW	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("\taddr 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;
5d5314d6 JW	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	*/
5d5314d6 JW	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	*/
377	static 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	*
36dfea42	487	* Process the 'ss' (Single Step) command.
5d5314d6 JW	488	*
5d5314d6 JW	489	* ss
5d5314d6 JW	490	*
	491	* Parameters:
	492	* argc Argument count
	493	* argv Argument vector
	494	* Outputs:
	495	* None.
	496	* Returns:
36dfea42	497	* KDB_CMD_SS for success, a kdb error if failure.
5d5314d6 JW	498	* Locking:
	499	* None.
	500	* Remarks:
	501	*
	502	* Set the arch specific option to trigger a debug trap after the next
	503	* instruction.
5d5314d6 JW	504	*/
	505
	506	static int kdb_ss(int argc, const char **argv)
	507	{
5d5314d6 JW	508	if (argc != 0)
	509	return KDB_ARGCOUNT;
	510	/*
	511	* Set trace flag and go.
	512	*/
	513	KDB_STATE_SET(DOING_SS);
5d5314d6 JW	514	return KDB_CMD_SS;
	515	}
	516
	517	/* Initialize the breakpoint table and register breakpoint commands. */
	518
	519	void __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
42c884c1	532	kdb_register_flags("bp", kdb_bp, "[<vaddr>]",
9452e977 DT	533	"Set/Display breakpoints", 0,
9452e977 DT	534	KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
42c884c1	535	kdb_register_flags("bl", kdb_bp, "[<vaddr>]",
9452e977 DT	536	"Display breakpoints", 0,
9452e977 DT	537	KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
5d5314d6	538	if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
42c884c1	539	kdb_register_flags("bph", kdb_bp, "[<vaddr>]",
9452e977 DT	540	"[datar [length]\|dataw [length]] Set hw brk", 0,
9452e977 DT	541	KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
42c884c1	542	kdb_register_flags("bc", kdb_bc, "<bpnum>",
9452e977 DT	543	"Clear Breakpoint", 0,
9452e977 DT	544	KDB_ENABLE_FLOW_CTRL);
42c884c1	545	kdb_register_flags("be", kdb_bc, "<bpnum>",
9452e977 DT	546	"Enable Breakpoint", 0,
9452e977 DT	547	KDB_ENABLE_FLOW_CTRL);
42c884c1	548	kdb_register_flags("bd", kdb_bc, "<bpnum>",
9452e977 DT	549	"Disable Breakpoint", 0,
9452e977 DT	550	KDB_ENABLE_FLOW_CTRL);
5d5314d6	551
42c884c1	552	kdb_register_flags("ss", kdb_ss, "",
9452e977 DT	553	"Single Step", 1,
9452e977 DT	554	KDB_ENABLE_FLOW_CTRL \| KDB_REPEAT_NO_ARGS);
5d5314d6 JW	555	/*
	556	* Architecture dependent initialization.
	557	*/
	558	}