Errlog User Details: Log Arbitrary Attributes

Add code so that a hostboot or procedure developer can save attributes
into an error log and have them display in a human-readable way in order
to aid debug and FA.  All data is stored in errlog in binary format and
decoded into strings and enum 'constants' with the parse function.

Methods to dump and parse the attributes are auto-generated by the
xmltohb.pl script.

In addition, cleanup up Target User Details so that blanks lines aren't
output and so that the attribute name isn't put into the error log and
is instead added by the parse function (smaller errlog usage), and change
to same coding style as other UserDetail functions (data put into buffer
in ctor and not in addToLog function).

following will be added in future story/task work:
 - parsing for complex attributes.
 - combining multiple attribute user details together instead of
    generating a separate log entry for each.

Change-Id: I6baafa36ef095aafabb5bf86d6054bcb3db47019
RTC: 35275
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/944
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>
Tested-by: Jenkins Server

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;