sparc/sun4v/gmem.esc

	gmem.esc revision 5b461e745fd57f3b9708a1b7ccb30395836c735a
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#define DIAGNOSE_ERPT (payloadprop_defined("diagnose") && \
    payloadprop("diagnose") != 0x0)

#define DIMMPATH dimm

#define CONTAINS_DIMM (payloadprop_contains("resource", asru(DIMMPATH)))

#define SET_ADDR (!payloadprop_defined("phys-addr") || \
    setpayloadprop("physaddr", payloadprop("phys-addr")))

#define SET_OFFSET (!payloadprop_defined("offset") || \
    setpayloadprop("offset",\
        payloadprop("offset")))

#define SET_SERDT (!payloadprop_defined("serd_t") || \
    setserdt(payloadprop("serd_t")))

#define SET_SERDN (!payloadprop_defined("serd_n") || \
    setserdn(payloadprop("serd_n")))

#define SET_RATIO        \
    ((payloadprop_defined("filter_ratio") && \
    payloadprop("filter_ratio") != 0x0) ? \
    (setserdincrement(payloadprop("filter_ratio"))) : 1)

/*
 * fault.memory.generic-sparc.bank & fault.memory.generic-sparc.page
 * are generated for memory ue error.
 */
#define MEMUE_ERPT(level)   \
    event ereport.cpu.generic-sparc.mem-uc@level { within(1s)}

MEMUE_ERPT(chip);
MEMUE_ERPT(core);
MEMUE_ERPT(strand);

#define FLT_MEM_UE_BANK(level)                      \
    event fault.memory.bank@DIMMPATH;               \
                                    \
    prop fault.memory.bank@DIMMPATH                 \
        { DIAGNOSE_ERPT && CONTAINS_DIMM } (0)->            \
        ereport.cpu.generic-sparc.mem-uc@level<>;           \
                                    \
    event upset.memory.bank@DIMMPATH;               \
                                    \
    prop upset.memory.bank@DIMMPATH                 \
        { !DIAGNOSE_ERPT } (0)->                    \
        ereport.cpu.generic-sparc.mem-uc@level<>

FLT_MEM_UE_BANK(chip);
FLT_MEM_UE_BANK(core);
FLT_MEM_UE_BANK(strand);

#define FLT_MEM_UE_PAGE(level)                      \
    event fault.memory.page@DIMMPATH,               \
         message=0;                         \
                                    \
    prop fault.memory.page@DIMMPATH                 \
        { DIAGNOSE_ERPT && CONTAINS_DIMM && SET_ADDR && SET_OFFSET } (0)-> \
        ereport.cpu.generic-sparc.mem-uc@level<>;           \
                                    \
    event upset.memory.page@DIMMPATH;               \
                                    \
    prop upset.memory.page@DIMMPATH                 \
        { !DIAGNOSE_ERPT } (0)->                    \
        ereport.cpu.generic-sparc.mem-uc@level<>

FLT_MEM_UE_PAGE(chip);
FLT_MEM_UE_PAGE(core);
FLT_MEM_UE_PAGE(strand);


#define CHIP        chip
#define MEM_BUFF    memory-buffer
#define MEM_CTRL    memory-controller

#define CONTAINS_CHIP     (payloadprop_contains("sender", asru(CHIP)))
#define CONTAINS_MEMBUFF  (payloadprop_contains("sender", asru(MEM_BUFF)))
#define CONTAINS_MEMCTRL  (payloadprop_contains("sender", asru(MEM_CTRL)))

engine serd.memory.generic-sparc.membuf-crc@CHIP, N=120, T=30min;
engine serd.memory.generic-sparc.membuf-crc@MEM_BUFF, N=120, T=30min;
engine serd.memory.generic-sparc.membuf-crc@MEM_CTRL, N=120, T=30min;


event fault.memory.memlink@CHIP,
    engine=serd.memory.generic-sparc.membuf-crc@CHIP;
event fault.memory.memlink@MEM_BUFF,
    engine=serd.memory.generic-sparc.membuf-crc@MEM_BUFF;
event fault.memory.memlink@MEM_CTRL,
    engine=serd.memory.generic-sparc.membuf-crc@MEM_CTRL;

/*
 * membuf-crc errors will fault the FRU of the detector & the FRU of the sender
 * - if detector is chip or memory-controller, the sender is memory-buffer.
 * - if detector is memory-buffer, the sender is chip or memory-controller
 */
event ereport.cpu.generic-sparc.membuf-crc@CHIP { within(1s) };
event ereport.cpu.generic-sparc.membuf-crc@MEM_BUFF { within(1s) };
event ereport.cpu.generic-sparc.membuf-crc@MEM_CTRL { within(1s) };

/*
 * detector is chip
 */
prop fault.memory.memlink@CHIP
    { DIAGNOSE_ERPT && SET_SERDN && SET_SERDT && SET_RATIO } (0) ->
    ereport.cpu.generic-sparc.membuf-crc@CHIP;

prop fault.memory.memlink@MEM_BUFF
    { DIAGNOSE_ERPT && CONTAINS_MEMBUFF && SET_SERDN &&
    SET_SERDT && SET_RATIO } (0)->
    ereport.cpu.generic-sparc.membuf-crc@CHIP<>;

event upset.memory.memlink@CHIP;

prop upset.memory.memlink@CHIP
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc@CHIP;
/*
 * detector is memory-buffer
 */
prop fault.memory.memlink@MEM_BUFF
    { DIAGNOSE_ERPT && SET_SERDN && SET_SERDT && SET_RATIO } (0) ->
    ereport.cpu.generic-sparc.membuf-crc@MEM_BUFF;

prop fault.memory.memlink@CHIP
    { DIAGNOSE_ERPT && CONTAINS_CHIP && SET_SERDN &&
    SET_SERDT && SET_RATIO } (0) ->
    ereport.cpu.generic-sparc.membuf-crc@MEM_BUFF<>;

prop fault.memory.memlink@MEM_CTRL
    { DIAGNOSE_ERPT && CONTAINS_MEMCTRL && SET_SERDN &&
    SET_SERDT && SET_RATIO } (0)->
    ereport.cpu.generic-sparc.membuf-crc@MEM_BUFF<>;

event upset.memory.memlink@MEM_BUFF;

prop upset.memory.memlink@MEM_BUFF
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc@MEM_BUFF;

/*
 * detector is memory-controller
 */
prop fault.memory.memlink@MEM_CTRL
    { DIAGNOSE_ERPT && SET_SERDN && SET_SERDT && SET_RATIO } (0)->
    ereport.cpu.generic-sparc.membuf-crc@MEM_CTRL;

prop fault.memory.memlink@MEM_BUFF
    { DIAGNOSE_ERPT && CONTAINS_MEMBUFF && SET_SERDN &&
    SET_SERDT && SET_RATIO } (0)->
    ereport.cpu.generic-sparc.membuf-crc@MEM_CTRL<>;

event upset.memory.memlink@MEM_CTRL;

prop upset.memory.memlink@MEM_CTRL
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc@MEM_CTRL;

/*
 * membuf-crc-uc will fault the detector FRU and sender FRU
 * if detector is CHIP or MEM_CTRL, the sender is MEM_BUFF.
 * if detector is MEM_BUFF, the sender is CHIP or MEM_CTRL
 */
event ereport.cpu.generic-sparc.membuf-crc-uc@CHIP { within(1s) };
event ereport.cpu.generic-sparc.membuf-crc-uc@MEM_BUFF { within(1s) };
event ereport.cpu.generic-sparc.membuf-crc-uc@MEM_CTRL { within(1s) };

event fault.memory.memlink-uc@CHIP;
event fault.memory.memlink-uc@MEM_BUFF;
event fault.memory.memlink-uc@MEM_CTRL;

/*
 * chip is detector
 */
prop fault.memory.memlink-uc@CHIP
    { DIAGNOSE_ERPT } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@CHIP;

prop fault.memory.memlink-uc@MEM_BUFF
    { DIAGNOSE_ERPT && CONTAINS_MEMBUFF } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@CHIP<>;

event upset.memory.memlink-uc@CHIP;

prop upset.memory.memlink-uc@CHIP
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc-uc@CHIP;

/*
 * memory-buffer is detector
 */
prop fault.memory.memlink-uc@MEM_BUFF
    { DIAGNOSE_ERPT } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_BUFF;

prop fault.memory.memlink-uc@CHIP
    { DIAGNOSE_ERPT && CONTAINS_CHIP } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_BUFF<>;

prop fault.memory.memlink-uc@MEM_CTRL
    { DIAGNOSE_ERPT && CONTAINS_MEMCTRL } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_BUFF<>;

event upset.memory.memlink-uc@MEM_BUFF;

prop upset.memory.memlink-uc@MEM_BUFF
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_BUFF;

/*
 * memory-controller is detector
 */
prop fault.memory.memlink-uc@MEM_CTRL
    { DIAGNOSE_ERPT } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_CTRL;

prop fault.memory.memlink-uc@MEM_BUFF
    { DIAGNOSE_ERPT && CONTAINS_MEMBUFF } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_CTRL<>;

event upset.memory.memlink-uc@MEM_CTRL;

prop upset.memory.memlink-uc@MEM_CTRL
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc-uc@MEM_CTRL;
/*
 * membuf-crc-failover will fault the detector FRU and sender FRU
 * if detector is chip or memory-controller, the sender is memory-buffer.
 * if detector is memory-buffer, the sender is chip or memory-controller
 */
event ereport.cpu.generic-sparc.membuf-crc-failover@CHIP { within(1s) };
event ereport.cpu.generic-sparc.membuf-crc-failover@MEM_BUFF
    { within(1s) };
event ereport.cpu.generic-sparc.membuf-crc-failover@MEM_CTRL
    { within(1s) };

event fault.memory.memlink-failover@CHIP;
event fault.memory.memlink-failover@MEM_BUFF;
event fault.memory.memlink-failover@MEM_CTRL;

/*
 * chip is detector
 */
prop fault.memory.memlink-failover@CHIP
    { DIAGNOSE_ERPT } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@CHIP;

prop fault.memory.memlink-failover@MEM_BUFF
    { DIAGNOSE_ERPT && CONTAINS_MEMBUFF } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@CHIP<>;

event upset.memory.memlink-failover@CHIP;

prop upset.memory.memlink-failover@CHIP
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc-failover@CHIP;
/*
 * memory-buffer is detector
 */
prop fault.memory.memlink-failover@MEM_BUFF
    { DIAGNOSE_ERPT } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_BUFF;

prop fault.memory.memlink-failover@CHIP
    { DIAGNOSE_ERPT && CONTAINS_CHIP } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_BUFF<>;

prop fault.memory.memlink-failover@MEM_CTRL
    { DIAGNOSE_ERPT && CONTAINS_MEMCTRL } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_BUFF<>;

event upset.memory.memlink-failover@MEM_BUFF;

prop upset.memory.memlink-failover@MEM_BUFF
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_BUFF;
/*
 * memory-controller is detector
 */
prop fault.memory.memlink-failover@MEM_CTRL
    { DIAGNOSE_ERPT } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_CTRL;

prop fault.memory.memlink-failover@MEM_BUFF
    { DIAGNOSE_ERPT && CONTAINS_MEMBUFF } (0) ->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_CTRL<>;

event upset.memory.memlink-failover@MEM_CTRL;

prop upset.memory.memlink-failover@MEM_CTRL
    { !DIAGNOSE_ERPT } (0)->
    ereport.cpu.generic-sparc.membuf-crc-failover@MEM_CTRL;
/*
 * ignore the membuf-other errors
 */
event ereport.cpu.generic-sparc.membuf-other@CHIP;
event ereport.cpu.generic-sparc.membuf-other@MEM_BUFF;
event ereport.cpu.generic-sparc.membuf-other@MEM_CTRL;

event upset.memory.discard@CHIP;
event upset.memory.discard@MEM_BUFF;
event upset.memory.discard@MEM_CTRL;

prop upset.memory.discard@CHIP (1)->
    ereport.cpu.generic-sparc.membuf-other@CHIP;

prop upset.memory.discard@MEM_BUFF (1)->
    ereport.cpu.generic-sparc.membuf-other@MEM_BUFF;

prop upset.memory.discard@MEM_CTRL (1)->
    ereport.cpu.generic-sparc.membuf-other@MEM_CTRL;