Separate attr override section of PNOR into 2 parts

New Sections: ATTR_TMP, ATTR_PERM

Change-Id: Id66495509076f9637e8720f3d2631e8db7456fb2
RTC:113615
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/14168
Tested-by: Jenkins Server
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

3 files changed, 297 insertions, 116 deletions

diff --git a/src/usr/targeting/attrPlatOverride.C b/src/usr/targeting/attrPlatOverride.C
index 7f67ab221..3f71da189 100644
--- a/src/usr/targeting/attrPlatOverride.C
+++ b/src/usr/targeting/attrPlatOverride.C
@@ -26,13 +26,13 @@
 #include <hwpf/plat/fapiPlatAttrOverrideSync.H>
 #include <targeting/common/trace.H>
 #include <targeting/common/targreasoncodes.H>
+#include <errl/errlmanager.H>
 
 namespace TARGETING
 {
 
-errlHndl_t getAttrOverrides(PNOR::SectionId i_section,
-                      AttributeTank* io_tanks[AttributeTank::TANK_LAYER_LAST],
-                      uint32_t pnorSecOffset)
+errlHndl_t getAttrOverrides(PNOR::SectionInfo_t &i_sectionInfo,
+                      AttributeTank* io_tanks[AttributeTank::TANK_LAYER_LAST])
 {
     TRACFCOMP(g_trac_targeting,"attrPlatOverride::getAttrOverrides ENTER");
 
@@ -63,65 +63,57 @@ errlHndl_t getAttrOverrides(PNOR::SectionId i_section,
 
     do
     {
-        // Read PNOR section
-        PNOR::SectionInfo_t sectionInfo;
-        l_err = PNOR::getSectionInfo( i_section, sectionInfo );
-        // Attr override sections are optional so just delete error and break
-        if (l_err)
-        {
-            delete l_err;
-            l_err = NULL;
-            break;
-        }
 
-        uint32_t l_index = pnorSecOffset;
+        uint32_t l_index = 0;
         // Deserialize each section
-        while (l_index < sectionInfo.size)
+        while (l_index < i_sectionInfo.size)
         {
             AttrOverrideSection * l_pAttrOverSec =
                 reinterpret_cast<AttrOverrideSection *>
-                    (sectionInfo.vaddr + l_index);
+                    (i_sectionInfo.vaddr + l_index);
 
-            // Reached termination chunck
-            if (l_pAttrOverSec->iv_layer == AttributeTank::TANK_LAYER_NONE)
+            // Reached termination chunk
+            if (l_pAttrOverSec->iv_layer == AttributeTank::TANK_LAYER_TERM)
             {
                 TRACFCOMP(g_trac_targeting,"attrPlatOverride::getAttrOverrides Reached termination section at chunk (0x%x)",
-                            (sectionInfo.size - l_index));
+                            (i_sectionInfo.size - l_index));
                 break;
             }
 
             // Remaining chunk smaller than AttrOverrideSection, quit
-            if (sizeof(AttrOverrideSection) > (sectionInfo.size - l_index))
+            if (sizeof(AttrOverrideSection) > (i_sectionInfo.size - l_index))
             {
                 TRACFCOMP(g_trac_targeting,"attrPlatOverride::getAttrOverrides AttrOverrideSection too big for chunk (0x%x)",
-                            (sectionInfo.size - l_index));
-            /*@
-             * @errortype
-             * @moduleid     TARG_GET_ATTR_OVER
-             * @reasoncode   TARG_RC_ATTR_OVER_PNOR_SEC_SPACE_FAIL
-             * @userdata1    PNOR Section specified
-             * @userdata2    Size of AttrOverrideSection
-             * @devdesc      AttrOverrideSection too big to fit in remaining
-             *               chunck of pnor section
-             */
-            l_err =
-                new ERRORLOG::ErrlEntry
-                (ERRORLOG::ERRL_SEV_PREDICTIVE,
-                 TARG_GET_ATTR_OVER,
-                 TARG_RC_ATTR_OVER_PNOR_SEC_SPACE_FAIL,
-                 i_section,
-                 sizeof(AttrOverrideSection),
-                 true /*SW callout*/);
-                break;
+                            (i_sectionInfo.size - l_index));
+                /*@
+                 * @errortype
+                 * @moduleid     TARG_GET_ATTR_OVER
+                 * @reasoncode   TARG_RC_ATTR_OVER_PNOR_SEC_SPACE_FAIL
+                 * @userdata1    PNOR Section specified
+                 * @userdata2    Size of AttrOverrideSection
+                 * @devdesc      AttrOverrideSection too big to fit in remaining
+                 *               chunck of pnor section
+                 * @custdesc     Invalid configuration data in firmware pnor
+                 */
+                l_err =
+                    new ERRORLOG::ErrlEntry
+                    (ERRORLOG::ERRL_SEV_PREDICTIVE,
+                     TARG_GET_ATTR_OVER,
+                     TARG_RC_ATTR_OVER_PNOR_SEC_SPACE_FAIL,
+                     i_sectionInfo.id,
+                     sizeof(AttrOverrideSection));
+                l_err->addProcedureCallout(HWAS::EPUB_PRC_SP_CODE,
+                                           HWAS::SRCI_PRIORITY_HIGH);
+                    break;
             }
 
             l_index += sizeof(AttrOverrideSection);
 
             // Remaining chunk smaller than serialized chunk size, quit
-            if (l_pAttrOverSec->iv_size > (sectionInfo.size - l_index))
+            if (l_pAttrOverSec->iv_size > (i_sectionInfo.size - l_index))
             {
                 TRACFCOMP(g_trac_targeting,"attrPlatOverride::getAttrOverrides serialized chunk too big for chunk (0x%x)",
-                            (sectionInfo.size - l_index));
+                            (i_sectionInfo.size - l_index));
                 /*@
                  * @errortype
                  * @moduleid     TARG_GET_ATTR_OVER
@@ -130,35 +122,113 @@ errlHndl_t getAttrOverrides(PNOR::SectionId i_section,
                  * @userdata2    Size of Serialized attribute override
                  * @devdesc      Serialized attribute override chunk too big to
                  *               fit in remaining chunck of pnor section
+                 * @custdesc     Invalid configuration data in firmware pnor
                  */
                 l_err =
                     new ERRORLOG::ErrlEntry
                     (ERRORLOG::ERRL_SEV_PREDICTIVE,
                      TARG_GET_ATTR_OVER,
                      TARG_RC_ATTR_OVER_ATTR_DATA_SIZE_FAIL,
-                     i_section,
-                     l_pAttrOverSec->iv_size,
-                     true /*SW callout*/);
+                     i_sectionInfo.id,
+                     l_pAttrOverSec->iv_size);
+                l_err->addProcedureCallout(HWAS::EPUB_PRC_SP_CODE,
+                                           HWAS::SRCI_PRIORITY_HIGH);
                 break;
             }
 
-            // Get the AttributeTank that corresponds to the TankLayer in the
-            // AttrOverrideSection. Enum starts with TANK_LAYER_NONE so need to
-            // substract 1
-            AttributeTank* l_ptank = l_pOverTanks[l_pAttrOverSec->iv_layer - 1];
-
-            // Create serialized chunck with AttrOverrideSection data
-            AttributeTank::AttributeSerializedChunk l_chunk;
-            l_chunk.iv_size = l_pAttrOverSec->iv_size;
-            l_chunk.iv_pAttributes = &l_pAttrOverSec->iv_chunk[0];
-
-            // Deserialize the data with the approriate AttributeTank
-            l_ptank->deserializeAttributes(l_chunk);
+            // Check if a tank layer is specified, if not we can't apply the
+            // attribute override.
+            if (l_pAttrOverSec->iv_layer == AttributeTank::TANK_LAYER_NONE)
+            {
+                TRACFCOMP(g_trac_targeting,"attrPlatOverride::getAttrOverrides no tank layer specified at chunk (0x%x)",
+                            (i_sectionInfo.size - l_index));
+                /*@
+                 * @errortype
+                 * @moduleid     TARG_GET_ATTR_OVER
+                 * @reasoncode   TARG_RC_WRITE_ATTR_OVER_NO_TANK_LAYER
+                 * @userdata1    PNOR Section specified
+                 * @userdata2    Chunk location with no tank layer
+                 * @devdesc      No tank layer was specified for attribute
+                 *               override.
+                 * @custdesc     Invalid configuration data in firmware pnor
+                 */
+                l_err =
+                    new ERRORLOG::ErrlEntry
+                    (ERRORLOG::ERRL_SEV_PREDICTIVE,
+                     TARG_GET_ATTR_OVER,
+                     TARG_RC_WRITE_ATTR_OVER_NO_TANK_LAYER,
+                     i_sectionInfo.id,
+                     (i_sectionInfo.size - l_index));
+                l_err->collectTrace("TARG",256);
+                l_err->addProcedureCallout(HWAS::EPUB_PRC_SP_CODE,
+                                           HWAS::SRCI_PRIORITY_HIGH);
+                ERRORLOG::errlCommit(l_err, TARG_COMP_ID);
+            }
+            // Check if the AttrOverSec is in the correct PNOR section
+            // It was decided that this should not cause a failed IPL, so the
+            // override will not be applied, the errl will be committed, then
+            // we move on.
+            else if (tankLayerToPnor[l_pAttrOverSec->iv_layer - 1].second !=
+                                                            i_sectionInfo.id)
+            {
+                TRACFCOMP(g_trac_targeting,"getAttrOverrides: Failed to apply override - override with TankLayer 0x%X should not be in PNOR::%s",
+                            l_pAttrOverSec->iv_layer, i_sectionInfo.name);
+                /*@
+                 * @errortype
+                 * @moduleid     TARG_GET_ATTR_OVER
+                 * @reasoncode   TARG_RC_WRITE_ATTR_OVER_WRONG_PNOR_SEC
+                 * @userdata1    Tank Layer of attribute
+                 * @userdata2    PNOR Section specified
+                 * @devdesc      Attribute override is in the wrong pnor section
+                 *               needs to be moved to the section associated
+                 *               with its attribute tank layer
+                 * @custdesc     Invalid configuration data in firmware pnor
+                 */
+                l_err =
+                    new ERRORLOG::ErrlEntry
+                    (ERRORLOG::ERRL_SEV_PREDICTIVE,
+                     TARG_GET_ATTR_OVER,
+                     TARG_RC_WRITE_ATTR_OVER_WRONG_PNOR_SEC,
+                     l_pAttrOverSec->iv_layer,
+                     i_sectionInfo.id);
+                l_err->collectTrace("TARG",256);
+                l_err->addProcedureCallout(HWAS::EPUB_PRC_SP_CODE,
+                                           HWAS::SRCI_PRIORITY_HIGH);
+                ERRORLOG::errlCommit(l_err, TARG_COMP_ID);
+            }
+            // Only apply attribute override if in the correct PNOR section
+            else
+            {
+                // Get the AttributeTank that corresponds to the TankLayer in
+                // the AttrOverrideSection. Enum starts with TANK_LAYER_NONE
+                // so need to substract 1
+                AttributeTank* l_ptank = l_pOverTanks[l_pAttrOverSec->iv_layer - 1];
+
+                // Create serialized chunck with AttrOverrideSection data
+                AttributeTank::AttributeSerializedChunk l_chunk;
+                l_chunk.iv_size = l_pAttrOverSec->iv_size;
+                l_chunk.iv_pAttributes = &l_pAttrOverSec->iv_chunk[0];
+
+                // Deserialize the data with the approriate AttributeTank
+                l_ptank->deserializeAttributes(l_chunk);
+            }
             l_index += l_pAttrOverSec->iv_size;
         }
 
+        if (l_err)
+        {
+            break;
+        }
+
         // Write permanent attribute overrides
-        l_err = l_PermTank.writePermAttributes();
+        if ((i_sectionInfo.id == PNOR::ATTR_PERM) &&
+            (l_PermTank.size() > 0) )
+        {
+            // l_PermTank should be empty if the section is not ATTR_PERM
+            // with the check above, but sanity check
+            l_err = l_PermTank.writePermAttributes();
+            break;
+        }
 
     } while(0);
 
diff --git a/src/usr/targeting/common/attributeTank.C b/src/usr/targeting/common/attributeTank.C
index 17f6375d7..d23494c14 100644
--- a/src/usr/targeting/common/attributeTank.C
+++ b/src/usr/targeting/common/attributeTank.C
@@ -597,4 +597,10 @@ errlHndl_t AttributeTank::writePermAttributes()
     return l_err;
 }
 
+//******************************************************************************
+size_t AttributeTank::size() const
+{
+    return iv_attributes.size();
+}
+
 }
diff --git a/src/usr/targeting/test/testattrtank.H b/src/usr/targeting/test/testattrtank.H
index 5a7cb8cc7..247076e58 100644
--- a/src/usr/targeting/test/testattrtank.H
+++ b/src/usr/targeting/test/testattrtank.H
@@ -1149,30 +1149,39 @@ public:
 
     /**
      * @brief Test BMC Attr Override function
-     *        Set attributes into 3 different tanks for attribute override and
-     *        serialize the data of each tank. Then call getAttrOverrides to
-     *        deserialize each sections data and check that the data is correct
+     *        Set attributes into 3 different tanks. Then place overrides in
+     *        both correct/incorrect simulated pnor sections. Finally call
+     *        getAttrOverrides to deserialize each sections data and verify
+     *        that it did not apply incorrect overrides and applied correct ones
      *
      */
     void testBMCAttrOverride(void)
     {
+        errlHndl_t l_errhdl = NULL;
+        const uint64_t l_chunkSize = 4096;
+
+        // Simulate Pnor ATTR_TMP and ATTR_PERM sections in memory
+        PNOR::SectionInfo_t l_attrTmpSec;
+        l_attrTmpSec.id = PNOR::ATTR_TMP;
+        l_attrTmpSec.name = "Test Attr Tmp";
+        l_attrTmpSec.vaddr = reinterpret_cast<uint64_t>(malloc(3*l_chunkSize));
+
+        PNOR::SectionInfo_t l_attrPermSec;
+        l_attrPermSec.id = PNOR::ATTR_PERM;
+        l_attrPermSec.name = "Test Attr Perm";
+        l_attrPermSec.vaddr = reinterpret_cast<uint64_t>(malloc(3*l_chunkSize));
+
         do
         {
-            errlHndl_t errhdl = NULL;
-            // Use the TEST partition as scratch space
-            PNOR::SectionInfo_t info;
-            errhdl = PNOR::getSectionInfo( PNOR::TEST, info );
-            if (errhdl)
-            {
-                TS_FAIL("testattrtank::testBMCAttrOverride could not get PNOR test section info");
-                break;
-            }
-
             // Create local AttributeTanks
             AttributeTank l_FapiTank;
             AttributeTank l_TargetTank;
             AttributeTank l_PermTank;
 
+            // Create local array of those tanks
+            AttributeTank* l_tanks[AttributeTank::TANK_LAYER_LAST];
+
+            // Create Attr Overrides
             // Add ATTR_SCRATCH_UINT64_1 to the Fapi tank
             uint64_t l_val = 4;
             l_FapiTank.setAttribute(ATTR_SCRATCH_UINT64_1,
@@ -1197,107 +1206,157 @@ public:
                                     AttributeTank::ATTR_NODE_NA,
                                     0, sizeof(l_val), &l_val);
 
+
             ////////////////////////////////////////////////////////////////////
-            // Fapi
+            // Fill in simulated pnor sections
+            // Add a fapi, targ, and perm overrides to both sections to test
+            // catching incorrect ones and applying the correct ones
 
-            // Serialize all attributes from each tank
+            uint32_t l_permIndex = 0;
+            uint32_t l_tmpIndex = 0;
+            AttrOverrideSection * l_pAttrOverSec = NULL;
+            AttributeTank::AttributeSerializedChunk l_chunk;
+
+            // Fapi - Serialize all attributes from each tank
             AttributeTank::AttributeSerializedChunks_t l_attributes;
             l_FapiTank.serializeAttributes(AttributeTank::ALLOC_TYPE_NEW,
-                    4096, l_attributes);
+                    l_chunkSize, l_attributes);
 
-            // Copy Fapi Override chunk to PNOR
-            uint32_t l_index = PNOR::pnorTestSec_BMCAttrOverride_offset;
+            // Copy Fapi Overrides to test tmp and perm sections
             for (AttributeTank::AttributeSerializedChunks_t::iterator
                     chunkIter = l_attributes.begin();
                     chunkIter != l_attributes.end();
                     ++chunkIter)
             {
-                AttrOverrideSection * l_pAttrOverSec =
-                    reinterpret_cast<AttrOverrideSection *>
-                        (info.vaddr + l_index);
-                AttributeTank::AttributeSerializedChunk l_chunk = *chunkIter;
+                l_chunk = *chunkIter;
+
+                // handle tmp section
+                l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                        (l_attrTmpSec.vaddr + l_tmpIndex);
                 l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_FAPI;
                 l_pAttrOverSec->iv_size = l_chunk.iv_size;
                 memcpy(&l_pAttrOverSec->iv_chunk, l_chunk.iv_pAttributes,
                         l_chunk.iv_size);
-                l_index += sizeof(AttrOverrideSection)+l_pAttrOverSec->iv_size;
-            }
+                l_tmpIndex += sizeof(AttrOverrideSection)+
+                                        l_pAttrOverSec->iv_size;
 
-            ////////////////////////////////////////////////////////////////////
-            // Targeting
+                // handle perm section
+                l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                        (l_attrPermSec.vaddr + l_permIndex);
+                l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_FAPI;
+                l_pAttrOverSec->iv_size = l_chunk.iv_size;
+                memcpy(&l_pAttrOverSec->iv_chunk, l_chunk.iv_pAttributes,
+                        l_chunk.iv_size);
+                l_permIndex += sizeof(AttrOverrideSection)+
+                                        l_pAttrOverSec->iv_size;
+            }
 
-            // Serialize all attributes from each tank
+            // Targeting - Serialize all attributes from tank
             l_attributes.clear();
             l_TargetTank.serializeAttributes(AttributeTank::ALLOC_TYPE_NEW,
-                    4096, l_attributes);
+                    l_chunkSize, l_attributes);
 
-            // Copy Target Override chunk to PNOR
+            // Copy Target Override chunk to test tmp and perm sections
             for (AttributeTank::AttributeSerializedChunks_t::iterator
                     chunkIter = l_attributes.begin();
                     chunkIter != l_attributes.end();
                     ++chunkIter)
             {
-                AttrOverrideSection * l_pAttrOverSec =
-                    reinterpret_cast<AttrOverrideSection *>
-                        (info.vaddr + l_index);
-                AttributeTank::AttributeSerializedChunk l_chunk = *chunkIter;
+                l_chunk = *chunkIter;
+
+                // handle tmp section
+                l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                        (l_attrTmpSec.vaddr + l_tmpIndex);
                 l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_TARG;
                 l_pAttrOverSec->iv_size = l_chunk.iv_size;
                 memcpy(&l_pAttrOverSec->iv_chunk, l_chunk.iv_pAttributes,
                         l_chunk.iv_size);
-                l_index += sizeof(AttrOverrideSection)+l_pAttrOverSec->iv_size;
+                l_tmpIndex += sizeof(AttrOverrideSection)+
+                                        l_pAttrOverSec->iv_size;
 
+                // handle perm section
+                l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                        (l_attrPermSec.vaddr + l_permIndex);
+                l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_TARG;
+                l_pAttrOverSec->iv_size = l_chunk.iv_size;
+                memcpy(&l_pAttrOverSec->iv_chunk, l_chunk.iv_pAttributes,
+                        l_chunk.iv_size);
+                l_permIndex += sizeof(AttrOverrideSection)+
+                                        l_pAttrOverSec->iv_size;
             }
 
-            ////////////////////////////////////////////////////////////////////
-            // Permanent
-
-            // Serialize all attributes from each tank
+            // Permanent - Serialize all attributes from tank
             l_attributes.clear();
             l_PermTank.serializeAttributes(AttributeTank::ALLOC_TYPE_NEW,
-                    4096, l_attributes);
+                    l_chunkSize, l_attributes);
 
-            // Copy Target Override chunk to PNOR
+            // Copy Perm Override chunk to test tmp and perm sections
             for (AttributeTank::AttributeSerializedChunks_t::iterator
                     chunkIter = l_attributes.begin();
                     chunkIter != l_attributes.end();
                     ++chunkIter)
             {
-                AttrOverrideSection * l_pAttrOverSec =
-                    reinterpret_cast<AttrOverrideSection *>
-                        (info.vaddr + l_index);
-                AttributeTank::AttributeSerializedChunk l_chunk = *chunkIter;
+                l_chunk = *chunkIter;
+
+                // handle tmp section
+                l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                        (l_attrTmpSec.vaddr + l_tmpIndex);
                 l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_PERM;
                 l_pAttrOverSec->iv_size = l_chunk.iv_size;
                 memcpy(&l_pAttrOverSec->iv_chunk, l_chunk.iv_pAttributes,
                         l_chunk.iv_size);
-                l_index += sizeof(AttrOverrideSection)+l_pAttrOverSec->iv_size;
+                l_tmpIndex += sizeof(AttrOverrideSection)+
+                                        l_pAttrOverSec->iv_size;
 
+                // handle perm section
+                l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                        (l_attrPermSec.vaddr + l_permIndex);
+                l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_PERM;
+                l_pAttrOverSec->iv_size = l_chunk.iv_size;
+                memcpy(&l_pAttrOverSec->iv_chunk, l_chunk.iv_pAttributes,
+                        l_chunk.iv_size);
+                l_permIndex += sizeof(AttrOverrideSection)+
+                                        l_pAttrOverSec->iv_size;
             }
 
             // Add termination section
-            AttrOverrideSection * l_pAttrOverSecTerm =
-                    reinterpret_cast<AttrOverrideSection *>
-                        (info.vaddr + l_index);
-            l_pAttrOverSecTerm->iv_layer = AttributeTank::TANK_LAYER_NONE;
-            l_pAttrOverSecTerm->iv_size = 0;
 
-            // Clear tanks
+            // handle tmp section
+            l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                    (l_attrTmpSec.vaddr + l_tmpIndex);
+            l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_TERM;
+            l_pAttrOverSec->iv_size = 0;
+            l_tmpIndex += sizeof(AttrOverrideSection);
+
+            // handle perm section
+            l_pAttrOverSec = reinterpret_cast<AttrOverrideSection *>
+                                    (l_attrPermSec.vaddr + l_permIndex);
+            l_pAttrOverSec->iv_layer = AttributeTank::TANK_LAYER_TERM;
+            l_pAttrOverSec->iv_size = 0;
+            l_permIndex += sizeof(AttrOverrideSection);
+
+            // Update final size of created section
+            l_attrTmpSec.size = l_tmpIndex;
+            l_attrPermSec.size = l_permIndex;
+
+            ////////////////////////////////////////////////////////////////////
+            // Test simulated pnor sections attr overrides
+
+            // Test Attr Tmp - should only include Fapi and Targ overrides
             l_FapiTank.clearAllAttributes();
             l_TargetTank.clearAllAttributes();
             l_PermTank.clearAllAttributes();
 
-            // Call function that actually reads in attribute overrides
-            AttributeTank* l_tanks[AttributeTank::TANK_LAYER_LAST];
             l_tanks[AttributeTank::TANK_LAYER_FAPI-1] = &l_FapiTank;
             l_tanks[AttributeTank::TANK_LAYER_TARG-1] = &l_TargetTank;
             l_tanks[AttributeTank::TANK_LAYER_PERM-1] = &l_PermTank;
-            errhdl = getAttrOverrides(PNOR::TEST,
-                             l_tanks,
-                             PNOR::pnorTestSec_BMCAttrOverride_offset);
-            if (errhdl)
+
+            // Call function that actually reads in attribute overrides
+            l_errhdl = getAttrOverrides(l_attrTmpSec, l_tanks);
+
+            if (l_errhdl)
             {
-                errlCommit(errhdl, TARG_COMP_ID);
+                errlCommit(l_errhdl, TARG_COMP_ID);
                 TS_FAIL("testattrtank::testBMCAttrOverride getAttrOverrides() failed");
                 break;
             }
@@ -1341,6 +1400,21 @@ public:
                 break;
             }
 
+            // Check to make sure no Permanent overrides were applied
+            if (l_PermTank.size() > 0)
+            {
+                TS_FAIL("testattrtank::testBMCAttrOverride: Error. A permanent override was found and applied in the PNOR::TMP section");
+                break;
+            }
+
+            // Test Attr Perm - should only include Perm overrides
+            l_tanks[AttributeTank::TANK_LAYER_FAPI-1]->clearAllAttributes();
+            l_tanks[AttributeTank::TANK_LAYER_TARG-1]->clearAllAttributes();
+            l_tanks[AttributeTank::TANK_LAYER_PERM-1]->clearAllAttributes();
+
+            // Call function that actually reads in attribute overrides
+            l_errhdl = getAttrOverrides(l_attrPermSec, l_tanks);
+
             // Check the first attribute made it back into the Perm tank
             l_val = 0;
             if (!(l_PermTank.getAttribute(ATTR_SCRATCH_UINT64_1,
@@ -1359,8 +1433,39 @@ public:
                         l_val);
                 break;
             }
+            // Check to make sure no Fapi overrides were applied
+            if (l_FapiTank.size() > 0)
+            {
+                TS_FAIL("testattrtank::testBMCAttrOverride: Error. A fapi override was found and applied in the PNOR::PERM section");
+                break;
+            }
+            // Check to make sure no Targ overrides were applied
+            if (l_TargetTank.size() > 0)
+            {
+                TS_FAIL("testattrtank::testBMCAttrOverride: Error. A targ override was found and applied in the PNOR::PERM section");
+                break;
+            }
+
         } while(0);
-        TRACFCOMP(g_trac_targeting, "testattrtank::testBMCAttrOverride: Success steve");
+
+        // Free memory
+        free (reinterpret_cast<char *>(l_attrTmpSec.vaddr));
+        free (reinterpret_cast<char *>(l_attrPermSec.vaddr));
+    }
+
+    /**
+     * @brief Test to check if the const array tankLayerToPnor is sorted
+     *        which also indicates in enum order
+     */
+    void testLidToPnorSorted(void)
+    {
+        for (size_t i = 0; i < (AttributeTank::TANK_LAYER_LAST - 1); ++i)
+        {
+            if (tankLayerToPnor[i].first > tankLayerToPnor[i+1].first)
+            {
+                TS_FAIL("testattrtank::testTankLayerToPnorSorted: attrPlatOverride.H tankLayerToPnor[] is not sorted");
+            }
+        }
     }
 };