Call Dump Collect from call_host_mpipl_service

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

6 files changed, 419 insertions, 130 deletions

diff --git a/src/usr/dump/dumpCollect.C b/src/usr/dump/dumpCollect.C
index 1a23a9757..4af04ec71 100644
--- a/src/usr/dump/dumpCollect.C
+++ b/src/usr/dump/dumpCollect.C
@@ -34,7 +34,10 @@
 #include <runtime/runtime.H>
 #include <util/align.H>
 #include <sys/mm.h>
+#include <dump/dumpif.H>
 
+#include    <sys/msg.h>                     //  message Q's
+#include    <mbox/mbox_queues.H>            // 
 
 // Trace definition
 trace_desc_t* g_trac_dump = NULL;
@@ -45,7 +48,6 @@ namespace DUMP
 {
 
 
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -67,29 +69,29 @@ namespace DUMP
 
         do
         {
-        // Get the Data pointers to the locations we need from HDAT
-        //     MS_DUMP_SRC_TBL, < MDST: Memory Dump Source Table
-        //     MS_DUMP_DST_TBL, < MDDT: Memory Dump Destination Table
-        //     MS_DUMP_RESULTS_TBL,  <MDRT:Memory Dump Results Table
-        l_err = getHostDataPtrs(srcTableEntry, srcTableSize,
-                                destTableEntry, destTableSize,
-                                resultsTableEntry, resultsTableSize);
-
-        if (l_err)
-        {
-            TRACFCOMP(g_trac_dump, "doDumpCollect: Got an error back from getHostDataPtrs");
-            break;
-        }
+            // Get the Data pointers to the locations we need from HDAT
+            //     MS_DUMP_SRC_TBL, < MDST: Memory Dump Source Table
+            //     MS_DUMP_DST_TBL, < MDDT: Memory Dump Destination Table
+            //     MS_DUMP_RESULTS_TBL,  <MDRT:Memory Dump Results Table
+            l_err = getHostDataPtrs(srcTableEntry, srcTableSize,
+                                    destTableEntry, destTableSize,
+                                    resultsTableEntry, resultsTableSize);
 
-        l_err = copySrcToDest(srcTableEntry,srcTableSize,
-                              destTableEntry,destTableSize,
-                              resultsTableEntry,resultsTableSize);
+            if (l_err)
+            {
+                TRACFCOMP(g_trac_dump, "doDumpCollect: Got an error back from getHostDataPtrs");
+                break;
+            }
 
-        if (l_err)
-        {
-            TRACFCOMP(g_trac_dump, "doDumpCollect: Got an error back from copySrcToDest");
-            break;
-        }
+            l_err = copySrcToDest(srcTableEntry,srcTableSize,
+                                  destTableEntry,destTableSize,
+                                  resultsTableEntry,resultsTableSize);
+
+            if (l_err)
+            {
+                TRACFCOMP(g_trac_dump, "doDumpCollect: Got an error back from copySrcToDest");
+                break;
+            }
 
         }while (0);
 
@@ -97,8 +99,8 @@ namespace DUMP
     }
 
 
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////////
 
     errlHndl_t copySrcToDest(dumpEntry *srcTableEntry, uint64_t srcTableSize,
                              dumpEntry *destTableEntry, uint64_t destTableSize,
@@ -188,13 +190,13 @@ namespace DUMP
 
             vaMapSrcTableAddr =
               (static_cast<uint64_t*>(mmio_dev_map(reinterpret_cast<void*>(ALIGN_PAGE_DOWN(curSrcTableAddr)),
-                                      THIRTYTWO_GB)));
+                                                   THIRTYTWO_GB)));
 
             vaSrcTableAddr = vaMapSrcTableAddr;
 
             vaMapDestTableAddr =
               (static_cast<uint64_t*>(mmio_dev_map(reinterpret_cast<void*>(ALIGN_PAGE_DOWN(curDestTableAddr)),
-                                      THIRTYTWO_GB)));
+                                                   THIRTYTWO_GB)));
 
             vaDestTableAddr = vaMapDestTableAddr;
 
@@ -271,9 +273,9 @@ namespace DUMP
 
                     // map the MDST entry to a device such that we can read and write from that memory
                     // address
-                     vaMapSrcTableAddr =
-                       (static_cast<uint64_t*>(mmio_dev_map(reinterpret_cast<void*>(ALIGN_PAGE_DOWN(curSrcTableAddr)),
-                                                            THIRTYTWO_GB)));
+                    vaMapSrcTableAddr =
+                      (static_cast<uint64_t*>(mmio_dev_map(reinterpret_cast<void*>(ALIGN_PAGE_DOWN(curSrcTableAddr)),
+                                                           THIRTYTWO_GB)));
 
                     vaSrcTableAddr = vaMapSrcTableAddr;
 
@@ -392,7 +394,7 @@ namespace DUMP
                             //  size.. Perhaps put the bad destination entry
                             //  there as well       
                         }
-                        
+
                         break;
                     }
 
@@ -603,7 +605,7 @@ namespace DUMP
                 // Invalid size or address
                 TRACFCOMP(g_trac_dump,
                           "HBDumpGetHostData address or size invalie for MDDT: addr =0x%X, size =0x%X," ,
-                           destTableAddr, destTableSize);
+                          destTableAddr, destTableSize);
 
                 l_section = RUNTIME::MS_DUMP_DST_TBL;
                 l_addr = destTableAddr;
@@ -636,7 +638,7 @@ namespace DUMP
                 // Invalid size or address
                 TRACFCOMP(g_trac_dump,
                           "HBDumpGetHostData address or size invalid for MDRT: addr =0x%X, size =0x%X," ,
-                           resultsTableAddr, resultsTableSize);
+                          resultsTableAddr, resultsTableSize);
 
                 l_section = RUNTIME::MS_DUMP_RESULTS_TBL;
                 l_addr = resultsTableAddr;
@@ -678,4 +680,166 @@ namespace DUMP
     }
 
 
-}
+    // ------------------------------------------------------------------
+    // sendMboxMsg
+    // ------------------------------------------------------------------
+    errlHndl_t sendMboxMsg(DUMP_MSG_TYPE i_type)
+
+    {
+        errlHndl_t l_err = NULL;
+        msg_t* msg = NULL;
+        TRACFCOMP( g_trac_dump,
+                   ENTER_MRK"sendMboxMsg()" );
+
+        do
+        {
+            
+            //Create a mailbox message to send to FSP
+            msg = msg_allocate();
+            msg->type = i_type;
+
+            // If this is not a dump start message, need to collect the
+            // Results table and size as well as the results table itself.
+            if (i_type != DUMP_MSG_START_MSG_TYPE)
+            {
+                uint64_t resultsTableAddr = 0;
+                uint64_t resultsTableSize = 0;
+
+                // Get the Results Table Address
+                l_err =
+                  RUNTIME::get_host_data_section(RUNTIME::MS_DUMP_RESULTS_TBL,
+                                                 0,
+                                                 resultsTableAddr,
+                                                 resultsTableSize);
+
+
+                if (l_err)
+                {
+                    // Got an errorlog back from get_host_data_sections
+                    TRACFCOMP(g_trac_dump, "HBDumpGetHostData get_host_data_sections for MDDT failed rc=0x%X", l_err->reasonCode());
+                }
+                // If the address or size is zero - error out
+                else if ((resultsTableSize == 0) || (resultsTableAddr == 0))
+                {
+                    // Invalid size or address
+                    TRACFCOMP(g_trac_dump,
+                              "HBDumpGetHostData address or size invalid for MDRT: addr =0x%X, size =0x%X," ,
+                              resultsTableAddr, resultsTableSize);
+
+
+                    // Create an errorlog and change the type to error and add
+                    // the plid to the data section.
+
+                    /*@
+                     * @errortype
+                     * @moduleid     DUMP::DUMP_SEND_MBOX_MSG
+                     * @reasoncode   DUMP::DUMP_NO_HDAT_ADDR
+                     * @userdata1    Address returned
+                     * @userdata2    Table type Requested
+                     * @devdesc      Invalid address and size returned from HDAT
+                     */
+                    l_err =
+                      new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                              DUMP_SEND_MBOX_MSG,
+                                              DUMP_NO_HDAT_ADDR,
+                                              resultsTableAddr,
+                                              i_type);
+
+                }
+
+                // if no error then collect as expected. 
+                if (!l_err)
+                {
+
+                    // TODO:  Issue RTC 67082 - fix sending the MDRT
+                    // to FSP once we have a design that can send the
+                    // entire table.. Max size is 512K - truncating to
+                    // 32K for the time being. 
+                    uint64_t l_resultsTableSize = resultsTableSize;
+
+                    // If the results table is greater than 32K truncate it.
+                    if (resultsTableSize > (32*KILOBYTE))
+                    {
+                        // Set the results table size to only include up to
+                        // 32K
+                        l_resultsTableSize = (32*KILOBYTE);
+
+                        TRACFCOMP( g_trac_dump,
+                                   INFO_MRK"Truncating the RESULTS table to 32K for dump msg type =. %.8X,",
+                                   i_type);
+
+                    }
+
+                    // TODO:  RTC 67082 - Need to make sure we put the physical
+                    // Address here.
+
+                    // Address of the results table
+                    msg->data[0] = resultsTableAddr;
+
+                    // Number of bytes in the results table
+                    msg->data[1] = l_resultsTableSize;
+
+                    //Copy the Results table into the message
+                    msg->extra_data = malloc( l_resultsTableSize );
+
+                    memcpy( msg->extra_data,
+                            reinterpret_cast<uint64_t*>(resultsTableAddr),
+                            l_resultsTableSize);
+
+
+                }
+                else
+                {
+                    TRACFCOMP( g_trac_dump,
+                               INFO_MRK"Got an error trying to send msg. %.8X,",
+                               i_type);
+
+                    // change the msg type to be error type
+                    i_type = DUMP_MSG_ERROR_MSG_TYPE;
+
+                    l_err->collectTrace("DUMP",1024);
+
+                    // Put a default value into the data[0] indicating plid to in data[1]
+                    msg->data[0] = 0xFFFF;
+
+                    msg->data[1] = l_err->plid(); // plid
+
+                    // just commit the log from failure on Read.. and
+                    // send an error msg to FSP.          
+                    errlCommit( l_err, DUMP_COMP_ID );
+                    l_err = NULL;
+
+                }
+            }
+
+
+            TRACFCOMP( g_trac_dump,
+                       INFO_MRK"Send msg to FSP about DUMP %.8X,",
+                       i_type);
+
+            // Send the message
+            l_err = MBOX::send( MBOX::FSP_DUMP_MSGQ_ID, msg );
+
+            // got an error.. Free the msg space allocated above.
+            if( l_err )
+            {
+                TRACFCOMP(g_trac_dump,
+                          ERR_MRK "Failed sending DUMP to FSP for %.8X",i_type);
+
+                l_err->collectTrace("DUMP",1024);
+
+                free( msg->extra_data );
+                msg->extra_data = NULL;
+                msg_free( msg );
+            }
+        } while( 0 );
+
+
+        TRACFCOMP( g_trac_dump,
+                   EXIT_MRK"sendMboxMsg()" );
+
+        return l_err;
+    }
+
+
+}; // end of namespace
diff --git a/src/usr/dump/dumpCollect.H b/src/usr/dump/dumpCollect.H
index 282a13886..3272c401d 100644
--- a/src/usr/dump/dumpCollect.H
+++ b/src/usr/dump/dumpCollect.H
@@ -24,65 +24,15 @@
 #define __DUMPCOLLECT_H
 
 #include <errl/errlentry.H>
-
+#include <dump/dumpif.H>
 /** @file  dumpCollect.H
- *  @brief Provides the interfaces to copy dump data from src to destination
+ *  @brief Provides the interfaces to get the host data pointers for the
+ *        dump tables.
  */
 
 namespace DUMP
 {
 
-    //These structures are defined in the HDAT spec
-    //The MDST and MDDT have this format.
-    struct dumpEntry
-    {
-        uint64_t dataAddr;
-        uint64_t dataSize;
-    };
-
-    
-    //The MDRT has this format.
-    struct resultsEntry
-    {
-        uint64_t srcAddr;
-        uint64_t destAddr;
-        uint64_t dataSize;
-    };
-
-
-    /**
-     * @brief This function is a wrapper function that calls
-     *   getHostDataPtrs to get the MDDT, MDST, MDRT pointers
-     *   and then passes those values to the copySrcToDest
-     *   routine that performs the copy
-     *
-     * @param[in]   void
-     *
-     * @return  errlHndl_t
-     */                    
-     errlHndl_t doDumpCollect(void);
-
-     /**
-      * @brief This function copies the data and sizes retrieved from the
-      * MDST(source table) to the addresses indicated by the MDDT(destination
-      * table).   Each write is then logged in the MDRT (results table) with
-      * source addr, destination addr and size
-      *
-      * @param[in]   srcTableEntry     Ptr to the first MDST entry                           
-      * @param[in]   srcTableSize      Size of the entire MDST
-      *
-      * @param[in]   destTableAddr     Ptr to the first MDDT entry                     
-      * @param[in]   destTableSize     Size of the entire MDDT
-      *
-      * @param[in]   resultsTableAddr  Ptr to the first MDRT entry                           
-      * @param[in]   resultsTableSize  Size of the entire MDRT
-      *
-      * @return  errlHndl_t
-      */
-     errlHndl_t copySrcToDest(dumpEntry *srcTableEntry, uint64_t srcTableSize,
-                              dumpEntry *destTableEntry, uint64_t destTableSize,
-                              resultsEntry *resultsTableEntry, uint64_t resultsTableSize);
-
      /**
       * @brief This routine retrieves first entry of the MDST, MDDT and
       *      MDRT and the size of each of those tables.
@@ -103,7 +53,7 @@ namespace DUMP
                                 resultsEntry *resultsTableEntry,uint64_t &resultsTableSize);
 
 
-}
+}; // end of namespace
 
 
 #endif
diff --git a/src/usr/dump/test/dumptest.H b/src/usr/dump/test/dumptest.H
index a0fa852d1..7b9d16385 100644
--- a/src/usr/dump/test/dumptest.H
+++ b/src/usr/dump/test/dumptest.H
@@ -35,13 +35,12 @@
 #include <errl/errlentry.H>
 #include <devicefw/userif.H>
 #include <targeting/common/util.H>
-#include "../dumpCollect.H"
 #include <runtime/runtime.H>
-#include <usr/vmmconst.h>
 #include <sys/mmio.h>
 #include <util/align.H>
 #include <sys/mm.h>
-
+#include <dump/dumpif.H>
+#include <vfs/vfs.H>
 
 extern trace_desc_t* g_trac_dump;
 
@@ -49,6 +48,35 @@ class DumpTest: public CxxTest::TestSuite
 {
   public:
 
+    // Load the dump module as it is loaded on demand
+    DumpTest(): CxxTest::TestSuite()
+    {
+        errlHndl_t l_err = VFS::module_load( "libdump.so" );
+
+        if (l_err)
+        {
+            TRACFCOMP(g_trac_dump, "DumpTest:DumpTest> got an error back from moduleLoad : RC=%X",l_err->reasonCode() );
+            TS_FAIL( "DumpTest::DumpTest ERROR : Unexpected error log from moduleLoad" );
+            errlCommit(l_err,DUMP_COMP_ID);
+
+        }
+    };
+
+     // unload the dump module
+    ~DumpTest()
+    {
+        // Need to unload the dump module regardless of whether we have
+        // an error or not.
+        errlHndl_t l_err = VFS::module_unload( "libdump.so" );
+
+        if (l_err)
+        {
+            TRACFCOMP(g_trac_dump, "DumpTest:~DumpTest> got an error back from moduleUnLoad : RC=%X",l_err->reasonCode() );
+            TS_FAIL( "DumpTest::DumpTest ERROR : Unexpected error log from moduleUnLoad" );
+            errlCommit(l_err,DUMP_COMP_ID);
+
+        }
+    };
 
     /**
      * @brief Basic dump test that has sequential src addresses to
@@ -1041,7 +1069,7 @@ class DumpTest: public CxxTest::TestSuite
             TRACFCOMP(g_trac_dump, "DumpTest::DumpCollectUnevenSRC:1 : Results Data mismatch rc = %d", result_rc);
             TS_FAIL( "DumpTest::DumpCollectUnevenSrc ERROR : Unexpected error data mismatch in results table" );
         }
-
+        
 
         TRACFCOMP( g_trac_dump, "dumpTest::test_dumpCollectUnevenSrc COMPLETE" );
     }
@@ -1049,7 +1077,9 @@ class DumpTest: public CxxTest::TestSuite
 
     /**
      * @brief Basic dump test that forces an error condition that does not have
-     *     enough destination space to hold the src size
+     *     enough destination space to hold the src size.
+     *     This testcase also verifies that we can send a mbox message with
+     *     dump status to the FSP. 
      *
      */
 
@@ -1164,23 +1194,42 @@ class DumpTest: public CxxTest::TestSuite
             index+=2;
         }
 
+        l_err = DUMP::sendMboxMsg(DUMP::DUMP_MSG_START_MSG_TYPE);
+        // On the end message queue we need to add the results talble..
+        if (l_err)
+        {
+            TRACFCOMP(g_trac_dump,
+                      "DumpTest::DumpCollectNotEnoughDest ERROR : Got an errorlog back from sendMboxMsg-start");
+            TS_FAIL(
+                    "DumpTest::DumpCollectNotEnoughDest ERROR : Got an errorlog back from sendMboxMsg-start" );
+            errlCommit(l_err,DUMP_COMP_ID);
+        }
 
         srcTableEntry = reinterpret_cast<DUMP::dumpEntry *>(srcTableAddr);
         destTableEntry = reinterpret_cast<DUMP::dumpEntry *>(dstTableAddr);
         resultsTableEntry = reinterpret_cast<DUMP::resultsEntry *>(resultsTableAddr);
 
-
         l_err = DUMP::copySrcToDest(srcTableEntry,srcTableSize,
                                     destTableEntry,dstTableSize,
                                     resultsTableEntry,resultsTableSize);
 
-
         // this testcase expects an error returned.
         if( l_err )
         {
+
             TRACFCOMP(g_trac_dump,
                       "DumpTest::DumpCollectNotEnoughDest got an EXPECTED error back from copySrcToDest : RC=%X",l_err->reasonCode() );
             delete l_err;
+
+            // Send an Error mbox msg to FSP that we got an error
+            l_err = DUMP::sendMboxMsg(DUMP::DUMP_MSG_ERROR_MSG_TYPE);
+
+            if (l_err)
+            {
+                TRACFCOMP(g_trac_dump,
+                          "DumpTest::DumpCollectNotEnoughDest ERROR : Got an errorlog back from sendMboxMsg-error");
+                TS_FAIL( "DumpTest::DumpCollectNotEnoughDest ERROR : Got an errorlog back from sendMboxMsg-error" );
+            }
         }
         else
         {
@@ -1190,6 +1239,21 @@ class DumpTest: public CxxTest::TestSuite
         }
 
 
+        // This call is just to verify we can call MSG_END .. even though with
+        // this flow we already sent a msg ERROR.
+                          
+      
+        // Successful so send mbox message indicating the dump is complete and successful
+        l_err = DUMP::sendMboxMsg(DUMP::DUMP_MSG_END_MSG_TYPE);
+
+        if (l_err)
+        {
+            TRACFCOMP(g_trac_dump,
+                      "DumpTest::DumpCollectNotEnoughDest ERROR : Got an errorlog back from sendMboxMsg-END");
+            TS_FAIL( "DumpTest::DumpCollectNotEnoughDest ERROR : Got an errorlog back from sendMboxMsg-END" );
+        }
+   
+
         TRACFCOMP( g_trac_dump, "dumpTest::test_dumpCollectNotEnoughDest COMPLETE" );
 
     }
diff --git a/src/usr/hwpf/hwp/dram_initialization/dram_initialization.C b/src/usr/hwpf/hwp/dram_initialization/dram_initialization.C
index 3ae989ddc..c0eae1734 100644
--- a/src/usr/hwpf/hwp/dram_initialization/dram_initialization.C
+++ b/src/usr/hwpf/hwp/dram_initialization/dram_initialization.C
@@ -75,7 +75,8 @@
 #include <vpd/spdenums.H>
 #include <sys/time.h>
 #include <sys/mm.h>
-
+#include <dump/dumpif.H>
+#include <vfs/vfs.H>
 
 namespace   DRAM_INITIALIZATION
 {
@@ -706,39 +707,46 @@ void*    call_proc_exit_cache_contained( void    *io_pArgs )
                   "ERROR : call_proc_exit_cache_contained, errorlog PLID=0x%x",
                   l_errl->plid() );
     }
+    // no errors so extend VMM.
     else
     {
         TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                    "SUCCESS : call_proc_exit_cache_contained" );
-    }
 
 
-    // Call the function to extend VMM to 32MEG
-    int rc = mm_extend();
 
-    if (rc!=0)
-    {
-        /*@
-         * @errortype
-         * @moduleid     fapi::MOD_EXIT_CACHE_CONTAINED
-         * @reasoncode   fapi::RC_MM_EXTEND_FAILED
-         * @userdata1    rc from mm_extend
-         * @userdata2    <UNUSED>
-         *
-         *   @devdesc  Failure extending memory to 32MEG after
-         *        exiting cache contained mode.
-         */
-        l_errl = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
-                                         fapi::MOD_EXIT_CACHE_CONTAINED,
-                                         fapi::RC_MM_EXTEND_FAILED,
-                                         rc,
-                                         0);
+        // Call the function to extend VMM to 32MEG
+        int rc = mm_extend();
 
-        TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-                  "ERROR : call_proc_exit_cache_contained - extendVMM, rc=0x%x",
-                  rc );
-    }
+        if (rc!=0)
+        {
+            /*@
+             * @errortype
+             * @moduleid     fapi::MOD_EXIT_CACHE_CONTAINED
+             * @reasoncode   fapi::RC_MM_EXTEND_FAILED
+             * @userdata1    rc from mm_extend
+             * @userdata2    <UNUSED>
+             *
+             *   @devdesc  Failure extending memory to 32MEG after
+             *        exiting cache contained mode.
+             */
+            l_errl = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                             fapi::MOD_EXIT_CACHE_CONTAINED,
+                                             fapi::RC_MM_EXTEND_FAILED,
+                                             rc,
+                                             0);
 
+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                      "ERROR : call_proc_exit_cache_contained - extendVMM, rc=0x%x",
+                      rc );
+        }
+        else
+        {
+           // trace out the extend VMM was successful
+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                      "SUCCESS : call_proc_exit_cache_contained - extendVMM");
+        }
+    }
     if ( l_errl )
     {
         /*@
@@ -845,6 +853,117 @@ void*   call_host_mpipl_service( void *io_pArgs )
         }
     }
 
+    // No error on the procedure.. proceed to collect the dump.
+    if (!l_err)
+    {
+
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                   "SUCCESS : proc_mpipl_ex_cleanup" );
+
+
+        // currently according to Adriana, the dump calls should only cause an
+        // istep failure when the dump collect portion of this step fails..  We
+        // will not fail the istep on any mbox message failures. instead we will
+        // simply commit the errorlog and continue.
+   
+        errlHndl_t l_errMsg = NULL;
+
+        // Need to load the dump module
+        l_err = VFS::module_load( "libdump.so" );
+
+        // If dump module successfull loaded then continue with DumpCollect and
+        // messaging
+        if (!l_err)
+        {
+            do
+            {
+                // send the start message
+                l_errMsg = DUMP::sendMboxMsg(DUMP::DUMP_MSG_START_MSG_TYPE);
+
+                // If error, commit and send error message.
+                if (l_errMsg)
+                {
+                    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                              "ERROR : returned from DUMP::sendMboxMsg - dump start" );
+
+                    errlCommit( l_errMsg, HWPF_COMP_ID );
+
+                    // don't break in this case because we not want to fail the
+                    // istep on the dump collect so we will continue after we
+                    // log the errhandle that we can't send a message.
+                }
+
+                // Call the dump collect
+                l_err = DUMP::doDumpCollect();
+
+                // Got a Dump Collect error.. Commit the dumpCollect
+                // errorlog and then send an dump Error mbox message
+                // and FSP will decide what to do.
+                // We do not want dump Collect failures to terminate the istep.
+                if (l_err)
+                {
+                    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                              "ERROR : returned from DUMP::HbDumpCopySrcToDest" );
+
+                    break;
+                }
+
+            } while(0);
+
+            DUMP::DUMP_MSG_TYPE msgType = DUMP::DUMP_MSG_END_MSG_TYPE;
+
+            // Send dumpCollect success trace
+            if (!l_err)
+            {
+                TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                           "SUCCESS : doDumpCollect" );
+            }
+            // got an error that we need to send a ERROR message to FSP
+            // and commit the errorlog from dumpCollect.
+            else
+            {
+                msgType = DUMP::DUMP_MSG_ERROR_MSG_TYPE;
+
+                // Commit the dumpCollect errorlog from above as
+                // we dont want dump collect to kill the istep
+                errlCommit( l_err, HWPF_COMP_ID );
+
+            }
+
+            // Send an Error mbox msg to FSP (either end or error)
+            l_errMsg = DUMP::sendMboxMsg(msgType);
+
+            if (l_errMsg)
+            {
+                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                          "ERROR : returned from DUMP::sendMboxMsg" );
+
+                errlCommit( l_errMsg, HWPF_COMP_ID );
+            }
+
+
+            // Need to unload the dump module regardless of whether we have
+            // an error or not.
+            errlHndl_t l_errUnLoad = VFS::module_unload( "libdump.so" );
+
+            if (l_errUnLoad)
+            {
+                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                          "ERROR : returned from VFS::module_unload (libdump.so)" );
+
+                errlCommit( l_errUnLoad, HWPF_COMP_ID );
+            }
+
+        }
+        else
+        {
+            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                      "ERROR : returned from VFS::module_load (libdump.so)" );
+        }    
+
+    }
+
+    // If got an error in the procedure or collection of the dump kill the istep
     if( l_err )
     {
 
@@ -871,6 +990,8 @@ void*   call_host_mpipl_service( void *io_pArgs )
         errlCommit( l_err, HWPF_COMP_ID );
     }
 
+
+
     TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "call_host_mpipl_service exit" );
 
diff --git a/src/usr/initservice/extinitsvc/extinitsvctasks.H b/src/usr/initservice/extinitsvc/extinitsvctasks.H
index 7edd7b724..2701c9d0e 100644
--- a/src/usr/initservice/extinitsvc/extinitsvctasks.H
+++ b/src/usr/initservice/extinitsvc/extinitsvctasks.H
@@ -304,17 +304,6 @@ const TaskInfo g_exttaskinfolist[]   =   {
             }
         },
 
-        /**
-         * @brief dump code library
-         */
-        {
-            "libdump.so" ,                        // taskname
-            NULL,                                 // no pointer to fn
-            {
-               INIT_TASK,                         // task type
-               EXT_IMAGE,                         // Extended Module
-            }
-        },
 
 
 // end TODO.
diff --git a/src/usr/runtime/hdatservice.C b/src/usr/runtime/hdatservice.C
index 4ad6325f6..e67abc3f3 100644
--- a/src/usr/runtime/hdatservice.C
+++ b/src/usr/runtime/hdatservice.C
@@ -31,6 +31,7 @@
 #include <util/align.H>
 #include "hdatstructs.H"
 #include "fakepayload.H"
+#include <dump/dumpif.H>
 
 extern trace_desc_t* g_trac_runtime;