xref: /illumos-gate/usr/src/uts/sun4v/os/error.c (revision b72ed0ff)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5a812d870Sayznaga  * Common Development and Distribution License (the "License").
6a812d870Sayznaga  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
225a5604afSrf  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate #include <sys/types.h>
297c478bd9Sstevel@tonic-gate #include <sys/machsystm.h>
302ae0af4bSep #include <sys/sysmacros.h>
317c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
327c478bd9Sstevel@tonic-gate #include <sys/async.h>
337c478bd9Sstevel@tonic-gate #include <sys/ontrap.h>
347c478bd9Sstevel@tonic-gate #include <sys/ddifm.h>
357c478bd9Sstevel@tonic-gate #include <sys/hypervisor_api.h>
367c478bd9Sstevel@tonic-gate #include <sys/errorq.h>
377c478bd9Sstevel@tonic-gate #include <sys/promif.h>
387c478bd9Sstevel@tonic-gate #include <sys/prom_plat.h>
397c478bd9Sstevel@tonic-gate #include <sys/x_call.h>
407c478bd9Sstevel@tonic-gate #include <sys/error.h>
417c478bd9Sstevel@tonic-gate #include <sys/fm/util.h>
423cac8019Srf #include <sys/ivintr.h>
4344961713Sgirish #include <sys/archsystm.h>
447c478bd9Sstevel@tonic-gate 
457c478bd9Sstevel@tonic-gate #define	MAX_CE_FLTS		10
467c478bd9Sstevel@tonic-gate #define	MAX_ASYNC_FLTS		6
477c478bd9Sstevel@tonic-gate 
487c478bd9Sstevel@tonic-gate errorq_t *ue_queue;			/* queue of uncorrectable errors */
497c478bd9Sstevel@tonic-gate errorq_t *ce_queue;			/* queue of correctable errors */
507c478bd9Sstevel@tonic-gate 
517c478bd9Sstevel@tonic-gate /*
527c478bd9Sstevel@tonic-gate  * Being used by memory test driver.
537c478bd9Sstevel@tonic-gate  * ce_verbose_memory - covers CEs in DIMMs
547c478bd9Sstevel@tonic-gate  * ce_verbose_other - covers "others" (ecache, IO, etc.)
557c478bd9Sstevel@tonic-gate  *
567c478bd9Sstevel@tonic-gate  * If the value is 0, nothing is logged.
577c478bd9Sstevel@tonic-gate  * If the value is 1, the error is logged to the log file, but not console.
587c478bd9Sstevel@tonic-gate  * If the value is 2, the error is logged to the log file and console.
597c478bd9Sstevel@tonic-gate  */
607c478bd9Sstevel@tonic-gate int	ce_verbose_memory = 1;
617c478bd9Sstevel@tonic-gate int	ce_verbose_other = 1;
627c478bd9Sstevel@tonic-gate 
637c478bd9Sstevel@tonic-gate int	ce_show_data = 0;
647c478bd9Sstevel@tonic-gate int	ce_debug = 0;
657c478bd9Sstevel@tonic-gate int	ue_debug = 0;
667c478bd9Sstevel@tonic-gate int	reset_debug = 0;
677c478bd9Sstevel@tonic-gate 
687c478bd9Sstevel@tonic-gate /*
697c478bd9Sstevel@tonic-gate  * Tunables for controlling the handling of asynchronous faults (AFTs). Setting
707c478bd9Sstevel@tonic-gate  * these to non-default values on a non-DEBUG kernel is NOT supported.
717c478bd9Sstevel@tonic-gate  */
727c478bd9Sstevel@tonic-gate int	aft_verbose = 0;	/* log AFT messages > 1 to log only */
737c478bd9Sstevel@tonic-gate int	aft_panic = 0;		/* panic (not reboot) on fatal usermode AFLT */
747c478bd9Sstevel@tonic-gate int	aft_testfatal = 0;	/* force all AFTs to panic immediately */
757c478bd9Sstevel@tonic-gate 
763cac8019Srf /*
773cac8019Srf  * Used for vbsc hostshutdown (power-off buton)
783cac8019Srf  */
793cac8019Srf int	err_shutdown_triggered = 0;	/* only once */
80b0fc0e77Sgovinda uint64_t err_shutdown_inum = 0;	/* used to pull the trigger */
813cac8019Srf 
827c478bd9Sstevel@tonic-gate /*
837c478bd9Sstevel@tonic-gate  * Defined in bus_func.c but initialised in error_init
847c478bd9Sstevel@tonic-gate  */
857c478bd9Sstevel@tonic-gate extern kmutex_t bfd_lock;
867c478bd9Sstevel@tonic-gate 
877c478bd9Sstevel@tonic-gate static uint32_t rq_overflow_count = 0;		/* counter for rq overflow */
887c478bd9Sstevel@tonic-gate 
897c478bd9Sstevel@tonic-gate static void cpu_queue_one_event(errh_async_flt_t *);
907c478bd9Sstevel@tonic-gate static uint32_t count_entries_on_queue(uint64_t, uint64_t, uint32_t);
91db874c57Selowe static void errh_page_retire(errh_async_flt_t *, uchar_t);
927c478bd9Sstevel@tonic-gate static int errh_error_protected(struct regs *, struct async_flt *, int *);
937c478bd9Sstevel@tonic-gate static void errh_rq_full(struct async_flt *);
947c478bd9Sstevel@tonic-gate static void ue_drain(void *, struct async_flt *, errorq_elem_t *);
957c478bd9Sstevel@tonic-gate static void ce_drain(void *, struct async_flt *, errorq_elem_t *);
9644961713Sgirish static void errh_handle_attr(errh_async_flt_t *);
9744961713Sgirish static void errh_handle_asr(errh_async_flt_t *);
987c478bd9Sstevel@tonic-gate 
997c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1007c478bd9Sstevel@tonic-gate void
1017c478bd9Sstevel@tonic-gate process_resumable_error(struct regs *rp, uint32_t head_offset,
1027c478bd9Sstevel@tonic-gate     uint32_t tail_offset)
1037c478bd9Sstevel@tonic-gate {
1047c478bd9Sstevel@tonic-gate 	struct machcpu *mcpup;
1057c478bd9Sstevel@tonic-gate 	struct async_flt *aflt;
1067c478bd9Sstevel@tonic-gate 	errh_async_flt_t errh_flt;
1077c478bd9Sstevel@tonic-gate 	errh_er_t *head_va;
1087c478bd9Sstevel@tonic-gate 
1097c478bd9Sstevel@tonic-gate 	mcpup = &(CPU->cpu_m);
1107c478bd9Sstevel@tonic-gate 
1117c478bd9Sstevel@tonic-gate 	while (head_offset != tail_offset) {
1127c478bd9Sstevel@tonic-gate 		/* kernel buffer starts right after the resumable queue */
1137c478bd9Sstevel@tonic-gate 		head_va = (errh_er_t *)(mcpup->cpu_rq_va + head_offset +
1147c478bd9Sstevel@tonic-gate 		    CPU_RQ_SIZE);
1157c478bd9Sstevel@tonic-gate 		/* Copy the error report to local buffer */
1167c478bd9Sstevel@tonic-gate 		bzero(&errh_flt, sizeof (errh_async_flt_t));
1177c478bd9Sstevel@tonic-gate 		bcopy((char *)head_va, &(errh_flt.errh_er),
1187c478bd9Sstevel@tonic-gate 		    sizeof (errh_er_t));
1197c478bd9Sstevel@tonic-gate 
1207c478bd9Sstevel@tonic-gate 		/* Increment the queue head */
1217c478bd9Sstevel@tonic-gate 		head_offset += Q_ENTRY_SIZE;
1227c478bd9Sstevel@tonic-gate 		/* Wrap around */
1237c478bd9Sstevel@tonic-gate 		head_offset &= (CPU_RQ_SIZE - 1);
1247c478bd9Sstevel@tonic-gate 
1257c478bd9Sstevel@tonic-gate 		/* set error handle to zero so it can hold new error report */
1267c478bd9Sstevel@tonic-gate 		head_va->ehdl = 0;
1277c478bd9Sstevel@tonic-gate 
1287c478bd9Sstevel@tonic-gate 		switch (errh_flt.errh_er.desc) {
1297c478bd9Sstevel@tonic-gate 		case ERRH_DESC_UCOR_RE:
13044961713Sgirish 			/*
13144961713Sgirish 			 * Check error attribute, handle individual error
13244961713Sgirish 			 * if it is needed.
13344961713Sgirish 			 */
13444961713Sgirish 			errh_handle_attr(&errh_flt);
1357c478bd9Sstevel@tonic-gate 			break;
1367c478bd9Sstevel@tonic-gate 
1373cac8019Srf 		case ERRH_DESC_WARN_RE:
1383cac8019Srf 			/*
1393cac8019Srf 			 * Power-off requested, but handle it one time only.
1403cac8019Srf 			 */
1413cac8019Srf 			if (!err_shutdown_triggered) {
1423cac8019Srf 				setsoftint(err_shutdown_inum);
1433cac8019Srf 				++err_shutdown_triggered;
1443cac8019Srf 			}
1453cac8019Srf 			continue;
1463cac8019Srf 
1477c478bd9Sstevel@tonic-gate 		default:
1487c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "Error Descriptor 0x%llx "
1497c478bd9Sstevel@tonic-gate 			    " invalid in resumable error handler",
1507c478bd9Sstevel@tonic-gate 			    (long long) errh_flt.errh_er.desc);
1517c478bd9Sstevel@tonic-gate 			continue;
1527c478bd9Sstevel@tonic-gate 		}
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate 		aflt = (struct async_flt *)&(errh_flt.cmn_asyncflt);
1557c478bd9Sstevel@tonic-gate 		aflt->flt_id = gethrtime();
1567c478bd9Sstevel@tonic-gate 		aflt->flt_bus_id = getprocessorid();
1577c478bd9Sstevel@tonic-gate 		aflt->flt_class = CPU_FAULT;
1587c478bd9Sstevel@tonic-gate 		aflt->flt_prot = AFLT_PROT_NONE;
1597c478bd9Sstevel@tonic-gate 		aflt->flt_priv = (((errh_flt.errh_er.attr & ERRH_MODE_MASK)
1607c478bd9Sstevel@tonic-gate 		    >> ERRH_MODE_SHIFT) == ERRH_MODE_PRIV);
1617c478bd9Sstevel@tonic-gate 
1627c478bd9Sstevel@tonic-gate 		if (errh_flt.errh_er.attr & ERRH_ATTR_CPU)
1637c478bd9Sstevel@tonic-gate 			/* If it is an error on other cpu */
1647c478bd9Sstevel@tonic-gate 			aflt->flt_panic = 1;
1657c478bd9Sstevel@tonic-gate 		else
1667c478bd9Sstevel@tonic-gate 			aflt->flt_panic = 0;
1677c478bd9Sstevel@tonic-gate 
1687c478bd9Sstevel@tonic-gate 		/*
1697c478bd9Sstevel@tonic-gate 		 * Handle resumable queue full case.
1707c478bd9Sstevel@tonic-gate 		 */
1717c478bd9Sstevel@tonic-gate 		if (errh_flt.errh_er.attr & ERRH_ATTR_RQF) {
1727c478bd9Sstevel@tonic-gate 			(void) errh_rq_full(aflt);
1737c478bd9Sstevel@tonic-gate 		}
1747c478bd9Sstevel@tonic-gate 
1757c478bd9Sstevel@tonic-gate 		/*
1767c478bd9Sstevel@tonic-gate 		 * Queue the error on ce or ue queue depend on flt_panic.
1777c478bd9Sstevel@tonic-gate 		 * Even if flt_panic is set, the code still keep processing
1787c478bd9Sstevel@tonic-gate 		 * the rest element on rq until the panic starts.
1797c478bd9Sstevel@tonic-gate 		 */
1807c478bd9Sstevel@tonic-gate 		(void) cpu_queue_one_event(&errh_flt);
1817c478bd9Sstevel@tonic-gate 
1827c478bd9Sstevel@tonic-gate 		/*
1837c478bd9Sstevel@tonic-gate 		 * Panic here if aflt->flt_panic has been set.
1847c478bd9Sstevel@tonic-gate 		 * Enqueued errors will be logged as part of the panic flow.
1857c478bd9Sstevel@tonic-gate 		 */
1867c478bd9Sstevel@tonic-gate 		if (aflt->flt_panic) {
1877c478bd9Sstevel@tonic-gate 			fm_panic("Unrecoverable error on another CPU");
1887c478bd9Sstevel@tonic-gate 		}
1897c478bd9Sstevel@tonic-gate 	}
1907c478bd9Sstevel@tonic-gate }
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate void
193ad559ebfSwh process_nonresumable_error(struct regs *rp, uint64_t flags,
1947c478bd9Sstevel@tonic-gate     uint32_t head_offset, uint32_t tail_offset)
1957c478bd9Sstevel@tonic-gate {
1967c478bd9Sstevel@tonic-gate 	struct machcpu *mcpup;
1977c478bd9Sstevel@tonic-gate 	struct async_flt *aflt;
1987c478bd9Sstevel@tonic-gate 	errh_async_flt_t errh_flt;
1997c478bd9Sstevel@tonic-gate 	errh_er_t *head_va;
2007c478bd9Sstevel@tonic-gate 	int trampolined = 0;
2017c478bd9Sstevel@tonic-gate 	int expected = DDI_FM_ERR_UNEXPECTED;
2027c478bd9Sstevel@tonic-gate 	uint64_t exec_mode;
203ad559ebfSwh 	uint8_t u_spill_fill;
2047c478bd9Sstevel@tonic-gate 
2057c478bd9Sstevel@tonic-gate 	mcpup = &(CPU->cpu_m);
2067c478bd9Sstevel@tonic-gate 
2077c478bd9Sstevel@tonic-gate 	while (head_offset != tail_offset) {
2087c478bd9Sstevel@tonic-gate 		/* kernel buffer starts right after the nonresumable queue */
2097c478bd9Sstevel@tonic-gate 		head_va = (errh_er_t *)(mcpup->cpu_nrq_va + head_offset +
2107c478bd9Sstevel@tonic-gate 		    CPU_NRQ_SIZE);
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate 		/* Copy the error report to local buffer */
2137c478bd9Sstevel@tonic-gate 		bzero(&errh_flt, sizeof (errh_async_flt_t));
2147c478bd9Sstevel@tonic-gate 
2157c478bd9Sstevel@tonic-gate 		bcopy((char *)head_va, &(errh_flt.errh_er),
2167c478bd9Sstevel@tonic-gate 		    sizeof (errh_er_t));
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate 		/* Increment the queue head */
2197c478bd9Sstevel@tonic-gate 		head_offset += Q_ENTRY_SIZE;
2207c478bd9Sstevel@tonic-gate 		/* Wrap around */
2217c478bd9Sstevel@tonic-gate 		head_offset &= (CPU_NRQ_SIZE - 1);
2227c478bd9Sstevel@tonic-gate 
2237c478bd9Sstevel@tonic-gate 		/* set error handle to zero so it can hold new error report */
2247c478bd9Sstevel@tonic-gate 		head_va->ehdl = 0;
2257c478bd9Sstevel@tonic-gate 
2267c478bd9Sstevel@tonic-gate 		aflt = (struct async_flt *)&(errh_flt.cmn_asyncflt);
2277c478bd9Sstevel@tonic-gate 
2287c478bd9Sstevel@tonic-gate 		trampolined = 0;
2297c478bd9Sstevel@tonic-gate 
2307c478bd9Sstevel@tonic-gate 		if (errh_flt.errh_er.attr & ERRH_ATTR_PIO)
2317c478bd9Sstevel@tonic-gate 			aflt->flt_class = BUS_FAULT;
2327c478bd9Sstevel@tonic-gate 		else
2337c478bd9Sstevel@tonic-gate 			aflt->flt_class = CPU_FAULT;
2347c478bd9Sstevel@tonic-gate 
2357c478bd9Sstevel@tonic-gate 		aflt->flt_id = gethrtime();
2367c478bd9Sstevel@tonic-gate 		aflt->flt_bus_id = getprocessorid();
2377c478bd9Sstevel@tonic-gate 		aflt->flt_pc = (caddr_t)rp->r_pc;
2387c478bd9Sstevel@tonic-gate 		exec_mode = (errh_flt.errh_er.attr & ERRH_MODE_MASK)
2397c478bd9Sstevel@tonic-gate 		    >> ERRH_MODE_SHIFT;
2407c478bd9Sstevel@tonic-gate 		aflt->flt_priv = (exec_mode == ERRH_MODE_PRIV ||
2417c478bd9Sstevel@tonic-gate 		    exec_mode == ERRH_MODE_UNKNOWN);
2427c478bd9Sstevel@tonic-gate 		aflt->flt_prot = AFLT_PROT_NONE;
243ad559ebfSwh 		aflt->flt_tl = (uchar_t)(flags & ERRH_TL_MASK);
2447c478bd9Sstevel@tonic-gate 		aflt->flt_panic = ((aflt->flt_tl != 0) ||
2457c478bd9Sstevel@tonic-gate 		    (aft_testfatal != 0));
2467c478bd9Sstevel@tonic-gate 
247ad559ebfSwh 		/*
248ad559ebfSwh 		 * For the first error packet on the queue, check if it
249ad559ebfSwh 		 * happened in user fill/spill trap.
250ad559ebfSwh 		 */
251ad559ebfSwh 		if (flags & ERRH_U_SPILL_FILL) {
252ad559ebfSwh 			u_spill_fill = 1;
253ad559ebfSwh 			/* clear the user fill/spill flag in flags */
254ad559ebfSwh 			flags = (uint64_t)aflt->flt_tl;
255ad559ebfSwh 		} else
256ad559ebfSwh 			u_spill_fill = 0;
257ad559ebfSwh 
2587c478bd9Sstevel@tonic-gate 		switch (errh_flt.errh_er.desc) {
2597c478bd9Sstevel@tonic-gate 		case ERRH_DESC_PR_NRE:
260ad559ebfSwh 			if (u_spill_fill) {
261ad559ebfSwh 				aflt->flt_panic = 0;
262ad559ebfSwh 				break;
263ad559ebfSwh 			}
2647c478bd9Sstevel@tonic-gate 			/*
2657c478bd9Sstevel@tonic-gate 			 * Fall through, precise fault also need to check
2667c478bd9Sstevel@tonic-gate 			 * to see if it was protected.
2677c478bd9Sstevel@tonic-gate 			 */
268ad559ebfSwh 			/*FALLTHRU*/
2697c478bd9Sstevel@tonic-gate 
2707c478bd9Sstevel@tonic-gate 		case ERRH_DESC_DEF_NRE:
2717c478bd9Sstevel@tonic-gate 			/*
2727c478bd9Sstevel@tonic-gate 			 * If the trap occurred in privileged mode at TL=0,
2737c478bd9Sstevel@tonic-gate 			 * we need to check to see if we were executing
2747c478bd9Sstevel@tonic-gate 			 * in kernel under on_trap() or t_lofault
2755a5604afSrf 			 * protection. If so, and if it was a PIO or MEM
2765a5604afSrf 			 * error, then modify the saved registers so that
2775a5604afSrf 			 * we return from the trap to the appropriate
2785a5604afSrf 			 * trampoline routine.
2797c478bd9Sstevel@tonic-gate 			 */
2805a5604afSrf 			if (aflt->flt_priv == 1 && aflt->flt_tl == 0 &&
2815a5604afSrf 			    ((errh_flt.errh_er.attr & ERRH_ATTR_PIO) ||
2825a5604afSrf 			    (errh_flt.errh_er.attr & ERRH_ATTR_MEM))) {
2837c478bd9Sstevel@tonic-gate 				trampolined =
2847c478bd9Sstevel@tonic-gate 				    errh_error_protected(rp, aflt, &expected);
2855a5604afSrf 			}
2867c478bd9Sstevel@tonic-gate 
2877c478bd9Sstevel@tonic-gate 			if (!aflt->flt_priv || aflt->flt_prot ==
2887c478bd9Sstevel@tonic-gate 			    AFLT_PROT_COPY) {
2897c478bd9Sstevel@tonic-gate 				aflt->flt_panic |= aft_panic;
2907c478bd9Sstevel@tonic-gate 			} else if (!trampolined &&
291c4b03495Srf 			    (aflt->flt_class != BUS_FAULT)) {
2927c478bd9Sstevel@tonic-gate 				aflt->flt_panic = 1;
2937c478bd9Sstevel@tonic-gate 			}
2947c478bd9Sstevel@tonic-gate 
29544961713Sgirish 			/*
29644961713Sgirish 			 * Check error attribute, handle individual error
29744961713Sgirish 			 * if it is needed.
29844961713Sgirish 			 */
29944961713Sgirish 			errh_handle_attr(&errh_flt);
30044961713Sgirish 
3017c478bd9Sstevel@tonic-gate 			/*
3027c478bd9Sstevel@tonic-gate 			 * If PIO error, we need to query the bus nexus
3037c478bd9Sstevel@tonic-gate 			 * for fatal errors.
3047c478bd9Sstevel@tonic-gate 			 */
3057c478bd9Sstevel@tonic-gate 			if (aflt->flt_class == BUS_FAULT) {
3067c478bd9Sstevel@tonic-gate 				aflt->flt_addr = errh_flt.errh_er.ra;
3077c478bd9Sstevel@tonic-gate 				errh_cpu_run_bus_error_handlers(aflt,
3087c478bd9Sstevel@tonic-gate 				    expected);
3097c478bd9Sstevel@tonic-gate 			}
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate 			break;
3127c478bd9Sstevel@tonic-gate 
313*b72ed0ffSiskreen 		case ERRH_DESC_USER_DCORE:
314*b72ed0ffSiskreen 			/*
315*b72ed0ffSiskreen 			 * User generated panic. Call panic directly
316*b72ed0ffSiskreen 			 * since there are no FMA e-reports to
317*b72ed0ffSiskreen 			 * display.
318*b72ed0ffSiskreen 			 */
319*b72ed0ffSiskreen 
320*b72ed0ffSiskreen 			panic("Panic - Generated at user request");
321*b72ed0ffSiskreen 
322*b72ed0ffSiskreen 			break;
323*b72ed0ffSiskreen 
3247c478bd9Sstevel@tonic-gate 		default:
3254cacbdcfSwh 			cmn_err(CE_WARN, "Panic - Error Descriptor 0x%llx "
3264cacbdcfSwh 			    " invalid in non-resumable error handler",
3277c478bd9Sstevel@tonic-gate 			    (long long) errh_flt.errh_er.desc);
3284cacbdcfSwh 			aflt->flt_panic = 1;
3294cacbdcfSwh 			break;
3307c478bd9Sstevel@tonic-gate 		}
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 		/*
3337c478bd9Sstevel@tonic-gate 		 * Queue the error report for further processing. If
3347c478bd9Sstevel@tonic-gate 		 * flt_panic is set, code still process other errors
3357c478bd9Sstevel@tonic-gate 		 * in the queue until the panic routine stops the
3367c478bd9Sstevel@tonic-gate 		 * kernel.
3377c478bd9Sstevel@tonic-gate 		 */
3387c478bd9Sstevel@tonic-gate 		(void) cpu_queue_one_event(&errh_flt);
3397c478bd9Sstevel@tonic-gate 
3407c478bd9Sstevel@tonic-gate 		/*
3417c478bd9Sstevel@tonic-gate 		 * Panic here if aflt->flt_panic has been set.
3427c478bd9Sstevel@tonic-gate 		 * Enqueued errors will be logged as part of the panic flow.
3437c478bd9Sstevel@tonic-gate 		 */
3447c478bd9Sstevel@tonic-gate 		if (aflt->flt_panic) {
3457c478bd9Sstevel@tonic-gate 			fm_panic("Unrecoverable hardware error");
3467c478bd9Sstevel@tonic-gate 		}
3477c478bd9Sstevel@tonic-gate 
3487c478bd9Sstevel@tonic-gate 		/*
349db874c57Selowe 		 * Call page_retire() to handle memory errors.
3507c478bd9Sstevel@tonic-gate 		 */
3517c478bd9Sstevel@tonic-gate 		if (errh_flt.errh_er.attr & ERRH_ATTR_MEM)
352db874c57Selowe 			errh_page_retire(&errh_flt, PR_UE);
3537c478bd9Sstevel@tonic-gate 
3547c478bd9Sstevel@tonic-gate 		/*
355ad559ebfSwh 		 * If we queued an error and the it was in user mode, or
356ad559ebfSwh 		 * protected by t_lofault, or user_spill_fill is set, we
3577c478bd9Sstevel@tonic-gate 		 * set AST flag so the queue will be drained before
3587c478bd9Sstevel@tonic-gate 		 * returning to user mode.
3597c478bd9Sstevel@tonic-gate 		 */
360ad559ebfSwh 		if (!aflt->flt_priv || aflt->flt_prot == AFLT_PROT_COPY ||
361ad559ebfSwh 		    u_spill_fill) {
3627c478bd9Sstevel@tonic-gate 			int pcb_flag = 0;
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 			if (aflt->flt_class == CPU_FAULT)
3657c478bd9Sstevel@tonic-gate 				pcb_flag |= ASYNC_HWERR;
3667c478bd9Sstevel@tonic-gate 			else if (aflt->flt_class == BUS_FAULT)
3677c478bd9Sstevel@tonic-gate 				pcb_flag |= ASYNC_BERR;
3687c478bd9Sstevel@tonic-gate 
3697c478bd9Sstevel@tonic-gate 			ttolwp(curthread)->lwp_pcb.pcb_flags |= pcb_flag;
3707c478bd9Sstevel@tonic-gate 			aston(curthread);
3717c478bd9Sstevel@tonic-gate 		}
3727c478bd9Sstevel@tonic-gate 	}
3737c478bd9Sstevel@tonic-gate }
3747c478bd9Sstevel@tonic-gate 
3757c478bd9Sstevel@tonic-gate /*
3767c478bd9Sstevel@tonic-gate  * For PIO errors, this routine calls nexus driver's error
3777c478bd9Sstevel@tonic-gate  * callback routines. If the callback routine returns fatal, and
3787c478bd9Sstevel@tonic-gate  * we are in kernel or unknow mode without any error protection,
3797c478bd9Sstevel@tonic-gate  * we need to turn on the panic flag.
3807c478bd9Sstevel@tonic-gate  */
3817c478bd9Sstevel@tonic-gate void
3827c478bd9Sstevel@tonic-gate errh_cpu_run_bus_error_handlers(struct async_flt *aflt, int expected)
3837c478bd9Sstevel@tonic-gate {
3847c478bd9Sstevel@tonic-gate 	int status;
3857c478bd9Sstevel@tonic-gate 	ddi_fm_error_t de;
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate 	bzero(&de, sizeof (ddi_fm_error_t));
3887c478bd9Sstevel@tonic-gate 
3897c478bd9Sstevel@tonic-gate 	de.fme_version = DDI_FME_VERSION;
3907c478bd9Sstevel@tonic-gate 	de.fme_ena = fm_ena_generate(aflt->flt_id, FM_ENA_FMT1);
3917c478bd9Sstevel@tonic-gate 	de.fme_flag = expected;
3927c478bd9Sstevel@tonic-gate 	de.fme_bus_specific = (void *)aflt->flt_addr;
3937c478bd9Sstevel@tonic-gate 	status = ndi_fm_handler_dispatch(ddi_root_node(), NULL, &de);
3947c478bd9Sstevel@tonic-gate 
3957c478bd9Sstevel@tonic-gate 	/*
3967c478bd9Sstevel@tonic-gate 	 * If error is protected, it will jump to proper routine
3977c478bd9Sstevel@tonic-gate 	 * to handle the handle; if it is in user level, we just
3987c478bd9Sstevel@tonic-gate 	 * kill the user process; if the driver thinks the error is
3997c478bd9Sstevel@tonic-gate 	 * not fatal, we can drive on. If none of above are true,
4007c478bd9Sstevel@tonic-gate 	 * we panic
4017c478bd9Sstevel@tonic-gate 	 */
4027c478bd9Sstevel@tonic-gate 	if ((aflt->flt_prot == AFLT_PROT_NONE) && (aflt->flt_priv == 1) &&
4037c478bd9Sstevel@tonic-gate 	    (status == DDI_FM_FATAL))
4047c478bd9Sstevel@tonic-gate 		aflt->flt_panic = 1;
4057c478bd9Sstevel@tonic-gate }
4067c478bd9Sstevel@tonic-gate 
4077c478bd9Sstevel@tonic-gate /*
4087c478bd9Sstevel@tonic-gate  * This routine checks to see if we are under any error protection when
4097c478bd9Sstevel@tonic-gate  * the error happens. If we are under error protection, we unwind to
4107c478bd9Sstevel@tonic-gate  * the protection and indicate fault.
4117c478bd9Sstevel@tonic-gate  */
4127c478bd9Sstevel@tonic-gate static int
4137c478bd9Sstevel@tonic-gate errh_error_protected(struct regs *rp, struct async_flt *aflt, int *expected)
4147c478bd9Sstevel@tonic-gate {
4157c478bd9Sstevel@tonic-gate 	int trampolined = 0;
4167c478bd9Sstevel@tonic-gate 	ddi_acc_hdl_t *hp;
4177c478bd9Sstevel@tonic-gate 
4187c478bd9Sstevel@tonic-gate 	if (curthread->t_ontrap != NULL) {
4197c478bd9Sstevel@tonic-gate 		on_trap_data_t *otp = curthread->t_ontrap;
4207c478bd9Sstevel@tonic-gate 
4217c478bd9Sstevel@tonic-gate 		if (otp->ot_prot & OT_DATA_EC) {
4227c478bd9Sstevel@tonic-gate 			aflt->flt_prot = AFLT_PROT_EC;
4237c478bd9Sstevel@tonic-gate 			otp->ot_trap |= OT_DATA_EC;
4247c478bd9Sstevel@tonic-gate 			rp->r_pc = otp->ot_trampoline;
4257c478bd9Sstevel@tonic-gate 			rp->r_npc = rp->r_pc +4;
4267c478bd9Sstevel@tonic-gate 			trampolined = 1;
4277c478bd9Sstevel@tonic-gate 		}
4287c478bd9Sstevel@tonic-gate 
4297c478bd9Sstevel@tonic-gate 		if (otp->ot_prot & OT_DATA_ACCESS) {
4307c478bd9Sstevel@tonic-gate 			aflt->flt_prot = AFLT_PROT_ACCESS;
4317c478bd9Sstevel@tonic-gate 			otp->ot_trap |= OT_DATA_ACCESS;
4327c478bd9Sstevel@tonic-gate 			rp->r_pc = otp->ot_trampoline;
4337c478bd9Sstevel@tonic-gate 			rp->r_npc = rp->r_pc + 4;
4347c478bd9Sstevel@tonic-gate 			trampolined = 1;
4357c478bd9Sstevel@tonic-gate 			/*
4367c478bd9Sstevel@tonic-gate 			 * for peek and caut_gets
4377c478bd9Sstevel@tonic-gate 			 * errors are expected
4387c478bd9Sstevel@tonic-gate 			 */
4397c478bd9Sstevel@tonic-gate 			hp = (ddi_acc_hdl_t *)otp->ot_handle;
4407c478bd9Sstevel@tonic-gate 			if (!hp)
4417c478bd9Sstevel@tonic-gate 				*expected = DDI_FM_ERR_PEEK;
4427c478bd9Sstevel@tonic-gate 			else if (hp->ah_acc.devacc_attr_access ==
4437c478bd9Sstevel@tonic-gate 			    DDI_CAUTIOUS_ACC)
4447c478bd9Sstevel@tonic-gate 				*expected = DDI_FM_ERR_EXPECTED;
4457c478bd9Sstevel@tonic-gate 		}
4467c478bd9Sstevel@tonic-gate 	} else if (curthread->t_lofault) {
4477c478bd9Sstevel@tonic-gate 		aflt->flt_prot = AFLT_PROT_COPY;
4487c478bd9Sstevel@tonic-gate 		rp->r_g1 = EFAULT;
4497c478bd9Sstevel@tonic-gate 		rp->r_pc = curthread->t_lofault;
4507c478bd9Sstevel@tonic-gate 		rp->r_npc = rp->r_pc + 4;
4517c478bd9Sstevel@tonic-gate 		trampolined = 1;
4527c478bd9Sstevel@tonic-gate 	}
4537c478bd9Sstevel@tonic-gate 
4547c478bd9Sstevel@tonic-gate 	return (trampolined);
4557c478bd9Sstevel@tonic-gate }
4567c478bd9Sstevel@tonic-gate 
4577c478bd9Sstevel@tonic-gate /*
4587c478bd9Sstevel@tonic-gate  * Queue one event.
4597c478bd9Sstevel@tonic-gate  */
4607c478bd9Sstevel@tonic-gate static void
4617c478bd9Sstevel@tonic-gate cpu_queue_one_event(errh_async_flt_t *errh_fltp)
4627c478bd9Sstevel@tonic-gate {
4637c478bd9Sstevel@tonic-gate 	struct async_flt *aflt = (struct async_flt *)errh_fltp;
4647c478bd9Sstevel@tonic-gate 	errorq_t *eqp;
4657c478bd9Sstevel@tonic-gate 
4667c478bd9Sstevel@tonic-gate 	if (aflt->flt_panic)
4677c478bd9Sstevel@tonic-gate 		eqp = ue_queue;
4687c478bd9Sstevel@tonic-gate 	else
4697c478bd9Sstevel@tonic-gate 		eqp = ce_queue;
4707c478bd9Sstevel@tonic-gate 
4717c478bd9Sstevel@tonic-gate 	errorq_dispatch(eqp, errh_fltp, sizeof (errh_async_flt_t),
4727c478bd9Sstevel@tonic-gate 	    aflt->flt_panic);
4737c478bd9Sstevel@tonic-gate }
4747c478bd9Sstevel@tonic-gate 
4757c478bd9Sstevel@tonic-gate /*
4767c478bd9Sstevel@tonic-gate  * The cpu_async_log_err() function is called by the ce/ue_drain() function to
4777c478bd9Sstevel@tonic-gate  * handle logging for CPU events that are dequeued.  As such, it can be invoked
4787c478bd9Sstevel@tonic-gate  * from softint context, from AST processing in the trap() flow, or from the
4797c478bd9Sstevel@tonic-gate  * panic flow.  We decode the CPU-specific data, and log appropriate messages.
4807c478bd9Sstevel@tonic-gate  */
4817c478bd9Sstevel@tonic-gate void
4827c478bd9Sstevel@tonic-gate cpu_async_log_err(void *flt)
4837c478bd9Sstevel@tonic-gate {
4847c478bd9Sstevel@tonic-gate 	errh_async_flt_t *errh_fltp = (errh_async_flt_t *)flt;
4857c478bd9Sstevel@tonic-gate 	errh_er_t *errh_erp = (errh_er_t *)&errh_fltp->errh_er;
4867c478bd9Sstevel@tonic-gate 
4877c478bd9Sstevel@tonic-gate 	switch (errh_erp->desc) {
4887c478bd9Sstevel@tonic-gate 	case ERRH_DESC_UCOR_RE:
4897c478bd9Sstevel@tonic-gate 		if (errh_erp->attr & ERRH_ATTR_MEM) {
4907c478bd9Sstevel@tonic-gate 			/*
491db874c57Selowe 			 * Turn on the PR_UE flag. The page will be
4927c478bd9Sstevel@tonic-gate 			 * scrubbed when it is freed.
4937c478bd9Sstevel@tonic-gate 			 */
494db874c57Selowe 			errh_page_retire(errh_fltp, PR_UE);
4957c478bd9Sstevel@tonic-gate 		}
4967c478bd9Sstevel@tonic-gate 
4977c478bd9Sstevel@tonic-gate 		break;
4987c478bd9Sstevel@tonic-gate 
4997c478bd9Sstevel@tonic-gate 	case ERRH_DESC_PR_NRE:
5007c478bd9Sstevel@tonic-gate 	case ERRH_DESC_DEF_NRE:
5017c478bd9Sstevel@tonic-gate 		if (errh_erp->attr & ERRH_ATTR_MEM) {
5027c478bd9Sstevel@tonic-gate 			/*
5037c478bd9Sstevel@tonic-gate 			 * For non-resumable memory error, retire
5047c478bd9Sstevel@tonic-gate 			 * the page here.
5057c478bd9Sstevel@tonic-gate 			 */
506db874c57Selowe 			errh_page_retire(errh_fltp, PR_UE);
5073461bce3Swh 
5083461bce3Swh 			/*
5093461bce3Swh 			 * If we are going to panic, scrub the page first
5103461bce3Swh 			 */
5113461bce3Swh 			if (errh_fltp->cmn_asyncflt.flt_panic)
5123461bce3Swh 				mem_scrub(errh_fltp->errh_er.ra,
5133461bce3Swh 				    errh_fltp->errh_er.sz);
5147c478bd9Sstevel@tonic-gate 		}
5157c478bd9Sstevel@tonic-gate 		break;
5167c478bd9Sstevel@tonic-gate 
5177c478bd9Sstevel@tonic-gate 	default:
5187c478bd9Sstevel@tonic-gate 		break;
5197c478bd9Sstevel@tonic-gate 	}
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate 
5227c478bd9Sstevel@tonic-gate /*
5237c478bd9Sstevel@tonic-gate  * Called from ce_drain().
5247c478bd9Sstevel@tonic-gate  */
5257c478bd9Sstevel@tonic-gate void
5267c478bd9Sstevel@tonic-gate cpu_ce_log_err(struct async_flt *aflt)
5277c478bd9Sstevel@tonic-gate {
5287c478bd9Sstevel@tonic-gate 	switch (aflt->flt_class) {
5297c478bd9Sstevel@tonic-gate 	case CPU_FAULT:
5307c478bd9Sstevel@tonic-gate 		cpu_async_log_err(aflt);
5317c478bd9Sstevel@tonic-gate 		break;
5327c478bd9Sstevel@tonic-gate 
5337c478bd9Sstevel@tonic-gate 	case BUS_FAULT:
5347c478bd9Sstevel@tonic-gate 		cpu_async_log_err(aflt);
5357c478bd9Sstevel@tonic-gate 		break;
5367c478bd9Sstevel@tonic-gate 
5377c478bd9Sstevel@tonic-gate 	default:
5387c478bd9Sstevel@tonic-gate 		break;
5397c478bd9Sstevel@tonic-gate 	}
5407c478bd9Sstevel@tonic-gate }
5417c478bd9Sstevel@tonic-gate 
5427c478bd9Sstevel@tonic-gate /*
5437c478bd9Sstevel@tonic-gate  * Called from ue_drain().
5447c478bd9Sstevel@tonic-gate  */
5457c478bd9Sstevel@tonic-gate void
5467c478bd9Sstevel@tonic-gate cpu_ue_log_err(struct async_flt *aflt)
5477c478bd9Sstevel@tonic-gate {
5487c478bd9Sstevel@tonic-gate 	switch (aflt->flt_class) {
5497c478bd9Sstevel@tonic-gate 	case CPU_FAULT:
5507c478bd9Sstevel@tonic-gate 		cpu_async_log_err(aflt);
5517c478bd9Sstevel@tonic-gate 		break;
5527c478bd9Sstevel@tonic-gate 
5537c478bd9Sstevel@tonic-gate 	case BUS_FAULT:
5547c478bd9Sstevel@tonic-gate 		cpu_async_log_err(aflt);
5557c478bd9Sstevel@tonic-gate 		break;
5567c478bd9Sstevel@tonic-gate 
5577c478bd9Sstevel@tonic-gate 	default:
5587c478bd9Sstevel@tonic-gate 		break;
5597c478bd9Sstevel@tonic-gate 	}
5607c478bd9Sstevel@tonic-gate }
5617c478bd9Sstevel@tonic-gate 
5627c478bd9Sstevel@tonic-gate /*
5637c478bd9Sstevel@tonic-gate  * Turn on flag on the error memory region.
5647c478bd9Sstevel@tonic-gate  */
5657c478bd9Sstevel@tonic-gate static void
566db874c57Selowe errh_page_retire(errh_async_flt_t *errh_fltp, uchar_t flag)
5677c478bd9Sstevel@tonic-gate {
5687c478bd9Sstevel@tonic-gate 	uint64_t flt_real_addr_start = errh_fltp->errh_er.ra;
5697c478bd9Sstevel@tonic-gate 	uint64_t flt_real_addr_end = flt_real_addr_start +
5707c478bd9Sstevel@tonic-gate 	    errh_fltp->errh_er.sz - 1;
5717c478bd9Sstevel@tonic-gate 	int64_t current_addr;
5727c478bd9Sstevel@tonic-gate 
5737c478bd9Sstevel@tonic-gate 	if (errh_fltp->errh_er.sz == 0)
5747c478bd9Sstevel@tonic-gate 		return;
5757c478bd9Sstevel@tonic-gate 
5767c478bd9Sstevel@tonic-gate 	for (current_addr = flt_real_addr_start;
5777c478bd9Sstevel@tonic-gate 	    current_addr < flt_real_addr_end; current_addr += MMU_PAGESIZE) {
578db874c57Selowe 		(void) page_retire(current_addr, flag);
5797c478bd9Sstevel@tonic-gate 	}
5807c478bd9Sstevel@tonic-gate }
5817c478bd9Sstevel@tonic-gate 
5827c478bd9Sstevel@tonic-gate void
5837c478bd9Sstevel@tonic-gate mem_scrub(uint64_t paddr, uint64_t len)
5847c478bd9Sstevel@tonic-gate {
5857c478bd9Sstevel@tonic-gate 	uint64_t pa, length, scrubbed_len;
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	pa = paddr;
5887c478bd9Sstevel@tonic-gate 	length = len;
5897c478bd9Sstevel@tonic-gate 	scrubbed_len = 0;
5907c478bd9Sstevel@tonic-gate 
5913461bce3Swh 	while (length > 0) {
5923461bce3Swh 		if (hv_mem_scrub(pa, length, &scrubbed_len) != H_EOK)
5937c478bd9Sstevel@tonic-gate 			break;
5947c478bd9Sstevel@tonic-gate 
5957c478bd9Sstevel@tonic-gate 		pa += scrubbed_len;
5967c478bd9Sstevel@tonic-gate 		length -= scrubbed_len;
5977c478bd9Sstevel@tonic-gate 	}
5987c478bd9Sstevel@tonic-gate }
5997c478bd9Sstevel@tonic-gate 
600ad559ebfSwh /*
6012ae0af4bSep  * Call hypervisor to flush the memory region.
6022ae0af4bSep  * Both va and len must be MMU_PAGESIZE aligned.
6032ae0af4bSep  * Returns the total number of bytes flushed.
604ad559ebfSwh  */
6052ae0af4bSep uint64_t
6067c478bd9Sstevel@tonic-gate mem_sync(caddr_t va, size_t len)
6077c478bd9Sstevel@tonic-gate {
6087c478bd9Sstevel@tonic-gate 	uint64_t pa, length, flushed;
6092ae0af4bSep 	uint64_t chunk_len = MMU_PAGESIZE;
6102ae0af4bSep 	uint64_t total_flushed = 0;
6117c478bd9Sstevel@tonic-gate 
6122ae0af4bSep 	if (((uint64_t)va | (uint64_t)len) & MMU_PAGEOFFSET)
6132ae0af4bSep 		return (total_flushed);
6147c478bd9Sstevel@tonic-gate 
6152ae0af4bSep 	while (len > 0) {
6162ae0af4bSep 		pa = va_to_pa((caddr_t)va);
6172ae0af4bSep 		if (pa == (uint64_t)-1)
6182ae0af4bSep 			return (total_flushed);
6197c478bd9Sstevel@tonic-gate 
6202ae0af4bSep 		length = chunk_len;
6212ae0af4bSep 		flushed = 0;
622ad559ebfSwh 
6232ae0af4bSep 		while (length > 0) {
6242ae0af4bSep 			if (hv_mem_sync(pa, length, &flushed) != H_EOK)
6252ae0af4bSep 				return (total_flushed);
6267c478bd9Sstevel@tonic-gate 
6272ae0af4bSep 			pa += flushed;
6282ae0af4bSep 			length -= flushed;
6292ae0af4bSep 			total_flushed += flushed;
6302ae0af4bSep 		}
6317c478bd9Sstevel@tonic-gate 
6322ae0af4bSep 		va += chunk_len;
6332ae0af4bSep 		len -= chunk_len;
6347c478bd9Sstevel@tonic-gate 	}
6352ae0af4bSep 
6362ae0af4bSep 	return (total_flushed);
6377c478bd9Sstevel@tonic-gate }
6387c478bd9Sstevel@tonic-gate 
6397c478bd9Sstevel@tonic-gate /*
6407c478bd9Sstevel@tonic-gate  * If resumable queue is full, we need to check if any cpu is in
6417c478bd9Sstevel@tonic-gate  * error state. If not, we drive on. If yes, we need to panic. The
6427c478bd9Sstevel@tonic-gate  * hypervisor call hv_cpu_state() is being used for checking the
6437c478bd9Sstevel@tonic-gate  * cpu state.
6447c478bd9Sstevel@tonic-gate  */
6457c478bd9Sstevel@tonic-gate static void
6467c478bd9Sstevel@tonic-gate errh_rq_full(struct async_flt *afltp)
6477c478bd9Sstevel@tonic-gate {
6487c478bd9Sstevel@tonic-gate 	processorid_t who;
6497c478bd9Sstevel@tonic-gate 	uint64_t cpu_state;
6507c478bd9Sstevel@tonic-gate 	uint64_t retval;
6517c478bd9Sstevel@tonic-gate 
6527c478bd9Sstevel@tonic-gate 	for (who = 0; who < NCPU; who++)
6537c478bd9Sstevel@tonic-gate 		if (CPU_IN_SET(cpu_ready_set, who)) {
6547c478bd9Sstevel@tonic-gate 			retval = hv_cpu_state(who, &cpu_state);
6557c478bd9Sstevel@tonic-gate 			if (retval != H_EOK || cpu_state == CPU_STATE_ERROR) {
6567c478bd9Sstevel@tonic-gate 				afltp->flt_panic = 1;
6577c478bd9Sstevel@tonic-gate 				break;
6587c478bd9Sstevel@tonic-gate 			}
6597c478bd9Sstevel@tonic-gate 		}
6607c478bd9Sstevel@tonic-gate }
6617c478bd9Sstevel@tonic-gate 
6627c478bd9Sstevel@tonic-gate /*
6637c478bd9Sstevel@tonic-gate  * Return processor specific async error structure
6647c478bd9Sstevel@tonic-gate  * size used.
6657c478bd9Sstevel@tonic-gate  */
6667c478bd9Sstevel@tonic-gate int
6677c478bd9Sstevel@tonic-gate cpu_aflt_size(void)
6687c478bd9Sstevel@tonic-gate {
6697c478bd9Sstevel@tonic-gate 	return (sizeof (errh_async_flt_t));
6707c478bd9Sstevel@tonic-gate }
6717c478bd9Sstevel@tonic-gate 
6727c478bd9Sstevel@tonic-gate #define	SZ_TO_ETRS_SHIFT	6
6737c478bd9Sstevel@tonic-gate 
6747c478bd9Sstevel@tonic-gate /*
6757c478bd9Sstevel@tonic-gate  * Message print out when resumable queue is overflown
6767c478bd9Sstevel@tonic-gate  */
6777c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6787c478bd9Sstevel@tonic-gate void
6797c478bd9Sstevel@tonic-gate rq_overflow(struct regs *rp, uint64_t head_offset,
6807c478bd9Sstevel@tonic-gate     uint64_t tail_offset)
6817c478bd9Sstevel@tonic-gate {
6827c478bd9Sstevel@tonic-gate 	rq_overflow_count++;
6837c478bd9Sstevel@tonic-gate }
6847c478bd9Sstevel@tonic-gate 
6857c478bd9Sstevel@tonic-gate /*
6867c478bd9Sstevel@tonic-gate  * Handler to process a fatal error.  This routine can be called from a
6877c478bd9Sstevel@tonic-gate  * softint, called from trap()'s AST handling, or called from the panic flow.
6887c478bd9Sstevel@tonic-gate  */
6897c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6907c478bd9Sstevel@tonic-gate static void
6917c478bd9Sstevel@tonic-gate ue_drain(void *ignored, struct async_flt *aflt, errorq_elem_t *eqep)
6927c478bd9Sstevel@tonic-gate {
6937c478bd9Sstevel@tonic-gate 	cpu_ue_log_err(aflt);
6947c478bd9Sstevel@tonic-gate }
6957c478bd9Sstevel@tonic-gate 
6967c478bd9Sstevel@tonic-gate /*
6977c478bd9Sstevel@tonic-gate  * Handler to process a correctable error.  This routine can be called from a
6987c478bd9Sstevel@tonic-gate  * softint.  We just call the CPU module's logging routine.
6997c478bd9Sstevel@tonic-gate  */
7007c478bd9Sstevel@tonic-gate /*ARGSUSED*/
7017c478bd9Sstevel@tonic-gate static void
7027c478bd9Sstevel@tonic-gate ce_drain(void *ignored, struct async_flt *aflt, errorq_elem_t *eqep)
7037c478bd9Sstevel@tonic-gate {
7047c478bd9Sstevel@tonic-gate 	cpu_ce_log_err(aflt);
7057c478bd9Sstevel@tonic-gate }
7067c478bd9Sstevel@tonic-gate 
7073cac8019Srf /*
7083cac8019Srf  * Handler to process vbsc hostshutdown (power-off button).
7093cac8019Srf  */
7103cac8019Srf static int
7113cac8019Srf err_shutdown_softintr()
7123cac8019Srf {
7133cac8019Srf 	cmn_err(CE_WARN, "Power-off requested, system will now shutdown.");
7143cac8019Srf 	do_shutdown();
7153cac8019Srf 
7163cac8019Srf 	/*
7173cac8019Srf 	 * just in case do_shutdown() fails
7183cac8019Srf 	 */
7193cac8019Srf 	(void) timeout((void(*)(void *))power_down, NULL, 100 * hz);
7203cac8019Srf 	return (DDI_INTR_CLAIMED);
7213cac8019Srf }
7223cac8019Srf 
7237c478bd9Sstevel@tonic-gate /*
7247c478bd9Sstevel@tonic-gate  * Allocate error queue sizes based on max_ncpus.  max_ncpus is set just
7257c478bd9Sstevel@tonic-gate  * after ncpunode has been determined.  ncpus is set in start_other_cpus
7267c478bd9Sstevel@tonic-gate  * which is called after error_init() but may change dynamically.
7277c478bd9Sstevel@tonic-gate  */
7287c478bd9Sstevel@tonic-gate void
7297c478bd9Sstevel@tonic-gate error_init(void)
7307c478bd9Sstevel@tonic-gate {
7317c478bd9Sstevel@tonic-gate 	char tmp_name[MAXSYSNAME];
732fa9e4066Sahrens 	pnode_t node;
7337c478bd9Sstevel@tonic-gate 	size_t size = cpu_aflt_size();
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate 	/*
7367c478bd9Sstevel@tonic-gate 	 * Initialize the correctable and uncorrectable error queues.
7377c478bd9Sstevel@tonic-gate 	 */
7387c478bd9Sstevel@tonic-gate 	ue_queue = errorq_create("ue_queue", (errorq_func_t)ue_drain, NULL,
7397c478bd9Sstevel@tonic-gate 	    MAX_ASYNC_FLTS * (max_ncpus + 1), size, PIL_2, ERRORQ_VITAL);
7407c478bd9Sstevel@tonic-gate 
7417c478bd9Sstevel@tonic-gate 	ce_queue = errorq_create("ce_queue", (errorq_func_t)ce_drain, NULL,
7427c478bd9Sstevel@tonic-gate 	    MAX_CE_FLTS * (max_ncpus + 1), size, PIL_1, 0);
7437c478bd9Sstevel@tonic-gate 
7447c478bd9Sstevel@tonic-gate 	if (ue_queue == NULL || ce_queue == NULL)
7457c478bd9Sstevel@tonic-gate 		panic("failed to create required system error queue");
7467c478bd9Sstevel@tonic-gate 
7473cac8019Srf 	/*
7483cac8019Srf 	 * Setup interrupt handler for power-off button.
7493cac8019Srf 	 */
7503cac8019Srf 	err_shutdown_inum = add_softintr(PIL_9,
751b0fc0e77Sgovinda 	    (softintrfunc)err_shutdown_softintr, NULL, SOFTINT_ST);
7523cac8019Srf 
7537c478bd9Sstevel@tonic-gate 	/*
7547c478bd9Sstevel@tonic-gate 	 * Initialize the busfunc list mutex.  This must be a PIL_15 spin lock
7557c478bd9Sstevel@tonic-gate 	 * because we will need to acquire it from cpu_async_error().
7567c478bd9Sstevel@tonic-gate 	 */
7577c478bd9Sstevel@tonic-gate 	mutex_init(&bfd_lock, NULL, MUTEX_SPIN, (void *)PIL_15);
7587c478bd9Sstevel@tonic-gate 
7597c478bd9Sstevel@tonic-gate 	node = prom_rootnode();
7607c478bd9Sstevel@tonic-gate 	if ((node == OBP_NONODE) || (node == OBP_BADNODE)) {
7617c478bd9Sstevel@tonic-gate 		cmn_err(CE_CONT, "error_init: node 0x%x\n", (uint_t)node);
7627c478bd9Sstevel@tonic-gate 		return;
7637c478bd9Sstevel@tonic-gate 	}
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate 	if (((size = prom_getproplen(node, "reset-reason")) != -1) &&
7667c478bd9Sstevel@tonic-gate 	    (size <= MAXSYSNAME) &&
7677c478bd9Sstevel@tonic-gate 	    (prom_getprop(node, "reset-reason", tmp_name) != -1)) {
7687c478bd9Sstevel@tonic-gate 		if (reset_debug) {
7697c478bd9Sstevel@tonic-gate 			cmn_err(CE_CONT, "System booting after %s\n", tmp_name);
7707c478bd9Sstevel@tonic-gate 		} else if (strncmp(tmp_name, "FATAL", 5) == 0) {
7717c478bd9Sstevel@tonic-gate 			cmn_err(CE_CONT,
7727c478bd9Sstevel@tonic-gate 			    "System booting after fatal error %s\n", tmp_name);
7737c478bd9Sstevel@tonic-gate 		}
7747c478bd9Sstevel@tonic-gate 	}
7757c478bd9Sstevel@tonic-gate }
77618aea0b1Swh 
77718aea0b1Swh /*
77818aea0b1Swh  * Nonresumable queue is full, panic here
77918aea0b1Swh  */
78018aea0b1Swh /*ARGSUSED*/
78118aea0b1Swh void
78218aea0b1Swh nrq_overflow(struct regs *rp)
78318aea0b1Swh {
78418aea0b1Swh 	fm_panic("Nonresumable queue full");
78518aea0b1Swh }
78644961713Sgirish 
78744961713Sgirish /*
78844961713Sgirish  * This is the place for special error handling for individual errors.
78944961713Sgirish  */
79044961713Sgirish static void
79144961713Sgirish errh_handle_attr(errh_async_flt_t *errh_fltp)
79244961713Sgirish {
79344961713Sgirish 	switch (errh_fltp->errh_er.attr & ~ERRH_MODE_MASK) {
79444961713Sgirish 	case ERRH_ATTR_CPU:
79544961713Sgirish 	case ERRH_ATTR_MEM:
79644961713Sgirish 	case ERRH_ATTR_PIO:
79744961713Sgirish 	case ERRH_ATTR_IRF:
79844961713Sgirish 	case ERRH_ATTR_FRF:
79944961713Sgirish 	case ERRH_ATTR_SHUT:
80044961713Sgirish 		break;
80144961713Sgirish 
80244961713Sgirish 	case ERRH_ATTR_ASR:
80344961713Sgirish 		errh_handle_asr(errh_fltp);
80444961713Sgirish 		break;
80544961713Sgirish 
80644961713Sgirish 	case ERRH_ATTR_ASI:
80744961713Sgirish 	case ERRH_ATTR_PREG:
80844961713Sgirish 	case ERRH_ATTR_RQF:
80944961713Sgirish 		break;
81044961713Sgirish 
81144961713Sgirish 	default:
81244961713Sgirish 		break;
81344961713Sgirish 	}
81444961713Sgirish }
81544961713Sgirish 
81644961713Sgirish /*
81744961713Sgirish  * Handle ASR bit set in ATTR
81844961713Sgirish  */
81944961713Sgirish static void
82044961713Sgirish errh_handle_asr(errh_async_flt_t *errh_fltp)
82144961713Sgirish {
82244961713Sgirish 	uint64_t current_tick;
82344961713Sgirish 
82444961713Sgirish 	switch (errh_fltp->errh_er.reg) {
82544961713Sgirish 	case ASR_REG_VALID | ASR_REG_TICK:
82644961713Sgirish 		/*
82744961713Sgirish 		 * For Tick Compare Register error, it only happens when
82844961713Sgirish 		 * the register is being read or compared with the %tick
82944961713Sgirish 		 * register. Since we lost the contents of the register,
83044961713Sgirish 		 * we set the %tick_compr in the future. An interrupt will
83144961713Sgirish 		 * happen when %tick matches the value field of %tick_compr.
83244961713Sgirish 		 */
83344961713Sgirish 		current_tick = (uint64_t)gettick();
83444961713Sgirish 		tickcmpr_set(current_tick);
83544961713Sgirish 		/* Do not panic */
83644961713Sgirish 		errh_fltp->cmn_asyncflt.flt_panic = 0;
83744961713Sgirish 		break;
83844961713Sgirish 
83944961713Sgirish 	default:
84044961713Sgirish 		break;
84144961713Sgirish 	}
84244961713Sgirish }
843