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