xref: /onnv-gate/usr/src/uts/sun4u/os/mach_trap.c (revision 0:68f95e015346)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/trap.h>
#include <sys/machtrap.h>
#include <sys/machsystm.h>
#include <sys/cpu_module.h>
#include <sys/panic.h>
#include <sys/uadmin.h>
#include <sys/kobj.h>
#include <sys/contract/process_impl.h>
#include <vm/hat_sfmmu.h>
#include <sys/reboot.h>

#ifdef  TRAPTRACE
#include <sys/traptrace.h>
#endif

void showregs(unsigned, struct regs *, caddr_t, uint_t);

extern int tudebug;

void
mmu_print_sfsr(uint_t sfsr)
{
	printf("MMU sfsr=%x:", sfsr);
	switch (X_FAULT_TYPE(sfsr)) {
	case FT_NONE:
		printf(" No error");
		break;
	case FT_PRIV:
		printf(" Privilege violation");
		break;
	case FT_SPEC_LD:
		printf(" Speculative load on E-bit page");
		break;
	case FT_ATOMIC_NC:
		printf(" Atomic to uncacheable page");
		break;
	case FT_ILL_ALT:
		printf(" Illegal lda or sta");
		break;
	case FT_NFO:
		printf(" Normal access to NFO page");
		break;
	case FT_RANGE:
		printf(" Data or instruction address out of range");
		break;
	case FT_RANGE_REG:
		printf(" Jump to register out of range");
		break;
	default:
		printf(" Unknown error");
		break;
	}
	if (sfsr) {
		printf(" on ASI 0x%x E %d CID %d PRIV %d W %d OW %d FV %d",
			(sfsr & SFSR_ASI) >> SFSR_ASI_SHIFT,
			(sfsr & SFSR_E) != 0,
			(sfsr & SFSR_CTX) >> SFSR_CT_SHIFT,
			(sfsr & SFSR_PR) != 0,
			(sfsr & SFSR_W) != 0,
			(sfsr & SFSR_OW) != 0,
			(sfsr & SFSR_FV) != 0);
	}
	printf("\n");
}


/*
 * Handle an asynchronous hardware error, i.e. an E-$ parity error.
 * The policy is currently to send a hardware error contract event to
 * the process's process contract and to kill the process.  Eventually
 * we may want to instead send a special signal whose default
 * disposition is to generate the contract event.
 */
void
trap_async_hwerr(void)
{
	k_siginfo_t si;
	proc_t *p = ttoproc(curthread);

	errorq_drain(ue_queue); /* flush pending async error messages */

	contract_process_hwerr(p->p_ct_process, p);

	bzero(&si, sizeof (k_siginfo_t));
	si.si_signo = SIGKILL;
	si.si_code = SI_NOINFO;
	trapsig(&si, 1);
}

/*
 * Handle bus error and bus timeout for a user process by sending SIGBUS
 * The type is either ASYNC_BERR or ASYNC_BTO.
 */
void
trap_async_berr_bto(int type, struct regs *rp)
{
	k_siginfo_t si;

	errorq_drain(ue_queue); /* flush pending async error messages */
	bzero(&si, sizeof (k_siginfo_t));

	si.si_signo = SIGBUS;
	si.si_code = (type == ASYNC_BERR ? BUS_OBJERR : BUS_ADRERR);
	si.si_addr = (caddr_t)rp->r_pc; /* AFAR unavailable - future RFE */
	si.si_errno = ENXIO;

	trapsig(&si, 1);
}

#ifdef TRAPWINDOW
long trap_window[25];
#endif /* TRAPWINDOW */

/*
 * Print out debugging info.
 */
/*ARGSUSED*/
void
showregs(uint_t type, struct regs *rp, caddr_t addr, uint_t mmu_fsr)
{
	int s;

	s = spl7();
	type &= ~T_USER;
	printf("%s: ", u.u_comm);

	switch (type) {
	case T_SYS_RTT_ALIGN:
	case T_ALIGNMENT:
		printf("alignment error:\n");
		break;
	case T_INSTR_EXCEPTION:
		printf("text access exception:\n");
		break;
	case T_DATA_EXCEPTION:
		printf("data access exception:\n");
		break;
	case T_PRIV_INSTR:
		printf("privileged instruction fault:\n");
		break;
	case T_UNIMP_INSTR:
		printf("illegal instruction fault:\n");
		break;
	case T_IDIV0:
		printf("integer divide zero trap:\n");
		break;
	case T_DIV0:
		printf("zero divide trap:\n");
		break;
	case T_INT_OVERFLOW:
		printf("integer overflow:\n");
		break;
	case T_BREAKPOINT:
		printf("breakpoint trap:\n");
		break;
	case T_TAG_OVERFLOW:
		printf("tag overflow:\n");
		break;
	default:
		if (type >= T_SOFTWARE_TRAP && type <= T_ESOFTWARE_TRAP)
			printf("software trap 0x%x\n", type - T_SOFTWARE_TRAP);
		else
			printf("trap type = 0x%x\n", type);
		break;
	}
	if (type == T_DATA_EXCEPTION || type == T_INSTR_EXCEPTION) {
		mmu_print_sfsr(mmu_fsr);
	} else if (addr) {
		printf("addr=0x%p\n", (void *)addr);
	}

	printf("pid=%d, pc=0x%lx, sp=0x%llx, tstate=0x%llx, context=0x%x\n",
	    (ttoproc(curthread) && ttoproc(curthread)->p_pidp) ?
	    (ttoproc(curthread)->p_pid) : 0, rp->r_pc, rp->r_sp,
	    rp->r_tstate, sfmmu_getctx_sec());
	if (USERMODE(rp->r_tstate)) {
		printf("o0-o7: %llx, %llx, %llx, %llx, %llx, %llx, "
		    "%llx, %llx\n", rp->r_o0, rp->r_o1, rp->r_o2, rp->r_o3,
		    rp->r_o4, rp->r_o5, rp->r_o6, rp->r_o7);
	}
	printf("g1-g7: %llx, %llx, %llx, %llx, %llx, %llx, %llx\n",
	    rp->r_g1, rp->r_g2, rp->r_g3,
	    rp->r_g4, rp->r_g5, rp->r_g6, rp->r_g7);

#ifdef TRAPWINDOW
	printf("trap_window: wim=%x\n", trap_window[24]);
	printf("o0-o7: %x, %x, %x, %x, %x, %x, %x, %x\n",
	    trap_window[0], trap_window[1], trap_window[2], trap_window[3],
	    trap_window[4], trap_window[5], trap_window[6], trap_window[7]);
	printf("l0-l7: %x, %x, %x, %x, %x, %x, %x, %x\n",
	    trap_window[8], trap_window[9], trap_window[10], trap_window[11],
	    trap_window[12], trap_window[13], trap_window[14], trap_window[15]);
	printf("i0-i7: %x, %x, %x, %x, %x, %x, %x, %x\n",
	    trap_window[16], trap_window[17], trap_window[18], trap_window[19],
	    trap_window[20], trap_window[21], trap_window[22], trap_window[23]);
#endif /* TRAPWINDOW */
	if (tudebug > 1 && (boothowto & RB_DEBUG)) {
		debug_enter((char *)NULL);
	}
	splx(s);
}

static void
ptl1_showtrap(ptl1_state_t *pstate)
{
	ptl1_regs_t *rp = &pstate->ptl1_regs;
	short i, j, maxtl = rp->ptl1_trap_regs[0].ptl1_tl;

	printf("%%tl %%tpc              %%tnpc             %%tstate"
	    "           %%tt\n");

	for (i = maxtl - 1; i >= 0; i--) {
		ptl1_trapregs_t *ptp = &rp->ptl1_trap_regs[i];
		uint64_t tstate = ptp->ptl1_tstate;
		uint32_t ccr, asi, cwp, pstate;

		cwp = (tstate >> TSTATE_CWP_SHIFT) & TSTATE_CWP_MASK;
		pstate = (tstate >> TSTATE_PSTATE_SHIFT) & TSTATE_PSTATE_MASK;
		asi = (tstate >> TSTATE_ASI_SHIFT) & TSTATE_ASI_MASK;
		ccr = (tstate >> TSTATE_CCR_SHIFT) & TSTATE_CCR_MASK;

		printf(" %d  %016" PRIx64 "  %016" PRIx64 "  %010" PRIx64
		    "        %03x\n", ptp->ptl1_tl, ptp->ptl1_tpc,
		    ptp->ptl1_tnpc, tstate, ptp->ptl1_tt);
		printf("    %%ccr: %02x  %%asi: %02x  %%cwp: %x  "
		    "%%pstate: %b\n", ccr, asi, cwp, pstate, PSTATE_BITS);
	}

	printf("%%g0-3: %016x %016" PRIx64 " %016" PRIx64 " %016"
	    PRIx64 "\n", 0, rp->ptl1_g1, rp->ptl1_g2, rp->ptl1_g3);
	printf("%%g4-7: %016" PRIx64 " %016" PRIx64 " %016" PRIx64 " %016"
	    PRIx64 "\n", rp->ptl1_g4, rp->ptl1_g5, rp->ptl1_g6, rp->ptl1_g7);

	i = rp->ptl1_cwp;
	j = rp->ptl1_canrestore;
	for (; j >= 0; i--, j--) {
		struct rwindow *wp;
		ulong_t off;
		char *sym;

		if (i < 0)
			i += MAXWIN;

		wp = &rp->ptl1_rwindow[i];

		if ((sym = kobj_getsymname(wp->rw_in[7], &off)) != NULL) {
			printf("Register window %d, caller %s+%lx\n",
			    i, sym, off);
		} else {
			printf("Register window %d, caller %lx\n",
			    i, wp->rw_in[7]);
		}

		if (i == rp->ptl1_cwp) {
			struct rwindow *nwp;

			if (i == MAXWIN - 1)
				nwp = &rp->ptl1_rwindow[0];
			else
				nwp = &rp->ptl1_rwindow[i+1];
			printf("%%o0-3: %016lx %016lx %016lx %016lx\n"
			    "%%o4-7: %016lx %016lx %016lx %016lx\n",
			    nwp->rw_in[0], nwp->rw_in[1], nwp->rw_in[2],
			    nwp->rw_in[3], nwp->rw_in[4], nwp->rw_in[5],
			    nwp->rw_in[6], nwp->rw_in[7]);
		}
		printf("%%l0-3: %016lx %016lx %016lx %016lx\n"
		    "%%l4-7: %016lx %016lx %016lx %016lx\n",
		    wp->rw_local[0], wp->rw_local[1], wp->rw_local[2],
		    wp->rw_local[3], wp->rw_local[4], wp->rw_local[5],
		    wp->rw_local[6], wp->rw_local[7]);

		printf("%%i0-3: %016lx %016lx %016lx %016lx\n"
		    "%%i4-7: %016lx %016lx %016lx %016lx\n",
		    wp->rw_in[0], wp->rw_in[1], wp->rw_in[2], wp->rw_in[3],
		    wp->rw_in[4], wp->rw_in[5], wp->rw_in[6], wp->rw_in[7]);
	}
}

void
panic_showtrap(struct trap_info *tip)
{
	ptl1_state_t *pstate = &CPU->cpu_m.ptl1_state;
	/*
	 * If ptl1_panic() was called, print out the information
	 * saved in the ptl1_state struture.
	 */
	if (pstate->ptl1_entry_count) {
		ptl1_showtrap(pstate);
		return;
	}

	showregs(tip->trap_type, tip->trap_regs, tip->trap_addr,
	    tip->trap_mmu_fsr);
}

static void
ptl1_savetrap(panic_data_t *pdp, ptl1_state_t *pstate)
{
	ptl1_regs_t *rp = &pstate->ptl1_regs;
	short i, maxtl = rp->ptl1_trap_regs[0].ptl1_tl;
	panic_nv_t *pnv = PANICNVGET(pdp);
	char name[PANICNVNAMELEN];

	for (i = maxtl - 1; i >= 0; i--) {
		ptl1_trapregs_t *ptp = &rp->ptl1_trap_regs[i];

		(void) snprintf(name, sizeof (name), "tl[%d]", i);
		PANICNVADD(pnv, name, ptp->ptl1_tl);
		(void) snprintf(name, sizeof (name), "tt[%d]", i);
		PANICNVADD(pnv, name, ptp->ptl1_tt);
		(void) snprintf(name, sizeof (name), "tpc[%d]", i);
		PANICNVADD(pnv, name, ptp->ptl1_tpc);
		(void) snprintf(name, sizeof (name), "tnpc[%d]", i);
		PANICNVADD(pnv, name, ptp->ptl1_tnpc);
		(void) snprintf(name, sizeof (name), "tstate[%d]", i);
		PANICNVADD(pnv, name, ptp->ptl1_tstate);
	}

	PANICNVSET(pdp, pnv);
}

void
panic_savetrap(panic_data_t *pdp, struct trap_info *tip)
{
	panic_nv_t *pnv;
	ptl1_state_t *pstate = &CPU->cpu_m.ptl1_state;
	/*
	 * If ptl1_panic() was called, save the trap registers
	 * stored in the ptl1_state struture.
	 */
	if (pstate->ptl1_entry_count) {
		ptl1_savetrap(pdp, pstate);
		return;
	}

	panic_saveregs(pdp, tip->trap_regs);
	pnv = PANICNVGET(pdp);

	PANICNVADD(pnv, "sfsr", tip->trap_mmu_fsr);
	PANICNVADD(pnv, "sfar", tip->trap_addr);
	PANICNVADD(pnv, "tt", tip->trap_type);

	PANICNVSET(pdp, pnv);
}