kdb: core for kgdb back end (1 of 2)

#ifndef _KDB_H

#define _KDB_H

/*

 * Kernel Debugger Architecture Independent Global Headers

 *

 * 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) 2000-2007 Silicon Graphics, Inc.  All Rights Reserved.

 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>

 * Copyright (C) 2009 Jason Wessel <jason.wessel@windriver.com>

 */

#ifdef	CONFIG_KGDB_KDB

#include <linux/init.h>

#include <linux/sched.h>

#include <asm/atomic.h>

#define KDB_POLL_FUNC_MAX	5

/*

 * kdb_initial_cpu is initialized to -1, and is set to the cpu

 * number whenever the kernel debugger is entered.

 */

extern int kdb_initial_cpu;

extern atomic_t kdb_event;

/*

 * kdb_diemsg

 *

 *	Contains a pointer to the last string supplied to the

 *	kernel 'die' panic function.

 */

extern const char *kdb_diemsg;

#define KDB_FLAG_EARLYKDB	(1 << 0) /* set from boot parameter kdb=early */

#define KDB_FLAG_CATASTROPHIC	(1 << 1) /* A catastrophic event has occurred */

#define KDB_FLAG_CMD_INTERRUPT	(1 << 2) /* Previous command was interrupted */

#define KDB_FLAG_NOIPI		(1 << 3) /* Do not send IPIs */

#define KDB_FLAG_ONLY_DO_DUMP	(1 << 4) /* Only do a dump, used when

					  * kdb is off */

#define KDB_FLAG_NO_CONSOLE	(1 << 5) /* No console is available,

					  * kdb is disabled */

#define KDB_FLAG_NO_VT_CONSOLE	(1 << 6) /* No VT console is available, do

					  * not use keyboard */

#define KDB_FLAG_NO_I8042	(1 << 7) /* No i8042 chip is available, do

					  * not use keyboard */

extern int kdb_flags;	/* Global flags, see kdb_state for per cpu state */

extern void kdb_save_flags(void);

extern void kdb_restore_flags(void);

#define KDB_FLAG(flag)		(kdb_flags & KDB_FLAG_##flag)

#define KDB_FLAG_SET(flag)	((void)(kdb_flags |= KDB_FLAG_##flag))

#define KDB_FLAG_CLEAR(flag)	((void)(kdb_flags &= ~KDB_FLAG_##flag))

/*

 * External entry point for the kernel debugger.  The pt_regs

 * at the time of entry are supplied along with the reason for

 * entry to the kernel debugger.

 */

typedef enum {

	KDB_REASON_ENTER = 1,	/* KDB_ENTER() trap/fault - regs valid */

	KDB_REASON_ENTER_SLAVE,	/* KDB_ENTER_SLAVE() trap/fault - regs valid */

	KDB_REASON_BREAK,	/* Breakpoint inst. - regs valid */

	KDB_REASON_DEBUG,	/* Debug Fault - regs valid */

	KDB_REASON_OOPS,	/* Kernel Oops - regs valid */

	KDB_REASON_SWITCH,	/* CPU switch - regs valid*/

	KDB_REASON_KEYBOARD,	/* Keyboard entry - regs valid */

	KDB_REASON_NMI,		/* Non-maskable interrupt; regs valid */

	KDB_REASON_RECURSE,	/* Recursive entry to kdb;

				 * regs probably valid */

	KDB_REASON_SSTEP,	/* Single Step trap. - regs valid */

} kdb_reason_t;

extern int kdb_printf(const char *, ...)

	    __attribute__ ((format (printf, 1, 2)));

typedef int (*kdb_printf_t)(const char *, ...)

	     __attribute__ ((format (printf, 1, 2)));

extern void kdb_init(int level);

/* Access to kdb specific polling devices */

typedef int (*get_char_func)(void);

extern get_char_func kdb_poll_funcs[];

extern int kdb_get_kbd_char(void);

static inline

int kdb_process_cpu(const struct task_struct *p)

{

	unsigned int cpu = task_thread_info(p)->cpu;

	if (cpu > num_possible_cpus())

		cpu = 0;

	return cpu;

}

/* kdb access to register set for stack dumping */

extern struct pt_regs *kdb_current_regs;

#else /* ! CONFIG_KGDB_KDB */

#define kdb_printf(...)

#define kdb_init(x)

#endif	/* CONFIG_KGDB_KDB */

enum {

	KDB_NOT_INITIALIZED,

	KDB_INIT_EARLY,

	KDB_INIT_FULL,

};

#endif	/* !_KDB_H */

#

obj-$(CONFIG_KGDB) += debug_core.o gdbstub.o

obj-$(CONFIG_KGDB_KDB) += kdb/

gen-kdb_cmds.c

# 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.

#

CCVERSION	:= $(shell $(CC) -v 2>&1 | sed -ne '$$p')

obj-y := kdb_io.o kdb_main.o kdb_support.o kdb_bt.o gen-kdb_cmds.o kdb_bp.o kdb_debugger.o

clean-files := gen-kdb_cmds.c

quiet_cmd_gen-kdb = GENKDB  $@

      cmd_gen-kdb = $(AWK) 'BEGIN {print "\#include <linux/stddef.h>"; print "\#include <linux/init.h>"} \

		/^\#/{next} \

		/^[ \t]*$$/{next} \

		{gsub(/"/, "\\\"", $$0); \

		  print "static __initdata char kdb_cmd" cmds++ "[] = \"" $$0 "\\n\";"} \

		END {print "extern char *kdb_cmds[]; char __initdata *kdb_cmds[] = {"; for (i = 0; i < cmds; ++i) {print "  kdb_cmd" i ","}; print("  NULL\n};");}' \

		$(filter-out %/Makefile,$^) > $@#

$(obj)/gen-kdb_cmds.c:	$(src)/kdb_cmds $(src)/Makefile

	$(call cmd,gen-kdb)

/*

 * 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 (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0)

			bp->bp_type = BP_ACCESS_WATCHPOINT;

		else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0)

			bp->bp_type = BP_WRITE_WATCHPOINT;

		else if (strnicmp(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);

		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;

	int free;

	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

	 */

	free = KDB_MAXBPT;

	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) and 'ssb' (Single Step to Branch)

 *	commands.

 *

 *	ss

 *	ssb

 *

 * Parameters:

 *	argc	Argument count

 *	argv	Argument vector

 * Outputs:

 *	None.

 * Returns:

 *	KDB_CMD_SS[B] for success, a kdb error if failure.

 * Locking:

 *	None.

 * Remarks:

 *

 *	Set the arch specific option to trigger a debug trap after the next

 *	instruction.

 *

 *	For 'ssb', set the trace flag in the debug trap handler

 *	after printing the current insn and return directly without

 *	invoking the kdb command processor, until a branch instruction

 *	is encountered.

 */

static int kdb_ss(int argc, const char **argv)

{

	int ssb = 0;

	ssb = (strcmp(argv[0], "ssb") == 0);

	if (argc != 0)

		return KDB_ARGCOUNT;

	/*

	 * Set trace flag and go.

	 */

	KDB_STATE_SET(DOING_SS);

	if (ssb) {

		KDB_STATE_SET(DOING_SSB);

		return KDB_CMD_SSB;

	}

	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_repeat("bp", kdb_bp, "[<vaddr>]",

		"Set/Display breakpoints", 0, KDB_REPEAT_NO_ARGS);

	kdb_register_repeat("bl", kdb_bp, "[<vaddr>]",

		"Display breakpoints", 0, KDB_REPEAT_NO_ARGS);

	if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)

		kdb_register_repeat("bph", kdb_bp, "[<vaddr>]",

		"[datar [length]|dataw [length]]   Set hw brk", 0, KDB_REPEAT_NO_ARGS);

	kdb_register_repeat("bc", kdb_bc, "<bpnum>",

		"Clear Breakpoint", 0, KDB_REPEAT_NONE);

	kdb_register_repeat("be", kdb_bc, "<bpnum>",

		"Enable Breakpoint", 0, KDB_REPEAT_NONE);

	kdb_register_repeat("bd", kdb_bc, "<bpnum>",

		"Disable Breakpoint", 0, KDB_REPEAT_NONE);

	kdb_register_repeat("ss", kdb_ss, "",

		"Single Step", 1, KDB_REPEAT_NO_ARGS);

	kdb_register_repeat("ssb", kdb_ss, "",

		"Single step to branch/call", 0, KDB_REPEAT_NO_ARGS);

	/*

	 * Architecture dependent initialization.

	 */

}