add support to write errlog to PNOR during runtime

Change-Id: Ia2b211d8ebf489e92f2bc3d281d92175a6b61f30
Depends-On: I170d6586062b6e4684a55782df83a1b19ed7d937
Depends-On: Id8c44b0dcdb5714c163ac6485a53216786f9fbcf
Depends-On: I626bce5c8c0c8b7d0a44408280de178c7a86a83f
RTC: 123419
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/18233
Tested-by: Jenkins Server
Tested-by: Jenkins OP Build CI
Reviewed-by: STEPHEN M. CPREK <smcprek@us.ibm.com>
Tested-by: Jenkins OP HW
Reviewed-by: WILLIAM G. HOFFA <wghoffa@us.ibm.com>
Tested-by: FSP CI Jenkins
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

6 files changed, 542 insertions, 532 deletions

diff --git a/src/include/usr/errl/errlmanager.H b/src/include/usr/errl/errlmanager.H
index 92fcac9b6..586b42221 100644
--- a/src/include/usr/errl/errlmanager.H
+++ b/src/include/usr/errl/errlmanager.H
@@ -255,8 +255,13 @@ private:
      */
     enum ERRORLOG_PLID_OFFSET
     {
+#ifdef __HOSTBOOT_RUNTIME
+        ERRLOG_PLID_BASE        = 0x80000000,// Hostboot Runtime Base PLID Offset
+        ERRLOG_PLID_BASE_MASK   = 0x89000000,// mask of just the id
+#else
         ERRLOG_PLID_BASE        = 0x90000000,// Hostboot Base PLID Offset
         ERRLOG_PLID_BASE_MASK   = 0x9F000000,// mask of just the id
+#endif
         ERRLOG_PLID_NODE_SHIFT  = 24,        // shift to put node number 0x9#
         ERRLOG_PLID_MASK        = 0x00FFFFFF,// mask to find log number
         ERRLOG_PLID_INITIAL     = 0x00FF0000,// initial big id number
@@ -346,6 +351,7 @@ private:
      */
     void sendMboxMsg ( errlHndl_t& io_err );
 
+#ifdef STORE_ERRL_IN_L3
     /**
      * @brief Save errlog entry in the memory
      *
@@ -354,6 +360,7 @@ private:
      *
      */
     void saveErrLogEntry( errlHndl_t& io_err );
+#endif
 
     /**
      * @brief Shutdown error log manager
diff --git a/src/usr/errl/errl.mk b/src/usr/errl/errl.mk
index f87b6c217..91ce34b0e 100644
--- a/src/usr/errl/errl.mk
+++ b/src/usr/errl/errl.mk
@@ -38,4 +38,4 @@ OBJS += errludbacktrace.o
 OBJS += errludattribute.o
 OBJS += errludlogregister.o
 OBJS += errludcallout.o
-OBJS += $(if $(CONFIG_BMC_IPMI),errlmanager_common.o)
\ No newline at end of file
+OBJS += errlmanager_common.o
diff --git a/src/usr/errl/errlmanager.C b/src/usr/errl/errlmanager.C
index 3ae08dde2..dea951ce4 100644
--- a/src/usr/errl/errlmanager.C
+++ b/src/usr/errl/errlmanager.C
@@ -92,10 +92,6 @@ char* g_ErrlStorage;
 
 #endif
 
-const uint32_t PNOR_ERROR_LENGTH = 4096;
-const uint32_t EMPTY_ERRLOG_IN_PNOR = 0xFFFFFFFF;
-const uint32_t FIRST_BYTE_ERRLOG = 0xF0000000;
-
 // Comparator function to check if a eid and a plid are equal
 bool compareEidToPlid(const uint32_t i_plid,
                       const std::pair<errlHndl_t, uint8_t> i_pair)
@@ -754,13 +750,6 @@ void ErrlManager::saveErrLogEntry( errlHndl_t& io_err )
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Atomically increment log id and return it.
-uint32_t ErrlManager::getUniqueErrId()
-{
-    return (__sync_add_and_fetch(&iv_currLogId, 1));
-}
-
-///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 void ErrlManager::setHwasProcessCalloutFn(HWAS::processCalloutFn i_fn)
 {
@@ -771,21 +760,6 @@ void ErrlManager::setHwasProcessCalloutFn(HWAS::processCalloutFn i_fn)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// Global function (not a method on an object) to commit the error log.
-void errlCommit(errlHndl_t& io_err, compId_t i_committerComp )
-{
-    ERRORLOG::theErrlManager::instance().commitErrLog(io_err, i_committerComp );
-    return;
-}
-
-// Global function (not a method on an object) to get the hidden logs flag.
-uint8_t getHiddenLogsEnable( )
-{
-    return ERRORLOG::theErrlManager::instance().iv_hiddenErrLogsEnable;
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // Global function (not a method on an object) to commit the error log.
 void ErrlManager::errlResourceReady(errlManagerNeeds i_needs)
 {
@@ -946,15 +920,7 @@ void ErrlManager::errlogShutdown()
 
     // Ensure that all the error logs are pushed out to PNOR
     // prior to the PNOR resource provider shutting down.
-    int l_rc = mm_remove_pages(FLUSH, (void *) iv_pnorAddr,
-                    iv_maxErrlInPnor * PNOR_ERROR_LENGTH);
-    if( l_rc )
-    {
-        //If mm_remove_pages returns none zero for error then
-        //log an error trace in this case.
-        TRACFCOMP(g_trac_errl, ERR_MRK "Fail to flush the page %p size %d",
-                iv_pnorAddr, iv_maxErrlInPnor * PNOR_ERROR_LENGTH);
-    }
+    PNOR::flush(PNOR::HB_ERRLOGS);
 
     // Un-register error log message queue from the shutdown
     INITSERVICE::unregisterShutdownEvent( iv_msgQ);
@@ -976,355 +942,6 @@ void ErrlManager::errlogShutdown()
     return;
 }
 
-// ------------------------------------------------------------------
-// setupPnorInfo
-// ------------------------------------------------------------------
-void ErrlManager::setupPnorInfo()
-{
-    TRACFCOMP( g_trac_errl, ENTER_MRK"setupPnorInfo" );
-
-    do
-    {
-        // Get SPD PNOR section info from PNOR RP
-        PNOR::SectionInfo_t info;
-        errlHndl_t err = PNOR::getSectionInfo( PNOR::HB_ERRLOGS, info );
-
-        if (err)
-        {
-            TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo getSectionInfo failed");
-            assert(err == NULL);
-            break;
-        }
-
-        TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo sectionInfo id %d name \"%s\" size %d",
-                info.id, info.name, info.size );
-
-        // Set the globals appropriately
-        iv_pnorAddr = reinterpret_cast<char *> (info.vaddr);
-        iv_maxErrlInPnor = info.size / PNOR_ERROR_LENGTH;
-
-        TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo iv_pnorAddr %p maxErrlInPnor %d",
-                iv_pnorAddr, iv_maxErrlInPnor );
-
-        // initial value, in case PNOR is empty - start at this end slot
-        // so that our first save will increment and wrap correctly
-        iv_pnorOpenSlot = (iv_maxErrlInPnor - 1);
-
-        // walk thru memory, finding error logs and determine the highest ID
-        uint32_t l_maxId = 0;
-        for (uint32_t i = 0; i < iv_maxErrlInPnor; i++)
-        {
-            if (!isSlotEmpty(i))
-            {
-                uint32_t l_id = readEidFromFlattened(i);
-                // If id is not from HB (0x9XXXXXXX) grab plid instead
-                if ( (l_id & FIRST_BYTE_ERRLOG) != ERRLOG_PLID_BASE )
-                {
-                    l_id = readPlidFromFlattened(i);
-                }
-                if (l_id > l_maxId )
-                {
-                    l_maxId = l_id;
-
-                    // set this - start at this 'max' slot so that our first
-                    // save will increment correctly
-                    iv_pnorOpenSlot = i;
-                }
-                // also check if it's ACKed or not
-                if (!isSlotACKed(i))
-                {
-                    TRACFCOMP( g_trac_errl,
-                        INFO_MRK"setupPnorInfo slot %d eid %.8X was not ACKed.",
-                        i, l_id);
-
-#ifdef CONFIG_BMC_IPMI
-                    // for IPMI systems, unflatten to send down to the BMC
-                    err = new ERRORLOG::ErrlEntry(
-                            ERRORLOG::ERRL_SEV_UNRECOVERABLE, 0,0);
-                    char *l_errlAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i);
-                    uint64_t rc = err->unflatten(l_errlAddr, PNOR_ERROR_LENGTH);
-                    if (rc != 0)
-                    {
-                        // unflatten didn't work, nothing we can do
-                        TRACFCOMP( g_trac_errl,
-                            ERR_MRK"setupPnorInfo unflatten failed on slot %d eid %.8X.",
-                            i, l_id);
-                    }
-                    else
-                    {
-                        // Decide if we need to skip the error log
-                        setErrlSkipFlag(err);
-                        if(err->getSkipShowingLog())
-                        {
-                            // skip it, go to the next one
-                            continue;
-                        }
-                        if (iv_isIpmiEnabled)
-                        {
-                            // convert to SEL/eSEL and send to BMC over IPMI
-                            sendErrLogToBmc(err);
-                            delete err;
-                        }
-                        else
-                        {
-                            TRACFCOMP( g_trac_errl,
-                                INFO_MRK"setupPnorInfo pushing slot %d eid %.8X to iv_errList.",
-                                i, l_id);
-                            // Pair with IPMI flag to add to the errlList
-                            // so that it'll get sent down when IPMI is up
-#ifdef CONFIG_CONSOLE_OUTPUT_ERRORDISPLAY
-                            ErrlFlagPair_t l_pair(err, IPMI_FLAG | ERRLDISP_FLAG);
-#else
-                            ErrlFlagPair_t l_pair(err, IPMI_FLAG);
-#endif
-                            iv_errlList.push_back(l_pair);
-                        }
-                    }
-#else
-                    // for FSP system, this shouldn't ever happen.
-                    setACKInFlattened(i);
-#endif
-                } // not ACKed
-            } // not empty
-        } // for
-
-        // bump the current eid to 1 past the max eid found
-        while (!__sync_bool_compare_and_swap(&iv_currLogId, iv_currLogId,
-                    (iv_currLogId & ERRLOG_PLID_BASE_MASK) +
-                    (l_maxId & ERRLOG_PLID_MASK) + 1));
-        TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo reseting LogId 0x%X", iv_currLogId);
-
-        // if error(s) came in before PNOR was ready,
-        // the error log(s) would be on this list. save now.
-        ErrlListItr_t it = iv_errlList.begin();
-        while(it != iv_errlList.end())
-        {
-            // Check if PNOR processing is needed
-            if (_isFlagSet(*it, PNOR_FLAG))
-            {
-                //ACK it if no one is there to receive
-                bool l_savedToPnor = saveErrLogToPnor(it->first);
-
-                // check if we actually saved the msg to PNOR
-                if (l_savedToPnor)
-                {
-                    // Mark PNOR processing complete
-                    _clearFlag(*it, PNOR_FLAG);
-                    _updateErrlListIter(it);
-                }
-                else
-                {
-                    // still couldn't save it (PNOR maybe full) so
-                    // it's still on the list.
-                    break; // get out of this while loop.
-                }
-            }
-            else
-            {
-                ++it;
-            }
-        }
-    } while (0);
-
-    TRACFCOMP( g_trac_errl, EXIT_MRK"setupPnorInfo");
-} // setupPnorInfo
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::incrementPnorOpenSlot()
-///////////////////////////////////////////////////////////////////////////////
-bool ErrlManager::incrementPnorOpenSlot()
-{
-    uint32_t initialSlot = iv_pnorOpenSlot; // starting slot
-    do
-    {
-        iv_pnorOpenSlot++;
-        if (iv_pnorOpenSlot == iv_maxErrlInPnor)
-        {   // wrap
-            iv_pnorOpenSlot = 0;
-        }
-    } while (   !isSlotEmpty(iv_pnorOpenSlot) &&
-                !isSlotACKed(iv_pnorOpenSlot) &&
-                (iv_pnorOpenSlot != initialSlot));
-
-    // if we got a different slot, return true; else false - no open slots
-    return (iv_pnorOpenSlot != initialSlot);
-} // incrementPnorOpenSlot
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::saveErrLogToPnor()
-///////////////////////////////////////////////////////////////////////////////
-bool ErrlManager::saveErrLogToPnor( errlHndl_t& io_err)
-{
-    bool rc = false;
-    TRACFCOMP( g_trac_errl, ENTER_MRK"saveErrLogToPnor eid=%.8x", io_err->eid());
-
-    do
-    {
-        // Decide whether or not to skip error log
-        if( io_err->getSkipShowingLog() )
-        {
-            TRACFCOMP( g_trac_errl, INFO_MRK"saveErrLogToPnor: INFORMATIONAL/RECOVERED log, skipping");
-            break;
-        }
-
-        // save our current slot, and see if there's an open slot
-        uint32_t l_previousSlot = iv_pnorOpenSlot;  // in case flatten fails
-
-        if ((iv_pnorAddr != NULL) && incrementPnorOpenSlot())
-        {
-            // flatten into PNOR, truncate to the slot size
-            char *l_pnorAddr =
-                iv_pnorAddr + (PNOR_ERROR_LENGTH * iv_pnorOpenSlot);
-            TRACDBIN( g_trac_errl, INFO_MRK"saveErrLogToPnor: l_pnorAddr before",
-                l_pnorAddr, 128);
-            uint64_t l_errSize = io_err->flatten(l_pnorAddr,
-                                    PNOR_ERROR_LENGTH, true);
-            if (l_errSize !=0)
-            {
-                TRACFCOMP( g_trac_errl, INFO_MRK"saveErrLogToPnor: %d bytes flattened into %p, slot %d",
-                    l_errSize, l_pnorAddr, iv_pnorOpenSlot );
-
-                TRACDBIN( g_trac_errl, INFO_MRK"saveErrLogToPnor: l_pnorAddr after",
-                    l_pnorAddr, 128);
-
-                // Ensure that this error log is pushed out to PNOR
-                int l_rc = mm_remove_pages(FLUSH,
-                                (void *) l_pnorAddr, l_errSize);
-                if( l_rc )
-                {
-                    //If mm_remove_pages returns none zero for error then
-                    //log an error trace in this case.
-                    TRACFCOMP(g_trac_errl, ERR_MRK "Fail to flush the page %p size %d",
-                            l_pnorAddr, PNOR_ERROR_LENGTH);
-                }
-            }
-            else
-            {
-                // flatten didn't work, so still return true - we don't want
-                // to try to save this errlog.
-
-                TRACFCOMP( g_trac_errl, ERR_MRK"saveErrLogToPnor: could not flatten data");
-                // restore slot so that our next save will find this slot
-                iv_pnorOpenSlot = l_previousSlot;
-            }
-            rc = true;
-        }
-        // else no open slot - return false
-    } while( 0 );
-
-    TRACFCOMP( g_trac_errl, EXIT_MRK"saveErrLogToPnor returning %s",
-        rc ? "true" : "false");
-    return rc;
-} // saveErrLogToPnor
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::ackErrLogInPnor()
-///////////////////////////////////////////////////////////////////////////////
-bool ErrlManager::ackErrLogInPnor( uint32_t i_errEid )
-{
-    TRACFCOMP( g_trac_errl, ENTER_MRK"ackErrLogInPnor(%.8x)", i_errEid);
-    bool rc = true;
-
-    // look for an un-ACKed log that matches this eid
-    uint32_t i;
-    for (i = 0; i < iv_maxErrlInPnor; i++)
-    {
-        if (!isSlotEmpty(i) && !isSlotACKed(i))
-        {
-            uint32_t l_eid = readEidFromFlattened(i);
-            if (l_eid == i_errEid)
-            {
-                TRACDCOMP( g_trac_errl, INFO_MRK"ackErrLogInPnor: match in slot %d", i);
-                setACKInFlattened(i);
-                break;
-            }
-        }
-    } // for
-
-    // if we made it through the loop w/out breaking early
-    if (i == iv_maxErrlInPnor)
-    {
-        //could not find the errorlog to mark for acknowledgment
-        TRACDCOMP( g_trac_errl, ERR_MRK"ackErrLogInPnor failed to find the error log" );
-        rc = false;
-    }
-
-    TRACFCOMP( g_trac_errl, EXIT_MRK"ackErrLogInPnor returning %s",
-            rc ? "true" : "false");
-    return rc;
-} // ackErrLogInPnor
-
-
-bool ErrlManager::isSlotEmpty(uint32_t i_position)
-{
-    // checks the first word of the flattened errlog, which should be a
-    //  pelsectionheader - which will NEVER be 0xFFFFFFFF if it's valid.
-    char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
-    bool rc = (memcmp(l_pnorAddr, &EMPTY_ERRLOG_IN_PNOR, sizeof(uint32_t))
-                    == 0);
-    TRACDCOMP( g_trac_errl, "isSlotEmpty: slot %d @ %p is %s",
-        i_position, l_pnorAddr, rc ? "empty" : "not empty");
-    return rc;
-}
-
-// readEidFromFlattened()
-// i_position MUST be valid errlog (not EMPTY_ERRLOG_IN_PNOR)
-uint32_t ErrlManager::readEidFromFlattened(uint32_t i_position)
-{
-    const char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
-    const pelPrivateHeaderSection_t *pPH =
-            reinterpret_cast<const pelPrivateHeaderSection_t *>(l_pnorAddr);
-    TRACDCOMP(g_trac_errl, "readEid(%d): eid %.8x", i_position, pPH->eid);
-
-    return pPH->eid;
-}
-
-// readPlidFromFlattened()
-// i_position MUST be valid errlog (not EMPTY_ERRLOG_IN_PNOR)
-uint32_t ErrlManager::readPlidFromFlattened(uint32_t i_position)
-{
-    const char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
-    const pelPrivateHeaderSection_t *pPH =
-            reinterpret_cast<const pelPrivateHeaderSection_t *>(l_pnorAddr);
-    TRACDCOMP(g_trac_errl, "readEid(%d): plid %.8x", i_position, pPH->plid);
-
-    return pPH->plid;
-}
-
-// isSlotACKed()
-// i_position MUST be valid errlog (not EMPTY_ERRLOG_IN_PNOR)
-bool ErrlManager::isSlotACKed(uint32_t i_position)
-{
-    const char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
-    l_pnorAddr += sizeof(pelPrivateHeaderSection_t);
-    l_pnorAddr += sizeof(pelUserHeaderSection_t);
-    const pelSRCSection_t *pSRC =
-            reinterpret_cast<const pelSRCSection_t *>(l_pnorAddr);
-
-    TRACDCOMP(g_trac_errl, "isSlotACKed(%d): word5 %08x - %s",
-        i_position, pSRC->word5,
-        (pSRC->word5 & ErrlSrc::ACK_BIT) ? "not ACKed" : "ACKed");
-
-    return (pSRC->word5 & ErrlSrc::ACK_BIT) ? false : true;
-}
-
-// setACKInFlattened()
-void ErrlManager::setACKInFlattened(uint32_t i_position)
-{
-    char * l_pnorErrlAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
-    char * l_pnorAddr = l_pnorErrlAddr + sizeof(pelPrivateHeaderSection_t);
-    l_pnorAddr += sizeof(pelUserHeaderSection_t);
-    pelSRCSection_t *pSRC = reinterpret_cast<pelSRCSection_t *>(l_pnorAddr);
-
-    pSRC->word5 &= ~(ErrlSrc::ACK_BIT);
-
-    TRACDCOMP(g_trac_errl, "setACKInFlattened(%d): word5 %08x - %s",
-        i_position, pSRC->word5,
-        (pSRC->word5 & ErrlSrc::ACK_BIT) ? "not ACKed" : "ACKed");
-
-    return;
-}
-
 bool ErrlManager::_updateErrlListIter(ErrlListItr_t & io_it)
 {
     bool l_removed = false;
@@ -1344,55 +961,4 @@ bool ErrlManager::_updateErrlListIter(ErrlListItr_t & io_it)
     return l_removed;
 }
 
-void ErrlManager::setErrlSkipFlag(errlHndl_t io_err)
-{
-    // Note: iv_skipShowingLog is set to True by default
-    //0 = Prevent INFORMATIONAL/RECOVERED error logs from being processed.
-    //1 = Send only INFORMATIONAL error logs.
-    //2 = Send only RECOVERED error logs.
-    //3 = Allow all hidden error logs to be processed.
-
-    //Check severity
-    switch (io_err->sev())
-    {
-        case ERRORLOG::ERRL_SEV_INFORMATIONAL:
-
-            // check if we are allowing info logs through.
-            if((iv_hiddenErrLogsEnable ==
-                TARGETING::
-                    HIDDEN_ERRLOGS_ENABLE_ALLOW_INFORMATIONAL)||
-               (iv_hiddenErrLogsEnable ==
-                TARGETING::
-                    HIDDEN_ERRLOGS_ENABLE_ALLOW_ALL_LOGS))
-            {
-                io_err->setSkipShowingLog(false);
-            }
-            break;
-
-        case ERRORLOG::ERRL_SEV_RECOVERED:
-
-            // check if we are allowing recovered logs through.
-            if(((iv_hiddenErrLogsEnable ==
-               TARGETING::
-                    HIDDEN_ERRLOGS_ENABLE_ALLOW_RECOVERED) ||
-               (iv_hiddenErrLogsEnable ==
-                TARGETING::
-                    HIDDEN_ERRLOGS_ENABLE_ALLOW_ALL_LOGS)) &&
-                !iv_isSpBaseServices)
-            {
-                //Recovered error logs that are encountered
-                //before targeting and initservice are loaded,
-                //will still be queued for sending to PNOR/IPMI
-                io_err->setSkipShowingLog(false);
-            }
-            break;
-
-        default:
-
-            // For any error log that is not INFORMATIONAL
-            // or RECOVERED, we want to show the log
-            io_err->setSkipShowingLog(false);
-    }
-} // setErrlSkipFlag
-
 } // End namespace
diff --git a/src/usr/errl/errlmanager_common.C b/src/usr/errl/errlmanager_common.C
index a87323813..17422cb12 100644
--- a/src/usr/errl/errlmanager_common.C
+++ b/src/usr/errl/errlmanager_common.C
@@ -29,13 +29,405 @@
 #include <ipmi/ipmisel.H>
 #include <ipmi/ipmisensor.H>
 
+#include <sys/mm.h>
+#include <pnor/pnorif.H>
+
 namespace ERRORLOG
 {
 
 extern trace_desc_t* g_trac_errl;
 
+const uint32_t PNOR_ERROR_LENGTH = 4096;
+const uint32_t EMPTY_ERRLOG_IN_PNOR = 0xFFFFFFFF;
+const uint32_t FIRST_BYTE_ERRLOG = 0xF0000000;
+
+///////////////////////////////////////////////////////////////////////////////
+// Atomically increment log id and return it.
+uint32_t ErrlManager::getUniqueErrId()
+{
+    return (__sync_add_and_fetch(&iv_currLogId, 1));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// Global function (not a method on an object) to commit the error log.
+void errlCommit(errlHndl_t& io_err, compId_t i_committerComp )
+{
+    ERRORLOG::theErrlManager::instance().commitErrLog(io_err, i_committerComp );
+    return;
+}
+
+
+// Global function (not a method on an object) to get the hidden logs flag.
+uint8_t getHiddenLogsEnable( )
+{
+    return ERRORLOG::theErrlManager::instance().iv_hiddenErrLogsEnable;
+}
+
+// ------------------------------------------------------------------
+// setupPnorInfo
+// ------------------------------------------------------------------
+void ErrlManager::setupPnorInfo()
+{
+    TRACFCOMP( g_trac_errl, ENTER_MRK"setupPnorInfo" );
+
+    do
+    {
+        // Get HB_ERRLOG PNOR section info from PNOR RP
+        PNOR::SectionInfo_t info;
+        errlHndl_t err = PNOR::getSectionInfo( PNOR::HB_ERRLOGS, info );
+
+        if (err)
+        {
+            TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo getSectionInfo failed");
+            assert(err == NULL);
+            break;
+        }
+
+        TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo sectionInfo id %d name \"%s\" size %d",
+                info.id, info.name, info.size );
+
+#ifndef __HOSTBOOT_RUNTIME
+        // Set the globals appropriately
+        iv_pnorAddr = reinterpret_cast<char *> (info.vaddr);
+        iv_maxErrlInPnor = info.size / PNOR_ERROR_LENGTH;
+
+        TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo iv_pnorAddr %p maxErrlInPnor %d",
+                iv_pnorAddr, iv_maxErrlInPnor );
+
+        // initial value, in case PNOR is empty - start at this end slot
+        // so that our first save will increment and wrap correctly
+        iv_pnorOpenSlot = (iv_maxErrlInPnor - 1);
+
+        // walk thru memory, finding error logs and determine the highest ID
+        uint32_t l_maxId = 0;
+        for (uint32_t i = 0; i < iv_maxErrlInPnor; i++)
+        {
+            if (!isSlotEmpty(i))
+            {
+                uint32_t l_id = readEidFromFlattened(i);
+                // If eid is not from HB or HBRT (meaning the FSP put this log
+                // in here for us to 'start' from; FSP eid's aren't in the same
+                // range as HB/HBRT eid's)
+                if ( (l_id & FIRST_BYTE_ERRLOG) != ERRLOG_PLID_BASE )
+                {
+                    // then grab plid instead (FSP will have put a HB plid in
+                    l_id = readPlidFromFlattened(i);
+                }
+                // if this is 'my' type of plid (HB or HBRT) see if it's max
+                if (((l_id & FIRST_BYTE_ERRLOG) == ERRLOG_PLID_BASE ) &&
+                    (l_id > l_maxId ))
+                {
+                    l_maxId = l_id;
+
+                    // set this - start at this 'max' slot so that our first
+                    // save will increment correctly
+                    iv_pnorOpenSlot = i;
+                }
+                // also check if it's ACKed or not
+                if (!isSlotACKed(i))
+                {
+                    TRACFCOMP( g_trac_errl,
+                        INFO_MRK"setupPnorInfo slot %d eid %.8X was not ACKed.",
+                        i, l_id);
+
 #ifdef CONFIG_BMC_IPMI
+                    // for IPMI systems, unflatten to send down to the BMC
+                    err = new ERRORLOG::ErrlEntry(
+                            ERRORLOG::ERRL_SEV_UNRECOVERABLE, 0,0);
+                    char *l_errlAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i);
+                    uint64_t rc = err->unflatten(l_errlAddr, PNOR_ERROR_LENGTH);
+                    if (rc != 0)
+                    {
+                        // unflatten didn't work, nothing we can do
+                        TRACFCOMP( g_trac_errl,
+                            ERR_MRK"setupPnorInfo unflatten failed on slot %d eid %.8X.",
+                            i, l_id);
+                    }
+                    else
+                    {
+                        // Decide if we need to skip the error log
+                        setErrlSkipFlag(err);
+                        if(err->getSkipShowingLog())
+                        {
+                            // skip it, go to the next one
+                            continue;
+                        }
+                        if (iv_isIpmiEnabled)
+                        {
+                            // convert to SEL/eSEL and send to BMC over IPMI
+                            sendErrLogToBmc(err);
+                            delete err;
+                        }
+                        else
+                        {
+                            TRACFCOMP( g_trac_errl,
+                                INFO_MRK"setupPnorInfo pushing slot %d eid %.8X to iv_errList.",
+                                i, l_id);
+                            // Pair with IPMI flag to add to the errlList
+                            // so that it'll get sent down when IPMI is up
+                            ErrlFlagPair_t l_pair(err, IPMI_FLAG
+#ifdef CONFIG_CONSOLE_OUTPUT_ERRORDISPLAY
+                                                         | ERRLDISP_FLAG
+#endif
+                                                 );
+                            iv_errlList.push_back(l_pair);
+                        }
+                    }
+#else
+                    // for FSP system, this shouldn't ever happen.
+                    setACKInFlattened(i);
+#endif
+                } // not ACKed
+            } // not empty
+        } // for
+
+        // bump the current eid to 1 past the max eid found
+        while (!__sync_bool_compare_and_swap(&iv_currLogId, iv_currLogId,
+                    (iv_currLogId & ERRLOG_PLID_BASE_MASK) +
+                    (l_maxId & ERRLOG_PLID_MASK) + 1));
+        TRACFCOMP( g_trac_errl, INFO_MRK"setupPnorInfo reseting LogId 0x%X", iv_currLogId);
+
+        // if error(s) came in before PNOR was ready,
+        // the error log(s) would be on this list. save now.
+        ErrlListItr_t it = iv_errlList.begin();
+        while(it != iv_errlList.end())
+        {
+            // Check if PNOR processing is needed
+            if (_isFlagSet(*it, PNOR_FLAG))
+            {
+                //ACK it if no one is there to receive
+                bool l_savedToPnor = saveErrLogToPnor(it->first);
+
+                // check if we actually saved the msg to PNOR
+                if (l_savedToPnor)
+                {
+                    // Mark PNOR processing complete
+                    _clearFlag(*it, PNOR_FLAG);
+                    _updateErrlListIter(it);
+                }
+                else
+                {
+                    // still couldn't save it (PNOR maybe full) so
+                    // it's still on the list.
+                    break; // get out of this while loop.
+                }
+            }
+            else
+            {
+                ++it;
+            }
+        }
+#endif // __HOSTBOOT_RUNTIME
+    } while (0);
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK"setupPnorInfo");
+} // setupPnorInfo
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::incrementPnorOpenSlot()
+///////////////////////////////////////////////////////////////////////////////
+bool ErrlManager::incrementPnorOpenSlot()
+{
+    uint32_t initialSlot = iv_pnorOpenSlot; // starting slot
+    do
+    {
+        iv_pnorOpenSlot++;
+        if (iv_pnorOpenSlot == iv_maxErrlInPnor)
+        {   // wrap
+            iv_pnorOpenSlot = 0;
+        }
+    } while (   !isSlotEmpty(iv_pnorOpenSlot) &&
+                !isSlotACKed(iv_pnorOpenSlot) &&
+                (iv_pnorOpenSlot != initialSlot));
+
+    // if we got a different slot, return true; else false - no open slots
+    return (iv_pnorOpenSlot != initialSlot);
+} // incrementPnorOpenSlot
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::saveErrLogToPnor()
+///////////////////////////////////////////////////////////////////////////////
+bool ErrlManager::saveErrLogToPnor( errlHndl_t& io_err)
+{
+    bool rc = false;
+    TRACFCOMP( g_trac_errl, ENTER_MRK"saveErrLogToPnor eid=%.8x", io_err->eid());
+
+    do
+    {
+        // Decide whether or not to skip error log
+        // if so, we'll just 'say' that we saved it and go on.
+        if( io_err->getSkipShowingLog() )
+        {
+            TRACFCOMP( g_trac_errl, INFO_MRK"saveErrLogToPnor: INFORMATIONAL/RECOVERED log, skipping");
+            rc = true;
+            break;
+        }
+
+        // save our current slot, and see if there's an open slot
+        uint32_t l_previousSlot = iv_pnorOpenSlot;  // in case flatten fails
+
+        if ((iv_pnorAddr != NULL) && incrementPnorOpenSlot())
+        {
+            // flatten into PNOR, truncate to the slot size
+            char *l_pnorAddr =
+                iv_pnorAddr + (PNOR_ERROR_LENGTH * iv_pnorOpenSlot);
+            TRACDBIN( g_trac_errl, INFO_MRK"saveErrLogToPnor: l_pnorAddr before",
+                l_pnorAddr, 128);
+            uint64_t l_errSize = io_err->flatten(l_pnorAddr,
+                                    PNOR_ERROR_LENGTH, true);
+            if (l_errSize !=0)
+            {
+                TRACFCOMP( g_trac_errl, INFO_MRK"saveErrLogToPnor: %d bytes flattened into %p, slot %d",
+                    l_errSize, l_pnorAddr, iv_pnorOpenSlot );
+
+                TRACDBIN( g_trac_errl, INFO_MRK"saveErrLogToPnor: l_pnorAddr after",
+                    l_pnorAddr, 128);
+
+                // Ensure that this error log is pushed out to PNOR
+#ifdef __HOSTBOOT_RUNTIME
+                PNOR::flush(PNOR::HB_ERRLOGS);
+#else
+                // FLUSH so that only the dirty pages get pushed out
+                int l_rc = mm_remove_pages(FLUSH,
+                                (void *) l_pnorAddr, l_errSize);
+                if( l_rc )
+                {
+                    //If mm_remove_pages returns non zero, trace error
+                    TRACFCOMP(g_trac_errl, ERR_MRK "Fail to flush the page %p size %d",
+                            l_pnorAddr, l_errSize);
+                }
+#endif
+            }
+            else
+            {
+                // flatten didn't work, so still return true - we don't want
+                // to try to save this errlog.
+
+                TRACFCOMP( g_trac_errl, ERR_MRK"saveErrLogToPnor: could not flatten data");
+                // restore slot so that our next save will find this slot
+                iv_pnorOpenSlot = l_previousSlot;
+            }
+            rc = true;
+        }
+        // else no open slot - return false
+    } while (0);
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK"saveErrLogToPnor returning %s",
+        rc ? "true" : "false");
+    return rc;
+} // saveErrLogToPnor
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::ackErrLogInPnor()
+///////////////////////////////////////////////////////////////////////////////
+bool ErrlManager::ackErrLogInPnor( uint32_t i_errEid )
+{
+    TRACFCOMP( g_trac_errl, ENTER_MRK"ackErrLogInPnor(%.8x)", i_errEid);
+    bool rc = true;
+
+    // look for an un-ACKed log that matches this eid
+    uint32_t i;
+    for (i = 0; i < iv_maxErrlInPnor; i++)
+    {
+        if (!isSlotEmpty(i) && !isSlotACKed(i))
+        {
+            uint32_t l_eid = readEidFromFlattened(i);
+            if (l_eid == i_errEid)
+            {
+                TRACDCOMP( g_trac_errl, INFO_MRK"ackErrLogInPnor: match in slot %d", i);
+                setACKInFlattened(i);
+                break;
+            }
+        }
+    } // for
+
+    // if we made it through the loop w/out breaking early
+    if (i == iv_maxErrlInPnor)
+    {
+        //could not find the errorlog to mark for acknowledgment
+        TRACDCOMP( g_trac_errl, ERR_MRK"ackErrLogInPnor failed to find the error log" );
+        rc = false;
+    }
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK"ackErrLogInPnor returning %s",
+            rc ? "true" : "false");
+    return rc;
+} // ackErrLogInPnor
+
+
+bool ErrlManager::isSlotEmpty(uint32_t i_position)
+{
+    // checks the first word of the flattened errlog, which should be a
+    //  pelsectionheader - which will NEVER be 0xFFFFFFFF if it's valid.
+    char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
+    bool rc = (memcmp(l_pnorAddr, &EMPTY_ERRLOG_IN_PNOR, sizeof(uint32_t))
+                    == 0);
+    TRACDCOMP( g_trac_errl, "isSlotEmpty: slot %d @ %p is %s",
+        i_position, l_pnorAddr, rc ? "empty" : "not empty");
+    return rc;
+}
+
+// readEidFromFlattened()
+// i_position MUST be valid errlog (not EMPTY_ERRLOG_IN_PNOR)
+uint32_t ErrlManager::readEidFromFlattened(uint32_t i_position)
+{
+    const char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
+    const pelPrivateHeaderSection_t *pPH =
+            reinterpret_cast<const pelPrivateHeaderSection_t *>(l_pnorAddr);
+    TRACDCOMP(g_trac_errl, "readEid(%d): eid %.8x", i_position, pPH->eid);
+
+    return pPH->eid;
+}
+
+// readPlidFromFlattened()
+// i_position MUST be valid errlog (not EMPTY_ERRLOG_IN_PNOR)
+uint32_t ErrlManager::readPlidFromFlattened(uint32_t i_position)
+{
+    const char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
+    const pelPrivateHeaderSection_t *pPH =
+            reinterpret_cast<const pelPrivateHeaderSection_t *>(l_pnorAddr);
+    TRACDCOMP(g_trac_errl, "readEid(%d): plid %.8x", i_position, pPH->plid);
+
+    return pPH->plid;
+}
+
+// isSlotACKed()
+// i_position MUST be valid errlog (not EMPTY_ERRLOG_IN_PNOR)
+bool ErrlManager::isSlotACKed(uint32_t i_position)
+{
+    const char * l_pnorAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
+    l_pnorAddr += sizeof(pelPrivateHeaderSection_t);
+    l_pnorAddr += sizeof(pelUserHeaderSection_t);
+    const pelSRCSection_t *pSRC =
+            reinterpret_cast<const pelSRCSection_t *>(l_pnorAddr);
 
+    TRACDCOMP(g_trac_errl, "isSlotACKed(%d): word5 %08x - %s",
+        i_position, pSRC->word5,
+        (pSRC->word5 & ErrlSrc::ACK_BIT) ? "not ACKed" : "ACKed");
+
+    return (pSRC->word5 & ErrlSrc::ACK_BIT) ? false : true;
+}
+
+// setACKInFlattened()
+void ErrlManager::setACKInFlattened(uint32_t i_position)
+{
+    char * l_pnorErrlAddr = iv_pnorAddr + (PNOR_ERROR_LENGTH * i_position);
+    char * l_pnorAddr = l_pnorErrlAddr + sizeof(pelPrivateHeaderSection_t);
+    l_pnorAddr += sizeof(pelUserHeaderSection_t);
+    pelSRCSection_t *pSRC = reinterpret_cast<pelSRCSection_t *>(l_pnorAddr);
+
+    pSRC->word5 &= ~(ErrlSrc::ACK_BIT);
+
+    TRACDCOMP(g_trac_errl, "setACKInFlattened(%d): word5 %08x - %s",
+        i_position, pSRC->word5,
+        (pSRC->word5 & ErrlSrc::ACK_BIT) ? "not ACKed" : "ACKed");
+
+    return;
+}
+
+
+#ifdef CONFIG_BMC_IPMI
 void getSensorOffsetBasedOnSeverity(errlHndl_t & io_err,
                                     uint8_t &o_eventDirType,
                                     uint8_t & o_offset );
@@ -47,6 +439,9 @@ void getSensorInfo(HWAS::callout_ud_t *i_ud,
                    HWAS::callOutPriority &io_priority,
                    errlHndl_t& io_error );
 
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::sendErrLogToBmc()
+///////////////////////////////////////////////////////////////////////////////
 void ErrlManager::sendErrLogToBmc(errlHndl_t &io_err)
 {
     TRACFCOMP(g_trac_errl, ENTER_MRK
@@ -226,7 +621,6 @@ void ErrlManager::sendErrLogToBmc(errlHndl_t &io_err)
     TRACFCOMP(g_trac_errl, EXIT_MRK "sendErrLogToBmc");
 } // sendErrLogToBmc
 
-
 void getSensorInfo(HWAS::callout_ud_t *i_ud, uint8_t
                          &o_sensorNumber, uint8_t &o_eventOffset,
                          HWAS::callOutPriority &io_priority,
@@ -330,7 +724,57 @@ void getSensorOffsetBasedOnSeverity(errlHndl_t & io_err,
             break;
     }
 }
+#endif // CONFIG_BMC_IPMI
 
-#endif
+void ErrlManager::setErrlSkipFlag(errlHndl_t io_err)
+{
+    // Note: iv_skipShowingLog is set to True by default
+    //0 = Prevent INFORMATIONAL/RECOVERED error logs from being processed.
+    //1 = Send only INFORMATIONAL error logs.
+    //2 = Send only RECOVERED error logs.
+    //3 = Allow all hidden error logs to be processed.
+
+    //Check severity
+    switch (io_err->sev())
+    {
+        case ERRORLOG::ERRL_SEV_INFORMATIONAL:
+
+            // check if we are allowing info logs through.
+            if((iv_hiddenErrLogsEnable ==
+                TARGETING::
+                    HIDDEN_ERRLOGS_ENABLE_ALLOW_INFORMATIONAL)||
+               (iv_hiddenErrLogsEnable ==
+                TARGETING::
+                    HIDDEN_ERRLOGS_ENABLE_ALLOW_ALL_LOGS))
+            {
+                io_err->setSkipShowingLog(false);
+            }
+            break;
+
+        case ERRORLOG::ERRL_SEV_RECOVERED:
+
+            // check if we are allowing recovered logs through.
+            if(((iv_hiddenErrLogsEnable ==
+               TARGETING::
+                    HIDDEN_ERRLOGS_ENABLE_ALLOW_RECOVERED) ||
+               (iv_hiddenErrLogsEnable ==
+                TARGETING::
+                    HIDDEN_ERRLOGS_ENABLE_ALLOW_ALL_LOGS)) &&
+                !iv_isSpBaseServices)
+            {
+                //Recovered error logs that are encountered
+                //before targeting and initservice are loaded,
+                //will still be queued for sending to PNOR/IPMI
+                io_err->setSkipShowingLog(false);
+            }
+            break;
+
+        default:
+
+            // For any error log that is not INFORMATIONAL
+            // or RECOVERED, we want to show the log
+            io_err->setSkipShowingLog(false);
+    }
+} // setErrlSkipFlag
 
 } // end namespace
diff --git a/src/usr/errl/runtime/rt_errlmanager.C b/src/usr/errl/runtime/rt_errlmanager.C
index ff668a7c4..f75844172 100644
--- a/src/usr/errl/runtime/rt_errlmanager.C
+++ b/src/usr/errl/runtime/rt_errlmanager.C
@@ -33,6 +33,7 @@
 #include <string.h>
 #include <runtime/interface.h>
 #include <targeting/common/targetservice.H>
+#include <pnor/pnorif.H>
 
 namespace ERRORLOG
 {
@@ -61,21 +62,27 @@ bool rt_processCallout(errlHndl_t &io_errl,
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
-ErrlManager::ErrlManager()
-    :
+ErrlManager::ErrlManager() :
         iv_currLogId(0),
         iv_pStorage(NULL),
         iv_hwasProcessCalloutFn(NULL),
-        iv_msgQ(NULL)
+        iv_pnorAddr(NULL),
+        iv_maxErrlInPnor(0),
+        iv_pnorOpenSlot(0),
+        iv_isSpBaseServices(false),
+#ifdef CONFIG_BMC_IPMI
+        iv_isIpmiEnabled(true)
+#else
+        iv_isIpmiEnabled(false)
+#endif
 {
-    TRACFCOMP( g_trac_errl, ENTER_MRK "ErrlManager::ErrlManager constructor" );
-
+    TRACFCOMP( g_trac_errl, ENTER_MRK "ErrlManager::ErrlManager constructor." );
 
     iv_hwasProcessCalloutFn = rt_processCallout;
 
+    // determine starting PLID value
     TARGETING::Target * sys = NULL;
     TARGETING::targetService().getTopLevelTarget( sys );
-
     if(sys)
     {
         iv_currLogId = sys->getAttr<TARGETING::ATTR_HOSTSVC_PLID>();
@@ -90,10 +97,34 @@ ErrlManager::ErrlManager()
     }
     else
     {
-        iv_currLogId = 0x9fbad000;
+        iv_currLogId = 0x89bad000;
         TRACFCOMP( g_trac_errl, ERR_MRK"HOSTSVC_PLID not available" );
     }
 
+#if 1
+// TODO: RTC 131067
+// for now do this. but the real code should be the #else below.
+#ifdef CONFIG_BMC_IPMI
+        // setup so that we can write the error log to PNOR
+        setupPnorInfo();
+#endif
+#else
+    // check if there's an FSP. if not, then we write to PNOR
+    TARGETING::SpFunctions spfn;
+    if (!(sys &&
+          sys->tryGetAttr<TARGETING::ATTR_SP_FUNCTIONS>(spfn) &&
+          spfn.baseServices))
+    {
+        iv_isSpBaseServices = false;
+        TRACFCOMP( g_trac_errl, INFO_MRK"no baseServices, setting up to save to pnor" );
+        setupPnorInfo();
+    }
+    else
+    {
+        iv_isSpBaseServices = true;
+    }
+#endif
+
     TRACFCOMP( g_trac_errl, EXIT_MRK "ErrlManager::ErrlManager constructor." );
 }
 
@@ -102,44 +133,60 @@ ErrlManager::ErrlManager()
 ErrlManager::~ErrlManager()
 {
     TRACFCOMP( g_trac_errl, INFO_MRK"ErrlManager::ErrlManager destructor" );
+#if 1
+// TODO: RTC 131067
+// for now do this. but the real code should be the #else below.
+#ifdef CONFIG_BMC_IPMI
+        // if we saved to PNOR, we need to flush
+        TRACFCOMP( g_trac_errl, INFO_MRK"flushing pnor" );
+        PNOR::flush(PNOR::HB_ERRLOGS);
+#endif
+#else
+    if (!iv_isSpBaseServices)
+    {
+        // if we saved to PNOR, we need to flush
+        TRACFCOMP( g_trac_errl, INFO_MRK"no baseServices, flushing pnor" );
+        PNOR::flush(PNOR::HB_ERRLOGS);
+    }
+#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::msgQueueInit()
-///////////////////////////////////////////////////////////////////////////////
-void ErrlManager::msgQueueInit ( void )
-{
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::startup()
-///////////////////////////////////////////////////////////////////////////////
-void * ErrlManager::startup ( void* i_self )
-{
-    return NULL;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::errlogMsgHndlr()
-///////////////////////////////////////////////////////////////////////////////
-void ErrlManager::errlogMsgHndlr ( void )
-{
-    // Not used in HB_RUNTIME
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
 // ErrlManager::sendMboxMsg()
 ///////////////////////////////////////////////////////////////////////////////
 void ErrlManager::sendMboxMsg ( errlHndl_t& io_err )
 {
-    TRACFCOMP( g_trac_errl, ENTER_MRK"ErrlManager::sendToHypervisor" );
     do
     {
+#if 1
+// TODO: RTC 131067
+// for now do this. but the real code should be the #else below.
+#ifdef CONFIG_BMC_IPMI
+        bool l_savedToPnor = saveErrLogToPnor(io_err);
+        if (!l_savedToPnor)
+        {
+            TRACFCOMP( g_trac_errl, ENTER_MRK"saveErrLogToPnor didn't save 0x%X",
+                io_err->eid());
+        }
+#endif
+#else
+        if (!iv_isSpBaseServices)
+        {
+            // save to PNOR
+            TRACFCOMP( g_trac_errl, INFO_MRK"no baseServices, saving to pnor" );
+            bool l_savedToPnor = saveErrLogToPnor(io_err);
+            if (!l_savedToPnor)
+            {
+                TRACFCOMP( g_trac_errl, ENTER_MRK"saveErrLogToPnor didn't save 0x%X",
+                    io_err->eid());
+            }
+        }
+#endif
+
 #ifdef CONFIG_BMC_IPMI
         TRACFCOMP(g_trac_errl,INFO_MRK"Send msg to BMC for errlogId [0x%08x]",
                   io_err->plid() );
+
         // convert to SEL/eSEL and send to BMC over IPMI
         sendErrLogToBmc(io_err);
 #else
@@ -225,64 +272,12 @@ void ErrlManager::commitErrLog(errlHndl_t& io_err, compId_t i_committerComp )
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::saveErrLogEntry()
-///////////////////////////////////////////////////////////////////////////////
-void ErrlManager::saveErrLogEntry( errlHndl_t& io_err )
-{
-    return;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Atomically increment log id and return it.
-uint32_t ErrlManager::getUniqueErrId()
-{
-    return (__sync_add_and_fetch(&iv_currLogId, 1));
-}
-
-///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 void ErrlManager::setHwasProcessCalloutFn(HWAS::processCalloutFn i_fn)
 {
     ERRORLOG::theErrlManager::instance().iv_hwasProcessCalloutFn = i_fn;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// Global function (not a method on an object) to commit the error log.
-void errlCommit(errlHndl_t& io_err, compId_t i_committerComp )
-{
-    ERRORLOG::theErrlManager::instance().commitErrLog(io_err, i_committerComp );
-    return;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// Global function (not a method on an object) to get the hidden logs flag.
-uint8_t getHiddenLogsEnable( )
-{
-    return ERRORLOG::theErrlManager::instance().iv_hiddenErrLogsEnable;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::sendErrlogToMessageQueue()
-///////////////////////////////////////////////////////////////////////////////
-void ErrlManager::sendErrlogToMessageQueue ( errlHndl_t& io_err,
-                                             compId_t i_committerComp )
-{
-    return;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// ErrlManager::errlogShutdown()
-///////////////////////////////////////////////////////////////////////////////
-void ErrlManager::errlogShutdown(void)
-{
-    return;
-}
-
 //  Runtime processCallout
 bool rt_processCallout(errlHndl_t &io_errl,
                        uint8_t * i_pData,
@@ -309,4 +304,10 @@ bool rt_processCallout(errlHndl_t &io_errl,
     return true;
 }
 
+void ErrlManager::errlAckErrorlog(uint32_t i_eid)
+{
+    ERRORLOG::theErrlManager::instance().ackErrLogInPnor(i_eid);
+    return;
+}
+
 } // End namespace
diff --git a/src/usr/ipmi/ipmisel.C b/src/usr/ipmi/ipmisel.C
index d2381efad..54512e606 100644
--- a/src/usr/ipmi/ipmisel.C
+++ b/src/usr/ipmi/ipmisel.C
@@ -182,10 +182,6 @@ void process_esel(msg_t *i_msg)
         IPMI_TRAC(ERR_MRK "DELETING l_err 0x%.8X", l_err->eid());
         delete l_err;
         l_err = NULL;
-
-        // TODO RTC: 123419 investigate adding a 'iv_isIpmiEnabled' flag and setting
-        // that to false somehow, so that we can commit error logs in this path
-        // and future calls wont try to send them down.
 #else
         l_err->collectTrace(IPMI_COMP_NAME);
         errlCommit(l_err, IPMI_COMP_ID);
@@ -194,13 +190,9 @@ void process_esel(msg_t *i_msg)
     else if((l_cc == IPMI::CC_OK) &&        // no error
             (l_eid != 0))                   // and it's an errorlog
     {
-#ifdef __HOSTBOOT_RUNTIME
-        // TODO RTC: 123419 story to add storing errlog to PNOR in HBRT if IPMI
-#else
-        // eSEL successfully sent to the BMC - send an ack to the errlmanager
+        // eSEL successfully sent to the BMC - 'send' an ack to the errlmanager
         IPMI_TRAC(INFO_MRK "Sending ack for eid 0x%.8X", l_eid);
         ERRORLOG::ErrlManager::errlAckErrorlog(l_eid);
-#endif
     }
 
     delete l_data;