Report host boot error log to FSP

Change-Id: Iad4be4f0a45a607f7b56fc5d194f1812f74fbfe8
RTC: 34235
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/1949
Tested-by: Jenkins Server
Reviewed-by: MIKE J. JONES <mjjones@us.ibm.com>
Reviewed-by: Brian H. Horton <brianh@linux.ibm.com>
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

1 files changed, 334 insertions, 24 deletions

diff --git a/src/usr/errl/errlmanager.C b/src/usr/errl/errlmanager.C
index 132ec49c1..e95b6d2fa 100644
--- a/src/usr/errl/errlmanager.C
+++ b/src/usr/errl/errlmanager.C
@@ -32,12 +32,14 @@
 #include <errl/errlmanager.H>
 #include <trace/interface.H>
 #include <errl/errlentry.H>
+#include <sys/task.h>
 #include <stdlib.h>
 #include <string.h>
-
-
-
-
+#include <mbox/mbox_queues.H>
+#include <mbox/mboxif.H> 
+#include <initservice/initserviceif.H>
+#include <pnor/pnorif.H>
+#include <sys/mm.h>
 
 namespace ERRORLOG
 {
@@ -45,7 +47,6 @@ namespace ERRORLOG
 extern trace_desc_t* g_trac_errl;
 
 
-
 // Scaffolding
 // Store error logs in this memory buffer in L3 RAM.
 char* g_ErrlStorage = new char[ ERRL_STORAGE_SIZE ];
@@ -83,7 +84,7 @@ ErrlManager::ErrlManager()
 
     iv_hwasProcessCalloutFn = NULL;
 
-    mutex_init(&iv_commitMutex);
+    TRACFCOMP( g_trac_errl, ENTER_MRK "ErrlManager::ErrlManager constructor" );
 
     // Scaffolding.
     // For now, put error logs in a 64KB buffer in L3 RAM
@@ -104,37 +105,268 @@ ErrlManager::ErrlManager()
     l_pMarker->offsetNext = 0;
     l_pMarker->length     = 0;
 
+    // Create and register error log message queue.
+    msgQueueInit();
+    
+    // Startup the error log processing thread.
+    task_create( ErrlManager::startup, this );
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK "ErrlManager::ErrlManager constructor." );
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 ErrlManager::~ErrlManager()
 {
+    TRACFCOMP( g_trac_errl, ENTER_MRK "ErrlManager::ErrlManager destructor" );
+
+    // Singleton destructor gets run when module gets unloaded. 
+    // This errorlog module never gets unloaded. So rather to send a
+    // message to error log daemon and tell it to shutdow and delete 
+    // the queue we will assert here because the destructor never gets
+    // call. 
+    assert(0);
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK "ErrlManager::ErrlManager destructor." );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::msgQueueInit()
+///////////////////////////////////////////////////////////////////////////////
+void ErrlManager::msgQueueInit ( void )
+{
+    errlHndl_t l_err = NULL;
+    
+    TRACFCOMP( g_trac_errl, ENTER_MRK "ErrlManager::msgQueueInit ..." );
+
+    do
+    {
+        // Create error log message queue.
+        iv_msgQ = msg_q_create();
+
+        // Register messageQ with Mailbox to receive message.
+        l_err = MBOX::msgq_register( MBOX::HB_ERROR_MSGQ,
+                                       iv_msgQ );
+        if( l_err )
+        {
+            TRACFCOMP(g_trac_errl, ERR_MRK "Msg queue already registered");
+            
+            delete( l_err );
+            l_err = NULL;
+
+            //If we got an error then it means the message queue is
+            //registered with mailbox. This should not happen. 
+            //So assert here.
+            assert(0);
+
+            break;
+        }
+
+        // Register for error log manager shutdown event
+        INITSERVICE::registerShutdownEvent( iv_msgQ, ERRLOG_SHUTDOWN, 
+                                                  INITSERVICE::NO_PRIORITY );
+
+    } while (0);
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK "ErrlManager::msgQueueInit" );
+
+    return;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::startup()
+///////////////////////////////////////////////////////////////////////////////
+void * ErrlManager::startup ( void* i_self )
+{
+
+    TRACFCOMP( g_trac_errl, ENTER_MRK "ErrlManager::startup..." );
+
+    //Start a thread and let error log message handler running.
+    reinterpret_cast<ErrlManager *>(i_self)->errlogMsgHndlr();
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK "ErrlManager::startup" );
+
+    return NULL;
+}  
+
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::errlogMsgHndlr()
+///////////////////////////////////////////////////////////////////////////////
+void ErrlManager::errlogMsgHndlr ( void )
+{
+    errlHndl_t l_err = NULL;
+    msg_t * theMsg = NULL;
+
+    TRACFCOMP( g_trac_errl, ENTER_MRK "Enter ErrlManager::errlogMsgHndlr" );
+
+    while( 1 )
+    {
+        theMsg = msg_wait( iv_msgQ );
+        TRACFCOMP( g_trac_errl, INFO_MRK"Got an error log Msg - Type: 0x%08x", 
+                                                               theMsg->type );
+        //Process message just received 
+        switch( theMsg->type )
+        {
+            case ERRLOG_NEEDS_TO_BE_COMMITTED_TYPE:
+
+                //Extract error log handle from the message. We need the error
+                //log handle to pass along to saveErrlogEntry and sendMboxMsg
+                l_err = (errlHndl_t) theMsg->extra_data;
+                
+                //Ask the ErrlEntry to assign commit component, commit time
+                //and callout information
+                l_err->commit( (compId_t) theMsg->data[0] );
+
+                //Write the error log to L3 memory till PNOR is implemented 
+                //RTC #47517 for future task to write error log to PNOR
+                saveErrLogEntry ( l_err );
+           
+                //Create a mbox message with the error log and send it to FSP
+                //We only send error log to FSP when mailbox is enabled
+                if( MBOX::mailbox_enabled() )
+                {
+                    sendMboxMsg ( l_err );
+                }
+ 
+                //We are done with the error log handle so delete it.
+                delete l_err;
+                l_err = NULL;
+
+                //We are done with the msg so go back and wait for a next one 
+                msg_free(theMsg);
+ 
+                break;
+
+            case ERRLOG_COMMITTED_ACK_RESPONSE_TYPE:
+                //Hostboot must keep track and clean up hostboot error 
+                //logs in PNOR after it is committed by FSP. 
+
+                //TODO: We have an RTC 47517 for this work. New code need
+                //to be added to mark the error log in PNOR as committed.
+
+                TRACFCOMP( g_trac_errl, INFO_MRK"Got a acked msg - Type: 0x%08x", 
+                                                                  theMsg->type );
+                msg_free(theMsg);
+                break;
+
+            case ERRLOG_SHUTDOWN:
+                TRACFCOMP( g_trac_errl, INFO_MRK "Shutdown event received" );
+
+                //Start shutdown process for error log
+                errlogShutdown();
+                msg_respond ( iv_msgQ, theMsg );
+                break;
+
+            default:
+                // Default Message
+                TRACFCOMP( g_trac_errl, ERR_MRK "Unexpected message type 0x%08x", 
+                                                                  theMsg->type );
+
+                msg_free(theMsg);
+                break;
+        }
+    }
+
+    //The errlogMsgHndlr should run all the time. It only
+    //exits when error log message thread is killed.
+    TRACFCOMP( g_trac_errl, EXIT_MRK "Exit ErrlManager::errlogMsgHndlr" );
+    return;
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::sendMboxMsg()
+///////////////////////////////////////////////////////////////////////////////
+void ErrlManager::sendMboxMsg ( errlHndl_t& io_err ) 
+{
+    errlHndl_t l_err = NULL;
+    msg_t  *  msg  = NULL;
+
+    TRACFCOMP( g_trac_errl, ENTER_MRK"ErrlManager::sendMboxMsg" );
+    do
+    {
+         //Create a mailbox message to send to FSP
+         msg = msg_allocate();
+         msg->type = ERRLOG_SEND_TO_FSP_TYPE;
+    
+         uint32_t l_msgSize = io_err->flattenedSize();
+
+         //Data[0] will be hostboot error log ID so Hostboot can
+         //keep track of the error log when FSP responses back.
+         //The error log ID is also the plid (platform log identify)
+
+         msg->data[0] = io_err->plid();
+         msg->data[1] = l_msgSize;
+
+         void * temp_buff = malloc( l_msgSize );
+         io_err->flatten ( temp_buff, l_msgSize );
+         msg->extra_data = temp_buff;
+
+        TRACDCOMP( g_trac_errl, INFO_MRK"Send msg to FSP for errlogId [0x%08x]", 
+                                                               io_err->plid() );
+
+        l_err = MBOX::send( MBOX::FSP_ERROR_MSGQ, msg );
+        if( l_err )
+        {
+           TRACFCOMP(g_trac_errl, ERR_MRK "Failed sending error log to FSP");
+
+           //Free the extra data due to the error
+           if( msg != NULL && msg->extra_data != NULL )
+           {
+               free( msg->extra_data );
+               msg_free( msg );
+           }
+
+           delete l_err;
+           l_err = NULL;
+
+        }
+    } while (0);
+
+    TRACFCOMP( g_trac_errl, EXIT_MRK"sendMboxMsg()" );
+    return;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Handling commit error log.
 ///////////////////////////////////////////////////////////////////////////////
-//
-//  Save and delete this error log. On output, io_err will be nul.
-//
 void ErrlManager::commitErrLog(errlHndl_t& io_err, compId_t i_committerComp )
 {
+
+    TRACDCOMP( g_trac_errl, ENTER_MRK"ErrlManager::commitErrLog" );
     do
     {
         if (io_err == NULL)
         {
             // put out warning trace
-            TRACFCOMP(g_trac_errl, "commitErrLog() - NULL pointer");
+            TRACFCOMP(g_trac_errl, ERR_MRK "commitErrLog() - NULL pointer");
             break;
         }
 
-        TRACFCOMP(g_trac_errl, "commitErrLog() called by %.4X for plid=0x%X, Reasoncode=%.4X", i_committerComp, io_err->plid(), io_err->reasonCode() );
+        TRACFCOMP(g_trac_errl, "commitErrLog() called by %.4X for plid=0x%X,"
+                               "Reasoncode=%.4X", i_committerComp,
+                               io_err->plid(), io_err->reasonCode() );
 
-        // lock sem
-        mutex_lock(&iv_commitMutex);
+        //Offload the error log to the errlog message queue 
+        sendErrlogToMessageQueue ( io_err, i_committerComp );
+        io_err = NULL;
+    
+   } while( 0 );
+
+   TRACDCOMP( g_trac_errl, EXIT_MRK"ErrlManager::commitErrLog" );
 
-        // Ask the ErrlEntry to assign commit component, commit time, etc.
-        io_err->commit( i_committerComp  );
+   return;
+}
 
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::saveErrLogEntry() 
+///////////////////////////////////////////////////////////////////////////////
+void ErrlManager::saveErrLogEntry( errlHndl_t& io_err )
+{
+    TRACFCOMP( g_trac_errl, ENTER_MRK"ErrlManager::saveErrLogEntry" );
+    do
+    {
         // Get flattened count of bytes.
         uint32_t l_cbActualFlat = io_err->flattenedSize();
 
@@ -165,19 +397,12 @@ void ErrlManager::commitErrLog(errlHndl_t& io_err, compId_t i_committerComp )
             pNew->length = 0;
         }
 
-
         // Count of error logs called to commit, regardless if there was
         // room to commit them or not.
         iv_pStorage->cInserted++;
 
-
-        // unlock sem
-        mutex_unlock(&iv_commitMutex);
-
-        delete io_err;
-        io_err = NULL;
-    }
-    while( 0 );
+    } while( 0 );
+    TRACFCOMP( g_trac_errl, EXIT_MRK"ErrlManager::saveErrLogEntry" );
     return;
 }
 
@@ -209,4 +434,89 @@ void errlCommit(errlHndl_t& io_err, compId_t i_committerComp )
     return;
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::sendErrlogToMessageQueue()
+///////////////////////////////////////////////////////////////////////////////
+void ErrlManager::sendErrlogToMessageQueue ( errlHndl_t& io_err, 
+                                             compId_t i_committerComp )
+{
+    msg_t  *  msg     = NULL;
+
+    TRACFCOMP( g_trac_errl, ENTER_MRK"ErrlManager::sendErrlogToMessageQueue" );
+    
+    do
+    {
+        //Create a message to send to Host boot error message queue.
+        msg = msg_allocate();
+
+        msg->type = ERRLOG_NEEDS_TO_BE_COMMITTED_TYPE;
+
+        //Pass along the component id in the message
+        msg->data[0] = i_committerComp;
+
+        //Pass along the error log handle in the message
+        msg->data[1] = 8;
+        msg->extra_data = io_err;
+
+        TRACFCOMP( g_trac_errl, INFO_MRK"Send an error log to message queue"
+                                " to commit. plid=0x%X", io_err->plid() );
+
+        //Send the error log to error message queue to handle.
+        //Message is sent as asynchronous.
+        int rc = msg_send ( iv_msgQ, msg );
+
+        //Return code is non-zero when the message queue is invalid
+        //or the message type is invalid. 
+        if ( rc )
+        {
+            TRACFCOMP( g_trac_errl, ERR_MRK "Failed to send mailbox message"
+                       "to message queue. plid=0x%X", io_err->plid() );
+            break;
+        }
+
+    } while (0);
+    TRACFCOMP( g_trac_errl, EXIT_MRK"ErrlManager::sendErrlogToMessageQueue" );
+    return;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ErrlManager::errlogShutdown()
+///////////////////////////////////////////////////////////////////////////////
+void ErrlManager::errlogShutdown(void)
+{
+    errlHndl_t l_err = NULL;
+    PNOR::SectionInfo_t l_section;
+
+    // Ensure that all the error logs are pushed out to PNOR
+    // prior to the PNOR resource provider shutting down.
+ 
+    l_err = PNOR::getSectionInfo(PNOR::HB_ERRLOGS, PNOR::CURRENT_SIDE, l_section);
+ 
+    if(l_err)
+    {
+        TRACFCOMP(g_trac_errl, ERR_MRK "Error in getting PNOR section info");
+        //We are shutting the error log manager so we can not commit
+        //error. So just log the error trace for the error.
+        delete l_err;
+        l_err = NULL;        
+    }
+    else
+    {
+        int l_rc = mm_remove_pages(FLUSH, (void *) l_section.vaddr, 
+                                                   l_section.size);
+        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");
+        }
+    }
+
+    // Un-register error log message queue from the mailbox service
+    MBOX::msgq_unregister( MBOX::HB_ERROR_MSGQ );
+
+    return;
+}
+
 } // End namespace