1 /* $NetBSD: db_trace.c,v 1.8 2003/01/17 22:28:48 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 2000, 2001 Ben Harris 5 * Copyright (c) 1996 Scott K. Stevens 6 * 7 * Mach Operating System 8 * Copyright (c) 1991,1990 Carnegie Mellon University 9 * All Rights Reserved. 10 * 11 * Permission to use, copy, modify and distribute this software and its 12 * documentation is hereby granted, provided that both the copyright 13 * notice and this permission notice appear in all copies of the 14 * software, derivative works or modified versions, and any portions 15 * thereof, and that both notices appear in supporting documentation. 16 * 17 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 18 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR 19 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 20 * 21 * Carnegie Mellon requests users of this software to return to 22 * 23 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 24 * School of Computer Science 25 * Carnegie Mellon University 26 * Pittsburgh PA 15213-3890 27 * 28 * any improvements or extensions that they make and grant Carnegie the 29 * rights to redistribute these changes. 30 */ 31 #include "opt_ddb.h" 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 38 39 #include <sys/proc.h> 40 #include <sys/kdb.h> 41 #include <sys/stack.h> 42 43 #include <machine/armreg.h> 44 #include <machine/asm.h> 45 #include <machine/cpufunc.h> 46 #include <machine/db_machdep.h> 47 #include <machine/debug_monitor.h> 48 #include <machine/pcb.h> 49 #include <machine/stack.h> 50 #include <machine/vmparam.h> 51 52 #include <ddb/ddb.h> 53 #include <ddb/db_access.h> 54 #include <ddb/db_sym.h> 55 #include <ddb/db_output.h> 56 57 static void 58 db_stack_trace_cmd(struct unwind_state *state) 59 { 60 const char *name; 61 db_expr_t value; 62 db_expr_t offset; 63 c_db_sym_t sym; 64 u_int reg, i; 65 char *sep; 66 uint16_t upd_mask; 67 bool finished; 68 69 finished = false; 70 while (!finished) { 71 finished = unwind_stack_one(state, 1); 72 73 /* Print the frame details */ 74 sym = db_search_symbol(state->start_pc, DB_STGY_ANY, &offset); 75 if (sym == C_DB_SYM_NULL) { 76 value = 0; 77 name = "(null)"; 78 } else 79 db_symbol_values(sym, &name, &value); 80 db_printf("%s() at ", name); 81 db_printsym(state->start_pc, DB_STGY_PROC); 82 db_printf("\n"); 83 db_printf("\t pc = 0x%08x lr = 0x%08x (", state->start_pc, 84 state->registers[LR]); 85 db_printsym(state->registers[LR], DB_STGY_PROC); 86 db_printf(")\n"); 87 db_printf("\t sp = 0x%08x fp = 0x%08x", 88 state->registers[SP], state->registers[FP]); 89 90 /* Don't print the registers we have already printed */ 91 upd_mask = state->update_mask & 92 ~((1 << SP) | (1 << FP) | (1 << LR) | (1 << PC)); 93 sep = "\n\t"; 94 for (i = 0, reg = 0; upd_mask != 0; upd_mask >>= 1, reg++) { 95 if ((upd_mask & 1) != 0) { 96 db_printf("%s%sr%d = 0x%08x", sep, 97 (reg < 10) ? " " : "", reg, 98 state->registers[reg]); 99 i++; 100 if (i == 2) { 101 sep = "\n\t"; 102 i = 0; 103 } else 104 sep = " "; 105 106 } 107 } 108 db_printf("\n"); 109 110 if (finished) 111 break; 112 113 /* 114 * Stop if directed to do so, or if we've unwound back to the 115 * kernel entry point, or if the unwind function didn't change 116 * anything (to avoid getting stuck in this loop forever). 117 * If the latter happens, it's an indication that the unwind 118 * information is incorrect somehow for the function named in 119 * the last frame printed before you see the unwind failure 120 * message (maybe it needs a STOP_UNWINDING). 121 */ 122 if (state->registers[PC] < VM_MIN_KERNEL_ADDRESS) { 123 db_printf("Unable to unwind into user mode\n"); 124 finished = true; 125 } else if (state->update_mask == 0) { 126 db_printf("Unwind failure (no registers changed)\n"); 127 finished = true; 128 } 129 } 130 } 131 132 void 133 db_md_list_watchpoints(void) 134 { 135 136 dbg_show_watchpoint(); 137 } 138 139 int 140 db_md_clr_watchpoint(db_expr_t addr, db_expr_t size) 141 { 142 143 return (dbg_remove_watchpoint(addr, size)); 144 } 145 146 int 147 db_md_set_watchpoint(db_expr_t addr, db_expr_t size) 148 { 149 150 return (dbg_setup_watchpoint(addr, size, HW_WATCHPOINT_RW)); 151 } 152 153 int 154 db_trace_thread(struct thread *thr, int count) 155 { 156 struct unwind_state state; 157 struct pcb *ctx; 158 159 if (thr != curthread) { 160 ctx = kdb_thr_ctx(thr); 161 162 state.registers[FP] = ctx->pcb_regs.sf_r11; 163 state.registers[SP] = ctx->pcb_regs.sf_sp; 164 state.registers[LR] = ctx->pcb_regs.sf_lr; 165 state.registers[PC] = ctx->pcb_regs.sf_pc; 166 167 db_stack_trace_cmd(&state); 168 } else 169 db_trace_self(); 170 return (0); 171 } 172 173 void 174 db_trace_self(void) 175 { 176 struct unwind_state state; 177 uint32_t sp; 178 179 /* Read the stack pointer */ 180 __asm __volatile("mov %0, sp" : "=&r" (sp)); 181 182 state.registers[FP] = (uint32_t)__builtin_frame_address(0); 183 state.registers[SP] = sp; 184 state.registers[LR] = (uint32_t)__builtin_return_address(0); 185 state.registers[PC] = (uint32_t)db_trace_self; 186 187 db_stack_trace_cmd(&state); 188 } 189