Changeset 46083 in vbox for trunk

Timestamp:

May 14, 2013 11:39:28 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

85759

Message:

Made it possible to find symbols for windows nt using a image-in-guest-memory loader fallback.

Location:

trunk

Files:

• include/iprt/dbg.h (modified) (1 diff)
• include/iprt/ldr.h (modified) (1 diff)
• src/VBox/Debugger/DBGPlugInWinNt.cpp (modified) (5 diffs)
• src/VBox/Runtime/common/dbg/dbgmod.cpp (modified) (3 diffs)
• src/VBox/Runtime/common/dbg/dbgmodldr.cpp (modified) (6 diffs)
• src/VBox/Runtime/common/ldr/ldrELFRelocatable.cpp.h (modified) (10 diffs)
• src/VBox/Runtime/common/ldr/ldrEx.cpp (modified) (1 diff)
• src/VBox/Runtime/common/ldr/ldrMemory.cpp (modified) (2 diffs)
• src/VBox/Runtime/common/ldr/ldrNative.cpp (modified) (1 diff)
• src/VBox/Runtime/common/ldr/ldrPE.cpp (modified) (8 diffs)
• src/VBox/Runtime/common/ldr/ldrkStuff.cpp (modified) (3 diffs)
• src/VBox/Runtime/include/internal/dbgmod.h (modified) (1 diff)
• src/VBox/Runtime/include/internal/ldr.h (modified) (2 diffs)
• src/VBox/Runtime/tools/RTLdrFlt.cpp (modified) (1 diff)

trunk/include/iprt/dbg.h

@@ -927 +927 @@
 RTDECL(int)         RTDbgModCreateFromMap(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTUINTPTR uSubtrahend,
                                           RTDBGCFG hDbgCfg);
-RTDECL(int)         RTDbgModCreateFromPeImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, uint32_t cbImage,
-                                              uint32_t uTimeDateStamp, RTDBGCFG hDbgCfg);
+RTDECL(int)         RTDbgModCreateFromPeImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTLDRMOD hLdrMod,
+                                              uint32_t cbImage, uint32_t uTimeDateStamp, RTDBGCFG hDbgCfg);
 RTDECL(int)         RTDbgModCreateFromDbg(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, uint32_t cbImage,
                                           uint32_t uTimeDateStamp, RTDBGCFG hDbgCfg);

trunk/include/iprt/ldr.h

@@ -227 +227 @@
  *                      a pointer to a memory block.
  * @param   phLdrMod    Where to return the module handle.
+ *
+ * @remarks With the exception of invalid @a pfnDtor and/or @a pvUser
+ *          parameters, the pfnDtor methods (or the default one if NULL) will
+ *          always be invoked.  The destruction of pvUser is entirely in the
+ *          hands of this method once it's called.
  */
 RTDECL(int) RTLdrOpenInMemory(const char *pszName, uint32_t fFlags, RTLDRARCH enmArch, size_t cbImage,
                               PFNRTLDRRDRMEMREAD pfnRead, PFNRTLDRRDRMEMDTOR pfnDtor, void *pvUser,
                               PRTLDRMOD phLdrMod);
-
 
 /**

trunk/src/VBox/Debugger/DBGPlugInWinNt.cpp

@@ -25 +25 @@
 #include <VBox/err.h>
 #include <VBox/param.h>
-#include <iprt/string.h>
+#include <iprt/ldr.h>
 #include <iprt/mem.h>
 #include <iprt/stream.h>
+#include <iprt/string.h>
 
 #include "../Runtime/include/internal/ldrMZ.h"  /* ugly */
@@ -239 +240 @@
 
 
+/**
+ * The WinNT digger's loader reader instance data.
+ */
+typedef struct DBGDIGGERWINNTRDR
+{
+    /** The VM handle (referenced). */
+    PUVM                pUVM;
+    /** The image base. */
+    DBGFADDRESS         ImageAddr;
+    /** The image size. */
+    uint32_t            cbImage;
+    /** Number of entries in the aMappings table. */
+    uint32_t            cMappings;
+    /** Mapping hint. */
+    uint32_t            iHint;
+    /** Mapping file offset to memory offsets, ordered by file offset. */
+    struct
+    {
+        /** The file offset. */
+        uint32_t        offFile;
+        /** The size of this mapping. */
+        uint32_t        cbMem;
+        /** The offset to the memory from the start of the image.  */
+        uint32_t        offMem;
+    } aMappings[1];
+} DBGDIGGERWINNTRDR;
+/** Pointer a WinNT loader reader instance data. */
+typedef DBGDIGGERWINNTRDR *PDBGDIGGERWINNTRDR;
+
+
 /*******************************************************************************
 *   Defined Constants And Macros                                               *
@@ -274 +305 @@
 
 
+
+/** @callback_method_impl{PFNRTLDRRDRMEMREAD} */
+static DECLCALLBACK(int) dbgDiggerWinNtRdr_Read(void *pvBuf, size_t cb, size_t off, void *pvUser)
+{
+    PDBGDIGGERWINNTRDR pThis = (PDBGDIGGERWINNTRDR)pvUser;
+
+    uint32_t i = pThis->iHint;
+    if (pThis->aMappings[i].offFile > off)
+    {
+        i = pThis->cMappings;
+        while (i-- > 0)
+            if (off >= pThis->aMappings[i].offFile)
+                break;
+        pThis->iHint = i;
+    }
+
+    while (cb > 0)
+    {
+        uint32_t offNextMap =  i + 1 < pThis->cMappings ? pThis->aMappings[i + 1].offFile : pThis->cbImage;
+        uint32_t offMap     = (uint32_t)off - pThis->aMappings[i].offFile;
+
+        /* Read file bits backed by memory. */
+        if (off < pThis->aMappings[i].cbMem)
+        {
+            uint32_t cbToRead = pThis->aMappings[i].cbMem - offMap;
+            if (cbToRead > cb)
+                cbToRead = (uint32_t)cb;
+
+            DBGFADDRESS Addr = pThis->ImageAddr;
+            DBGFR3AddrAdd(&Addr, pThis->aMappings[i].offMem + offMap);
+
+            int rc = DBGFR3MemRead(pThis->pUVM, 0 /*idCpu*/, &Addr, pvBuf, cbToRead);
+            if (RT_FAILURE(rc))
+                return rc;
+            if (cbToRead == cb)
+                break;
+
+            off  += cbToRead;
+            cb   -= cbToRead;
+            pvBuf = (char *)pvBuf + cbToRead;
+        }
+
+        /* Mind the gap. */
+        if (offNextMap > off)
+        {
+            uint32_t cbZero = offNextMap - (uint32_t)off;
+            if (cbZero > cb)
+            {
+                RT_BZERO(pvBuf, cb);
+                break;
+            }
+
+            RT_BZERO(pvBuf, cbZero);
+            off  += cbZero;
+            cb   -= cbZero;
+            pvBuf = (char *)pvBuf + cbZero;
+        }
+
+        pThis->iHint = ++i;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/** @callback_method_impl{PFNRTLDRRDRMEMDTOR} */
+static DECLCALLBACK(void) dbgDiggerWinNtRdr_Dtor(void *pvUser)
+{
+    PDBGDIGGERWINNTRDR pThis = (PDBGDIGGERWINNTRDR)pvUser;
+
+    VMR3ReleaseUVM(pThis->pUVM);
+    pThis->pUVM = NULL;
+    RTMemFree(pvUser);
+}
+
+
 /**
  * Process a PE image found in guest memory.
@@ -390 +497 @@
      * Create the module.
      */
-    bool     fPeImageMod = true;
     RTDBGMOD hMod;
-    int rc = RTDbgModCreateFromPeImage(&hMod, pszName, NULL, cbImageFromHdr, TimeDateStamp, DBGFR3AsGetConfig(pUVM));
+    int rc = RTDbgModCreateFromPeImage(&hMod, pszName, NULL, NIL_RTLDRMOD,
+                                       cbImageFromHdr, TimeDateStamp, DBGFR3AsGetConfig(pUVM));
     if (RT_FAILURE(rc))
     {
-        rc = RTDbgModCreate(&hMod, pszName, cbImage, 0);
+        /*
+         * Probably didn't find the image any where, try fake an image
+         * from guest memory.
+         */
+        uint32_t            cMappings = WINNT_UNION(pThis, pHdrs, FileHeader.NumberOfSections) + 3;
+        PDBGDIGGERWINNTRDR  pRdr = (PDBGDIGGERWINNTRDR)RTMemAlloc(RT_OFFSETOF(DBGDIGGERWINNTRDR, aMappings[cMappings]));
+        if (!pRdr)
+            return;
+
+        VMR3RetainUVM(pUVM);
+        pRdr->pUVM          = pUVM;
+        pRdr->ImageAddr     = *pImageAddr;
+        pRdr->cbImage       = cbImageFromHdr;
+        pRdr->cMappings     = 1;
+        pRdr->iHint         = 0;
+        pRdr->aMappings[0].offFile = 0;
+        pRdr->aMappings[0].offMem  =  0;
+        pRdr->aMappings[0].cbMem   = cbImageFromHdr;
+
+        RTLDRMOD hLdrMod;
+        rc = RTLdrOpenInMemory(pszName, RTLDR_O_FOR_DEBUG, RTLDRARCH_WHATEVER, pRdr->cbImage,
+                               dbgDiggerWinNtRdr_Read, dbgDiggerWinNtRdr_Dtor, pRdr,
+                               &hLdrMod);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTDbgModCreateFromPeImage(&hMod, pszName, NULL, hLdrMod,
+                                           cbImageFromHdr, TimeDateStamp, DBGFR3AsGetConfig(pUVM));
+            if (RT_FAILURE(rc))
+                RTLdrClose(hLdrMod);
+        }
         if (RT_FAILURE(rc))
-            return;
-        fPeImageMod = false;
+        {
+            /*
+             * Final fallback is a container module.
+             */
+            rc = RTDbgModCreate(&hMod, pszName, cbImage, 0);
+            if (RT_FAILURE(rc))
+                return;
+
+            rc = RTDbgModSymbolAdd(hMod, "Headers", 0 /*iSeg*/, 0, cbImage, 0 /*fFlags*/, NULL); AssertRC(rc);
+        }
     }
     rc = RTDbgModSetTag(hMod, DIG_WINNT_MOD_TAG); AssertRC(rc);
 
-    if (fPeImageMod)
-    {
-        rc = RTDbgModSymbolAdd(hMod, "Headers", 0 /*iSeg*/, 0, cbImage, 0 /*fFlags*/, NULL);
-        AssertRC(rc);
-        /** @todo add sections? */
-    }
-
+#if 0
     /*
      * Dig out debug info if possible.  What we're after is the CODEVIEW part.
@@ -434 +572 @@
         }
     }
+#endif
 
     /*

trunk/src/VBox/Runtime/common/dbg/dbgmod.cpp

@@ -885 +885 @@
 
     Assert(pDbgMod->pszImgFile);
-    if (pDeferred->hDbgCfg != NIL_RTDBGCFG)
+    if (!pDbgMod->pImgVt)
         rc = RTDbgCfgOpenPeImage(pDeferred->hDbgCfg, pDbgMod->pszImgFile,
                                  pDeferred->cbImage, pDeferred->u.PeImage.uTimestamp,
                                  rtDbgModFromPeImageOpenCallback, pDbgMod, pDeferred);
     else
-        rc = rtDbgModFromPeImageOpenCallback(NIL_RTDBGCFG, pDbgMod->pszImgFile, pDbgMod, pDeferred);
-
-    return rc;
-}
-
-
-RTDECL(int) RTDbgModCreateFromPeImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, uint32_t cbImage,
-                                      uint32_t uTimestamp, RTDBGCFG hDbgCfg)
+    {
+        rc = rtDbgModOpenDebugInfoExternalToImage(pDbgMod, pDeferred->hDbgCfg);
+        if (RT_FAILURE(rc))
+            rc = rtDbgModOpenDebugInfoInsideImage(pDbgMod);
+        if (RT_FAILURE(rc))
+            rc = rtDbgModCreateForExports(pDbgMod);
+    }
+    return rc;
+}
+
+
+RTDECL(int) RTDbgModCreateFromPeImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTLDRMOD hLdrMod,
+                                      uint32_t cbImage, uint32_t uTimestamp, RTDBGCFG hDbgCfg)
 {
     /*
@@ -909 +914 @@
         pszName = RTPathFilename(pszFilename);
     AssertPtrReturn(pszName, VERR_INVALID_POINTER);
+    AssertReturn(hLdrMod == NIL_RTLDRMOD || RTLdrSize(hLdrMod) != ~(size_t)0, VERR_INVALID_HANDLE);
 
     int rc = rtDbgModLazyInit();
@@ -939 +945 @@
             {
                 /*
-                 * Do it now or procrastinate?
+                 * If we have a loader module, we must instantiate the loader
+                 * side of things regardless of the deferred setting.
                  */
-                if (!(fDbgCfg & RTDBGCFG_FLAGS_DEFERRED) || !cbImage)
+                if (hLdrMod != NIL_RTLDRMOD)
                 {
-                    RTDBGMODDEFERRED Deferred;
-                    Deferred.cbImage = cbImage;
-                    Deferred.hDbgCfg = hDbgCfg;
-                    Deferred.u.PeImage.uTimestamp = uTimestamp;
-                    rc = rtDbgModFromPeImageDeferredCallback(pDbgMod, &Deferred);
-                }
-                else
-                {
-                    PRTDBGMODDEFERRED pDeferred;
-                    rc = rtDbgModDeferredCreate(pDbgMod, rtDbgModFromPeImageDeferredCallback, cbImage, hDbgCfg, &pDeferred);
-                    if (RT_SUCCESS(rc))
-                        pDeferred->u.PeImage.uTimestamp = uTimestamp;
+                    if (!cbImage)
+                        cbImage = (uint32_t)RTLdrSize(hLdrMod);
+                    pDbgMod->pImgVt = &g_rtDbgModVtImgLdr;
+
+                    rc = rtDbgModLdrOpenFromHandle(pDbgMod, hLdrMod);
                 }
                 if (RT_SUCCESS(rc))
                 {
-                    *phDbgMod = pDbgMod;
-                    return VINF_SUCCESS;
+                    /*
+                     * Do it now or procrastinate?
+                     */
+                    if (!(fDbgCfg & RTDBGCFG_FLAGS_DEFERRED) || !cbImage)
+                    {
+                        RTDBGMODDEFERRED Deferred;
+                        Deferred.cbImage = cbImage;
+                        Deferred.hDbgCfg = hDbgCfg;
+                        Deferred.u.PeImage.uTimestamp = uTimestamp;
+                        rc = rtDbgModFromPeImageDeferredCallback(pDbgMod, &Deferred);
+                    }
+                    else
+                    {
+                        PRTDBGMODDEFERRED pDeferred;
+                        rc = rtDbgModDeferredCreate(pDbgMod, rtDbgModFromPeImageDeferredCallback, cbImage, hDbgCfg, &pDeferred);
+                        if (RT_SUCCESS(rc))
+                            pDeferred->u.PeImage.uTimestamp = uTimestamp;
+                    }
+                    if (RT_SUCCESS(rc))
+                    {
+                        *phDbgMod = pDbgMod;
+                        return VINF_SUCCESS;
+                    }
+
+                    /* Failed, bail out. */
+                    if (hLdrMod != NIL_RTLDRMOD)
+                    {
+                        Assert(pDbgMod->pImgVt);
+                        pDbgMod->pImgVt->pfnClose(pDbgMod);
+                    }
                 }
-
-                /* bail out */
                 RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
             }

trunk/src/VBox/Runtime/common/dbg/dbgmodldr.cpp

@@ -41 +41 @@
 #include <iprt/string.h>
 #include "internal/dbgmod.h"
+#include "internal/ldr.h"
 #include "internal/magics.h"
 
@@ -54 +55 @@
     /** The loader handle. */
     RTLDRMOD        hLdrMod;
-    /** File handle for the image. */
-    RTFILE          hFile;
 } RTDBGMODLDR;
 /** Pointer to instance data NM map reader. */
@@ -80 +79 @@
         return VERR_NO_MEMORY;
 
-    int rc = RTFileReadAt(pThis->hFile, off, pvMap, cb, NULL);
+    int rc = rtLdrReadAt(pThis->hLdrMod, pvMap, off, cb);
     if (RT_SUCCESS(rc))
         *ppvMap = pvMap;
@@ -134 +133 @@
     pThis->hLdrMod = NIL_RTLDRMOD;
 
-    rc = RTFileClose(pThis->hFile); AssertRC(rc);
-    pThis->hFile = NIL_RTFILE;
-
     RTMemFree(pThis);
 
@@ -146 +142 @@
 static DECLCALLBACK(int) rtDbgModLdr_TryOpen(PRTDBGMODINT pMod)
 {
-    RTFILE hFile;
-    int rc = RTFileOpen(&hFile, pMod->pszImgFile, RTFILE_O_READ | RTFILE_O_DENY_WRITE | RTFILE_O_OPEN);
+    RTLDRMOD hLdrMod;
+    int rc = RTLdrOpen(pMod->pszImgFile, RTLDR_O_FOR_DEBUG, RTLDRARCH_WHATEVER, &hLdrMod);
     if (RT_SUCCESS(rc))
     {
-        RTLDRMOD hLdrMod;
-        rc = RTLdrOpen(pMod->pszImgFile, RTLDR_O_FOR_DEBUG, RTLDRARCH_WHATEVER, &hLdrMod);
-        if (RT_SUCCESS(rc))
-        {
-            PRTDBGMODLDR pThis = (PRTDBGMODLDR)RTMemAllocZ(sizeof(RTDBGMODLDR));
-            if (pThis)
-            {
-                pThis->hLdrMod  = hLdrMod;
-                pThis->hFile    = hFile;
-                pMod->pvImgPriv = pThis;
-                return VINF_SUCCESS;
-            }
-
-            rc = VERR_NO_MEMORY;
+        rc = rtDbgModLdrOpenFromHandle(pMod, hLdrMod);
+        if (RT_FAILURE(rc))
             RTLdrClose(hLdrMod);
-        }
-
-        RTFileClose(hFile);
     }
     return rc;
@@ -191 +172 @@
 };
 
+
+/**
+ * Open PE-image trick.
+ *
+ * @returns IPRT status code
+ * @param   pDbgMod             The debug module instance.
+ * @param   hLdrMod             The module to open a image debug backend for.
+ */
+DECLHIDDEN(int) rtDbgModLdrOpenFromHandle(PRTDBGMODINT pDbgMod, RTLDRMOD hLdrMod)
+{
+    PRTDBGMODLDR pThis = (PRTDBGMODLDR)RTMemAllocZ(sizeof(RTDBGMODLDR));
+    if (!pThis)
+        return VERR_NO_MEMORY;
+
+    pThis->hLdrMod     = hLdrMod;
+    pDbgMod->pvImgPriv = pThis;
+    return VINF_SUCCESS;
+}
+

trunk/src/VBox/Runtime/common/ldr/ldrELFRelocatable.cpp.h

@@ -93 +93 @@
     /** Core module structure. */
     RTLDRMODINTERNAL        Core;
-    /** Pointer to the reader instance. */
-    PRTLDRREADER            pReader;
     /** Pointer to readonly mapping of the image bits.
      * This mapping is provided by the pReader. */
@@ -145 +143 @@
     if (pModElf->pvBits)
         return VINF_SUCCESS;
-    int rc = pModElf->pReader->pfnMap(pModElf->pReader, &pModElf->pvBits);
+    int rc = pModElf->Core.pReader->pfnMap(pModElf->Core.pReader, &pModElf->pvBits);
     if (RT_SUCCESS(rc))
     {
@@ -423 +421 @@
     }
 
-    if (pModElf->pReader)
-    {
-        pModElf->pReader->pfnDestroy(pModElf->pReader);
-        pModElf->pReader = NULL;
-    }
-
     pModElf->pvBits = NULL;
 
@@ -534 +526 @@
             break;
         case ET_EXEC:
-            Log(("RTLdrELF: %s: Executable images are not supported yet!\n", pModElf->pReader->pfnLogName(pModElf->pReader)));
+            Log(("RTLdrELF: %s: Executable images are not supported yet!\n", pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader)));
             return VERR_LDRELF_EXEC;
         case ET_DYN:
-            Log(("RTLdrELF: %s: Dynamic images are not supported yet!\n", pModElf->pReader->pfnLogName(pModElf->pReader)));
+            Log(("RTLdrELF: %s: Dynamic images are not supported yet!\n", pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader)));
             return VERR_LDRELF_DYN;
         default: AssertFailedReturn(VERR_BAD_EXE_FORMAT);
@@ -560 +552 @@
                 default:
                 {
-                    int rc = pModElf->pReader->pfnRead(pModElf->pReader, (uint8_t *)pvBits + paShdrs[iShdr].sh_addr,
-                                                       (size_t)paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset);
+                    int rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, (uint8_t *)pvBits + paShdrs[iShdr].sh_addr,
+                                                            (size_t)paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset);
                     if (RT_FAILURE(rc))
                     {
                         Log(("RTLdrELF: %s: Read error when reading " FMT_ELF_SIZE " bytes at " FMT_ELF_OFF ", iShdr=%d\n",
-                             pModElf->pReader->pfnLogName(pModElf->pReader),
+                             pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader),
                              paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset, iShdr));
                         return rc;
@@ -587 +579 @@
     PRTLDRMODELF    pModElf = (PRTLDRMODELF)pMod;
 #ifdef LOG_ENABLED
-    const char     *pszLogName = pModElf->pReader->pfnLogName(pModElf->pReader);
+    const char     *pszLogName = pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader);
 #endif
     NOREF(OldBaseAddress);
@@ -1170 +1162 @@
  *
  * @returns pszName.
- * @param   pReader         The loader reader instance.
  * @param   pEhdr           The elf header.
  * @param   offName         The offset of the section header name.
@@ -1179 +1170 @@
 {
     RTFOFF off = pModElf->paShdrs[pModElf->Ehdr.e_shstrndx].sh_offset + offName;
-    int rc = pModElf->pReader->pfnRead(pModElf->pReader, pszName, cbName - 1, off);
+    int rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, pszName, cbName - 1, off);
     if (RT_FAILURE(rc))
     {
@@ -1185 +1176 @@
         for (unsigned i = 0; i < cbName; i++, off++)
         {
-            rc = pModElf->pReader->pfnRead(pModElf->pReader, pszName + i, 1, off);
+            rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, pszName + i, 1, off);
             if (RT_FAILURE(rc))
             {
@@ -1347 +1338 @@
     pModElf->Core.u32Magic  = RTLDRMOD_MAGIC;
     pModElf->Core.eState    = LDR_STATE_INVALID;
-    pModElf->pReader        = pReader;
+    pModElf->Core.pReader   = pReader;
     //pModElf->pvBits         = NULL;
     //pModElf->Ehdr           = {0};

trunk/src/VBox/Runtime/common/ldr/ldrEx.cpp

@@ -539 +539 @@
 RT_EXPORT_SYMBOL(RTLdrRvaToSegOffset);
 
+
+/**
+ * Internal method used by the IPRT debug bits.
+ *
+ * @returns IPRT status code.
+ * @param   hLdrMod             The loader handle which executable we wish to
+ *                              read from.
+ * @param   pvBuf               The output buffer.
+ * @param   off                 Where in the executable file to start reading.
+ * @param   cb                  The number of bytes to read.
+ */
+DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, RTFOFF off, size_t cb)
+{
+    AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
+    PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
+    AssertReturn(pMod->pReader, VERR_INVALID_HANDLE);
+
+    return pMod->pReader->pfnRead(pMod->pReader, pvBuf, cb, off);
+}
+

trunk/src/VBox/Runtime/common/ldr/ldrMemory.cpp

@@ -264 +264 @@
     LogFlow(("RTLdrOpenInMemory: pszName=%p:{%s} fFlags=%#x enmArch=%d cbImage=%#zu pfnRead=%p pfnDtor=%p pvUser=%p phLdrMod=%p\n",
              pszName, pszName, fFlags, enmArch, cbImage, pfnRead, pfnDtor, pvUser, phLdrMod));
-    AssertMsgReturn(!(fFlags & ~RTLDR_O_VALID_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
-    AssertMsgReturn(enmArch > RTLDRARCH_INVALID && enmArch < RTLDRARCH_END, ("%d\n", enmArch), VERR_INVALID_PARAMETER);
+
     if (!pfnRead || !pfnDtor)
         AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+    if (!pfnDtor)
+        pfnDtor = rtldrRdrMemDefaultDtor;
+    else
+        AssertPtrReturn(pfnRead, VERR_INVALID_POINTER);
+
+    /* The rest of the validations will call the destructor. */
+    AssertMsgReturnStmt(!(fFlags & ~RTLDR_O_VALID_MASK), ("%#x\n", fFlags),
+                        pfnDtor(pvUser), VERR_INVALID_PARAMETER);
+    AssertMsgReturnStmt(enmArch > RTLDRARCH_INVALID && enmArch < RTLDRARCH_END, ("%d\n", enmArch),
+                        pfnDtor(pvUser), VERR_INVALID_PARAMETER);
     if (!pfnRead)
         pfnRead = rtldrRdrMemDefaultReader;
     else
-        AssertPtrReturn(pfnRead, VERR_INVALID_POINTER);
-    if (!pfnDtor)
-        pfnDtor = rtldrRdrMemDefaultDtor;
-    else
-        AssertPtrReturn(pfnRead, VERR_INVALID_POINTER);
-    AssertReturn(cbImage > 0, VERR_INVALID_PARAMETER);
-
+        AssertReturnStmt(RT_VALID_PTR(pfnRead), pfnDtor(pvUser), VERR_INVALID_POINTER);
+    AssertReturnStmt(cbImage > 0, pfnDtor(pvUser), VERR_INVALID_PARAMETER);
 
     /*
@@ -304 +308 @@
             return rc;
         }
+
         pReader->pfnDestroy(pReader);
     }
+    else
+        pfnDtor(pvUser),
     *phLdrMod = NIL_RTLDRMOD;
+
     LogFlow(("RTLdrOpen: return %Rrc\n", rc));
     return rc;

trunk/src/VBox/Runtime/common/ldr/ldrNative.cpp

@@ -131 +131 @@
         pMod->Core.eState   = LDR_STATE_LOADED;
         pMod->Core.pOps     = &s_rtldrNativeOps;
+        pMod->Core.pReader  = NULL;
         pMod->hNative       = ~(uintptr_t)0;
 

trunk/src/VBox/Runtime/common/ldr/ldrPE.cpp

@@ -65 +65 @@
     /** Core module structure. */
     RTLDRMODINTERNAL        Core;
-    /** Pointer to the reader instance. */
-    PRTLDRREADER            pReader;
     /** Pointer to internal copy of image bits.
      * @todo the reader should take care of this. */
@@ -160 +158 @@
      * Both these checks are related to pfnDone().
      */
-    PRTLDRREADER pReader = pModPe->pReader;
+    PRTLDRREADER pReader = pModPe->Core.pReader;
     if (!pReader)
     {
@@ -1101 +1099 @@
         pModPe->pvBits = NULL;
     }
-    if (pModPe->pReader)
-    {
-        int rc = pModPe->pReader->pfnDestroy(pModPe->pReader);
-        AssertRC(rc);
-        pModPe->pReader = NULL;
-    }
     return VINF_SUCCESS;
 }
@@ -1124 +1116 @@
         pModPe->pvBits = NULL;
     }
-    if (pModPe->pReader)
-    {
-        int rc = pModPe->pReader->pfnDestroy(pModPe->pReader);
+    if (pModPe->Core.pReader)
+    {
+        int rc = pModPe->Core.pReader->pfnDestroy(pModPe->Core.pReader);
         AssertRC(rc);
-        pModPe->pReader = NULL;
+        pModPe->Core.pReader = NULL;
     }
     return VINF_SUCCESS;
@@ -1618 +1610 @@
 {
     const IMAGE_SECTION_HEADER *pSH = pModPe->paSections;
-    PRTLDRREADER                pReader = pModPe->pReader;
+    PRTLDRREADER                pReader = pModPe->Core.pReader;
     uint32_t                    cbRead;
     int                         rc;
@@ -1698 +1690 @@
 int rtldrPEValidateDirectories(PRTLDRMODPE pModPe, const IMAGE_OPTIONAL_HEADER64 *pOptHdr)
 {
-    const char *pszLogName = pModPe->pReader->pfnLogName(pModPe->pReader); NOREF(pszLogName);
+    const char *pszLogName = pModPe->Core.pReader->pfnLogName(pModPe->Core.pReader); NOREF(pszLogName);
     union /* combine stuff we're reading to help reduce stack usage. */
     {
@@ -1772 +1764 @@
         if (!pFirst)
             return VERR_NO_TMP_MEMORY;
-        int rc = pModPe->pReader->pfnRead(pModPe->pReader, pFirst, Dir.Size, Dir.VirtualAddress);
+        int rc = pModPe->Core.pReader->pfnRead(pModPe->Core.pReader, pFirst, Dir.Size, Dir.VirtualAddress);
         if (RT_SUCCESS(rc))
         {
@@ -1897 +1889 @@
                 else
                     pModPe->Core.pOps = &s_rtldrPE32Ops.Core;
-                pModPe->pReader       = pReader;
+                pModPe->Core.pReader  = pReader;
                 pModPe->pvBits        = NULL;
                 pModPe->offNtHdrs     = offNtHdrs;

trunk/src/VBox/Runtime/common/ldr/ldrkStuff.cpp

@@ -241 +241 @@
 static int      rtkldrRdr_Destroy( PKRDR pRdr)
 {
-    PRTLDRREADER pReader = ((PRTKLDRRDR)pRdr)->pReader;
-    int rc = pReader->pfnDestroy(pReader);
-    return rtkldrConvertErrorFromIPRT(rc);
+    PRTKLDRRDR pThis = (PRTKLDRRDR)pRdr;
+    pThis->pReader = NULL;
+    RTMemFree(pThis);
+    return 0;
 }
 
@@ -877 +878 @@
         {
             pNewMod->Core.u32Magic = RTLDRMOD_MAGIC;
-            pNewMod->Core.eState = LDR_STATE_OPENED;
-            pNewMod->Core.pOps = &g_rtkldrOps;
-            pNewMod->pMod = pMod;
+            pNewMod->Core.eState   = LDR_STATE_OPENED;
+            pNewMod->Core.pOps     = &g_rtkldrOps;
+            pNewMod->Core.pReader  = pReader;
+            pNewMod->pMod          = pMod;
             *phLdrMod = &pNewMod->Core;
 
@@ -896 +898 @@
             return VINF_SUCCESS;
         }
+
+        /* bail out */
         kLdrModClose(pMod);
         krc = KERR_NO_MEMORY;
     }
+    else
+        RTMemFree(pRdr);
+
     return rtkldrConvertError(krc);
 }

trunk/src/VBox/Runtime/include/internal/dbgmod.h

@@ -567 +567 @@
                                        RTDBGCFG hDbgCfg, PRTDBGMODDEFERRED *ppDeferred);
 
+DECLHIDDEN(int) rtDbgModLdrOpenFromHandle(PRTDBGMODINT pDbgMod, RTLDRMOD hLdrMod);
+
 /** @} */
 

trunk/src/VBox/Runtime/include/internal/ldr.h

@@ -403 +403 @@
     /** Loader ops. */
     PCRTLDROPS              pOps;
+    /** Pointer to the reader instance. This is NULL for native image. */
+    PRTLDRREADER            pReader;
 } RTLDRMODINTERNAL;
 
@@ -456 +458 @@
 
 
+DECLHIDDEN(int) rtLdrReadAt(RTLDRMOD hLdrMod, void *pvBuf, RTFOFF off, size_t cb);
+
 RT_C_DECLS_END
 

trunk/src/VBox/Runtime/tools/RTLdrFlt.cpp

@@ -239 +239 @@
                     rc = RTDbgModCreateFromImage(&hMod, pszModule, NULL, hDbgCfg);
                 else
-                    rc = RTDbgModCreateFromPeImage(&hMod, pszModule, NULL, cbImage, uTimestamp, hDbgCfg);
+                    rc = RTDbgModCreateFromPeImage(&hMod, pszModule, NULL, NIL_RTLDRMOD, cbImage, uTimestamp, hDbgCfg);
                 if (RT_FAILURE(rc))
                     return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDbgModCreateFromImage(,%s,,) -> %Rrc", pszModule, rc);