db_trace.c revision 1.21
1 /* $NetBSD: db_trace.c,v 1.21 2002/03/05 15:12:58 simonb 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 { "t0", (long *)&ddb_regs.f_regs[T0], DB_SETF_REGS }, 89 { "t1", (long *)&ddb_regs.f_regs[T1], DB_SETF_REGS }, 90 { "t2", (long *)&ddb_regs.f_regs[T2], DB_SETF_REGS }, 91 { "t3", (long *)&ddb_regs.f_regs[T3], DB_SETF_REGS }, 92 { "t4", (long *)&ddb_regs.f_regs[T4], DB_SETF_REGS }, 93 { "t5", (long *)&ddb_regs.f_regs[T5], DB_SETF_REGS }, 94 { "t6", (long *)&ddb_regs.f_regs[T6], DB_SETF_REGS }, 95 { "t7", (long *)&ddb_regs.f_regs[T7], DB_SETF_REGS }, 96 { "s0", (long *)&ddb_regs.f_regs[S0], DB_SETF_REGS }, 97 { "s1", (long *)&ddb_regs.f_regs[S1], DB_SETF_REGS }, 98 { "s2", (long *)&ddb_regs.f_regs[S2], DB_SETF_REGS }, 99 { "s3", (long *)&ddb_regs.f_regs[S3], DB_SETF_REGS }, 100 { "s4", (long *)&ddb_regs.f_regs[S4], DB_SETF_REGS }, 101 { "s5", (long *)&ddb_regs.f_regs[S5], DB_SETF_REGS }, 102 { "s6", (long *)&ddb_regs.f_regs[S6], DB_SETF_REGS }, 103 { "s7", (long *)&ddb_regs.f_regs[S7], DB_SETF_REGS }, 104 { "t8", (long *)&ddb_regs.f_regs[T8], DB_SETF_REGS }, 105 { "t9", (long *)&ddb_regs.f_regs[T9], DB_SETF_REGS }, 106 { "k0", (long *)&ddb_regs.f_regs[K0], DB_SETF_REGS }, 107 { "k1", (long *)&ddb_regs.f_regs[K1], DB_SETF_REGS }, 108 { "gp", (long *)&ddb_regs.f_regs[GP], DB_SETF_REGS }, 109 { "sp", (long *)&ddb_regs.f_regs[SP], DB_SETF_REGS }, 110 { "fp", (long *)&ddb_regs.f_regs[S8], DB_SETF_REGS }, /* frame ptr */ 111 { "ra", (long *)&ddb_regs.f_regs[RA], DB_SETF_REGS }, 112 { "sr", (long *)&ddb_regs.f_regs[SR], DB_SETF_REGS }, 113 { "mdlo",(long *)&ddb_regs.f_regs[MULLO], DB_SETF_REGS }, 114 { "mdhi",(long *)&ddb_regs.f_regs[MULHI], DB_SETF_REGS }, 115 { "bad", (long *)&ddb_regs.f_regs[BADVADDR], DB_SETF_REGS }, 116 { "cs", (long *)&ddb_regs.f_regs[CAUSE], DB_SETF_REGS }, 117 { "pc", (long *)&ddb_regs.f_regs[PC], DB_SETF_REGS }, 118 }; 119 const struct db_variable * const db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); 120 121 void 122 db_stack_trace_print(db_expr_t addr, boolean_t have_addr, db_expr_t count, 123 char *modif, void (*pr)(const char *, ...)) 124 { 125 #ifndef DDB_TRACE 126 struct pcb *pcb; 127 struct proc *p; 128 129 if (!have_addr) { 130 stacktrace_subr(ddb_regs.f_regs[A0], ddb_regs.f_regs[A1], 131 ddb_regs.f_regs[A2], ddb_regs.f_regs[A3], 132 ddb_regs.f_regs[PC], 133 ddb_regs.f_regs[SP], 134 /* non-virtual frame pointer */ 135 ddb_regs.f_regs[S8], 136 ddb_regs.f_regs[RA], 137 pr); 138 return; 139 } 140 141 /* "trace/t" */ 142 (*pr)("pid %d ", (int)addr); 143 p = pfind(addr); 144 if (p == NULL) { 145 (*pr)("not found\n"); 146 return; 147 } 148 if (!(p->p_flag&P_INMEM)) { 149 (*pr)("swapped out\n"); 150 return; 151 } 152 153 pcb = &(p->p_addr->u_pcb); 154 (*pr)("at %p\n", pcb); 155 156 stacktrace_subr(0,0,0,0, /* no args known */ 157 (int)cpu_switch, 158 pcb->pcb_context[8], 159 pcb->pcb_context[9], 160 pcb->pcb_context[10], 161 pr); 162 #else 163 /* 164 * Incomplete but practically useful stack backtrace. 165 */ 166 #define MIPS_JR_RA 0x03e00008 /* instruction code for jr ra */ 167 #define MIPS_JR_K0 0x03400008 /* instruction code for jr k0 */ 168 #define MIPS_ERET 0x42000018 /* instruction code for eret */ 169 unsigned va, pc, ra, sp, func; 170 int insn; 171 InstFmt i; 172 int stacksize; 173 db_addr_t offset; 174 char *name; 175 extern char verylocore[]; 176 177 pc = ddb_regs.f_regs[PC]; 178 sp = ddb_regs.f_regs[SP]; 179 ra = ddb_regs.f_regs[RA]; 180 do { 181 va = pc; 182 do { 183 va -= sizeof(int); 184 insn = *(int *)va; 185 if (insn == MIPS_ERET) 186 goto mips3_eret; 187 } while (insn != MIPS_JR_RA && insn != MIPS_JR_K0); 188 va += sizeof(int); 189 mips3_eret: 190 va += sizeof(int); 191 while (*(int *)va == 0x00000000) 192 va += sizeof(int); 193 func = va; 194 stacksize = 0; 195 do { 196 i.word = *(int *)va; 197 if (i.IType.op == OP_SW 198 && i.IType.rs == SP 199 && i.IType.rt == RA) 200 ra = *(int *)(sp + (short)i.IType.imm); 201 if (i.IType.op == OP_ADDIU 202 && i.IType.rs == SP 203 && i.IType.rt == SP) 204 stacksize = -(short)i.IType.imm; 205 va += sizeof(int); 206 } while (va < pc); 207 208 db_find_sym_and_offset(func, &name, &offset); 209 if (name == 0) 210 name = "?"; 211 (*pr)("%s()+0x%x, called by %p, stack size %d\n", 212 name, pc - func, (void *)ra, stacksize); 213 214 if (ra == pc) { 215 (*pr)("-- loop? --\n"); 216 return; 217 } 218 sp += stacksize; 219 pc = ra; 220 } while (pc > (unsigned)verylocore); 221 if (pc < 0x80000000) 222 (*pr)("-- user process --\n"); 223 else 224 (*pr)("-- kernel entry --\n"); 225 #endif 226 } 227 228 void 229 db_mips_stack_trace(int count, vaddr_t stackp, vaddr_t the_pc, vaddr_t the_ra, 230 int flags, vaddr_t kstackp) 231 { 232 233 /* nothing... */ 234 } 235 236 237 int 238 db_mips_variable_func (const struct db_variable *vp, db_expr_t *valuep, 239 int db_var_fcn) 240 { 241 242 switch (db_var_fcn) { 243 case DB_VAR_GET: 244 *valuep = *(mips_reg_t *) vp->valuep; 245 break; 246 case DB_VAR_SET: 247 *(mips_reg_t *) vp->valuep = *valuep; 248 break; 249 } 250 return 0; 251 } 252
Indexes created Fri Sep 26 08:10:20 GMT 2025