[dragonfly.git] / sys / platform / pc32 / i386 / db_trace.c

/*
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 *
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 *
 * $FreeBSD: src/sys/i386/i386/db_trace.c,v 1.35.2.3 2002/02/21 22:31:25 silby Exp $
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/linker_set.h>
#include <sys/lock.h>
#include <sys/proc.h>
#include <sys/reg.h>

#include <machine/cpu.h>
#include <machine/md_var.h>

#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>
#include <vm/vm_map.h>
#include <ddb/ddb.h>

#include <sys/user.h>

#include <ddb/db_access.h>
#include <ddb/db_sym.h>
#include <ddb/db_variables.h>

db_varfcn_t db_dr0;
db_varfcn_t db_dr1;
db_varfcn_t db_dr2;
db_varfcn_t db_dr3;
db_varfcn_t db_dr4;
db_varfcn_t db_dr5;
db_varfcn_t db_dr6;
db_varfcn_t db_dr7;

/*
 * Machine register set.
 */
struct db_variable db_regs[] = {
	{ "cs",		&ddb_regs.tf_cs,     NULL },
	{ "ds",		&ddb_regs.tf_ds,     NULL },
	{ "es",		&ddb_regs.tf_es,     NULL },
	{ "fs",		&ddb_regs.tf_fs,     NULL },
	{ "gs",		&ddb_regs.tf_gs,     NULL },
	{ "ss",		&ddb_regs.tf_ss,     NULL },
	{ "eax",	&ddb_regs.tf_eax,    NULL },
	{ "ecx",	&ddb_regs.tf_ecx,    NULL },
	{ "edx",	&ddb_regs.tf_edx,    NULL },
	{ "ebx",	&ddb_regs.tf_ebx,    NULL },
	{ "esp",	&ddb_regs.tf_esp,    NULL },
	{ "ebp",	&ddb_regs.tf_ebp,    NULL },
	{ "esi",	&ddb_regs.tf_esi,    NULL },
	{ "edi",	&ddb_regs.tf_edi,    NULL },
	{ "eip",	&ddb_regs.tf_eip,    NULL },
	{ "efl",	&ddb_regs.tf_eflags, NULL },
	{ "dr0",	NULL,		     db_dr0 },
	{ "dr1",	NULL,		     db_dr1 },
	{ "dr2",	NULL,		     db_dr2 },
	{ "dr3",	NULL,		     db_dr3 },
	{ "dr4",	NULL,		     db_dr4 },
	{ "dr5",	NULL,		     db_dr5 },
	{ "dr6",	NULL,		     db_dr6 },
	{ "dr7",	NULL,		     db_dr7 },
};
struct db_variable *db_eregs = db_regs + NELEM(db_regs);

/*
 * Stack trace.
 */
#define	INKERNEL(va)	(((vm_offset_t)(va)) >= USRSTACK)

struct i386_frame {
	struct i386_frame	*f_frame;
	int			f_retaddr;
	int			f_arg0;
};

#define NORMAL		0
#define	TRAP		1
#define	INTERRUPT	2
#define	SYSCALL		3

static void	db_nextframe(struct i386_frame **, db_addr_t *);
static int	db_numargs(struct i386_frame *);
static void	db_print_stack_entry(const char *, int, char **, int *, db_addr_t);


static char	*watchtype_str(int type);
static int	ki386_set_watch(int watchnum, unsigned int watchaddr, 
                               int size, int access, struct dbreg * d);
static int	ki386_clr_watch(int watchnum, struct dbreg * d);
int		db_md_set_watchpoint(db_expr_t addr, db_expr_t size);
int		db_md_clr_watchpoint(db_expr_t addr, db_expr_t size);
void		db_md_list_watchpoints(void);


/*
 * Figure out how many arguments were passed into the frame at "fp".
 */
static int
db_numargs(struct i386_frame *fp)
{
	int	*argp;
	int	inst;
	int	args;

	argp = (int *)db_get_value((int)&fp->f_retaddr, 4, FALSE);
	/*
	 * XXX etext is wrong for LKMs.  We should attempt to interpret
	 * the instruction at the return address in all cases.  This
	 * may require better fault handling.
	 */
	if (argp < (int *)btext || argp >= (int *)etext) {
		args = 5;
	} else {
		inst = db_get_value((int)argp, 4, FALSE);
		if ((inst & 0xff) == 0x59)	/* popl %ecx */
			args = 1;
		else if ((inst & 0xffff) == 0xc483)	/* addl $Ibs, %esp */
			args = ((inst >> 16) & 0xff) / 4;
		else
			args = 5;
	}
	return(args);
}

static void
db_print_stack_entry(const char *name, int narg, char **argnp, int *argp,
		     db_addr_t callpc)
{
	db_printf("%s(", name);
	while (narg) {
		if (argnp)
			db_printf("%s=", *argnp++);
		db_printf("%r", db_get_value((int)argp, 4, FALSE));
		argp++;
		if (--narg != 0)
			db_printf(",");
  	}
	db_printf(") at ");
	db_printsym(callpc, DB_STGY_PROC);
        db_printf(" %p ",  (void*) callpc);
	db_printf("\n");
}

/*
 * Figure out the next frame up in the call stack.
 */
static void
db_nextframe(struct i386_frame **fp, db_addr_t *ip)
{
	struct trapframe *tf;
	int frame_type;
	int eip, esp, ebp;
	db_expr_t offset;
	const char *sym, *name;

	eip = db_get_value((int) &(*fp)->f_retaddr, 4, FALSE);
	ebp = db_get_value((int) &(*fp)->f_frame, 4, FALSE);

	/*
	 * Figure out frame type.
	 */

	frame_type = NORMAL;

	sym = db_search_symbol(eip, DB_STGY_ANY, &offset);
	db_symbol_values(sym, &name, NULL);
	if (name != NULL) {
		if (!strcmp(name, "calltrap")) {
			frame_type = TRAP;
		} else if (!strncmp(name, "Xresume", 7)) {
			frame_type = INTERRUPT;
		} else if (!strcmp(name, "_Xsyscall")) {
			frame_type = SYSCALL;
		}
	}

	/*
	 * Normal frames need no special processing.
	 */
	if (frame_type == NORMAL) {
		*ip = (db_addr_t) eip;
		*fp = (struct i386_frame *) ebp;
		return;
	}

	db_print_stack_entry(name, 0, 0, 0, eip);

	/*
	 * Point to base of trapframe which is just above the
	 * current frame.
	 */
	tf = (struct trapframe *) ((int)*fp + 8);

	esp = (ISPL(tf->tf_cs) == SEL_UPL) ?  tf->tf_esp : (int)&tf->tf_esp;
	switch (frame_type) {
	case TRAP:
		if (INKERNEL((int) tf)) {
			eip = tf->tf_eip;
			ebp = tf->tf_ebp;
			db_printf(
		    "--- trap %#r, eip = %#r, esp = %#r, ebp = %#r ---\n",
			    tf->tf_trapno, eip, esp, ebp);
		}
		break;
	case SYSCALL:
		if (INKERNEL((int) tf)) {
			eip = tf->tf_eip;
			ebp = tf->tf_ebp;
			db_printf(
		    "--- syscall %#r, eip = %#r, esp = %#r, ebp = %#r ---\n",
			    tf->tf_eax, eip, esp, ebp);
		}
		break;
	case INTERRUPT:
		tf = (struct trapframe *)((int)*fp + 16);
		if (INKERNEL((int) tf)) {
			eip = tf->tf_eip;
			ebp = tf->tf_ebp;
			db_printf(
		    "--- interrupt, eip = %#r, esp = %#r, ebp = %#r ---\n",
			    eip, esp, ebp);
		}
		break;
	default:
		break;
	}

	*ip = (db_addr_t) eip;
	*fp = (struct i386_frame *) ebp;
}

void
db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
		   char *modif)
{
	struct i386_frame *frame;
	int *argp;
	db_addr_t callpc;
	boolean_t first;
	int i;

	if (count == -1)
		count = 1024;

	if (!have_addr) {
		frame = (struct i386_frame *)BP_REGS(&ddb_regs);
		if (frame == NULL)
			frame = (struct i386_frame *)(SP_REGS(&ddb_regs) - 4);
		callpc = PC_REGS(&ddb_regs);
	} else if (!INKERNEL(addr)) {
#if 0 /* needswork */
		pid = (addr % 16) + ((addr >> 4) % 16) * 10 +
		    ((addr >> 8) % 16) * 100 + ((addr >> 12) % 16) * 1000 +
		    ((addr >> 16) % 16) * 10000;
		/*
		 * The pcb for curproc is not valid at this point,
		 * so fall back to the default case.
		 */
		if ((curproc != NULL) && (pid == curproc->p_pid)) {
			frame = (struct i386_frame *)BP_REGS(&ddb_regs);
			if (frame == NULL)
				frame = (struct i386_frame *)
				    (SP_REGS(&ddb_regs) - 4);
			callpc = PC_REGS(&ddb_regs);
		} else {
			pid_t pid;
			struct proc *p;
			struct pcb *pcb;

			p = pfindn(pid);
			if (p == NULL) {
				db_printf("pid %d not found\n", pid);
				return;
			}
			if ((p->p_flags & P_SWAPPEDOUT)) {
				db_printf("pid %d swapped out\n", pid);
				return;
			}
			pcb = p->p_thread->td_pcb;
			frame = (struct i386_frame *)pcb->pcb_ebp;
			if (frame == NULL)
				frame = (struct i386_frame *)
				    (pcb->pcb_esp - 4);
			callpc = (db_addr_t)pcb->pcb_eip;
		}
#else
		/* XXX */
		db_printf("no kernel stack address\n");
		return;
#endif
	} else {
		/*
		 * Look for something that might be a frame pointer, just as
		 * a convenience.
		 */
		frame = (struct i386_frame *)addr;
		for (i = 0; i < 4096; i += 4) {
			struct i386_frame *check;

			check = (struct i386_frame *)db_get_value((int)((char *)&frame->f_frame + i), 4, FALSE);
			if ((char *)check - (char *)frame >= 0 &&
			    (char *)check - (char *)frame < 4096
			) {
				break;
			}
			db_printf("%p does not look like a stack frame, skipping\n", (char *)&frame->f_frame + i);
		}
		if (i == 4096) {
			db_printf("Unable to find anything that looks like a stack frame\n");
			return;
		}
		frame = (void *)((char *)frame + i);
		db_printf("Trace beginning at frame %p\n", frame);
		callpc = (db_addr_t)db_get_value((int)&frame->f_retaddr, 4, FALSE);
	}

	first = TRUE;
	while (count--) {
		struct i386_frame *actframe;
		int		narg;
		const char *	name;
		db_expr_t	offset;
		c_db_sym_t	sym;
#define MAXNARG	16
		char	*argnames[MAXNARG], **argnp = NULL;

		sym = db_search_symbol(callpc, DB_STGY_ANY, &offset);
		db_symbol_values(sym, &name, NULL);

		/*
		 * Attempt to determine a (possibly fake) frame that gives
		 * the caller's pc.  It may differ from `frame' if the
		 * current function never sets up a standard frame or hasn't
		 * set one up yet or has just discarded one.  The last two
		 * cases can be guessed fairly reliably for code generated
		 * by gcc.  The first case is too much trouble to handle in
		 * general because the amount of junk on the stack depends
		 * on the pc (the special handling of "calltrap", etc. in
		 * db_nextframe() works because the `next' pc is special).
		 */
		actframe = frame;
		if (first) {
			if (!have_addr) {
				int instr;

				instr = db_get_value(callpc, 4, FALSE);
				if ((instr & 0x00ffffff) == 0x00e58955) {
					/* pushl %ebp; movl %esp, %ebp */
					actframe = (struct i386_frame *)
					    (SP_REGS(&ddb_regs) - 4);
				} else if ((instr & 0x0000ffff) == 0x0000e589) {
					/* movl %esp, %ebp */
					actframe = (struct i386_frame *)
					    SP_REGS(&ddb_regs);
					if (ddb_regs.tf_ebp == 0) {
						/* Fake caller's frame better. */
						frame = actframe;
					}
				} else if ((instr & 0x000000ff) == 0x000000c3) {
					/* ret */
					actframe = (struct i386_frame *)
					    (SP_REGS(&ddb_regs) - 4);
				} else if (offset == 0) {
					/* Probably a symbol in assembler code. */
					actframe = (struct i386_frame *)
					    (SP_REGS(&ddb_regs) - 4);
				}
			} else if (name != NULL &&
				   strcmp(name, "fork_trampoline") == 0) {
				/*
				 * Don't try to walk back on a stack for a
				 * process that hasn't actually been run yet.
				 */
				db_print_stack_entry(name, 0, 0, 0, callpc);
				break;
			}
			first = FALSE;
		}

		argp = &actframe->f_arg0;
		narg = MAXNARG;
		if (sym != NULL && db_sym_numargs(sym, &narg, argnames)) {
			argnp = argnames;
		} else {
			narg = db_numargs(frame);
		}

		db_print_stack_entry(name, narg, argnp, argp, callpc);

		if (actframe != frame) {
			/* `frame' belongs to caller. */
			callpc = (db_addr_t)
			    db_get_value((int)&actframe->f_retaddr, 4, FALSE);
			continue;
		}

		db_nextframe(&frame, &callpc);

		if (INKERNEL((int) callpc) && !INKERNEL((int) frame)) {
			sym = db_search_symbol(callpc, DB_STGY_ANY, &offset);
			db_symbol_values(sym, &name, NULL);
			db_print_stack_entry(name, 0, 0, 0, callpc);
			break;
		}
		if (!INKERNEL((int) frame)) {
			break;
		}
	}
}

void
print_backtrace(int count)
{
	register_t  ebp;

	__asm __volatile("movl %%ebp, %0" : "=r" (ebp));
	db_stack_trace_cmd(ebp, 1, count, NULL);
}

#define DB_DRX_FUNC(reg)						\
int									\
db_ ## reg (struct db_variable *vp, db_expr_t *valuep, int op)		\
{									\
	if (op == DB_VAR_GET)						\
		*valuep = r ## reg ();					\
	else								\
		load_ ## reg (*valuep); 				\
									\
	return(0);							\
} 

DB_DRX_FUNC(dr0)
DB_DRX_FUNC(dr1)
DB_DRX_FUNC(dr2)
DB_DRX_FUNC(dr3)
DB_DRX_FUNC(dr4)
DB_DRX_FUNC(dr5)
DB_DRX_FUNC(dr6)
DB_DRX_FUNC(dr7)

static int
ki386_set_watch(int watchnum, unsigned int watchaddr, int size, int access,
	       struct dbreg *d)
{
	int i;
	unsigned int mask;
	
	if (watchnum == -1) {
		for (i = 0, mask = 0x3; i < 4; i++, mask <<= 2)
			if ((d->dr7 & mask) == 0)
				break;
		if (i < 4)
			watchnum = i;
		else
			return(-1);
	}
	
	switch (access) {
	case DBREG_DR7_EXEC:
		size = 1; /* size must be 1 for an execution breakpoint */
		/* fall through */
	case DBREG_DR7_WRONLY:
	case DBREG_DR7_RDWR:
		break;
	default:
		return(-1);
	}

	/*
	 * we can watch a 1, 2, or 4 byte sized location
	 */
	switch (size) {
	case 1:
		mask = 0x00;
		break;
	case 2:
		mask = 0x01 << 2;
		break;
	case 4:
		mask = 0x03 << 2;
		break;
	default:
		return(-1);
	}

	mask |= access;

	/* clear the bits we are about to affect */
	d->dr7 &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16)));

	/* set drN register to the address, N=watchnum */
	DBREG_DRX(d, watchnum) = watchaddr;

	/* enable the watchpoint */
	d->dr7 |= (0x2 << (watchnum * 2)) | (mask << (watchnum * 4 + 16));

	return(watchnum);
}


int
ki386_clr_watch(int watchnum, struct dbreg *d)
{
	if (watchnum < 0 || watchnum >= 4)
		return(-1);
	
	d->dr7 &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16)));
	DBREG_DRX(d, watchnum) = 0;
	
	return(0);
}


int
db_md_set_watchpoint(db_expr_t addr, db_expr_t size)
{
	int avail, wsize;
	int i;
	struct dbreg d;
	
	fill_dbregs(NULL, &d);
	
	avail = 0;
	for(i=0; i < 4; i++) {
		if ((d.dr7 & (3 << (i * 2))) == 0)
			avail++;
	}
	
	if (avail * 4 < size)
		return(-1);
	
	for (i=0; i < 4 && (size != 0); i++) {
		if ((d.dr7 & (3 << (i * 2))) == 0) {
			if (size > 4)
				wsize = 4;
			else
				wsize = size;
			if (wsize == 3)
				wsize++;
			ki386_set_watch(i, addr, wsize, DBREG_DR7_WRONLY, &d);
			addr += wsize;
			size -= wsize;
		}
	}

	set_dbregs(NULL, &d);

	return(0);
}

int
db_md_clr_watchpoint(db_expr_t addr, db_expr_t size)
{
	int i;
	struct dbreg d;

	fill_dbregs(NULL, &d);

	for(i=0; i<4; i++) {
		if (d.dr7 & (3 << (i * 2))) {
			if ((DBREG_DRX((&d), i) >= addr) && 
			    (DBREG_DRX((&d), i) < addr + size))
				ki386_clr_watch(i, &d);
		}
	}

	set_dbregs(NULL, &d);

	return(0);
}

static char *
watchtype_str(int type)
{
	switch (type) {
	case DBREG_DR7_EXEC:
		return "execute";
	case DBREG_DR7_RDWR:
		return "read/write";
	case DBREG_DR7_WRONLY:
		return "write";
	default:
		return "invalid";
	}
}

void
db_md_list_watchpoints(void)
{
	int i;
	struct dbreg d;

	fill_dbregs(NULL, &d);

	db_printf("\nhardware watchpoints:\n");
	db_printf("  watch    status        type  len     address\n"
		  "  -----  --------  ----------  ---  ----------\n");
	for (i=0; i < 4; i++) {
		if (d.dr7 & (0x03 << (i * 2))) {
			unsigned type, len;
			type = (d.dr7 >> (16 + (i * 4))) & 3;
			len =  (d.dr7 >> (16 + (i * 4) + 2)) & 3;
			db_printf("  %-5d  %-8s  %10s  %3d  0x%08x\n",
				  i, "enabled", watchtype_str(type), 
				  len + 1, DBREG_DRX((&d), i));
		} else {
			db_printf("  %-5d  disabled\n", i);
		}
	}

	db_printf("\ndebug register values:\n");
	for (i=0; i < 8; i++)
		db_printf("  dr%d 0x%08x\n", i, DBREG_DRX((&d),i));
	db_printf("\n");
}
Commit	Line	Data
984263bc MD	1	/*
	2	* Mach Operating System
	3	* Copyright (c) 1991,1990 Carnegie Mellon University
	4	* All Rights Reserved.
	5	*
	6	* Permission to use, copy, modify and distribute this software and its
	7	* documentation is hereby granted, provided that both the copyright
	8	* notice and this permission notice appear in all copies of the
	9	* software, derivative works or modified versions, and any portions
	10	* thereof, and that both notices appear in supporting documentation.
	11	*
	12	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
	13	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	14	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	15	*
	16	* Carnegie Mellon requests users of this software to return to
	17	*
	18	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	19	* School of Computer Science
	20	* Carnegie Mellon University
	21	* Pittsburgh PA 15213-3890
	22	*
	23	* any improvements or extensions that they make and grant Carnegie the
	24	* rights to redistribute these changes.
	25	*
	26	* $FreeBSD: src/sys/i386/i386/db_trace.c,v 1.35.2.3 2002/02/21 22:31:25 silby Exp $
	27	*/
	28
	29	#include <sys/param.h>
	30	#include <sys/systm.h>
	31	#include <sys/linker_set.h>
	32	#include <sys/lock.h>
	33	#include <sys/proc.h>
527fddf7	34	#include <sys/reg.h>
984263bc MD	35
	36	#include <machine/cpu.h>
	37	#include <machine/md_var.h>
984263bc MD	38
	39	#include <vm/vm.h>
	40	#include <vm/vm_param.h>
	41	#include <vm/pmap.h>
	42	#include <vm/vm_map.h>
	43	#include <ddb/ddb.h>
	44
	45	#include <sys/user.h>
	46
	47	#include <ddb/db_access.h>
	48	#include <ddb/db_sym.h>
	49	#include <ddb/db_variables.h>
	50
	51	db_varfcn_t db_dr0;
	52	db_varfcn_t db_dr1;
	53	db_varfcn_t db_dr2;
	54	db_varfcn_t db_dr3;
	55	db_varfcn_t db_dr4;
	56	db_varfcn_t db_dr5;
	57	db_varfcn_t db_dr6;
	58	db_varfcn_t db_dr7;
	59
	60	/*
	61	* Machine register set.
	62	*/
	63	struct db_variable db_regs[] = {
60233e58 SW	64	{ "cs", &ddb_regs.tf_cs, NULL },
	65	{ "ds", &ddb_regs.tf_ds, NULL },
	66	{ "es", &ddb_regs.tf_es, NULL },
	67	{ "fs", &ddb_regs.tf_fs, NULL },
	68	{ "gs", &ddb_regs.tf_gs, NULL },
	69	{ "ss", &ddb_regs.tf_ss, NULL },
	70	{ "eax", &ddb_regs.tf_eax, NULL },
	71	{ "ecx", &ddb_regs.tf_ecx, NULL },
	72	{ "edx", &ddb_regs.tf_edx, NULL },
	73	{ "ebx", &ddb_regs.tf_ebx, NULL },
	74	{ "esp", &ddb_regs.tf_esp, NULL },
	75	{ "ebp", &ddb_regs.tf_ebp, NULL },
	76	{ "esi", &ddb_regs.tf_esi, NULL },
	77	{ "edi", &ddb_regs.tf_edi, NULL },
	78	{ "eip", &ddb_regs.tf_eip, NULL },
	79	{ "efl", &ddb_regs.tf_eflags, NULL },
984263bc MD	80	{ "dr0", NULL, db_dr0 },
	81	{ "dr1", NULL, db_dr1 },
	82	{ "dr2", NULL, db_dr2 },
	83	{ "dr3", NULL, db_dr3 },
	84	{ "dr4", NULL, db_dr4 },
	85	{ "dr5", NULL, db_dr5 },
	86	{ "dr6", NULL, db_dr6 },
	87	{ "dr7", NULL, db_dr7 },
	88	};
c157ff7a	89	struct db_variable *db_eregs = db_regs + NELEM(db_regs);
984263bc MD	90
	91	/*
	92	* Stack trace.
	93	*/
	94	#define INKERNEL(va) (((vm_offset_t)(va)) >= USRSTACK)
	95
	96	struct i386_frame {
	97	struct i386_frame *f_frame;
	98	int f_retaddr;
	99	int f_arg0;
	100	};
	101
	102	#define NORMAL 0
	103	#define TRAP 1
	104	#define INTERRUPT 2
	105	#define SYSCALL 3
	106
30ef6427 JS	107	static void db_nextframe(struct i386_frame *, db_addr_t );
	108	static int db_numargs(struct i386_frame *);
	109	static void db_print_stack_entry(const char , int, char , int , db_addr_t);
984263bc MD	110
984263bc MD	111
30ef6427	112	static char *watchtype_str(int type);
73f913ca	113	static int ki386_set_watch(int watchnum, unsigned int watchaddr,
30ef6427	114	int size, int access, struct dbreg * d);
73f913ca	115	static int ki386_clr_watch(int watchnum, struct dbreg * d);
30ef6427 JS	116	int db_md_set_watchpoint(db_expr_t addr, db_expr_t size);
	117	int db_md_clr_watchpoint(db_expr_t addr, db_expr_t size);
	118	void db_md_list_watchpoints(void);
984263bc MD	119
	120
	121	/*
	122	* Figure out how many arguments were passed into the frame at "fp".
	123	*/
	124	static int
30ef6427	125	db_numargs(struct i386_frame *fp)
984263bc MD	126	{
	127	int *argp;
	128	int inst;
	129	int args;
	130
	131	argp = (int *)db_get_value((int)&fp->f_retaddr, 4, FALSE);
	132	/*
	133	* XXX etext is wrong for LKMs. We should attempt to interpret
	134	* the instruction at the return address in all cases. This
	135	* may require better fault handling.
	136	*/
	137	if (argp < (int )btext \|\| argp >= (int )etext) {
	138	args = 5;
	139	} else {
	140	inst = db_get_value((int)argp, 4, FALSE);
	141	if ((inst & 0xff) == 0x59) /* popl %ecx */
	142	args = 1;
	143	else if ((inst & 0xffff) == 0xc483) /* addl $Ibs, %esp */
	144	args = ((inst >> 16) & 0xff) / 4;
	145	else
	146	args = 5;
	147	}
30ef6427	148	return(args);
984263bc MD	149	}
	150
	151	static void
30ef6427 JS	152	db_print_stack_entry(const char name, int narg, char argnp, int argp,
30ef6427 JS	153	db_addr_t callpc)
984263bc MD	154	{
	155	db_printf("%s(", name);
	156	while (narg) {
	157	if (argnp)
	158	db_printf("%s=", *argnp++);
	159	db_printf("%r", db_get_value((int)argp, 4, FALSE));
	160	argp++;
	161	if (--narg != 0)
	162	db_printf(",");
	163	}
	164	db_printf(") at ");
	165	db_printsym(callpc, DB_STGY_PROC);
ebd07f54	166	db_printf(" %p ", (void*) callpc);
984263bc MD	167	db_printf("\n");
	168	}
	169
	170	/*
	171	* Figure out the next frame up in the call stack.
	172	*/
	173	static void
ff803bd8	174	db_nextframe(struct i386_frame *fp, db_addr_t ip)
984263bc MD	175	{
	176	struct trapframe *tf;
	177	int frame_type;
	178	int eip, esp, ebp;
	179	db_expr_t offset;
	180	const char sym, name;
	181
	182	eip = db_get_value((int) &(*fp)->f_retaddr, 4, FALSE);
	183	ebp = db_get_value((int) &(*fp)->f_frame, 4, FALSE);
	184
	185	/*
	186	* Figure out frame type.
	187	*/
	188
	189	frame_type = NORMAL;
	190
	191	sym = db_search_symbol(eip, DB_STGY_ANY, &offset);
	192	db_symbol_values(sym, &name, NULL);
	193	if (name != NULL) {
	194	if (!strcmp(name, "calltrap")) {
	195	frame_type = TRAP;
	196	} else if (!strncmp(name, "Xresume", 7)) {
	197	frame_type = INTERRUPT;
	198	} else if (!strcmp(name, "_Xsyscall")) {
	199	frame_type = SYSCALL;
	200	}
	201	}
	202
	203	/*
	204	* Normal frames need no special processing.
	205	*/
	206	if (frame_type == NORMAL) {
	207	*ip = (db_addr_t) eip;
	208	fp = (struct i386_frame ) ebp;
	209	return;
	210	}
	211
	212	db_print_stack_entry(name, 0, 0, 0, eip);
	213
	214	/*
	215	* Point to base of trapframe which is just above the
	216	* current frame.
	217	*/
	218	tf = (struct trapframe ) ((int)fp + 8);
	219
	220	esp = (ISPL(tf->tf_cs) == SEL_UPL) ? tf->tf_esp : (int)&tf->tf_esp;
	221	switch (frame_type) {
	222	case TRAP:
	223	if (INKERNEL((int) tf)) {
	224	eip = tf->tf_eip;
	225	ebp = tf->tf_ebp;
	226	db_printf(
	227	"--- trap %#r, eip = %#r, esp = %#r, ebp = %#r ---\n",
	228	tf->tf_trapno, eip, esp, ebp);
	229	}
	230	break;
	231	case SYSCALL:
	232	if (INKERNEL((int) tf)) {
	233	eip = tf->tf_eip;
	234	ebp = tf->tf_ebp;
	235	db_printf(
	236	"--- syscall %#r, eip = %#r, esp = %#r, ebp = %#r ---\n",
	237	tf->tf_eax, eip, esp, ebp);
	238	}
239	break;
240	case INTERRUPT:
241	tf = (struct trapframe )((int)fp + 16);
242	if (INKERNEL((int) tf)) {
243	eip = tf->tf_eip;
244	ebp = tf->tf_ebp;
245	db_printf(
246	"--- interrupt, eip = %#r, esp = %#r, ebp = %#r ---\n",
247	eip, esp, ebp);
248	}
249	break;
250	default:
251	break;
252	}
253
254	*ip = (db_addr_t) eip;
255	fp = (struct i386_frame ) ebp;
256	}
257
258	void
30ef6427 JS	259	db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
30ef6427 JS	260	char *modif)
984263bc MD	261	{
	262	struct i386_frame *frame;
	263	int *argp;
	264	db_addr_t callpc;
	265	boolean_t first;
8ec5e934	266	int i;
984263bc MD	267
	268	if (count == -1)
	269	count = 1024;
	270
	271	if (!have_addr) {
55a2e6d4	272	frame = (struct i386_frame *)BP_REGS(&ddb_regs);
984263bc	273	if (frame == NULL)
55a2e6d4 MD	274	frame = (struct i386_frame *)(SP_REGS(&ddb_regs) - 4);
55a2e6d4 MD	275	callpc = PC_REGS(&ddb_regs);
984263bc	276	} else if (!INKERNEL(addr)) {
122df98f	277	#if 0 /* needswork */
984263bc MD	278	pid = (addr % 16) + ((addr >> 4) % 16) * 10 +
	279	((addr >> 8) % 16) * 100 + ((addr >> 12) % 16) * 1000 +
	280	((addr >> 16) % 16) * 10000;
	281	/*
	282	* The pcb for curproc is not valid at this point,
	283	* so fall back to the default case.
	284	*/
	285	if ((curproc != NULL) && (pid == curproc->p_pid)) {
55a2e6d4	286	frame = (struct i386_frame *)BP_REGS(&ddb_regs);
984263bc MD	287	if (frame == NULL)
984263bc MD	288	frame = (struct i386_frame *)
55a2e6d4 MD	289	(SP_REGS(&ddb_regs) - 4);
55a2e6d4 MD	290	callpc = PC_REGS(&ddb_regs);
984263bc	291	} else {
bb3cd951 SS	292	pid_t pid;
	293	struct proc *p;
	294	struct pcb *pcb;
	295
58c2553a	296	p = pfindn(pid);
984263bc MD	297	if (p == NULL) {
	298	db_printf("pid %d not found\n", pid);
	299	return;
	300	}
4643740a	301	if ((p->p_flags & P_SWAPPEDOUT)) {
984263bc MD	302	db_printf("pid %d swapped out\n", pid);
	303	return;
	304	}
b7c628e4	305	pcb = p->p_thread->td_pcb;
984263bc MD	306	frame = (struct i386_frame *)pcb->pcb_ebp;
	307	if (frame == NULL)
	308	frame = (struct i386_frame *)
	309	(pcb->pcb_esp - 4);
	310	callpc = (db_addr_t)pcb->pcb_eip;
	311	}
bb3cd951 SS	312	#else
	313	/* XXX */
	314	db_printf("no kernel stack address\n");
	315	return;
	316	#endif
984263bc	317	} else {
8ec5e934 MD	318	/*
	319	* Look for something that might be a frame pointer, just as
	320	* a convenience.
	321	*/
984263bc	322	frame = (struct i386_frame *)addr;
8ec5e934 MD	323	for (i = 0; i < 4096; i += 4) {
	324	struct i386_frame *check;
	325
	326	check = (struct i386_frame )db_get_value((int)((char )&frame->f_frame + i), 4, FALSE);
	327	if ((char )check - (char )frame >= 0 &&
	328	(char )check - (char )frame < 4096
	329	) {
	330	break;
	331	}
	332	db_printf("%p does not look like a stack frame, skipping\n", (char *)&frame->f_frame + i);
	333	}
	334	if (i == 4096) {
	335	db_printf("Unable to find anything that looks like a stack frame\n");
	336	return;
	337	}
	338	frame = (void )((char )frame + i);
	339	db_printf("Trace beginning at frame %p\n", frame);
984263bc MD	340	callpc = (db_addr_t)db_get_value((int)&frame->f_retaddr, 4, FALSE);
	341	}
	342
	343	first = TRUE;
	344	while (count--) {
	345	struct i386_frame *actframe;
	346	int narg;
	347	const char * name;
	348	db_expr_t offset;
	349	c_db_sym_t sym;
	350	#define MAXNARG 16
	351	char argnames[MAXNARG], *argnp = NULL;
	352
	353	sym = db_search_symbol(callpc, DB_STGY_ANY, &offset);
	354	db_symbol_values(sym, &name, NULL);
	355
	356	/*
	357	* Attempt to determine a (possibly fake) frame that gives
	358	* the caller's pc. It may differ from `frame' if the
	359	* current function never sets up a standard frame or hasn't
	360	* set one up yet or has just discarded one. The last two
	361	* cases can be guessed fairly reliably for code generated
	362	* by gcc. The first case is too much trouble to handle in
	363	* general because the amount of junk on the stack depends
	364	* on the pc (the special handling of "calltrap", etc. in
	365	* db_nextframe() works because the `next' pc is special).
	366	*/
	367	actframe = frame;
	368	if (first) {
	369	if (!have_addr) {
	370	int instr;
	371
	372	instr = db_get_value(callpc, 4, FALSE);
	373	if ((instr & 0x00ffffff) == 0x00e58955) {
	374	/* pushl %ebp; movl %esp, %ebp */
	375	actframe = (struct i386_frame *)
55a2e6d4	376	(SP_REGS(&ddb_regs) - 4);
984263bc MD	377	} else if ((instr & 0x0000ffff) == 0x0000e589) {
	378	/* movl %esp, %ebp */
	379	actframe = (struct i386_frame *)
55a2e6d4	380	SP_REGS(&ddb_regs);
984263bc MD	381	if (ddb_regs.tf_ebp == 0) {
	382	/* Fake caller's frame better. */
	383	frame = actframe;
	384	}
	385	} else if ((instr & 0x000000ff) == 0x000000c3) {
	386	/* ret */
	387	actframe = (struct i386_frame *)
55a2e6d4	388	(SP_REGS(&ddb_regs) - 4);
984263bc MD	389	} else if (offset == 0) {
	390	/* Probably a symbol in assembler code. */
	391	actframe = (struct i386_frame *)
55a2e6d4	392	(SP_REGS(&ddb_regs) - 4);
984263bc	393	}
27735f7d SS	394	} else if (name != NULL &&
27735f7d SS	395	strcmp(name, "fork_trampoline") == 0) {
984263bc MD	396	/*
	397	* Don't try to walk back on a stack for a
	398	* process that hasn't actually been run yet.
	399	*/
	400	db_print_stack_entry(name, 0, 0, 0, callpc);
	401	break;
	402	}
	403	first = FALSE;
	404	}
	405
	406	argp = &actframe->f_arg0;
	407	narg = MAXNARG;
	408	if (sym != NULL && db_sym_numargs(sym, &narg, argnames)) {
	409	argnp = argnames;
	410	} else {
	411	narg = db_numargs(frame);
	412	}
	413
	414	db_print_stack_entry(name, narg, argnp, argp, callpc);
	415
	416	if (actframe != frame) {
	417	/* `frame' belongs to caller. */
	418	callpc = (db_addr_t)
	419	db_get_value((int)&actframe->f_retaddr, 4, FALSE);
	420	continue;
	421	}
	422
	423	db_nextframe(&frame, &callpc);
	424
	425	if (INKERNEL((int) callpc) && !INKERNEL((int) frame)) {
	426	sym = db_search_symbol(callpc, DB_STGY_ANY, &offset);
	427	db_symbol_values(sym, &name, NULL);
	428	db_print_stack_entry(name, 0, 0, 0, callpc);
	429	break;
	430	}
	431	if (!INKERNEL((int) frame)) {
	432	break;
	433	}
	434	}
	435	}
	436
6bd9bbba	437	void
7ce2998e	438	print_backtrace(int count)
6bd9bbba	439	{
30ef6427	440	register_t ebp;
6bd9bbba	441
30ef6427	442	__asm __volatile("movl %%ebp, %0" : "=r" (ebp));
7ce2998e	443	db_stack_trace_cmd(ebp, 1, count, NULL);
6bd9bbba HP	444	}
6bd9bbba HP	445
30ef6427 JS	446	#define DB_DRX_FUNC(reg) \
	447	int \
	448	db_ ## reg (struct db_variable vp, db_expr_t valuep, int op) \
	449	{ \
	450	if (op == DB_VAR_GET) \
	451	*valuep = r ## reg (); \
	452	else \
	453	load_ ## reg (*valuep); \
	454	\
	455	return(0); \
984263bc MD	456	}
	457
	458	DB_DRX_FUNC(dr0)
	459	DB_DRX_FUNC(dr1)
	460	DB_DRX_FUNC(dr2)
	461	DB_DRX_FUNC(dr3)
	462	DB_DRX_FUNC(dr4)
	463	DB_DRX_FUNC(dr5)
	464	DB_DRX_FUNC(dr6)
	465	DB_DRX_FUNC(dr7)
	466
73f913ca MD	467	static int
73f913ca MD	468	ki386_set_watch(int watchnum, unsigned int watchaddr, int size, int access,
30ef6427	469	struct dbreg *d)
984263bc MD	470	{
	471	int i;
	472	unsigned int mask;
	473
	474	if (watchnum == -1) {
	475	for (i = 0, mask = 0x3; i < 4; i++, mask <<= 2)
	476	if ((d->dr7 & mask) == 0)
	477	break;
	478	if (i < 4)
	479	watchnum = i;
	480	else
30ef6427	481	return(-1);
984263bc MD	482	}
	483
	484	switch (access) {
	485	case DBREG_DR7_EXEC:
	486	size = 1; /* size must be 1 for an execution breakpoint */
	487	/* fall through */
	488	case DBREG_DR7_WRONLY:
	489	case DBREG_DR7_RDWR:
	490	break;
30ef6427 JS	491	default:
30ef6427 JS	492	return(-1);
984263bc	493	}
30ef6427	494
984263bc MD	495	/*
	496	* we can watch a 1, 2, or 4 byte sized location
	497	*/
	498	switch (size) {
30ef6427 JS	499	case 1:
	500	mask = 0x00;
	501	break;
	502	case 2:
	503	mask = 0x01 << 2;
	504	break;
	505	case 4:
	506	mask = 0x03 << 2;
	507	break;
	508	default:
	509	return(-1);
984263bc MD	510	}
	511
	512	mask \|= access;
	513
	514	/* clear the bits we are about to affect */
30ef6427	515	d->dr7 &= ~((0x3 << (watchnum * 2)) \| (0x0f << (watchnum * 4 + 16)));
984263bc MD	516
984263bc MD	517	/* set drN register to the address, N=watchnum */
30ef6427	518	DBREG_DRX(d, watchnum) = watchaddr;
984263bc MD	519
984263bc MD	520	/* enable the watchpoint */
30ef6427	521	d->dr7 \|= (0x2 << (watchnum * 2)) \| (mask << (watchnum * 4 + 16));
984263bc	522
30ef6427	523	return(watchnum);
984263bc MD	524	}
	525
	526
	527	int
73f913ca	528	ki386_clr_watch(int watchnum, struct dbreg *d)
984263bc	529	{
984263bc	530	if (watchnum < 0 \|\| watchnum >= 4)
30ef6427	531	return(-1);
984263bc	532
30ef6427 JS	533	d->dr7 &= ~((0x3 << (watchnum * 2)) \| (0x0f << (watchnum * 4 + 16)));
30ef6427 JS	534	DBREG_DRX(d, watchnum) = 0;
984263bc	535
30ef6427	536	return(0);
984263bc MD	537	}
	538
	539
	540	int
30ef6427	541	db_md_set_watchpoint(db_expr_t addr, db_expr_t size)
984263bc MD	542	{
	543	int avail, wsize;
	544	int i;
	545	struct dbreg d;
	546
	547	fill_dbregs(NULL, &d);
	548
	549	avail = 0;
30ef6427 JS	550	for(i=0; i < 4; i++) {
30ef6427 JS	551	if ((d.dr7 & (3 << (i * 2))) == 0)
984263bc MD	552	avail++;
	553	}
	554
30ef6427 JS	555	if (avail * 4 < size)
30ef6427 JS	556	return(-1);
984263bc	557
30ef6427 JS	558	for (i=0; i < 4 && (size != 0); i++) {
30ef6427 JS	559	if ((d.dr7 & (3 << (i * 2))) == 0) {
984263bc MD	560	if (size > 4)
	561	wsize = 4;
	562	else
	563	wsize = size;
	564	if (wsize == 3)
	565	wsize++;
73f913ca	566	ki386_set_watch(i, addr, wsize, DBREG_DR7_WRONLY, &d);
984263bc MD	567	addr += wsize;
	568	size -= wsize;
	569	}
	570	}
30ef6427	571
984263bc	572	set_dbregs(NULL, &d);
30ef6427	573
984263bc MD	574	return(0);
	575	}
	576
984263bc	577	int
30ef6427	578	db_md_clr_watchpoint(db_expr_t addr, db_expr_t size)
984263bc MD	579	{
	580	int i;
	581	struct dbreg d;
	582
	583	fill_dbregs(NULL, &d);
	584
	585	for(i=0; i<4; i++) {
30ef6427	586	if (d.dr7 & (3 << (i * 2))) {
984263bc	587	if ((DBREG_DRX((&d), i) >= addr) &&
30ef6427	588	(DBREG_DRX((&d), i) < addr + size))
73f913ca	589	ki386_clr_watch(i, &d);
984263bc MD	590	}
984263bc MD	591	}
30ef6427	592
984263bc	593	set_dbregs(NULL, &d);
30ef6427	594
984263bc MD	595	return(0);
	596	}
	597
30ef6427 JS	598	static char *
30ef6427 JS	599	watchtype_str(int type)
984263bc MD	600	{
984263bc MD	601	switch (type) {
30ef6427 JS	602	case DBREG_DR7_EXEC:
	603	return "execute";
	604	case DBREG_DR7_RDWR:
	605	return "read/write";
	606	case DBREG_DR7_WRONLY:
	607	return "write";
	608	default:
	609	return "invalid";
984263bc MD	610	}
	611	}
	612
984263bc	613	void
30ef6427	614	db_md_list_watchpoints(void)
984263bc MD	615	{
	616	int i;
	617	struct dbreg d;
	618
	619	fill_dbregs(NULL, &d);
	620
	621	db_printf("\nhardware watchpoints:\n");
	622	db_printf(" watch status type len address\n"
	623	" ----- -------- ---------- --- ----------\n");
30ef6427 JS	624	for (i=0; i < 4; i++) {
30ef6427 JS	625	if (d.dr7 & (0x03 << (i * 2))) {
984263bc	626	unsigned type, len;
30ef6427 JS	627	type = (d.dr7 >> (16 + (i * 4))) & 3;
30ef6427 JS	628	len = (d.dr7 >> (16 + (i * 4) + 2)) & 3;
984263bc MD	629	db_printf(" %-5d %-8s %10s %3d 0x%08x\n",
984263bc MD	630	i, "enabled", watchtype_str(type),
30ef6427 JS	631	len + 1, DBREG_DRX((&d), i));
30ef6427 JS	632	} else {
984263bc MD	633	db_printf(" %-5d disabled\n", i);
	634	}
	635	}
30ef6427	636
984263bc	637	db_printf("\ndebug register values:\n");
30ef6427	638	for (i=0; i < 8; i++)
984263bc	639	db_printf(" dr%d 0x%08x\n", i, DBREG_DRX((&d),i));
984263bc MD	640	db_printf("\n");
984263bc MD	641	}