1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/trap.h> 30 #include <sys/machtrap.h> 31 #include <sys/machsystm.h> 32 #include <sys/cpu_module.h> 33 #include <sys/panic.h> 34 #include <sys/uadmin.h> 35 #include <sys/kobj.h> 36 #include <sys/contract/process_impl.h> 37 #include <vm/hat_sfmmu.h> 38 #include <sys/reboot.h> 39 40 #ifdef TRAPTRACE 41 #include <sys/traptrace.h> 42 #endif 43 44 void showregs(unsigned, struct regs *, caddr_t, uint_t); 45 46 extern int tudebug; 47 48 void 49 mmu_print_sfsr(uint_t sfsr) 50 { 51 printf("MMU sfsr=%x:", sfsr); 52 switch (X_FAULT_TYPE(sfsr)) { 53 case FT_NONE: 54 printf(" No error"); 55 break; 56 case FT_PRIV: 57 printf(" Privilege violation"); 58 break; 59 case FT_SPEC_LD: 60 printf(" Speculative load on E-bit page"); 61 break; 62 case FT_ATOMIC_NC: 63 printf(" Atomic to uncacheable page"); 64 break; 65 case FT_ILL_ALT: 66 printf(" Illegal lda or sta"); 67 break; 68 case FT_NFO: 69 printf(" Normal access to NFO page"); 70 break; 71 case FT_RANGE: 72 printf(" Data or instruction address out of range"); 73 break; 74 case FT_RANGE_REG: 75 printf(" Jump to register out of range"); 76 break; 77 default: 78 printf(" Unknown error"); 79 break; 80 } 81 if (sfsr) { 82 printf(" on ASI 0x%x E %d CID %d PRIV %d W %d OW %d FV %d", 83 (sfsr & SFSR_ASI) >> SFSR_ASI_SHIFT, 84 (sfsr & SFSR_E) != 0, 85 (sfsr & SFSR_CTX) >> SFSR_CT_SHIFT, 86 (sfsr & SFSR_PR) != 0, 87 (sfsr & SFSR_W) != 0, 88 (sfsr & SFSR_OW) != 0, 89 (sfsr & SFSR_FV) != 0); 90 } 91 printf("\n"); 92 } 93 94 95 /* 96 * Handle an asynchronous hardware error, i.e. an E-$ parity error. 97 * The policy is currently to send a hardware error contract event to 98 * the process's process contract and to kill the process. Eventually 99 * we may want to instead send a special signal whose default 100 * disposition is to generate the contract event. 101 */ 102 void 103 trap_async_hwerr(void) 104 { 105 k_siginfo_t si; 106 proc_t *p = ttoproc(curthread); 107 108 errorq_drain(ue_queue); /* flush pending async error messages */ 109 110 contract_process_hwerr(p->p_ct_process, p); 111 112 bzero(&si, sizeof (k_siginfo_t)); 113 si.si_signo = SIGKILL; 114 si.si_code = SI_NOINFO; 115 trapsig(&si, 1); 116 } 117 118 /* 119 * Handle bus error and bus timeout for a user process by sending SIGBUS 120 * The type is either ASYNC_BERR or ASYNC_BTO. 121 */ 122 void 123 trap_async_berr_bto(int type, struct regs *rp) 124 { 125 k_siginfo_t si; 126 127 errorq_drain(ue_queue); /* flush pending async error messages */ 128 bzero(&si, sizeof (k_siginfo_t)); 129 130 si.si_signo = SIGBUS; 131 si.si_code = (type == ASYNC_BERR ? BUS_OBJERR : BUS_ADRERR); 132 si.si_addr = (caddr_t)rp->r_pc; /* AFAR unavailable - future RFE */ 133 si.si_errno = ENXIO; 134 135 trapsig(&si, 1); 136 } 137 138 #ifdef TRAPWINDOW 139 long trap_window[25]; 140 #endif /* TRAPWINDOW */ 141 142 /* 143 * Print out debugging info. 144 */ 145 /*ARGSUSED*/ 146 void 147 showregs(uint_t type, struct regs *rp, caddr_t addr, uint_t mmu_fsr) 148 { 149 int s; 150 151 s = spl7(); 152 type &= ~T_USER; 153 printf("%s: ", u.u_comm); 154 155 switch (type) { 156 case T_SYS_RTT_ALIGN: 157 case T_ALIGNMENT: 158 printf("alignment error:\n"); 159 break; 160 case T_INSTR_EXCEPTION: 161 printf("text access exception:\n"); 162 break; 163 case T_DATA_EXCEPTION: 164 printf("data access exception:\n"); 165 break; 166 case T_PRIV_INSTR: 167 printf("privileged instruction fault:\n"); 168 break; 169 case T_UNIMP_INSTR: 170 printf("illegal instruction fault:\n"); 171 break; 172 case T_IDIV0: 173 printf("integer divide zero trap:\n"); 174 break; 175 case T_DIV0: 176 printf("zero divide trap:\n"); 177 break; 178 case T_INT_OVERFLOW: 179 printf("integer overflow:\n"); 180 break; 181 case T_BREAKPOINT: 182 printf("breakpoint trap:\n"); 183 break; 184 case T_TAG_OVERFLOW: 185 printf("tag overflow:\n"); 186 break; 187 default: 188 if (type >= T_SOFTWARE_TRAP && type <= T_ESOFTWARE_TRAP) 189 printf("software trap 0x%x\n", type - T_SOFTWARE_TRAP); 190 else 191 printf("trap type = 0x%x\n", type); 192 break; 193 } 194 if (type == T_DATA_EXCEPTION || type == T_INSTR_EXCEPTION) { 195 mmu_print_sfsr(mmu_fsr); 196 } else if (addr) { 197 printf("addr=0x%p\n", (void *)addr); 198 } 199 200 printf("pid=%d, pc=0x%lx, sp=0x%llx, tstate=0x%llx, context=0x%x\n", 201 (ttoproc(curthread) && ttoproc(curthread)->p_pidp) ? 202 (ttoproc(curthread)->p_pid) : 0, rp->r_pc, rp->r_sp, 203 rp->r_tstate, sfmmu_getctx_sec()); 204 if (USERMODE(rp->r_tstate)) { 205 printf("o0-o7: %llx, %llx, %llx, %llx, %llx, %llx, " 206 "%llx, %llx\n", rp->r_o0, rp->r_o1, rp->r_o2, rp->r_o3, 207 rp->r_o4, rp->r_o5, rp->r_o6, rp->r_o7); 208 } 209 printf("g1-g7: %llx, %llx, %llx, %llx, %llx, %llx, %llx\n", 210 rp->r_g1, rp->r_g2, rp->r_g3, 211 rp->r_g4, rp->r_g5, rp->r_g6, rp->r_g7); 212 213 #ifdef TRAPWINDOW 214 printf("trap_window: wim=%x\n", trap_window[24]); 215 printf("o0-o7: %x, %x, %x, %x, %x, %x, %x, %x\n", 216 trap_window[0], trap_window[1], trap_window[2], trap_window[3], 217 trap_window[4], trap_window[5], trap_window[6], trap_window[7]); 218 printf("l0-l7: %x, %x, %x, %x, %x, %x, %x, %x\n", 219 trap_window[8], trap_window[9], trap_window[10], trap_window[11], 220 trap_window[12], trap_window[13], trap_window[14], trap_window[15]); 221 printf("i0-i7: %x, %x, %x, %x, %x, %x, %x, %x\n", 222 trap_window[16], trap_window[17], trap_window[18], trap_window[19], 223 trap_window[20], trap_window[21], trap_window[22], trap_window[23]); 224 #endif /* TRAPWINDOW */ 225 if (tudebug > 1 && (boothowto & RB_DEBUG)) { 226 debug_enter((char *)NULL); 227 } 228 splx(s); 229 } 230 231 static void 232 ptl1_showtrap(ptl1_state_t *pstate) 233 { 234 ptl1_regs_t *rp = &pstate->ptl1_regs; 235 short i, j, maxtl = rp->ptl1_trap_regs[0].ptl1_tl; 236 237 printf("%%tl %%tpc %%tnpc %%tstate" 238 " %%tt\n"); 239 240 for (i = maxtl - 1; i >= 0; i--) { 241 ptl1_trapregs_t *ptp = &rp->ptl1_trap_regs[i]; 242 uint64_t tstate = ptp->ptl1_tstate; 243 uint32_t ccr, asi, cwp, pstate; 244 245 cwp = (tstate >> TSTATE_CWP_SHIFT) & TSTATE_CWP_MASK; 246 pstate = (tstate >> TSTATE_PSTATE_SHIFT) & TSTATE_PSTATE_MASK; 247 asi = (tstate >> TSTATE_ASI_SHIFT) & TSTATE_ASI_MASK; 248 ccr = (tstate >> TSTATE_CCR_SHIFT) & TSTATE_CCR_MASK; 249 250 printf(" %d %016" PRIx64 " %016" PRIx64 " %010" PRIx64 251 " %03x\n", ptp->ptl1_tl, ptp->ptl1_tpc, 252 ptp->ptl1_tnpc, tstate, ptp->ptl1_tt); 253 printf(" %%ccr: %02x %%asi: %02x %%cwp: %x " 254 "%%pstate: %b\n", ccr, asi, cwp, pstate, PSTATE_BITS); 255 } 256 257 printf("%%g0-3: %016x %016" PRIx64 " %016" PRIx64 " %016" 258 PRIx64 "\n", 0, rp->ptl1_g1, rp->ptl1_g2, rp->ptl1_g3); 259 printf("%%g4-7: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016" 260 PRIx64 "\n", rp->ptl1_g4, rp->ptl1_g5, rp->ptl1_g6, rp->ptl1_g7); 261 262 i = rp->ptl1_cwp; 263 j = rp->ptl1_canrestore; 264 for (; j >= 0; i--, j--) { 265 struct rwindow *wp; 266 ulong_t off; 267 char *sym; 268 269 if (i < 0) 270 i += MAXWIN; 271 272 wp = &rp->ptl1_rwindow[i]; 273 274 if ((sym = kobj_getsymname(wp->rw_in[7], &off)) != NULL) { 275 printf("Register window %d, caller %s+%lx\n", 276 i, sym, off); 277 } else { 278 printf("Register window %d, caller %lx\n", 279 i, wp->rw_in[7]); 280 } 281 282 if (i == rp->ptl1_cwp) { 283 struct rwindow *nwp; 284 285 if (i == MAXWIN - 1) 286 nwp = &rp->ptl1_rwindow[0]; 287 else 288 nwp = &rp->ptl1_rwindow[i+1]; 289 printf("%%o0-3: %016lx %016lx %016lx %016lx\n" 290 "%%o4-7: %016lx %016lx %016lx %016lx\n", 291 nwp->rw_in[0], nwp->rw_in[1], nwp->rw_in[2], 292 nwp->rw_in[3], nwp->rw_in[4], nwp->rw_in[5], 293 nwp->rw_in[6], nwp->rw_in[7]); 294 } 295 printf("%%l0-3: %016lx %016lx %016lx %016lx\n" 296 "%%l4-7: %016lx %016lx %016lx %016lx\n", 297 wp->rw_local[0], wp->rw_local[1], wp->rw_local[2], 298 wp->rw_local[3], wp->rw_local[4], wp->rw_local[5], 299 wp->rw_local[6], wp->rw_local[7]); 300 301 printf("%%i0-3: %016lx %016lx %016lx %016lx\n" 302 "%%i4-7: %016lx %016lx %016lx %016lx\n", 303 wp->rw_in[0], wp->rw_in[1], wp->rw_in[2], wp->rw_in[3], 304 wp->rw_in[4], wp->rw_in[5], wp->rw_in[6], wp->rw_in[7]); 305 } 306 } 307 308 void 309 panic_showtrap(struct trap_info *tip) 310 { 311 ptl1_state_t *pstate = &CPU->cpu_m.ptl1_state; 312 /* 313 * If ptl1_panic() was called, print out the information 314 * saved in the ptl1_state struture. 315 */ 316 if (pstate->ptl1_entry_count) { 317 ptl1_showtrap(pstate); 318 return; 319 } 320 321 showregs(tip->trap_type, tip->trap_regs, tip->trap_addr, 322 tip->trap_mmu_fsr); 323 } 324 325 static void 326 ptl1_savetrap(panic_data_t *pdp, ptl1_state_t *pstate) 327 { 328 ptl1_regs_t *rp = &pstate->ptl1_regs; 329 short i, maxtl = rp->ptl1_trap_regs[0].ptl1_tl; 330 panic_nv_t *pnv = PANICNVGET(pdp); 331 char name[PANICNVNAMELEN]; 332 333 for (i = maxtl - 1; i >= 0; i--) { 334 ptl1_trapregs_t *ptp = &rp->ptl1_trap_regs[i]; 335 336 (void) snprintf(name, sizeof (name), "tl[%d]", i); 337 PANICNVADD(pnv, name, ptp->ptl1_tl); 338 (void) snprintf(name, sizeof (name), "tt[%d]", i); 339 PANICNVADD(pnv, name, ptp->ptl1_tt); 340 (void) snprintf(name, sizeof (name), "tpc[%d]", i); 341 PANICNVADD(pnv, name, ptp->ptl1_tpc); 342 (void) snprintf(name, sizeof (name), "tnpc[%d]", i); 343 PANICNVADD(pnv, name, ptp->ptl1_tnpc); 344 (void) snprintf(name, sizeof (name), "tstate[%d]", i); 345 PANICNVADD(pnv, name, ptp->ptl1_tstate); 346 } 347 348 PANICNVSET(pdp, pnv); 349 } 350 351 void 352 panic_savetrap(panic_data_t *pdp, struct trap_info *tip) 353 { 354 panic_nv_t *pnv; 355 ptl1_state_t *pstate = &CPU->cpu_m.ptl1_state; 356 /* 357 * If ptl1_panic() was called, save the trap registers 358 * stored in the ptl1_state struture. 359 */ 360 if (pstate->ptl1_entry_count) { 361 ptl1_savetrap(pdp, pstate); 362 return; 363 } 364 365 panic_saveregs(pdp, tip->trap_regs); 366 pnv = PANICNVGET(pdp); 367 368 PANICNVADD(pnv, "sfsr", tip->trap_mmu_fsr); 369 PANICNVADD(pnv, "sfar", tip->trap_addr); 370 PANICNVADD(pnv, "tt", tip->trap_type); 371 372 PANICNVSET(pdp, pnv); 373 } 374