ecc.c revision fa9e4066f08beec538e775443c5be79dd423fcab
/*
* 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 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/param.h>
#include <sys/mutex.h>
#include <sys/kmem.h>
#include <sys/machparam.h>
#include <sys/machsystm.h>
#include <sys/machthread.h>
#include <sys/cpu.h>
#include <sys/cpuvar.h>
#include <vm/page.h>
#include <vm/hat.h>
#include <vm/seg.h>
#include <vm/seg_kmem.h>
#include <sys/vmsystm.h>
#include <sys/vmem.h>
#include <sys/mman.h>
#include <sys/cmn_err.h>
#include <sys/time.h>
#include <sys/async.h>
#include <sys/spl.h>
#include <sys/trap.h>
#include <sys/machtrap.h>
#include <sys/promif.h>
#include <sys/prom_plat.h>
#include <sys/debug.h>
#include <sys/x_call.h>
#include <sys/membar.h>
#include <sys/ivintr.h>
#include <sys/cred.h>
#include <sys/cpu_module.h>
#include <sys/ontrap.h>
#include <sys/sdt.h>
#include <sys/errorq.h>
#define MAX_CE_FLTS 10
#define MAX_ASYNC_FLTS 6
errorq_t *ue_queue; /* queue of uncorrectable errors */
errorq_t *ce_queue; /* queue of correctable errors */
/*
* ce_verbose_memory - covers CEs in DIMMs
* ce_verbose_other - covers "others" (ecache, IO, etc.)
*
* If the value is 0, nothing is logged.
* If the value is 1, the error is logged to the log file, but not console.
* If the value is 2, the error is logged to the log file and console.
*/
int ce_verbose_memory = 1;
int ce_verbose_other = 1;
int ce_show_data = 0;
int ce_debug = 0;
int ue_debug = 0;
int reset_debug = 0;
/*
* Tunables for controlling the handling of asynchronous faults (AFTs). Setting
* these to non-default values on a non-DEBUG kernel is NOT supported.
*/
int aft_verbose = 0; /* log AFT messages > 1 to log only */
int aft_panic = 0; /* panic (not reboot) on fatal usermode AFLT */
int aft_testfatal = 0; /* force all AFTs to panic immediately */
/*
* Panic_* variables specific to the AFT code. These are used to record
* information that the platform-specific code will need once we panic.
*/
struct async_flt panic_aflt;
/*
* Defined in bus_func.c but initialised in error_init
*/
extern kmutex_t bfd_lock;
/*
* Common bus driver async error logging routine. This routine can be shared
* by all sun4u CPUs (unlike cpu_async_log_err) because we are assuming that
* if an i/o bus error required a panic, the error interrupt handler will
* enqueue the error and call panic itself.
*/
void
bus_async_log_err(struct async_flt *aflt)
{
char unum[UNUM_NAMLEN];
int len;
/*
* Call back into the processor specific routine
* to check for cpu related errors that may
* have resulted in this error. (E.g. copyout trap)
*/
if (aflt->flt_in_memory)
cpu_check_allcpus(aflt);
/*
* Note that aflt->flt_stat is not the CPU afsr.
*/
(void) cpu_get_mem_unum_aflt(AFLT_STAT_INVALID, aflt,
unum, UNUM_NAMLEN, &len);
aflt->flt_func(aflt, unum);
}
/*
* ecc_cpu_call called from bus drain functions to run cpu
* specific functions to check other cpus and get the unum.
*/
void
ecc_cpu_call(struct async_flt *ecc, char *unum, int err_type)
{
int len;
/*
* Call back into the processor
* specific routine to check for cpu related errors
* that may have resulted in this error.
* (E.g. copyout trap)
*/
if (ecc->flt_in_memory)
cpu_check_allcpus(ecc);
(void) cpu_get_mem_unum(AFLT_STAT_VALID, ecc->flt_synd,
(uint64_t)-1, ecc->flt_addr,
ecc->flt_bus_id, ecc->flt_in_memory,
ecc->flt_status, unum,
UNUM_NAMLEN, &len);
if (err_type == ECC_IO_CE)
cpu_ce_count_unum(ecc, len, unum);
}
/*
* Handler to process a fatal error. This routine can be called from a
* softint, called from trap()'s AST handling, or called from the panic flow.
*/
/*ARGSUSED*/
static void
ue_drain(void *ignored, struct async_flt *aflt, errorq_elem_t *eqep)
{
cpu_ue_log_err(aflt);
}
/*
* Handler to process a correctable error. This routine can be called from a
* softint. We just call the CPU module's logging routine.
*/
/*ARGSUSED*/
static void
ce_drain(void *ignored, struct async_flt *aflt, errorq_elem_t *eqep)
{
cpu_ce_log_err(aflt, eqep);
}
/*
* Scrub a non-fatal correctable ecc error.
*/
void
ce_scrub(struct async_flt *aflt)
{
if (aflt->flt_in_memory)
cpu_ce_scrub_mem_err(aflt, B_FALSE);
}
/*
* Allocate error queue sizes based on max_ncpus. max_ncpus is set just
* after ncpunode has been determined. ncpus is set in start_other_cpus
* which is called after error_init() but may change dynamically.
*/
void
error_init(void)
{
char tmp_name[MAXSYSNAME];
pnode_t node;
size_t size = cpu_aflt_size();
/*
* Initialize the correctable and uncorrectable error queues.
*/
ue_queue = errorq_create("ue_queue", (errorq_func_t)ue_drain, NULL,
MAX_ASYNC_FLTS * (max_ncpus + 1), size, PIL_2, ERRORQ_VITAL);
ce_queue = errorq_create("ce_queue", (errorq_func_t)ce_drain, NULL,
MAX_CE_FLTS * (max_ncpus + 1), size, PIL_1, 0);
if (ue_queue == NULL || ce_queue == NULL)
panic("failed to create required system error queue");
/*
* Initialize the busfunc list mutex. This must be a PIL_15 spin lock
* because we will need to acquire it from cpu_async_error().
*/
mutex_init(&bfd_lock, NULL, MUTEX_SPIN, (void *)PIL_15);
node = prom_rootnode();
if ((node == OBP_NONODE) || (node == OBP_BADNODE)) {
cmn_err(CE_CONT, "error_init: node 0x%x\n", (uint_t)node);
return;
}
if (((size = prom_getproplen(node, "reset-reason")) != -1) &&
(size <= MAXSYSNAME) &&
(prom_getprop(node, "reset-reason", tmp_name) != -1)) {
if (reset_debug) {
cmn_err(CE_CONT, "System booting after %s\n", tmp_name);
} else if (strncmp(tmp_name, "FATAL", 5) == 0) {
cmn_err(CE_CONT,
"System booting after fatal error %s\n", tmp_name);
}
}
if (&cpu_error_init) {
cpu_error_init((MAX_ASYNC_FLTS + MAX_CE_FLTS) *
(max_ncpus + 1));
}
}
/*
* Success flags for ecc_page_zero
*/
#define PAGE_ZERO_SUCCESS 0
#define PAGE_ZERO_FAIL_NOLOCK 1
#define PAGE_ZERO_FAIL_ONTRAP 2
/*
* arg is a physical address - zero out the page that contains it
*/
void
ecc_page_zero(void *arg)
{
uint64_t pa = (uint64_t)arg;
page_t *pp = page_numtopp_nolock((pfn_t)(pa >> MMU_PAGESHIFT));
int ret, success_flag;
if (pp == NULL || !page_isretired(pp))
return;
/*
* Must hold a lock on the page before calling pagezero()
*
* This will only fail if someone has or wants an exclusive lock on
* the page. Since it's a retired page, this shouldn't happen.
*/
ret = page_lock(pp, SE_SHARED, (kmutex_t *)NULL, P_NO_RECLAIM);
if (ret > 0) {
on_trap_data_t otd;
/*
* Protect pagezero() from async faults
*/
if (!on_trap(&otd, OT_DATA_EC)) {
pagezero(pp, 0, PAGESIZE);
success_flag = PAGE_ZERO_SUCCESS;
} else {
success_flag = PAGE_ZERO_FAIL_ONTRAP;
}
no_trap();
page_unlock(pp);
} else {
success_flag = PAGE_ZERO_FAIL_NOLOCK;
}
DTRACE_PROBE2(page_zero_result, int, success_flag, uint64_t, pa);
}