diff options
Diffstat (limited to 'usr/src/uts/sun4u/os/ecc.c')
| -rw-r--r-- | usr/src/uts/sun4u/os/ecc.c | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/usr/src/uts/sun4u/os/ecc.c b/usr/src/uts/sun4u/os/ecc.c new file mode 100644 index 0000000000..773ae8033d --- /dev/null +++ b/usr/src/uts/sun4u/os/ecc.c @@ -0,0 +1,295 @@ +/* + * 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]; + dnode_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); +} |