1 /* $OpenBSD: db_trace.c,v 1.10 2016/09/10 06:36:26 jasper 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 35 #include <uvm/uvm_extern.h> 36 37 #include <machine/db_machdep.h> 38 #include <machine/signal.h> 39 #include <machine/pcb.h> 40 #include <machine/pmap.h> 41 42 #include <ddb/db_access.h> 43 #include <ddb/db_sym.h> 44 #include <ddb/db_variables.h> 45 #include <ddb/db_interface.h> 46 #include <ddb/db_output.h> 47 48 db_regs_t ddb_regs; 49 50 struct db_variable db_regs[] = { 51 { "r0", (long *)&ddb_regs.fixreg[0], FCN_NULL }, 52 { "r1", (long *)&ddb_regs.fixreg[1], FCN_NULL }, 53 { "r2", (long *)&ddb_regs.fixreg[2], FCN_NULL }, 54 { "r3", (long *)&ddb_regs.fixreg[3], FCN_NULL }, 55 { "r4", (long *)&ddb_regs.fixreg[4], FCN_NULL }, 56 { "r5", (long *)&ddb_regs.fixreg[5], FCN_NULL }, 57 { "r6", (long *)&ddb_regs.fixreg[6], FCN_NULL }, 58 { "r7", (long *)&ddb_regs.fixreg[7], FCN_NULL }, 59 { "r8", (long *)&ddb_regs.fixreg[8], FCN_NULL }, 60 { "r9", (long *)&ddb_regs.fixreg[9], FCN_NULL }, 61 { "r10", (long *)&ddb_regs.fixreg[10], FCN_NULL }, 62 { "r11", (long *)&ddb_regs.fixreg[11], FCN_NULL }, 63 { "r12", (long *)&ddb_regs.fixreg[12], FCN_NULL }, 64 { "r13", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 65 { "r14", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 66 { "r15", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 67 { "r16", (long *)&ddb_regs.fixreg[13], FCN_NULL }, 68 { "r17", (long *)&ddb_regs.fixreg[17], FCN_NULL }, 69 { "r18", (long *)&ddb_regs.fixreg[18], FCN_NULL }, 70 { "r19", (long *)&ddb_regs.fixreg[19], FCN_NULL }, 71 { "r20", (long *)&ddb_regs.fixreg[20], FCN_NULL }, 72 { "r21", (long *)&ddb_regs.fixreg[21], FCN_NULL }, 73 { "r22", (long *)&ddb_regs.fixreg[22], FCN_NULL }, 74 { "r23", (long *)&ddb_regs.fixreg[23], FCN_NULL }, 75 { "r24", (long *)&ddb_regs.fixreg[24], FCN_NULL }, 76 { "r25", (long *)&ddb_regs.fixreg[25], FCN_NULL }, 77 { "r26", (long *)&ddb_regs.fixreg[26], FCN_NULL }, 78 { "r27", (long *)&ddb_regs.fixreg[27], FCN_NULL }, 79 { "r28", (long *)&ddb_regs.fixreg[28], FCN_NULL }, 80 { "r29", (long *)&ddb_regs.fixreg[29], FCN_NULL }, 81 { "r30", (long *)&ddb_regs.fixreg[30], FCN_NULL }, 82 { "r31", (long *)&ddb_regs.fixreg[31], FCN_NULL }, 83 { "lr", (long *)&ddb_regs.lr, FCN_NULL }, 84 { "cr", (long *)&ddb_regs.cr, FCN_NULL }, 85 { "xer", (long *)&ddb_regs.xer, FCN_NULL }, 86 { "ctr", (long *)&ddb_regs.ctr, FCN_NULL }, 87 { "iar", (long *)&ddb_regs.srr0, FCN_NULL }, 88 { "msr", (long *)&ddb_regs.srr1, FCN_NULL }, 89 }; 90 91 struct db_variable *db_eregs = db_regs + nitems(db_regs); 92 93 /* 94 * this is probably hackery. 95 */ 96 void 97 db_save_regs(struct trapframe *frame) 98 { 99 bcopy(frame, &ddb_regs, sizeof (struct trapframe)); 100 } 101 102 /* from locore.S */ 103 extern db_addr_t trapexit; 104 extern db_addr_t esym; 105 #define INTSTK (8*1024) /* 8K interrupt stack */ 106 107 #define INKERNEL(va) (((vaddr_t)(va)) >= VM_MIN_KERNEL_ADDRESS && \ 108 ((vaddr_t)(va)) < VM_MAX_KERNEL_ADDRESS) 109 110 #define ININTSTK(va) (((vaddr_t)(va)) >= round_page(esym) && \ 111 ((vaddr_t)(va)) < (round_page(esym) + INTSTK)) 112 113 /* 114 * Frame tracing. 115 */ 116 void 117 db_stack_trace_print(db_expr_t addr, int have_addr, db_expr_t count, 118 char *modif, int (*pr)(const char *, ...)) 119 { 120 db_addr_t lr, sp, lastsp; 121 db_expr_t offset; 122 db_sym_t sym; 123 char *name; 124 char c, *cp = modif; 125 int trace_proc = 0; 126 127 while ((c = *cp++) != 0) { 128 if (c == 'p') 129 trace_proc = 1; 130 } 131 132 if (!have_addr) { 133 sp = ddb_regs.fixreg[1]; 134 lr = ddb_regs.srr0; 135 } else { 136 if (trace_proc) { 137 struct proc *p = pfind((pid_t)addr); 138 if (p == NULL) { 139 (*pr) ("not found\n"); 140 return; 141 } 142 addr = p->p_addr->u_pcb.pcb_sp; 143 } 144 sp = addr; 145 db_read_bytes(sp + 4, sizeof(db_addr_t), (char *)&lr); 146 } 147 148 while (count && sp != 0) { 149 /* 150 * lr contains the return address, so adjust its value 151 * to display the offset of the calling address. 152 */ 153 sym = db_search_symbol(lr - 4, DB_STGY_ANY, &offset); 154 db_symbol_values(sym, &name, NULL); 155 156 if (name == NULL || strcmp(name, "end") == 0) { 157 (*pr)("at 0x%lx", lr - 4); 158 } else { 159 (*pr)("%s() at ", name); 160 db_printsym(lr - 4, DB_STGY_PROC, pr); 161 } 162 (*pr)("\n"); 163 164 lastsp = sp; 165 166 /* 167 * Abuse the fact that the return address of the trap() 168 * function is always 'trapexit'. 169 */ 170 if (lr == (db_addr_t)&trapexit) { 171 struct trapframe *tf = (struct trapframe *)(sp + 8); 172 uint32_t code = tf->fixreg[0]; 173 uint32_t type = tf->exc; 174 175 if (tf->srr1 & PSL_PR) 176 type |= EXC_USER; 177 178 if (type == (EXC_SC|EXC_USER)) 179 (*pr)("--- syscall (number %d) ---\n", code); 180 else 181 (*pr)("--- trap (type 0x%x) ---\n", type); 182 } 183 184 db_read_bytes(sp, sizeof(db_addr_t), (char *)&sp); 185 if (sp == 0) 186 break; 187 188 db_read_bytes(sp + 4, sizeof(db_addr_t), (char *)&lr); 189 190 if (INKERNEL(sp)) { 191 if (sp <= lastsp) { 192 (*pr)("Bad frame pointer: 0x%lx\n", sp); 193 break; 194 } 195 196 if (ININTSTK(lastsp)) 197 (*pr)("--- interrupt ---\n"); 198 199 } else { 200 if (!ININTSTK(sp)) { 201 (*pr)("End of kernel: 0x%lx\n", sp); 202 break; 203 } 204 } 205 --count; 206 } 207 (*pr)("end trace frame: 0x%lx, count: %d\n", sp, count); 208 } 209