ddifm.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* 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
* 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"
/*
* Fault Management for Device Drivers
*
* Device drivers wishing to participate in fault management may do so by
* first initializing their fault management state and capabilties via
* ddi_fm_init(). If the system supports the requested FM capabilities,
* the IO framework will intialize FM state and return a bit mask of the
* requested capabilities.
*
* If the system does not support the requested FM capabilities,
* the device driver must behave in accordance with the programming semantics
* defined below for the capabilities returned from ddi_fm_init().
* ddi_fm_init() must be called at attach(9E) time and ddi_fm_fini() must be
* called from detach(9E) to perform FM clean-up.
*
* Driver Fault Management Capabilities
*
* DDI_FM_NOT_CAPABLE
*
* This is the default fault management capability for drivers. Drivers
* that implement no fault management capabilites or do not participate
* in fault management activities have their FM capability bitmask set
* to 0.
*
* DDI_FM_EREPORT_CAPABLE
*
* When this capability bit is set, drivers are expected to generate error
* report events via ddi_ereport_post() for the associated faults
* that are diagnosed by the IO fault manager DE. ddi_ereport_post()
* may be called in any context subject to the constraints specified
* by the interrupt iblock cookie returned during initialization.
*
* Error reports resulting from hardware component specific and common IO
* fault and driver defects must be accompanied by an Eversholt fault
* tree (.eft) by the Solaris fault manager (fmd(1M)) for
* diagnosis.
*
* DDI_FM_ERRCB_CAPABLE
*
* Device drivers are expected to implement and register an error
* handler callback function. ddi_fm_handler_register() and
* ddi_fm_handler_unregister() must be
* called in passive kernel context, typically during an attach(9E)
* or detach(9E) operation. When called by the FM IO framework,
* the callback function should check for error conditions for the
* hardware and software under its control. All detected errors
* should have ereport events generated for them.
*
* Upon completion of the error handler callback, the driver should
* return one of the following values:
*
* #define DDI_FM_OK - no error was detected
* #define DDI_FM_FATAL - a fatal error was detected
* #define DDI_FM_NONFATAL - a non-fatal error was detected
* #define DDI_FM_UNKNOWN - the error status is unknown
*
* To insure single threaded access to error handling callbacks,
* the device driver may use i_ddi_fm_handler_enter() and
* i_ddi_fm_handler_exit() when entering and exiting the callback.
*
*
* Device drivers are expected to set-up access and DMA handles
* with FM-specific attributes designed to allow nexus parent
* drivers to flag any errors seen during subsequent IO transactions.
* Drivers must set the devacc_attr_acc_flag member of their
* ddi_device_acc_attr_t structures to DDI_FLAGERR_ACC or DDI_CAUTIOUS_ACC.
* For DMA transactions, driver must set the dma_attr_flags of
* their ddi_dma_attr_t structures to DDI_DMA_FLAGERR.
*
* Upon completion of an IO transaction, device drivers are expected
* to check the status of host-side hardware access and device-side
* dma completions by calling ddi_acc_err_check() or ddi_dma_err_check()
* respectively. If the handle is associated with an error detected by
* the nexus parent or FM IO framework, ddi_fm_error_t data (status, ena
* and error expectation) is returned. If status of DDI_FM_NONFATAL or
* DDI_FM_FATAL is returned, the ena is valid and the expectation flag
* will be set to 1 if the error was unexpected (i.e. not the result
* of a peek or poke type operation).
*
* ddi_acc_err_check() and ddi_dma_err_check() may be called in any
* context subject to the constraints specified by the interrupt
* iblock cookie returned during initialization.
*
* Device drivers should generate an access (DDI_FM_IO_ACC) or dma
* (DDI_FM_IO_DMA) data path error report if DDI_FM_NONFATAL or
* DDI_FM_FATAL is returned.
*
*/
#include <sys/ddi_impldefs.h>
#include <sys/errorq_impl.h>
/* Globals */
int ddi_system_fmcap = 0;
static struct i_ddi_fmkstat ddifm_kstat_template = {
{"erpt_dropped", KSTAT_DATA_UINT64 },
{"fm_cache_full", KSTAT_DATA_UINT64 },
{"fm_cache_grew", KSTAT_DATA_UINT64 },
{"acc_err", KSTAT_DATA_UINT64 },
{"dma_err", KSTAT_DATA_UINT64 }
};
/*
* Update the service state following the detection of an
* error.
*/
void
{
if (!DEVI_IS_DEVICE_OFFLINE(dip)) {
switch (svc_impact) {
case DDI_SERVICE_LOST:
break;
case DDI_SERVICE_DEGRADED:
break;
case DDI_SERVICE_RESTORED:
break;
case DDI_SERVICE_UNAFFECTED:
default:
break;
}
}
}
static int
{
char device_path[MAXPATHLEN];
char ddi_error_class[ERPT_CLASS_SZ];
/*
* Driver defect - should not call with DDI_SLEEP while
* in interrupt context
*/
if (servicing_interrupt()) {
return (1);
}
return (1);
/*
*/
if (dip == ddi_root_node()) {
device_path[0] = '/';
} else {
}
device_path, devid);
} else {
device_path, NULL);
}
if (ena == 0)
return (0);
}
static int
{
char *name;
char device_path[MAXPATHLEN];
char ddi_error_class[ERPT_CLASS_SZ];
return (1);
/*
*/
if (dip == ddi_root_node()) {
device_path[0] = '/';
} else {
}
device_path, NULL);
if (ena == 0)
return (0);
}
void
{
int i;
int depth;
char classp[DDI_DVR_MAX_CLASS];
char *buf;
char **stkpp;
char *sym;
return;
/* Allocate array of char * for nvlist payload */
/*
* Allocate temporary 64-bit aligned buffer for stack
* symbol strings
*/
for (i = 0; i < depth; ++i) {
stkp += DDI_FM_SYM_SZ;
}
if (errp)
else
NULL);
} else {
if (errp)
else
NULL);
}
}
/*
* Generate an error report for consumption by the Solaris Fault Manager,
* ENA should be set if this error is a result of an error status returned
* from ddi_dma_err_check() or ddi_acc_err_check(). Otherwise, an ENA
* value of 0 is appropriate.
*
* If sflag == DDI_NOSLEEP, ddi_fm_ereport_post () may be called
* from user, kernel, interrupt or high-interrupt context. Otherwise,
* ddi_fm_ereport_post() must be called from user or kernel context.
*/
void
int sflag, ...)
{
int ret;
char *name;
return;
}
/* First payload tuple should be the version */
return;
}
else
ap);
if (ret != 0)
}
/*
* Driver error handling entry. Prevents multiple simultaneous calls into
* driver error handling callback.
*
* May be called from a context consistent with the iblock_cookie returned
* in ddi_fm_init().
*/
void
{
}
/*
* Driver error handling exit.
*
* May be called from a context consistent with the iblock_cookie returned
* in ddi_fm_init().
*/
void
{
}
/*
* Register a fault manager error handler for this device instance
*
* This function must be called from a driver's attach(9E) routine.
*/
void
void *impl_data)
{
struct i_ddi_fmhdl *pfmhdl;
struct i_ddi_errhdl *new_eh;
struct i_ddi_fmtgt *tgt;
/*
* Check for proper calling context.
* The DDI configuration framework does not support
* DR states to allow checking for proper invocation
* from a DDI_ATTACH or DDI_RESUME. This limits context checking
* to interrupt only.
*/
if (servicing_interrupt()) {
return;
}
return;
}
/* Add dip to parent's target list of registered error handlers */
}
/*
* Unregister a fault manager error handler for this device instance
*
* This function must be called from a drivers attach(9E) or detach(9E)
* routine.
*/
void
{
struct i_ddi_fmhdl *pfmhdl;
/*
* Check for proper calling context.
* The DDI configuration framework does not support
* DR states to allow checking for proper invocation
* from a DDI_DETACH or DDI_SUSPEND. This limits context checking
* to interrupt only.
*/
if (servicing_interrupt()) {
return;
}
return;
}
break;
}
}
}
/*
* Initialize Fault Management capabilities for this device instance (dip).
* When called with the following capabilities, data structures neccessary
* for fault management activities are allocated and initialized.
*
* DDI_FM_EREPORT_CAPABLE - initialize ereport errorq and ereport
* capable driver property.
*
* DDI_FM_ERRCB_CAPABLE - check with parent for ability to register
* an error handler.
*
* DDI_FM_ACCCHK_CAPABLE - initialize access handle cache and acc-chk
* driver property
*
* DDI_FM_DMACHK_CAPABLE - initialize dma handle cache and dma-chk
* driver property
*
* A driver's FM capability level may not exceed that of its parent or
* system-wide FM capability. The available capability level for this
* device instance is returned in *fmcap.
*
* This function must be called from a driver's attach(9E) entry point.
*/
void
{
struct i_ddi_fmhdl *fmhdl;
if (!DEVI_IS_ATTACHING(dip)) {
return;
}
if (DDI_FM_DEFAULT_CAP(*fmcap))
return;
/*
* Check parent for supported FM level
* and correct error handling PIL
*/
if (dip != ddi_root_node()) {
/*
* Initialize the default ibc. The parent may change it
* depending upon its capabilities.
*/
} else {
}
/* Initialize the per-device instance FM handle */
KSTAT_TYPE_NAMED, sizeof (struct i_ddi_fmkstat) /
return;
}
sizeof (struct i_ddi_fmkstat));
/*
* Initialize support for ereport generation
*/
if (DDI_FM_EREPORT_CAP(*fmcap) &&
"fm-ereport-capable", 0) == 0)
}
/*
* Need cooperation of the parent for error handling
*/
"fm-errcb-capable", 0) == 0)
}
/*
* Support for DMA and Access error handling
*/
/* Set-up dma chk capability prop */
"fm-dmachk-capable", 0) == 0)
}
/* Set-up dma chk capability prop */
"fm-accchk-capable", 0) == 0)
}
/*
* Return the capability support available
* to this driver instance
*/
}
/*
* Finalize Fault Management activities for this device instance.
* Outstanding IO transaction must be completed prior to calling
* this routine. All previously allocated resources and error handler
* registration are cleared and deallocated.
*
* This function must be called from a driver's detach(9E) entry point.
*/
void
{
return;
}
return;
"fm-ereport-capable");
}
if (dip != ddi_root_node()) {
"fm-dmachk-capable");
}
"fm-accachk-capable");
}
}
}
}
/*
* Return the fault management capability level for this device instance.
*
* This function may be called from user, kernel, or interrupt context.
*/
int
{
return (DDI_FM_NOT_CAPABLE);
}
/*
*
* These routines may be called from user, kernel, and interrupt contexts.
*/
void
{
if (version != DDI_FME_VER0) {
"Invalid driver version\n");
}
}
void
{
if (version != DDI_FME_VER0) {
"Invalid driver version\n");
}
}
void
int flag)
{
}
void
int flag)
{
}