/* $OpenBSD: db_interface.c,v 1.51 2024/11/07 16:02:29 miod Exp $ */ /* * Copyright (c) 1999-2003 Michael Shalayeff * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR OR HIS RELATIVES 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 MIND, 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. */ #undef DDB_DEBUG #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include void kdbprinttrap(int, int); extern char *trap_type[]; extern int trap_types; db_regs_t ddb_regs; struct db_variable db_regs[] = { { "flags", (long *)&ddb_regs.tf_flags, FCN_NULL }, { "r1", (long *)&ddb_regs.tf_r1, FCN_NULL }, { "rp", (long *)&ddb_regs.tf_rp, FCN_NULL }, { "r3", (long *)&ddb_regs.tf_r3, FCN_NULL }, { "r4", (long *)&ddb_regs.tf_r4, FCN_NULL }, { "r5", (long *)&ddb_regs.tf_r5, FCN_NULL }, { "r6", (long *)&ddb_regs.tf_r6, FCN_NULL }, { "r7", (long *)&ddb_regs.tf_r7, FCN_NULL }, { "r8", (long *)&ddb_regs.tf_r8, FCN_NULL }, { "r9", (long *)&ddb_regs.tf_r9, FCN_NULL }, { "r10", (long *)&ddb_regs.tf_r10, FCN_NULL }, { "r11", (long *)&ddb_regs.tf_r11, FCN_NULL }, { "r12", (long *)&ddb_regs.tf_r12, FCN_NULL }, { "r13", (long *)&ddb_regs.tf_r13, FCN_NULL }, { "r14", (long *)&ddb_regs.tf_r14, FCN_NULL }, { "r15", (long *)&ddb_regs.tf_r15, FCN_NULL }, { "r16", (long *)&ddb_regs.tf_r16, FCN_NULL }, { "r17", (long *)&ddb_regs.tf_r17, FCN_NULL }, { "r18", (long *)&ddb_regs.tf_r18, FCN_NULL }, { "r19", (long *)&ddb_regs.tf_t4, FCN_NULL }, { "r20", (long *)&ddb_regs.tf_t3, FCN_NULL }, { "r21", (long *)&ddb_regs.tf_t2, FCN_NULL }, { "r22", (long *)&ddb_regs.tf_t1, FCN_NULL }, { "r23", (long *)&ddb_regs.tf_arg3, FCN_NULL }, { "r24", (long *)&ddb_regs.tf_arg2, FCN_NULL }, { "r25", (long *)&ddb_regs.tf_arg1, FCN_NULL }, { "r26", (long *)&ddb_regs.tf_arg0, FCN_NULL }, { "r27", (long *)&ddb_regs.tf_dp, FCN_NULL }, { "r28", (long *)&ddb_regs.tf_ret0, FCN_NULL }, { "r29", (long *)&ddb_regs.tf_ret1, FCN_NULL }, { "r30", (long *)&ddb_regs.tf_sp, FCN_NULL }, { "r31", (long *)&ddb_regs.tf_r31, FCN_NULL }, { "sar", (long *)&ddb_regs.tf_sar, FCN_NULL }, { "rctr", (long *)&ddb_regs.tf_rctr, FCN_NULL }, { "ccr", (long *)&ddb_regs.tf_ccr, FCN_NULL }, { "eirr", (long *)&ddb_regs.tf_eirr, FCN_NULL }, { "eiem", (long *)&ddb_regs.tf_eiem, FCN_NULL }, { "iir", (long *)&ddb_regs.tf_iir, FCN_NULL }, { "isr", (long *)&ddb_regs.tf_isr, FCN_NULL }, { "ior", (long *)&ddb_regs.tf_ior, FCN_NULL }, { "ipsw", (long *)&ddb_regs.tf_ipsw, FCN_NULL }, { "iisqh", (long *)&ddb_regs.tf_iisq_head, FCN_NULL }, { "iioqh", (long *)&ddb_regs.tf_iioq_head, FCN_NULL }, { "iisqt", (long *)&ddb_regs.tf_iisq_tail, FCN_NULL }, { "iioqt", (long *)&ddb_regs.tf_iioq_tail, FCN_NULL }, { "sr0", (long *)&ddb_regs.tf_sr0, FCN_NULL }, { "sr1", (long *)&ddb_regs.tf_sr1, FCN_NULL }, { "sr2", (long *)&ddb_regs.tf_sr2, FCN_NULL }, { "sr3", (long *)&ddb_regs.tf_sr3, FCN_NULL }, { "sr4", (long *)&ddb_regs.tf_sr4, FCN_NULL }, { "sr5", (long *)&ddb_regs.tf_sr5, FCN_NULL }, { "sr6", (long *)&ddb_regs.tf_sr6, FCN_NULL }, { "sr7", (long *)&ddb_regs.tf_sr7, FCN_NULL }, { "pidr1", (long *)&ddb_regs.tf_pidr1, FCN_NULL }, { "pidr2", (long *)&ddb_regs.tf_pidr2, FCN_NULL }, #ifdef pbably_not_worth_it { "pidr3", (long *)&ddb_regs.tf_pidr3, FCN_NULL }, { "pidr4", (long *)&ddb_regs.tf_pidr4, FCN_NULL }, #endif { "vtop", (long *)&ddb_regs.tf_vtop, FCN_NULL }, { "cr28", (long *)&ddb_regs.tf_cr28, FCN_NULL }, { "cr30", (long *)&ddb_regs.tf_cr30, FCN_NULL }, }; struct db_variable *db_eregs = db_regs + nitems(db_regs); void db_enter(void) { extern int kernelmapped; /* from locore.S */ if (kernelmapped) __asm volatile ("break %0, %1" :: "i" (HPPA_BREAK_KERNEL), "i" (HPPA_BREAK_KGDB)); } void db_read_bytes(vaddr_t addr, size_t size, void *datap) { char *data = datap; register char *src = (char *)addr; while (size--) *data++ = *src++; } void db_write_bytes(vaddr_t addr, size_t size, void *datap) { char *data = datap; register char *dst = (char *)addr; while (size--) *dst++ = *data++; /* unfortunately ddb does not provide any hooks for these */ ficache(HPPA_SID_KERNEL, (vaddr_t)data, size); fdcache(HPPA_SID_KERNEL, (vaddr_t)data, size); } /* * Print trap reason. */ void kdbprinttrap(int type, int code) { type &= ~T_USER; /* just in case */ db_printf("kernel: "); if (type >= trap_types || type < 0) db_printf("type 0x%x", type); else db_printf("%s", trap_type[type]); db_printf(" trap, code=0x%x\n", code); } /* * db_ktrap - field a BPT trap */ int db_ktrap(int type, int code, db_regs_t *regs) { extern label_t *db_recover; int s; switch (type) { case T_IBREAK: case T_DBREAK: case -1: break; default: if (!db_panic) return (0); kdbprinttrap(type, code); if (db_recover != 0) { db_error("Caught exception in DDB; continuing...\n"); /* NOT REACHED */ } } /* XXX Should switch to kdb`s own stack here. */ s = splhigh(); ddb_regs = *regs; db_active++; cnpollc(1); db_trap(type, code); cnpollc(0); db_active--; splx(s); *regs = ddb_regs; return (1); } /* * Validate an address for use as a breakpoint. * Any address is allowed for now. */ int db_valid_breakpoint(vaddr_t addr) { return (1); } void db_stack_trace_print(db_expr_t addr, int have_addr, db_expr_t count, char *modif, int (*pr)(const char *, ...)) { register_t *fp, pc, rp, *argp; Elf_Sym *sym; db_expr_t off; const char *name; int nargs; if (count < 0) count = 65536; if (!have_addr) { fp = (register_t *)ddb_regs.tf_r3; pc = ddb_regs.tf_iioq_head; rp = ddb_regs.tf_rp; } else { fp = (register_t *)addr; pc = 0; rp = ((register_t *)fp)[-5]; } #ifdef DDB_DEBUG (*pr) (">> %p, 0x%x, 0x%x\t", fp, pc, rp); #endif while (fp && count--) { if (USERMODE(pc)) return; sym = db_search_symbol(pc, DB_STGY_ANY, &off); db_symbol_values (sym, &name, NULL); if (name == NULL) (*pr)("%lx(", pc); else (*pr)("%s(", name); /* args */ nargs = 4; /* * XXX first four args are passed on registers, and may not * be stored on stack, dunno how to recover their values yet */ for (argp = &fp[-9]; nargs--; argp--) { (*pr)("%x%s", db_get_value((int)argp, 4, 0), nargs? ",":""); } (*pr)(") at "); db_printsym(pc, DB_STGY_PROC, pr); (*pr)("\n"); /* TODO: print locals */ /* next frame */ pc = rp; rp = fp[-5]; /* if a terminal frame and not a start of a page * then skip the trapframe and the terminal frame */ if (!fp[0]) { struct trapframe *tf; tf = (struct trapframe *)((char *)fp - sizeof(*tf)); if (tf->tf_flags & TFF_SYS) (*pr)("-- syscall #%d(%x, %x, %x, %x, ...)\n", tf->tf_t1, tf->tf_arg0, tf->tf_arg1, tf->tf_arg2, tf->tf_arg3); else (*pr)("-- trap #%d%s\n", tf->tf_flags & 0x3f, (tf->tf_flags & T_USER)? " from user" : ""); if (!(tf->tf_flags & TFF_LAST)) { fp = (register_t *)tf->tf_r3; pc = tf->tf_iioq_head; rp = tf->tf_rp; } else fp = 0; } else fp = (register_t *)fp[0]; #ifdef DDB_DEBUG (*pr) (">> %x, %x, %x\t", fp, pc, rp); #endif } if (count && pc) { db_printsym(pc, DB_STGY_XTRN, pr); (*pr)(":\n"); } } void stacktrace_save_at(struct stacktrace *st, unsigned int skip) { register_t *fp, pc, rp; int i; fp = (register_t *)__builtin_frame_address(0); pc = 0; rp = fp[-5]; st->st_count = 0; for (i = 0; i < STACKTRACE_MAX; i++) { if (skip == 0) st->st_pc[st->st_count++] = rp; else skip--; /* next frame */ pc = rp; if (!fp[0] || USERMODE(pc)) break; rp = fp[-5]; fp = (register_t *)fp[0]; } } void stacktrace_save_utrace(struct stacktrace *st) { st->st_count = 0; }