db_trace.c revision 1.40
1 /* $NetBSD: db_trace.c,v 1.40 2010/07/07 01:22:35 chs 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/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: db_trace.c,v 1.40 2010/07/07 01:22:35 chs Exp $"); 31 32 #include "opt_ddb.h" 33 34 #include <sys/types.h> 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/proc.h> 38 #include <sys/cpu.h> 39 40 #include <mips/mips_opcode.h> 41 42 #include <machine/db_machdep.h> 43 44 #include <ddb/db_interface.h> 45 #include <ddb/db_output.h> 46 #include <ddb/db_variables.h> 47 #include <ddb/db_sym.h> 48 49 int __start(void); /* lowest kernel code address */ 50 vaddr_t getreg_val(db_expr_t regno); 51 52 #define REG_ARG(i) (4+i) 53 #define SAVES_RA(x) isa_spill((x),31) 54 55 #define KERN_SAVE_REG_IDX(vp) ( \ 56 ((vp)->valuep >= (int *)(&((struct mips_saved_state *)0)->s0) && \ 57 (vp)->valuep <= (int *)(&((struct mips_saved_state *)0)->s7))? \ 58 vp->valuep - (int *)(&((struct mips_saved_state *)0)->s0): \ 59 ((vp)->valuep >= (int *)(&((struct mips_saved_state *)0)->sp) && \ 60 (vp)->valuep <= (int *)(&((struct mips_saved_state *)0)->ra))? \ 61 ((vp)->valuep-(int *)(&((struct mips_saved_state *)0)->sp)) + \ 62 ((int *)(&((struct mips_kernel_state *)0)->sp) - (int *)0): \ 63 -1) 64 65 db_sym_t localsym(db_sym_t sym, bool isreg, int *lex_level); 66 67 /* 68 * Machine register set. 69 */ 70 struct mips_saved_state *db_cur_exc_frame = 0; 71 72 /*XXX*/ 73 void stacktrace_subr(mips_reg_t, mips_reg_t, mips_reg_t, mips_reg_t, 74 vaddr_t, vaddr_t, vaddr_t, vaddr_t, 75 void (*)(const char*, ...)); 76 77 /* 78 * Stack trace helper. 79 */ 80 void db_mips_stack_trace(int, vaddr_t, vaddr_t, vaddr_t, int, vaddr_t); 81 int db_mips_variable_func(const struct db_variable *, db_expr_t *, int); 82 83 #define DB_SETF_REGS db_mips_variable_func 84 #define DBREGS_REG() 85 86 const struct db_variable db_regs[] = { 87 { "at", (long *)&ddb_regs.f_regs[_R_AST], DB_SETF_REGS }, 88 { "v0", (long *)&ddb_regs.f_regs[_R_V0], DB_SETF_REGS }, 89 { "v1", (long *)&ddb_regs.f_regs[_R_V1], DB_SETF_REGS }, 90 { "a0", (long *)&ddb_regs.f_regs[_R_A0], DB_SETF_REGS }, 91 { "a1", (long *)&ddb_regs.f_regs[_R_A1], DB_SETF_REGS }, 92 { "a2", (long *)&ddb_regs.f_regs[_R_A2], DB_SETF_REGS }, 93 { "a3", (long *)&ddb_regs.f_regs[_R_A3], DB_SETF_REGS }, 94 #if defined(__mips_n32) || defined(__mips_n64) 95 { "a4", (long *)&ddb_regs.f_regs[_R_A4], DB_SETF_REGS }, 96 { "a5", (long *)&ddb_regs.f_regs[_R_A5], DB_SETF_REGS }, 97 { "a6", (long *)&ddb_regs.f_regs[_R_A6], DB_SETF_REGS }, 98 { "a7", (long *)&ddb_regs.f_regs[_R_A7], DB_SETF_REGS }, 99 { "t0", (long *)&ddb_regs.f_regs[_R_T0], DB_SETF_REGS }, 100 { "t1", (long *)&ddb_regs.f_regs[_R_T1], DB_SETF_REGS }, 101 { "t2", (long *)&ddb_regs.f_regs[_R_T2], DB_SETF_REGS }, 102 { "t3", (long *)&ddb_regs.f_regs[_R_T3], DB_SETF_REGS }, 103 #else 104 { "t0", (long *)&ddb_regs.f_regs[_R_T0], DB_SETF_REGS }, 105 { "t1", (long *)&ddb_regs.f_regs[_R_T1], DB_SETF_REGS }, 106 { "t2", (long *)&ddb_regs.f_regs[_R_T2], DB_SETF_REGS }, 107 { "t3", (long *)&ddb_regs.f_regs[_R_T3], DB_SETF_REGS }, 108 { "t4", (long *)&ddb_regs.f_regs[_R_T4], DB_SETF_REGS }, 109 { "t5", (long *)&ddb_regs.f_regs[_R_T5], DB_SETF_REGS }, 110 { "t6", (long *)&ddb_regs.f_regs[_R_T6], DB_SETF_REGS }, 111 { "t7", (long *)&ddb_regs.f_regs[_R_T7], DB_SETF_REGS }, 112 #endif /* __mips_n32 || __mips_n64 */ 113 { "s0", (long *)&ddb_regs.f_regs[_R_S0], DB_SETF_REGS }, 114 { "s1", (long *)&ddb_regs.f_regs[_R_S1], DB_SETF_REGS }, 115 { "s2", (long *)&ddb_regs.f_regs[_R_S2], DB_SETF_REGS }, 116 { "s3", (long *)&ddb_regs.f_regs[_R_S3], DB_SETF_REGS }, 117 { "s4", (long *)&ddb_regs.f_regs[_R_S4], DB_SETF_REGS }, 118 { "s5", (long *)&ddb_regs.f_regs[_R_S5], DB_SETF_REGS }, 119 { "s6", (long *)&ddb_regs.f_regs[_R_S6], DB_SETF_REGS }, 120 { "s7", (long *)&ddb_regs.f_regs[_R_S7], DB_SETF_REGS }, 121 { "t8", (long *)&ddb_regs.f_regs[_R_T8], DB_SETF_REGS }, 122 { "t9", (long *)&ddb_regs.f_regs[_R_T9], DB_SETF_REGS }, 123 { "k0", (long *)&ddb_regs.f_regs[_R_K0], DB_SETF_REGS }, 124 { "k1", (long *)&ddb_regs.f_regs[_R_K1], DB_SETF_REGS }, 125 { "gp", (long *)&ddb_regs.f_regs[_R_GP], DB_SETF_REGS }, 126 { "sp", (long *)&ddb_regs.f_regs[_R_SP], DB_SETF_REGS }, 127 { "fp", (long *)&ddb_regs.f_regs[_R_S8], DB_SETF_REGS },/* frame ptr */ 128 { "ra", (long *)&ddb_regs.f_regs[_R_RA], DB_SETF_REGS }, 129 { "sr", (long *)&ddb_regs.f_regs[_R_SR], DB_SETF_REGS }, 130 { "mdlo",(long *)&ddb_regs.f_regs[_R_MULLO], DB_SETF_REGS }, 131 { "mdhi",(long *)&ddb_regs.f_regs[_R_MULHI], DB_SETF_REGS }, 132 { "bad", (long *)&ddb_regs.f_regs[_R_BADVADDR], DB_SETF_REGS }, 133 { "cs", (long *)&ddb_regs.f_regs[_R_CAUSE], DB_SETF_REGS }, 134 { "pc", (long *)&ddb_regs.f_regs[_R_PC], DB_SETF_REGS }, 135 }; 136 const struct db_variable * const db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); 137 138 void 139 db_stack_trace_print(db_expr_t addr, bool have_addr, db_expr_t count, 140 const char *modif, void (*pr)(const char *, ...)) 141 { 142 #ifndef DDB_TRACE 143 struct pcb *pcb; 144 struct proc *p; 145 struct lwp *l; 146 const char *cp = modif; 147 char c; 148 bool lwpaddr = false; 149 150 if (!have_addr) { 151 stacktrace_subr(ddb_regs.f_regs[_R_A0], 152 ddb_regs.f_regs[_R_A1], 153 ddb_regs.f_regs[_R_A2], 154 ddb_regs.f_regs[_R_A3], 155 ddb_regs.f_regs[_R_PC], 156 ddb_regs.f_regs[_R_SP], 157 /* non-virtual frame pointer */ 158 ddb_regs.f_regs[_R_S8], 159 ddb_regs.f_regs[_R_RA], 160 pr); 161 return; 162 } 163 164 while ((c = *cp++) != 0) { 165 if (c == 'a') { 166 lwpaddr = true; 167 } 168 } 169 170 if (lwpaddr) { 171 l = (struct lwp *)addr; 172 (*pr)("pid %d.%d ", l->l_proc->p_pid, l->l_lid); 173 } else { 174 /* "trace/t" */ 175 176 (*pr)("pid %d ", (int)addr); 177 p = proc_find_raw(addr); 178 if (p == NULL) { 179 (*pr)("not found\n"); 180 return; 181 } 182 l = LIST_FIRST(&p->p_lwps); /* XXX NJWLWP */ 183 } 184 pcb = lwp_getpcb(l); 185 (*pr)("at %p\n", pcb); 186 187 stacktrace_subr(0,0,0,0, /* no args known */ 188 (vaddr_t)cpu_switchto, 189 pcb->pcb_context.val[_L_SP], 190 pcb->pcb_context.val[_L_S8], 191 pcb->pcb_context.val[_L_RA], 192 pr); 193 #else 194 /* 195 * Incomplete but practically useful stack backtrace. 196 */ 197 #define MIPS_JR_RA 0x03e00008 /* instruction code for jr ra */ 198 #define MIPS_JR_K0 0x03400008 /* instruction code for jr k0 */ 199 #define MIPS_ERET 0x42000018 /* instruction code for eret */ 200 register_t va, pc, ra, sp, func; 201 int insn; 202 InstFmt i; 203 int stacksize; 204 db_addr_t offset; 205 const char *name; 206 extern char verylocore[]; 207 208 pc = ddb_regs.f_regs[_R_PC]; 209 sp = ddb_regs.f_regs[_R_SP]; 210 ra = ddb_regs.f_regs[_R_RA]; 211 do { 212 va = pc; 213 do { 214 va -= sizeof(int); 215 insn = *(int *)(intptr_t)va; 216 if (insn == MIPS_ERET) 217 goto mips3_eret; 218 } while (insn != MIPS_JR_RA && insn != MIPS_JR_K0); 219 va += sizeof(int); 220 mips3_eret: 221 va += sizeof(int); 222 while (*(int *)(intptr_t)va == 0x00000000) 223 va += sizeof(int); 224 func = va; 225 stacksize = 0; 226 do { 227 i.word = *(int *)(intptr_t)va; 228 if (((i.IType.op == OP_SW) || (i.IType.op == OP_SD)) 229 && i.IType.rs == _R_SP 230 && i.IType.rt == _R_RA) 231 ra = *(int *)(intptr_t)(sp + (short)i.IType.imm); 232 if (((i.IType.op == OP_ADDIU) || (i.IType.op == OP_DADDIU)) 233 && i.IType.rs == _R_SP 234 && i.IType.rt == _R_SP) 235 stacksize = -(short)i.IType.imm; 236 va += sizeof(int); 237 } while (va < pc); 238 239 db_find_sym_and_offset(func, &name, &offset); 240 if (name == 0) 241 name = "?"; 242 (*pr)("%s()+0x%x, called by %p, stack size %d\n", 243 name, pc - func, (void *)(intptr_t)ra, stacksize); 244 245 if (ra == pc) { 246 (*pr)("-- loop? --\n"); 247 return; 248 } 249 sp += stacksize; 250 pc = ra; 251 } while (pc > (intptr_t)verylocore); 252 if (pc < 0x80000000) 253 (*pr)("-- user process --\n"); 254 else 255 (*pr)("-- kernel entry --\n"); 256 #endif 257 } 258 259 void 260 db_mips_stack_trace(int count, vaddr_t stackp, vaddr_t the_pc, vaddr_t the_ra, 261 int flags, vaddr_t kstackp) 262 { 263 264 /* nothing... */ 265 } 266 267 268 int 269 db_mips_variable_func (const struct db_variable *vp, db_expr_t *valuep, 270 int db_var_fcn) 271 { 272 273 switch (db_var_fcn) { 274 case DB_VAR_GET: 275 *valuep = *(mips_reg_t *) vp->valuep; 276 break; 277 case DB_VAR_SET: 278 *(mips_reg_t *) vp->valuep = *valuep; 279 break; 280 } 281 return 0; 282 } 283
Indexes created Wed Sep 24 05:09:52 GMT 2025