/* * Copyright (c) 2008 The DragonFly Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 3. Neither the name of The DragonFly Project nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific, prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * -- * * Mach Operating System * Copyright (c) 1991,1990 Carnegie Mellon University * All Rights Reserved. * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. * * $FreeBSD: src/sys/i386/i386/db_trace.c,v 1.35.2.3 2002/02/21 22:31:25 silby Exp $ * $DragonFly: src/sys/platform/pc64/amd64/db_trace.c,v 1.3 2008/08/29 17:07:10 dillon Exp $ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* DLL */ #include #include #include #include db_varfcn_t db_dr0; db_varfcn_t db_dr1; db_varfcn_t db_dr2; db_varfcn_t db_dr3; db_varfcn_t db_dr4; db_varfcn_t db_dr5; db_varfcn_t db_dr6; db_varfcn_t db_dr7; /* * Machine register set. */ struct db_variable db_regs[] = { { "cs", &ddb_regs.tf_cs, NULL }, /* { "ds", &ddb_regs.tf_ds, NULL }, { "es", &ddb_regs.tf_es, NULL }, { "fs", &ddb_regs.tf_fs, NULL }, { "gs", &ddb_regs.tf_gs, NULL }, */ { "ss", &ddb_regs.tf_ss, NULL }, { "rax", &ddb_regs.tf_rax, NULL }, { "rcx", &ddb_regs.tf_rcx, NULL }, { "rdx", &ddb_regs.tf_rdx, NULL }, { "rbx", &ddb_regs.tf_rbx, NULL }, { "rsp", &ddb_regs.tf_rsp, NULL }, { "rbp", &ddb_regs.tf_rbp, NULL }, { "rsi", &ddb_regs.tf_rsi, NULL }, { "rdi", &ddb_regs.tf_rdi, NULL }, { "rip", &ddb_regs.tf_rip, NULL }, { "rfl", &ddb_regs.tf_rflags, NULL }, { "r8", &ddb_regs.tf_r8, NULL }, { "r9", &ddb_regs.tf_r9, NULL }, { "r10", &ddb_regs.tf_r10, NULL }, { "r11", &ddb_regs.tf_r11, NULL }, { "r12", &ddb_regs.tf_r12, NULL }, { "r13", &ddb_regs.tf_r13, NULL }, { "r14", &ddb_regs.tf_r14, NULL }, { "r15", &ddb_regs.tf_r15, NULL }, { "dr0", NULL, db_dr0 }, { "dr1", NULL, db_dr1 }, { "dr2", NULL, db_dr2 }, { "dr3", NULL, db_dr3 }, { "dr4", NULL, db_dr4 }, { "dr5", NULL, db_dr5 }, { "dr6", NULL, db_dr6 }, { "dr7", NULL, db_dr7 }, }; struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); /* * Stack trace. */ #define INKERNEL(va) (((vm_offset_t)(va)) >= USRSTACK) struct amd64_frame { struct amd64_frame *f_frame; long f_retaddr; long f_arg0; }; #define NORMAL 0 #define TRAP 1 #define INTERRUPT 2 #define SYSCALL 3 static void db_nextframe(struct amd64_frame **, db_addr_t *); static int db_numargs(struct amd64_frame *); static void db_print_stack_entry(const char *, int, char **, long *, db_addr_t); static void dl_symbol_values(long callpc, const char **name); static char *watchtype_str(int type); static int kamd64_set_watch(int watchnum, unsigned int watchaddr, int size, int access, struct dbreg * d); static int kamd64_clr_watch(int watchnum, struct dbreg * d); int db_md_set_watchpoint(db_expr_t addr, db_expr_t size); int db_md_clr_watchpoint(db_expr_t addr, db_expr_t size); void db_md_list_watchpoints(void); /* * Figure out how many arguments were passed into the frame at "fp". */ static int db_numargs(struct amd64_frame *fp) { #if 1 return (0); /* regparm, needs dwarf2 info */ #else int args; #if 0 int *argp; int inst; argp = (int *)db_get_value((int)&fp->f_retaddr, 4, FALSE); /* * XXX etext is wrong for LKMs. We should attempt to interpret * the instruction at the return address in all cases. This * may require better fault handling. */ if (argp < (int *)btext || argp >= (int *)etext) { args = 5; } else { inst = db_get_value((int)argp, 4, FALSE); if ((inst & 0xff) == 0x59) /* popl %ecx */ args = 1; else if ((inst & 0xffff) == 0xc483) /* addl $Ibs, %esp */ args = ((inst >> 16) & 0xff) / 4; else args = 5; } #endif args = 5; return(args); #endif } static void db_print_stack_entry(const char *name, int narg, char **argnp, long *argp, db_addr_t callpc) { db_printf("%s(", name); while (narg) { if (argnp) db_printf("%s=", *argnp++); db_printf("%ld", (long)db_get_value((long)argp, 8, FALSE)); argp++; if (--narg != 0) db_printf(","); } db_printf(") at "); db_printsym(callpc, DB_STGY_PROC); db_printf("\n"); } /* * Figure out the next frame up in the call stack. */ static void db_nextframe(struct amd64_frame **fp, db_addr_t *ip) { struct trapframe *tf; int frame_type; long rip, rsp, rbp; db_expr_t offset; const char *sym, *name; rip = db_get_value((long) &(*fp)->f_retaddr, 8, FALSE); rbp = db_get_value((long) &(*fp)->f_frame, 8, FALSE); /* * Figure out frame type. */ frame_type = NORMAL; sym = db_search_symbol(rip, DB_STGY_ANY, &offset); db_symbol_values(sym, &name, NULL); dl_symbol_values(rip, &name); if (name != NULL) { if (!strcmp(name, "calltrap")) { frame_type = TRAP; } else if (!strncmp(name, "Xresume", 7)) { frame_type = INTERRUPT; } else if (!strcmp(name, "_Xsyscall")) { frame_type = SYSCALL; } } /* * Normal frames need no special processing. */ if (frame_type == NORMAL) { *ip = (db_addr_t) rip; *fp = (struct amd64_frame *) rbp; return; } db_print_stack_entry(name, 0, 0, 0, rip); /* * Point to base of trapframe which is just above the * current frame. */ tf = (struct trapframe *)((long)*fp + 16); #if 0 rsp = (ISPL(tf->tf_cs) == SEL_UPL) ? tf->tf_rsp : (long)&tf->tf_rsp; #endif rsp = (long)&tf->tf_rsp; switch (frame_type) { case TRAP: { rip = tf->tf_rip; rbp = tf->tf_rbp; db_printf( "--- trap %016lx, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n", tf->tf_trapno, rip, rsp, rbp); } break; case SYSCALL: { rip = tf->tf_rip; rbp = tf->tf_rbp; db_printf( "--- syscall %016lx, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n", tf->tf_rax, rip, rsp, rbp); } break; case INTERRUPT: tf = (struct trapframe *)((long)*fp + 16); { rip = tf->tf_rip; rbp = tf->tf_rbp; db_printf( "--- interrupt, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n", rip, rsp, rbp); } break; default: break; } *ip = (db_addr_t) rip; *fp = (struct amd64_frame *) rbp; } void db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count, char *modif) { struct amd64_frame *frame; long *argp; db_addr_t callpc; boolean_t first; int i; if (count == -1) count = 1024; if (!have_addr) { frame = (struct amd64_frame *)BP_REGS(&ddb_regs); if (frame == NULL) frame = (struct amd64_frame *)(SP_REGS(&ddb_regs) - 8); callpc = PC_REGS(&ddb_regs); } else { /* * Look for something that might be a frame pointer, just as * a convenience. */ frame = (struct amd64_frame *)addr; for (i = 0; i < 4096; i += 8) { struct amd64_frame *check; check = (struct amd64_frame *)db_get_value((long)((char *)&frame->f_frame + i), 8, FALSE); if ((char *)check - (char *)frame >= 0 && (char *)check - (char *)frame < 4096 ) { break; } db_printf("%p does not look like a stack frame, skipping\n", (char *)&frame->f_frame + i); } if (i == 4096) { db_printf("Unable to find anything that looks like a stack frame\n"); return; } frame = (void *)((char *)frame + i); db_printf("Trace beginning at frame %p\n", frame); callpc = (db_addr_t)db_get_value((long)&frame->f_retaddr, 8, FALSE); } first = TRUE; while (count--) { struct amd64_frame *actframe; int narg; const char * name; db_expr_t offset; c_db_sym_t sym; #define MAXNARG 16 char *argnames[MAXNARG], **argnp = NULL; sym = db_search_symbol(callpc, DB_STGY_ANY, &offset); db_symbol_values(sym, &name, NULL); dl_symbol_values(callpc, &name); /* * Attempt to determine a (possibly fake) frame that gives * the caller's pc. It may differ from `frame' if the * current function never sets up a standard frame or hasn't * set one up yet or has just discarded one. The last two * cases can be guessed fairly reliably for code generated * by gcc. The first case is too much trouble to handle in * general because the amount of junk on the stack depends * on the pc (the special handling of "calltrap", etc. in * db_nextframe() works because the `next' pc is special). */ actframe = frame; if (first) { if (!have_addr) { int instr; instr = db_get_value(callpc, 4, FALSE); if ((instr & 0xffffffff) == 0xe5894855) { /* pushq %rbp; movq %rsp, %rbp */ actframe = (struct amd64_frame *) (SP_REGS(&ddb_regs) - 8); } else if ((instr & 0xffffff) == 0xe58948) { /* movq %rsp, %rbp */ actframe = (struct amd64_frame *) SP_REGS(&ddb_regs); if (ddb_regs.tf_rbp == 0) { /* Fake caller's frame better. */ frame = actframe; } } else if ((instr & 0xff) == 0xc3) { /* ret */ actframe = (struct amd64_frame *) (SP_REGS(&ddb_regs) - 8); } else if (offset == 0) { /* Probably a symbol in assembler code. */ actframe = (struct amd64_frame *) (SP_REGS(&ddb_regs) - 8); } } else if (name != NULL && strcmp(name, "fork_trampoline") == 0) { /* * Don't try to walk back on a stack for a * process that hasn't actually been run yet. */ db_print_stack_entry(name, 0, 0, 0, callpc); break; } first = FALSE; } argp = &actframe->f_arg0; narg = MAXNARG; if (sym != NULL && db_sym_numargs(sym, &narg, argnames)) { argnp = argnames; } else { narg = db_numargs(frame); } db_print_stack_entry(name, narg, argnp, argp, callpc); if (actframe != frame) { /* `frame' belongs to caller. */ callpc = (db_addr_t) db_get_value((long)&actframe->f_retaddr, 8, FALSE); continue; } db_nextframe(&frame, &callpc); if (frame == 0) break; } } void print_backtrace(void) { register_t rbp; __asm __volatile("movq %%rbp, %0" : "=r" (rbp)); db_stack_trace_cmd(rbp, 1, -1, NULL); } #define DB_DRX_FUNC(reg) \ int \ db_ ## reg (struct db_variable *vp, db_expr_t *valuep, int op) \ { \ if (op == DB_VAR_GET) \ *valuep = r ## reg (); \ else \ load_ ## reg (*valuep); \ \ return(0); \ } DB_DRX_FUNC(dr0) DB_DRX_FUNC(dr1) DB_DRX_FUNC(dr2) DB_DRX_FUNC(dr3) DB_DRX_FUNC(dr4) DB_DRX_FUNC(dr5) DB_DRX_FUNC(dr6) DB_DRX_FUNC(dr7) static int kamd64_set_watch(int watchnum, unsigned int watchaddr, int size, int access, struct dbreg *d) { int i; unsigned int mask; if (watchnum == -1) { for (i = 0, mask = 0x3; i < 4; i++, mask <<= 2) if ((d->dr[7] & mask) == 0) break; if (i < 4) watchnum = i; else return(-1); } switch (access) { case DBREG_DR7_EXEC: size = 1; /* size must be 1 for an execution breakpoint */ /* fall through */ case DBREG_DR7_WRONLY: case DBREG_DR7_RDWR: break; default: return(-1); } /* * we can watch a 1, 2, 4, or 8 byte sized location */ switch (size) { case 1: mask = 0x00; break; case 2: mask = 0x01 << 2; break; case 4: mask = 0x03 << 2; case 8: mask = 0x02 << 2; break; default: return(-1); } mask |= access; /* clear the bits we are about to affect */ d->dr[7] &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16))); /* set drN register to the address, N=watchnum */ DBREG_DRX(d, watchnum) = watchaddr; /* enable the watchpoint */ d->dr[7] |= (0x2 << (watchnum * 2)) | (mask << (watchnum * 4 + 16)); return(watchnum); } int kamd64_clr_watch(int watchnum, struct dbreg *d) { if (watchnum < 0 || watchnum >= 4) return(-1); d->dr[7] &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16))); DBREG_DRX(d, watchnum) = 0; return(0); } int db_md_set_watchpoint(db_expr_t addr, db_expr_t size) { int avail, wsize; int i; struct dbreg d; fill_dbregs(NULL, &d); avail = 0; for (i = 0; i < 4; i++) { if ((d.dr[7] & (3 << (i * 2))) == 0) avail++; } if (avail * 8 < size) return(-1); for (i=0; i < 4 && (size != 0); i++) { if ((d.dr[7] & (3 << (i * 2))) == 0) { if (size >= 8 || (avail == 1 && size > 4)) wsize = 8; else if (size > 2) wsize = 4; else wsize = size; if (wsize == 3) wsize++; kamd64_set_watch(i, addr, wsize, DBREG_DR7_WRONLY, &d); addr += wsize; size -= wsize; } } set_dbregs(NULL, &d); return(0); } int db_md_clr_watchpoint(db_expr_t addr, db_expr_t size) { struct dbreg d; int i; fill_dbregs(NULL, &d); for(i = 0; i < 4; i++) { if (d.dr[7] & (3 << (i * 2))) { if ((DBREG_DRX((&d), i) >= addr) && (DBREG_DRX((&d), i) < addr + size)) kamd64_clr_watch(i, &d); } } set_dbregs(NULL, &d); return(0); } static char * watchtype_str(int type) { switch (type) { case DBREG_DR7_EXEC: return "execute"; case DBREG_DR7_RDWR: return "read/write"; case DBREG_DR7_WRONLY: return "write"; default: return "invalid"; } } void db_md_list_watchpoints(void) { int i; struct dbreg d; fill_dbregs(NULL, &d); db_printf("\nhardware watchpoints:\n"); db_printf(" watch status type len address\n" " ----- -------- ---------- --- ----------\n"); for (i = 0; i < 4; i++) { if (d.dr[7] & (0x03 << (i * 2))) { unsigned type, len; type = (d.dr[7] >> (16 + (i * 4))) & 3; len = (d.dr[7] >> (16 + (i * 4) + 2)) & 3; db_printf(" %-5d %-8s %10s %3d 0x%08lx\n", i, "enabled", watchtype_str(type), len + 1, DBREG_DRX((&d), i)); } else { db_printf(" %-5d disabled\n", i); } } db_printf("\ndebug register values:\n"); for (i = 0; i < 8; i++) db_printf(" dr%d 0x%08lx\n", i, DBREG_DRX((&d),i)); db_printf("\n"); } /* * See if dladdr() can get the symbol name via the standard dynamic loader. */ static void dl_symbol_values(long callpc, const char **name) { Dl_info info; /* if (*name == NULL) { if (dladdr((const void *)callpc, &info) != 0) { if (info.dli_saddr <= (const void *)callpc) *name = info.dli_sname; } } */ }