Home | History | Annotate | Line # | Download | only in mips
db_trace.c revision 1.23
      1 /*	$NetBSD: db_trace.c,v 1.23 2003/01/17 23:36:11 thorpej Exp $	*/
      2 
      3 /*
      4  * Mach Operating System
      5  * Copyright (c) 1993-1987 Carnegie Mellon University
      6  * All Rights Reserved.
      7  *
      8  * Permission to use, copy, modify and distribute this software and its
      9  * documentation is hereby granted, provided that both the copyright
     10  * notice and this permission notice appear in all copies of the
     11  * software, derivative works or modified versions, and any portions
     12  * thereof, and that both notices appear in supporting documentation.
     13  *
     14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
     15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
     16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     17  *
     18  * Carnegie Mellon requests users of this software to return to
     19  *
     20  *  Software Distribution Coordinator  or  Software.Distribution (at) CS.CMU.EDU
     21  *  School of Computer Science
     22  *  Carnegie Mellon University
     23  *  Pittsburgh PA 15213-3890
     24  *
     25  * any improvements or extensions that they make and grant Carnegie Mellon
     26  * the rights to redistribute these changes.
     27  */
     28 
     29 #include <sys/types.h>
     30 #include <sys/param.h>
     31 #include <sys/systm.h>
     32 #include <sys/proc.h>
     33 #include <sys/user.h>
     34 
     35 #include <mips/mips_opcode.h>
     36 
     37 #include <machine/param.h>
     38 #include <machine/db_machdep.h>
     39 #include <ddb/db_interface.h>
     40 #include <ddb/db_output.h>
     41 #include <ddb/db_variables.h>
     42 #include <ddb/db_sym.h>
     43 
     44 int __start(void);	/* lowest kernel code address */
     45 vaddr_t getreg_val(db_expr_t regno);
     46 
     47 #define REG_ARG(i)	(4+i)
     48 #define SAVES_RA(x)	isa_spill((x),31)
     49 
     50 #define KERN_SAVE_REG_IDX(vp)	( \
     51 	((vp)->valuep >= (int *)(&((struct mips_saved_state *)0)->s0) &&    \
     52 	 (vp)->valuep <= (int *)(&((struct mips_saved_state *)0)->s7))?	    \
     53 		vp->valuep - (int *)(&((struct mips_saved_state *)0)->s0):  \
     54 	((vp)->valuep >= (int *)(&((struct mips_saved_state *)0)->sp) &&    \
     55 	 (vp)->valuep <= (int *)(&((struct mips_saved_state *)0)->ra))?	    \
     56 		((vp)->valuep-(int *)(&((struct mips_saved_state *)0)->sp)) + \
     57 		 ((int *)(&((struct mips_kernel_state *)0)->sp) - (int *)0):  \
     58 	 -1)
     59 
     60 db_sym_t localsym(db_sym_t sym, boolean_t isreg, int *lex_level);
     61 
     62 /*
     63  * Machine register set.
     64  */
     65 struct mips_saved_state *db_cur_exc_frame = 0;
     66 
     67 /*XXX*/
     68 void	stacktrace_subr(int, int, int, int, u_int, u_int, u_int, u_int,
     69 	    void (*)(const char*, ...));
     70 
     71 /*
     72  * Stack trace helper.
     73  */
     74 void db_mips_stack_trace(int, vaddr_t, vaddr_t, vaddr_t, int, vaddr_t);
     75 int db_mips_variable_func(const struct db_variable *, db_expr_t *, int);
     76 
     77 #define DB_SETF_REGS db_mips_variable_func
     78 #define DBREGS_REG()
     79 
     80 const struct db_variable db_regs[] = {
     81 	{ "at",	(long *)&ddb_regs.f_regs[AST],  DB_SETF_REGS },
     82 	{ "v0",	(long *)&ddb_regs.f_regs[V0],  DB_SETF_REGS },
     83 	{ "v1",	(long *)&ddb_regs.f_regs[V1],  DB_SETF_REGS },
     84 	{ "a0",	(long *)&ddb_regs.f_regs[A0],  DB_SETF_REGS },
     85 	{ "a1",	(long *)&ddb_regs.f_regs[A1],  DB_SETF_REGS },
     86 	{ "a2",	(long *)&ddb_regs.f_regs[A2],  DB_SETF_REGS },
     87 	{ "a3",	(long *)&ddb_regs.f_regs[A3],  DB_SETF_REGS },
     88 #if defined(__mips_n32) || defined(__mips_n64)
     89 	{ "a4",	(long *)&ddb_regs.f_regs[A4],  DB_SETF_REGS },
     90 	{ "a5",	(long *)&ddb_regs.f_regs[A5],  DB_SETF_REGS },
     91 	{ "a6",	(long *)&ddb_regs.f_regs[A6],  DB_SETF_REGS },
     92 	{ "a7",	(long *)&ddb_regs.f_regs[A7],  DB_SETF_REGS },
     93 	{ "t0",	(long *)&ddb_regs.f_regs[T0],  DB_SETF_REGS },
     94 	{ "t1",	(long *)&ddb_regs.f_regs[T1],  DB_SETF_REGS },
     95 	{ "t2",	(long *)&ddb_regs.f_regs[T2],  DB_SETF_REGS },
     96 	{ "t3",	(long *)&ddb_regs.f_regs[T3],  DB_SETF_REGS },
     97 #else
     98 	{ "t0",	(long *)&ddb_regs.f_regs[T0],  DB_SETF_REGS },
     99 	{ "t1",	(long *)&ddb_regs.f_regs[T1],  DB_SETF_REGS },
    100 	{ "t2",	(long *)&ddb_regs.f_regs[T2],  DB_SETF_REGS },
    101 	{ "t3",	(long *)&ddb_regs.f_regs[T3],  DB_SETF_REGS },
    102 	{ "t4",	(long *)&ddb_regs.f_regs[T4],  DB_SETF_REGS },
    103 	{ "t5",	(long *)&ddb_regs.f_regs[T5],  DB_SETF_REGS },
    104 	{ "t6",	(long *)&ddb_regs.f_regs[T6],  DB_SETF_REGS },
    105 	{ "t7",	(long *)&ddb_regs.f_regs[T7],  DB_SETF_REGS },
    106 #endif /* __mips_n32 || __mips_n64 */
    107 	{ "s0",	(long *)&ddb_regs.f_regs[S0],  DB_SETF_REGS },
    108 	{ "s1",	(long *)&ddb_regs.f_regs[S1],  DB_SETF_REGS },
    109 	{ "s2",	(long *)&ddb_regs.f_regs[S2],  DB_SETF_REGS },
    110 	{ "s3",	(long *)&ddb_regs.f_regs[S3],  DB_SETF_REGS },
    111 	{ "s4",	(long *)&ddb_regs.f_regs[S4],  DB_SETF_REGS },
    112 	{ "s5",	(long *)&ddb_regs.f_regs[S5],  DB_SETF_REGS },
    113 	{ "s6",	(long *)&ddb_regs.f_regs[S6],  DB_SETF_REGS },
    114 	{ "s7",	(long *)&ddb_regs.f_regs[S7],  DB_SETF_REGS },
    115 	{ "t8",	(long *)&ddb_regs.f_regs[T8],  DB_SETF_REGS },
    116 	{ "t9",	(long *)&ddb_regs.f_regs[T9],  DB_SETF_REGS },
    117 	{ "k0",	(long *)&ddb_regs.f_regs[K0],  DB_SETF_REGS },
    118 	{ "k1",	(long *)&ddb_regs.f_regs[K1],  DB_SETF_REGS },
    119 	{ "gp",	(long *)&ddb_regs.f_regs[GP],  DB_SETF_REGS },
    120 	{ "sp",	(long *)&ddb_regs.f_regs[SP],  DB_SETF_REGS },
    121 	{ "fp",	(long *)&ddb_regs.f_regs[S8],  DB_SETF_REGS },	/* frame ptr */
    122 	{ "ra",	(long *)&ddb_regs.f_regs[RA],  DB_SETF_REGS },
    123 	{ "sr",	(long *)&ddb_regs.f_regs[SR],  DB_SETF_REGS },
    124 	{ "mdlo",(long *)&ddb_regs.f_regs[MULLO],  DB_SETF_REGS },
    125 	{ "mdhi",(long *)&ddb_regs.f_regs[MULHI],  DB_SETF_REGS },
    126 	{ "bad", (long *)&ddb_regs.f_regs[BADVADDR], DB_SETF_REGS },
    127 	{ "cs",	(long *)&ddb_regs.f_regs[CAUSE],  DB_SETF_REGS },
    128 	{ "pc",	(long *)&ddb_regs.f_regs[PC],  DB_SETF_REGS },
    129 };
    130 const struct db_variable * const db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]);
    131 
    132 void
    133 db_stack_trace_print(db_expr_t addr, boolean_t have_addr, db_expr_t count,
    134     char *modif, void (*pr)(const char *, ...))
    135 {
    136 #ifndef DDB_TRACE
    137 	struct pcb *pcb;
    138 	struct proc *p;
    139 	struct lwp *l;
    140 
    141 	if (!have_addr) {
    142 		stacktrace_subr(ddb_regs.f_regs[A0], ddb_regs.f_regs[A1],
    143 				ddb_regs.f_regs[A2], ddb_regs.f_regs[A3],
    144 				ddb_regs.f_regs[PC],
    145 				ddb_regs.f_regs[SP],
    146 				/* non-virtual frame pointer */
    147 				ddb_regs.f_regs[S8],
    148 				ddb_regs.f_regs[RA],
    149 				pr);
    150 		return;
    151 	}
    152 
    153 	/* "trace/t" */
    154 	(*pr)("pid %d ", (int)addr);
    155 	p = pfind(addr);
    156 	if (p == NULL) {
    157 		(*pr)("not found\n");
    158 		return;
    159 	}
    160 	l = LIST_FIRST(&p->p_lwps); /* XXX NJWLWP */
    161 	if (!(l->l_flag & L_INMEM)) {
    162 		(*pr)("swapped out\n");
    163 		return;
    164 	}
    165 
    166 	pcb = &(l->l_addr->u_pcb);
    167 	(*pr)("at %p\n", pcb);
    168 
    169 	stacktrace_subr(0,0,0,0,	/* no args known */
    170 			(int)cpu_switch,
    171 			pcb->pcb_context[8],
    172 			pcb->pcb_context[9],
    173 			pcb->pcb_context[10],
    174 			pr);
    175 #else
    176 /*
    177  * Incomplete but practically useful stack backtrace.
    178  */
    179 #define	MIPS_JR_RA	0x03e00008	/* instruction code for jr ra */
    180 #define	MIPS_JR_K0	0x03400008	/* instruction code for jr k0 */
    181 #define	MIPS_ERET	0x42000018	/* instruction code for eret */
    182 	unsigned va, pc, ra, sp, func;
    183 	int insn;
    184 	InstFmt i;
    185 	int stacksize;
    186 	db_addr_t offset;
    187 	char *name;
    188 	extern char verylocore[];
    189 
    190 	pc = ddb_regs.f_regs[PC];
    191 	sp = ddb_regs.f_regs[SP];
    192 	ra = ddb_regs.f_regs[RA];
    193 	do {
    194 		va = pc;
    195 		do {
    196 			va -= sizeof(int);
    197 			insn = *(int *)va;
    198 			if (insn == MIPS_ERET)
    199 				goto mips3_eret;
    200 		} while (insn != MIPS_JR_RA && insn != MIPS_JR_K0);
    201 		va += sizeof(int);
    202 	mips3_eret:
    203 		va += sizeof(int);
    204 		while (*(int *)va == 0x00000000)
    205 			va += sizeof(int);
    206 		func = va;
    207 		stacksize = 0;
    208 		do {
    209 			i.word = *(int *)va;
    210 			if (i.IType.op == OP_SW
    211 			    && i.IType.rs == SP
    212 			    && i.IType.rt == RA)
    213 				ra = *(int *)(sp + (short)i.IType.imm);
    214 			if (i.IType.op == OP_ADDIU
    215 			    && i.IType.rs == SP
    216 			    && i.IType.rt == SP)
    217 				stacksize = -(short)i.IType.imm;
    218 			va += sizeof(int);
    219 		} while (va < pc);
    220 
    221 		db_find_sym_and_offset(func, &name, &offset);
    222 		if (name == 0)
    223 			name = "?";
    224 		(*pr)("%s()+0x%x, called by %p, stack size %d\n",
    225 			name, pc - func, (void *)ra, stacksize);
    226 
    227 		if (ra == pc) {
    228 			(*pr)("-- loop? --\n");
    229 			return;
    230 		}
    231 		sp += stacksize;
    232 		pc = ra;
    233 	} while (pc > (unsigned)verylocore);
    234 	if (pc < 0x80000000)
    235 		(*pr)("-- user process --\n");
    236 	else
    237 		(*pr)("-- kernel entry --\n");
    238 #endif
    239 }
    240 
    241 void
    242 db_mips_stack_trace(int count, vaddr_t stackp, vaddr_t the_pc, vaddr_t the_ra,
    243     int flags, vaddr_t kstackp)
    244 {
    245 
    246 	/* nothing... */
    247 }
    248 
    249 
    250 int
    251 db_mips_variable_func (const struct db_variable *vp, db_expr_t *valuep,
    252     int db_var_fcn)
    253 {
    254 
    255 	switch (db_var_fcn) {
    256 	case DB_VAR_GET:
    257 		*valuep = *(mips_reg_t *) vp->valuep;
    258 		break;
    259 	case DB_VAR_SET:
    260 		*(mips_reg_t *) vp->valuep = *valuep;
    261 		break;
    262 	}
    263 	return 0;
    264 }
    265