1 /* $OpenBSD: db_trace.c,v 1.17 2020/05/14 06:58:54 mpi Exp $ */ 2 /* $NetBSD: db_trace.c,v 1.15 1996/02/22 23:23:41 gwr Exp $ */ 3 4 /* 5 * Mach Operating System 6 * Copyright (c) 1992 Carnegie Mellon University 7 * All Rights Reserved. 8 * 9 * Permission to use, copy, modify and distribute this software and its 10 * documentation is hereby granted, provided that both the copyright 11 * notice and this permission notice appear in all copies of the 12 * software, derivative works or modified versions, and any portions 13 * thereof, and that both notices appear in supporting documentation. 14 * 15 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 16 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR 17 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 18 * 19 * Carnegie Mellon requests users of this software to return to 20 * 21 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 22 * School of Computer Science 23 * Carnegie Mellon University 24 * Pittsburgh PA 15213-3890 25 * 26 * any improvements or extensions that they make and grant Carnegie Mellon 27 * the rights to redistribute these changes. 28 */ 29 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/proc.h> 33 #include <sys/user.h> 34 #include <sys/stacktrace.h> 35 36 #include <uvm/uvm_extern.h> 37 38 #include <machine/db_machdep.h> 39 #include <machine/signal.h> 40 #include <machine/pcb.h> 41 #include <machine/pmap.h> 42 43 #include <ddb/db_access.h> 44 #include <ddb/db_sym.h> 45 #include <ddb/db_variables.h> 46 #include <ddb/db_interface.h> 47 #include <ddb/db_output.h> 48 49 db_regs_t ddb_regs; 50 51 struct db_variable db_regs[] = { 52 { "r0", (long *)&ddb_regs.fixreg[0], FCN_NULL }, 53 { "r1", (long *)&ddb_regs.fixreg[1], FCN_NULL }, 54 { "r2", (long *)&ddb_regs.fixreg[2], FCN_NULL }, 55 { "r3", (long *)&ddb_regs.fixreg[3], FCN_NULL }, 56 { "r4", (long *)&ddb_regs.fixreg[4], FCN_NULL }, 57 { "r5", (long *)&ddb_regs.fixreg[5], FCN_NULL }, 58 { "r6", (long *)&ddb_regs.fixreg[6], FCN_NULL }, 59 { "r7", (long *)&ddb_regs.fixreg[7], FCN_NULL }, 60 { "r8", (long *)&ddb_regs.fixreg[8], FCN_NULL }, 61 { "r9", (long *)&ddb_regs.fixreg[9], FCN_NULL }, 62 { "r10", (long *)&ddb_regs.fixreg[10], FCN_NULL }, 63 { "r11", (long *)&ddb_regs.fixreg[11], FCN_NULL }, 64 { "r12", (long *)&ddb_regs.fixreg[12], FCN_NULL }, 65 { "r13", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 66 { "r14", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 67 { "r15", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 68 { "r16", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 69 { "r17", (long *)&ddb_regs.fixreg[17], FCN_NULL }, 70 { "r18", (long *)&ddb_regs.fixreg[18], FCN_NULL }, 71 { "r19", (long *)&ddb_regs.fixreg[19], FCN_NULL }, 72 { "r20", (long *)&ddb_regs.fixreg[20], FCN_NULL }, 73 { "r21", (long *)&ddb_regs.fixreg[21], FCN_NULL }, 74 { "r22", (long *)&ddb_regs.fixreg[22], FCN_NULL }, 75 { "r23", (long *)&ddb_regs.fixreg[23], FCN_NULL }, 76 { "r24", (long *)&ddb_regs.fixreg[24], FCN_NULL }, 77 { "r25", (long *)&ddb_regs.fixreg[25], FCN_NULL }, 78 { "r26", (long *)&ddb_regs.fixreg[26], FCN_NULL }, 79 { "r27", (long *)&ddb_regs.fixreg[27], FCN_NULL }, 80 { "r28", (long *)&ddb_regs.fixreg[28], FCN_NULL }, 81 { "r29", (long *)&ddb_regs.fixreg[29], FCN_NULL }, 82 { "r30", (long *)&ddb_regs.fixreg[30], FCN_NULL }, 83 { "r31", (long *)&ddb_regs.fixreg[31], FCN_NULL }, 84 { "lr", (long *)&ddb_regs.lr, FCN_NULL }, 85 { "cr", (long *)&ddb_regs.cr, FCN_NULL }, 86 { "xer", (long *)&ddb_regs.xer, FCN_NULL }, 87 { "ctr", (long *)&ddb_regs.ctr, FCN_NULL }, 88 { "iar", (long *)&ddb_regs.srr0, FCN_NULL }, 89 { "msr", (long *)&ddb_regs.srr1, FCN_NULL }, 90 }; 91 92 struct db_variable *db_eregs = db_regs + nitems(db_regs); 93 94 /* 95 * this is probably hackery. 96 */ 97 void 98 db_save_regs(struct trapframe *frame) 99 { 100 bcopy(frame, &ddb_regs, sizeof (struct trapframe)); 101 } 102 103 /* from locore.S */ 104 extern vaddr_t trapexit; 105 extern vaddr_t esym; 106 #define INTSTK (8*1024) /* 8K interrupt stack */ 107 108 #define INKERNEL(va) (((vaddr_t)(va)) >= VM_MIN_KERNEL_ADDRESS && \ 109 ((vaddr_t)(va)) < VM_MAX_KERNEL_ADDRESS) 110 111 #define ININTSTK(va) (((vaddr_t)(va)) >= round_page(esym) && \ 112 ((vaddr_t)(va)) < (round_page(esym) + INTSTK)) 113 114 /* 115 * Frame tracing. 116 */ 117 void 118 db_stack_trace_print(db_expr_t addr, int have_addr, db_expr_t count, 119 char *modif, int (*pr)(const char *, ...)) 120 { 121 vaddr_t lr, sp, lastsp, *db_fp_args; 122 db_expr_t offset; 123 Elf_Sym *sym; 124 char *name; 125 char c, *cp = modif; 126 int i, narg, trace_proc = 0; 127 128 while ((c = *cp++) != 0) { 129 if (c == 't') 130 trace_proc = 1; 131 } 132 133 if (!have_addr) { 134 sp = ddb_regs.fixreg[1]; 135 lr = ddb_regs.srr0; 136 } else { 137 if (trace_proc) { 138 struct proc *p = tfind((pid_t)addr); 139 if (p == NULL) { 140 (*pr) ("not found\n"); 141 return; 142 } 143 addr = p->p_addr->u_pcb.pcb_sp; 144 } 145 sp = addr; 146 db_read_bytes(sp + 4, sizeof(vaddr_t), (char *)&lr); 147 } 148 149 while (count && sp != 0) { 150 /* 151 * lr contains the return address, so adjust its value 152 * to display the offset of the calling address. 153 */ 154 sym = db_search_symbol(lr - 4, DB_STGY_ANY, &offset); 155 db_symbol_values(sym, &name, NULL); 156 157 if (name == NULL || strcmp(name, "end") == 0) { 158 (*pr)("at 0x%lx", lr - 4); 159 } else { 160 narg = db_ctf_func_numargs(sym); 161 if (narg < 0 || narg > 8) 162 narg = 8; 163 164 (*pr)("%s(", name); 165 166 if (narg > 0) { 167 db_fp_args = (vaddr_t *)(sp + 8); 168 169 for (i = 0; i < narg; i++) { 170 (*pr)("%lx", db_fp_args[i]); 171 if (i != (narg-1)) 172 (*pr)(","); 173 } 174 } 175 176 (*pr)(") at "); 177 db_printsym(lr - 4, DB_STGY_PROC, pr); 178 } 179 (*pr)("\n"); 180 181 lastsp = sp; 182 183 /* 184 * Abuse the fact that the return address of the trap() 185 * function is always 'trapexit'. 186 */ 187 if (lr == (vaddr_t)&trapexit) { 188 struct trapframe *tf = (struct trapframe *)(sp + 8); 189 uint32_t code = tf->fixreg[0]; 190 uint32_t type = tf->exc; 191 192 if (tf->srr1 & PSL_PR) 193 type |= EXC_USER; 194 195 if (type == (EXC_SC|EXC_USER)) 196 (*pr)("--- syscall (number %d) ---\n", code); 197 else 198 (*pr)("--- trap (type 0x%x) ---\n", type); 199 } 200 201 db_read_bytes(sp, sizeof(vaddr_t), (char *)&sp); 202 if (sp == 0) 203 break; 204 205 db_read_bytes(sp + 4, sizeof(vaddr_t), (char *)&lr); 206 207 if (INKERNEL(sp)) { 208 if (sp <= lastsp) { 209 (*pr)("Bad frame pointer: 0x%lx\n", sp); 210 break; 211 } 212 213 if (ININTSTK(lastsp)) 214 (*pr)("--- interrupt ---\n"); 215 216 } else { 217 if (!ININTSTK(sp)) { 218 (*pr)("End of kernel: 0x%lx\n", sp); 219 break; 220 } 221 } 222 --count; 223 } 224 (*pr)("end trace frame: 0x%lx, count: %d\n", sp, count); 225 } 226 227 void 228 stacktrace_save_at(struct stacktrace *st, unsigned int skip) 229 { 230 vaddr_t lr, sp, lastsp; 231 232 sp = (vaddr_t)__builtin_frame_address(0); 233 if (!INKERNEL(sp) && !ININTSTK(sp)) 234 return; 235 236 st->st_count = 0; 237 while (st->st_count < STACKTRACE_MAX) { 238 lr = *(vaddr_t *)(sp + 4) - 4; 239 if (lr & 3) 240 break; 241 242 if (skip == 0) 243 st->st_pc[st->st_count++] = lr; 244 else 245 skip--; 246 247 lastsp = sp; 248 sp = *(vaddr_t *)sp; 249 250 if ((sp == 0) || (sp & 3) || (sp <= lastsp)) 251 break; 252 if (!INKERNEL(sp) && !ININTSTK(sp)) 253 break; 254 } 255 } 256