sys/powerpc/powerpc/db_trace.c

   1 /*      $FreeBSD$ */
   2 /*      $NetBSD: db_trace.c,v 1.20 2002/05/13 20:30:09 matt Exp $       */
   3 /*      $OpenBSD: db_trace.c,v 1.3 1997/03/21 02:10:48 niklas Exp $     */
   4
   5 /*-
   6  * Mach Operating System
   7  * Copyright (c) 1992 Carnegie Mellon University
   8  * All Rights Reserved.
   9  *
  10  * Permission to use, copy, modify and distribute this software and its
  11  * documentation is hereby granted, provided that both the copyright
  12  * notice and this permission notice appear in all copies of the
  13  * software, derivative works or modified versions, and any portions
  14  * thereof, and that both notices appear in supporting documentation.
  15  *
  16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  18  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  19  *
  20  * Carnegie Mellon requests users of this software to return to
  21  *
  22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  23  *  School of Computer Science
  24  *  Carnegie Mellon University
  25  *  Pittsburgh PA 15213-3890
  26  *
  27  * any improvements or extensions that they make and grant Carnegie Mellon
  28  * the rights to redistribute these changes.
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/kdb.h>
  34 #include <sys/proc.h>
  35 #include <sys/stack.h>
  36
  37 #include <vm/vm.h>
  38 #include <vm/pmap.h>
  39 #include <vm/vm_extern.h>
  40
  41 #include <machine/db_machdep.h>
  42 #include <machine/pcb.h>
  43 #include <machine/spr.h>
  44 #include <machine/stack.h>
  45 #include <machine/trap.h>
  46
  47 #include <ddb/ddb.h>
  48 #include <ddb/db_access.h>
  49 #include <ddb/db_sym.h>
  50 #include <ddb/db_variables.h>
  51
  52 static db_varfcn_t db_frame;
  53
  54 #define DB_OFFSET(x)    (db_expr_t *)offsetof(struct trapframe, x)
  55
  56 #ifdef __powerpc64__
  57 #define CALLOFFSET      8       /* Include TOC reload slot */
  58 #else
  59 #define CALLOFFSET      4
  60 #endif
  61
  62 struct db_variable db_regs[] = {
  63         { "r0",  DB_OFFSET(fixreg[0]),  db_frame },
  64         { "r1",  DB_OFFSET(fixreg[1]),  db_frame },
  65         { "r2",  DB_OFFSET(fixreg[2]),  db_frame },
  66         { "r3",  DB_OFFSET(fixreg[3]),  db_frame },
  67         { "r4",  DB_OFFSET(fixreg[4]),  db_frame },
  68         { "r5",  DB_OFFSET(fixreg[5]),  db_frame },
  69         { "r6",  DB_OFFSET(fixreg[6]),  db_frame },
  70         { "r7",  DB_OFFSET(fixreg[7]),  db_frame },
  71         { "r8",  DB_OFFSET(fixreg[8]),  db_frame },
  72         { "r9",  DB_OFFSET(fixreg[9]),  db_frame },
  73         { "r10", DB_OFFSET(fixreg[10]), db_frame },
  74         { "r11", DB_OFFSET(fixreg[11]), db_frame },
  75         { "r12", DB_OFFSET(fixreg[12]), db_frame },
  76         { "r13", DB_OFFSET(fixreg[13]), db_frame },
  77         { "r14", DB_OFFSET(fixreg[14]), db_frame },
  78         { "r15", DB_OFFSET(fixreg[15]), db_frame },
  79         { "r16", DB_OFFSET(fixreg[16]), db_frame },
  80         { "r17", DB_OFFSET(fixreg[17]), db_frame },
  81         { "r18", DB_OFFSET(fixreg[18]), db_frame },
  82         { "r19", DB_OFFSET(fixreg[19]), db_frame },
  83         { "r20", DB_OFFSET(fixreg[20]), db_frame },
  84         { "r21", DB_OFFSET(fixreg[21]), db_frame },
  85         { "r22", DB_OFFSET(fixreg[22]), db_frame },
  86         { "r23", DB_OFFSET(fixreg[23]), db_frame },
  87         { "r24", DB_OFFSET(fixreg[24]), db_frame },
  88         { "r25", DB_OFFSET(fixreg[25]), db_frame },
  89         { "r26", DB_OFFSET(fixreg[26]), db_frame },
  90         { "r27", DB_OFFSET(fixreg[27]), db_frame },
  91         { "r28", DB_OFFSET(fixreg[28]), db_frame },
  92         { "r29", DB_OFFSET(fixreg[29]), db_frame },
  93         { "r30", DB_OFFSET(fixreg[30]), db_frame },
  94         { "r31", DB_OFFSET(fixreg[31]), db_frame },
  95         { "srr0", DB_OFFSET(srr0),      db_frame },
  96         { "srr1", DB_OFFSET(srr1),      db_frame },
  97         { "lr",  DB_OFFSET(lr),         db_frame },
  98         { "ctr", DB_OFFSET(ctr),        db_frame },
  99         { "cr",  DB_OFFSET(cr),         db_frame },
 100         { "xer", DB_OFFSET(xer),        db_frame },
 101         { "dar", DB_OFFSET(dar),        db_frame },
 102 #ifdef AIM
 103         { "dsisr", DB_OFFSET(cpu.aim.dsisr),    db_frame },
 104 #endif
 105 #if defined(BOOKE)
 106         { "esr", DB_OFFSET(cpu.booke.esr),      db_frame },
 107 #endif
 108 };
 109 struct db_variable *db_eregs = db_regs + nitems(db_regs);
 110
 111 /*
 112  * register variable handling
 113  */
 114 static int
 115 db_frame(struct db_variable *vp, db_expr_t *valuep, int op)
 116 {
 117         register_t *reg;
 118
 119         if (kdb_frame == NULL)
 120                 return (0);
 121         reg = (register_t*)((uintptr_t)kdb_frame + (uintptr_t)vp->valuep);
 122         if (op == DB_VAR_GET)
 123                 *valuep = *reg;
 124         else
 125                 *reg = *valuep;
 126         return (1);
 127 }
 128
 129 /*
 130  *      Frame tracing.
 131  */
 132 static int
 133 db_backtrace(struct thread *td, db_addr_t fp, int count)
 134 {
 135         db_addr_t stackframe, lr, *args;
 136         boolean_t kernel_only = TRUE;
 137         boolean_t full = FALSE;
 138
 139 #if 0
 140         {
 141                 register char *cp = modif;
 142                 register char c;
 143
 144                 while ((c = *cp++) != 0) {
 145                         if (c == 't')
 146                                 trace_thread = TRUE;
 147                         if (c == 'u')
 148                                 kernel_only = FALSE;
 149                         if (c == 'f')
 150                                 full = TRUE;
 151                 }
 152         }
 153 #endif
 154
 155         stackframe = fp;
 156
 157         while (!db_pager_quit) {
 158                 if (stackframe < PAGE_SIZE)
 159                         break;
 160
 161                 /*
 162                  * Locate the next frame by grabbing the backchain ptr
 163                  * from frame[0]
 164                  */
 165                 stackframe = *(db_addr_t *)stackframe;
 166
 167         next_frame:
 168             #ifdef __powerpc64__
 169                 /* The saved arg values start at frame[6] */
 170                 args = (db_addr_t *)(stackframe + 48);
 171             #else
 172                 /* The saved arg values start at frame[2] */
 173                 args = (db_addr_t *)(stackframe + 8);
 174             #endif
 175
 176                 if (stackframe < PAGE_SIZE)
 177                         break;
 178
 179                 if (count-- == 0)
 180                         break;
 181
 182                 /*
 183                  * Extract link register from frame and subtract
 184                  * 4 to convert into calling address (as opposed to
 185                  * return address)
 186                  */
 187             #ifdef __powerpc64__
 188                 lr = *(db_addr_t *)(stackframe + 16) - 4;
 189             #else
 190                 lr = *(db_addr_t *)(stackframe + 4) - 4;
 191             #endif
 192                 if ((lr & 3) || (lr < 0x100)) {
 193                         db_printf("saved LR(0x%zx) is invalid.", lr);
 194                         break;
 195                 }
 196
 197                 #ifdef __powerpc64__
 198                 db_printf("0x%016lx: ", stackframe);
 199                 #else
 200                 db_printf("0x%08x: ", stackframe);
 201                 #endif
 202
 203                 /*
 204                  * The trap code labels the return addresses from the
 205                  * call to C code as 'trapexit' and 'asttrapexit. Use this
 206                  * to determine if the callframe has to traverse a saved
 207                  * trap context
 208                  */
 209                 if ((lr + CALLOFFSET == (db_addr_t) &trapexit) ||
 210                     (lr + CALLOFFSET == (db_addr_t) &asttrapexit)) {
 211                         const char *trapstr;
 212                         struct trapframe *tf = (struct trapframe *)(args);
 213                         db_printf("%s ", tf->srr1 & PSL_PR ? "user" : "kernel");
 214                         switch (tf->exc) {
 215                         case EXC_DSI:
 216                                 /* XXX take advantage of the union. */
 217 #ifdef BOOKE
 218                                 db_printf("DSI %s trap @ %#zx by ",
 219                                     (tf->cpu.booke.esr & ESR_ST) ? "write"
 220                                     : "read", tf->dar);
 221 #else
 222                                 db_printf("DSI %s trap @ %#zx by ",
 223                                     (tf->cpu.aim.dsisr & DSISR_STORE) ? "write"
 224                                     : "read", tf->dar);
 225 #endif
 226                                 goto print_trap;
 227                         case EXC_ALI:
 228                                 db_printf("ALI trap @ %#zx (xSR %#x) ",
 229                                     tf->dar, (uint32_t)tf->cpu.aim.dsisr);
 230                                 goto print_trap;
 231 #ifdef __powerpc64__
 232                         case EXC_DSE:
 233                                 db_printf("DSE trap @ %#zx by ", tf->dar);
 234                                 goto print_trap;
 235                         case EXC_ISE:
 236                                 db_printf("ISE trap @ %#zx by ", tf->srr0);
 237                                 goto print_trap;
 238 #endif
 239                         case EXC_ISI: trapstr = "ISI"; break;
 240                         case EXC_PGM: trapstr = "PGM"; break;
 241                         case EXC_SC: trapstr = "SC"; break;
 242                         case EXC_EXI: trapstr = "EXI"; break;
 243                         case EXC_MCHK: trapstr = "MCHK"; break;
 244                         case EXC_VEC: trapstr = "VEC"; break;
 245 #if !defined(BOOKE)
 246                         case EXC_FPA: trapstr = "FPA"; break;
 247                         case EXC_BPT: trapstr = "BPT"; break;
 248                         case EXC_TRC: trapstr = "TRC"; break;
 249                         case EXC_RUNMODETRC: trapstr = "RUNMODETRC"; break;
 250                         case EXC_SMI: trapstr = "SMI"; break;
 251                         case EXC_RST: trapstr = "RST"; break;
 252 #endif
 253                         case EXC_FPU: trapstr = "FPU"; break;
 254                         case EXC_DECR: trapstr = "DECR"; break;
 255                         case EXC_PERF: trapstr = "PERF"; break;
 256                         case EXC_VSX: trapstr = "VSX"; break;
 257                         case EXC_SOFT_PATCH: trapstr = "SOFT_PATCH"; break;
 258                         default: trapstr = NULL; break;
 259                         }
 260                         if (trapstr != NULL) {
 261                                 db_printf("%s trap by ", trapstr);
 262                         } else {
 263                                 db_printf("trap %#zx by ", tf->exc);
 264                         }
 265
 266                    print_trap:
 267                         lr = (db_addr_t) tf->srr0;
 268                         db_printsym(lr, DB_STGY_ANY);
 269                         db_printf(": srr1=%#zx\n", tf->srr1);
 270                         db_printf("%-10s  r1=%#zx cr=%#x xer=%#x ctr=%#zx",
 271                             "", tf->fixreg[1], (uint32_t)tf->cr,
 272                             (uint32_t)tf->xer, tf->ctr);
 273 #ifdef __powerpc64__
 274                         db_printf(" r2=%#zx", tf->fixreg[2]);
 275 #endif
 276                         if (tf->exc == EXC_DSI)
 277                                 db_printf(" sr=%#x",
 278                                     (uint32_t)tf->cpu.aim.dsisr);
 279                         db_printf(" frame=%p\n", tf);
 280                         stackframe = (db_addr_t) tf->fixreg[1];
 281                         if (kernel_only && (tf->srr1 & PSL_PR))
 282                                 break;
 283                         goto next_frame;
 284                 }
 285
 286                 db_printf("at ");
 287                 db_printsym(lr, DB_STGY_PROC);
 288                 if (full)
 289                         /* Print all the args stored in that stackframe. */
 290                         db_printf("(%zx, %zx, %zx, %zx, %zx, %zx, %zx, %zx)",
 291                                 args[0], args[1], args[2], args[3],
 292                                 args[4], args[5], args[6], args[7]);
 293                 db_printf("\n");
 294         }
 295
 296         return (0);
 297 }
 298
 299 void
 300 db_trace_self(void)
 301 {
 302         db_addr_t addr;
 303
 304         addr = (db_addr_t)__builtin_frame_address(0);
 305         if (addr == 0) {
 306                 db_printf("Null frame address\n");
 307                 return;
 308         }
 309         db_backtrace(curthread, *(db_addr_t *)addr, -1);
 310 }
 311
 312 int
 313 db_trace_thread(struct thread *td, int count)
 314 {
 315         struct pcb *ctx;
 316
 317         ctx = kdb_thr_ctx(td);
 318         return (db_backtrace(td, (db_addr_t)ctx->pcb_sp, count));
 319 }