summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/include/usr/errl/errlreasoncodes.H1
-rw-r--r--src/include/usr/errl/errludparserfactoryerrl.H2
-rw-r--r--src/include/usr/errl/errludtarget.H187
-rw-r--r--src/include/usr/errl/hberrltypes.H1
-rw-r--r--src/include/usr/targeting/common/target.H2
-rw-r--r--src/usr/errl/errlud.C27
-rw-r--r--src/usr/errl/errludtarget.C50
-rw-r--r--src/usr/errl/makefile5
-rw-r--r--src/usr/errl/test/errluserdetailtest.H117
-rw-r--r--src/usr/targeting/common/target.C96
-rwxr-xr-xsrc/usr/targeting/common/xmltohb/xmltohb.pl552
11 files changed, 932 insertions, 108 deletions
diff --git a/src/include/usr/errl/errlreasoncodes.H b/src/include/usr/errl/errlreasoncodes.H
index 89d31e1d4..6bff54568 100644
--- a/src/include/usr/errl/errlreasoncodes.H
+++ b/src/include/usr/errl/errlreasoncodes.H
@@ -48,6 +48,7 @@ enum errlReasonCode
HBERRL_FIRST_ERR = HBERRL_COMP_ID | 0x01,
HBERRL_TEST_STRING_UD = HBERRL_COMP_ID | 0x02,
HBERRL_TEST_REASON_CODE = HBERRL_COMP_ID | 0x03,
+ HBERRL_TEST_ATTRIBUTE_UD = HBERRL_COMP_ID | 0x04,
//........
HBERRL_LAST_ERR = HBERRL_COMP_ID | 0xFF
};
diff --git a/src/include/usr/errl/errludparserfactoryerrl.H b/src/include/usr/errl/errludparserfactoryerrl.H
index 510265e89..f535b562d 100644
--- a/src/include/usr/errl/errludparserfactoryerrl.H
+++ b/src/include/usr/errl/errludparserfactoryerrl.H
@@ -33,6 +33,7 @@
#include <errl/errludstring.H>
#include <errl/errludtarget.H>
#include <errl/errludbacktrace.H>
+#include <errludattribute.H>
#include <errl/errludparserfactory.H>
namespace ERRORLOG
@@ -56,6 +57,7 @@ public:
registerParser<ErrlUserDetailsParserString>(HBERRL_UDT_STRING);
registerParser<ErrlUserDetailsParserTarget>(HBERRL_UDT_TARGET);
registerParser<ErrlUserDetailsParserBackTrace>(HBERRL_UDT_BACKTRACE);
+ registerParser<ErrlUserDetailsParserAttribute>(HBERRL_UDT_ATTRIBUTE);
}
private:
diff --git a/src/include/usr/errl/errludtarget.H b/src/include/usr/errl/errludtarget.H
index b76c58f13..83c9b8991 100644
--- a/src/include/usr/errl/errludtarget.H
+++ b/src/include/usr/errl/errludtarget.H
@@ -67,17 +67,7 @@ public:
*/
virtual ~ErrlUserDetailsTarget();
- /**
- * @brief Adds the Target as user detail data to an error log
- *
- * @param i_errl Error log to add detail data to.
- */
- virtual void addToLog(errlHndl_t i_errl);
-
private:
- // Target pointer
- const TARGETING::Target * iv_pTarget;
-
// Disabled
ErrlUserDetailsTarget(const ErrlUserDetailsTarget &);
ErrlUserDetailsTarget & operator=(const ErrlUserDetailsTarget &);
@@ -124,14 +114,179 @@ public:
const uint32_t i_buflen) const
{
i_parser.PrintString("Target data", NULL);
- char * l_ptr = static_cast<char *>(i_pBuffer);
- for (uint32_t i = 0; i < i_buflen; )
+ const char *attrData;
+ uint32_t i = 0;
+
+ // errlog data
+ uint8_t *l_ptr = static_cast<char *>(i_pBuffer);
+
+ if (*l_ptr == 1) // special - master
+ {
+ //const char *pTargetString = "MASTER_PROCESSOR_CHIP_TARGET_SENTINEL";
+ i_parser.PrintString(NULL, "MASTER_PROCESSOR_CHIP_TARGET_SENTINEL");
+ }
+ else
{
- i_parser.PrintString(NULL, l_ptr);
- i += strlen(l_ptr) + 1;
- l_ptr += strlen(l_ptr) + 1;
+ l_ptr += sizeof(uint8_t); // past the marker
+
+ // first 4 are always the same
+ if (i_buflen >= sizeof(uint32_t) + 3 * sizeof(uint8_t))
+ {
+ char sHuid[12];
+ sprintf(sHuid, "0x%x",*((uint32_t *)l_ptr));
+ i_parser.PrintString("ATTR_HUID", sHuid);
+ i += sizeof(uint32_t);
+ l_ptr += sizeof(uint32_t);
+
+ // CLASS
+ switch (*l_ptr) {
+ case 0x00: { attrData = "CLASS_NA"; break; }
+ case 0x01: { attrData = "CLASS_CARD"; break; }
+ case 0x02: { attrData = "CLASS_ENC"; break; }
+ case 0x03: { attrData = "CLASS_CHIP"; break; }
+ case 0x04: { attrData = "CLASS_UNIT"; break; }
+ case 0x05: { attrData = "CLASS_DEV"; break; }
+ case 0x06: { attrData = "CLASS_SYS"; break; }
+ case 0x07: { attrData = "CLASS_LOGICAL_CARD"; break; }
+ case 0x08: { attrData = "CLASS_MAX"; break; }
+ default: { attrData = "UNKNOWN CLASS"; break; }
+ } // switch
+ i_parser.PrintString("ATTR_CLASS", attrData);
+ i ++;
+ l_ptr ++;
+
+ // TYPE
+ switch (*l_ptr) {
+ case 0x00: { attrData = "TYPE_NA"; break; }
+ case 0x01: { attrData = "TYPE_SYS"; break; }
+ case 0x02: { attrData = "TYPE_NODE"; break; }
+ case 0x03: { attrData = "TYPE_DIMM"; break; }
+ case 0x04: { attrData = "TYPE_SCM"; break; }
+ case 0x05: { attrData = "TYPE_DCM"; break; }
+ case 0x06: { attrData = "TYPE_MEMBUF"; break; }
+ case 0x07: { attrData = "TYPE_PROC"; break; }
+ case 0x08: { attrData = "TYPE_MEMVRM"; break; }
+ case 0x09: { attrData = "TYPE_PROCVRM"; break; }
+ case 0x0A: { attrData = "TYPE_EX"; break; }
+ case 0x0B: { attrData = "TYPE_CORE"; break; }
+ case 0x0C: { attrData = "TYPE_L2"; break; }
+ case 0x0D: { attrData = "TYPE_L3"; break; }
+ case 0x0E: { attrData = "TYPE_L4"; break; }
+ case 0x0F: { attrData = "TYPE_MCS"; break; }
+ case 0x10: { attrData = "TYPE_MBS"; break; }
+ case 0x11: { attrData = "TYPE_MBA"; break; }
+ case 0x12: { attrData = "TYPE_MEM_PORT"; break; }
+ case 0x13: { attrData = "TYPE_PERVASIVE"; break; }
+ case 0x14: { attrData = "TYPE_POWERBUS"; break; }
+ case 0x15: { attrData = "TYPE_XBUS"; break; }
+ case 0x16: { attrData = "TYPE_ABUS"; break; }
+ case 0x17: { attrData = "TYPE_PCI"; break; }
+ case 0x18: { attrData = "TYPE_TP"; break; }
+ case 0x19: { attrData = "TYPE_DMI"; break; }
+ case 0x1A: { attrData = "TYPE_DPSS"; break; }
+ case 0x1B: { attrData = "TYPE_APSS"; break; }
+ case 0x1C: { attrData = "TYPE_OCC"; break; }
+ case 0x1D: { attrData = "TYPE_LAST_IN_RANGE"; break; }
+ default: { attrData = "UNKNOWN TYPE"; break; }
+ } // switch
+ i_parser.PrintString("ATTR_TYPE", attrData);
+ i++;
+ l_ptr++;
+
+ // MODEL
+ switch (*l_ptr) {
+ case 0x00: { attrData = "MODEL_NA"; break; }
+ case 0x10: { attrData = "MODEL_SALERNO"; break; }
+ case 0x11: { attrData = "MODEL_VENICE"; break; }
+ case 0x12: { attrData = "MODEL_MURANO"; break; }
+ case 0x30: { attrData = "MODEL_CENTAUR"; break; }
+ case 0x50: { attrData = "MODEL_JEDEC"; break; }
+ case 0x51: { attrData = "MODEL_CDIMM"; break; }
+ case 0x70: { attrData = "MODEL_POWER8"; break; }
+ default: { attrData = "UNKNOWN MODEL"; break; }
+ } // switch
+ i_parser.PrintString("ATTR_MODEL", attrData);
+ i++;
+ l_ptr++;
+ }
+
+ for (; i < i_buflen; )
+ {
+
+ if ((*l_ptr == 0x15) || // ATTR_PHYS_PATH
+ (*l_ptr == 0x16)) // ATTR_AFFINITY_PATH
+ {
+ l_ptr++;
+ const char *pathString;
+ char outString[128];
+ // from targeting/common/entitypath.[CH]
+ // entityPath is PATH_TYPE:4, NumberOfElements:4,
+ // [Element, Instance#]
+ // PATH_TYPE
+ const uint8_t pathTypeLength = *((uint8_t *)l_ptr);
+ l_ptr++;
+ const uint8_t pathType = (pathTypeLength & 0xF0) >> 4;
+ switch (pathType) {
+ case 0x01: pathString = "Logical:"; break;
+ case 0x02: pathString = "Physical:"; break;
+ case 0x03: pathString = "Device:"; break;
+ case 0x04: pathString = "Power:"; break;
+ default: pathString = "Unknown:"; break;
+ }
+ uint32_t dataSize = sprintf(outString, "%s",pathString);
+ const uint8_t pathSize = (pathTypeLength & 0x0F);
+ uint8_t *lElementInstance = ((uint8_t *)l_ptr);
+ l_ptr += pathSize * sizeof(uint8_t);
+ for (uint32_t i=0;i<pathSize;i += 2) {
+ switch (lElementInstance[i]) {
+ case 0x01: pathString = "/Sys"; break;
+ case 0x02: pathString = "/Node"; break;
+ case 0x03: pathString = "/DIMM"; break;
+ case 0x04: pathString = "/SCM"; break;
+ case 0x05: pathString = "/DCM"; break;
+ case 0x06: pathString = "/Membuf"; break;
+ case 0x07: pathString = "/Proc"; break;
+ case 0x08: pathString = "/MemVRM"; break;
+ case 0x09: pathString = "/ProcVRM"; break;
+ case 0x0A: pathString = "/EX"; break;
+ case 0x0B: pathString = "/Core"; break;
+ case 0x0C: pathString = "/L2"; break;
+ case 0x0D: pathString = "/L3"; break;
+ case 0x0E: pathString = "/L4"; break;
+ case 0x0F: pathString = "/MCS"; break;
+ case 0x10: pathString = "/MBS"; break;
+ case 0x11: pathString = "/MBA"; break;
+ case 0x12: pathString = "/MemPort"; break;
+ case 0x13: pathString = "/Pervasive"; break;
+ case 0x14: pathString = "/Powerbus"; break;
+ case 0x15: pathString = "/XBUS"; break;
+ case 0x16: pathString = "/ABUS"; break;
+ case 0x17: pathString = "/PCI"; break;
+ case 0x18: pathString = "/TP"; break;
+ case 0x19: pathString = "/DMI"; break;
+ case 0x1A: pathString = "/DPSS"; break;
+ case 0x1B: pathString = "/APSS"; break;
+ case 0x1C: pathString = "/OCC"; break;
+ //case TYPE_FSI_LINK: pathString = "/FSI-link"; break;
+ //case TYPE_CFAM: pathString = "/CFAM"; break;
+ //case TYPE_ENGINE: pathString = "/Engine"; break;
+ default: pathString = "/Unknown"; break;
+ } // switch
+ // copy next part in, overwritting previous terminator
+ dataSize += sprintf(outString + dataSize, "%s%d",pathString,lElementInstance[i+1]);
+ } // for
+ if (*l_ptr == 0x15) // ATTR_PHYS_PATH
+ {
+ i_parser.PrintString("ATTR_PHYS_PATH", outString);
+ }
+ else
+ {
+ i_parser.PrintString("ATTR_AFFINITY_PATH", outString);
+ }
+ }
+ } // for
}
- }
+ } // parse()
private:
// Disabled
diff --git a/src/include/usr/errl/hberrltypes.H b/src/include/usr/errl/hberrltypes.H
index 35b7a0417..2328bd6e3 100644
--- a/src/include/usr/errl/hberrltypes.H
+++ b/src/include/usr/errl/hberrltypes.H
@@ -50,6 +50,7 @@ enum errlUserDataType_t
HBERRL_UDT_STRING = 1,
HBERRL_UDT_TARGET = 2,
HBERRL_UDT_BACKTRACE = 3,
+ HBERRL_UDT_ATTRIBUTE = 4,
};
diff --git a/src/include/usr/targeting/common/target.H b/src/include/usr/targeting/common/target.H
index d91483cad..bd37b8a01 100644
--- a/src/include/usr/targeting/common/target.H
+++ b/src/include/usr/targeting/common/target.H
@@ -249,7 +249,7 @@ class Target
*
* @post caller must call free() to release the buffer
*/
- char * targetFFDC( uint32_t & o_size ) const;
+ uint8_t * targetFFDC( uint32_t & o_size ) const;
private: // Private helper interfaces
diff --git a/src/usr/errl/errlud.C b/src/usr/errl/errlud.C
index 2d707e286..0a442781b 100644
--- a/src/usr/errl/errlud.C
+++ b/src/usr/errl/errlud.C
@@ -77,7 +77,7 @@ ErrlUD::ErrlUD(
ErrlUD::~ErrlUD()
{
- if( iv_pData ) free( iv_pData );
+ free( iv_pData );
}
@@ -90,31 +90,20 @@ ErrlUD::~ErrlUD()
uint64_t ErrlUD::addData(const void *i_data, const uint64_t i_size)
{
- uint64_t l_rc = 0;
-
// Expected new size of user data.
uint64_t l_newsize = iv_Size + i_size;
// Resize memory block
iv_pData = static_cast<uint8_t*>(realloc(iv_pData, l_newsize));
- // Make sure reallocate call succeeds
- if (iv_pData != NULL)
- {
- // Copy new data to new area, past existing data (if any)
- memcpy( iv_pData + iv_Size, i_data, i_size );
+ // Copy new data to new area, past existing data (if any)
+ memcpy( iv_pData + iv_Size, i_data, i_size );
- // Save new size of the user-provided data. This will also
- // be what this method returns.
- iv_Size = l_newsize;
- l_rc = iv_Size;
- }
- else
- {
- TRACFCOMP( g_trac_errl,
- "ErrlUD::addData() - Reallocate memory failed!");
- }
- return l_rc;
+ // Save new size of the user-provided data. This will also
+ // be what this method returns.
+ iv_Size = l_newsize;
+
+ return iv_Size;
}
diff --git a/src/usr/errl/errludtarget.C b/src/usr/errl/errludtarget.C
index 86d221b47..b0a6879d3 100644
--- a/src/usr/errl/errludtarget.C
+++ b/src/usr/errl/errludtarget.C
@@ -28,6 +28,7 @@
#include <errl/errludtarget.H>
#include <targeting/common/target.H>
#include <targeting/common/targetservice.H>
+#include <targeting/common/trace.H>
namespace ERRORLOG
{
@@ -35,9 +36,27 @@ namespace ERRORLOG
//------------------------------------------------------------------------------
ErrlUserDetailsTarget::ErrlUserDetailsTarget(
const TARGETING::Target * i_pTarget)
-: iv_pTarget(i_pTarget)
{
+ // Set up ErrlUserDetails instance variables
+ iv_CompId = HBERRL_COMP_ID;
+ iv_Version = 1;
+ iv_SubSection = HBERRL_UDT_TARGET;
+ if (i_pTarget == TARGETING::MASTER_PROCESSOR_CHIP_TARGET_SENTINEL)
+ {
+ uint8_t *pBuffer = reinterpret_cast<uint8_t *>(
+ reallocUsrBuf(sizeof(uint8_t)));
+ // copy 0x1 to indicate MASTER
+ *pBuffer = 1;
+ }
+ else
+ {
+ uint32_t bufSize = 0;
+ uint8_t *pTargetString = i_pTarget->targetFFDC(bufSize);
+ uint8_t *pBuffer = reinterpret_cast<uint8_t *>(reallocUsrBuf(bufSize));
+ memcpy(pBuffer, pTargetString, bufSize);
+ free (pTargetString);
+ }
}
//------------------------------------------------------------------------------
@@ -46,34 +65,5 @@ ErrlUserDetailsTarget::~ErrlUserDetailsTarget()
}
-//------------------------------------------------------------------------------
-void ErrlUserDetailsTarget::addToLog(errlHndl_t i_errl)
-{
- if (i_errl != NULL)
- {
- if (iv_pTarget == TARGETING::MASTER_PROCESSOR_CHIP_TARGET_SENTINEL)
- {
- const char *l_bufPtr = "MASTER_PROCESSOR_CHIP_TARGET_SENTINEL";
- i_errl->addFFDC(HBERRL_COMP_ID,
- l_bufPtr, strlen(l_bufPtr)+1,
- 1, HBERRL_UDT_TARGET);
- }
- else
- {
- uint32_t l_bufSize = 0;
- char * l_bufPtr = NULL;
-
- l_bufPtr = iv_pTarget->targetFFDC( l_bufSize );
- if (l_bufPtr)
- {
- i_errl->addFFDC(HBERRL_COMP_ID,
- l_bufPtr, l_bufSize,
- 1, HBERRL_UDT_TARGET);
- free (l_bufPtr);
- }
- }
- }
-}
-
}
diff --git a/src/usr/errl/makefile b/src/usr/errl/makefile
index 1d5c515e9..0a12e57f0 100644
--- a/src/usr/errl/makefile
+++ b/src/usr/errl/makefile
@@ -25,8 +25,11 @@ MODULE = errl
OBJS = errlentry.o errlmanager.o errlsctn.o errlsctnhdr.o errlprvt.o errluh.o \
errlud.o errlsrc.o errluserdetails.o backtrace.o errludtarget.o \
- errludstring.o errludbacktrace.o
+ errludstring.o errludbacktrace.o errludattribute.o
SUBDIRS = test.d parser.d
include ${ROOTPATH}/config.mk
+
+# to find errludattribute.C and .H
+vpath %.C ${GENDIR}
diff --git a/src/usr/errl/test/errluserdetailtest.H b/src/usr/errl/test/errluserdetailtest.H
index 8fb1f3ed5..c70119a74 100644
--- a/src/usr/errl/test/errluserdetailtest.H
+++ b/src/usr/errl/test/errluserdetailtest.H
@@ -35,6 +35,13 @@
#include <errl/errluserdetails.H>
#include <errl/errlreasoncodes.H>
#include <errl/errludstring.H>
+#include <errl/errludbacktrace.H>
+#include <errl/errludtarget.H>
+#include <errludattribute.H>
+#include <targeting/common/targetservice.H>
+#include <targeting/common/iterators/rangefilter.H>
+#include <targeting/common/predicates/predicates.H>
+#include <targeting/common/util.H>
using namespace ERRORLOG;
@@ -61,8 +68,8 @@ public:
* @userdata2 Test data 2
* @devdesc User Details unit test - create string user detail data
*/
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_INFORMATIONAL,
+ l_errl = new ErrlEntry(
+ ERRL_SEV_INFORMATIONAL,
HBERRL_USERDATA_TEST_MOD_ID,
HBERRL_TEST_STRING_UD,
0x1234567890, // user1
@@ -76,6 +83,112 @@ public:
errlCommit(l_errl, CXXTEST_COMP_ID);
}
+ /**
+ * @test testAttribute - Capture a String in an error log
+ */
+ void testAttribute(void)
+ {
+ errlHndl_t l_err = NULL;
+
+ TS_TRACE( "testAttribute errorlog user detail data");
+ /*@
+ * @errortype
+ * @severity ERRORLOG_SEV_INFORMATIONAL
+ * @moduleid HBERRL_USERDATA_TEST_MOD_ID
+ * @reasoncode HBERRL_TEST_ATTRIBUTE_UD
+ * @userdata1 Test data 1
+ * @userdata2 Test data 2
+ * @devdesc User Details unit test - create string user detail data
+ */
+ l_err = new ErrlEntry(
+ ERRL_SEV_INFORMATIONAL,
+ HBERRL_USERDATA_TEST_MOD_ID,
+ HBERRL_TEST_ATTRIBUTE_UD,
+ 0x0001002300450067,
+ 0x008900AB00CD00EF);
+
+ using namespace TARGETING;
+
+ // find a proc target
+ PredicateCTM procChipFilter(CLASS_CHIP,TYPE_PROC);
+ TargetRangeFilter pProc(
+ targetService().begin(), targetService().end(),
+ &procChipFilter);
+
+ // find a membuf target
+ PredicateCTM membufChipFilter(CLASS_CHIP,TYPE_MEMBUF);
+ TargetRangeFilter pMembuf(
+ targetService().begin(), targetService().end(),
+ &membufChipFilter);
+
+ // find a dimm target
+ PredicateCTM dimmChipFilter(CLASS_NA,TYPE_DIMM);
+ TargetRangeFilter pDimm(
+ targetService().begin(), targetService().end(),
+ &dimmChipFilter);
+
+ const Target* c_target;
+ c_target = *pProc;
+ TS_TRACE( "testAttribute pProc %p", c_target);
+ ErrlUserDetailsString("Attribute test").addToLog(l_err);
+ ErrlUserDetailsTarget(c_target).addToLog(l_err);
+ ErrlUserDetailsBackTrace().addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_CLASS).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_TYPE).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_MODEL).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_PHYS_PATH).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_SCRATCH_UINT8_1).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_HUID).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_DUMMY_WO).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target).addToLog(l_err);
+
+ c_target = *pMembuf;
+ TS_TRACE( "testAttribute pMembuf %p", c_target);
+ ErrlUserDetailsString("Attribute test").addToLog(l_err);
+ ErrlUserDetailsTarget(c_target).addToLog(l_err);
+ ErrlUserDetailsBackTrace().addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_CLASS).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_TYPE).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_MODEL).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_PHYS_PATH).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_SCRATCH_UINT8_1).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_HUID).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_DUMMY_WO).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target).addToLog(l_err);
+
+ c_target = *pDimm;
+ TS_TRACE( "testAttribute pDimm %p", c_target);
+ ErrlUserDetailsString("Attribute test").addToLog(l_err);
+ ErrlUserDetailsTarget(c_target).addToLog(l_err);
+ ErrlUserDetailsBackTrace().addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_CLASS).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_TYPE).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_MODEL).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_PHYS_PATH).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_SCRATCH_UINT8_1).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_HUID).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target,ATTR_DUMMY_WO).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target).addToLog(l_err);
+
+#if 0
+ // extended test
+ uint32_t i = 0;
+ for (TargetIterator target = targetService().begin();
+ (i < 10) && (target != targetService().end());
+ ++i, ++target)
+ {
+ TS_TRACE( "testAttribute %p", *target);
+ const Target* c_target = *target;
+ ErrlUserDetailsTarget(c_target).addToLog(l_err);
+ ErrlUserDetailsAttribute(c_target).addToLog(l_err);
+ }
+#endif
+
+ // commit the errorlog
+ errlCommit(l_err, CXXTEST_COMP_ID);
+ TS_TRACE( "testAttribute done");
+ }
+
};
#endif
diff --git a/src/usr/targeting/common/target.C b/src/usr/targeting/common/target.C
index 9da4de170..96e6c89e0 100644
--- a/src/usr/targeting/common/target.C
+++ b/src/usr/targeting/common/target.C
@@ -148,7 +148,7 @@ void Target::_getAttrPtr(
// Only translate addresses on platforms where addresses are 4 bytes
// wide (FSP). The compiler should perform dead code elimination of
- // this path on platforms with 8 byte wide addresses (Hostboot),
+ // this path on platforms with 8 byte wide addresses (Hostboot),
// since the "if" check can be statically computed at compile time.
if(TARG_ADDR_TRANSLATION_REQUIRED)
{
@@ -177,12 +177,12 @@ mutex_t* Target::_getHbMutexAttr(
void* l_pAttr = NULL;
(void)_getAttrPtr(i_attribute,l_pAttr);
- //@TODO Remove assert once release has stablized
+ //@TODO Remove assert once release has stablized
TARG_ASSERT(l_pAttr,"TARGETING::Target::_getHbMutexAttr<%d>: _getAttrPtr "
"returned NULL",i_attribute);
return static_cast<mutex_t*>(l_pAttr);
-
+
#undef TARG_FN
}
@@ -195,12 +195,12 @@ bool Target::_tryGetHbMutexAttr(
mutex_t*& o_pMutex) const
{
#define TARG_FN "_tryGetHbMutexAttr()"
-
+
void* l_pAttr = NULL;
(void)_getAttrPtr(i_attribute,l_pAttr);
o_pMutex = static_cast<mutex_t*>(l_pAttr);
return (l_pAttr != NULL);
-
+
#undef TARG_FN
}
@@ -222,51 +222,69 @@ Target::Target()
// Target::targetFFDC()
//******************************************************************************
-char * Target::targetFFDC( uint32_t & o_size ) const
+uint8_t * Target::targetFFDC( uint32_t & o_size ) const
{
#define TARG_FN "targetFFDC(...)"
- char l_buff[128];
- char *l_pFFDC = NULL;
- char *l_ptr = NULL;
- void *l_ptr1 = NULL;
- uint32_t l_len;
-
- o_size = sprintf( l_buff, "Class = 0x%X, Type = 0x%X, Model = 0x%X",
- getAttr<ATTR_CLASS>(),
- getAttr<ATTR_TYPE>(),
- getAttr<ATTR_MODEL>() );
+ AttributeTraits<ATTR_HUID>::Type attrHuid = getAttr<ATTR_HUID>();
+ AttributeTraits<ATTR_CLASS>::Type attrClass = getAttr<ATTR_CLASS>();
+ AttributeTraits<ATTR_TYPE>::Type attrType = getAttr<ATTR_TYPE>();
+ AttributeTraits<ATTR_MODEL>::Type attrModel = getAttr<ATTR_MODEL>();
+ uint32_t headerSize = sizeof(uint8_t) + sizeof(attrHuid) +
+ sizeof(attrClass) + sizeof(attrType) +
+ sizeof(attrModel);
+
+ uint8_t pathPhysSize = 0;
+ AttributeTraits<ATTR_PHYS_PATH>::Type pathPhys;
+ if( tryGetAttr<ATTR_PHYS_PATH>(pathPhys) ) {
+ // entityPath is PATH_TYPE:4, NumberOfElements:4, [Element, Instance#]
+ pathPhysSize = sizeof(uint8_t) + (sizeof(pathPhys[0]) * pathPhys.size());
+ }
- l_pFFDC = static_cast<char*>( malloc( ++o_size ) );
- memcpy( l_pFFDC, l_buff, o_size );
+ uint8_t pathAffSize = 0;
+ AttributeTraits<ATTR_AFFINITY_PATH>::Type pathAff;
+ if( tryGetAttr<ATTR_AFFINITY_PATH>(pathAff) ) {
+ // entityPath is PATH_TYPE:4, NumberOfElements:4, [Element, Instance#]
+ pathAffSize = sizeof(uint8_t) + (sizeof(pathAff[0]) * pathAff.size());
+ }
- l_ptr = getAttr<ATTR_PHYS_PATH>().toString();
- if (l_ptr)
+ uint8_t *pFFDC;
+ pFFDC = static_cast<uint8_t*>( malloc(headerSize +
+ pathPhysSize + pathAffSize));
+
+ // we'll send down a '0' then HUID CLASS TYPE and MODEL
+ uint32_t bSize = 0; // size of data in the buffer
+ *pFFDC = 0;
+ bSize++;
+ memcpy(pFFDC + bSize, &attrHuid, sizeof(attrHuid) );
+ bSize += sizeof(attrHuid);
+ memcpy(pFFDC + bSize, &attrClass, sizeof(attrClass) );
+ bSize += sizeof(attrClass);
+ memcpy(pFFDC + bSize, &attrType, sizeof(attrType) );
+ bSize += sizeof(attrType);
+ memcpy(pFFDC + bSize, &attrModel, sizeof(attrModel) );
+ bSize += sizeof(attrModel);
+
+ if( pathPhysSize > 0)
{
- l_len = strlen( l_ptr ) + 1;
- l_ptr1 = realloc( l_pFFDC, o_size + l_len );
- l_pFFDC = static_cast<char*>( l_ptr1 );
- memcpy( l_pFFDC + o_size, l_ptr, l_len );
- o_size += l_len;
- free( l_ptr );
+ uint8_t attrEnum = ATTR_PHYS_PATH;
+ memcpy(pFFDC + bSize, &attrEnum, sizeof(attrEnum));
+ bSize += sizeof(attrEnum);
+ memcpy(pFFDC + bSize, &pathPhys, pathPhysSize);
+ bSize += pathPhysSize;
}
- EntityPath l_entityPath;
- if( tryGetAttr<ATTR_AFFINITY_PATH>(l_entityPath) )
+ if( pathAffSize > 0)
{
- l_ptr = l_entityPath.toString();
- if (l_ptr)
- {
- l_len = strlen( l_ptr ) + 1;
- l_ptr1 = realloc( l_pFFDC, o_size + l_len );
- l_pFFDC = static_cast<char*>( l_ptr1 );
- memcpy( l_pFFDC + o_size, l_ptr, l_len );
- o_size += l_len;
- free( l_ptr );
- }
+ uint8_t attrEnum = ATTR_AFFINITY_PATH;
+ memcpy(pFFDC + bSize, &attrEnum, sizeof(attrEnum));
+ bSize += sizeof(attrEnum);
+ memcpy(pFFDC + bSize, &pathAff, pathAffSize);
+ bSize += pathAffSize;
}
- return l_pFFDC;
+ o_size = bSize;
+ return pFFDC;
#undef TARG_FN
}
diff --git a/src/usr/targeting/common/xmltohb/xmltohb.pl b/src/usr/targeting/common/xmltohb/xmltohb.pl
index 1abd986d3..de841d72a 100755
--- a/src/usr/targeting/common/xmltohb/xmltohb.pl
+++ b/src/usr/targeting/common/xmltohb/xmltohb.pl
@@ -198,6 +198,20 @@ if( !($cfgSrcOutputDir =~ "none") )
writeDumpFile($attributes,$dumpFile);
close $dumpFile;
+ open(ATTR_ATTRERRL_C_FILE,">$cfgSrcOutputDir"."errludattribute.C")
+ or fatal ("Attribute errlog C file: \"$cfgSrcOutputDir"
+ . "errludattribute.C\" could not be opened.");
+ my $attrErrlCFile = *ATTR_ATTRERRL_C_FILE;
+ writeAttrErrlCFile($attributes,$attrErrlCFile);
+ close $attrErrlCFile;
+
+ open(ATTR_ATTRERRL_H_FILE,">$cfgSrcOutputDir"."errludattribute.H")
+ or fatal ("Attribute errlog H file: \"$cfgSrcOutputDir"
+ . "errludattribute.H\" could not be opened.");
+ my $attrErrlHFile = *ATTR_ATTRERRL_H_FILE;
+ writeAttrErrlHFile($attributes,$attrErrlHFile);
+ close $attrErrlHFile;
+
}
if( !($cfgImgOutputDir =~ "none") )
@@ -1411,6 +1425,543 @@ sub writeTraitFileFooter {
VERBATIM
}
+######
+#Create a .C file to put attributes into the errlog
+#####
+sub writeAttrErrlCFile {
+ my($attributes,$outFile) = @_;
+
+ #First setup the includes and function definition
+ print $outFile "#include <stdint.h>\n";
+ print $outFile "#include <stdio.h>\n";
+ print $outFile "#include <string.h>\n";
+ print $outFile "#include <errludattribute.H>\n";
+ print $outFile "#include <targeting/common/targetservice.H>\n";
+ print $outFile "#include <targeting/common/trace.H>\n";
+ print $outFile "\n";
+ print $outFile "namespace ERRORLOG\n";
+ print $outFile "{\n";
+ print $outFile "using namespace TARGETING;\n";
+ print $outFile "extern TARG_TD_t g_trac_errl; \n";
+
+ # loop through every attribute to create the local dump function
+ foreach my $attribute (@{$attributes->{attribute}})
+ {
+ # things we'll skip:
+ if(!(exists $attribute->{readable}) || # write-only attributes
+ !(exists $attribute->{writeable}) || # read-only attributes
+ (exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{hbmutex})) # mutex attributes
+ ) {
+ next;
+ }
+ # any complicated types just get dumped as raw hex binary
+ elsif(exists $attribute->{complexType}) {
+ #print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ #print $outFile "{ //complexType\n";
+ #print $outFile " uint32_t retSize = 0;\n";
+ #print $outFile " AttributeTraits<ATTR_",$attribute->{id},">::Type tmp;\n";
+ #print $outFile " if( i_pTarget->tryGetAttr<ATTR_",$attribute->{id},">(tmp) ) {\n";
+ #print $outFile " retSize = 1 + sprintf(i_buffer, \" \", &tmp, sizeof(tmp));\n";
+ #print $outFile " }\n";
+ #print $outFile " return(retSize);\n";
+ #print $outFile "}\n";
+ print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ print $outFile "{ //complexType\n";
+ print $outFile " TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: ",$attribute->{id}," skipped -- complexType\");\n";
+ print $outFile " return(0);\n";
+ print $outFile "}\n";
+ }
+ # Enums
+ elsif(exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{enumeration}) ) {
+ print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ print $outFile "{ //simpleType:enum\n";
+ print $outFile " //TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: ",$attribute->{id}," entry\");\n";
+ print $outFile " uint32_t retSize = 0;\n";
+ print $outFile " AttributeTraits<ATTR_",$attribute->{id},">::Type tmp;\n";
+ print $outFile " if( i_pTarget->tryGetAttr<ATTR_",$attribute->{id},">(tmp) ) {\n";
+ print $outFile " memcpy(i_buffer, &tmp, sizeof(tmp));\n";
+ print $outFile " retSize = sizeof(tmp);\n";
+ print $outFile " }\n";
+ print $outFile " return(retSize);\n";
+ print $outFile "}\n";
+ }
+ # signed and unsigned ints
+ elsif(exists $attribute->{simpleType} &&
+ ( (exists $attribute->{simpleType}->{uint8_t}) ||
+ (exists $attribute->{simpleType}->{uint16_t}) ||
+ (exists $attribute->{simpleType}->{uint32_t}) ||
+ (exists $attribute->{simpleType}->{uint64_t}) ||
+ (exists $attribute->{simpleType}->{int8_t}) ||
+ (exists $attribute->{simpleType}->{int16_t}) ||
+ (exists $attribute->{simpleType}->{int32_t}) ||
+ (exists $attribute->{simpleType}->{int64_t})
+ )
+ )
+ {
+ print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ print $outFile "{ //simpleType:uint :int\n";
+ print $outFile " //TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: ",$attribute->{id}," entry\");\n";
+ print $outFile " uint32_t retSize = 0;\n";
+ print $outFile " AttributeTraits<ATTR_",$attribute->{id},">::Type tmp;\n";
+ print $outFile " if( i_pTarget->tryGetAttr<ATTR_",$attribute->{id},">(tmp) ) {\n";
+ print $outFile " memcpy(i_buffer, &tmp, sizeof(tmp));\n";
+ print $outFile " retSize = sizeof(tmp);\n";
+ print $outFile " }\n";
+ print $outFile " return(retSize);\n";
+ print $outFile "}\n";
+ }
+ # dump the enums for EntityPaths
+ elsif(exists $attribute->{nativeType} && ($attribute->{nativeType}->{name} eq "EntityPath")) {
+ print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ print $outFile "{ //nativeType:EntityPath\n";
+ print $outFile " //TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: ",$attribute->{id}," entry\");\n";
+ print $outFile " uint32_t retSize = 0;\n";
+ print $outFile " AttributeTraits<ATTR_",$attribute->{id},">::Type tmp;\n";
+ print $outFile " if( i_pTarget->tryGetAttr<ATTR_",$attribute->{id},">(tmp) ) {\n";
+ print $outFile " // data is PATH_TYPE, Number of elements, [ Element, Instance# ] \n";
+ print $outFile " EntityPath::PATH_TYPE lPtype = tmp.type();\n";
+ print $outFile " memcpy(i_buffer + retSize,&lPtype,sizeof(lPtype));\n";
+ print $outFile " retSize += sizeof(lPtype);\n";
+ print $outFile " uint8_t lSize = tmp.size();\n";
+ print $outFile " memcpy(i_buffer + retSize,&lSize,sizeof(lSize));\n";
+ print $outFile " retSize += sizeof(lSize);\n";
+ print $outFile " for (uint32_t i=0;i<lSize;i++) {\n";
+ print $outFile " EntityPath::PathElement lType = tmp[i];\n";
+ print $outFile " memcpy(i_buffer + retSize,&tmp[i],sizeof(tmp[i]));\n";
+ print $outFile " retSize += sizeof(tmp[i]);\n";
+ print $outFile " }\n";
+ print $outFile " }\n";
+ print $outFile " return(retSize);\n";
+ print $outFile "}\n";
+ }
+ # any other nativeTypes are just decimals... (I never saw one)
+ elsif(exists $attribute->{nativeType}) {
+ print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ print $outFile "{ //nativeType\n";
+ print $outFile " //TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: ",$attribute->{id}," entry\");\n";
+ print $outFile " uint32_t retSize = 0;\n";
+ print $outFile " AttributeTraits<ATTR_",$attribute->{id},">::Type tmp;\n";
+ print $outFile " if( i_pTarget->tryGetAttr<ATTR_",$attribute->{id},">(tmp) ) {\n";
+ print $outFile " memcpy(i_buffer, &tmp, sizeof(tmp));\n";
+ print $outFile " retSize = sizeof(tmp);\n";
+ print $outFile " }\n";
+ print $outFile " return(retSize);\n";
+ print $outFile "}\n";
+ }
+ # just in case, add a dummy function
+ else
+ {
+ print $outFile "uint32_t dump_ATTR_",$attribute->{id},"(const Target * i_pTarget, char *i_buffer)\n";
+ print $outFile "{ //unknown attributes\n";
+ print $outFile " TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: ",$attribute->{id}," UNKNOWN\");\n";
+ print $outFile " return(0);\n";
+ print $outFile "}\n";
+ }
+ }
+
+ # build function that takes prints 1 attribute
+ print $outFile "\n";
+ print $outFile "ErrlUserDetailsAttribute::ErrlUserDetailsAttribute(\n";
+ print $outFile " const Target * i_pTarget, uint8_t i_attr)\n";
+ print $outFile "{\n";
+ print $outFile " // Set up ErrlUserDetails instance variables\n";
+ print $outFile " iv_CompId = HBERRL_COMP_ID;\n";
+ print $outFile " iv_Version = 1;\n";
+ print $outFile " iv_SubSection = HBERRL_UDT_ATTRIBUTE;\n";
+ print $outFile "\n";
+ print $outFile " char tmpBuffer[128];\n";
+ print $outFile " uint32_t attrSize = 0;\n";
+ print $outFile "\n";
+ print $outFile " switch (i_attr) {\n";
+
+ # loop through every attribute to make the swith/case
+ foreach my $attribute (@{$attributes->{attribute}})
+ {
+ # things we'll skip:
+ if(!(exists $attribute->{readable}) || # write-only attributes
+ !(exists $attribute->{writeable}) || # read-only attributes
+ (exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{hbmutex})) # mutex attributes
+ ) {
+ print $outFile " case (ATTR_",$attribute->{id},"): { break; }\n";
+ next;
+ }
+ print $outFile " case (ATTR_",$attribute->{id},"): {\n";
+ print $outFile " attrSize = dump_ATTR_",$attribute->{id},"(i_pTarget,tmpBuffer); break;\n";
+ print $outFile " }\n";
+ }
+
+ print $outFile " default: { //Shouldn't be anything here!!\n";
+ print $outFile " TRACDCOMP( g_trac_errl, \"ErrlUserDetailsAttribute: UNKNOWN i_attr %x - dumping HUID\", i_attr);\n";
+ print $outFile " attrSize = dump_ATTR_HUID(i_pTarget,tmpBuffer); break;\n";
+ print $outFile " break;\n";
+ print $outFile " }\n";
+ print $outFile " } //switch\n";
+ print $outFile "\n";
+ print $outFile " // if we generated one, copy the string into the buffer\n";
+ print $outFile " if (attrSize) {\n";
+ print $outFile " // first, write out the HUID if we didn't already\n";
+ print $outFile " if (i_attr != ATTR_HUID) {\n";
+ print $outFile " char huidBuffer[128];\n";
+ print $outFile " uint32_t huidSize = dump_ATTR_HUID(i_pTarget,huidBuffer);\n";
+ print $outFile " // resize buffer\n";
+ print $outFile " uint8_t * pBuf;\n";
+ print $outFile " pBuf = reinterpret_cast<uint8_t *>(reallocUsrBuf(huidSize + attrSize + 2));\n";
+ print $outFile " *pBuf = ATTR_HUID; // first dump the attr enum\n";
+ print $outFile " pBuf++;\n";
+ print $outFile " memcpy(pBuf, huidBuffer, huidSize); // copy huid into iv_pBuffer\n";
+ print $outFile " pBuf += huidSize;\n";
+ print $outFile " memcpy(pBuf, &i_attr, 1); // first dump the attr enum\n";
+ print $outFile " pBuf++;\n";
+ print $outFile " memcpy(pBuf, tmpBuffer, attrSize); // copy tmpBuffer into iv_pBuffer\n";
+ print $outFile " //pBuf += attrSize;\n";
+ print $outFile " } else { // it IS HUID - just dump it\n";
+ print $outFile " // resize buffer\n";
+ print $outFile " uint8_t * pBuf;\n";
+ print $outFile " pBuf = reinterpret_cast<uint8_t *>(reallocUsrBuf(attrSize + 1));\n";
+ print $outFile " *pBuf = i_attr; // first dump the attr enum\n";
+ print $outFile " pBuf++;\n";
+ print $outFile " memcpy(pBuf, tmpBuffer, attrSize); // copy tmpBuffer into iv_pBuffer\n";
+ print $outFile " //pBuf += attrSize;\n";
+ print $outFile " }\n";
+ print $outFile " }\n";
+ print $outFile "}\n";
+
+ # build function that takes prints all attributes
+ print $outFile "\n";
+ print $outFile "ErrlUserDetailsAttribute::ErrlUserDetailsAttribute(\n";
+ print $outFile " const Target * i_pTarget)\n";
+ print $outFile "{\n";
+ print $outFile " // Set up ErrlUserDetails instance variables\n";
+ print $outFile " iv_CompId = HBERRL_COMP_ID;\n";
+ print $outFile " iv_Version = 1;\n";
+ print $outFile " iv_SubSection = HBERRL_UDT_ATTRIBUTE;\n";
+ print $outFile "\n";
+ print $outFile " char tmpBuffer[128];\n";
+ print $outFile " uint8_t * pBuf;\n";
+ print $outFile " uint32_t attrSize = 0, bufSize = 0;\n";
+ print $outFile "\n";
+ print $outFile " // write out the HUID first and always\n";
+ print $outFile " attrSize = dump_ATTR_HUID(i_pTarget,tmpBuffer);\n";
+ print $outFile " pBuf = reinterpret_cast<uint8_t *>(reallocUsrBuf(bufSize + attrSize + 1)); \n";
+ print $outFile " *pBuf = ATTR_HUID; // first dump the attr enum\n";
+ print $outFile " bufSize++;\n";
+ print $outFile " memcpy(pBuf + bufSize, tmpBuffer, attrSize); // copy into iv_pBuffer \n";
+ print $outFile " bufSize += attrSize; \n";
+ print $outFile "\n";
+
+ # loop through every attribute to make the swith/case
+ foreach my $attribute (@{$attributes->{attribute}})
+ {
+ # skip the HUID that we already added
+ if( $attribute->{id} =~ /HUID/ ) {
+ next;
+ }
+ # things we'll skip:
+ if(!(exists $attribute->{readable}) || # write-only attributes
+ !(exists $attribute->{writeable}) || # read-only attributes
+ (exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{hbmutex})) # mutex attributes
+ ) {
+ next;
+ }
+ print $outFile " attrSize = dump_ATTR_",$attribute->{id},"(i_pTarget,tmpBuffer);\n";
+ print $outFile " if (attrSize) { // we have something to output\n";
+ print $outFile " // resize buffer and copy string into it\n";
+ print $outFile " pBuf = reinterpret_cast<uint8_t *>(reallocUsrBuf(bufSize + attrSize + 1));\n";
+ print $outFile " *(pBuf + bufSize) = ATTR_",$attribute->{id},"; // first dump the attr enum\n";
+ print $outFile " bufSize++;\n";
+ print $outFile " memcpy(pBuf + bufSize, tmpBuffer, attrSize); // copy into iv_pBuffer\n";
+ print $outFile " bufSize += attrSize;\n";
+ print $outFile " }\n";
+ print $outFile "\n";
+ }
+
+ print $outFile "}\n";
+
+ print $outFile "\n";
+ print $outFile "//------------------------------------------------------------------------------\n";
+ print $outFile "ErrlUserDetailsAttribute::~ErrlUserDetailsAttribute()\n";
+ print $outFile "{ }\n";
+ print $outFile "} // namespace\n";
+} # sub writeAttrErrlCFile
+
+
+######
+#Create a .H file to parse attributes out of the errlog
+#####
+sub writeAttrErrlHFile {
+ my($attributes,$outFile) = @_;
+
+ #First setup the includes and function definition
+ print $outFile "\n";
+ print $outFile "#ifndef ERRL_UDATTRIBUTE_H\n";
+ print $outFile "#define ERRL_UDATTRIBUTE_H\n";
+ print $outFile "\n";
+ print $outFile "#include <errl/errluserdetails.H>\n";
+ print $outFile "\n";
+ print $outFile "#ifndef PARSER\n";
+ print $outFile "\n";
+ print $outFile "namespace TARGETING // Forward reference\n";
+ print $outFile "{ class Target; } \n";
+ print $outFile "\n";
+ print $outFile "namespace ERRORLOG\n";
+ print $outFile "{\n";
+ print $outFile "class ErrlUserDetailsAttribute : public ErrlUserDetails {\n";
+ print $outFile "public:\n";
+ print $outFile "\n";
+ print $outFile " ErrlUserDetailsAttribute(const TARGETING::Target * i_pTarget, uint8_t i_attr);\n";
+ print $outFile "\n";
+ print $outFile " ErrlUserDetailsAttribute(const TARGETING::Target * i_pTarget);\n";
+ print $outFile "\n";
+ print $outFile " virtual ~ErrlUserDetailsAttribute();\n";
+ print $outFile "\n";
+ print $outFile "private:\n";
+ print $outFile "\n";
+ print $outFile "// Disabled\n";
+ print $outFile " ErrlUserDetailsAttribute(const ErrlUserDetailsAttribute &);\n";
+ print $outFile " ErrlUserDetailsAttribute & operator=(const ErrlUserDetailsAttribute &);\n";
+ print $outFile "};\n";
+ print $outFile "}\n";
+ print $outFile "#else // if PARSER defined\n";
+ print $outFile "\n";
+ print $outFile "#include <string.h>\n";
+ print $outFile "\n";
+ print $outFile "namespace ERRORLOG\n";
+ print $outFile "{\n";
+ print $outFile "class ErrlUserDetailsParserAttribute : public ErrlUserDetailsParser {\n";
+ print $outFile "public:\n";
+ print $outFile "\n";
+ print $outFile " ErrlUserDetailsParserAttribute() {}\n";
+ print $outFile "\n";
+ print $outFile " virtual ~ErrlUserDetailsParserAttribute() {}\n";
+ print $outFile "/**\n";
+ print $outFile " * \@brief Parses Attribute user detail data from an error log\n";
+ print $outFile " * \@param i_version Version of the data\n";
+ print $outFile " * \@param i_parse ErrlUsrParser object for outputting information\n";
+ print $outFile " * \@param i_pBuffer Pointer to buffer containing detail data\n";
+ print $outFile " * \@param i_buflen Length of the buffer\n";
+ print $outFile " */\n";
+ print $outFile " virtual void parse(errlver_t i_version, \n";
+ print $outFile " ErrlUsrParser & i_parser,\n";
+ print $outFile " void * i_pBuffer,\n";
+ print $outFile " const uint32_t i_buflen) const\n";
+ print $outFile " {\n";
+ print $outFile " const char *pLabel;\n";
+ print $outFile " uint8_t *l_ptr = static_cast<char *>(i_pBuffer);\n";
+ print $outFile " uint32_t i = 0;\n";
+ print $outFile " std::vector<char> l_traceEntry(128);\n";
+ print $outFile "\n";
+ print $outFile " for (; i < i_buflen; ) {\n";
+ print $outFile " if (*l_ptr == 0) { // skip over NULLs\n";
+ print $outFile " l_ptr++;\n";
+ print $outFile " i++;\n";
+ print $outFile " continue;\n";
+ print $outFile " }\n";
+ print $outFile " // first byte is the attr enum\n";
+ print $outFile " uint8_t attrEnum = *l_ptr;\n";
+ print $outFile " uint32_t dataSize = 0;\n";
+ print $outFile " l_ptr++;\n";
+ print $outFile " i++;\n";
+ print $outFile "\n";
+ print $outFile " switch (attrEnum) {\n";
+
+ # loop through every attribute to make the swith/case
+ foreach my $attribute (@{$attributes->{attribute}})
+ {
+ my $attrVal = sprintf "0x%02X", $attribute->{value};
+ print $outFile " case ",$attrVal,": {\n";
+
+ # things we'll skip:
+ if(!(exists $attribute->{readable}) || # write-only attributes
+ !(exists $attribute->{writeable}) || # read-only attributes
+ (exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{hbmutex})) # mutex attributes
+ ) {
+ print $outFile " //not readable\n";
+ }
+ # Enums have strings defined already, use them
+ elsif(exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{enumeration}) ) {
+ print $outFile " //simpleType:enum\n";
+ print $outFile " pLabel = \"ATTR_",$attribute->{id},"\";\n";
+ foreach my $enumerationType (@{$attributes->{enumerationType}})
+ {
+ if ($enumerationType->{id} eq $attribute->{id})
+ {
+ print $outFile " switch (*l_ptr) {\n";
+ foreach my $enumerator (@{$enumerationType->{enumerator}})
+ {
+ my $enumName = $attribute->{id} . "_" . $enumerator->{name};
+ my $enumHex = sprintf "0x%02X", enumNameToValue($enumerationType,$enumerator->{name});
+ print $outFile " case ",$enumHex,": {\n";
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"",$enumName,"\");\n";
+ print $outFile " break;\n";
+ print $outFile " }\n";
+ }
+ print $outFile " default: break;\n";
+ print $outFile " }\n";
+ }
+ }
+ }
+ # makes no sense to dump mutex attributes, so skipping
+ elsif(exists $attribute->{simpleType} && (exists $attribute->{simpleType}->{hbmutex}) ) {
+ print $outFile " //Mutex attributes - skipping\n";
+ }
+ # any complicated types just get dumped as raw hex binary
+ elsif(exists $attribute->{complexType}) {
+ #print $outFile " //complexType\n";
+ #print $outFile " uint32_t<ATTR_",$attribute->{id},">::Type tmp;\n";
+ #print $outFile " if( i_pTarget->tryGetAttr<ATTR_",$attribute->{id},">(tmp) ) {\n";
+ #print $outFile " dataSize = sprintf(i_buffer, \" \", &tmp, sizeof(tmp));\n";
+ #print $outFile " }\n";
+ print $outFile " //complexType - skipping\n";
+ }
+ # unsigned ints dump as hex, signed as decimals
+ elsif(exists $attribute->{simpleType} &&
+ ( (exists $attribute->{simpleType}->{uint8_t}) ||
+ (exists $attribute->{simpleType}->{uint16_t}) ||
+ (exists $attribute->{simpleType}->{uint32_t}) ||
+ (exists $attribute->{simpleType}->{uint64_t}) ||
+ (exists $attribute->{simpleType}->{int8_t}) ||
+ (exists $attribute->{simpleType}->{int16_t}) ||
+ (exists $attribute->{simpleType}->{int32_t}) ||
+ (exists $attribute->{simpleType}->{int64_t})
+ )
+ )
+ {
+ print $outFile " //simpleType:uint\n";
+ print $outFile " pLabel = \"ATTR_",$attribute->{id},"\";\n";
+ if (exists $attribute->{simpleType}->{uint8_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"0x%.2X\", *((uint8_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{uint16_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"0x%.4X\", *((uint16_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{uint32_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"0x%.8X\", *((uint32_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{uint64_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"0x%.16llX\", *((uint64_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{int8_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"%d\", *((int8_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{int16_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"%d\", *((int16_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{int32_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"%d\", *((int32_t *)l_ptr));\n";
+ }
+ elsif (exists $attribute->{simpleType}->{int64_t}) {
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"%d\", *((int64_t *)l_ptr));\n";
+ }
+ if(exists $attribute->{array})
+ {
+ ### need to do loop for types that are ARRAYS!
+ }
+ }
+ # EntityPaths
+ elsif(exists $attribute->{nativeType} && ($attribute->{nativeType}->{name} eq "EntityPath")) {
+ print $outFile " //nativeType:EntityPath\n";
+ print $outFile " pLabel = \"ATTR_",$attribute->{id},"\";\n";
+ # data is PATH_TYPE, Number of elements, [ Element, Instance# ]
+ # output is PathType:/ElementInstance/ElementInstance/ElementInstance
+ print $outFile " const char *pathString;\n";
+ print $outFile " // from targeting/common/entitypath.[CH]\n";
+ print $outFile " const uint8_t lPtype = *l_ptr; // PATH_TYPE\n";
+ print $outFile " switch (lPtype) {\n";
+ print $outFile " case 0x01: pathString = \"Logical:\"; break;\n";
+ print $outFile " case 0x02: pathString = \"Physical:\"; break;\n";
+ print $outFile " case 0x03: pathString = \"Device:\"; break;\n";
+ print $outFile " case 0x04: pathString = \"Power:\"; break;\n";
+ print $outFile " default: pathString = \"Unknown:\"; break;\n";
+ print $outFile " }\n";
+ print $outFile " dataSize = sprintf(&(l_traceEntry[0]), \"%s\",pathString);\n";
+ print $outFile " const uint8_t lSize = *(l_ptr + 1); // number of elements\n";
+ print $outFile " uint8_t *lElementInstance = (l_ptr + 2);\n";
+ print $outFile " for (uint32_t i=0;i<lSize;i += 2) {\n";
+ print $outFile " switch (lElementInstance[i]) {\n";
+ print $outFile " case 0x01: pathString = \"/Sys\"; break;\n";
+ print $outFile " case 0x02: pathString = \"/Node\"; break;\n";
+ print $outFile " case 0x03: pathString = \"/DIMM\"; break;\n";
+ print $outFile " case 0x04: pathString = \"/SCM\"; break;\n";
+ print $outFile " case 0x05: pathString = \"/DCM\"; break;\n";
+ print $outFile " case 0x06: pathString = \"/Membuf\"; break;\n";
+ print $outFile " case 0x07: pathString = \"/Proc\"; break;\n";
+ print $outFile " case 0x08: pathString = \"/MemVRM\"; break;\n";
+ print $outFile " case 0x09: pathString = \"/ProcVRM\"; break;\n";
+ print $outFile " case 0x0A: pathString = \"/EX\"; break;\n";
+ print $outFile " case 0x0B: pathString = \"/Core\"; break;\n";
+ print $outFile " case 0x0C: pathString = \"/L2\"; break;\n";
+ print $outFile " case 0x0D: pathString = \"/L3\"; break;\n";
+ print $outFile " case 0x0E: pathString = \"/L4\"; break;\n";
+ print $outFile " case 0x0F: pathString = \"/MCS\"; break;\n";
+ print $outFile " case 0x10: pathString = \"/MBS\"; break;\n";
+ print $outFile " case 0x11: pathString = \"/MBA\"; break;\n";
+ print $outFile " case 0x12: pathString = \"/MemPort\"; break;\n";
+ print $outFile " case 0x13: pathString = \"/Pervasive\"; break;\n";
+ print $outFile " case 0x14: pathString = \"/Powerbus\"; break;\n";
+ print $outFile " case 0x15: pathString = \"/XBUS\"; break;\n";
+ print $outFile " case 0x16: pathString = \"/ABUS\"; break;\n";
+ print $outFile " case 0x17: pathString = \"/PCI\"; break;\n";
+ print $outFile " case 0x18: pathString = \"/TP\"; break;\n";
+ print $outFile " case 0x19: pathString = \"/DMI\"; break;\n";
+ print $outFile " case 0x1A: pathString = \"/DPSS\"; break;\n";
+ print $outFile " case 0x1B: pathString = \"/APSS\"; break;\n";
+ print $outFile " case 0x1C: pathString = \"/OCC\"; break;\n";
+ print $outFile " //case TYPE_FSI_LINK: pathString = \"/FSI-link\"; break;\n";
+ print $outFile " //case TYPE_CFAM: pathString = \"/CFAM\"; break;\n";
+ print $outFile " //case TYPE_ENGINE: pathString = \"/Engine\"; break;\n";
+ print $outFile " default: pathString = \"/Unknown\"; break;\n";
+ print $outFile " } // switch\n";
+ print $outFile " // copy next part in, overwritting previous terminator\n";
+ print $outFile " dataSize += sprintf(&(l_traceEntry[0]) + dataSize, \"%s%d\",pathString,lElementInstance[i+1]);\n";
+ print $outFile " } // for\n";
+ print $outFile " dataSize++; // account for last NULL terminator\n";
+ }
+ # any other nativeTypes are just decimals... (I never saw one)
+ elsif(exists $attribute->{nativeType}) {
+ print $outFile " //nativeType\n";
+ print $outFile " pLabel = \"ATTR_",$attribute->{id},"\";\n";
+ print $outFile " dataSize = 1 + sprintf(&(l_traceEntry[0]), \"%d\", *((int32_t *)l_ptr));\n";
+ }
+ # just in case, nothing..
+ else
+ {
+ #print $outFile " //unknown attributes\n";
+ }
+
+
+ print $outFile " break;\n";
+ print $outFile " }\n";
+ }
+ print $outFile " default: {\n";
+ print $outFile " pLabel = \"unknown Attribute\";\n";
+ print $outFile " break;\n";
+ print $outFile " }\n";
+ print $outFile " } // switch\n";
+ print $outFile "\n";
+ print $outFile " i += dataSize; // increment past all of this\n";
+ print $outFile " // pointing to something - print it.\n";
+ print $outFile " if (dataSize != 0) {\n";
+ print $outFile " if (l_traceEntry.size() < dataSize + 2) {\n";
+ print $outFile " l_traceEntry.resize(dataSize + 2);\n";
+ print $outFile " }\n";
+ print $outFile " i_parser.PrintString(pLabel, &(l_traceEntry[0]));\n";
+ print $outFile " }\n";
+ print $outFile " l_ptr += dataSize;\n";
+ print $outFile " } // for\n";
+ print $outFile " }\n";
+ print $outFile "private:\n";
+ print $outFile "\n";
+ print $outFile "// Disabled\n";
+ print $outFile "ErrlUserDetailsParserAttribute(const ErrlUserDetailsParserAttribute &);\n";
+ print $outFile "ErrlUserDetailsParserAttribute & operator=(const ErrlUserDetailsParserAttribute &);\n";
+ print $outFile "};\n";
+ print $outFile "} // namespace\n";
+ print $outFile "#endif\n";
+ print $outFile "#endif\n";
+} # sub writeAttrErrlHFile
+
+
+
#fixme-Remove when RTC:38197 is done
######
#Create a .C file to dump all possible attributes
@@ -1604,6 +2155,7 @@ sub getAttributeIdEnumeration {
= $attribute->{id};
$enumeration->{enumerator}->[$attributeValue]->{value}
= sprintf "%u",$attributeValue;
+ $attribute->{value} = $attributeValue;
}
return $enumeration;
OpenPOWER on IntegriCloud