Refactor lid to pnor mapping and add pnor to lid pair mapping

Change-Id: Ib4f3afef44cdab96c66b13426da86049b896757a
RTC: 175115
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/43809
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Michael Baiocchi <mbaiocch@us.ibm.com>
Reviewed-by: Nicholas E. Bofferding <bofferdn@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

8 files changed, 145 insertions, 85 deletions

diff --git a/src/include/usr/util/utillidmgr.H b/src/include/usr/util/utillidmgr.H
index 6e0c95d2f..f6a4762f4 100644
--- a/src/include/usr/util/utillidmgr.H
+++ b/src/include/usr/util/utillidmgr.H
@@ -41,17 +41,24 @@
 
 namespace Util
 {
-// Lid id's
+
+// Lid Ids
+//  A Container Lid can be referred to as a Secure Header. The Container Lid ID
+//  is associated with the header data that sits in front of an image.
 enum LidId
 {
     TEST_LIDID = 0x00000111,
     OCC_LIDID = 0x81e00430,
+    OCC_CONTAINER_LIDID = 0x80d0000b,
     // TODO RTC 172767 Make utillidmgr LIDID structure attribute driven
     WOF_LIDID = 0x81e00440,
+    WOF_CONTAINER_LIDID = 0x80d00015,
     // Hcode Reference Image LIDs
     NIMBUS_HCODE_LIDID = 0x81e00602,
     CUMULUS_HCODE_LIDID = 0x81e00603,
+    HCODE_CONTAINER_LIDID = 0x80d0000c,
     HWREFIMG_RINGOVD_LIDID = 0x81e00620,
+    INVALID_LIDID = 0xFFFFFFFF
 };
 
 }
@@ -415,16 +422,17 @@ class UtilLidMgr
 #endif // __HOSTBOOT_RUNTIME
 
     /**
-     *  @brief search lidToPnor array for the pnor section for the given lid
-     *         lidToPnor array does not includes the ext img section
+     *  @brief Determines if a Lid Id has a corresponding PNOR section ID
+     *         and sets PNOR info if it exists
      *
-     *  @param[in] i_lidId          - provide lid id to search for
-     *  @param[out] o_lidPnorInfo   - pnor section that the lid is in
+     *  @param[in] i_lidId          - lid id to search for
+     *  @param[out] o_lidPnorInfo   - pnor section info associated with the lid
+     *                                if it exists in pnor
      *
      *  @return bool - True if lid is in a section, false otherwise
     */
-    bool getLidPnorSection(uint32_t i_lidId,
-                           PNOR::SectionInfo_t &o_lidPnorInfo);
+    bool getLidPnorSectionInfo(uint32_t i_lidId,
+                               PNOR::SectionInfo_t &o_lidPnorInfo);
     /**
      * @brief LID fileName
      */
diff --git a/src/usr/util/utillidpnor.H b/src/include/usr/util/utillidpnor.H
index f4da469dc..c7daa00b7 100644
--- a/src/usr/util/utillidpnor.H
+++ b/src/include/usr/util/utillidpnor.H
@@ -1,7 +1,7 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: src/usr/util/utillidpnor.H $                                  */
+/* $Source: src/include/usr/util/utillidpnor.H $                          */
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
@@ -25,49 +25,54 @@
 #ifndef _UTILLIDPNOR_H
 #define _UTILLIDPNOR_H
 
-/**
- * @file lidpnor.H
- *
- * @brief brief Provides the lid to pnor mapping currently used in the lidmgr
- *              In its own file to limit number of duplicate definitions for
- *              every user compared to being defined in utillidmgr
- *
- */
-
 #include <util/utillidmgr.H>
 #include <utility>
+#include <map>
 
 namespace Util
 {
 
-/**
- *  @brief Simple compare function for lidToPnor elements
+/** @struct LidAndContainerLid
+ *  @brief  Stores the Lid ID and corresponding Container Lid ID for a lid
+ *
+ *  A Container Lid can be referred to as a Secure Header. The Container Lid ID
+ *  is associated with the header data that sits in front of an image.
  */
-bool cmpLidToPnor (const std::pair<uint32_t, PNOR::SectionId> p1,
-                   const std::pair<uint32_t, PNOR::SectionId> p2)
+struct LidAndContainerLid
 {
-    return (p1.first < p2.first);
-}
+    // Lid ID for content
+    LidId lid;
+    // Lid ID for Container Lid (Secure Header)
+    LidId containerLid;
+    LidAndContainerLid() : lid(INVALID_LIDID),containerLid(INVALID_LIDID) {}
+    LidAndContainerLid(LidId i_lid, LidId i_containerLid) :
+        lid(i_lid), containerLid(i_containerLid) {}
+};
+
+typedef std::map<PNOR::SectionId, LidAndContainerLid > PnorLidsMap;
+typedef std::pair<PNOR::SectionId, LidAndContainerLid> PnorLidsPair;
 
 /**
- *  @brief Array containing lid to pnor mappings
- *         When adding maintain order by uint32_t (lidID)
- *         There is a test case to confirm this is sorted
- */
-const std::pair<uint32_t, PNOR::SectionId>
-    lidToPnor[] =
-    {
-        std::make_pair(Util::TEST_LIDID, PNOR::TESTRO),            // 0x00000111
-        std::make_pair(Util::OCC_LIDID, PNOR::OCC),                // 0x81e00430
-        std::make_pair(Util::WOF_LIDID, PNOR::WOFDATA),            // 0x81e00440
-        std::make_pair(Util::NIMBUS_HCODE_LIDID, PNOR::HCODE),     // 0x81e00602
-        std::make_pair(Util::CUMULUS_HCODE_LIDID, PNOR::HCODE),    // 0x81e00603
-        std::make_pair(Util::HWREFIMG_RINGOVD_LIDID, PNOR::RINGOVD)// 0x81e00620
-    };
+  * @brief Returns Lid and ContainerLid (Secure Header) Ids associated with a
+  *        PNOR section.
+  *
+  * @param[in] i_sec     Pnor section to find associated LIDs for
+  *
+  * @return  LidAndContainerLid - If found, valid LidIds
+  *                               else, invalid LidIds
+  * Note: May return valid LidId with an invalid ContainerLid
+*/
+LidAndContainerLid getPnorSecLidIds(PNOR::SectionId i_sec);
 
-// Size of lidToPnor[]
-const size_t NUM_LID_TO_PNOR = ( sizeof(lidToPnor) /
-                                 sizeof(std::pair<uint32_t, PNOR::SectionId>));
+/**
+  * @brief Returns PNOR section ID associated with a LidID.
+  *
+  * @param[in] i_lid     LidId to find associated PNOR section for
+  *
+  * @return  PNOR::SectionId - If found, valid PNOR section
+  *                            else, INVALID_SECTION
+*/
+PNOR::SectionId getLidPnorSection(LidId i_lid);
 
 }
 
diff --git a/src/usr/pnor/pnor_utils.C b/src/usr/pnor/pnor_utils.C
index 1ee89e349..9945edada 100644
--- a/src/usr/pnor/pnor_utils.C
+++ b/src/usr/pnor/pnor_utils.C
@@ -471,8 +471,8 @@ const char * PNOR::SectionIdToString( uint32_t i_secIdIndex )
     static_assert (numEntries == (PNOR::NUM_SECTIONS),
                "Mismatch between number of SectionIds and correlating strings");
 
-    // Assert if accessing index out of array.
-    assert(i_secIdIndex < (PNOR::NUM_SECTIONS),
+    // Assert if accessing index out of array or not INVALID section
+    assert(i_secIdIndex <= (PNOR::NUM_SECTIONS),
 #ifdef BOOTLOADER
            BTLDR_TRC_UTILS_PNOR_SECID_OUT_OF_RANGE,
            Bootloader::RC_PNOR_SECID_OUT_OF_RANGE
@@ -481,7 +481,13 @@ const char * PNOR::SectionIdToString( uint32_t i_secIdIndex )
 #endif
     );
 
-    return SectionIdToStringArr[i_secIdIndex];
+    const char * l_str = "INVALID_SECTION";
+    if(i_secIdIndex < PNOR::INVALID_SECTION)
+    {
+       l_str = SectionIdToStringArr[i_secIdIndex];
+    }
+
+    return l_str;
 }
 
 bool PNOR::cmpSecurebootMagicNumber(const uint8_t* i_vaddr)
diff --git a/src/usr/targeting/test/testattrtank.H b/src/usr/targeting/test/testattrtank.H
index e1a2b22af..dc68e8a1a 100644
--- a/src/usr/targeting/test/testattrtank.H
+++ b/src/usr/targeting/test/testattrtank.H
@@ -1469,7 +1469,7 @@ public:
      * @brief Test to check if the const array tankLayerToPnor is sorted
      *        which also indicates in enum order
      */
-    void testLidToPnorSorted(void)
+    void testTankLayerToPnorSorted(void)
     {
         for (size_t i = 0; i < (AttributeTank::TANK_LAYER_LAST - 1); ++i)
         {
diff --git a/src/usr/util/runtime/utillidmgr_rt.C b/src/usr/util/runtime/utillidmgr_rt.C
index 6f1173666..ea31c61ce 100644
--- a/src/usr/util/runtime/utillidmgr_rt.C
+++ b/src/usr/util/runtime/utillidmgr_rt.C
@@ -241,7 +241,7 @@ void UtilLidMgr::updateLid(uint32_t i_lidId)
     {
         // If it's in PNOR it's not technically a lid
         // so use a slightly different extension
-        iv_isLidInPnor = getLidPnorSection(iv_lidId, iv_lidPnorInfo);
+        iv_isLidInPnor = getLidPnorSectionInfo(iv_lidId, iv_lidPnorInfo);
     }
     sprintf(iv_lidFileName, "%x.lidbin", iv_lidId);
     iv_isLidInVFS  = VFS::module_exists(iv_lidFileName);
diff --git a/src/usr/util/test/testlidmgr.H b/src/usr/util/test/testlidmgr.H
index 334c1d810..1644b1432 100644
--- a/src/usr/util/test/testlidmgr.H
+++ b/src/usr/util/test/testlidmgr.H
@@ -35,27 +35,13 @@
 
 #include <errl/errlmanager.H>
 #include "../utilbase.H"
-#include "../utillidpnor.H"
+#include <util/utillidmgr.H>
 
 class LidMgrTest : public CxxTest::TestSuite
 {
 public:
 
     /**
-     *  @brief Test to check if the const array lidToPnor is sorted
-     */
-    void testLidToPnorSorted(void)
-    {
-        for (size_t i = 0; (i+1) < Util::NUM_LID_TO_PNOR; ++i)
-        {
-            if (Util::lidToPnor[i].first > Util::lidToPnor[i+1].first)
-            {
-                TS_FAIL("testLidToPnorSorted: utilidmgr lidToPnor[] is not sorted");
-            }
-        }
-    }
-
-    /**
      *  @brief Test to check if the structure that maps lidID's to pnor sections
      *         is working correctly
      */
diff --git a/src/usr/util/utillidmgr.C b/src/usr/util/utillidmgr.C
index 767b2df23..a92a30f3c 100644
--- a/src/usr/util/utillidmgr.C
+++ b/src/usr/util/utillidmgr.C
@@ -824,7 +824,7 @@ void UtilLidMgr::updateLid(uint32_t i_lidId)
     //if it's in PNOR, it's not technically lid, so use a slightly
     //different extension.
     sprintf(iv_lidFileName, "%x.lidbin", iv_lidId);
-    iv_isLidInPnor = getLidPnorSection(iv_lidId, iv_lidPnorInfo);
+    iv_isLidInPnor = getLidPnorSectionInfo(iv_lidId, iv_lidPnorInfo);
     UTIL_FT(INFO_MRK "UtilLidMgr: LID 0x%.8X in pnor: %d",
               iv_lidId ,iv_isLidInPnor);
     iv_isLidInVFS = VFS::module_exists(iv_lidFileName);
diff --git a/src/usr/util/utillidpnor.C b/src/usr/util/utillidpnor.C
index e98e97a7d..b4c2d8ba4 100644
--- a/src/usr/util/utillidpnor.C
+++ b/src/usr/util/utillidpnor.C
@@ -24,61 +24,117 @@
 /* IBM_PROLOG_END_TAG                                                     */
 
 #include <util/utillidmgr.H>
-#include <utility>
-#include "utillidpnor.H"
+#include <util/utillidpnor.H>
 #include <config.h>
 #ifdef CONFIG_SECUREBOOT
 #include <pnor/pnorif.H>
 #include <errl/errlmanager.H>
 #endif
 
-bool UtilLidMgr::getLidPnorSection(uint32_t i_lidId,
-                                   PNOR::SectionInfo_t &o_lidPnorInfo)
+#include <utility>
+#include <map>
+
+namespace Util
 {
-    errlHndl_t l_err = NULL;
-    bool l_lidInPnor = false;
 
-    const std::pair<uint32_t, PNOR::SectionId> l_lid(i_lidId,
-                                                     PNOR::INVALID_SECTION);
+//  Map of PNOR section Ids to pairs of LidIds
+//  Key - PNOR section
+//  Value - LidAndContainerLid
+//          The first Lid in the pair is the image content
+//          The second Lid in the pair is the Container LID (Secure Header)
+static const PnorLidsMap PnorToLidsMap =
+{
+    { PNOR::TESTRO,  LidAndContainerLid(TEST_LIDID, INVALID_LIDID)},
+    { PNOR::OCC,     LidAndContainerLid(OCC_LIDID, OCC_CONTAINER_LIDID)},
+    { PNOR::WOFDATA, LidAndContainerLid(WOF_LIDID, WOF_CONTAINER_LIDID)},
+    { PNOR::HCODE,   LidAndContainerLid(NIMBUS_HCODE_LIDID, HCODE_CONTAINER_LIDID)},
+    /* @TODO RTC:177927 - Figure out how to handle different Lids for the
+                              same PNOR section based on chip.
+    { PNOR::HCODE,   LidAndContainerLid(CUMULUS_HCODE_LIDID, HCODE_CONTAINER_LIDID)},
+    */
+    { PNOR::RINGOVD, LidAndContainerLid(HWREFIMG_RINGOVD_LIDID,INVALID_LIDID)},
+};
 
-    const std::pair<uint32_t, PNOR::SectionId>* l_result =
-                            std::lower_bound (Util::lidToPnor,
-                                        Util::lidToPnor + Util::NUM_LID_TO_PNOR,
-                                        l_lid,
-                                        Util::cmpLidToPnor);
+LidAndContainerLid getPnorSecLidIds(const PNOR::SectionId i_sec)
+{
+    LidAndContainerLid l_lids;
 
-    if (l_result != (Util::lidToPnor + Util::NUM_LID_TO_PNOR) &&
-        l_result->first == l_lid.first &&
-        l_result->second != PNOR::INVALID_SECTION)
+    auto l_secIter = PnorToLidsMap.find(i_sec);
+    if (l_secIter != PnorToLidsMap.end())
     {
-        l_err = PNOR::getSectionInfo(l_result->second, o_lidPnorInfo);
+        l_lids.lid = l_secIter->second.lid;
+        l_lids.containerLid = l_secIter->second.containerLid;
+    }
+
+    return l_lids;
+}
+
+PNOR::SectionId getLidPnorSection(const LidId i_lid)
+{
+    PNOR::SectionId l_secId  = PNOR::INVALID_SECTION;
+
+    // Search map by value
+    // Note: Sacrificed constant look up with another map in the reverse
+    //       direction to simplify maintenance with a single map
+    auto l_secIter = std::find_if( PnorToLidsMap.begin(),
+                                   PnorToLidsMap.end(),
+                                   [i_lid](const PnorLidsPair & pair) -> bool
+                                 {
+                                     return pair.second.lid == i_lid;
+                                 });
+    // Check if we found a valid entry.
+    if (l_secIter != PnorToLidsMap.end())
+    {
+        l_secId = l_secIter->first;
+    }
+
+    return l_secId;
+}
+
+} // end Util namespace
+
+bool UtilLidMgr::getLidPnorSectionInfo(uint32_t i_lidId,
+                                       PNOR::SectionInfo_t &o_lidPnorInfo)
+{
+    errlHndl_t l_err = NULL;
+    bool l_lidInPnor = false;
+
+    // Search if a lid id maps to pnor section
+    auto l_secId = Util::getLidPnorSection(static_cast<Util::LidId>(i_lidId));
+    // LidToPnor will return INVALID_SECITON if no mapping found
+    if (l_secId == PNOR::INVALID_SECTION)
+    {
+        o_lidPnorInfo.id = PNOR::INVALID_SECTION;
+    }
+    // A mapping was found
+    else
+    {
+        l_err = PNOR::getSectionInfo(l_secId, o_lidPnorInfo);
         // Section is optional or lid is not in PNOR, so just delete error
         if (l_err)
         {
             o_lidPnorInfo.id = PNOR::INVALID_SECTION;
-            l_lidInPnor = false;
             delete l_err;
             l_err = NULL;
         }
         else
         {
             l_lidInPnor = true;
-
 #ifdef CONFIG_SECUREBOOT
 #ifndef __HOSTBOOT_RUNTIME
             // The lid could be securely signed in PNOR
             if(o_lidPnorInfo.secure)
             {
                 // Load the secure section
-                l_err = loadSecureSection(l_result->second);
+                l_err = loadSecureSection(l_secId);
 
                 // If secure section fails to load log the error and assert
                 if (l_err)
                 {
                     errlCommit(l_err, UTIL_COMP_ID);
-                    assert(false,"UtilLidMgr::getLidPnorSection: attempt to "
+                    assert(false,"UtilLidMgr::getLidPnorSectionInfo: attempt to "
                                  "load Secure Section %d failed",
-                                 l_result->second);
+                                 l_secId);
                 }
 
                 // In Secureboot, rather than using the whole partition size,
@@ -94,5 +150,4 @@ bool UtilLidMgr::getLidPnorSection(uint32_t i_lidId,
         }
     }
     return l_lidInPnor;
-
-}
+}
\ No newline at end of file