Changeset 31860 in vbox for trunk/src

Timestamp:

Aug 23, 2010 1:56:17 PM (14 years ago)

Author:

vboxsync

Message:

RTCoreDumper: integration into IPRT, cleanup.

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• r3/solaris/coredumper-solaris.cpp (modified) (93 diffs)
• r3/solaris/coredumper-solaris.h (modified) (6 diffs)
• testcase/tstRTCoreDump.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -759 +759 @@
         r3/solaris/alloc-solaris.cpp \
         r3/solaris/mp-solaris.cpp \
+        r3/solaris/coredumper-solaris.cpp \
         r3/solaris/rtProcInitExePath-solaris.cpp
 RuntimeR3_SOURCES.solaris.amd64 = \

trunk/src/VBox/Runtime/r3/solaris/coredumper-solaris.cpp

@@ -28 +28 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#define LOG_GROUP LOG_GROUP_CORE_DUMPER
+#include <VBox/log.h>
+#include <iprt/coredumper.h>
 #include <iprt/types.h>
 #include <iprt/file.h>
@@ -34 +37 @@
 #include <iprt/path.h>
 #include <iprt/string.h>
-#include <iprt/stream.h>
-#include <iprt/initterm.h>
 #include <iprt/thread.h>
 #include <iprt/param.h>
 #include <iprt/asm.h>
-#include "tstRTCoreDump.h"
+#include "coredumper-solaris.h"
 
 #ifdef RT_OS_SOLARIS
+# include <syslog.h>
 # include <signal.h>
 # include <unistd.h>
@@ -53 +55 @@
 
 /*******************************************************************************
+*   Globals                                                                    *
+*******************************************************************************/
+volatile static uint64_t   g_CoreDumpThread = NIL_RTTHREAD;
+volatile static bool       g_fCoreDumpSignalSetup = false;
+volatile static bool       g_fCoreDumpDeliberate = false;
+volatile static bool       g_fCoreDumpInProgress = false;
+volatile static uint32_t   g_fCoreDumpFlags = 0;
+static char                g_szCoreDumpDir[PATH_MAX] = { 0 };
+static char                g_szCoreDumpFile[PATH_MAX] = { 0 };
+
+
+/*******************************************************************************
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-#define CORELOG(a)          RTPrintf a
-#define CORELOGREL(a)       RTPrintf a
-
-/**
- * VBOXSOLCORETYPE: Whether this is an old or new style core.
- */
-typedef enum VBOXSOLCORETYPE
-{
-    enmOldEra       = 0x01d,        /* old */
-    enmNewEra       = 0x5c151       /* sci-fi */
-} VBOXSOLCORETYPE;
-
-static unsigned volatile g_cErrors = 0;
-
-volatile bool g_fCoreDumpInProgress = false;
+#define CORELOG_NAME        "CoreDumper: "
+#define CORELOG(a)          Log(a)
+#define CORELOGRELSYS(a)       \
+    do { \
+        LogRel(a); \
+        rtCoreDumperSysLogWrapper a; \
+    } while (0)
+
+
+/** 
+ * Wrapper function to write IPRT format style string to the syslog. 
+ * 
+ * @param pszFormat         Format string 
+ */
+static void rtCoreDumperSysLogWrapper(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    char szBuf[1024];
+    RTStrPrintfV(szBuf, sizeof(szBuf), pszFormat, va);
+    va_end(va);
+    syslog(LOG_ERR, "%s", szBuf);
+}
 
 
@@ -143 +165 @@
  * @return VINF_SUCCESS, if all the given bytes was read in, otherwise VERR_READ_ERROR.
  */
-static ssize_t ReadProcAddrSpace(PVBOXPROCESS pVBoxProc, RTFOFF off, void *pvBuf, size_t cbToRead)
+static ssize_t ProcReadAddrSpace(PVBOXPROCESS pVBoxProc, RTFOFF off, void *pvBuf, size_t cbToRead)
 {
     while (1)
@@ -162 +184 @@
  * @return true if the architecture matches the current one.
  */
-inline bool IsProcArchNative(PVBOXPROCESS pVBoxProc)
+static inline bool IsProcessArchNative(PVBOXPROCESS pVBoxProc)
 {
     return pVBoxProc->ProcInfo.pr_dmodel == PR_MODEL_NATIVE;
@@ -175 +197 @@
  * @return The size of the file in bytes.
  */
-size_t GetFileSize(const char *pszPath)
+static size_t GetFileSize(const char *pszPath)
 {
     size_t cb = 0;
@@ -186 +208 @@
     }
     else
-        CORELOGREL(("GetFileSize failed to open %s rc=%Rrc\n", pszPath, rc));
+        CORELOGRELSYS((CORELOG_NAME "GetFileSize failed to open %s rc=%Rrc\n", pszPath, rc));
     return cb;
 }
@@ -200 +222 @@
  * @return VBox status code.
  */
-int AllocMemoryArea(PVBOXCORE pVBoxCore)
+static int AllocMemoryArea(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore->pvCore == NULL, VERR_ALREADY_EXISTS);
@@ -249 +271 @@
     if (pv)
     {
-        CORELOG(("AllocMemoryArea: memory area of %u bytes allocated.\n", cb));
+        CORELOG((CORELOG_NAME "AllocMemoryArea: memory area of %u bytes allocated.\n", cb));
         pVBoxCore->pvCore = pv;
         pVBoxCore->pvFree = pv;
@@ -257 +279 @@
     else
     {
-        CORELOGREL(("AllocMemoryArea: failed cb=%u\n", cb));
+        CORELOGRELSYS((CORELOG_NAME "AllocMemoryArea: failed cb=%u\n", cb));
         return VERR_NO_MEMORY;
     }
@@ -268 +290 @@
  * @param pVBoxCore         Pointer to the core object.
  */
-void FreeMemoryArea(PVBOXCORE pVBoxCore)
+static void FreeMemoryArea(PVBOXCORE pVBoxCore)
 {
     AssertReturnVoid(pVBoxCore);
@@ -275 +297 @@
 
     munmap(pVBoxCore->pvCore, pVBoxCore->cbCore);
-    CORELOG(("FreeMemoryArea: memory area of %u bytes freed.\n", pVBoxCore->cbCore));
+    CORELOG((CORELOG_NAME "FreeMemoryArea: memory area of %u bytes freed.\n", pVBoxCore->cbCore));
 
     pVBoxCore->pvCore = NULL;
@@ -291 +313 @@
  * @return Pointer to allocated memory, or NULL on failure.
  */
-void *GetMemoryChunk(PVBOXCORE pVBoxCore, size_t cb)
+static void *GetMemoryChunk(PVBOXCORE pVBoxCore, size_t cb)
 {
     AssertReturn(pVBoxCore, NULL);
@@ -319 +341 @@
  * @return VBox status code.
  */
-int ProcReadFileInto(PVBOXCORE pVBoxCore, const char *pszProcFileName, void **ppv, size_t *pcb)
+static int ProcReadFileInto(PVBOXCORE pVBoxCore, const char *pszProcFileName, void **ppv, size_t *pcb)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -346 +368 @@
     }
     else
-        CORELOGREL(("ProcReadFileInto: failed to open %s. rc=%Rrc\n", szPath, rc));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadFileInto: failed to open %s. rc=%Rrc\n", szPath, rc));
     return rc;
 }
@@ -358 +380 @@
  * @return VBox status code.
  */
-int ReadProcInfo(PVBOXCORE pVBoxCore)
+static int ProcReadInfo(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -386 +408 @@
  * @return VBox status code.
  */
-int ReadProcStatus(PVBOXCORE pVBoxCore)
+static int ProcReadStatus(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -417 +439 @@
  * @return VBox status code.
  */
-int ReadProcCred(PVBOXCORE pVBoxCore)
+static int ProcReadCred(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -434 +456 @@
  * @return VBox status code.
  */
-int ReadProcPriv(PVBOXCORE pVBoxCore)
+static int ProcReadPriv(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -445 +467 @@
     if (!pVBoxProc->pcPrivImpl)
     {
-        CORELOGREL(("ReadProcPriv: getprivimplinfo returned NULL.\n"));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadPriv: getprivimplinfo returned NULL.\n"));
         return VERR_INVALID_STATE;
     }
@@ -460 +482 @@
  * @return VBox status code.
  */
-int ReadProcLdt(PVBOXCORE pVBoxCore)
+static int ProcReadLdt(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -477 +499 @@
  * @return VBox status code.
  */
-int ReadProcAuxVecs(PVBOXCORE pVBoxCore)
+static int ProcReadAuxVecs(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -488 +510 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("ReadProcAuxVecs: RTFileOpen %s failed rc=%Rrc\n", szPath, rc));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: RTFileOpen %s failed rc=%Rrc\n", szPath, rc));
         return rc;
     }
@@ -504 +526 @@
                 /* Terminate list of vectors */
                 pVBoxProc->cAuxVecs = cbAuxFile / sizeof(auxv_t);
-                CORELOG(("ReadProcAuxVecs: cbAuxFile=%u auxv_t size %d cAuxVecs=%u\n", cbAuxFile, sizeof(auxv_t), pVBoxProc->cAuxVecs));
+                CORELOG((CORELOG_NAME "ProcReadAuxVecs: cbAuxFile=%u auxv_t size %d cAuxVecs=%u\n", cbAuxFile, sizeof(auxv_t), pVBoxProc->cAuxVecs));
                 if (pVBoxProc->cAuxVecs > 0)
                 {
@@ -514 +536 @@
                 else
                 {
-                    CORELOGREL(("ReadProcAuxVecs: Invalid vector count %u\n", pVBoxProc->cAuxVecs));
+                    CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: Invalid vector count %u\n", pVBoxProc->cAuxVecs));
                     rc = VERR_READ_ERROR;
                 }
             }
             else
-                CORELOGREL(("ReadProcAuxVecs: ReadFileNoIntr failed. rc=%Rrc cbAuxFile=%u\n", rc, cbAuxFile));
+                CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: ReadFileNoIntr failed. rc=%Rrc cbAuxFile=%u\n", rc, cbAuxFile));
 
             pVBoxProc->pAuxVecs = NULL;
@@ -526 +548 @@
         else
         {
-            CORELOGREL(("ReadProcAuxVecs: no memory for %u bytes\n", cbAuxFile + sizeof(auxv_t)));
+            CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: no memory for %u bytes\n", cbAuxFile + sizeof(auxv_t)));
             rc = VERR_NO_MEMORY;
         }
     }
     else
-        CORELOGREL(("ReadProcAuxVecs: aux file too small %u, expecting %u or more\n", cbAuxFile, sizeof(auxv_t)));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadAuxVecs: aux file too small %u, expecting %u or more\n", cbAuxFile, sizeof(auxv_t)));
 
     RTFileClose(hFile);
@@ -541 +563 @@
  * Find an element in the process' auxiliary vector.
  */
-long GetAuxVal(PVBOXPROCESS pVBoxProc, int Type)
+static long GetAuxVal(PVBOXPROCESS pVBoxProc, int Type)
 {
     AssertReturn(pVBoxProc, -1);
@@ -565 +587 @@
  * @return VBox status code.
  */
-int ReadProcMappings(PVBOXCORE pVBoxCore)
+static int ProcReadMappings(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -625 +647 @@
                                 {
                                     size_t cb = RT_MIN(sizeof(achBuf), pCur->pMap.pr_size - k);
-                                    int rc2 = ReadProcAddrSpace(pVBoxProc, pCur->pMap.pr_vaddr + k, &achBuf, cb);
+                                    int rc2 = ProcReadAddrSpace(pVBoxProc, pCur->pMap.pr_vaddr + k, &achBuf, cb);
                                     if (RT_FAILURE(rc2))
                                     {
-                                        CORELOGREL(("ReadProcMappings: skipping mapping. vaddr=%#x rc=%Rrc\n", pCur->pMap.pr_vaddr, rc2));
+                                        CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: skipping mapping. vaddr=%#x rc=%Rrc\n", pCur->pMap.pr_vaddr, rc2));
 
                                         /*
@@ -652 +674 @@
                             RTFileClose(pVBoxProc->hAs);
                             pVBoxProc->hAs = NIL_RTFILE;
-                            CORELOG(("ReadProcMappings: successfully read in %u mappings\n", pVBoxProc->cMappings));
+                            CORELOG((CORELOG_NAME "ProcReadMappings: successfully read in %u mappings\n", pVBoxProc->cMappings));
                             return VINF_SUCCESS;
                         }
                         else
                         {
-                            CORELOGREL(("ReadProcMappings: GetMemoryChunk failed %u\n", pVBoxProc->cMappings * sizeof(VBOXSOLMAPINFO)));
+                            CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: GetMemoryChunk failed %u\n", pVBoxProc->cMappings * sizeof(VBOXSOLMAPINFO)));
                             rc = VERR_NO_MEMORY;
                         }
@@ -663 +685 @@
                     else
                     {
-                        CORELOGREL(("ReadProcMappings: Invalid mapping count %u\n", pVBoxProc->cMappings));
+                        CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: Invalid mapping count %u\n", pVBoxProc->cMappings));
                         rc = VERR_READ_ERROR;
                     }
                 }
                 else
-                    CORELOGREL(("ReadProcMappings: FileReadNoIntr failed. rc=%Rrc cbMapFile=%u\n", rc, cbMapFile));
+                    CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: FileReadNoIntr failed. rc=%Rrc cbMapFile=%u\n", rc, cbMapFile));
             }
             else
             {
-                CORELOGREL(("ReadProcMappings: GetMemoryChunk failed. cbMapFile=%u\n", cbMapFile));
+                CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: GetMemoryChunk failed. cbMapFile=%u\n", cbMapFile));
                 rc = VERR_NO_MEMORY;
             }
@@ -681 +703 @@
     }
     else
-        CORELOGREL(("ReadProcMappings: failed to open %s. rc=%Rrc\n", szPath, rc));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadMappings: failed to open %s. rc=%Rrc\n", szPath, rc));
 
     RTFileClose(hFile);
@@ -696 +718 @@
  * @return VBox status code.
  */
-int ReadProcThreads(PVBOXCORE pVBoxCore)
+static int ProcReadThreads(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -728 +750 @@
             uint64_t cInfo         = pInfoHdr->pr_nent;
 
-            CORELOG(("ReadProcThreads: read info(%u) status(%u), threads:cInfo=%u cStatus=%u\n", cbInfoHdrAndData, cbStatusHdrAndData, cInfo, cStatus));
+            CORELOG((CORELOG_NAME "ProcReadThreads: read info(%u) status(%u), threads:cInfo=%u cStatus=%u\n", cbInfoHdrAndData,
+                        cbStatusHdrAndData, cInfo, cStatus));
 
             /*
@@ -747 +770 @@
                             || pStatus->pr_lwpid != pInfo->pr_lwpid)
                         {
-                            CORELOGREL(("ReadProcThreads: cStatus = %u pStatuslwpid=%d infolwpid=%d\n", cStatus, pStatus->pr_lwpid, pInfo->pr_lwpid));
+                            CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: cStatus = %u pStatuslwpid=%d infolwpid=%d\n", cStatus,
+                                        pStatus->pr_lwpid, pInfo->pr_lwpid));
                             rc = VERR_INVALID_STATE;
                             break;
@@ -796 +820 @@
                                     pStatus->pr_ustack = (uintptr_t)&pVBoxProc->pCurThreadCtx->uc_stack;
 
-                                    CORELOG(("ReadProcThreads: patched dumper thread context with pre-dump time context.\n"));
+                                    CORELOG((CORELOG_NAME "ProcReadThreads: patched dumper thread context with pre-dump time context.\n"));
                                 }
 
@@ -804 +828 @@
                             else
                             {
-                                CORELOGREL(("ReadProcThreads: missing status for lwp %d\n", pInfo->pr_lwpid));
+                                CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: missing status for lwp %d\n", pInfo->pr_lwpid));
                                 pCur->pStatus = NULL;
                             }
@@ -816 +840 @@
                             pPrev->pNext = NULL;
 
-                        CORELOG(("ReadProcThreads: successfully read %u threads.\n", cInfo));
+                        CORELOG((CORELOG_NAME "ProcReadThreads: successfully read %u threads.\n", cInfo));
                         pVBoxProc->cThreads = cInfo;
                         return VINF_SUCCESS;
@@ -822 +846 @@
                     else
                     {
-                        CORELOGREL(("ReadProcThreads: GetMemoryChunk failed for %u bytes\n", cbThreadInfo));
+                        CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: GetMemoryChunk failed for %u bytes\n", cbThreadInfo));
                         rc = VERR_NO_MEMORY;
                     }
                 }
                 else
-                    CORELOGREL(("ReadProcThreads: Invalid state information for threads.\n", rc));
+                    CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: Invalid state information for threads.\n", rc));
             }
             else
             {
-                CORELOGREL(("ReadProcThreads: huh!? cbStatusHdrAndData=%u prheader_t=%u entsize=%u\n", cbStatusHdrAndData,
+                CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: huh!? cbStatusHdrAndData=%u prheader_t=%u entsize=%u\n", cbStatusHdrAndData,
                             sizeof(prheader_t), pStatusHdr->pr_entsize));
-                CORELOGREL(("ReadProcThreads: huh!? cbInfoHdrAndData=%u entsize=%u\n", cbInfoHdrAndData, pStatusHdr->pr_entsize));
+                CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: huh!? cbInfoHdrAndData=%u entsize=%u\n", cbInfoHdrAndData, pStatusHdr->pr_entsize));
                 rc = VERR_INVALID_STATE;
             }
         }
         else
-            CORELOGREL(("ReadProcThreads: ReadFileNoIntr failed for \"lpsinfo\" rc=%Rrc\n", rc));
+            CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: ReadFileNoIntr failed for \"lpsinfo\" rc=%Rrc\n", rc));
     }
     else
-        CORELOGREL(("ReadProcThreads: ReadFileNoIntr failed for \"lstatus\" rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadThreads: ReadFileNoIntr failed for \"lstatus\" rc=%Rrc\n", rc));
     return rc;
 }
@@ -854 +878 @@
  * @return VBox status code.
  */
-int ReadProcMiscInfo(PVBOXCORE pVBoxCore)
+static int ProcReadMiscInfo(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -867 +891 @@
     if (rc == -1)
     {
-        CORELOGREL(("ReadProcMiscInfo: sysinfo failed. rc=%d errno=%d\n", rc, errno));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: sysinfo failed. rc=%d errno=%d\n", rc, errno));
         return VERR_GENERAL_FAILURE;
     }
@@ -875 +899 @@
     if (rc == -1)
     {
-        CORELOGREL(("ReadProcMiscInfo: uname failed. rc=%d errno=%d\n", rc, errno));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: uname failed. rc=%d errno=%d\n", rc, errno));
         return VERR_GENERAL_FAILURE;
     }
@@ -882 +906 @@
     if (rc < 0)
     {
-        CORELOGREL(("ReadProcMiscInfo: getzonenamebyid failed. rc=%d errno=%d zoneid=%d\n", rc, errno, pVBoxProc->ProcInfo.pr_zoneid));
+        CORELOGRELSYS((CORELOG_NAME "ProcReadMiscInfo: getzonenamebyid failed. rc=%d errno=%d zoneid=%d\n", rc, errno, pVBoxProc->ProcInfo.pr_zoneid));
         return VERR_GENERAL_FAILURE;
     }
@@ -902 +926 @@
  * @param pInfo             Pointer to the old prpsinfo_t structure to update.
  */
-void GetOldProcessInfo(PVBOXCORE pVBoxCore, prpsinfo_t *pInfo)
+static void GetOldProcessInfo(PVBOXCORE pVBoxCore, prpsinfo_t *pInfo)
 {
     AssertReturnVoid(pVBoxCore);
@@ -961 +985 @@
  *
  */
-void GetOldProcessStatus(PVBOXCORE pVBoxCore, lwpsinfo_t *pInfo, lwpstatus_t *pStatus, prstatus_t *pDst)
+static void GetOldProcessStatus(PVBOXCORE pVBoxCore, lwpsinfo_t *pInfo, lwpstatus_t *pStatus, prstatus_t *pDst)
 {
     AssertReturnVoid(pVBoxCore);
@@ -1040 +1064 @@
 
 /**
- * Count the number of sections which will be dumped into the core file.
- *
- * @param pVBoxCore             Pointer to the core object.
- *
- * @return Number of sections for the core file.
- */
-uint32_t CountSections(PVBOXCORE pVBoxCore)
-{
-    /* @todo sections */
-    NOREF(pVBoxCore);
-    return 0;
-}
-
-
-/**
  * Resume all threads of this process.
  *
@@ -1061 +1070 @@
  * @return VBox error code.
  */
-int ResumeAllThreads(PVBOXPROCESS pVBoxProc)
+static int ResumeAllThreads(PVBOXPROCESS pVBoxProc)
 {
     AssertReturn(pVBoxProc, VERR_INVALID_POINTER);
@@ -1094 +1103 @@
         }
 
-        CORELOG(("ResumeAllThreads: resumed %d threads\n", cRunningThreads));
+        CORELOG((CORELOG_NAME "ResumeAllThreads: resumed %d threads\n", cRunningThreads));
         RTDirClose(pDir);
     }
     else
     {
-        CORELOGREL(("ResumeAllThreads: Failed to open %s\n", szPath));
+        CORELOGRELSYS((CORELOG_NAME "ResumeAllThreads: Failed to open %s\n", szPath));
         rc = VERR_READ_ERROR;
     }
@@ -1115 +1124 @@
  * @return VBox error code.
  */
-int SuspendAllThreads(PVBOXPROCESS pVBoxProc)
+static int SuspendAllThreads(PVBOXPROCESS pVBoxProc)
 {
     char szCurThread[128];
@@ -1161 +1170 @@
         else
         {
-            CORELOGREL(("SuspendAllThreads: Failed to open %s cTries=%d\n", szPath, cTries));
+            CORELOGRELSYS((CORELOG_NAME "SuspendAllThreads: Failed to open %s cTries=%d\n", szPath, cTries));
             rc = VERR_READ_ERROR;
             break;
@@ -1168 +1177 @@
 
     if (RT_SUCCESS(rc))
-        CORELOG(("Stopped %u threads successfully with %u tries\n", cThreads, cTries));
+        CORELOG((CORELOG_NAME "Stopped %u threads successfully with %u tries\n", cThreads, cTries));
 
     return rc;
@@ -1181 +1190 @@
  * @return Size of data actually used for NOTE header and section.
  */
-inline size_t ElfNoteHeaderSize(size_t cb)
+static inline size_t ElfNoteHeaderSize(size_t cb)
 {
     return sizeof(ELFNOTEHDR) + RT_ALIGN_Z(cb, 4);
@@ -1197 +1206 @@
  * @return VBox status code.
  */
-int ElfWriteNoteHeader(PVBOXCORE pVBoxCore, uint_t Type, const void *pcv, size_t cb)
+static int ElfWriteNoteHeader(PVBOXCORE pVBoxCore, uint_t Type, const void *pcv, size_t cb)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -1225 +1234 @@
 
     if (RT_FAILURE(rc))
-        CORELOGREL(("ElfWriteNote: pfnWriter failed. Type=%d rc=%Rrc\n", Type, rc));
+        CORELOGRELSYS((CORELOG_NAME "ElfWriteNote: pfnWriter failed. Type=%d rc=%Rrc\n", Type, rc));
 #else
 #error Port Me!
@@ -1242 +1251 @@
  * @return Size of NOTE section.
  */
-size_t ElfNoteSectionSize(PVBOXCORE pVBoxCore, VBOXSOLCORETYPE enmType)
+static size_t ElfNoteSectionSize(PVBOXCORE pVBoxCore, VBOXSOLCORETYPE enmType)
 {
     PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
@@ -1303 +1312 @@
         default:
         {
-            CORELOGREL(("ElfNoteSectionSize: Unknown segment era %d\n", enmType));
+            CORELOGRELSYS((CORELOG_NAME "ElfNoteSectionSize: Unknown segment era %d\n", enmType));
             break;
         }
@@ -1321 +1330 @@
  * @return VBox status code.
  */
-int ElfWriteNoteSection(PVBOXCORE pVBoxCore, VBOXSOLCORETYPE enmType)
+static int ElfWriteNoteSection(PVBOXCORE pVBoxCore, VBOXSOLCORETYPE enmType)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -1329 +1338 @@
 
 #ifdef RT_OS_SOLARIS
-
     typedef int (*PFNELFWRITENOTEHDR)(PVBOXCORE pVBoxCore, uint_t, const void *pcv, size_t cb);
     typedef struct ELFWRITENOTE
@@ -1355 +1363 @@
                 if (RT_FAILURE(rc))
                 {
-                    CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n", aElfNotes[i].pszType, rc));
+                    CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n", aElfNotes[i].pszType, rc));
                     break;
                 }
@@ -1378 +1386 @@
                     if (RT_FAILURE(rc))
                     {
-                        CORELOGREL(("ElfWriteSegment: ElfWriteNote failed for NT_PRFPREF. rc=%Rrc\n", rc));
+                        CORELOGRELSYS((CORELOG_NAME "ElfWriteSegment: ElfWriteNote failed for NT_PRFPREF. rc=%Rrc\n", rc));
                         break;
                     }
@@ -1384 +1392 @@
                 else
                 {
-                    CORELOGREL(("ElfWriteSegment: ElfWriteNote failed for NT_PRSTATUS. rc=%Rrc\n", rc));
+                    CORELOGRELSYS((CORELOG_NAME "ElfWriteSegment: ElfWriteNote failed for NT_PRSTATUS. rc=%Rrc\n", rc));
                     break;
                 }
@@ -1412 +1420 @@
                 if (RT_FAILURE(rc))
                 {
-                    CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n", aElfNotes[i].pszType, rc));
+                    CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n", aElfNotes[i].pszType, rc));
                     break;
                 }
@@ -1427 +1435 @@
                 if (RT_FAILURE(rc))
                 {
-                    CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSINFO failed. rc=%Rrc\n", rc));
+                    CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSINFO failed. rc=%Rrc\n", rc));
                     break;
                 }
@@ -1436 +1444 @@
                     if (RT_FAILURE(rc))
                     {
-                        CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSTATUS failed. rc=%Rrc\n", rc));
+                        CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSTATUS failed. rc=%Rrc\n", rc));
                         break;
                     }
@@ -1446 +1454 @@
         default:
         {
-            CORELOGREL(("ElfWriteNoteSection: Invalid type %d\n", enmType));
+            CORELOGRELSYS((CORELOG_NAME "ElfWriteNoteSection: Invalid type %d\n", enmType));
             rc = VERR_GENERAL_FAILURE;
             break;
@@ -1465 +1473 @@
  * @return VBox status code.
  */
-int ElfWriteMappings(PVBOXCORE pVBoxCore)
+static int ElfWriteMappings(PVBOXCORE pVBoxCore)
 {
     PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
@@ -1480 +1488 @@
             {
                 size_t cb = RT_MIN(sizeof(achBuf), pMapInfo->pMap.pr_size - k);
-                int rc2 = ReadProcAddrSpace(pVBoxProc, pMapInfo->pMap.pr_vaddr + k, &achBuf, cb);
+                int rc2 = ProcReadAddrSpace(pVBoxProc, pMapInfo->pMap.pr_vaddr + k, &achBuf, cb);
                 if (RT_FAILURE(rc2))
                 {
-                    CORELOGREL(("ElfWriteMappings: Failed to read mapping, can't recover. Bye. rc=%Rrc\n", rc));
+                    CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: Failed to read mapping, can't recover. Bye. rc=%Rrc\n", rc));
                     return VERR_INVALID_STATE;
                 }
@@ -1490 +1498 @@
                 if (RT_FAILURE(rc))
                 {
-                    CORELOGREL(("ElfWriteMappings: pfnWriter failed. rc=%Rrc\n", rc));
+                    CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: pfnWriter failed. rc=%Rrc\n", rc));
                     return rc;
                 }
@@ -1502 +1510 @@
             memcpy(achBuf, &pMapInfo->fError, sizeof(pMapInfo->fError));
             if (sizeof(achBuf) != pMapInfo->pMap.pr_size)
-                CORELOGREL(("ElfWriteMappings: Huh!? something is wrong!\n"));
+                CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: Huh!? something is wrong!\n"));
             rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &achBuf, sizeof(achBuf));
             if (RT_FAILURE(rc))
             {
-                CORELOGREL(("ElfWriteMappings: pfnWriter(2) failed. rc=%Rrc\n", rc));
+                CORELOGRELSYS((CORELOG_NAME "ElfWriteMappings: pfnWriter(2) failed. rc=%Rrc\n", rc));
                 return rc;
             }
@@ -1517 +1525 @@
 }
 
+
 /**
  * Write program headers for all mappings into the core file.
@@ -1524 +1533 @@
  * @return VBox status code.
  */
-int ElfWriteMappingHeaders(PVBOXCORE pVBoxCore)
+static int ElfWriteMappingHeaders(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -1556 +1565 @@
         if (RT_FAILURE(rc))
         {
-            CORELOGREL(("ElfWriteMappingHeaders: pfnWriter failed. rc=%Rrc\n", rc));
+            CORELOGRELSYS((CORELOG_NAME "ElfWriteMappingHeaders: pfnWriter failed. rc=%Rrc\n", rc));
             return rc;
         }
@@ -1577 +1586 @@
  * @return VBox status.
  */
-int WriteCore(PVBOXCORE pVBoxCore, PFNCOREWRITER pfnWriter)
+static int rtCoreDumperWriteCore(PVBOXCORE pVBoxCore, PFNCOREWRITER pfnWriter)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -1597 +1606 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: Failed to open address space, %s. rc=%Rrc\n", szPath, rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: Failed to open address space, %s. rc=%Rrc\n", szPath, rc));
         goto WriteCoreDone;
     }
@@ -1608 +1617 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: failed to open %s. rc=%Rrc\n", szPath, rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: failed to open %s. rc=%Rrc\n", szPath, rc));
         goto WriteCoreDone;
     }
@@ -1614 +1623 @@
     pVBoxCore->offWrite = 0;
     uint32_t cProgHdrs  = pVBoxProc->cMappings + 2; /* two PT_NOTE program headers (old, new style) */
-    uint32_t cSecHdrs   = CountSections(pVBoxCore);
 
     /*
@@ -1646 +1654 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: pfnWriter failed writing ELF header. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: pfnWriter failed writing ELF header. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1667 +1675 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: pfnWriter failed writing old-style ELF program Header. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: pfnWriter failed writing old-style ELF program Header. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1680 +1688 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: pfnWriter failed writing new-style ELF program header. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: pfnWriter failed writing new-style ELF program header. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1691 +1699 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("Write: ElfWriteMappings failed. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "Write: ElfWriteMappings failed. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1701 +1709 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: ElfWriteNoteSection old-style failed. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: ElfWriteNoteSection old-style failed. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1711 +1719 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: ElfWriteNoteSection new-style failed. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: ElfWriteNoteSection new-style failed. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1721 +1729 @@
     if (RT_FAILURE(rc))
     {
-        CORELOGREL(("WriteCore: ElfWriteMappings failed. rc=%Rrc\n", rc));
+        CORELOGRELSYS((CORELOG_NAME "WriteCore: ElfWriteMappings failed. rc=%Rrc\n", rc));
         goto WriteCoreDone;
     }
@@ -1755 +1763 @@
  * @return VBox status code.
  */
-int CreateCore(PVBOXCORE pVBoxCore, ucontext_t *pContext)
+static int rtCoreDumperCreateCore(PVBOXCORE pVBoxCore, ucontext_t *pContext)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -1778 +1786 @@
     RTProcGetExecutableName(pVBoxProc->szExecPath, sizeof(pVBoxProc->szExecPath));  /* this gets full path not just name */
     pVBoxProc->pszExecName = RTPathFilename(pVBoxProc->szExecPath);
-    RTStrPrintf(pVBoxCore->szCorePath, sizeof(pVBoxCore->szCorePath), "core.vb.%s.%d", pVBoxProc->pszExecName, (int)pVBoxProc->Process);
-
-    CORELOG(("tstRTCoreDump: Taking Core %s from Thread %d\n", pVBoxCore->szCorePath, (int)pVBoxProc->hCurThread));
+
+    /*
+     * If no output directory is specified, use current directory.
+     */
+    if (g_szCoreDumpDir[0] == '\0')
+        g_szCoreDumpDir[0] = '.';
+
+    if (g_szCoreDumpFile[0] == '\0')
+    {
+        /* We cannot call RTPathAbs*() as they call getcwd() which calls malloc. */
+        RTStrPrintf(pVBoxCore->szCorePath, sizeof(pVBoxCore->szCorePath), "%s/core.vb.%s.%d",
+                    g_szCoreDumpDir, pVBoxProc->pszExecName, (int)pVBoxProc->Process);
+    }
+    else
+        RTStrPrintf(pVBoxCore->szCorePath, sizeof(pVBoxCore->szCorePath), "%s/core.vb.%s", g_szCoreDumpDir, g_szCoreDumpFile);
+
+    CORELOG((CORELOG_NAME  "CreateCore: Taking Core %s from Thread %d\n", pVBoxCore->szCorePath, (int)pVBoxProc->hCurThread));
 
     /*
@@ -1788 +1810 @@
     if (RT_SUCCESS(rc))
     {
-        rc = ReadProcInfo(pVBoxCore);
+        rc = ProcReadInfo(pVBoxCore);
         if (RT_SUCCESS(rc))
         {
             GetOldProcessInfo(pVBoxCore, &pVBoxProc->ProcInfoOld);
-            if (IsProcArchNative(pVBoxProc))
+            if (IsProcessArchNative(pVBoxProc))
             {
                 /*
                  * Read process status, information such as number of active LWPs will be invalid since we just quiesced the process.
                  */
-                rc = ReadProcStatus(pVBoxCore);
+                rc = ProcReadStatus(pVBoxCore);
                 if (RT_SUCCESS(rc))
                 {
@@ -1810 +1832 @@
                         } aAccumulators[] =
                         {
-                            { "ReadProcLdt",      &ReadProcLdt,      false },
-                            { "ReadProcCred",     &ReadProcCred,     false },
-                            { "ReadProcPriv",     &ReadProcPriv,     false },
-                            { "ReadProcAuxVecs",  &ReadProcAuxVecs,  false },
-                            { "ReadProcMappings", &ReadProcMappings, false },
-                            { "ReadProcThreads",  &ReadProcThreads,  false },
-                            { "ReadProcMiscInfo", &ReadProcMiscInfo, false }
+                            { "ProcReadLdt",      &ProcReadLdt,      false },
+                            { "ProcReadCred",     &ProcReadCred,     false },
+                            { "ProcReadPriv",     &ProcReadPriv,     false },
+                            { "ProcReadAuxVecs",  &ProcReadAuxVecs,  false },
+                            { "ProcReadMappings", &ProcReadMappings, false },
+                            { "ProcReadThreads",  &ProcReadThreads,  false },
+                            { "ProcReadMiscInfo", &ProcReadMiscInfo, false }
                         };
 
@@ -1824 +1846 @@
                             if (RT_FAILURE(rc))
                             {
-                                CORELOGREL(("DumpCore: %s failed. rc=%Rrc\n", aAccumulators[i].pszName, rc));
+                                CORELOGRELSYS((CORELOG_NAME "CreateCore: %s failed. rc=%Rrc\n", aAccumulators[i].pszName, rc));
                                 if (!aAccumulators[i].fOptional)
                                     break;
@@ -1839 +1861 @@
                     }
                     else
-                        CORELOGREL(("DumpCore: AllocMemoryArea failed. rc=%Rrc\n", rc));
+                        CORELOGRELSYS((CORELOG_NAME "CreateCore: AllocMemoryArea failed. rc=%Rrc\n", rc));
                 }
                 else
-                    CORELOGREL(("DumpCore: ReadProcStatus failed. rc=%Rrc\n", rc));
+                    CORELOGRELSYS((CORELOG_NAME "CreateCore: ProcReadStatus failed. rc=%Rrc\n", rc));
             }
             else
             {
-                CORELOGREL(("DumpCore: IsProcArchNative failed.\n"));
+                CORELOGRELSYS((CORELOG_NAME "CreateCore: IsProcessArchNative failed.\n"));
                 rc = VERR_BAD_EXE_FORMAT;
             }
         }
         else
-            CORELOGREL(("DumpCore: ReadProcInfo failed. rc=%Rrc\n", rc));
+            CORELOGRELSYS((CORELOG_NAME "CreateCore: ProcReadInfo failed. rc=%Rrc\n", rc));
 
         /*
@@ -1859 +1881 @@
     }
     else
-        CORELOG(("DumpCore: SuspendAllThreads failed. Thread bomb!?! rc=%Rrc\n", rc));
+        CORELOG((CORELOG_NAME "CreateCore: SuspendAllThreads failed. Thread bomb!?! rc=%Rrc\n", rc));
 
     return rc;
@@ -1872 +1894 @@
  * @return VBox status code.
  */
-int DestroyCore(PVBOXCORE pVBoxCore)
+static int rtCoreDumperDestroyCore(PVBOXCORE pVBoxCore)
 {
     AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
@@ -1884 +1906 @@
 
 
-void CoreSigHandler(int Sig, siginfo_t *pSigInfo, void *pvArg)
-{
-    CORELOG(("CoreSigHandler Sig=%d pvArg=%p\n", Sig, pvArg));
-
-    ucontext_t *pContext = (ucontext_t *)pvArg;
+/**
+ * Takes a core dump. This function has no other parameters than the context
+ * because it can be called from signal handlers.
+ *
+ * @param   pContext            The context of the caller.
+ * @returns VBox status code.
+ */
+static int rtCoreDumperTakeDump(ucontext_t *pContext)
+{
     if (!pContext)
-        CORELOGREL(("CoreSigHandler: Missing context.\n"));
+    {
+        CORELOGRELSYS((CORELOG_NAME "TakeDump: Missing context.\n"));
+        return VERR_INVALID_POINTER;
+    }
+
+    /*
+     * Take a snapshot, then dump core to disk, all threads except this one are halted
+     * from before taking the snapshot until writing the core is completely finished.
+     * Any errors would resume all threads if they were halted.
+     */
+    VBOXCORE VBoxCore;
+    RT_ZERO(VBoxCore);
+    int rc = rtCoreDumperCreateCore(&VBoxCore, pContext);
+    if (RT_SUCCESS(rc))
+    {
+        rc = rtCoreDumperWriteCore(&VBoxCore, &WriteFileNoIntr);
+        if (RT_SUCCESS(rc))
+            CORELOGRELSYS((CORELOG_NAME "Success! Core written to %s\n", VBoxCore.szCorePath));
+        else
+            CORELOGRELSYS((CORELOG_NAME "TakeDump: WriteCore failed. szCorePath=%s rc=%Rrc\n", VBoxCore.szCorePath, rc));
+
+        rtCoreDumperDestroyCore(&VBoxCore);
+    }
     else
-    {
-        if (!ASMAtomicUoReadBool(&g_fCoreDumpInProgress))
-        {
-            ASMAtomicWriteBool(&g_fCoreDumpInProgress, true);
-
+        CORELOGRELSYS((CORELOG_NAME "TakeDump: CreateCore failed. rc=%Rrc\n", rc));
+
+    return rc;
+}
+
+
+/**
+ * The signal handler that will be invoked to take core dumps.
+ *
+ * @param Sig                   The signal that invoked us.
+ * @param pSigInfo              The signal information.
+ * @param pvArg                 Opaque pointer to the caller context structure,
+ *                              this cannot be NULL.
+ */
+static void rtCoreDumperSignalHandler(int Sig, siginfo_t *pSigInfo, void *pvArg)
+{
+    CORELOG((CORELOG_NAME "SignalHandler Sig=%d pvArg=%p\n", Sig, pvArg));
+
+    int rc = VERR_GENERAL_FAILURE;
+    bool fCallSystemDump = false;
+    if (ASMAtomicUoReadBool(&g_fCoreDumpInProgress) == false)
+    {
+        ASMAtomicWriteBool(&g_fCoreDumpInProgress, true);
+        ASMAtomicWriteU64(&g_CoreDumpThread, (uint64_t)RTThreadSelf());
+
+        rc = rtCoreDumperTakeDump((ucontext_t *)pvArg);
+
+        ASMAtomicWriteU64(&g_CoreDumpThread, NIL_RTTHREAD);
+        ASMAtomicWriteBool(&g_fCoreDumpInProgress, false);
+
+        if (RT_FAILURE(rc))
+        {
             /*
-             * Take a snapshot, then dump core to disk, all threads except this one are halted
-             * from before taking the snapshot until writing the core is completely finished.
-             * Any errors would resume all threads if they were halted.
+             * If it is NOT a deliberate dump taken by us & our handler fails we assume the
+             * worst, try to use the system signal handler and abort the process.
              */
-            VBOXCORE VBoxCore;
-            RT_ZERO(VBoxCore);
-            int rc = CreateCore(&VBoxCore, pContext);
-            if (RT_SUCCESS(rc))
-            {
-                rc = WriteCore(&VBoxCore, &WriteFileNoIntr);
-                if (RT_SUCCESS(rc))
-                    CORELOG(("CoreSigHandler: Successfully wrote core file to disk.\n"));
-                else
-                    CORELOGREL(("CoreSigHandler: WriteCore failed. rc=%Rrc\n", rc));
-
-                DestroyCore(&VBoxCore);
-            }
-            else
-                CORELOGREL(("CoreSigHandler: CreateCore failed. rc=%Rrc\n", rc));
-
-            ASMAtomicWriteBool(&g_fCoreDumpInProgress, false);
-        }
+            CORELOGRELSYS((CORELOG_NAME "TakeDump failed! rc=%Rrc\n", rc));
+            if (ASMAtomicReadBool(&g_fCoreDumpDeliberate) == false)
+                fCallSystemDump = true;
+        }
+    }
+    else
+    {
+        /*
+         * Core dumping is already in  progress and we've somehow ended up being
+         * signalled again.
+         */
+        rc = VERR_INTERNAL_ERROR;
+
+        /*
+         * If our dumper has crashed. No point in waiting, trigger the system one.
+         * Wait only when the dumping thread is not the one generating this signal.
+         */
+        if (ASMAtomicReadU64(&g_CoreDumpThread) != (uint64_t)RTThreadSelf())
+            fCallSystemDump = true;
         else
         {
-            /* @todo detect if we are awaiting for ourselves, if so don't. */
-            CORELOGREL(("CoreSigHandler: Core dump already in progress! Waiting before signalling Sig=%d.\n", Sig));
+            CORELOGRELSYS((CORELOG_NAME "SignalHandler: Core dump already in progress! Waiting before signalling Sig=%d.\n", Sig));
             int64_t iTimeout = 10000;  /* timeout (ms) */
-            while (!ASMAtomicUoReadBool(&g_fCoreDumpInProgress))
+            while (ASMAtomicUoReadBool(&g_fCoreDumpInProgress) == true)
             {
                 RTThreadSleep(200);
@@ -1933 +2007 @@
             }
             if (iTimeout <= 0)
-                CORELOGREL(("CoreSigHandler: Core dump seems to be stuck. Signalling new signal %d\n", Sig));
-        }
-    }
-
-    signal(Sig, SIG_DFL);
-    kill((int)getpid(), Sig);
-}
-
-
-static DECLCALLBACK(int) SleepyThread(RTTHREAD Thread, void *pvUser)
-{
-    NOREF(pvUser);
-    sleep(10000);
+            {
+                fCallSystemDump = true;
+                CORELOGRELSYS((CORELOG_NAME "SignalHandler: Core dump seems to be stuck. Signalling new signal %d\n", Sig));
+            }
+        }
+    }
+
+    if (fCallSystemDump)
+    {
+        signal(Sig, SIG_DFL);
+        raise(Sig);
+    }
+}
+
+
+/**
+ * Take a core dump of the current process without terminating it.
+ *
+ * @returns IPRT status code.
+ * @param   pszOutputFile       Name of the core file.  If NULL use the
+ *                              default naming scheme.
+ */
+RTDECL(int) RTCoreDumperTakeDump(const char *pszOutputFile)
+{
+    if (ASMAtomicReadBool(&g_fCoreDumpSignalSetup) == false)
+        return VERR_WRONG_ORDER;
+
+    RT_ZERO(g_szCoreDumpFile);
+    if (pszOutputFile)
+        RTStrCopy(g_szCoreDumpFile, sizeof(g_szCoreDumpFile), pszOutputFile);
+
+    ASMAtomicWriteBool(&g_fCoreDumpDeliberate, true);
+    raise(SIGSEGV);
+    ASMAtomicWriteBool(&g_fCoreDumpDeliberate, false);
     return VINF_SUCCESS;
 }
 
 
-int main()
-{
-    RTR3Init();
-    CORELOG(("tstRTCoreDump: TESTING pid=%d\n", getpid()));
+/**
+ * Sets up and enables the core dumper.
+ *
+ * Installs signal / unhandled exception handlers for catching fatal errors
+ * that should result in a core dump.  If you wish to install your own handlers
+ * you should do that after calling this function and make sure you pass on
+ * events you don't handle.
+ *
+ * This can be called multiple times to change the settings without needing to
+ * call RTCoreDumperDisable in between.
+ *
+ * @param   pszOutputDir        The directory to store the cores in.  If NULL
+ *                              the current directory will be used.
+ * @param   pszBaseName         Base file name, no directory.  If NULL the
+ *                              dumper will generate an appropriate name.
+ * @param   fFlags              Reserved for later, MBZ.
+ */
+RTDECL(int) RTCoreDumperSetup(const char *pszOutputDir, uint32_t fFlags)
+{
+    /*
+     * Validate flags.
+     */
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
 
     /*
      * Install core dump signal handler.
      */
-    struct sigaction sigAction;
-    sigAction.sa_sigaction = CoreSigHandler;
-    sigemptyset(&sigAction.sa_mask);
-    sigAction.sa_flags = SA_RESTART | SA_SIGINFO;
-    sigaction(SIGSEGV, &sigAction, NULL);
-    sigaction(SIGBUS, &sigAction, NULL);
-    sigaction(SIGUSR1, &sigAction, NULL);
-
+    struct sigaction sigAct;
+    sigAct.sa_sigaction = &rtCoreDumperSignalHandler;
+    sigemptyset(&sigAct.sa_mask);
+    sigAct.sa_flags = SA_RESTART | SA_SIGINFO;
+    sigaction(SIGSEGV, &sigAct, NULL);
+    sigaction(SIGBUS, &sigAct, NULL);
+
+    ASMAtomicWriteBool(&g_fCoreDumpSignalSetup, true);
+
+    RT_ZERO(g_szCoreDumpDir);
+    if (pszOutputDir)
+        RTStrCopy(g_szCoreDumpDir, sizeof(g_szCoreDumpDir), pszOutputDir);
+
+    ASMAtomicWriteU32(&g_fCoreDumpFlags, fFlags);
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Disables the core dumper, i.e. undoes what RTCoreDumperSetup did.
+ *
+ * @returns IPRT status code.
+ */
+RTDECL(int) RTCoreDumperDisable(void)
+{
     /*
-     * Spawn a few threads.
+     * Remove core dump signal handler & reset variables.
      */
-    RTTHREAD ahThreads[5];
-    for (unsigned i = 0; i < RT_ELEMENTS(ahThreads); i++)
-    {
-        int rc = RTThreadCreate(&ahThreads[i], SleepyThread, &ahThreads[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "TEST1");
-        if (RT_FAILURE(rc))
-        {
-            CORELOG(("tstRTCoreDump: FAILURE(%d) - %d RTThreadCreate failed, rc=%Rrc\n", __LINE__, i, rc));
-            g_cErrors++;
-            ahThreads[i] = NIL_RTTHREAD;
-            break;
-        }
-    }
-
-    CORELOG(("Spawned %d threads\n", RT_ELEMENTS(ahThreads)));
-
-    /*
-     * Send signal to dump core.
-     */
-    kill(getpid(), SIGSEGV);
-    g_cErrors++;
-
-    sleep(10);
-
-    /*
-     * Summary.
-     */
-    if (!g_cErrors)
-        CORELOG(("tstRTCoreDump: SUCCESS\n"));
-    else
-        CORELOG(("tstRTCoreDump: FAILURE - %d errors\n", g_cErrors));
-
-    return !!g_cErrors;
-}
-
+    signal(SIGSEGV, SIG_DFL);
+    signal(SIGBUS, SIG_DFL);
+    ASMAtomicWriteBool(&g_fCoreDumpSignalSetup, false);
+
+    RT_ZERO(g_szCoreDumpDir);
+    RT_ZERO(g_szCoreDumpFile);
+    return VINF_SUCCESS;
+}
+

trunk/src/VBox/Runtime/r3/solaris/coredumper-solaris.h

@@ -61 +61 @@
 
 /**
- * ELF NOTE header.
+ * ELFNOTEHDR: ELF NOTE header.
  */
 typedef struct ELFNOTEHDR
@@ -70 +70 @@
 typedef ELFNOTEHDR *PELFNOTEHDR;
 
+
 #ifdef RT_OS_SOLARIS
+/**
+ * VBOXSOLMAPINFO: Memory mapping description.
+ */
 typedef struct VBOXSOLMAPINFO
 {
@@ -79 +83 @@
 typedef VBOXSOLMAPINFO *PVBOXSOLMAPINFO;
 
+/**
+ * VBOXSOLCORETYPE: Whether this is an old or new style core.
+ */
+typedef enum VBOXSOLCORETYPE
+{
+    enmOldEra       = 0x01d,        /* old */
+    enmNewEra       = 0x5c151       /* sci-fi */
+} VBOXSOLCORETYPE;
+
+/**
+ * VBOXSOLTHREADINFO: Per-Thread information.
+ */
 typedef struct VBOXSOLTHREADINFO
 {
@@ -88 +104 @@
 #endif
 
-typedef int (*PFNCOREREADER)(RTFILE hFile, void *pv, size_t cb);
-typedef int (*PFNCOREWRITER)(RTFILE hFile, const void *pcv, size_t cb);
 
+/**
+ * VBOXPROCESS: Current (also the core target) process information.
+ */
 typedef struct VBOXPROCESS
 {
@@ -127 +144 @@
 typedef VBOXPROCESS *PVBOXPROCESS;
 
+typedef int (*PFNCOREREADER)(RTFILE hFile, void *pv, size_t cb);
+typedef int (*PFNCOREWRITER)(RTFILE hFile, const void *pcv, size_t cb);
+
+/**
+ * VBOXCORE: Core file object.
+ */
 typedef struct VBOXCORE
 {
@@ -142 +165 @@
 typedef VBOXCORE *PVBOXCORE;
 
-typedef int (*PFNCOREACCUMULATOR)(PVBOXCORE pVBoxCOre);
+typedef int (*PFNCOREACCUMULATOR)(PVBOXCORE pVBoxCore);
+

trunk/src/VBox/Runtime/testcase/tstRTCoreDump.cpp

@@ -29 +29 @@
 *******************************************************************************/
 #include <iprt/types.h>
-#include <iprt/file.h>
 #include <iprt/err.h>
-#include <iprt/dir.h>
-#include <iprt/path.h>
-#include <iprt/string.h>
-#include <iprt/stream.h>
 #include <iprt/initterm.h>
 #include <iprt/thread.h>
-#include <iprt/param.h>
-#include <iprt/asm.h>
-#include "tstRTCoreDump.h"
+#include <iprt/stream.h>
+#include <iprt/coredumper.h>
 
-#ifdef RT_OS_SOLARIS
-# include <signal.h>
-# include <unistd.h>
-# include <errno.h>
-# include <zone.h>
-# include <sys/proc.h>
-# include <sys/sysmacros.h>
-# include <sys/systeminfo.h>
-# include <sys/mman.h>
-#endif  /* RT_OS_SOLARIS */
 
 /*******************************************************************************
-*   Defined Constants And Macros                                               *
+*   Globals                                                                    *
 *******************************************************************************/
-#define CORELOG(a)          RTPrintf a
-#define CORELOGREL(a)       RTPrintf a
-
-/**
- * VBOXSOLCORETYPE: Whether this is an old or new style core.
- */
-typedef enum VBOXSOLCORETYPE
-{
-    enmOldEra       = 0x01d,        /* old */
-    enmNewEra       = 0x5c151       /* sci-fi */
-} VBOXSOLCORETYPE;
-
 static unsigned volatile g_cErrors = 0;
-
-volatile bool g_fCoreDumpInProgress = false;
-
-
-/**
- * Determines endianness of the system. Just for completeness.
- *
- * @return Will return false if system is little endian, true otherwise.
- */
-static bool IsBigEndian()
-{
-    const int i = 1;
-    char *p = (char *)&i;
-    if (p[0] == 1)
-        return false;
-    return true;
-}
-
-
-/**
- * Reads from a file making sure an interruption doesn't cause a failure.
- *
- * @param hFile             Handle to the file to read.
- * @param pv                Where to store the read data.
- * @param cbToRead          Size of data to read.
- *
- * @return VBox status code.
- */
-static int ReadFileNoIntr(RTFILE hFile, void *pv, size_t cbToRead)
-{
-    int rc = VERR_READ_ERROR;
-    while (1)
-    {
-        rc = RTFileRead(hFile, pv, cbToRead, NULL /* Read all */);
-        if (rc == VERR_INTERRUPTED)
-            continue;
-        break;
-    }
-    return rc;
-}
-
-
-/**
- * Writes to a file making sure an interruption doesn't cause a failure.
- *
- * @param hFile             Handle to the file to write.
- * @param pv                Pointer to what to write.
- * @param cbToRead          Size of data to write.
- *
- * @return VBox status code.
- */
-static int WriteFileNoIntr(RTFILE hFile, const void *pcv, size_t cbToRead)
-{
-    int rc = VERR_READ_ERROR;
-    while (1)
-    {
-        rc = RTFileWrite(hFile, pcv, cbToRead, NULL /* Write all */);
-        if (rc == VERR_INTERRUPTED)
-            continue;
-        break;
-    }
-    return rc;
-}
-
-
-/**
- * Read from a given offet in the process' address space.
- *
- * @param pVBoxProc         Pointer to the VBox process.
- * @param pv                Where to read the data into.
- * @param cb                Size of the read buffer.
- * @param off               Offset to read from.
- *
- * @return VINF_SUCCESS, if all the given bytes was read in, otherwise VERR_READ_ERROR.
- */
-static ssize_t ReadProcAddrSpace(PVBOXPROCESS pVBoxProc, RTFOFF off, void *pvBuf, size_t cbToRead)
-{
-    while (1)
-    {
-        int rc = RTFileReadAt(pVBoxProc->hAs, off, pvBuf, cbToRead, NULL);
-        if (rc == VERR_INTERRUPTED)
-            continue;
-        return rc;
-    }
-}
-
-
-/**
- * Determines if the current process' architecture is suitable for dumping core.
- *
- * @param pVBoxProc         Pointer to the VBox process.
- *
- * @return true if the architecture matches the current one.
- */
-inline bool IsProcArchNative(PVBOXPROCESS pVBoxProc)
-{
-    return pVBoxProc->ProcInfo.pr_dmodel == PR_MODEL_NATIVE;
-}
-
-
-/**
- * Helper function to get the size of a file given it's path.
- *
- * @param pszPath           Pointer to the full path of the file.
- *
- * @return The size of the file in bytes.
- */
-size_t GetFileSize(const char *pszPath)
-{
-    size_t cb = 0;
-    RTFILE hFile;
-    int rc = RTFileOpen(&hFile, pszPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_SUCCESS(rc))
-    {
-        RTFileGetSize(hFile, (uint64_t *)&cb);
-        RTFileClose(hFile);
-    }
-    else
-        CORELOGREL(("GetFileSize failed to open %s rc=%Rrc\n", pszPath, rc));
-    return cb;
-}
-
-
-/**
- * Pre-compute and pre-allocate sufficient memory for dumping core.
- * This is meant to be called once, as a single-large anonymously
- * mapped memory area which will be used during the core dumping routines.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int AllocMemoryArea(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore->pvCore == NULL, VERR_ALREADY_EXISTS);
-    AssertReturn(pVBoxCore->VBoxProc.Process != NIL_RTPROCESS, VERR_PROCESS_NOT_FOUND);
-
-    struct VBOXSOLPREALLOCTABLE
-    {
-        const char *pszFilePath;        /* Proc based path */
-        size_t      cbHeader;           /* Size of header */
-        size_t      cbEntry;            /* Size of each entry in file */
-        size_t      cbAccounting;       /* Size of each accounting entry per entry */
-    } aPreAllocTable[] = {
-        { "/proc/%d/map",        0,                  sizeof(prmap_t),       sizeof(VBOXSOLMAPINFO) },
-        { "/proc/%d/auxv",       0,                  0,                     0 },
-        { "/proc/%d/lpsinfo",    sizeof(prheader_t), sizeof(lwpsinfo_t),    sizeof(VBOXSOLTHREADINFO) },
-        { "/proc/%d/lstatus",    0,                  0,                     0 },
-        { "/proc/%d/ldt",        0,                  0,                     0 },
-        { "/proc/%d/cred",       sizeof(prcred_t),   sizeof(gid_t),         1 },
-        { "/proc/%d/priv",       sizeof(prpriv_t),   sizeof(priv_chunk_t),  1 },
-    };
-
-    size_t cb = 0;
-    for (int i = 0; i < (int)RT_ELEMENTS(aPreAllocTable); i++)
-    {
-        char szPath[PATH_MAX];
-        RTStrPrintf(szPath, sizeof(szPath), aPreAllocTable[i].pszFilePath, (int)pVBoxCore->VBoxProc.Process);
-        size_t cbFile = GetFileSize(szPath);
-        cb += cbFile;
-        if (   cbFile > 0
-            && aPreAllocTable[i].cbEntry > 0
-            && aPreAllocTable[i].cbAccounting > 0)
-        {
-            cb += ((cbFile - aPreAllocTable[i].cbHeader) / aPreAllocTable[i].cbEntry) * aPreAllocTable[i].cbAccounting;
-            cb += aPreAllocTable[i].cbHeader;
-        }
-    }
-
-    /*
-     * Make Room for our own mapping accountant entry which will also be included in the core.
-     */
-    cb += sizeof(VBOXSOLMAPINFO);
-
-    /*
-     * Allocate the required space, plus some extra room.
-     */
-    cb += _128K;
-    void *pv = mmap(NULL, cb, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1 /* fd */, 0 /* offset */);
-    if (pv)
-    {
-        CORELOG(("AllocMemoryArea: memory area of %u bytes allocated.\n", cb));
-        pVBoxCore->pvCore = pv;
-        pVBoxCore->pvFree = pv;
-        pVBoxCore->cbCore = cb;
-        return VINF_SUCCESS;
-    }
-    else
-    {
-        CORELOGREL(("AllocMemoryArea: failed cb=%u\n", cb));
-        return VERR_NO_MEMORY;
-    }
-}
-
-
-/**
- * Free memory area used by the core object.
- *
- * @param pVBoxCore         Pointer to the core object.
- */
-void FreeMemoryArea(PVBOXCORE pVBoxCore)
-{
-    AssertReturnVoid(pVBoxCore);
-    AssertReturnVoid(pVBoxCore->pvCore);
-    AssertReturnVoid(pVBoxCore->cbCore > 0);
-
-    munmap(pVBoxCore->pvCore, pVBoxCore->cbCore);
-    CORELOG(("FreeMemoryArea: memory area of %u bytes freed.\n", pVBoxCore->cbCore));
-
-    pVBoxCore->pvCore = NULL;
-    pVBoxCore->pvFree= NULL;
-    pVBoxCore->cbCore = 0;
-}
-
-
-/**
- * Get a chunk from the area of allocated memory.
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param cb                Size of requested chunk.
- *
- * @return Pointer to allocated memory, or NULL on failure.
- */
-void *GetMemoryChunk(PVBOXCORE pVBoxCore, size_t cb)
-{
-    AssertReturn(pVBoxCore, NULL);
-    AssertReturn(pVBoxCore->pvCore, NULL);
-    AssertReturn(pVBoxCore->pvFree, NULL);
-
-    size_t cbAllocated = (char *)pVBoxCore->pvFree - (char *)pVBoxCore->pvCore;
-    if (cbAllocated < pVBoxCore->cbCore)
-    {
-        char *pb = (char *)pVBoxCore->pvFree;
-        pVBoxCore->pvFree = pb + cb;
-        return pb;
-    }
-
-    return NULL;
-}
-
-
-/**
- * Reads the proc file's content into a newly allocated buffer.
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param pszFileFmt        Only the name of the file to read from (/proc/<pid> will be prepended)
- * @param ppv               Where to store the allocated buffer.
- * @param pcb               Where to store size of the buffer.
- *
- * @return VBox status code.
- */
-int ProcReadFileInto(PVBOXCORE pVBoxCore, const char *pszProcFileName, void **ppv, size_t *pcb)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    char szPath[PATH_MAX];
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/%s", (int)pVBoxCore->VBoxProc.Process, pszProcFileName);
-    RTFILE hFile;
-    int rc = RTFileOpen(&hFile, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_SUCCESS(rc))
-    {
-        RTFileGetSize(hFile, (uint64_t *)pcb);
-        if (*pcb > 0)
-        {
-            *ppv = GetMemoryChunk(pVBoxCore, *pcb);
-            if (*ppv)
-                rc = ReadFileNoIntr(hFile, *ppv, *pcb);
-            else
-                rc = VERR_NO_MEMORY;
-        }
-        else
-        {
-            *pcb =  0;
-            *ppv = NULL;
-        }
-        RTFileClose(hFile);
-    }
-    else
-        CORELOGREL(("ProcReadFileInto: failed to open %s. rc=%Rrc\n", szPath, rc));
-    return rc;
-}
-
-
-/**
- * Read process information (format psinfo_t) from /proc.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int ReadProcInfo(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    char szPath[PATH_MAX];
-    RTFILE hFile;
-
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/psinfo", (int)pVBoxProc->Process);
-    int rc = RTFileOpen(&hFile, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_SUCCESS(rc))
-    {
-        size_t cbProcInfo = sizeof(psinfo_t);
-        rc = ReadFileNoIntr(hFile, &pVBoxProc->ProcInfo, cbProcInfo);
-    }
-
-    RTFileClose(hFile);
-    return rc;
-}
-
-
-/**
- * Read process status (format pstatus_t) from /proc.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int ReadProcStatus(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-
-    char szPath[PATH_MAX];
-    RTFILE hFile;
-
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/status", (int)pVBoxProc->Process);
-    int rc = RTFileOpen(&hFile, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_SUCCESS(rc))
-    {
-        size_t cbRead;
-        size_t cbProcStatus = sizeof(pstatus_t);
-        AssertCompile(sizeof(pstatus_t) == sizeof(pVBoxProc->ProcStatus));
-        rc = ReadFileNoIntr(hFile, &pVBoxProc->ProcStatus, cbProcStatus);
-    }
-    RTFileClose(hFile);
-    return rc;
-}
-
-
-/**
- * Read process credential information (format prcred_t + array of guid_t)
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @remarks Should not be called before successful call to @see AllocMemoryArea()
- * @return VBox status code.
- */
-int ReadProcCred(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    return ProcReadFileInto(pVBoxCore, "cred", &pVBoxProc->pvCred, &pVBoxProc->cbCred);
-}
-
-
-/**
- * Read process privilege information (format prpriv_t + array of priv_chunk_t)
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @remarks Should not be called before successful call to @see AllocMemoryArea()
- * @return VBox status code.
- */
-int ReadProcPriv(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    int rc = ProcReadFileInto(pVBoxCore, "priv", (void **)&pVBoxProc->pPriv, &pVBoxProc->cbPriv);
-    if (RT_FAILURE(rc))
-        return rc;
-    pVBoxProc->pcPrivImpl = getprivimplinfo();
-    if (!pVBoxProc->pcPrivImpl)
-    {
-        CORELOGREL(("ReadProcPriv: getprivimplinfo returned NULL.\n"));
-        return VERR_INVALID_STATE;
-    }
-    return rc;
-}
-
-
-/**
- * Read process LDT information (format array of struct ssd) from /proc.
- *
- * @param pVBoxProc         Pointer to the core object.
- *
- * @remarks Should not be called before successful call to @see AllocMemoryArea()
- * @return VBox status code.
- */
-int ReadProcLdt(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    return ProcReadFileInto(pVBoxCore, "ldt", &pVBoxProc->pvLdt, &pVBoxProc->cbLdt);
-}
-
-
-/**
- * Read process auxiliary vectors (format auxv_t) for the process.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @remarks Should not be called before successful call to @see AllocMemoryArea()
- * @return VBox status code.
- */
-int ReadProcAuxVecs(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    char szPath[PATH_MAX];
-    RTFILE hFile = NIL_RTFILE;
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/auxv", (int)pVBoxProc->Process);
-    int rc = RTFileOpen(&hFile, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("ReadProcAuxVecs: RTFileOpen %s failed rc=%Rrc\n", szPath, rc));
-        return rc;
-    }
-
-    size_t cbAuxFile = 0;
-    RTFileGetSize(hFile, (uint64_t *)&cbAuxFile);
-    if (cbAuxFile >= sizeof(auxv_t))
-    {
-        pVBoxProc->pAuxVecs = (auxv_t*)GetMemoryChunk(pVBoxCore, cbAuxFile + sizeof(auxv_t));
-        if (pVBoxProc->pAuxVecs)
-        {
-            rc = ReadFileNoIntr(hFile, pVBoxProc->pAuxVecs, cbAuxFile);
-            if (RT_SUCCESS(rc))
-            {
-                /* Terminate list of vectors */
-                pVBoxProc->cAuxVecs = cbAuxFile / sizeof(auxv_t);
-                CORELOG(("ReadProcAuxVecs: cbAuxFile=%u auxv_t size %d cAuxVecs=%u\n", cbAuxFile, sizeof(auxv_t), pVBoxProc->cAuxVecs));
-                if (pVBoxProc->cAuxVecs > 0)
-                {
-                    pVBoxProc->pAuxVecs[pVBoxProc->cAuxVecs].a_type = AT_NULL;
-                    pVBoxProc->pAuxVecs[pVBoxProc->cAuxVecs].a_un.a_val = 0L;
-                    RTFileClose(hFile);
-                    return VINF_SUCCESS;
-                }
-                else
-                {
-                    CORELOGREL(("ReadProcAuxVecs: Invalid vector count %u\n", pVBoxProc->cAuxVecs));
-                    rc = VERR_READ_ERROR;
-                }
-            }
-            else
-                CORELOGREL(("ReadProcAuxVecs: ReadFileNoIntr failed. rc=%Rrc cbAuxFile=%u\n", rc, cbAuxFile));
-
-            pVBoxProc->pAuxVecs = NULL;
-            pVBoxProc->cAuxVecs = 0;
-        }
-        else
-        {
-            CORELOGREL(("ReadProcAuxVecs: no memory for %u bytes\n", cbAuxFile + sizeof(auxv_t)));
-            rc = VERR_NO_MEMORY;
-        }
-    }
-    else
-        CORELOGREL(("ReadProcAuxVecs: aux file too small %u, expecting %u or more\n", cbAuxFile, sizeof(auxv_t)));
-
-    RTFileClose(hFile);
-    return rc;
-}
-
-
-/*
- * Find an element in the process' auxiliary vector.
- */
-long GetAuxVal(PVBOXPROCESS pVBoxProc, int Type)
-{
-    AssertReturn(pVBoxProc, -1);
-    if (pVBoxProc->pAuxVecs)
-    {
-        auxv_t *pAuxVec = pVBoxProc->pAuxVecs;
-        for (; pAuxVec->a_type != AT_NULL; pAuxVec++)
-        {
-            if (pAuxVec->a_type == Type)
-                return pAuxVec->a_un.a_val;
-        }
-    }
-    return -1;
-}
-
-
-/**
- * Read the process mappings (format prmap_t array).
- *
- * @param   pVBoxCore           Pointer to the core object.
- *
- * @remarks Should not be called before successful call to @see AllocMemoryArea()
- * @return VBox status code.
- */
-int ReadProcMappings(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    char szPath[PATH_MAX];
-    RTFILE hFile = NIL_RTFILE;
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/map", (int)pVBoxProc->Process);
-    int rc = RTFileOpen(&hFile, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/as", (int)pVBoxProc->Process);
-    rc = RTFileOpen(&pVBoxProc->hAs, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Allocate and read all the prmap_t objects from proc.
-         */
-        size_t cbMapFile = 0;
-        RTFileGetSize(hFile, (uint64_t *)&cbMapFile);
-        if (cbMapFile >= sizeof(prmap_t))
-        {
-            prmap_t *pMap = (prmap_t*)GetMemoryChunk(pVBoxCore, cbMapFile);
-            if (pMap)
-            {
-                rc = ReadFileNoIntr(hFile, pMap, cbMapFile);
-                if (RT_SUCCESS(rc))
-                {
-                    pVBoxProc->cMappings = cbMapFile / sizeof(prmap_t);
-                    if (pVBoxProc->cMappings > 0)
-                    {
-                        /*
-                         * Allocate for each prmap_t object, a corresponding VBOXSOLMAPINFO object.
-                         */
-                        pVBoxProc->pMapInfoHead = (PVBOXSOLMAPINFO)GetMemoryChunk(pVBoxCore, pVBoxProc->cMappings * sizeof(VBOXSOLMAPINFO));
-                        if (pVBoxProc->pMapInfoHead)
-                        {
-                            /*
-                             * Associate the prmap_t with the mapping info object.
-                             */
-                            Assert(pVBoxProc->pMapInfoHead == NULL);
-                            PVBOXSOLMAPINFO pCur = pVBoxProc->pMapInfoHead;
-                            PVBOXSOLMAPINFO pPrev = NULL;
-                            for (uint64_t i = 0; i < pVBoxProc->cMappings; i++, pMap++, pCur++)
-                            {
-                                memcpy(&pCur->pMap, pMap, sizeof(pCur->pMap));
-                                if (pPrev)
-                                    pPrev->pNext = pCur;
-
-                                pCur->fError = 0;
-
-                                /*
-                                 * Make sure we can read the mapping, otherwise mark them to be skipped.
-                                 */
-                                char achBuf[PAGE_SIZE];
-                                uint64_t k = 0;
-                                while (k < pCur->pMap.pr_size)
-                                {
-                                    size_t cb = RT_MIN(sizeof(achBuf), pCur->pMap.pr_size - k);
-                                    int rc2 = ReadProcAddrSpace(pVBoxProc, pCur->pMap.pr_vaddr + k, &achBuf, cb);
-                                    if (RT_FAILURE(rc2))
-                                    {
-                                        CORELOGREL(("ReadProcMappings: skipping mapping. vaddr=%#x rc=%Rrc\n", pCur->pMap.pr_vaddr, rc2));
-
-                                        /*
-                                         * Instead of storing the actual mapping data which we failed to read, the core
-                                         * will contain an errno in place. So we adjust the prmap_t's size field too
-                                         * so the program header offsets match.
-                                         */
-                                        pCur->pMap.pr_size = RT_ALIGN_Z(sizeof(int), 8);
-                                        pCur->fError = errno;
-                                        if (pCur->fError == 0)  /* huh!? somehow errno got reset? fake one! EFAULT is nice. */
-                                            pCur->fError = EFAULT;
-                                        break;
-                                    }
-                                    k += cb;
-                                }
-
-                                pPrev = pCur;
-                            }
-                            if (pPrev)
-                                pPrev->pNext = NULL;
-
-                            RTFileClose(hFile);
-                            RTFileClose(pVBoxProc->hAs);
-                            pVBoxProc->hAs = NIL_RTFILE;
-                            CORELOG(("ReadProcMappings: successfully read in %u mappings\n", pVBoxProc->cMappings));
-                            return VINF_SUCCESS;
-                        }
-                        else
-                        {
-                            CORELOGREL(("ReadProcMappings: GetMemoryChunk failed %u\n", pVBoxProc->cMappings * sizeof(VBOXSOLMAPINFO)));
-                            rc = VERR_NO_MEMORY;
-                        }
-                    }
-                    else
-                    {
-                        CORELOGREL(("ReadProcMappings: Invalid mapping count %u\n", pVBoxProc->cMappings));
-                        rc = VERR_READ_ERROR;
-                    }
-                }
-                else
-                    CORELOGREL(("ReadProcMappings: FileReadNoIntr failed. rc=%Rrc cbMapFile=%u\n", rc, cbMapFile));
-            }
-            else
-            {
-                CORELOGREL(("ReadProcMappings: GetMemoryChunk failed. cbMapFile=%u\n", cbMapFile));
-                rc = VERR_NO_MEMORY;
-            }
-        }
-
-        RTFileClose(pVBoxProc->hAs);
-        pVBoxProc->hAs = NIL_RTFILE;
-    }
-    else
-        CORELOGREL(("ReadProcMappings: failed to open %s. rc=%Rrc\n", szPath, rc));
-
-    RTFileClose(hFile);
-    return rc;
-}
-
-
-/**
- * Reads the thread information for all threads in the process.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @remarks Should not be called before successful call to @see AllocMemoryArea()
- * @return VBox status code.
- */
-int ReadProcThreads(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    AssertReturn(pVBoxProc->pCurThreadCtx, VERR_NO_DATA);
-
-    /*
-     * Read the information for threads.
-     * Format: prheader_t + array of lwpsinfo_t's.
-     */
-    size_t cbInfoHdrAndData;
-    void *pvInfoHdr = NULL;
-    int rc = ProcReadFileInto(pVBoxCore, "lpsinfo", &pvInfoHdr, &cbInfoHdrAndData);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Read the status of threads.
-         * Format: prheader_t + array of lwpstatus_t's.
-         */
-        void *pvStatusHdr = NULL;
-        size_t cbStatusHdrAndData;
-        rc = ProcReadFileInto(pVBoxCore, "lstatus", &pvStatusHdr, &cbStatusHdrAndData);
-        if (RT_SUCCESS(rc))
-        {
-            prheader_t *pInfoHdr   = (prheader_t *)pvInfoHdr;
-            prheader_t *pStatusHdr = (prheader_t *)pvStatusHdr;
-            lwpstatus_t *pStatus   = (lwpstatus_t *)((uintptr_t)pStatusHdr + sizeof(prheader_t));
-            lwpsinfo_t *pInfo      = (lwpsinfo_t *)((uintptr_t)pInfoHdr + sizeof(prheader_t));
-            uint64_t cStatus       = pStatusHdr->pr_nent;
-            uint64_t cInfo         = pInfoHdr->pr_nent;
-
-            CORELOG(("ReadProcThreads: read info(%u) status(%u), threads:cInfo=%u cStatus=%u\n", cbInfoHdrAndData, cbStatusHdrAndData, cInfo, cStatus));
-
-            /*
-             * Minor sanity size check (remember sizeof lwpstatus_t & lwpsinfo_t is <= size in file per entry).
-             */
-            if (   (cbStatusHdrAndData - sizeof(prheader_t)) % pStatusHdr->pr_entsize == 0
-                && (cbInfoHdrAndData - sizeof(prheader_t)) % pInfoHdr->pr_entsize == 0)
-            {
-                /*
-                 * Make sure we have a matching lstatus entry for an lpsinfo entry unless
-                 * it is a zombie thread, in which case we will not have a matching lstatus entry.
-                 */
-                for (; cInfo != 0; cInfo--)
-                {
-                    if (pInfo->pr_sname != 'Z') /* zombie */
-                    {
-                        if (   cStatus == 0
-                            || pStatus->pr_lwpid != pInfo->pr_lwpid)
-                        {
-                            CORELOGREL(("ReadProcThreads: cStatus = %u pStatuslwpid=%d infolwpid=%d\n", cStatus, pStatus->pr_lwpid, pInfo->pr_lwpid));
-                            rc = VERR_INVALID_STATE;
-                            break;
-                        }
-                        pStatus = (lwpstatus_t *)((uintptr_t)pStatus + pStatusHdr->pr_entsize);
-                        cStatus--;
-                    }
-                    pInfo = (lwpsinfo_t *)((uintptr_t)pInfo + pInfoHdr->pr_entsize);
-                }
-
-                if (RT_SUCCESS(rc))
-                {
-                    /*
-                     * Threre can still be more lwpsinfo_t's than lwpstatus_t's, build the
-                     * lists accordingly.
-                     */
-                    pStatus = (lwpstatus_t *)((uintptr_t)pStatusHdr + sizeof(prheader_t));
-                    pInfo = (lwpsinfo_t *)((uintptr_t)pInfoHdr + sizeof(prheader_t));
-                    cInfo = pInfoHdr->pr_nent;
-                    cStatus = pInfoHdr->pr_nent;
-
-                    size_t cbThreadInfo = RT_MAX(cStatus, cInfo) * sizeof(VBOXSOLTHREADINFO);
-                    pVBoxProc->pThreadInfoHead = (PVBOXSOLTHREADINFO)GetMemoryChunk(pVBoxCore, cbThreadInfo);
-                    if (pVBoxProc->pThreadInfoHead)
-                    {
-                        PVBOXSOLTHREADINFO pCur = pVBoxProc->pThreadInfoHead;
-                        PVBOXSOLTHREADINFO pPrev = NULL;
-                        for (uint64_t i = 0; i < cInfo; i++, pCur++)
-                        {
-                            pCur->Info = *pInfo;
-                            if (   pInfo->pr_sname != 'Z'
-                                && pInfo->pr_lwpid == pStatus->pr_lwpid)
-                            {
-                                /*
-                                 * Adjust the context of the dumping thread to reflect the context
-                                 * when the core dump got initiated before whatever signal caused it.
-                                 */
-                                if (   pStatus          /* noid droid */
-                                    && pStatus->pr_lwpid == (id_t)pVBoxProc->hCurThread)
-                                {
-                                    AssertCompile(sizeof(pStatus->pr_reg) == sizeof(pVBoxProc->pCurThreadCtx->uc_mcontext.gregs));
-                                    AssertCompile(sizeof(pStatus->pr_fpreg) == sizeof(pVBoxProc->pCurThreadCtx->uc_mcontext.fpregs));
-                                    memcpy(&pStatus->pr_reg, &pVBoxProc->pCurThreadCtx->uc_mcontext.gregs, sizeof(pStatus->pr_reg));
-                                    memcpy(&pStatus->pr_fpreg, &pVBoxProc->pCurThreadCtx->uc_mcontext.fpregs, sizeof(pStatus->pr_fpreg));
-
-                                    AssertCompile(sizeof(pStatus->pr_lwphold) == sizeof(pVBoxProc->pCurThreadCtx->uc_sigmask));
-                                    memcpy(&pStatus->pr_lwphold, &pVBoxProc->pCurThreadCtx->uc_sigmask, sizeof(pStatus->pr_lwphold));
-                                    pStatus->pr_ustack = (uintptr_t)&pVBoxProc->pCurThreadCtx->uc_stack;
-
-                                    CORELOG(("ReadProcThreads: patched dumper thread context with pre-dump time context.\n"));
-                                }
-
-                                pCur->pStatus = pStatus;
-                                pStatus = (lwpstatus_t *)((uintptr_t)pStatus + pStatusHdr->pr_entsize);
-                            }
-                            else
-                            {
-                                CORELOGREL(("ReadProcThreads: missing status for lwp %d\n", pInfo->pr_lwpid));
-                                pCur->pStatus = NULL;
-                            }
-
-                            if (pPrev)
-                                pPrev->pNext = pCur;
-                            pPrev = pCur;
-                            pInfo = (lwpsinfo_t *)((uintptr_t)pInfo + pInfoHdr->pr_entsize);
-                        }
-                        if (pPrev)
-                            pPrev->pNext = NULL;
-
-                        CORELOG(("ReadProcThreads: successfully read %u threads.\n", cInfo));
-                        pVBoxProc->cThreads = cInfo;
-                        return VINF_SUCCESS;
-                    }
-                    else
-                    {
-                        CORELOGREL(("ReadProcThreads: GetMemoryChunk failed for %u bytes\n", cbThreadInfo));
-                        rc = VERR_NO_MEMORY;
-                    }
-                }
-                else
-                    CORELOGREL(("ReadProcThreads: Invalid state information for threads.\n", rc));
-            }
-            else
-            {
-                CORELOGREL(("ReadProcThreads: huh!? cbStatusHdrAndData=%u prheader_t=%u entsize=%u\n", cbStatusHdrAndData,
-                            sizeof(prheader_t), pStatusHdr->pr_entsize));
-                CORELOGREL(("ReadProcThreads: huh!? cbInfoHdrAndData=%u entsize=%u\n", cbInfoHdrAndData, pStatusHdr->pr_entsize));
-                rc = VERR_INVALID_STATE;
-            }
-        }
-        else
-            CORELOGREL(("ReadProcThreads: ReadFileNoIntr failed for \"lpsinfo\" rc=%Rrc\n", rc));
-    }
-    else
-        CORELOGREL(("ReadProcThreads: ReadFileNoIntr failed for \"lstatus\" rc=%Rrc\n", rc));
-    return rc;
-}
-
-
-/**
- * Reads miscellaneous information that is collected as part of a core file.
- * This may include platform name, zone name and other OS-specific information.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int ReadProcMiscInfo(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-
-#ifdef RT_OS_SOLARIS
-    /*
-     * Read the platform name, uname string and zone name.
-     */
-    int rc = sysinfo(SI_PLATFORM, pVBoxProc->szPlatform, sizeof(pVBoxProc->szPlatform));
-    if (rc == -1)
-    {
-        CORELOGREL(("ReadProcMiscInfo: sysinfo failed. rc=%d errno=%d\n", rc, errno));
-        return VERR_GENERAL_FAILURE;
-    }
-    pVBoxProc->szPlatform[sizeof(pVBoxProc->szPlatform) - 1] = '\0';
-
-    rc = uname(&pVBoxProc->UtsName);
-    if (rc == -1)
-    {
-        CORELOGREL(("ReadProcMiscInfo: uname failed. rc=%d errno=%d\n", rc, errno));
-        return VERR_GENERAL_FAILURE;
-    }
-
-    rc = getzonenamebyid(pVBoxProc->ProcInfo.pr_zoneid, pVBoxProc->szZoneName, sizeof(pVBoxProc->szZoneName));
-    if (rc < 0)
-    {
-        CORELOGREL(("ReadProcMiscInfo: getzonenamebyid failed. rc=%d errno=%d zoneid=%d\n", rc, errno, pVBoxProc->ProcInfo.pr_zoneid));
-        return VERR_GENERAL_FAILURE;
-    }
-    pVBoxProc->szZoneName[sizeof(pVBoxProc->szZoneName) - 1] = '\0';
-    rc = VINF_SUCCESS;
-
-#else
-# error Port Me!
-#endif
-    return rc;
-}
-
-
-/**
- * On Solaris use the old-style procfs interfaces but the core file still should have this
- * info. for backward and GDB compatibility, hence the need for this ugly function.
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param pInfo             Pointer to the old prpsinfo_t structure to update.
- */
-void GetOldProcessInfo(PVBOXCORE pVBoxCore, prpsinfo_t *pInfo)
-{
-    AssertReturnVoid(pVBoxCore);
-    AssertReturnVoid(pInfo);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    psinfo_t *pSrc = &pVBoxProc->ProcInfo;
-    memset(pInfo, 0, sizeof(prpsinfo_t));
-    pInfo->pr_state    = pSrc->pr_lwp.pr_state;
-    pInfo->pr_zomb     = (pInfo->pr_state == SZOMB);
-    RTStrCopy(pInfo->pr_clname, sizeof(pInfo->pr_clname), pSrc->pr_lwp.pr_clname);
-    RTStrCopy(pInfo->pr_fname, sizeof(pInfo->pr_fname), pSrc->pr_fname);
-    memcpy(&pInfo->pr_psargs, &pSrc->pr_psargs, sizeof(pInfo->pr_psargs));
-    pInfo->pr_nice     = pSrc->pr_lwp.pr_nice;
-    pInfo->pr_flag     = pSrc->pr_lwp.pr_flag;
-    pInfo->pr_uid      = pSrc->pr_uid;
-    pInfo->pr_gid      = pSrc->pr_gid;
-    pInfo->pr_pid      = pSrc->pr_pid;
-    pInfo->pr_ppid     = pSrc->pr_ppid;
-    pInfo->pr_pgrp     = pSrc->pr_pgid;
-    pInfo->pr_sid      = pSrc->pr_sid;
-    pInfo->pr_addr     = (caddr_t)pSrc->pr_addr;
-    pInfo->pr_size     = pSrc->pr_size;
-    pInfo->pr_rssize   = pSrc->pr_rssize;
-    pInfo->pr_wchan    = (caddr_t)pSrc->pr_lwp.pr_wchan;
-    pInfo->pr_start    = pSrc->pr_start;
-    pInfo->pr_time     = pSrc->pr_time;
-    pInfo->pr_pri      = pSrc->pr_lwp.pr_pri;
-    pInfo->pr_oldpri   = pSrc->pr_lwp.pr_oldpri;
-    pInfo->pr_cpu      = pSrc->pr_lwp.pr_cpu;
-    pInfo->pr_ottydev  = cmpdev(pSrc->pr_ttydev);
-    pInfo->pr_lttydev  = pSrc->pr_ttydev;
-    pInfo->pr_syscall  = pSrc->pr_lwp.pr_syscall;
-    pInfo->pr_ctime    = pSrc->pr_ctime;
-    pInfo->pr_bysize   = pSrc->pr_size * PAGESIZE;
-    pInfo->pr_byrssize = pSrc->pr_rssize * PAGESIZE;
-    pInfo->pr_argc     = pSrc->pr_argc;
-    pInfo->pr_argv     = (char **)pSrc->pr_argv;
-    pInfo->pr_envp     = (char **)pSrc->pr_envp;
-    pInfo->pr_wstat    = pSrc->pr_wstat;
-    pInfo->pr_pctcpu   = pSrc->pr_pctcpu;
-    pInfo->pr_pctmem   = pSrc->pr_pctmem;
-    pInfo->pr_euid     = pSrc->pr_euid;
-    pInfo->pr_egid     = pSrc->pr_egid;
-    pInfo->pr_aslwpid  = 0;
-    pInfo->pr_dmodel   = pSrc->pr_dmodel;
-}
-
-
-/**
- * On Solaris use the old-style procfs interfaces but the core file still should have this
- * info. for backward and GDB compatibility, hence the need for this ugly function.
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param pInfo             Pointer to the thread info.
- * @param pStatus           Pointer to the thread status.
- * @param pDst              Pointer to the old-style status structure to update.
- *
- */
-void GetOldProcessStatus(PVBOXCORE pVBoxCore, lwpsinfo_t *pInfo, lwpstatus_t *pStatus, prstatus_t *pDst)
-{
-    AssertReturnVoid(pVBoxCore);
-    AssertReturnVoid(pInfo);
-    AssertReturnVoid(pStatus);
-    AssertReturnVoid(pDst);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    memset(pDst, 0, sizeof(prstatus_t));
-    if (pStatus->pr_flags & PR_STOPPED)
-        pDst->pr_flags = 0x0001;
-    if (pStatus->pr_flags & PR_ISTOP)
-        pDst->pr_flags = 0x0002;
-    if (pStatus->pr_flags & PR_DSTOP)
-        pDst->pr_flags = 0x0004;
-    if (pStatus->pr_flags & PR_ASLEEP)
-        pDst->pr_flags = 0x0008;
-    if (pStatus->pr_flags & PR_FORK)
-        pDst->pr_flags = 0x0010;
-    if (pStatus->pr_flags & PR_RLC)
-        pDst->pr_flags = 0x0020;
-    /* PR_PTRACE is never set */
-    if (pStatus->pr_flags & PR_PCINVAL)
-        pDst->pr_flags = 0x0080;
-    if (pStatus->pr_flags & PR_ISSYS)
-        pDst->pr_flags = 0x0100;
-    if (pStatus->pr_flags & PR_STEP)
-        pDst->pr_flags = 0x0200;
-    if (pStatus->pr_flags & PR_KLC)
-        pDst->pr_flags = 0x0400;
-    if (pStatus->pr_flags & PR_ASYNC)
-        pDst->pr_flags = 0x0800;
-    if (pStatus->pr_flags & PR_PTRACE)
-        pDst->pr_flags = 0x1000;
-    if (pStatus->pr_flags & PR_MSACCT)
-        pDst->pr_flags = 0x2000;
-    if (pStatus->pr_flags & PR_BPTADJ)
-        pDst->pr_flags = 0x4000;
-    if (pStatus->pr_flags & PR_ASLWP)
-        pDst->pr_flags = 0x8000;
-
-    pDst->pr_who        = pStatus->pr_lwpid;
-    pDst->pr_why        = pStatus->pr_why;
-    pDst->pr_what       = pStatus->pr_what;
-    pDst->pr_info       = pStatus->pr_info;
-    pDst->pr_cursig     = pStatus->pr_cursig;
-    pDst->pr_sighold    = pStatus->pr_lwphold;
-    pDst->pr_altstack   = pStatus->pr_altstack;
-    pDst->pr_action     = pStatus->pr_action;
-    pDst->pr_syscall    = pStatus->pr_syscall;
-    pDst->pr_nsysarg    = pStatus->pr_nsysarg;
-    pDst->pr_lwppend    = pStatus->pr_lwppend;
-    pDst->pr_oldcontext = (ucontext_t *)pStatus->pr_oldcontext;
-    memcpy(pDst->pr_reg, pStatus->pr_reg, sizeof(pDst->pr_reg));
-    memcpy(pDst->pr_sysarg, pStatus->pr_sysarg, sizeof(pDst->pr_sysarg));
-    RTStrCopy(pDst->pr_clname, sizeof(pDst->pr_clname), pStatus->pr_clname);
-
-    pDst->pr_nlwp       = pVBoxProc->ProcStatus.pr_nlwp;
-    pDst->pr_sigpend    = pVBoxProc->ProcStatus.pr_sigpend;
-    pDst->pr_pid        = pVBoxProc->ProcStatus.pr_pid;
-    pDst->pr_ppid       = pVBoxProc->ProcStatus.pr_ppid;
-    pDst->pr_pgrp       = pVBoxProc->ProcStatus.pr_pgid;
-    pDst->pr_sid        = pVBoxProc->ProcStatus.pr_sid;
-    pDst->pr_utime      = pVBoxProc->ProcStatus.pr_utime;
-    pDst->pr_stime      = pVBoxProc->ProcStatus.pr_stime;
-    pDst->pr_cutime     = pVBoxProc->ProcStatus.pr_cutime;
-    pDst->pr_cstime     = pVBoxProc->ProcStatus.pr_cstime;
-    pDst->pr_brkbase    = (caddr_t)pVBoxProc->ProcStatus.pr_brkbase;
-    pDst->pr_brksize    = pVBoxProc->ProcStatus.pr_brksize;
-    pDst->pr_stkbase    = (caddr_t)pVBoxProc->ProcStatus.pr_stkbase;
-    pDst->pr_stksize    = pVBoxProc->ProcStatus.pr_stksize;
-
-    pDst->pr_processor  = (short)pInfo->pr_onpro;
-    pDst->pr_bind       = (short)pInfo->pr_bindpro;
-    pDst->pr_instr      = pStatus->pr_instr;
-}
-
-
-/**
- * Count the number of sections which will be dumped into the core file.
- *
- * @param pVBoxCore             Pointer to the core object.
- *
- * @return Number of sections for the core file.
- */
-uint32_t CountSections(PVBOXCORE pVBoxCore)
-{
-    /* @todo sections */
-    NOREF(pVBoxCore);
-    return 0;
-}
-
-
-/**
- * Resume all threads of this process.
- *
- * @param pVBoxProc         Pointer to the VBox process.
- *
- * @return VBox error code.
- */
-int ResumeAllThreads(PVBOXPROCESS pVBoxProc)
-{
-    AssertReturn(pVBoxProc, VERR_INVALID_POINTER);
-
-    char szCurThread[128];
-    char szPath[PATH_MAX];
-    PRTDIR pDir = NULL;
-
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/lwp", (int)pVBoxProc->Process);
-    RTStrPrintf(szCurThread, sizeof(szCurThread), "%d", (int)pVBoxProc->hCurThread);
-
-    int32_t cRunningThreads = 0;
-    int rc = RTDirOpen(&pDir, szPath);
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Loop through all our threads & resume them.
-         */
-        RTDIRENTRY DirEntry;
-        while (RT_SUCCESS(RTDirRead(pDir, &DirEntry, NULL)))
-        {
-            if (   !strcmp(DirEntry.szName, ".")
-                || !strcmp(DirEntry.szName, ".."))
-                continue;
-
-            if ( !strcmp(DirEntry.szName, szCurThread))
-                continue;
-
-            int32_t ThreadId = RTStrToInt32(DirEntry.szName);
-            _lwp_continue((lwpid_t)ThreadId);
-            ++cRunningThreads;
-        }
-
-        CORELOG(("ResumeAllThreads: resumed %d threads\n", cRunningThreads));
-        RTDirClose(pDir);
-    }
-    else
-    {
-        CORELOGREL(("ResumeAllThreads: Failed to open %s\n", szPath));
-        rc = VERR_READ_ERROR;
-    }
-
-    return rc;
-}
-
-
-/**
- * Stop all running threads of this process. Before dumping any
- * core we need to make sure the process is quiesced.
- *
- * @param pVBoxProc         Pointer to the VBox process.
- *
- * @return VBox error code.
- */
-int SuspendAllThreads(PVBOXPROCESS pVBoxProc)
-{
-    char szCurThread[128];
-    char szPath[PATH_MAX];
-    PRTDIR pDir = NULL;
-
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/lwp", (int)pVBoxProc->Process);
-    RTStrPrintf(szCurThread, sizeof(szCurThread), "%d", (int)pVBoxProc->hCurThread);
-
-    int rc = -1;
-    uint32_t cThreads = 0;
-    uint16_t cTries = 0;
-    for (cTries = 0; cTries < 10; cTries++)
-    {
-        uint32_t cRunningThreads = 0;
-        rc = RTDirOpen(&pDir, szPath);
-        if (RT_SUCCESS(rc))
-        {
-            /*
-             * Loop through all our threads & suspend them, multiple calls to _lwp_suspend() are okay.
-             */
-            RTDIRENTRY DirEntry;
-            while (RT_SUCCESS(RTDirRead(pDir, &DirEntry, NULL)))
-            {
-                if (   !strcmp(DirEntry.szName, ".")
-                    || !strcmp(DirEntry.szName, ".."))
-                    continue;
-
-                if ( !strcmp(DirEntry.szName, szCurThread))
-                    continue;
-
-                int32_t ThreadId = RTStrToInt32(DirEntry.szName);
-                _lwp_suspend((lwpid_t)ThreadId);
-                ++cRunningThreads;
-            }
-
-            if (cTries > 5 && cThreads == cRunningThreads)
-            {
-                rc = VINF_SUCCESS;
-                break;
-            }
-            cThreads = cRunningThreads;
-            RTDirClose(pDir);
-        }
-        else
-        {
-            CORELOGREL(("SuspendAllThreads: Failed to open %s cTries=%d\n", szPath, cTries));
-            rc = VERR_READ_ERROR;
-            break;
-        }
-    }
-
-    if (RT_SUCCESS(rc))
-        CORELOG(("Stopped %u threads successfully with %u tries\n", cThreads, cTries));
-
-    return rc;
-}
-
-
-/**
- * Returns size of an ELF NOTE header given the size of data the NOTE section will contain.
- *
- * @param cb                Size of the data.
- *
- * @return Size of data actually used for NOTE header and section.
- */
-inline size_t ElfNoteHeaderSize(size_t cb)
-{
-    return sizeof(ELFNOTEHDR) + RT_ALIGN_Z(cb, 4);
-}
-
-
-/**
- * Write an ELF NOTE header into the core file.
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param Type              Type of this NOTE section.
- * @param pcv               Opaque pointer to the data, if NULL only computes size.
- * @param cb                Size of the data.
- *
- * @return VBox status code.
- */
-int ElfWriteNoteHeader(PVBOXCORE pVBoxCore, uint_t Type, const void *pcv, size_t cb)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-    AssertReturn(pcv, VERR_INVALID_POINTER);
-    AssertReturn(cb > 0, VERR_NO_DATA);
-    AssertReturn(pVBoxCore->pfnWriter, VERR_WRITE_ERROR);
-    AssertReturn(pVBoxCore->hCoreFile, VERR_INVALID_HANDLE);
-
-    int rc = VERR_GENERAL_FAILURE;
-#ifdef RT_OS_SOLARIS
-    ELFNOTEHDR ElfNoteHdr;
-    RT_ZERO(ElfNoteHdr);
-    ElfNoteHdr.achName[0] = 'C';
-    ElfNoteHdr.achName[1] = 'O';
-    ElfNoteHdr.achName[2] = 'R';
-    ElfNoteHdr.achName[3] = 'E';
-    ElfNoteHdr.Hdr.n_namesz = 5;
-    ElfNoteHdr.Hdr.n_type = Type;
-    ElfNoteHdr.Hdr.n_descsz = RT_ALIGN_Z(cb, 4);
-
-    /*
-     * Write note header and description.
-     */
-    rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &ElfNoteHdr, sizeof(ElfNoteHdr));
-    if (RT_SUCCESS(rc))
-       rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, pcv, ElfNoteHdr.Hdr.n_descsz);
-
-    if (RT_FAILURE(rc))
-        CORELOGREL(("ElfWriteNote: pfnWriter failed. Type=%d rc=%Rrc\n", Type, rc));
-#else
-#error Port Me!
-#endif
-    return rc;
-}
-
-
-/**
- * Computes the size of NOTE section for the given core type.
- * Solaris has two types of program header information (new and old).
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param enmType           Type of core file information required.
- *
- * @return Size of NOTE section.
- */
-size_t ElfNoteSectionSize(PVBOXCORE pVBoxCore, VBOXSOLCORETYPE enmType)
-{
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    size_t cb = 0;
-    switch (enmType)
-    {
-        case enmOldEra:
-        {
-            cb += ElfNoteHeaderSize(sizeof(prpsinfo_t));
-            cb += ElfNoteHeaderSize(pVBoxProc->cAuxVecs * sizeof(auxv_t));
-            cb += ElfNoteHeaderSize(strlen(pVBoxProc->szPlatform));
-
-            PVBOXSOLTHREADINFO pThreadInfo = pVBoxProc->pThreadInfoHead;
-            while (pThreadInfo)
-            {
-                if (pThreadInfo->pStatus)
-                {
-                    cb += ElfNoteHeaderSize(sizeof(prstatus_t));
-                    cb += ElfNoteHeaderSize(sizeof(prfpregset_t));
-                }
-                pThreadInfo = pThreadInfo->pNext;
-            }
-
-            break;
-        }
-
-        case enmNewEra:
-        {
-            cb += ElfNoteHeaderSize(sizeof(psinfo_t));
-            cb += ElfNoteHeaderSize(sizeof(pstatus_t));
-            cb += ElfNoteHeaderSize(pVBoxProc->cAuxVecs * sizeof(auxv_t));
-            cb += ElfNoteHeaderSize(strlen(pVBoxProc->szPlatform) + 1);
-            cb += ElfNoteHeaderSize(sizeof(struct utsname));
-            cb += ElfNoteHeaderSize(sizeof(core_content_t));
-            cb += ElfNoteHeaderSize(pVBoxProc->cbCred);
-
-            if (pVBoxProc->pPriv)
-                cb += ElfNoteHeaderSize(PRIV_PRPRIV_SIZE(pVBoxProc->pPriv));   /* Ought to be same as cbPriv!? */
-
-            if (pVBoxProc->pcPrivImpl)
-                cb += ElfNoteHeaderSize(PRIV_IMPL_INFO_SIZE(pVBoxProc->pcPrivImpl));
-
-            cb += ElfNoteHeaderSize(strlen(pVBoxProc->szZoneName) + 1);
-            if (pVBoxProc->cbLdt > 0)
-                cb += ElfNoteHeaderSize(pVBoxProc->cbLdt);
-
-            PVBOXSOLTHREADINFO pThreadInfo = pVBoxProc->pThreadInfoHead;
-            while (pThreadInfo)
-            {
-                cb += ElfNoteHeaderSize(sizeof(lwpsinfo_t));
-                if (pThreadInfo->pStatus)
-                    cb += ElfNoteHeaderSize(sizeof(lwpstatus_t));
-
-                pThreadInfo = pThreadInfo->pNext;
-            }
-
-            break;
-        }
-
-        default:
-        {
-            CORELOGREL(("ElfNoteSectionSize: Unknown segment era %d\n", enmType));
-            break;
-        }
-    }
-
-    return cb;
-}
-
-
-/**
- * Write the note section for the given era into the core file.
- * Solaris has two types of program  header information (new and old).
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param enmType           Type of core file information required.
- *
- * @return VBox status code.
- */
-int ElfWriteNoteSection(PVBOXCORE pVBoxCore, VBOXSOLCORETYPE enmType)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    int rc = VERR_GENERAL_FAILURE;
-
-#ifdef RT_OS_SOLARIS
-
-    typedef int (*PFNELFWRITENOTEHDR)(PVBOXCORE pVBoxCore, uint_t, const void *pcv, size_t cb);
-    typedef struct ELFWRITENOTE
-    {
-        const char        *pszType;
-        uint_t             Type;
-        const void        *pcv;
-        size_t             cb;
-    } ELFWRITENOTE;
-
-    switch (enmType)
-    {
-        case enmOldEra:
-        {
-            ELFWRITENOTE aElfNotes[] =
-            {
-                { "NT_PRPSINFO", NT_PRPSINFO, &pVBoxProc->ProcInfoOld,  sizeof(prpsinfo_t) },
-                { "NT_AUXV",     NT_AUXV,      pVBoxProc->pAuxVecs,      pVBoxProc->cAuxVecs * sizeof(auxv_t) },
-                { "NT_PLATFORM", NT_PLATFORM,  pVBoxProc->szPlatform,    strlen(pVBoxProc->szPlatform) + 1 }
-            };
-
-            for (unsigned i = 0; i < RT_ELEMENTS(aElfNotes); i++)
-            {
-                rc = ElfWriteNoteHeader(pVBoxCore, aElfNotes[i].Type, aElfNotes[i].pcv, aElfNotes[i].cb);
-                if (RT_FAILURE(rc))
-                {
-                    CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n", aElfNotes[i].pszType, rc));
-                    break;
-                }
-            }
-
-            /*
-             * Write old-style thread info., they contain nothing about zombies,
-             * so we just skip if there is no status information for them.
-             */
-            PVBOXSOLTHREADINFO pThreadInfo = pVBoxProc->pThreadInfoHead;
-            for (; pThreadInfo; pThreadInfo = pThreadInfo->pNext)
-            {
-                if (!pThreadInfo->pStatus)
-                    continue;
-
-                prstatus_t OldProcessStatus;
-                GetOldProcessStatus(pVBoxCore, &pThreadInfo->Info, pThreadInfo->pStatus, &OldProcessStatus);
-                rc = ElfWriteNoteHeader(pVBoxCore, NT_PRSTATUS, &OldProcessStatus, sizeof(prstatus_t));
-                if (RT_SUCCESS(rc))
-                {
-                    rc = ElfWriteNoteHeader(pVBoxCore, NT_PRFPREG, &pThreadInfo->pStatus->pr_fpreg, sizeof(prfpregset_t));
-                    if (RT_FAILURE(rc))
-                    {
-                        CORELOGREL(("ElfWriteSegment: ElfWriteNote failed for NT_PRFPREF. rc=%Rrc\n", rc));
-                        break;
-                    }
-                }
-                else
-                {
-                    CORELOGREL(("ElfWriteSegment: ElfWriteNote failed for NT_PRSTATUS. rc=%Rrc\n", rc));
-                    break;
-                }
-            }
-            break;
-        }
-
-        case enmNewEra:
-        {
-            ELFWRITENOTE aElfNotes[] =
-            {
-                { "NT_PSINFO",     NT_PSINFO,     &pVBoxProc->ProcInfo,     sizeof(psinfo_t) },
-                { "NT_PSTATUS",    NT_PSTATUS,    &pVBoxProc->ProcStatus,   sizeof(pstatus_t) },
-                { "NT_AUXV",       NT_AUXV,        pVBoxProc->pAuxVecs,     pVBoxProc->cAuxVecs * sizeof(auxv_t) },
-                { "NT_PLATFORM",   NT_PLATFORM,    pVBoxProc->szPlatform,   strlen(pVBoxProc->szPlatform) + 1 },
-                { "NT_UTSNAME",    NT_UTSNAME,    &pVBoxProc->UtsName,      sizeof(struct utsname) },
-                { "NT_CONTENT",    NT_CONTENT,    &pVBoxProc->CoreContent,  sizeof(core_content_t) },
-                { "NT_PRCRED",     NT_PRCRED,      pVBoxProc->pvCred,       pVBoxProc->cbCred },
-                { "NT_PRPRIV",     NT_PRPRIV,      pVBoxProc->pPriv,        PRIV_PRPRIV_SIZE(pVBoxProc->pPriv) },
-                { "NT_PRPRIVINFO", NT_PRPRIVINFO,  pVBoxProc->pcPrivImpl,   PRIV_IMPL_INFO_SIZE(pVBoxProc->pcPrivImpl) },
-                { "NT_ZONENAME",   NT_ZONENAME,    pVBoxProc->szZoneName,   strlen(pVBoxProc->szZoneName) + 1 }
-            };
-
-            for (unsigned i = 0; i < RT_ELEMENTS(aElfNotes); i++)
-            {
-                rc = ElfWriteNoteHeader(pVBoxCore, aElfNotes[i].Type, aElfNotes[i].pcv, aElfNotes[i].cb);
-                if (RT_FAILURE(rc))
-                {
-                    CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader failed for %s. rc=%Rrc\n", aElfNotes[i].pszType, rc));
-                    break;
-                }
-            }
-
-            /*
-             * Write new-style thread info., missing lwpstatus_t indicates it's a zombie thread
-             * we only dump the lwpsinfo_t in that case.
-             */
-            PVBOXSOLTHREADINFO pThreadInfo = pVBoxProc->pThreadInfoHead;
-            for (; pThreadInfo; pThreadInfo = pThreadInfo->pNext)
-            {
-                rc = ElfWriteNoteHeader(pVBoxCore, NT_LWPSINFO, &pThreadInfo->Info, sizeof(lwpsinfo_t));
-                if (RT_FAILURE(rc))
-                {
-                    CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSINFO failed. rc=%Rrc\n", rc));
-                    break;
-                }
-
-                if (pThreadInfo->pStatus)
-                {
-                    rc = ElfWriteNoteHeader(pVBoxCore, NT_LWPSTATUS, pThreadInfo->pStatus, sizeof(lwpstatus_t));
-                    if (RT_FAILURE(rc))
-                    {
-                        CORELOGREL(("ElfWriteNoteSection: ElfWriteNoteHeader for NT_LWPSTATUS failed. rc=%Rrc\n", rc));
-                        break;
-                    }
-                }
-            }
-            break;
-        }
-
-        default:
-        {
-            CORELOGREL(("ElfWriteNoteSection: Invalid type %d\n", enmType));
-            rc = VERR_GENERAL_FAILURE;
-            break;
-        }
-    }
-#else
-# error Port Me!
-#endif
-    return rc;
-}
-
-
-/**
- * Write mappings into the core file.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int ElfWriteMappings(PVBOXCORE pVBoxCore)
-{
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-
-    int rc = VERR_GENERAL_FAILURE;
-    PVBOXSOLMAPINFO pMapInfo = pVBoxProc->pMapInfoHead;
-    while (pMapInfo)
-    {
-        if (!pMapInfo->fError)
-        {
-            uint64_t k = 0;
-            char achBuf[PAGE_SIZE];
-            while (k < pMapInfo->pMap.pr_size)
-            {
-                size_t cb = RT_MIN(sizeof(achBuf), pMapInfo->pMap.pr_size - k);
-                int rc2 = ReadProcAddrSpace(pVBoxProc, pMapInfo->pMap.pr_vaddr + k, &achBuf, cb);
-                if (RT_FAILURE(rc2))
-                {
-                    CORELOGREL(("ElfWriteMappings: Failed to read mapping, can't recover. Bye. rc=%Rrc\n", rc));
-                    return VERR_INVALID_STATE;
-                }
-
-                rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, achBuf, sizeof(achBuf));
-                if (RT_FAILURE(rc))
-                {
-                    CORELOGREL(("ElfWriteMappings: pfnWriter failed. rc=%Rrc\n", rc));
-                    return rc;
-                }
-                k += cb;
-            }
-        }
-        else
-        {
-            char achBuf[RT_ALIGN_Z(sizeof(int), 8)];
-            RT_ZERO(achBuf);
-            memcpy(achBuf, &pMapInfo->fError, sizeof(pMapInfo->fError));
-            if (sizeof(achBuf) != pMapInfo->pMap.pr_size)
-                CORELOGREL(("ElfWriteMappings: Huh!? something is wrong!\n"));
-            rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &achBuf, sizeof(achBuf));
-            if (RT_FAILURE(rc))
-            {
-                CORELOGREL(("ElfWriteMappings: pfnWriter(2) failed. rc=%Rrc\n", rc));
-                return rc;
-            }
-        }
-
-        pMapInfo = pMapInfo->pNext;
-    }
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Write program headers for all mappings into the core file.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int ElfWriteMappingHeaders(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    Phdr ProgHdr;
-    RT_ZERO(ProgHdr);
-    ProgHdr.p_type = PT_LOAD;
-
-    int rc = VERR_GENERAL_FAILURE;
-    PVBOXSOLMAPINFO pMapInfo = pVBoxProc->pMapInfoHead;
-    while (pMapInfo)
-    {
-        ProgHdr.p_vaddr  = pMapInfo->pMap.pr_vaddr;     /* Virtual address of this mapping in the process address space */
-        ProgHdr.p_offset = pVBoxCore->offWrite;         /* Where this mapping is located in the core file */
-        ProgHdr.p_memsz  = pMapInfo->pMap.pr_size;      /* Size of the memory image of the mapping */
-        ProgHdr.p_filesz = pMapInfo->pMap.pr_size;      /* Size of the file image of the mapping */
-
-        ProgHdr.p_flags = 0;                            /* Reset fields in a loop when needed! */
-        if (pMapInfo->pMap.pr_mflags & MA_READ)
-            ProgHdr.p_flags |= PF_R;
-        if (pMapInfo->pMap.pr_mflags & MA_WRITE)
-            ProgHdr.p_flags |= PF_W;
-        if (pMapInfo->pMap.pr_mflags & MA_EXEC)
-            ProgHdr.p_flags |= PF_X;
-
-        if (pMapInfo->fError)
-            ProgHdr.p_flags |= PF_SUNW_FAILURE;
-
-        rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &ProgHdr, sizeof(ProgHdr));
-        if (RT_FAILURE(rc))
-        {
-            CORELOGREL(("ElfWriteMappingHeaders: pfnWriter failed. rc=%Rrc\n", rc));
-            return rc;
-        }
-
-        pVBoxCore->offWrite += ProgHdr.p_filesz;
-        pMapInfo = pMapInfo->pNext;
-    }
-    return rc;
-}
-
-
-/**
- * Write a prepared core file using a user-passed in writer function, requires all threads
- * to be in suspended state (i.e. called after CreateCore).
- *
- * @param pVBoxCore         Pointer to the core object.
- * @param pfnWriter         Pointer to the writer function to override default writer (NULL uses default).
- *
- * @remarks Resumes all suspended threads, unless it's an invalid core.
- * @return VBox status.
- */
-int WriteCore(PVBOXCORE pVBoxCore, PFNCOREWRITER pfnWriter)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-
-    if (!pVBoxCore->fIsValid)
-        return VERR_INVALID_STATE;
-
-    if (pfnWriter)
-        pVBoxCore->pfnWriter = pfnWriter;
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    char szPath[PATH_MAX];
-
-    /*
-     * Open the process address space file.
-     */
-    RTStrPrintf(szPath, sizeof(szPath), "/proc/%d/as", (int)pVBoxProc->Process);
-    int rc = RTFileOpen(&pVBoxProc->hAs, szPath, RTFILE_O_OPEN | RTFILE_O_READ);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: Failed to open address space, %s. rc=%Rrc\n", szPath, rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Create the core file.
-     */
-    RTStrPrintf(szPath, sizeof(szPath), "/export/home/ram/vbox/out/solaris.amd64/release/bin/%s", pVBoxCore->szCorePath, pVBoxCore->VBoxProc.Process); /* @todo fix this */
-    rc = RTFileOpen(&pVBoxCore->hCoreFile, szPath, RTFILE_O_OPEN_CREATE | RTFILE_O_TRUNCATE | RTFILE_O_READWRITE | RTFILE_O_DENY_ALL);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: failed to open %s. rc=%Rrc\n", szPath, rc));
-        goto WriteCoreDone;
-    }
-
-    pVBoxCore->offWrite = 0;
-    uint32_t cProgHdrs  = pVBoxProc->cMappings + 2; /* two PT_NOTE program headers (old, new style) */
-    uint32_t cSecHdrs   = CountSections(pVBoxCore);
-
-    /*
-     * Write the ELF header.
-     */
-    Ehdr ElfHdr;
-    RT_ZERO(ElfHdr);
-    ElfHdr.e_ident[EI_MAG0]  = ELFMAG0;
-    ElfHdr.e_ident[EI_MAG1]  = ELFMAG1;
-    ElfHdr.e_ident[EI_MAG2]  = ELFMAG2;
-    ElfHdr.e_ident[EI_MAG3]  = ELFMAG3;
-    ElfHdr.e_ident[EI_DATA]  = IsBigEndian() ? ELFDATA2MSB : ELFDATA2LSB;
-    ElfHdr.e_type            = ET_CORE;
-    ElfHdr.e_version         = EV_CURRENT;
-#ifdef RT_ARCH_AMD64
-    ElfHdr.e_machine         = EM_AMD64;
-    ElfHdr.e_ident[EI_CLASS] = ELFCLASS64;
-#else
-    ElfHdr.e_machine         = EM_386;
-    ElfHdr.e_ident[EI_CLASS] = ELFCLASS32;
-#endif
-    if (cProgHdrs >= PN_XNUM)
-        ElfHdr.e_phnum       = PN_XNUM;
-    else
-        ElfHdr.e_phnum       = cProgHdrs;
-    ElfHdr.e_ehsize          = sizeof(ElfHdr);
-    ElfHdr.e_phoff           = sizeof(ElfHdr);
-    ElfHdr.e_phentsize       = sizeof(Phdr);
-    ElfHdr.e_shentsize       = sizeof(Shdr);
-    rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &ElfHdr, sizeof(ElfHdr));
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: pfnWriter failed writing ELF header. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Setup program header.
-     */
-    Phdr ProgHdr;
-    RT_ZERO(ProgHdr);
-    ProgHdr.p_type = PT_NOTE;
-    ProgHdr.p_flags = PF_R;
-
-    /*
-     * Write old-style NOTE program header.
-     */
-    pVBoxCore->offWrite += sizeof(ElfHdr) + cProgHdrs * sizeof(ProgHdr);
-    ProgHdr.p_offset = pVBoxCore->offWrite;
-    ProgHdr.p_filesz = ElfNoteSectionSize(pVBoxCore, enmOldEra);
-    rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &ProgHdr, sizeof(ProgHdr));
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: pfnWriter failed writing old-style ELF program Header. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Write new-style NOTE program header.
-     */
-    pVBoxCore->offWrite += ProgHdr.p_filesz;
-    ProgHdr.p_offset = pVBoxCore->offWrite;
-    ProgHdr.p_filesz = ElfNoteSectionSize(pVBoxCore, enmNewEra);
-    rc = pVBoxCore->pfnWriter(pVBoxCore->hCoreFile, &ProgHdr, sizeof(ProgHdr));
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: pfnWriter failed writing new-style ELF program header. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Write program headers per mapping.
-     */
-    pVBoxCore->offWrite += ProgHdr.p_filesz;
-    rc = ElfWriteMappingHeaders(pVBoxCore);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("Write: ElfWriteMappings failed. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Write old-style note section.
-     */
-    rc = ElfWriteNoteSection(pVBoxCore, enmOldEra);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: ElfWriteNoteSection old-style failed. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Write new-style section.
-     */
-    rc = ElfWriteNoteSection(pVBoxCore, enmNewEra);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: ElfWriteNoteSection new-style failed. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-    /*
-     * Write all mappings.
-     */
-    rc = ElfWriteMappings(pVBoxCore);
-    if (RT_FAILURE(rc))
-    {
-        CORELOGREL(("WriteCore: ElfWriteMappings failed. rc=%Rrc\n", rc));
-        goto WriteCoreDone;
-    }
-
-
-WriteCoreDone:
-    if (pVBoxCore->hCoreFile != NIL_RTFILE)
-    {
-        RTFileClose(pVBoxCore->hCoreFile);
-        pVBoxCore->hCoreFile = NIL_RTFILE;
-    }
-
-    if (pVBoxProc->hAs != NIL_RTFILE)
-    {
-        RTFileClose(pVBoxProc->hAs);
-        pVBoxProc->hAs = NIL_RTFILE;
-    }
-
-    ResumeAllThreads(pVBoxProc);
-    return rc;
-}
-
-
-/**
- * Takes a process snapshot into a passed-in core object. It has the side-effect of halting
- * all threads which can lead to things like spurious wakeups of threads (if and when threads
- * are ultimately resumed en-masse) already suspended while calling this function.
- *
- * @param pVBoxCore         Pointer to a core object.
- * @param pContext          Pointer to the caller context thread.
- *
- * @remarks Halts all threads.
- * @return VBox status code.
- */
-int CreateCore(PVBOXCORE pVBoxCore, ucontext_t *pContext)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-    AssertReturn(pContext, VERR_INVALID_POINTER);
-
-    /*
-     * Initialize core structures.
-     */
-    memset(pVBoxCore, 0, sizeof(VBOXCORE));
-    pVBoxCore->pfnReader = &ReadFileNoIntr;
-    pVBoxCore->pfnWriter = &WriteFileNoIntr;
-    pVBoxCore->fIsValid  = false;
-    pVBoxCore->hCoreFile = NIL_RTFILE;
-
-    PVBOXPROCESS pVBoxProc = &pVBoxCore->VBoxProc;
-    pVBoxProc->Process        = RTProcSelf();
-    pVBoxProc->hCurThread     = _lwp_self(); /* thr_self() */
-    pVBoxProc->hAs            = NIL_RTFILE;
-    pVBoxProc->pCurThreadCtx  = pContext;
-    pVBoxProc->CoreContent    = CC_CONTENT_DEFAULT;
-
-    RTProcGetExecutableName(pVBoxProc->szExecPath, sizeof(pVBoxProc->szExecPath));  /* this gets full path not just name */
-    pVBoxProc->pszExecName = RTPathFilename(pVBoxProc->szExecPath);
-    RTStrPrintf(pVBoxCore->szCorePath, sizeof(pVBoxCore->szCorePath), "core.vb.%s.%d", pVBoxProc->pszExecName, (int)pVBoxProc->Process);
-
-    CORELOG(("tstRTCoreDump: Taking Core %s from Thread %d\n", pVBoxCore->szCorePath, (int)pVBoxProc->hCurThread));
-
-    /*
-     * Quiesce the process.
-     */
-    int rc = SuspendAllThreads(pVBoxProc);
-    if (RT_SUCCESS(rc))
-    {
-        rc = ReadProcInfo(pVBoxCore);
-        if (RT_SUCCESS(rc))
-        {
-            GetOldProcessInfo(pVBoxCore, &pVBoxProc->ProcInfoOld);
-            if (IsProcArchNative(pVBoxProc))
-            {
-                /*
-                 * Read process status, information such as number of active LWPs will be invalid since we just quiesced the process.
-                 */
-                rc = ReadProcStatus(pVBoxCore);
-                if (RT_SUCCESS(rc))
-                {
-                    rc = AllocMemoryArea(pVBoxCore);
-                    if (RT_SUCCESS(rc))
-                    {
-                        struct COREACCUMULATOR
-                        {
-                            const char        *pszName;
-                            PFNCOREACCUMULATOR pfnAcc;
-                            bool               fOptional;
-                        } aAccumulators[] =
-                        {
-                            { "ReadProcLdt",      &ReadProcLdt,      false },
-                            { "ReadProcCred",     &ReadProcCred,     false },
-                            { "ReadProcPriv",     &ReadProcPriv,     false },
-                            { "ReadProcAuxVecs",  &ReadProcAuxVecs,  false },
-                            { "ReadProcMappings", &ReadProcMappings, false },
-                            { "ReadProcThreads",  &ReadProcThreads,  false },
-                            { "ReadProcMiscInfo", &ReadProcMiscInfo, false }
-                        };
-
-                        for (unsigned i = 0; i < RT_ELEMENTS(aAccumulators); i++)
-                        {
-                            rc = aAccumulators[i].pfnAcc(pVBoxCore);
-                            if (RT_FAILURE(rc))
-                            {
-                                CORELOGREL(("DumpCore: %s failed. rc=%Rrc\n", aAccumulators[i].pszName, rc));
-                                if (!aAccumulators[i].fOptional)
-                                    break;
-                            }
-                        }
-
-                        if (RT_SUCCESS(rc))
-                        {
-                            pVBoxCore->fIsValid = true;
-                            return VINF_SUCCESS;
-                        }
-
-                        FreeMemoryArea(pVBoxCore);
-                    }
-                    else
-                        CORELOGREL(("DumpCore: AllocMemoryArea failed. rc=%Rrc\n", rc));
-                }
-                else
-                    CORELOGREL(("DumpCore: ReadProcStatus failed. rc=%Rrc\n", rc));
-            }
-            else
-            {
-                CORELOGREL(("DumpCore: IsProcArchNative failed.\n"));
-                rc = VERR_BAD_EXE_FORMAT;
-            }
-        }
-        else
-            CORELOGREL(("DumpCore: ReadProcInfo failed. rc=%Rrc\n", rc));
-
-        /*
-         * Resume threads on failure.
-         */
-        ResumeAllThreads(pVBoxProc);
-    }
-    else
-        CORELOG(("DumpCore: SuspendAllThreads failed. Thread bomb!?! rc=%Rrc\n", rc));
-
-    return rc;
-}
-
-
-/**
- * Destroy an existing core object.
- *
- * @param pVBoxCore         Pointer to the core object.
- *
- * @return VBox status code.
- */
-int DestroyCore(PVBOXCORE pVBoxCore)
-{
-    AssertReturn(pVBoxCore, VERR_INVALID_POINTER);
-    if (!pVBoxCore->fIsValid)
-        return VERR_INVALID_STATE;
-
-    FreeMemoryArea(pVBoxCore);
-    pVBoxCore->fIsValid = false;
-    return VINF_SUCCESS;
-}
-
-
-void CoreSigHandler(int Sig, siginfo_t *pSigInfo, void *pvArg)
-{
-    CORELOG(("CoreSigHandler Sig=%d pvArg=%p\n", Sig, pvArg));
-
-    ucontext_t *pContext = (ucontext_t *)pvArg;
-    if (!pContext)
-        CORELOGREL(("CoreSigHandler: Missing context.\n"));
-    else
-    {
-        if (!ASMAtomicUoReadBool(&g_fCoreDumpInProgress))
-        {
-            ASMAtomicWriteBool(&g_fCoreDumpInProgress, true);
-
-            /*
-             * Take a snapshot, then dump core to disk, all threads except this one are halted
-             * from before taking the snapshot until writing the core is completely finished.
-             * Any errors would resume all threads if they were halted.
-             */
-            VBOXCORE VBoxCore;
-            RT_ZERO(VBoxCore);
-            int rc = CreateCore(&VBoxCore, pContext);
-            if (RT_SUCCESS(rc))
-            {
-                rc = WriteCore(&VBoxCore, &WriteFileNoIntr);
-                if (RT_SUCCESS(rc))
-                    CORELOG(("CoreSigHandler: Successfully wrote core file to disk.\n"));
-                else
-                    CORELOGREL(("CoreSigHandler: WriteCore failed. rc=%Rrc\n", rc));
-
-                DestroyCore(&VBoxCore);
-            }
-            else
-                CORELOGREL(("CoreSigHandler: CreateCore failed. rc=%Rrc\n", rc));
-
-            ASMAtomicWriteBool(&g_fCoreDumpInProgress, false);
-        }
-        else
-        {
-            /* @todo detect if we are awaiting for ourselves, if so don't. */
-            CORELOGREL(("CoreSigHandler: Core dump already in progress! Waiting before signalling Sig=%d.\n", Sig));
-            int64_t iTimeout = 10000;  /* timeout (ms) */
-            while (!ASMAtomicUoReadBool(&g_fCoreDumpInProgress))
-            {
-                RTThreadSleep(200);
-                iTimeout -= 200;
-                if (iTimeout <= 0)
-                    break;
-            }
-            if (iTimeout <= 0)
-                CORELOGREL(("CoreSigHandler: Core dump seems to be stuck. Signalling new signal %d\n", Sig));
-        }
-    }
-
-    signal(Sig, SIG_DFL);
-    kill((int)getpid(), Sig);
-}
-
 
 static DECLCALLBACK(int) SleepyThread(RTTHREAD Thread, void *pvUser)
 {
     NOREF(pvUser);
-    sleep(10000);
+    RTThreadSleep(90000000);
     return VINF_SUCCESS;
 }
-
 
 int main()
 {
     RTR3Init();
-    CORELOG(("tstRTCoreDump: TESTING pid=%d\n", getpid()));
+    RTPrintf("tstRTCoreDump: TESTING...\n");
 
     /*
-     * Install core dump signal handler.
+     * Setup core dumping.
      */
-    struct sigaction sigAction;
-    sigAction.sa_sigaction = CoreSigHandler;
-    sigemptyset(&sigAction.sa_mask);
-    sigAction.sa_flags = SA_RESTART | SA_SIGINFO;
-    sigaction(SIGSEGV, &sigAction, NULL);
-    sigaction(SIGBUS, &sigAction, NULL);
-    sigaction(SIGUSR1, &sigAction, NULL);
-
-    /*
-     * Spawn a few threads.
-     */
-    RTTHREAD ahThreads[5];
-    for (unsigned i = 0; i < RT_ELEMENTS(ahThreads); i++)
+    int rc = RTCoreDumperSetup(NULL, 0);
+    if (RT_SUCCESS(rc))
     {
-        int rc = RTThreadCreate(&ahThreads[i], SleepyThread, &ahThreads[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "TEST1");
+        /*
+         * Spawn a few threads.
+         */
+        RTTHREAD ahThreads[5];
+        unsigned i = 0;
+        for (; i < RT_ELEMENTS(ahThreads); i++)
+        {
+            rc = RTThreadCreate(&ahThreads[i], SleepyThread, &ahThreads[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "TEST1");
+            if (RT_FAILURE(rc))
+            {
+                RTPrintf("tstRTCoreDump: FAILURE(%d) - %d RTThreadCreate failed, rc=%Rrc\n", __LINE__, i, rc);
+                g_cErrors++;
+                ahThreads[i] = NIL_RTTHREAD;
+                break;
+            }
+        }
+        RTPrintf("Spawned %d threads.\n", i);
+    
+        /*
+         * Write the core to disk.
+         */
+        rc = RTCoreDumperTakeDump(NULL);
         if (RT_FAILURE(rc))
         {
-            CORELOG(("tstRTCoreDump: FAILURE(%d) - %d RTThreadCreate failed, rc=%Rrc\n", __LINE__, i, rc));
             g_cErrors++;
-            ahThreads[i] = NIL_RTTHREAD;
-            break;
+            RTPrintf("RTCoreDumperTakeDump failed. rc=%Rrc\n", rc);
         }
     }
-
-    CORELOG(("Spawned %d threads\n", RT_ELEMENTS(ahThreads)));
-
-    /*
-     * Send signal to dump core.
-     */
-    kill(getpid(), SIGSEGV);
-    g_cErrors++;
-
-    sleep(10);
+    else
+    {
+        g_cErrors++;
+        RTPrintf("RTCoreDumperSetup failed. rc=%Rrc\n", rc);
+    }
 
     /*
@@ -1996 +97 @@
      */
     if (!g_cErrors)
-        CORELOG(("tstRTCoreDump: SUCCESS\n"));
+        RTPrintf("tstRTCoreDump: SUCCESS\n");
     else
-        CORELOG(("tstRTCoreDump: FAILURE - %d errors\n", g_cErrors));
+        RTPrintf("tstRTCoreDump: FAILURE - %d errors\n", g_cErrors);
 
     return !!g_cErrors;