xref: /freebsd/sys/powerpc/powerpc/db_trace.c (revision 39beb93c)
1 /*	$FreeBSD$ */
2 /*	$NetBSD: db_trace.c,v 1.20 2002/05/13 20:30:09 matt Exp $	*/
3 /*	$OpenBSD: db_trace.c,v 1.3 1997/03/21 02:10:48 niklas Exp $	*/
4 
5 /*-
6  * Mach Operating System
7  * Copyright (c) 1992 Carnegie Mellon University
8  * All Rights Reserved.
9  *
10  * Permission to use, copy, modify and distribute this software and its
11  * documentation is hereby granted, provided that both the copyright
12  * notice and this permission notice appear in all copies of the
13  * software, derivative works or modified versions, and any portions
14  * thereof, and that both notices appear in supporting documentation.
15  *
16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
18  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
19  *
20  * Carnegie Mellon requests users of this software to return to
21  *
22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
23  *  School of Computer Science
24  *  Carnegie Mellon University
25  *  Pittsburgh PA 15213-3890
26  *
27  * any improvements or extensions that they make and grant Carnegie Mellon
28  * the rights to redistribute these changes.
29  */
30 
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/kdb.h>
34 #include <sys/proc.h>
35 #include <sys/stack.h>
36 
37 #include <vm/vm.h>
38 #include <vm/pmap.h>
39 #include <vm/vm_extern.h>
40 
41 #include <machine/db_machdep.h>
42 #include <machine/pcb.h>
43 #include <machine/spr.h>
44 #include <machine/stack.h>
45 #include <machine/trap.h>
46 
47 #include <ddb/ddb.h>
48 #include <ddb/db_access.h>
49 #include <ddb/db_sym.h>
50 #include <ddb/db_variables.h>
51 
52 static db_varfcn_t db_frame;
53 
54 #define DB_OFFSET(x)	(db_expr_t *)offsetof(struct trapframe, x)
55 
56 struct db_variable db_regs[] = {
57 	{ "r0",	 DB_OFFSET(fixreg[0]),	db_frame },
58 	{ "r1",	 DB_OFFSET(fixreg[1]),	db_frame },
59 	{ "r2",	 DB_OFFSET(fixreg[2]),	db_frame },
60 	{ "r3",	 DB_OFFSET(fixreg[3]),	db_frame },
61 	{ "r4",	 DB_OFFSET(fixreg[4]),	db_frame },
62 	{ "r5",	 DB_OFFSET(fixreg[5]),	db_frame },
63 	{ "r6",	 DB_OFFSET(fixreg[6]),	db_frame },
64 	{ "r7",	 DB_OFFSET(fixreg[7]),	db_frame },
65 	{ "r8",	 DB_OFFSET(fixreg[8]),	db_frame },
66 	{ "r9",	 DB_OFFSET(fixreg[9]),	db_frame },
67 	{ "r10", DB_OFFSET(fixreg[10]),	db_frame },
68 	{ "r11", DB_OFFSET(fixreg[11]),	db_frame },
69 	{ "r12", DB_OFFSET(fixreg[12]),	db_frame },
70 	{ "r13", DB_OFFSET(fixreg[13]),	db_frame },
71 	{ "r14", DB_OFFSET(fixreg[14]),	db_frame },
72 	{ "r15", DB_OFFSET(fixreg[15]),	db_frame },
73 	{ "r16", DB_OFFSET(fixreg[16]),	db_frame },
74 	{ "r17", DB_OFFSET(fixreg[17]),	db_frame },
75 	{ "r18", DB_OFFSET(fixreg[18]),	db_frame },
76 	{ "r19", DB_OFFSET(fixreg[19]),	db_frame },
77 	{ "r20", DB_OFFSET(fixreg[20]),	db_frame },
78 	{ "r21", DB_OFFSET(fixreg[21]),	db_frame },
79 	{ "r22", DB_OFFSET(fixreg[22]),	db_frame },
80 	{ "r23", DB_OFFSET(fixreg[23]),	db_frame },
81 	{ "r24", DB_OFFSET(fixreg[24]),	db_frame },
82 	{ "r25", DB_OFFSET(fixreg[25]),	db_frame },
83 	{ "r26", DB_OFFSET(fixreg[26]),	db_frame },
84 	{ "r27", DB_OFFSET(fixreg[27]),	db_frame },
85 	{ "r28", DB_OFFSET(fixreg[28]),	db_frame },
86 	{ "r29", DB_OFFSET(fixreg[29]),	db_frame },
87 	{ "r30", DB_OFFSET(fixreg[30]),	db_frame },
88 	{ "r31", DB_OFFSET(fixreg[31]),	db_frame },
89 	{ "srr0", DB_OFFSET(srr0),	db_frame },
90 	{ "srr1", DB_OFFSET(srr1),	db_frame },
91 	{ "lr",	 DB_OFFSET(lr),		db_frame },
92 	{ "ctr", DB_OFFSET(ctr),	db_frame },
93 	{ "cr",	 DB_OFFSET(cr),		db_frame },
94 	{ "xer", DB_OFFSET(xer),	db_frame },
95 #ifdef AIM
96 	{ "dar", DB_OFFSET(cpu.aim.dar),	db_frame },
97 	{ "dsisr", DB_OFFSET(cpu.aim.dsisr),	db_frame },
98 #endif
99 #ifdef E500
100 	{ "dear", DB_OFFSET(cpu.booke.dear),	db_frame },
101 	{ "esr", DB_OFFSET(cpu.booke.esr),	db_frame },
102 #endif
103 };
104 struct db_variable *db_eregs = db_regs + sizeof (db_regs)/sizeof (db_regs[0]);
105 
106 /*
107  * register variable handling
108  */
109 static int
110 db_frame(struct db_variable *vp, db_expr_t *valuep, int op)
111 {
112 	uint32_t *reg;
113 
114 	if (kdb_frame == NULL)
115 		return (0);
116         reg = (uint32_t*)((uintptr_t)kdb_frame + (uintptr_t)vp->valuep);
117         if (op == DB_VAR_GET)
118                 *valuep = *reg;
119         else
120                 *reg = *valuep;
121         return (1);
122 }
123 
124 
125 /*
126  *	Frame tracing.
127  */
128 static int
129 db_backtrace(struct thread *td, db_addr_t fp, int count)
130 {
131 	db_addr_t stackframe, lr, *args;
132 	db_expr_t diff;
133 	c_db_sym_t sym;
134 	const char *symname;
135 	boolean_t kernel_only = TRUE;
136 	boolean_t full = FALSE;
137 
138 #if 0
139 	{
140 		register char *cp = modif;
141 		register char c;
142 
143 		while ((c = *cp++) != 0) {
144 			if (c == 't')
145 				trace_thread = TRUE;
146 			if (c == 'u')
147 				kernel_only = FALSE;
148 			if (c == 'f')
149 				full = TRUE;
150 		}
151 	}
152 #endif
153 
154 	stackframe = fp;
155 
156 	while (!db_pager_quit) {
157 		if (stackframe < PAGE_SIZE)
158 			break;
159 
160 		/*
161 		 * Locate the next frame by grabbing the backchain ptr
162 		 * from frame[0]
163 		 */
164 		stackframe = *(db_addr_t *)stackframe;
165 
166 	next_frame:
167 		/* The saved arg values start at frame[2] */
168 		args = (db_addr_t *)(stackframe + 8);
169 
170 		if (stackframe < PAGE_SIZE)
171 			break;
172 
173 	        if (count-- == 0)
174 			break;
175 
176 		/*
177 		 * Extract link register from frame and subtract
178 		 * 4 to convert into calling address (as opposed to
179 		 * return address)
180 		 */
181 		lr = *(db_addr_t *)(stackframe + 4) - 4;
182 		if ((lr & 3) || (lr < 0x100)) {
183 			db_printf("saved LR(0x%x) is invalid.", lr);
184 			break;
185 		}
186 
187 		db_printf("0x%08x: ", stackframe);
188 
189 		/*
190 		 * The trap code labels the return addresses from the
191 		 * call to C code as 'trapexit' and 'asttrapexit. Use this
192 		 * to determine if the callframe has to traverse a saved
193 		 * trap context
194 		 */
195 		if ((lr + 4 == (db_addr_t) &trapexit) ||
196 		    (lr + 4 == (db_addr_t) &asttrapexit)) {
197 			const char *trapstr;
198 			struct trapframe *tf = (struct trapframe *)
199 				(stackframe+8);
200 			db_printf("%s ", tf->srr1 & PSL_PR ? "user" : "kernel");
201 			switch (tf->exc) {
202 			case EXC_DSI:
203 				/* XXX take advantage of the union. */
204 				db_printf("DSI %s trap @ %#x by ",
205 				    (tf->cpu.aim.dsisr & DSISR_STORE) ? "write"
206 				    : "read", tf->cpu.aim.dar);
207 				goto print_trap;
208 			case EXC_ALI:
209 				/* XXX take advantage of the union. */
210 				db_printf("ALI trap @ %#x (xSR %#x) ",
211 				    tf->cpu.aim.dar, tf->cpu.aim.dsisr);
212 				goto print_trap;
213 			case EXC_ISI: trapstr = "ISI"; break;
214 			case EXC_PGM: trapstr = "PGM"; break;
215 			case EXC_SC: trapstr = "SC"; break;
216 			case EXC_EXI: trapstr = "EXI"; break;
217 			case EXC_MCHK: trapstr = "MCHK"; break;
218 #ifndef E500
219 			case EXC_VEC: trapstr = "VEC"; break;
220 			case EXC_FPA: trapstr = "FPA"; break;
221 			case EXC_BPT: trapstr = "BPT"; break;
222 			case EXC_TRC: trapstr = "TRC"; break;
223 			case EXC_RUNMODETRC: trapstr = "RUNMODETRC"; break;
224 			case EXC_SMI: trapstr = "SMI"; break;
225 			case EXC_RST: trapstr = "RST"; break;
226 #endif
227 			case EXC_FPU: trapstr = "FPU"; break;
228 			case EXC_DECR: trapstr = "DECR"; break;
229 			case EXC_PERF: trapstr = "PERF"; break;
230 			default: trapstr = NULL; break;
231 			}
232 			if (trapstr != NULL) {
233 				db_printf("%s trap by ", trapstr);
234 			} else {
235 				db_printf("trap %#x by ", tf->exc);
236 			}
237 
238 		   print_trap:
239 			lr = (db_addr_t) tf->srr0;
240 			diff = 0;
241 			symname = NULL;
242 			sym = db_search_symbol(lr, DB_STGY_ANY, &diff);
243 			db_symbol_values(sym, &symname, 0);
244 			if (symname == NULL || !strcmp(symname, "end")) {
245 				db_printf("%#x: srr1=%#x\n", lr, tf->srr1);
246 			} else {
247 				db_printf("%s+%#x: srr1=%#x\n", symname, diff,
248 				    tf->srr1);
249 			}
250 			db_printf("%-10s  r1=%#x cr=%#x xer=%#x ctr=%#x",
251 			    "", tf->fixreg[1], tf->cr, tf->xer, tf->ctr);
252 			if (tf->exc == EXC_DSI)
253 				db_printf(" sr=%#x", tf->cpu.aim.dsisr);
254 			db_printf("\n");
255 			stackframe = (db_addr_t) tf->fixreg[1];
256 			if (kernel_only && (tf->srr1 & PSL_PR))
257 				break;
258 			goto next_frame;
259 		}
260 
261 		diff = 0;
262 		symname = NULL;
263 		sym = db_search_symbol(lr, DB_STGY_ANY, &diff);
264 		db_symbol_values(sym, &symname, 0);
265 		if (symname == NULL || !strcmp(symname, "end"))
266 			db_printf("at %x", lr);
267 		else
268 			db_printf("at %s+%#x", symname, diff);
269 		if (full)
270 			/* Print all the args stored in that stackframe. */
271 			db_printf("(%x, %x, %x, %x, %x, %x, %x, %x)",
272 				args[0], args[1], args[2], args[3],
273 				args[4], args[5], args[6], args[7]);
274 		db_printf("\n");
275 	}
276 
277 	return (0);
278 }
279 
280 void
281 db_trace_self(void)
282 {
283 	db_addr_t addr;
284 
285 	addr = (db_addr_t)__builtin_frame_address(1);
286 	db_backtrace(curthread, addr, -1);
287 }
288 
289 int
290 db_trace_thread(struct thread *td, int count)
291 {
292 	struct pcb *ctx;
293 
294 	ctx = kdb_thr_ctx(td);
295 	return (db_backtrace(td, (db_addr_t)ctx->pcb_sp, count));
296 }
297