Changeset 93470 in vbox for trunk/src

Timestamp:

Jan 27, 2022 11:51:28 PM (3 years ago)

Author:

vboxsync

Message:

DbgPlugInDiggers,VMM,Main: Refactored the diggers and related interfaces to work via the VMM function table. Removed non-working tstVBoxDbg (needs proper COM now). bugref:10072

Location:

trunk/src/VBox

Files:

• Debugger/DBGCCommands.cpp (modified) (2 diffs)
• Debugger/DBGCRemoteKd.cpp (modified) (5 diffs)
• Debugger/DBGPlugInCommonELF.cpp (modified) (1 diff)
• Debugger/DBGPlugInCommonELF.h (modified) (2 diffs)
• Debugger/DBGPlugInCommonELFTmpl.cpp.h (modified) (4 diffs)
• Debugger/DBGPlugInDarwin.cpp (modified) (38 diffs)
• Debugger/DBGPlugInDiggers.cpp (modified) (4 diffs)
• Debugger/DBGPlugInFreeBsd.cpp (modified) (37 diffs)
• Debugger/DBGPlugInLinux.cpp (modified) (105 diffs)
• Debugger/DBGPlugInLinuxModuleCodeTmpl.cpp.h (modified) (9 diffs)
• Debugger/DBGPlugInOS2.cpp (modified) (37 diffs)
• Debugger/DBGPlugInSolaris.cpp (modified) (48 diffs)
• Debugger/DBGPlugInWinNt.cpp (modified) (57 diffs)
• Debugger/Makefile.kmk (modified) (2 diffs)
• Debugger/testcase/tstDBGCStubs.cpp (modified) (1 diff)
• Debugger/testcase/tstVBoxDbg.cpp (deleted)
• Main/src-client/MachineDebuggerImpl.cpp (modified) (2 diffs)
• VMM/VMMR3/CFGM.cpp (modified) (1 diff)
• VMM/VMMR3/DBGFOS.cpp (modified) (21 diffs)
• VMM/VMMR3/DBGFR3PlugIn.cpp (modified) (4 diffs)
• VMM/VMMR3/SSM.cpp (modified) (1 diff)
• VMM/VMMR3/VM.cpp (modified) (1 diff)

trunk/src/VBox/Debugger/DBGCCommands.cpp

@@ -1093 +1093 @@
         if (pszBuf)
         {
-            rc = pDmesg->pfnQueryKernelLog(pDmesg, pUVM, 0 /*fFlags*/, cMessages, pszBuf, cbBuf, &cbActual);
+            rc = pDmesg->pfnQueryKernelLog(pDmesg, pUVM, VMMR3GetVTable(), 0 /*fFlags*/, cMessages, pszBuf, cbBuf, &cbActual);
 
             uint32_t cTries = 10;
@@ -1106 +1106 @@
                     break;
                 }
-                rc = pDmesg->pfnQueryKernelLog(pDmesg, pUVM, 0 /*fFlags*/, cMessages, pszBuf, cbBuf, &cbActual);
+                rc = pDmesg->pfnQueryKernelLog(pDmesg, pUVM, VMMR3GetVTable(), 0 /*fFlags*/, cMessages, pszBuf, cbBuf, &cbActual);
             }
             if (RT_SUCCESS(rc))

trunk/src/VBox/Debugger/DBGCRemoteKd.cpp

@@ -2750 +2750 @@
     if (pThis->pIfWinNt)
     {
-        int rc = pThis->pIfWinNt->pfnQueryVersion(pThis->pIfWinNt, pThis->Dbgc.pUVM,
+        int rc = pThis->pIfWinNt->pfnQueryVersion(pThis->pIfWinNt, pThis->Dbgc.pUVM, VMMR3GetVTable(),
                                                   NULL /*puVersMajor*/, NULL /*puVersMinor*/,
                                                   &NtBuildNumber, &f32Bit);
         if (RT_SUCCESS(rc))
-            rc = pThis->pIfWinNt->pfnQueryKernelPtrs(pThis->pIfWinNt, pThis->Dbgc.pUVM, &Resp.u.GetVersion.u64PtrKernBase,
+            rc = pThis->pIfWinNt->pfnQueryKernelPtrs(pThis->pIfWinNt, pThis->Dbgc.pUVM, VMMR3GetVTable(),
+                                                     &Resp.u.GetVersion.u64PtrKernBase,
                                                      &Resp.u.GetVersion.u64PtrPsLoadedModuleList);
     }
@@ -3028 +3029 @@
                     RTGCUINTPTR GCPtrKpcr = 0;
 
-                    rc = pThis->pIfWinNt->pfnQueryKpcrForVCpu(pThis->pIfWinNt, pThis->Dbgc.pUVM, RespHdr.idCpu,
+                    rc = pThis->pIfWinNt->pfnQueryKpcrForVCpu(pThis->pIfWinNt, pThis->Dbgc.pUVM, VMMR3GetVTable(), RespHdr.idCpu,
                                                               &GCPtrKpcr, NULL /*pKpcrb*/);
                     if (RT_SUCCESS(rc))
@@ -3043 +3044 @@
                     RTGCUINTPTR GCPtrKpcrb = 0;
 
-                    rc = pThis->pIfWinNt->pfnQueryKpcrForVCpu(pThis->pIfWinNt, pThis->Dbgc.pUVM, RespHdr.idCpu,
+                    rc = pThis->pIfWinNt->pfnQueryKpcrForVCpu(pThis->pIfWinNt, pThis->Dbgc.pUVM, VMMR3GetVTable(), RespHdr.idCpu,
                                                               NULL /*pKpcr*/, &GCPtrKpcrb);
                     if (RT_SUCCESS(rc))
@@ -3065 +3066 @@
                     RTGCUINTPTR GCPtrCurThrd = 0;
 
-                    rc = pThis->pIfWinNt->pfnQueryCurThrdForVCpu(pThis->pIfWinNt, pThis->Dbgc.pUVM, RespHdr.idCpu,
-                                                                 &GCPtrCurThrd);
+                    rc = pThis->pIfWinNt->pfnQueryCurThrdForVCpu(pThis->pIfWinNt, pThis->Dbgc.pUVM, VMMR3GetVTable(),
+                                                                 RespHdr.idCpu, &GCPtrCurThrd);
                     if (RT_SUCCESS(rc))
                         memcpy(&abResp[0], &GCPtrCurThrd, sizeof(GCPtrCurThrd));
@@ -3586 +3587 @@
     if (pThis->pIfWinNt)
     {
-        rc = pThis->pIfWinNt->pfnQueryVersion(pThis->pIfWinNt, pThis->Dbgc.pUVM,
+        rc = pThis->pIfWinNt->pfnQueryVersion(pThis->pIfWinNt, pThis->Dbgc.pUVM, VMMR3GetVTable(),
                                               NULL /*puVersMajor*/, NULL /*puVersMinor*/,
                                               NULL /*puBuildNumber*/, &pThis->f32Bit);

trunk/src/VBox/Debugger/DBGPlugInCommonELF.cpp

@@ -23 +23 @@
 #include "DBGPlugInCommonELF.h"
 
-#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <iprt/alloca.h>
 #include <iprt/asm.h>

trunk/src/VBox/Debugger/DBGPlugInCommonELF.h

@@ -38 +38 @@
 /** @} */
 
-int DBGDiggerCommonParseElf32Mod(PUVM pUVM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
+int DBGDiggerCommonParseElf32Mod(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
                                  Elf32_Ehdr const *pEhdr, Elf32_Shdr const *paShdrs,
                                  Elf32_Sym const *paSyms, size_t cMaxSyms,
@@ -44 +44 @@
                                  RTGCPTR MinAddr, RTGCPTR MaxAddr, uint64_t uModTag);
 
-int DBGDiggerCommonParseElf64Mod(PUVM pUVM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
+int DBGDiggerCommonParseElf64Mod(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
                                  Elf64_Ehdr const *pEhdr, Elf64_Shdr const *paShdrs,
                                  Elf64_Sym const *paSyms, size_t cMaxSyms,

trunk/src/VBox/Debugger/DBGPlugInCommonELFTmpl.cpp.h

@@ -45 +45 @@
  *
  * @param   pUVM            The user mode VM handle.
+ * @param   pVMM            The VMM function table.
  * @param   pszModName      The module name.
  * @param   pszFilename     The filename. optional.
@@ -69 +70 @@
  * @param   uModTag         Module tag. Pass 0 if tagging is of no interest.
  */
-int DBGDiggerCommonParseElfMod(PUVM pUVM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
+int DBGDiggerCommonParseElfMod(PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
                                Elf_Ehdr const *pEhdr, Elf_Shdr const *paShdrs,
                                Elf_Sym const *paSyms, size_t cMaxSyms,
@@ -76 +77 @@
 {
     AssertPtrReturn(pUVM, VERR_INVALID_POINTER);
+    AssertPtrReturn(pVMM, VERR_INVALID_POINTER);
     AssertPtrReturn(pszModName, VERR_INVALID_POINTER);
     AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
@@ -315 +317 @@
      * Link it into the address space.
      */
-    RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     if (hAs != NIL_RTDBGAS)
         rc = dbgDiggerCommonLinkElfSegs(hAs, hMod, paSegs, cSegs);

trunk/src/VBox/Debugger/DBGPlugInDarwin.cpp

@@ -22 +22 @@
 #define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
 #include "DBGPlugIns.h"
-#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <iprt/err.h>
 #include <iprt/mem.h>
@@ -132 +132 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int)  dbgDiggerDarwinInit(PUVM pUVM, void *pvData);
+static DECLCALLBACK(int)  dbgDiggerDarwinInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
 
 
@@ -139 +139 @@
  * @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog}
  */
-static DECLCALLBACK(int) dbgDiggerDarwinIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, uint32_t fFlags, uint32_t cMessages,
-                                                             char *pszBuf, size_t cbBuf, size_t *pcbActual)
+static DECLCALLBACK(int) dbgDiggerDarwinIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, uint32_t fFlags,
+                                                             uint32_t cMessages, char *pszBuf, size_t cbBuf, size_t *pcbActual)
 {
     RT_NOREF1(fFlags);
@@ -151 +151 @@
      * The 'msgbufp' variable points to a struct msgbuf (bsd/kern/subr_log.c).
      */
-    RTDBGAS  hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS  hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     RTDBGMOD hMod;
     int rc = RTDbgAsModuleByName(hAs, "mach_kernel", 0, &hMod);
@@ -164 +164 @@
     if (RT_SUCCESS(rc))
     {
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, SymInfo.Value + pData->AddrKernel.FlatPtr),
-                           &GCPtrMsgBufP, pData->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SymInfo.Value + pData->AddrKernel.FlatPtr),
+                                    &GCPtrMsgBufP, pData->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t));
         if (RT_FAILURE(rc))
         {
@@ -204 +205 @@
         uint64_t msg_bufc; /**< Size depends on windows size. */
     } MsgBuf;
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrMsgBufP),
-                       &MsgBuf, sizeof(MsgBuf) - (pData->f64Bit ? 0 : sizeof(uint32_t)) );
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, GCPtrMsgBufP),
+                                &MsgBuf, sizeof(MsgBuf) - (pData->f64Bit ? 0 : sizeof(uint32_t)) );
     if (RT_FAILURE(rc))
     {
@@ -239 +240 @@
         return VERR_INVALID_STATE;
     }
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, MsgBuf.msg_bufc), pchMsgBuf, MsgBuf.msg_size);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, MsgBuf.msg_bufc), pchMsgBuf, MsgBuf.msg_size);
     if (RT_SUCCESS(rc))
     {
@@ -312 +314 @@
  * @copydoc DBGFOSREG::pfnStackUnwindAssist
  */
-static DECLCALLBACK(int) dbgDiggerDarwinStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
-                                                          PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
-                                                          uint64_t *puScratch)
-{
-    RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
+static DECLCALLBACK(int) dbgDiggerDarwinStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
+                                                          PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx,
+                                                          RTDBGAS hAs, uint64_t *puScratch)
+{
+    RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
     return VINF_SUCCESS;
 }
@@ -324 +326 @@
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
-static DECLCALLBACK(void *) dbgDiggerDarwinQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void *) dbgDiggerDarwinQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
     switch (enmIf)
@@ -342 +344 @@
  * @copydoc DBGFOSREG::pfnQueryVersion
  */
-static DECLCALLBACK(int)  dbgDiggerDarwinQueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
+static DECLCALLBACK(int)  dbgDiggerDarwinQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
+                                                      char *pszVersion, size_t cchVersion)
 {
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
@@ -350 +353 @@
      * It's all in the linux banner.
      */
-    int rc = DBGFR3MemReadString(pUVM, 0, &pThis->AddrKernelVersion, pszVersion, cchVersion);
+    int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &pThis->AddrKernelVersion, pszVersion, cchVersion);
     if (RT_SUCCESS(rc))
     {
@@ -370 +373 @@
  * @copydoc DBGFOSREG::pfnTerm
  */
-static DECLCALLBACK(void)  dbgDiggerDarwinTerm(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void)  dbgDiggerDarwinTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
 
@@ -382 +385 @@
  * @copydoc DBGFOSREG::pfnRefresh
  */
-static DECLCALLBACK(int)  dbgDiggerDarwinRefresh(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerDarwinRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
@@ -391 +394 @@
      * For now we'll flush and reload everything.
      */
-    dbgDiggerDarwinTerm(pUVM, pvData);
-    return dbgDiggerDarwinInit(pUVM, pvData);
+    dbgDiggerDarwinTerm(pUVM, pVMM, pvData);
+    return dbgDiggerDarwinInit(pUVM, pVMM, pvData);
 }
 
@@ -402 +405 @@
  * @returns true if present, false if not.
  * @param   pUVM                The user mode VM structure.
+ * @param   pVMM                The VMM function table.
  * @param   uSegAddr            The segment addresss.
  * @param   cbSeg               The segment size.
@@ -407 +411 @@
  * @param   uMaxAddr            Highest allowed address.
  */
-static bool dbgDiggerDarwinIsSegmentPresent(PUVM pUVM, uint64_t uSegAddr, uint64_t cbSeg, uint64_t uMinAddr, uint64_t uMaxAddr)
+static bool dbgDiggerDarwinIsSegmentPresent(PUVM pUVM, PCVMMR3VTABLE pVMM, uint64_t uSegAddr, uint64_t cbSeg,
+                                            uint64_t uMinAddr, uint64_t uMaxAddr)
 {
     /*
@@ -449 +454 @@
         uint8_t     abBuf[8];
         DBGFADDRESS Addr;
-        int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uSegAddr), abBuf, sizeof(abBuf));
+        int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uSegAddr),
+                                        abBuf, sizeof(abBuf));
         if (RT_FAILURE(rc))
         {
@@ -500 +506 @@
 
 
-static int dbgDiggerDarwinAddModule(PDBGDIGGERDARWIN pThis, PUVM pUVM, uint64_t uModAddr, const char *pszName, bool *pf64Bit)
+static int dbgDiggerDarwinAddModule(PDBGDIGGERDARWIN pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                    uint64_t uModAddr, const char *pszName, bool *pf64Bit)
 {
     RT_NOREF1(pThis);
@@ -512 +519 @@
     /* Read the first page of the image. */
     DBGFADDRESS ModAddr;
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &ModAddr, uModAddr), uBuf.ab, X86_PAGE_4K_SIZE);
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModAddr, uModAddr), uBuf.ab, X86_PAGE_4K_SIZE);
     if (RT_FAILURE(rc))
         return rc;
@@ -539 +547 @@
     if (uBuf.Hdr32.sizeofcmds + (f64Bit ? sizeof(mach_header_64_t) : sizeof(mach_header_32_t)) > X86_PAGE_4K_SIZE)
     {
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &ModAddr, uModAddr + X86_PAGE_4K_SIZE),
-                           &uBuf.ab[X86_PAGE_4K_SIZE], X86_PAGE_4K_SIZE);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModAddr, uModAddr + X86_PAGE_4K_SIZE),
+                                    &uBuf.ab[X86_PAGE_4K_SIZE], X86_PAGE_4K_SIZE);
         if (RT_FAILURE(rc))
             return rc;
@@ -578 +586 @@
                     return VERR_INVALID_NAME;
                 if (   !strcmp(uLCmd.pSeg32->segname, "__LINKEDIT")
-                    && !(fHasLinkEdit = dbgDiggerDarwinIsSegmentPresent(pUVM, uLCmd.pSeg32->vmaddr, uLCmd.pSeg32->vmsize,
+                    && !(fHasLinkEdit = dbgDiggerDarwinIsSegmentPresent(pUVM, pVMM, uLCmd.pSeg32->vmaddr, uLCmd.pSeg32->vmsize,
                                                                         uModAddr, uModAddr + _64M)))
                     break; /* This usually is discarded or not loaded at all. */
@@ -599 +607 @@
                     return VERR_INVALID_NAME;
                 if (   !strcmp(uLCmd.pSeg64->segname, "__LINKEDIT")
-                    && !(fHasLinkEdit = dbgDiggerDarwinIsSegmentPresent(pUVM, uLCmd.pSeg64->vmaddr, uLCmd.pSeg64->vmsize,
+                    && !(fHasLinkEdit = dbgDiggerDarwinIsSegmentPresent(pUVM, pVMM, uLCmd.pSeg64->vmaddr, uLCmd.pSeg64->vmsize,
                                                                         uModAddr, uModAddr + _128M)))
                     break; /* This usually is discarded or not loaded at all. */
@@ -658 +666 @@
     RTDBGMOD hMod;
     rc = RTDbgModCreateFromMachOImage(&hMod, pszName, NULL, f64Bit ? RTLDRARCH_AMD64 : RTLDRARCH_X86_32, NULL /*phLdrModIn*/,
-                                      0 /*cbImage*/, cSegs, aSegs, &Uuid, DBGFR3AsGetConfig(pUVM),
+                                      0 /*cbImage*/, cSegs, aSegs, &Uuid, pVMM->pfnDBGFR3AsGetConfig(pUVM),
                                       RTDBGMOD_F_NOT_DEFERRED | (fHasLinkEdit ? RTDBGMOD_F_MACHO_LOAD_LINKEDIT : 0));
 
@@ -670 +678 @@
         DBGFADDRESS DbgfAddr;
         RTERRINFOSTATIC ErrInfo;
-        rc = DBGFR3ModInMem(pUVM, DBGFR3AddrFromFlat(pUVM, &DbgfAddr, uModAddr),
-                            DBGFMODINMEM_F_NO_CONTAINER_FALLBACK,
-                            pszName, NULL /*pszFilename*/, f64Bit ? RTLDRARCH_AMD64 : RTLDRARCH_X86_32, 0 /*cbImage */,
-                            &hMod, RTErrInfoInitStatic(&ErrInfo));
+        rc = pVMM->pfnDBGFR3ModInMem(pUVM, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &DbgfAddr, uModAddr),
+                                     DBGFMODINMEM_F_NO_CONTAINER_FALLBACK,
+                                     pszName, NULL /*pszFilename*/, f64Bit ? RTLDRARCH_AMD64 : RTLDRARCH_X86_32, 0 /*cbImage */,
+                                     &hMod, RTErrInfoInitStatic(&ErrInfo));
         if (RT_FAILURE(rc))
             LogRel(("OSXDig: Failed to do an in-memory-opening of '%s' at %#RX64: %Rrc%s%s\n", pszName, uModAddr, rc,
@@ -718 +726 @@
      * Link the module.
      */
-    RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     if (hAs != NIL_RTDBGAS)
     {
@@ -788 +796 @@
  * @copydoc DBGFOSREG::pfnInit
  */
-static DECLCALLBACK(int)  dbgDiggerDarwinInit(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerDarwinInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
@@ -797 +805 @@
      */
     bool f64Bit;
-    int rc = dbgDiggerDarwinAddModule(pThis, pUVM, pThis->AddrKernel.FlatPtr, "mach_kernel", &f64Bit);
+    int rc = dbgDiggerDarwinAddModule(pThis, pUVM, pVMM, pThis->AddrKernel.FlatPtr, "mach_kernel", &f64Bit);
     if (RT_SUCCESS(rc))
     {
@@ -809 +817 @@
          */
         RTDBGSYMBOL SymInfo;
-        rc = DBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "mach_kernel!kmod", &SymInfo, NULL);
+        rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "mach_kernel!kmod", &SymInfo, NULL);
         if (RT_FAILURE(rc))
-            rc = DBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "mach_kernel!_kmod", &SymInfo, NULL);
+            rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "mach_kernel!_kmod", &SymInfo, NULL);
         if (RT_SUCCESS(rc))
         {
             DBGFADDRESS AddrModInfo;
-            DBGFR3AddrFromFlat(pUVM, &AddrModInfo, SymInfo.Value);
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrModInfo, SymInfo.Value);
 
             /* Read the variable. */
             RTUINT64U uKmodValue = { 0 };
             if (f64Bit)
-                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrModInfo, &uKmodValue.u, sizeof(uKmodValue.u));
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrModInfo, &uKmodValue.u, sizeof(uKmodValue.u));
             else
-                rc = DBGFR3MemRead (pUVM, 0 /*idCpu*/, &AddrModInfo, &uKmodValue.s.Lo, sizeof(uKmodValue.s.Lo));
+                rc = pVMM->pfnDBGFR3MemRead (pUVM, 0 /*idCpu*/, &AddrModInfo, &uKmodValue.s.Lo, sizeof(uKmodValue.s.Lo));
             if (RT_SUCCESS(rc))
             {
-                DBGFR3AddrFromFlat(pUVM, &AddrModInfo, uKmodValue.u);
+                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrModInfo, uKmodValue.u);
 
                 /* Walk the list of modules. */
@@ -857 +865 @@
                     } uMod;
                     RT_ZERO(uMod);
-                    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrModInfo, &uMod,
-                                       f64Bit ? sizeof(uMod.Info64) : sizeof(uMod.Info32));
+                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrModInfo, &uMod,
+                                                f64Bit ? sizeof(uMod.Info64) : sizeof(uMod.Info32));
                     if (RT_FAILURE(rc))
                     {
@@ -941 +949 @@
                     LogRel(("OSXDig: kmod_info @%RGv: '%s' ver '%s', image @%#llx LB %#llx cbHdr=%#llx\n", AddrModInfo.FlatPtr,
                             pszName, pszVersion, uImageAddr, cbImage, cbHdr));
-                    rc = dbgDiggerDarwinAddModule(pThis, pUVM, uImageAddr, pszName, NULL);
+                    rc = dbgDiggerDarwinAddModule(pThis, pUVM, pVMM, uImageAddr, pszName, NULL);
 
 
@@ -947 +955 @@
                      * Advance to the next kmod_info entry.
                      */
-                    DBGFR3AddrFromFlat(pUVM, &AddrModInfo, f64Bit ? uMod.Info64.next : uMod.Info32.next);
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrModInfo, f64Bit ? uMod.Info64.next : uMod.Info32.next);
                 }
             }
@@ -967 +975 @@
  * @copydoc DBGFOSREG::pfnProbe
  */
-static DECLCALLBACK(bool)  dbgDiggerDarwinProbe(PUVM pUVM, void *pvData)
+static DECLCALLBACK(bool)  dbgDiggerDarwinProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
@@ -986 +994 @@
         { UINT64_C(0x00001000), UINT64_C(0x0ffff000), }
     };
-    for (unsigned iRange = DBGFR3CpuGetMode(pUVM, 0 /*idCpu*/) != CPUMMODE_LONG;
+    for (unsigned iRange = pVMM->pfnDBGFR3CpuGetMode(pUVM, 0 /*idCpu*/) != CPUMMODE_LONG;
           iRange < RT_ELEMENTS(s_aRanges);
           iRange++)
     {
         DBGFADDRESS     KernelAddr;
-        for (DBGFR3AddrFromFlat(pUVM, &KernelAddr, s_aRanges[iRange].uStart);
+        for (pVMM->pfnDBGFR3AddrFromFlat(pUVM, &KernelAddr, s_aRanges[iRange].uStart);
              KernelAddr.FlatPtr < s_aRanges[iRange].uEnd;
              KernelAddr.FlatPtr += X86_PAGE_4K_SIZE)
@@ -1001 +1009 @@
             };
 
-            int rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, s_aRanges[iRange].uEnd - KernelAddr.FlatPtr,
-                                   1, s_abNeedle, sizeof(s_abNeedle), &KernelAddr);
+            int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, s_aRanges[iRange].uEnd - KernelAddr.FlatPtr,
+                                            1, s_abNeedle, sizeof(s_abNeedle), &KernelAddr);
             if (RT_FAILURE(rc))
                 break;
-            DBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & X86_PAGE_4K_OFFSET_MASK);
+            pVMM->pfnDBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & X86_PAGE_4K_OFFSET_MASK);
 
             /*
@@ -1016 +1024 @@
                 mach_header_32_t    Hdr32;
             } uBuf;
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, uBuf.ab, X86_PAGE_4K_SIZE);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, uBuf.ab, X86_PAGE_4K_SIZE);
             if (RT_FAILURE(rc))
                 continue;
@@ -1047 +1055 @@
              * Finally, find the kernel version string.
              */
-            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, 32*_1M, 1, RT_STR_TUPLE("Darwin Kernel Version"),
-                               &pThis->AddrKernelVersion);
+            rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, 32*_1M, 1, RT_STR_TUPLE("Darwin Kernel Version"),
+                                        &pThis->AddrKernelVersion);
             if (RT_FAILURE(rc))
-                DBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelVersion, 0);
+                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelVersion, 0);
             return true;
         }
@@ -1061 +1069 @@
  * @copydoc DBGFOSREG::pfnDestruct
  */
-static DECLCALLBACK(void)  dbgDiggerDarwinDestruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
-
+static DECLCALLBACK(void)  dbgDiggerDarwinDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
 }
 
@@ -1071 +1078 @@
  * @copydoc DBGFOSREG::pfnConstruct
  */
-static DECLCALLBACK(int)  dbgDiggerDarwinConstruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerDarwinConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
 

trunk/src/VBox/Debugger/DBGPlugInDiggers.cpp

@@ -22 +22 @@
 #define LOG_GROUP LOG_GROUP_DBGC
 #include <VBox/dbg.h>
-#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include "DBGPlugIns.h"
 #include <VBox/version.h>
@@ -28 +28 @@
 
 
-DECLEXPORT(int) DbgPlugInEntry(DBGFPLUGINOP enmOperation, PUVM pUVM, uintptr_t uArg)
+DECLEXPORT(int) DbgPlugInEntry(DBGFPLUGINOP enmOperation, PUVM pUVM, PCVMMR3VTABLE pVMM, uintptr_t uArg)
 {
     static PCDBGFOSREG s_aPlugIns[] =
@@ -49 +49 @@
             for (unsigned i = 0; i < RT_ELEMENTS(s_aPlugIns); i++)
             {
-                int rc = DBGFR3OSRegister(pUVM, s_aPlugIns[i]);
+                int rc = pVMM->pfnDBGFR3OSRegister(pUVM, s_aPlugIns[i]);
                 if (RT_FAILURE(rc))
                 {
                     AssertRC(rc);
                     while (i-- > 0)
-                        DBGFR3OSDeregister(pUVM, s_aPlugIns[i]);
+                        pVMM->pfnDBGFR3OSDeregister(pUVM, s_aPlugIns[i]);
                     return rc;
                 }
@@ -65 +65 @@
             for (unsigned i = 0; i < RT_ELEMENTS(s_aPlugIns); i++)
             {
-                int rc = DBGFR3OSDeregister(pUVM, s_aPlugIns[i]);
+                int rc = pVMM->pfnDBGFR3OSDeregister(pUVM, s_aPlugIns[i]);
                 AssertRC(rc);
             }

trunk/src/VBox/Debugger/DBGPlugInFreeBsd.cpp

@@ -23 +23 @@
 #include "DBGPlugIns.h"
 #include "DBGPlugInCommonELF.h"
-#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <iprt/asm.h>
 #include <iprt/ctype.h>
@@ -195 +195 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int)  dbgDiggerFreeBsdInit(PUVM pUVM, void *pvData);
+static DECLCALLBACK(int)  dbgDiggerFreeBsdInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
 
 
@@ -226 +226 @@
  * @param   cbDynstr        Size of the .dynstr section.
  */
-static int dbgDiggerFreeBsdLoadSymbols(PDBGDIGGERFBSD pThis, PUVM pUVM, const char *pszName, RTGCUINTPTR uKernelStart,
-                                       size_t cbKernel, PDBGFADDRESS pAddrDynsym, uint32_t cSymbols, PDBGFADDRESS pAddrDynstr,
-                                       size_t cbDynstr)
+static int dbgDiggerFreeBsdLoadSymbols(PDBGDIGGERFBSD pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszName,
+                                       RTGCUINTPTR uKernelStart, size_t cbKernel, PDBGFADDRESS pAddrDynsym, uint32_t cSymbols,
+                                       PDBGFADDRESS pAddrDynstr, size_t cbDynstr)
 {
     LogFlowFunc(("pThis=%#p pszName=%s uKernelStart=%RGv cbKernel=%zu pAddrDynsym=%#p{%RGv} cSymbols=%u pAddrDynstr=%#p{%RGv} cbDynstr=%zu\n",
@@ -234 +234 @@
 
     char *pbDynstr = (char *)RTMemAllocZ(cbDynstr + 1); /* Extra terminator. */
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, pAddrDynstr, pbDynstr, cbDynstr);
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pAddrDynstr, pbDynstr, cbDynstr);
     if (RT_SUCCESS(rc))
     {
         uint32_t cbDynsymEnt = pThis->f64Bit ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym);
         uint8_t *pbDynsym = (uint8_t *)RTMemAllocZ(cSymbols * cbDynsymEnt);
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, pAddrDynsym, pbDynsym, cSymbols * cbDynsymEnt);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pAddrDynsym, pbDynsym, cSymbols * cbDynsymEnt);
         if (RT_SUCCESS(rc))
         {
@@ -294 +294 @@
                 if (RT_SUCCESS(rc))
                 {
-                    RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+                    RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
                     if (hAs != NIL_RTDBGAS)
                         rc = RTDbgAsModuleLink(hAs, hMod, uKernelStart, RTDBGASLINK_FLAGS_REPLACE);
@@ -327 +327 @@
  * @param   pThis           The instance data.
  * @param   pUVM            The user mode VM handle.
+ * @param   pVMM            The VMM function table.
  * @param   pszName         The image name.
  */
-static void dbgDiggerFreeBsdProcessKernelImage(PDBGDIGGERFBSD pThis, PUVM pUVM, const char *pszName)
+static void dbgDiggerFreeBsdProcessKernelImage(PDBGDIGGERFBSD pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszName)
 {
     /*
@@ -378 +379 @@
         size_t cbToRead = RT_MIN(sizeof(achBuf), AddrCur.FlatPtr - AddrInterpEnd.FlatPtr);
 
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrSub(&AddrCur, cbToRead), &achBuf[0], cbToRead);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrSub(&AddrCur, cbToRead), &achBuf[0], cbToRead);
         if (RT_FAILURE(rc))
             break;
@@ -403 +404 @@
                     {
                         /* Two consecutive terminator symbols mean end of .dynstr section. */
-                        DBGFR3AddrAdd(&AddrCur, i);
+                        pVMM->pfnDBGFR3AddrAdd(&AddrCur, i);
                         DBGFADDRESS AddrDynstrStart = AddrCur;
                         DBGFADDRESS AddrDynsymStart = AddrCur;
-                        DBGFR3AddrSub(&AddrDynsymStart, cSymbols * (pThis->f64Bit ? sizeof(Elf64_Sym) : sizeof(Elf64_Sym)));
+                        pVMM->pfnDBGFR3AddrSub(&AddrDynsymStart, cSymbols * (pThis->f64Bit ? sizeof(Elf64_Sym) : sizeof(Elf64_Sym)));
                         LogFlowFunc(("Found all required section start addresses (.dynsym=%RGv cSymbols=%u, .dynstr=%RGv cb=%u)\n",
                                      AddrDynsymStart.FlatPtr, cSymbols, AddrDynstrStart.FlatPtr,
                                      pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr));
-                        dbgDiggerFreeBsdLoadSymbols(pThis, pUVM, pszName, uKernelStart, cbKernel, &AddrDynsymStart, cSymbols, &AddrDynstrStart,
+                        dbgDiggerFreeBsdLoadSymbols(pThis, pUVM, pVMM, pszName, uKernelStart, cbKernel,
+                                                    &AddrDynsymStart, cSymbols, &AddrDynstrStart,
                                                     pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr);
                         return;
@@ -431 +433 @@
                         {
                             /* Indicates the end of the .dynstr section. */
-                            DBGFR3AddrAdd(&AddrCur, i);
+                            pVMM->pfnDBGFR3AddrAdd(&AddrCur, i);
                             DBGFADDRESS AddrDynstrStart = AddrCur;
                             DBGFADDRESS AddrDynsymStart = AddrCur;
-                            DBGFR3AddrSub(&AddrDynsymStart, cSymbols * (pThis->f64Bit ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym)));
+                            pVMM->pfnDBGFR3AddrSub(&AddrDynsymStart, cSymbols * (pThis->f64Bit ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym)));
                             LogFlowFunc(("Found all required section start addresses (.dynsym=%RGv cSymbols=%u, .dynstr=%RGv cb=%u)\n",
                                          AddrDynsymStart.FlatPtr, cSymbols, AddrDynstrStart.FlatPtr,
                                          pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr));
-                            dbgDiggerFreeBsdLoadSymbols(pThis, pUVM, pszName, uKernelStart, cbKernel, &AddrDynsymStart, cSymbols, &AddrDynstrStart,
+                            dbgDiggerFreeBsdLoadSymbols(pThis, pUVM, pVMM, pszName, uKernelStart, cbKernel,
+                                                        &AddrDynsymStart, cSymbols, &AddrDynstrStart,
                                                         pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr);
                             return;
@@ -455 +458 @@
     /* Calculate the start of the .hash section. */
     DBGFADDRESS AddrHashStart = pThis->AddrKernelInterp;
-    DBGFR3AddrAdd(&AddrHashStart, sizeof(g_abNeedleInterp));
+    pVMM->pfnDBGFR3AddrAdd(&AddrHashStart, sizeof(g_abNeedleInterp));
     AddrHashStart.FlatPtr = RT_ALIGN_GCPT(AddrHashStart.FlatPtr, pThis->f64Bit ? 8 : 4, RTGCUINTPTR);
     uint32_t au32Counters[2];
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrHashStart, &au32Counters[0], sizeof(au32Counters));
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrHashStart, &au32Counters[0], sizeof(au32Counters));
     if (RT_SUCCESS(rc))
     {
@@ -469 +472 @@
             RTGCUINTPTR uKernelStart = pThis->AddrKernelElfStart.FlatPtr;
 
-            DBGFR3AddrAdd(&AddrDynsymStart, cbHash);
+            pVMM->pfnDBGFR3AddrAdd(&AddrDynsymStart, cbHash);
             AddrDynsymStart.FlatPtr = RT_ALIGN_GCPT(AddrDynsymStart.FlatPtr, pThis->f64Bit ? 8 : 4, RTGCUINTPTR);
 
@@ -479 +482 @@
                 size_t cbToRead = RT_MIN(sizeof(abBuf), pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr);
 
-                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrDynstrStart, &abBuf[0], cbToRead);
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrDynstrStart, &abBuf[0], cbToRead);
                 if (RT_FAILURE(rc))
                     break;
@@ -522 +525 @@
                         if (!cbLeft)
                         {
-                            DBGFR3AddrAdd(&AddrDynstrStart, i * cbDynSymEnt);
+                            pVMM->pfnDBGFR3AddrAdd(&AddrDynstrStart, i * cbDynSymEnt);
                             LogFlowFunc(("Found all required section start addresses (.dynsym=%RGv cSymbols=%u, .dynstr=%RGv cb=%u)\n",
                                          AddrDynsymStart.FlatPtr, cSymbols, AddrDynstrStart.FlatPtr,
                                          pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr));
-                            dbgDiggerFreeBsdLoadSymbols(pThis, pUVM, pszName, uKernelStart, cbKernel, &AddrDynsymStart, cSymbols, &AddrDynstrStart,
+                            dbgDiggerFreeBsdLoadSymbols(pThis, pUVM, pVMM, pszName, uKernelStart, cbKernel,
+                                                        &AddrDynsymStart, cSymbols, &AddrDynstrStart,
                                                         pThis->AddrKernelText.FlatPtr - AddrDynstrStart.FlatPtr);
                             return;
@@ -546 +550 @@
 
                 /* Don't account incomplete entries. */
-                DBGFR3AddrAdd(&AddrDynstrStart, (cbToRead / cbDynSymEnt) * cbDynSymEnt);
+                pVMM->pfnDBGFR3AddrAdd(&AddrDynstrStart, (cbToRead / cbDynSymEnt) * cbDynSymEnt);
             }
         }
@@ -560 +564 @@
  * @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog}
  */
-static DECLCALLBACK(int) dbgDiggerFreeBsdIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, uint32_t fFlags, uint32_t cMessages,
-                                                              char *pszBuf, size_t cbBuf, size_t *pcbActual)
-{
-    RT_NOREF1(fFlags);
+static DECLCALLBACK(int) dbgDiggerFreeBsdIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, uint32_t fFlags,
+                                                              uint32_t cMessages, char *pszBuf, size_t cbBuf, size_t *pcbActual)
+{
     PDBGDIGGERFBSD pData = RT_FROM_MEMBER(pThis, DBGDIGGERFBSD, IDmesg);
+    RT_NOREF(fFlags);
 
     if (cMessages < 1)
@@ -571 +575 @@
     /* Resolve the message buffer address from the msgbufp symbol. */
     RTDBGSYMBOL SymInfo;
-    int rc = DBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "kernel!msgbufp", &SymInfo, NULL);
+    int rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "kernel!msgbufp", &SymInfo, NULL);
     if (RT_SUCCESS(rc))
     {
@@ -578 +582 @@
         /* Read the message buffer pointer. */
         RTGCPTR     GCPtrMsgBufP = 0;
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &AddrMsgBuf, SymInfo.Value),
-                           &GCPtrMsgBufP, pData->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrMsgBuf, SymInfo.Value),
+                                    &GCPtrMsgBufP, pData->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t));
         if (RT_FAILURE(rc))
         {
@@ -593 +597 @@
         /* Read the structure. */
         FBSDMSGBUF MsgBuf;
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &AddrMsgBuf, GCPtrMsgBufP),
-                           &MsgBuf, sizeof(MsgBuf));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrMsgBuf, GCPtrMsgBufP),
+                                    &MsgBuf, sizeof(MsgBuf));
         if (RT_SUCCESS(rc))
         {
@@ -627 +631 @@
                 return VERR_INVALID_STATE;
             }
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &AddrMsgBuf, AddrBuf), pchMsgBuf, cbMsgBuf);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrMsgBuf, AddrBuf),
+                                        pchMsgBuf, cbMsgBuf);
             if (RT_SUCCESS(rc))
             {
@@ -704 +709 @@
  * @copydoc DBGFOSREG::pfnStackUnwindAssist
  */
-static DECLCALLBACK(int) dbgDiggerFreeBsdStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
-                                                           PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
-                                                           uint64_t *puScratch)
-{
-    RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
+static DECLCALLBACK(int) dbgDiggerFreeBsdStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
+                                                           PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState,
+                                                           PCCPUMCTX pInitialCtx, RTDBGAS hAs, uint64_t *puScratch)
+{
+    RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
     return VINF_SUCCESS;
 }
@@ -716 +721 @@
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
-static DECLCALLBACK(void *) dbgDiggerFreeBsdQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void *) dbgDiggerFreeBsdQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
+{
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
+    RT_NOREF(pUVM, pVMM);
+
     switch (enmIf)
     {
@@ -734 +740 @@
  * @copydoc DBGFOSREG::pfnQueryVersion
  */
-static DECLCALLBACK(int)  dbgDiggerFreeBsdQueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
+static DECLCALLBACK(int)  dbgDiggerFreeBsdQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
+                                                       char *pszVersion, size_t cchVersion)
 {
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
@@ -740 +747 @@
 
     RTDBGSYMBOL SymInfo;
-    int rc = DBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "kernel!version", &SymInfo, NULL);
+    int rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "kernel!version", &SymInfo, NULL);
     if (RT_SUCCESS(rc))
     {
         DBGFADDRESS AddrVersion;
-        DBGFR3AddrFromFlat(pUVM, &AddrVersion, SymInfo.Value);
-
-        rc = DBGFR3MemReadString(pUVM, 0, &AddrVersion, pszVersion, cchVersion);
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrVersion, SymInfo.Value);
+
+        rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &AddrVersion, pszVersion, cchVersion);
         if (RT_SUCCESS(rc))
         {
@@ -768 +775 @@
  * @copydoc DBGFOSREG::pfnTerm
  */
-static DECLCALLBACK(void)  dbgDiggerFreeBsdTerm(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void)  dbgDiggerFreeBsdTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
     Assert(pThis->fValid);
-
-    RT_NOREF1(pUVM);
+    RT_NOREF(pUVM, pVMM);
 
     pThis->fValid = false;
@@ -783 +788 @@
  * @copydoc DBGFOSREG::pfnRefresh
  */
-static DECLCALLBACK(int)  dbgDiggerFreeBsdRefresh(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerFreeBsdRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
@@ -789 +794 @@
     Assert(pThis->fValid);
 
-    dbgDiggerFreeBsdTerm(pUVM, pvData);
-    return dbgDiggerFreeBsdInit(pUVM, pvData);
+    dbgDiggerFreeBsdTerm(pUVM, pVMM, pvData);
+    return dbgDiggerFreeBsdInit(pUVM, pVMM, pvData);
 }
 
@@ -797 +802 @@
  * @copydoc DBGFOSREG::pfnInit
  */
-static DECLCALLBACK(int)  dbgDiggerFreeBsdInit(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerFreeBsdInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
@@ -804 +809 @@
     RT_NOREF1(pUVM);
 
-    dbgDiggerFreeBsdProcessKernelImage(pThis, pUVM, "kernel");
+    dbgDiggerFreeBsdProcessKernelImage(pThis, pUVM, pVMM, "kernel");
     pThis->fValid = true;
     return VINF_SUCCESS;
@@ -813 +818 @@
  * @copydoc DBGFOSREG::pfnProbe
  */
-static DECLCALLBACK(bool)  dbgDiggerFreeBsdProbe(PUVM pUVM, void *pvData)
+static DECLCALLBACK(bool)  dbgDiggerFreeBsdProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
@@ -827 +832 @@
         static const uint8_t s_abNeedle[] = ELFMAG;
         DBGFADDRESS KernelAddr;
-        DBGFR3AddrFromFlat(pUVM, &KernelAddr, g_au64FreeBsdKernelAddresses[i]);
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &KernelAddr, g_au64FreeBsdKernelAddresses[i]);
         DBGFADDRESS HitAddr;
         uint32_t    cbLeft  = FBSD_MAX_KERNEL_SIZE;
@@ -833 +838 @@
         while (cbLeft > X86_PAGE_4K_SIZE)
         {
-            int rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, cbLeft, 1,
-                                   s_abNeedle, sizeof(s_abNeedle) - 1, &HitAddr);
+            int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, cbLeft, 1,
+                                            s_abNeedle, sizeof(s_abNeedle) - 1, &HitAddr);
             if (RT_FAILURE(rc))
                 break;
@@ -843 +848 @@
              */
             DBGFADDRESS HitAddrInterp;
-            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, FBSD_MAX_INTERP_OFFSET, 1,
-                               g_abNeedleInterp, sizeof(g_abNeedleInterp), &HitAddrInterp);
+            rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, FBSD_MAX_INTERP_OFFSET, 1,
+                                        g_abNeedleInterp, sizeof(g_abNeedleInterp), &HitAddrInterp);
             if (RT_SUCCESS(rc))
             {
@@ -858 +863 @@
                 AssertCompileMembersSameSizeAndOffset(Elf64_Ehdr, e_version, Elf32_Ehdr, e_version);
 
-                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &HitAddr, &ElfHdr.ab[0], X86_PAGE_4K_SIZE);
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &HitAddr, &ElfHdr.ab[0], X86_PAGE_4K_SIZE);
                 if (RT_SUCCESS(rc))
                 {
@@ -875 +880 @@
                         pThis->AddrKernelElfStart = HitAddr;
                         pThis->AddrKernelInterp = HitAddrInterp;
-                        DBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelText, FBSD_UNION(pThis, &ElfHdr, e_entry));
+                        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelText, FBSD_UNION(pThis, &ElfHdr, e_entry));
                         LogFunc(("Found %s FreeBSD kernel at %RGv (.interp section at %RGv, .text section at %RGv)\n",
                                  pThis->f64Bit ? "amd64" : "i386", pThis->AddrKernelElfStart.FlatPtr,
@@ -892 +897 @@
 
             cbLeft -= cbDistance;
-            DBGFR3AddrAdd(&KernelAddr, cbDistance);
+            pVMM->pfnDBGFR3AddrAdd(&KernelAddr, cbDistance);
         }
     }
@@ -902 +907 @@
  * @copydoc DBGFOSREG::pfnDestruct
  */
-static DECLCALLBACK(void)  dbgDiggerFreeBsdDestruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
+static DECLCALLBACK(void)  dbgDiggerFreeBsdDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
 }
 
@@ -911 +916 @@
  * @copydoc DBGFOSREG::pfnConstruct
  */
-static DECLCALLBACK(int)  dbgDiggerFreeBsdConstruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerFreeBsdConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
     PDBGDIGGERFBSD pThis = (PDBGDIGGERFBSD)pvData;
+    RT_NOREF(pUVM, pVMM);
 
     pThis->fValid = false;

trunk/src/VBox/Debugger/DBGPlugInLinux.cpp

@@ -23 +23 @@
 #include "DBGPlugIns.h"
 #include "DBGPlugInCommonELF.h"
-#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <VBox/dis.h>
 #include <iprt/ctype.h>
@@ -220 +220 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int)  dbgDiggerLinuxInit(PUVM pUVM, void *pvData);
+static DECLCALLBACK(int)  dbgDiggerLinuxInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
 
 
@@ -246 +246 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pGCPtrLogBuf        Where to store the start of the kernel log buffer on success.
  * @param   pcbLogBuf           Where to store the size of the kernel log buffer on success.
  */
-static int dbgDiggerLinuxKrnlLogBufFindByNeedle(PDBGDIGGERLINUX pThis, PUVM pUVM, RTGCPTR *pGCPtrLogBuf, uint32_t *pcbLogBuf)
+static int dbgDiggerLinuxKrnlLogBufFindByNeedle(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                                RTGCPTR *pGCPtrLogBuf, uint32_t *pcbLogBuf)
 {
     int rc = VINF_SUCCESS;
@@ -256 +258 @@
     DBGFADDRESS AddrScan;
     DBGFADDRESS AddrHit;
-    DBGFR3AddrFromFlat(pUVM, &AddrScan, pThis->f64Bit ? LNX64_KERNEL_ADDRESS_START : LNX32_KERNEL_ADDRESS_START);
-
-    rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &AddrScan, ~(RTGCUINTPTR)0, 1 /*uAlign*/,
-                       g_abKrnlLogNeedle, sizeof(g_abKrnlLogNeedle) - 1, &AddrHit);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrScan, pThis->f64Bit ? LNX64_KERNEL_ADDRESS_START : LNX32_KERNEL_ADDRESS_START);
+
+    rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &AddrScan, ~(RTGCUINTPTR)0, 1 /*uAlign*/,
+                                g_abKrnlLogNeedle, sizeof(g_abKrnlLogNeedle) - 1, &AddrHit);
     if (RT_SUCCESS(rc))
     {
@@ -266 +268 @@
         DBGFADDRESS AddrCur;
 
-        DBGFR3AddrSub(&AddrHit, sizeof(LNXPRINTKHDR));
+        pVMM->pfnDBGFR3AddrSub(&AddrHit, sizeof(LNXPRINTKHDR));
         AddrCur = AddrHit;
 
@@ -276 +278 @@
 
             LNXPRINTKHDR Hdr;
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrCur, &Hdr, sizeof(Hdr));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrCur, &Hdr, sizeof(Hdr));
             if (RT_SUCCESS(rc))
             {
@@ -294 +296 @@
 
                 cbLogBuf += Hdr.cbTotal;
-                DBGFR3AddrAdd(&AddrCur, Hdr.cbTotal);
+                pVMM->pfnDBGFR3AddrAdd(&AddrCur, Hdr.cbTotal);
             }
 
@@ -360 +362 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   hMod                The module to use.
  * @param   pszSymbol           The symbol of the getter.
@@ -365 +368 @@
  * @param   cbVal               Size of the value in bytes.
  */
-static int dbgDiggerLinuxDisassembleSimpleGetter(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
+static int dbgDiggerLinuxDisassembleSimpleGetter(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, RTDBGMOD hMod,
                                                  const char *pszSymbol, void *pvVal, uint32_t cbVal)
 {
@@ -391 +394 @@
             DBGFADDRESS Addr;
             RTGCPTR GCPtrCur = (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr + offInstr;
-            DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrCur);
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, GCPtrCur);
 
             /* Prefetch the instruction. */
             uint8_t abInstr[32];
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &abInstr[0], sizeof(abInstr));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &abInstr[0], sizeof(abInstr));
             if (RT_SUCCESS(rc))
             {
@@ -444 +447 @@
 
                                     DBGFADDRESS AddrVal;
-                                    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
-                                                       DBGFR3AddrFromFlat(pUVM, &AddrVal, GCPtrVal),
-                                                       pvVal, cbVal);
+                                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrVal, GCPtrVal),
+                                                                pvVal, cbVal);
                                 }
                             }
@@ -473 +476 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   hMod                The module to use.
  * @param   pGCPtrLogBuf        Where to store the log buffer pointer on success.
  * @param   pcbLogBuf           Where to store the size of the log buffer on success.
  */
-static int dbgDiggerLinuxQueryAsciiLogBufferPtrs(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
+static int dbgDiggerLinuxQueryAsciiLogBufferPtrs(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, RTDBGMOD hMod,
                                                  RTGCPTR *pGCPtrLogBuf, uint32_t *pcbLogBuf)
 {
@@ -522 +526 @@
             DBGFADDRESS Addr;
             RTGCPTR GCPtrCur = (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr + offInstr;
-            DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrCur);
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, GCPtrCur);
 
             /* Prefetch the instruction. */
             uint8_t abInstr[32];
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &abInstr[0], sizeof(abInstr));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &abInstr[0], sizeof(abInstr));
             if (RT_SUCCESS(rc))
             {
@@ -574 +578 @@
                                     union { uint8_t abVal[8]; uint32_t u32Val; uint64_t u64Val; } Val;
 
-                                    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
-                                                       DBGFR3AddrFromFlat(pUVM, &AddrVal, aAddresses[i].GCPtrOrigSrc),
-                                                       &Val.abVal[0], aAddresses[i].cb);
+                                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrVal,
+                                                                                            aAddresses[i].GCPtrOrigSrc),
+                                                                &Val.abVal[0], aAddresses[i].cb);
                                     if (RT_SUCCESS(rc))
                                     {
@@ -697 +702 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   hMod                The module to use.
  * @param   pGCPtrLogBuf        Where to store the log buffer pointer on success.
  * @param   pcbLogBuf           Where to store the size of the log buffer on success.
  */
-static int dbgDiggerLinuxQueryLogBufferPtrs(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
+static int dbgDiggerLinuxQueryLogBufferPtrs(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, RTDBGMOD hMod,
                                             RTGCPTR *pGCPtrLogBuf, uint32_t *pcbLogBuf)
 {
@@ -715 +721 @@
         RT_BZERO(aSymbols[i].pvVar, aSymbols[i].cbHost);
         Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
-        rc = dbgDiggerLinuxDisassembleSimpleGetter(pThis, pUVM, hMod, aSymbols[i].pszSymbol,
+        rc = dbgDiggerLinuxDisassembleSimpleGetter(pThis, pUVM, pVMM, hMod, aSymbols[i].pszSymbol,
                                                    aSymbols[i].pvVar, aSymbols[i].cbGuest);
     }
@@ -729 +735 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
- */
-static bool dbgDiggerLinuxLogBufferIsAsciiBuffer(PDBGDIGGERLINUX pThis, PUVM pUVM)
+ * @param   pVMM                The VMM function table.
+ */
+static bool dbgDiggerLinuxLogBufferIsAsciiBuffer(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM)
 {
     char szTmp[128];
@@ -736 +743 @@
 
     RT_ZERO(szTmp);
-    int rc = DBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, szTmp, sizeof(szTmp) - 1);
+    int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, szTmp, sizeof(szTmp) - 1);
     if (    RT_SUCCESS(rc)
         &&  RTStrVersionCompare(pszVer, "3.4") == -1)
@@ -750 +757 @@
  * @param   pThis       The Linux digger data.
  * @param   pUVM        The VM user mdoe handle.
+ * @param   pVMM        The VMM function table.
  * @param   hMod        The debug module handle.
  * @param   fFlags      Flags reserved for future use, MBZ.
@@ -760 +768 @@
  *                      holds the necessary buffer size.  Optional.
  */
-static int dbgDiggerLinuxLogBufferQueryAscii(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
+static int dbgDiggerLinuxLogBufferQueryAscii(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, RTDBGMOD hMod,
                                              uint32_t fFlags, uint32_t cMessages,
                                              char *pszBuf, size_t cbBuf, size_t *pcbActual)
@@ -783 +791 @@
             Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
             DBGFADDRESS Addr;
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
-                               DBGFR3AddrFromFlat(pUVM, &Addr, (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr),
-                               aSymbols[i].pvVar,  aSymbols[i].cbGuest);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr,
+                                                                    (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr),
+                                        aSymbols[i].pvVar,  aSymbols[i].cbGuest);
             if (RT_SUCCESS(rc))
                 continue;
@@ -804 +813 @@
     if (rc == VERR_NOT_FOUND)
     {
-        rc = dbgDiggerLinuxQueryAsciiLogBufferPtrs(pThis, pUVM, hMod, &GCPtrLogBuf, &cbLogBuf);
+        rc = dbgDiggerLinuxQueryAsciiLogBufferPtrs(pThis, pUVM, pVMM, hMod, &GCPtrLogBuf, &cbLogBuf);
         if (RT_FAILURE(rc))
             return rc;
@@ -835 +844 @@
     }
     DBGFADDRESS Addr;
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
     if (RT_FAILURE(rc))
     {
@@ -865 +874 @@
  * @param   pThis       The Linux digger data.
  * @param   pUVM        The VM user mode handle.
+ * @param   pVMM        The VMM function table.
  * @param   GCPtrLogBuf Flat guest address of the start of the log buffer.
  * @param   cbLogBuf    Power of two aligned size of the log buffer.
@@ -878 +888 @@
  *                      holds the necessary buffer size.  Optional.
  */
-static int dbgDiggerLinuxKrnLogBufferProcess(PDBGDIGGERLINUX pThis, PUVM pUVM, RTGCPTR GCPtrLogBuf,
+static int dbgDiggerLinuxKrnLogBufferProcess(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, RTGCPTR GCPtrLogBuf,
                                              uint32_t cbLogBuf, uint32_t idxFirst, uint32_t idxNext,
                                              uint32_t fFlags, uint32_t cMessages, char *pszBuf, size_t cbBuf,
@@ -924 +934 @@
     }
     DBGFADDRESS Addr;
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
     if (RT_FAILURE(rc))
     {
@@ -1061 +1071 @@
  * @param   pThis       The Linux digger data.
  * @param   pUVM        The VM user mdoe handle.
+ * @param   pVMM        The VMM function table.
  * @param   hMod        The debug module handle.
  * @param   fFlags      Flags reserved for future use, MBZ.
@@ -1071 +1082 @@
  *                      holds the necessary buffer size.  Optional.
  */
-static int dbgDiggerLinuxLogBufferQueryRecords(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
+static int dbgDiggerLinuxLogBufferQueryRecords(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, RTDBGMOD hMod,
                                                uint32_t fFlags, uint32_t cMessages,
                                                char *pszBuf, size_t cbBuf, size_t *pcbActual)
@@ -1097 +1108 @@
             Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
             DBGFADDRESS Addr;
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
-                               DBGFR3AddrFromFlat(pUVM, &Addr, (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr),
-                               aSymbols[i].pvVar,  aSymbols[i].cbGuest);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr,
+                                                                    (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr),
+                                        aSymbols[i].pvVar,  aSymbols[i].cbGuest);
             if (RT_SUCCESS(rc))
                 continue;
@@ -1120 +1132 @@
         idxFirst = 0;
         idxNext = 0;
-        rc = dbgDiggerLinuxQueryLogBufferPtrs(pThis, pUVM, hMod, &GCPtrLogBuf, &cbLogBuf);
+        rc = dbgDiggerLinuxQueryLogBufferPtrs(pThis, pUVM, pVMM, hMod, &GCPtrLogBuf, &cbLogBuf);
         if (RT_FAILURE(rc))
         {
@@ -1127 +1139 @@
              * and try to deduce the boundaries from there.
              */
-            rc = dbgDiggerLinuxKrnlLogBufFindByNeedle(pThis, pUVM, &GCPtrLogBuf, &cbLogBuf);
-            return rc;
-        }
-    }
-
-    return dbgDiggerLinuxKrnLogBufferProcess(pThis, pUVM, GCPtrLogBuf, cbLogBuf, idxFirst, idxNext,
+            return dbgDiggerLinuxKrnlLogBufFindByNeedle(pThis, pUVM, pVMM, &GCPtrLogBuf, &cbLogBuf);
+        }
+    }
+
+    return dbgDiggerLinuxKrnLogBufferProcess(pThis, pUVM, pVMM, GCPtrLogBuf, cbLogBuf, idxFirst, idxNext,
                                              fFlags, cMessages, pszBuf, cbBuf, pcbActual);
 }
@@ -1139 +1150 @@
  * @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog}
  */
-static DECLCALLBACK(int) dbgDiggerLinuxIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, uint32_t fFlags, uint32_t cMessages,
-                                                            char *pszBuf, size_t cbBuf, size_t *pcbActual)
+static DECLCALLBACK(int) dbgDiggerLinuxIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, uint32_t fFlags,
+                                                            uint32_t cMessages, char *pszBuf, size_t cbBuf, size_t *pcbActual)
 {
     PDBGDIGGERLINUX pData = RT_FROM_MEMBER(pThis, DBGDIGGERLINUX, IDmesg);
@@ -1150 +1161 @@
      * Resolve the symbols we need and read their values.
      */
-    RTDBGAS  hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS  hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     RTDBGMOD hMod;
     int rc = RTDbgAsModuleByName(hAs, "vmlinux", 0, &hMod);
@@ -1164 +1175 @@
          * see: http://thread.gmane.org/gmane.linux.kernel/1284184
          */
-        if (dbgDiggerLinuxLogBufferIsAsciiBuffer(pData, pUVM))
-            rc = dbgDiggerLinuxLogBufferQueryAscii(pData, pUVM, hMod, fFlags, cMessages, pszBuf, cbBuf, &cbActual);
+        if (dbgDiggerLinuxLogBufferIsAsciiBuffer(pData, pUVM, pVMM))
+            rc = dbgDiggerLinuxLogBufferQueryAscii(pData, pUVM, pVMM, hMod, fFlags, cMessages, pszBuf, cbBuf, &cbActual);
         else
-            rc = dbgDiggerLinuxLogBufferQueryRecords(pData, pUVM, hMod, fFlags, cMessages, pszBuf, cbBuf, &cbActual);
+            rc = dbgDiggerLinuxLogBufferQueryRecords(pData, pUVM, pVMM, hMod, fFlags, cMessages, pszBuf, cbBuf, &cbActual);
 
         /* Release the module in any case. */
@@ -1178 +1189 @@
          * require any symbols, try that here.
          */
-        if (!dbgDiggerLinuxLogBufferIsAsciiBuffer(pData, pUVM))
+        if (!dbgDiggerLinuxLogBufferIsAsciiBuffer(pData, pUVM, pVMM))
         {
             RTGCPTR GCPtrLogBuf = 0;
             uint32_t cbLogBuf = 0;
 
-            rc = dbgDiggerLinuxKrnlLogBufFindByNeedle(pData, pUVM, &GCPtrLogBuf, &cbLogBuf);
+            rc = dbgDiggerLinuxKrnlLogBufFindByNeedle(pData, pUVM, pVMM, &GCPtrLogBuf, &cbLogBuf);
             if (RT_SUCCESS(rc))
-                rc = dbgDiggerLinuxKrnLogBufferProcess(pData, pUVM, GCPtrLogBuf, cbLogBuf, 0 /*idxFirst*/, 0 /*idxNext*/,
+                rc = dbgDiggerLinuxKrnLogBufferProcess(pData, pUVM, pVMM, GCPtrLogBuf, cbLogBuf, 0 /*idxFirst*/, 0 /*idxNext*/,
                                                        fFlags, cMessages, pszBuf, cbBuf, &cbActual);
         }
@@ -1249 +1260 @@
  * @copydoc DBGFOSREG::pfnStackUnwindAssist
  */
-static DECLCALLBACK(int) dbgDiggerLinuxStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
-                                                         PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
-                                                         uint64_t *puScratch)
-{
-    RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
+static DECLCALLBACK(int) dbgDiggerLinuxStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
+                                                         PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx,
+                                                         RTDBGAS hAs, uint64_t *puScratch)
+{
+    RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
     return VINF_SUCCESS;
 }
@@ -1261 +1272 @@
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
-static DECLCALLBACK(void *) dbgDiggerLinuxQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void *) dbgDiggerLinuxQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
+{
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
+    RT_NOREF(pUVM, pVMM);
+
     switch (enmIf)
     {
@@ -1279 +1291 @@
  * @copydoc DBGFOSREG::pfnQueryVersion
  */
-static DECLCALLBACK(int)  dbgDiggerLinuxQueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
+static DECLCALLBACK(int)  dbgDiggerLinuxQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
+                                                     char *pszVersion, size_t cchVersion)
 {
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
@@ -1287 +1300 @@
      * It's all in the linux banner.
      */
-    int rc = DBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, pszVersion, cchVersion);
+    int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, pszVersion, cchVersion);
     if (RT_SUCCESS(rc))
     {
@@ -1307 +1320 @@
  * @copydoc DBGFOSREG::pfnTerm
  */
-static DECLCALLBACK(void)  dbgDiggerLinuxTerm(PUVM pUVM, void *pvData)
+static DECLCALLBACK(void)  dbgDiggerLinuxTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
@@ -1320 +1333 @@
      * Unlink and release our modules.
      */
-    RTDBGAS hDbgAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     if (hDbgAs != NIL_RTDBGAS)
     {
@@ -1347 +1360 @@
  * @copydoc DBGFOSREG::pfnRefresh
  */
-static DECLCALLBACK(int)  dbgDiggerLinuxRefresh(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerLinuxRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
-    NOREF(pThis);
+    RT_NOREF(pThis);
     Assert(pThis->fValid);
 
@@ -1356 +1369 @@
      * For now we'll flush and reload everything.
      */
-    dbgDiggerLinuxTerm(pUVM, pvData);
-    return dbgDiggerLinuxInit(pUVM, pvData);
+    dbgDiggerLinuxTerm(pUVM, pVMM, pvData);
+    return dbgDiggerLinuxInit(pUVM, pVMM, pvData);
 }
 
@@ -1367 +1380 @@
  * @returns VINF_SUCCESS.
  * @param   pThis               The Linux digger data to update.
+ * @param   pVMM                The VMM function table.
  * @param   pAddrKernelNames    The kallsyms_names address.
  * @param   cKernelSymbols      The number of kernel symbol.
  * @param   cbAddress           The guest address size.
  */
-static int dbgDiggerLinuxFoundStartOfNames(PDBGDIGGERLINUX pThis, PCDBGFADDRESS pAddrKernelNames,
+static int dbgDiggerLinuxFoundStartOfNames(PDBGDIGGERLINUX pThis, PCVMMR3VTABLE pVMM, PCDBGFADDRESS pAddrKernelNames,
                                            uint32_t cKernelSymbols, uint32_t cbAddress)
 {
@@ -1389 +1403 @@
         && (pThis->cKernelSymbols & 1))
         cbAlign = sizeof(int32_t);
-    DBGFR3AddrSub(&pThis->AddrKernelAddresses, cKernelSymbols * cbOffsets + cbSymbolsSkip + cbAlign);
+    pVMM->pfnDBGFR3AddrSub(&pThis->AddrKernelAddresses, cKernelSymbols * cbOffsets + cbSymbolsSkip + cbAlign);
 
     Log(("dbgDiggerLinuxFoundStartOfNames: AddrKernelAddresses=%RGv\n"
@@ -1412 +1426 @@
  *          been found and taken down.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  * @param   pHitAddr            An address we think is inside kallsyms_names.
  */
-static int dbgDiggerLinuxFindStartOfNamesAndSymbolCount(PUVM pUVM, PDBGDIGGERLINUX pThis, PCDBGFADDRESS pHitAddr)
+static int dbgDiggerLinuxFindStartOfNamesAndSymbolCount(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis,
+                                                        PCDBGFADDRESS pHitAddr)
 {
     /*
@@ -1429 +1445 @@
     uint32_t        cbBuf   = pHitAddr->FlatPtr & (sizeof(uBuf) - 1);
     DBGFADDRESS     CurAddr = *pHitAddr;
-    DBGFR3AddrSub(&CurAddr, cbBuf);
+    pVMM->pfnDBGFR3AddrSub(&CurAddr, cbBuf);
     cbBuf += sizeof(uint64_t) - 1;      /* In case our kobj hit is in the first 4/8 bytes. */
     for (;;)
     {
-        int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &CurAddr, &uBuf, sizeof(uBuf));
+        int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &CurAddr, &uBuf, sizeof(uBuf));
         if (RT_FAILURE(rc))
             return rc;
@@ -1509 +1525 @@
                             DBGFADDRESS RelAddr = CurAddr;
                             int32_t aiRelOff[3];
-                            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrAdd(&RelAddr, (i - 1) * sizeof(uint64_t) - sizeof(aiRelOff)),
-                                               &aiRelOff[0], sizeof(aiRelOff));
+                            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                        pVMM->pfnDBGFR3AddrAdd(&RelAddr,
+                                                                               (i - 1) * sizeof(uint64_t) - sizeof(aiRelOff)),
+                                                        &aiRelOff[0], sizeof(aiRelOff));
                             if (   RT_SUCCESS(rc)
                                 && LNX64_VALID_ADDRESS(uKrnlRelBase + aiRelOff[0])
@@ -1520 +1538 @@
                                 pThis->fRelKrnlAddr = true;
                                 pThis->uKernelRelativeBase = uKrnlRelBase;
-                                return dbgDiggerLinuxFoundStartOfNames(pThis,
-                                                                       DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint64_t)),
+                                return dbgDiggerLinuxFoundStartOfNames(pThis, pVMM,
+                                                                       pVMM->pfnDBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint64_t)),
                                                                        (uint32_t)uBuf.au64[i], sizeof(uint64_t));
                             }
@@ -1529 +1547 @@
                             && (i <= 1 || LNX64_VALID_ADDRESS(uBuf.au64[i - 2]))
                             && (i <= 2 || LNX64_VALID_ADDRESS(uBuf.au64[i - 3])))
-                            return dbgDiggerLinuxFoundStartOfNames(pThis,
-                                                                   DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint64_t)),
+                            return dbgDiggerLinuxFoundStartOfNames(pThis, pVMM,
+                                                                   pVMM->pfnDBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint64_t)),
                                                                    (uint32_t)uBuf.au64[i], sizeof(uint64_t));
                     }
@@ -1557 +1575 @@
                                 pThis->fRelKrnlAddr = true;
                                 pThis->uKernelRelativeBase = uKrnlRelBase;
-                                return dbgDiggerLinuxFoundStartOfNames(pThis,
-                                                                       DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint32_t)),
+                                return dbgDiggerLinuxFoundStartOfNames(pThis, pVMM,
+                                                                       pVMM->pfnDBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint32_t)),
                                                                        uBuf.au32[i], sizeof(uint32_t));
                             }
@@ -1566 +1584 @@
                             && (i <= 1 || LNX32_VALID_ADDRESS(uBuf.au32[i - 2]))
                             && (i <= 2 || LNX32_VALID_ADDRESS(uBuf.au32[i - 3])))
-                            return dbgDiggerLinuxFoundStartOfNames(pThis,
-                                                                   DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint32_t)),
+                            return dbgDiggerLinuxFoundStartOfNames(pThis, pVMM,
+                                                                   pVMM->pfnDBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint32_t)),
                                                                    uBuf.au32[i], sizeof(uint32_t));
                     }
@@ -1582 +1600 @@
         }
         cbLeft -= sizeof(uBuf);
-        DBGFR3AddrSub(&CurAddr, sizeof(uBuf));
+        pVMM->pfnDBGFR3AddrSub(&CurAddr, sizeof(uBuf));
         cbBuf = sizeof(uBuf);
     }
@@ -1593 +1611 @@
  * @returns VINF_SUCCESS
  * @param   pThis           The linux digger data to update.
+ * @param   pVMM                The VMM function table.
  * @param   pAddrMarkers    The address of the marker (kallsyms_markers).
  * @param   cbMarkerEntry   The size of a marker entry (32-bit or 64-bit).
  */
-static int dbgDiggerLinuxFoundMarkers(PDBGDIGGERLINUX pThis, PCDBGFADDRESS pAddrMarkers, uint32_t cbMarkerEntry)
+static int dbgDiggerLinuxFoundMarkers(PDBGDIGGERLINUX pThis, PCVMMR3VTABLE pVMM,
+                                      PCDBGFADDRESS pAddrMarkers, uint32_t cbMarkerEntry)
 {
     pThis->cbKernelNames         = pAddrMarkers->FlatPtr - pThis->AddrKernelNames.FlatPtr;
@@ -1602 +1622 @@
     pThis->cKernelNameMarkers    = RT_ALIGN_32(pThis->cKernelSymbols, 256) / 256;
     pThis->AddrKernelTokenTable  = *pAddrMarkers;
-    DBGFR3AddrAdd(&pThis->AddrKernelTokenTable, pThis->cKernelNameMarkers * cbMarkerEntry);
+    pVMM->pfnDBGFR3AddrAdd(&pThis->AddrKernelTokenTable, pThis->cKernelNameMarkers * cbMarkerEntry);
 
     Log(("dbgDiggerLinuxFoundMarkers: AddrKernelNames=%RGv cbKernelNames=%#x\n"
@@ -1626 +1646 @@
  *          been found and taken down.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  * @param   pHitAddr            An address we think is inside kallsyms_names.
  */
-static int dbgDiggerLinuxFindEndOfNamesAndMore(PUVM pUVM, PDBGDIGGERLINUX pThis, PCDBGFADDRESS pHitAddr)
+static int dbgDiggerLinuxFindEndOfNamesAndMore(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis, PCDBGFADDRESS pHitAddr)
 {
     /*
@@ -1644 +1665 @@
     uint32_t        offBuf  = pHitAddr->FlatPtr & (sizeof(uBuf) - 1);
     DBGFADDRESS     CurAddr = *pHitAddr;
-    DBGFR3AddrSub(&CurAddr, offBuf);
+    pVMM->pfnDBGFR3AddrSub(&CurAddr, offBuf);
     for (;;)
     {
-        int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &CurAddr, &uBuf, sizeof(uBuf));
+        int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &CurAddr, &uBuf, sizeof(uBuf));
         if (RT_FAILURE(rc))
             return rc;
@@ -1678 +1699 @@
                 && uBuf.au64[0] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
                 && uBuf.au64[0] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
-                return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrSub(&CurAddr, sizeof(uint64_t)), sizeof(uint64_t));
+                return dbgDiggerLinuxFoundMarkers(pThis, pVMM,
+                                                  pVMM->pfnDBGFR3AddrSub(&CurAddr, sizeof(uint64_t)), sizeof(uint64_t));
 
             uint32_t const cEntries = sizeof(uBuf) / sizeof(uint64_t);
@@ -1691 +1713 @@
                     if (   uBuf.au64[i + 1] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
                         && uBuf.au64[i + 1] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
-                        return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrAdd(&CurAddr, i * sizeof(uint64_t)), sizeof(uint64_t));
+                        return dbgDiggerLinuxFoundMarkers(pThis, pVMM,
+                                                          pVMM->pfnDBGFR3AddrAdd(&CurAddr, i * sizeof(uint64_t)), sizeof(uint64_t));
                 }
         }
@@ -1699 +1722 @@
                 && uBuf.au32[0] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
                 && uBuf.au32[0] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
-                return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrSub(&CurAddr, sizeof(uint32_t)), sizeof(uint32_t));
+                return dbgDiggerLinuxFoundMarkers(pThis, pVMM,
+                                                  pVMM->pfnDBGFR3AddrSub(&CurAddr, sizeof(uint32_t)), sizeof(uint32_t));
 
             uint32_t const cEntries = sizeof(uBuf) / sizeof(uint32_t);
@@ -1712 +1736 @@
                     if (   uBuf.au32[i + 1] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
                         && uBuf.au32[i + 1] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
-                        return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrAdd(&CurAddr, i * sizeof(uint32_t)), sizeof(uint32_t));
+                        return dbgDiggerLinuxFoundMarkers(pThis, pVMM,
+                                                          pVMM->pfnDBGFR3AddrAdd(&CurAddr, i * sizeof(uint32_t)), sizeof(uint32_t));
                 }
         }
@@ -1725 +1750 @@
         }
         cbLeft -= sizeof(uBuf);
-        DBGFR3AddrAdd(&CurAddr, sizeof(uBuf));
+        pVMM->pfnDBGFR3AddrAdd(&CurAddr, sizeof(uBuf));
         offBuf = 0;
     }
@@ -1739 +1764 @@
  * @returns VBox status code.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  */
-static int dbgDiggerLinuxFindTokenIndex(PUVM pUVM, PDBGDIGGERLINUX pThis)
+static int dbgDiggerLinuxFindTokenIndex(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis)
 {
     /*
@@ -1756 +1782 @@
     } uBuf;
     DBGFADDRESS CurAddr = pThis->AddrKernelTokenTable;
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &CurAddr, &uBuf, sizeof(uBuf));
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &CurAddr, &uBuf, sizeof(uBuf));
     if (RT_FAILURE(rc))
         return rc;
@@ -1789 +1815 @@
         {
             pThis->AddrKernelTokenIndex = CurAddr;
-            DBGFR3AddrAdd(&pThis->AddrKernelTokenIndex, i * sizeof(uint16_t));
+            pVMM->pfnDBGFR3AddrAdd(&pThis->AddrKernelTokenIndex, i * sizeof(uint16_t));
             pThis->cbKernelTokenTable = i * sizeof(uint16_t);
             return VINF_SUCCESS;
@@ -1805 +1831 @@
  * @returns VBox status code.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  * @param   uKernelStart        Flat kernel start address.
@@ -1811 +1838 @@
  *                              relative to the start of the kernel.
  */
-static int dbgDiggerLinuxLoadKernelSymbolsWorker(PUVM pUVM, PDBGDIGGERLINUX pThis, RTGCUINTPTR uKernelStart,
+static int dbgDiggerLinuxLoadKernelSymbolsWorker(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis, RTGCUINTPTR uKernelStart,
                                                  RTGCUINTPTR cbKernel, RTGCUINTPTR *pauSymOff)
 {
     uint8_t *pbNames = (uint8_t *)RTMemAllocZ(pThis->cbKernelNames);
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelNames, pbNames, pThis->cbKernelNames);
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelNames, pbNames, pThis->cbKernelNames);
     if (RT_SUCCESS(rc))
     {
         char *pszzTokens = (char *)RTMemAllocZ(pThis->cbKernelTokenTable);
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelTokenTable, pszzTokens, pThis->cbKernelTokenTable);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelTokenTable, pszzTokens, pThis->cbKernelTokenTable);
         if (RT_SUCCESS(rc))
         {
             uint16_t *paoffTokens = (uint16_t *)RTMemAllocZ(256 * sizeof(uint16_t));
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelTokenIndex, paoffTokens, 256 * sizeof(uint16_t));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelTokenIndex, paoffTokens, 256 * sizeof(uint16_t));
             if (RT_SUCCESS(rc))
             {
@@ -1915 +1942 @@
                     if (RT_SUCCESS(rc))
                     {
-                        RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+                        RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
                         if (hAs != NIL_RTDBGAS)
                             rc = RTDbgAsModuleLink(hAs, hMod, uKernelStart, RTDBGASLINK_FLAGS_REPLACE);
@@ -1952 +1979 @@
  * @returns VBox status code.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  */
-static int dbgDiggerLinuxLoadKernelSymbolsAbsolute(PUVM pUVM, PDBGDIGGERLINUX pThis)
+static int dbgDiggerLinuxLoadKernelSymbolsAbsolute(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis)
 {
     /*
@@ -1961 +1989 @@
     uint32_t const cbGuestAddr = pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
     void *pvAddresses = RTMemAllocZ(pThis->cKernelSymbols * cbGuestAddr);
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelAddresses, pvAddresses, pThis->cKernelSymbols * cbGuestAddr);
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelAddresses,
+                                    pvAddresses, pThis->cKernelSymbols * cbGuestAddr);
     if (RT_SUCCESS(rc))
     {
@@ -2010 +2039 @@
         RTGCUINTPTR cbKernel = uKernelEnd - uKernelStart;
         pThis->cbKernel = (uint32_t)cbKernel;
-        DBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelBase, uKernelStart);
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelBase, uKernelStart);
         Log(("dbgDiggerLinuxLoadKernelSymbolsAbsolute: uKernelStart=%RGv cbKernel=%#x\n", uKernelStart, cbKernel));
 
-        rc = dbgDiggerLinuxLoadKernelSymbolsWorker(pUVM, pThis, uKernelStart, cbKernel, pauSymOff);
+        rc = dbgDiggerLinuxLoadKernelSymbolsWorker(pUVM, pVMM, pThis, uKernelStart, cbKernel, pauSymOff);
         if (RT_FAILURE(rc))
             Log(("dbgDiggerLinuxLoadKernelSymbolsAbsolute: Loading symbols from given offset table failed: %Rrc\n", rc));
@@ -2032 +2061 @@
  * @returns VBox status code.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  */
-static int dbgDiggerLinuxLoadKernelSymbolsRelative(PUVM pUVM, PDBGDIGGERLINUX pThis)
+static int dbgDiggerLinuxLoadKernelSymbolsRelative(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis)
 {
     /*
@@ -2040 +2070 @@
      */
     int32_t *pai32Offsets = (int32_t *)RTMemAllocZ(pThis->cKernelSymbols * sizeof(int32_t));
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelAddresses, pai32Offsets, pThis->cKernelSymbols * sizeof(int32_t));
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &pThis->AddrKernelAddresses,
+                                    pai32Offsets, pThis->cKernelSymbols * sizeof(int32_t));
     if (RT_SUCCESS(rc))
     {
@@ -2076 +2107 @@
         RTGCUINTPTR cbKernel = uKernelEnd - uKernelStart;
         pThis->cbKernel = (uint32_t)cbKernel;
-        DBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelBase, uKernelStart);
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelBase, uKernelStart);
         Log(("dbgDiggerLinuxLoadKernelSymbolsRelative: uKernelStart=%RGv cbKernel=%#x\n", uKernelStart, cbKernel));
 
-        rc = dbgDiggerLinuxLoadKernelSymbolsWorker(pUVM, pThis, uKernelStart, cbKernel, pauSymOff);
+        rc = dbgDiggerLinuxLoadKernelSymbolsWorker(pUVM, pVMM, pThis, uKernelStart, cbKernel, pauSymOff);
         if (RT_FAILURE(rc))
             Log(("dbgDiggerLinuxLoadKernelSymbolsRelative: Loading symbols from given offset table failed: %Rrc\n", rc));
@@ -2098 +2129 @@
  * @returns VBox status code.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pThis               The Linux digger data.
  */
-static int dbgDiggerLinuxLoadKernelSymbols(PUVM pUVM, PDBGDIGGERLINUX pThis)
+static int dbgDiggerLinuxLoadKernelSymbols(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERLINUX pThis)
 {
     /*
@@ -2106 +2138 @@
      */
     if (pThis->fRelKrnlAddr)
-        return dbgDiggerLinuxLoadKernelSymbolsRelative(pUVM, pThis);
-    return dbgDiggerLinuxLoadKernelSymbolsAbsolute(pUVM, pThis);
+        return dbgDiggerLinuxLoadKernelSymbolsRelative(pUVM, pVMM, pThis);
+    return dbgDiggerLinuxLoadKernelSymbolsAbsolute(pUVM, pVMM, pThis);
 }
 
@@ -2133 +2165 @@
     uint32_t    uVersion;
     bool        f64Bit;
-    uint64_t  (*pfnProcessModule)(PDBGDIGGERLINUX pThis, PUVM pUVM, PDBGFADDRESS pAddrModule);
+    uint64_t  (*pfnProcessModule)(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGFADDRESS pAddrModule);
 } g_aModVersions[] =
 {
@@ -2156 +2188 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
- */
-static int dbgDiggerLinuxLoadModules(PDBGDIGGERLINUX pThis, PUVM pUVM)
+ * @param   pVMM                The VMM function table.
+ */
+static int dbgDiggerLinuxLoadModules(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM)
 {
     /*
      * Locate the list head.
      */
-    RTDBGAS     hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS     hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     RTDBGSYMBOL SymInfo;
     int rc = RTDbgAsSymbolByName(hAs, "vmlinux!modules", &SymInfo, NULL);
@@ -2184 +2217 @@
     } uListAnchor;
     DBGFADDRESS Addr;
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, SymInfo.Value),
-                       &uListAnchor, pThis->f64Bit ? sizeof(uListAnchor.u64Pair) : sizeof(uListAnchor.u32Pair));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SymInfo.Value),
+                                &uListAnchor, pThis->f64Bit ? sizeof(uListAnchor.u64Pair) : sizeof(uListAnchor.u32Pair));
     if (RT_FAILURE(rc))
     {
@@ -2229 +2262 @@
     uint64_t uModAddr = uListAnchor.u64Pair[0];
     for (size_t iModule = 0; iModule < 4096 && uModAddr != SymInfo.Value && uModAddr != 0; iModule++)
-        uModAddr = g_aModVersions[i].pfnProcessModule(pThis, pUVM, DBGFR3AddrFromFlat(pUVM, &Addr, uModAddr));
+        uModAddr = g_aModVersions[i].pfnProcessModule(pThis, pUVM, pVMM, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uModAddr));
 
     return VINF_SUCCESS;
@@ -2240 +2273 @@
  * @returns true if it's a likely fragment, false if not.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pHitAddr            The address where paNeedle was found.
  * @param   pabNeedle           The fragment we've been searching for.
  * @param   cbNeedle            The length of the fragment.
  */
-static bool dbgDiggerLinuxIsLikelyNameFragment(PUVM pUVM, PCDBGFADDRESS pHitAddr, uint8_t const *pabNeedle, uint8_t cbNeedle)
+static bool dbgDiggerLinuxIsLikelyNameFragment(PUVM pUVM, PCVMMR3VTABLE pVMM, PCDBGFADDRESS pHitAddr,
+                                               uint8_t const *pabNeedle, uint8_t cbNeedle)
 {
     /*
@@ -2269 +2304 @@
     uint8_t         abBuf[32];
     DBGFADDRESS     ReadAddr = *pHitAddr;
-    DBGFR3AddrSub(&ReadAddr, 2);
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &ReadAddr, abBuf, 2 + cbNeedle + 2);
+    pVMM->pfnDBGFR3AddrSub(&ReadAddr, 2);
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &ReadAddr, abBuf, 2 + cbNeedle + 2);
     if (RT_SUCCESS(rc))
     {
@@ -2299 +2334 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pabNeedle           The needle to use for searching.
  * @param   cbNeedle            Size of the needle in bytes.
  */
-static int dbgDiggerLinuxFindSymbolTableFromNeedle(PDBGDIGGERLINUX pThis, PUVM pUVM, uint8_t const *pabNeedle, uint8_t cbNeedle)
-{
-    int rc = VINF_SUCCESS;
-
+static int dbgDiggerLinuxFindSymbolTableFromNeedle(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                                   uint8_t const *pabNeedle, uint8_t cbNeedle)
+{
     /*
      * Go looking for the kallsyms table.  If it's there, it will be somewhere
      * after the linux_banner symbol, so use it for starting the search.
      */
+    int         rc      = VINF_SUCCESS;
     DBGFADDRESS CurAddr = pThis->AddrLinuxBanner;
     uint32_t    cbLeft  = LNX_MAX_KERNEL_SIZE;
@@ -2315 +2351 @@
     {
         DBGFADDRESS          HitAddr;
-        rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &CurAddr, cbLeft, 1 /*uAlign*/,
-                           pabNeedle, cbNeedle, &HitAddr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &CurAddr, cbLeft, 1 /*uAlign*/,
+                                    pabNeedle, cbNeedle, &HitAddr);
         if (RT_FAILURE(rc))
             break;
-        if (dbgDiggerLinuxIsLikelyNameFragment(pUVM, &HitAddr, pabNeedle, cbNeedle))
+        if (dbgDiggerLinuxIsLikelyNameFragment(pUVM, pVMM, &HitAddr, pabNeedle, cbNeedle))
         {
             /* There will be another hit near by. */
-            DBGFR3AddrAdd(&HitAddr, 1);
-            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, LNX_MAX_KALLSYMS_NAMES_SIZE, 1 /*uAlign*/,
-                               pabNeedle, cbNeedle, &HitAddr);
+            pVMM->pfnDBGFR3AddrAdd(&HitAddr, 1);
+            rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, LNX_MAX_KALLSYMS_NAMES_SIZE, 1 /*uAlign*/,
+                                        pabNeedle, cbNeedle, &HitAddr);
             if (   RT_SUCCESS(rc)
-                && dbgDiggerLinuxIsLikelyNameFragment(pUVM, &HitAddr, pabNeedle, cbNeedle))
+                && dbgDiggerLinuxIsLikelyNameFragment(pUVM, pVMM, &HitAddr, pabNeedle, cbNeedle))
             {
                 /*
@@ -2333 +2369 @@
                  * kallsyms_num_syms is aligned on sizeof(unsigned long) boundrary
                  */
-                rc = dbgDiggerLinuxFindStartOfNamesAndSymbolCount(pUVM, pThis, &HitAddr);
+                rc = dbgDiggerLinuxFindStartOfNamesAndSymbolCount(pUVM, pVMM, pThis, &HitAddr);
                 if (RT_SUCCESS(rc))
-                    rc = dbgDiggerLinuxFindEndOfNamesAndMore(pUVM, pThis, &HitAddr);
+                    rc = dbgDiggerLinuxFindEndOfNamesAndMore(pUVM, pVMM, pThis, &HitAddr);
                 if (RT_SUCCESS(rc))
-                    rc = dbgDiggerLinuxFindTokenIndex(pUVM, pThis);
+                    rc = dbgDiggerLinuxFindTokenIndex(pUVM, pVMM, pThis);
                 if (RT_SUCCESS(rc))
-                    rc = dbgDiggerLinuxLoadKernelSymbols(pUVM, pThis);
+                    rc = dbgDiggerLinuxLoadKernelSymbols(pUVM, pVMM, pThis);
                 if (RT_SUCCESS(rc))
                 {
-                    rc = dbgDiggerLinuxLoadModules(pThis, pUVM);
+                    rc = dbgDiggerLinuxLoadModules(pThis, pUVM, pVMM);
                     break;
                 }
@@ -2358 +2394 @@
         }
         cbLeft -= cbDistance;
-        DBGFR3AddrAdd(&CurAddr, cbDistance);
-
+        pVMM->pfnDBGFR3AddrAdd(&CurAddr, cbDistance);
     }
 
@@ -2666 +2701 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   pAddrStart          The start address of the compressed config.
  * @param   cbCfgComp           The size of the compressed config.
  */
-static int dbgDiggerLinuxCfgDecode(PDBGDIGGERLINUX pThis, PUVM pUVM,
+static int dbgDiggerLinuxCfgDecode(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
                                    PCDBGFADDRESS pAddrStart, size_t cbCfgComp)
 {
@@ -2677 +2713 @@
         return VERR_NO_MEMORY;
 
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, pAddrStart, pbCfgComp, cbCfgComp);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pAddrStart, pbCfgComp, cbCfgComp);
     if (RT_SUCCESS(rc))
     {
@@ -2703 +2739 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
- */
-static int dbgDiggerLinuxCfgFind(PDBGDIGGERLINUX pThis, PUVM pUVM)
-{
-    int rc = VINF_SUCCESS;
-
+ * @param   pVMM                The VMM function table.
+ */
+static int dbgDiggerLinuxCfgFind(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM)
+{
     /*
      * Go looking for the IKCFG_ST string which indicates the start
@@ -2714 +2749 @@
     static const uint8_t s_abCfgNeedleStart[] = "IKCFG_ST";
     static const uint8_t s_abCfgNeedleEnd[] = "IKCFG_ED";
+    int         rc      = VINF_SUCCESS;
     DBGFADDRESS CurAddr = pThis->AddrLinuxBanner;
     uint32_t    cbLeft  = LNX_MAX_KERNEL_SIZE;
@@ -2719 +2755 @@
     {
         DBGFADDRESS HitAddrStart;
-        rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &CurAddr, cbLeft, 1 /*uAlign*/,
-                           s_abCfgNeedleStart, sizeof(s_abCfgNeedleStart) - 1, &HitAddrStart);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &CurAddr, cbLeft, 1 /*uAlign*/,
+                                    s_abCfgNeedleStart, sizeof(s_abCfgNeedleStart) - 1, &HitAddrStart);
         if (RT_FAILURE(rc))
             break;
 
         /* Check for the end marker which shouldn't be that far away. */
-        DBGFR3AddrAdd(&HitAddrStart, sizeof(s_abCfgNeedleStart) - 1);
+        pVMM->pfnDBGFR3AddrAdd(&HitAddrStart, sizeof(s_abCfgNeedleStart) - 1);
         DBGFADDRESS HitAddrEnd;
-        rc = DBGFR3MemScan(pUVM, 0 /* idCpu */, &HitAddrStart, LNX_MAX_COMPRESSED_CFG_SIZE,
-                           1 /* uAlign */, s_abCfgNeedleEnd, sizeof(s_abCfgNeedleEnd) - 1, &HitAddrEnd);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /* idCpu */, &HitAddrStart, LNX_MAX_COMPRESSED_CFG_SIZE,
+                                    1 /* uAlign */, s_abCfgNeedleEnd, sizeof(s_abCfgNeedleEnd) - 1, &HitAddrEnd);
         if (RT_SUCCESS(rc))
         {
@@ -2734 +2770 @@
             RTGCUINTPTR cbCfg = HitAddrEnd.FlatPtr - HitAddrStart.FlatPtr;
             Assert(cbCfg == (size_t)cbCfg);
-            rc = dbgDiggerLinuxCfgDecode(pThis, pUVM, &HitAddrStart, cbCfg);
+            rc = dbgDiggerLinuxCfgDecode(pThis, pUVM, pVMM, &HitAddrStart, cbCfg);
             if (RT_SUCCESS(rc))
                 break;
@@ -2749 +2785 @@
         }
         cbLeft -= cbDistance;
-        DBGFR3AddrAdd(&CurAddr, cbDistance);
-
+        pVMM->pfnDBGFR3AddrAdd(&CurAddr, cbDistance);
     }
 
@@ -2762 +2797 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
+ * @param   pVMM                The VMM function table.
  * @param   uAddrStart          The address to start scanning at.
  * @param   cbScan              How much to scan.
  */
-static bool dbgDiggerLinuxProbeWithAddr(PDBGDIGGERLINUX pThis, PUVM pUVM, RTGCUINTPTR uAddrStart, size_t cbScan)
+static bool dbgDiggerLinuxProbeWithAddr(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                        RTGCUINTPTR uAddrStart, size_t cbScan)
 {
     /*
@@ -2772 +2809 @@
      */
     DBGFADDRESS KernelAddr;
-    DBGFR3AddrFromFlat(pUVM, &KernelAddr, uAddrStart);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &KernelAddr, uAddrStart);
     DBGFADDRESS HitAddr;
-    int rc = DBGFR3MemScan(pUVM, 0, &KernelAddr, cbScan, 1,
-                           g_abLinuxVersion, sizeof(g_abLinuxVersion) - 1, &HitAddr);
+    int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &KernelAddr, cbScan, 1,
+                                    g_abLinuxVersion, sizeof(g_abLinuxVersion) - 1, &HitAddr);
     if (RT_SUCCESS(rc))
     {
         char szTmp[128];
         char const *pszX = &szTmp[sizeof(g_abLinuxVersion) - 1];
-        rc = DBGFR3MemReadString(pUVM, 0, &HitAddr, szTmp, sizeof(szTmp));
+        rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &HitAddr, szTmp, sizeof(szTmp));
         if (    RT_SUCCESS(rc)
             &&  (   (   pszX[0] == '2'  /* 2.x.y with x in {0..6} */
@@ -2809 +2846 @@
  * @param   pThis               The Linux digger data.
  * @param   pUVM                The user mode VM handle.
- */
-static bool dbgDiggerLinuxProbeKaslr(PDBGDIGGERLINUX pThis, PUVM pUVM)
+ * @param   pVMM                The VMM function table.
+ */
+static bool dbgDiggerLinuxProbeKaslr(PDBGDIGGERLINUX pThis, PUVM pUVM, PCVMMR3VTABLE pVMM)
 {
     /**
@@ -2837 +2875 @@
      * So the highest offset the kernel can start is 0x40000000 which is 1GB (plus the maximum kernel size we defined).
      */
-    if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, LNX64_KERNEL_ADDRESS_START, _1G + LNX_MAX_KERNEL_SIZE))
+    if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, pVMM, LNX64_KERNEL_ADDRESS_START, _1G + LNX_MAX_KERNEL_SIZE))
         return true;
 
@@ -2846 +2884 @@
      * The default split is 3GB userspace and 1GB kernel, so we just search the entire upper 1GB kernel space.
      */
-    if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, LNX32_KERNEL_ADDRESS_START, _4G - LNX32_KERNEL_ADDRESS_START))
+    if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, pVMM, LNX32_KERNEL_ADDRESS_START, _4G - LNX32_KERNEL_ADDRESS_START))
         return true;
 
@@ -2855 +2893 @@
  * @copydoc DBGFOSREG::pfnInit
  */
-static DECLCALLBACK(int)  dbgDiggerLinuxInit(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerLinuxInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
@@ -2861 +2899 @@
 
     char szVersion[256] = "Linux version 4.19.0";
-    int rc = DBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, &szVersion[0], sizeof(szVersion));
+    int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, &szVersion[0], sizeof(szVersion));
     if (RT_SUCCESS(rc))
     {
@@ -2911 +2949 @@
      * the method to use.
      */
-    rc = dbgDiggerLinuxCfgFind(pThis, pUVM);
+    rc = dbgDiggerLinuxCfgFind(pThis, pUVM, pVMM);
     if (RT_FAILURE(rc))
         LogFlowFunc(("Failed to find kernel config (%Rrc), no config database available\n", rc));
 
     static const uint8_t s_abNeedle[] = "kobj";
-    rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, s_abNeedle, sizeof(s_abNeedle) - 1);
+    rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, pVMM, s_abNeedle, sizeof(s_abNeedle) - 1);
     if (RT_FAILURE(rc))
     {
         /* Try alternate needle (seen on older x86 Linux kernels). */
         static const uint8_t s_abNeedleAlt[] = "kobjec";
-        rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, s_abNeedleAlt, sizeof(s_abNeedleAlt) - 1);
+        rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, pVMM, s_abNeedleAlt, sizeof(s_abNeedleAlt) - 1);
         if (RT_FAILURE(rc))
         {
             static const uint8_t s_abNeedleOSuseX86[] = "nmi"; /* OpenSuSe 10.2 x86 */
-            rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, s_abNeedleOSuseX86, sizeof(s_abNeedleOSuseX86) - 1);
+            rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, pVMM, s_abNeedleOSuseX86, sizeof(s_abNeedleOSuseX86) - 1);
         }
     }
@@ -2937 +2975 @@
  * @copydoc DBGFOSREG::pfnProbe
  */
-static DECLCALLBACK(bool)  dbgDiggerLinuxProbe(PUVM pUVM, void *pvData)
+static DECLCALLBACK(bool)  dbgDiggerLinuxProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
@@ -2943 +2981 @@
     for (unsigned i = 0; i < RT_ELEMENTS(g_au64LnxKernelAddresses); i++)
     {
-        if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, g_au64LnxKernelAddresses[i], LNX_MAX_KERNEL_SIZE))
+        if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, pVMM, g_au64LnxKernelAddresses[i], LNX_MAX_KERNEL_SIZE))
             return true;
     }
 
     /* Maybe the kernel uses KASLR. */
-    if (dbgDiggerLinuxProbeKaslr(pThis, pUVM))
+    if (dbgDiggerLinuxProbeKaslr(pThis, pUVM, pVMM))
         return true;
 
@@ -2958 +2996 @@
  * @copydoc DBGFOSREG::pfnDestruct
  */
-static DECLCALLBACK(void)  dbgDiggerLinuxDestruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
+static DECLCALLBACK(void)  dbgDiggerLinuxDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
 }
 
@@ -2967 +3005 @@
  * @copydoc DBGFOSREG::pfnConstruct
  */
-static DECLCALLBACK(int)  dbgDiggerLinuxConstruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerLinuxConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
     pThis->IDmesg.u32Magic = DBGFOSIDMESG_MAGIC;

trunk/src/VBox/Debugger/DBGPlugInLinuxModuleCodeTmpl.cpp.h

@@ -395 +395 @@
  * @param   cSyms               Number of symbols in the array.
  */
-static int RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(PUVM pUVM, RTDBGMOD hDbgMod, LNX_PTR_T uPtrModuleStart, LNX_PTR_T uPtrSymStart, uint32_t cSyms)
+static int RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(PUVM pUVM, PCVMMR3VTABLE pVMM, RTDBGMOD hDbgMod,
+                                                                 LNX_PTR_T uPtrModuleStart, LNX_PTR_T uPtrSymStart, uint32_t cSyms)
 {
     int rc = VINF_SUCCESS;
     DBGFADDRESS AddrSym;
-    DBGFR3AddrFromFlat(pUVM, &AddrSym, uPtrSymStart);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrSym, uPtrSymStart);
 
     while (   cSyms
@@ -407 +408 @@
         uint32_t cThisLoad = RT_MIN(cSyms, RT_ELEMENTS(aSyms));
 
-        rc = DBGFR3MemRead(pUVM, 0, &AddrSym, &aSyms[0], cThisLoad * sizeof(aSyms[0]));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &AddrSym, &aSyms[0], cThisLoad * sizeof(aSyms[0]));
         if (RT_SUCCESS(rc))
         {
             cSyms -= cThisLoad;
-            DBGFR3AddrAdd(&AddrSym, cThisLoad * sizeof(aSyms[0]));
+            pVMM->pfnDBGFR3AddrAdd(&AddrSym, cThisLoad * sizeof(aSyms[0]));
 
             for (uint32_t i = 0; i < cThisLoad; i++)
@@ -417 +418 @@
                 char szSymName[128];
                 DBGFADDRESS AddrSymName;
-                rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &AddrSymName, aSyms[i].uPtrSymName),
-                                   &szSymName[0], sizeof(szSymName));
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrSymName, aSyms[i].uPtrSymName),
+                                            &szSymName[0], sizeof(szSymName));
                 if (RT_FAILURE(rc))
                     break;
@@ -428 +429 @@
 
                 Assert(aSyms[i].uValue >= uPtrModuleStart);
-                rc = RTDbgModSymbolAdd(hDbgMod, szSymName, RTDBGSEGIDX_RVA, aSyms[i].uValue - uPtrModuleStart, 0 /*cb*/, 0 /*fFlags*/, NULL);
+                rc = RTDbgModSymbolAdd(hDbgMod, szSymName, RTDBGSEGIDX_RVA, aSyms[i].uValue - uPtrModuleStart,
+                                       0 /*cb*/, 0 /*fFlags*/, NULL);
                 if (RT_SUCCESS(rc))
                     LogFlowFunc(("Added symbol '%s' successfully\n", szSymName));
@@ -447 +449 @@
  * Version specific module processing code.
  */
-static uint64_t RT_CONCAT(dbgDiggerLinuxLoadModule,LNX_SUFFIX)(PDBGDIGGERLINUX pThis, PUVM pUVM, PDBGFADDRESS pAddrModule)
+static uint64_t RT_CONCAT(dbgDiggerLinuxLoadModule,LNX_SUFFIX)(PDBGDIGGERLINUX pThis, PUVM pUVM,
+                                                               PCVMMR3VTABLE pVMM, PDBGFADDRESS pAddrModule)
 {
     RT_CONCAT(LNXKMODULE,LNX_SUFFIX) Module;
 
-    int rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrSub(pAddrModule, RT_UOFFSETOF(RT_CONCAT(LNXKMODULE,LNX_SUFFIX), uPtrNext)),
-                           &Module, sizeof(Module));
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrSub(pAddrModule, RT_UOFFSETOF(RT_CONCAT(LNXKMODULE,LNX_SUFFIX),
+                                                                                              uPtrNext)),
+                                    &Module, sizeof(Module));
     if (RT_FAILURE(rc))
     {
@@ -495 +499 @@
         if (RT_SUCCESS(rc))
         {
-            RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+            RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
             rc = RTDbgAsModuleLink(hAs, hDbgMod, uPtrModuleCore, RTDBGASLINK_FLAGS_REPLACE /*fFlags*/);
             RTDbgAsRelease(hAs);
             if (RT_SUCCESS(rc))
             {
-                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, hDbgMod, uPtrModuleCore,
+                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, pVMM, hDbgMod, uPtrModuleCore,
                                                                            Module.uPtrSyms, Module.num_syms);
                 if (RT_FAILURE(rc))
@@ -506 +510 @@
 
 #if LNX_VER >= LNX_MK_VER(2,5,55)
-                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, hDbgMod, uPtrModuleCore,
+                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, pVMM, hDbgMod, uPtrModuleCore,
                                                                            Module.uPtrGplSyms, Module.num_gpl_syms);
                 if (RT_FAILURE(rc))
@@ -513 +517 @@
 
 #if LNX_VER >= LNX_MK_VER(2,6,17)
-                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, hDbgMod, uPtrModuleCore,
+                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, pVMM, hDbgMod, uPtrModuleCore,
                                                                            Module.uPtrGplFutureSyms, Module.num_gpl_future_syms);
                 if (RT_FAILURE(rc))
@@ -520 +524 @@
 
 #if LNX_VER >= LNX_MK_VER(2,6,18)
-                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, hDbgMod, uPtrModuleCore,
+                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, pVMM, hDbgMod, uPtrModuleCore,
                                                                            Module.uPtrUnusedSyms, Module.num_unused_syms);
                 if (RT_FAILURE(rc))
                     LogRelFunc((" Faild to load unused symbols: %Rrc\n", rc));
 
-                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, hDbgMod, uPtrModuleCore,
+                rc = RT_CONCAT(dbgDiggerLinuxLoadModuleSymbols,LNX_SUFFIX)(pUVM, pVMM, hDbgMod, uPtrModuleCore,
                                                                            Module.uPtrUnusedGplSyms, Module.num_unused_gpl_syms);
                 if (RT_FAILURE(rc))

trunk/src/VBox/Debugger/DBGPlugInOS2.cpp

@@ -22 +22 @@
 #define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
 #include "DBGPlugIns.h"
-#include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <VBox/err.h>
 #include <VBox/param.h>
@@ -51 +51 @@
     /** The user-mode VM handle for use in info handlers. */
     PUVM                pUVM;
+    /** The VMM function table for use in info handlers. */
+    PCVMMR3VTABLE       pVMM;
 
     /** Whether the information is valid or not.
@@ -408 +410 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int)  dbgDiggerOS2Init(PUVM pUVM, void *pvData);
+static DECLCALLBACK(int)  dbgDiggerOS2Init(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
 
 
@@ -415 +417 @@
 {
     RT_ZERO(*pSelInfo);
-    int rc = DBGFR3SelQueryInfo(pThis->pUVM, 0 /*idCpu*/, uSel, DBGFSELQI_FLAGS_DT_GUEST, pSelInfo);
+    int rc = pThis->pVMM->pfnDBGFR3SelQueryInfo(pThis->pUVM, 0 /*idCpu*/, uSel, DBGFSELQI_FLAGS_DT_GUEST, pSelInfo);
     if (RT_SUCCESS(rc))
     {
@@ -447 +449 @@
 {
     RT_NOREF(pszArgs);
-    PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvUser;
-    DBGFSELINFO   SelInfo;
-    int rc = DBGFR3SelQueryInfo(pThis->pUVM, 0 /*idCpu*/, 0x70, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo);
+    PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
+    PUVM const          pUVM  = pThis->pUVM;
+    PCVMMR3VTABLE const pVMM  = pThis->pVMM;
+
+    DBGFSELINFO SelInfo;
+    int rc = pVMM->pfnDBGFR3SelQueryInfo(pUVM, 0 /*idCpu*/, 0x70, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo);
     if (RT_FAILURE(rc))
     {
@@ -467 +472 @@
     };
     DBGFADDRESS Addr;
-    rc = DBGFR3MemRead(pThis->pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pThis->pUVM, &Addr, SelInfo.GCPtrBase), &Sas, sizeof(Sas));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase),
+                                &Sas, sizeof(Sas));
     if (RT_FAILURE(rc))
     {
@@ -511 +517 @@
      * Info data.
      */
-    rc = DBGFR3MemRead(pThis->pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pThis->pUVM, &Addr, SelInfo.GCPtrBase + Sas.SAS_info_data),
-                       &u.Info, sizeof(u.Info));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase + Sas.SAS_info_data),
+                                &u.Info, sizeof(u.Info));
     if (RT_SUCCESS(rc))
     {
@@ -535 +542 @@
 {
     RT_NOREF(pszArgs);
-    PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvUser;
-    DBGFSELINFO   SelInfo;
+    PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
+    PUVM const          pUVM  = pThis->pUVM;
+    PCVMMR3VTABLE const pVMM  = pThis->pVMM;
+
+    DBGFSELINFO SelInfo;
     int rc = dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, pThis->selGis, UINT32_MAX, 0, "Global info segment", &SelInfo);
     if (RT_FAILURE(rc))
@@ -547 +557 @@
     OS2GIS      Gis;
     RT_ZERO(Gis);
-    rc = DBGFR3MemRead(pThis->pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pThis->pUVM, &Addr, SelInfo.GCPtrBase), &Gis,
-                       RT_MIN(sizeof(Gis), SelInfo.cbLimit + 1));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase), &Gis,
+                                RT_MIN(sizeof(Gis), SelInfo.cbLimit + 1));
     if (RT_FAILURE(rc))
     {
@@ -591 +601 @@
 {
     RT_NOREF(pszArgs);
-    PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvUser;
-    DBGFSELINFO   SelInfo;
+    PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
+    PUVM const          pUVM  = pThis->pUVM;
+    PCVMMR3VTABLE const pVMM  = pThis->pVMM;
+
+    DBGFSELINFO SelInfo;
     int rc = dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, pThis->Lis.sel, pThis->Lis.off, 19, "Local info segment", &SelInfo);
     if (RT_FAILURE(rc))
@@ -603 +616 @@
     OS2LIS      Lis;
     RT_ZERO(Lis);
-    rc = DBGFR3MemRead(pThis->pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pThis->pUVM, &Addr, SelInfo.GCPtrBase + pThis->Lis.off),
-                       &Lis, sizeof(Lis));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase + pThis->Lis.off),
+                                &Lis, sizeof(Lis));
     if (RT_FAILURE(rc))
     {
@@ -639 +652 @@
 {
     RT_NOREF(pszArgs);
-    PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvUser;
-    DBGFADDRESS   HitAddr;
-    int rc = DBGFR3MemScan(pThis->pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pThis->pUVM, &HitAddr, pThis->uKernelAddr),
-                           pThis->cbKernel, 1, RT_STR_TUPLE("Exception in module:"), &HitAddr);
+    PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
+    PUVM const          pUVM  = pThis->pUVM;
+    PCVMMR3VTABLE const pVMM  = pThis->pVMM;
+
+    DBGFADDRESS HitAddr;
+    int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &HitAddr, pThis->uKernelAddr),
+                                    pThis->cbKernel, 1, RT_STR_TUPLE("Exception in module:"), &HitAddr);
     if (RT_FAILURE(rc))
-        rc = DBGFR3MemScan(pThis->pUVM, 0 /*idCpu&*/, DBGFR3AddrFromFlat(pThis->pUVM, &HitAddr, pThis->uKernelAddr),
-                           pThis->cbKernel, 1, RT_STR_TUPLE("Exception in device driver:"), &HitAddr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu&*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &HitAddr, pThis->uKernelAddr),
+                                    pThis->cbKernel, 1, RT_STR_TUPLE("Exception in device driver:"), &HitAddr);
     /** @todo support pre-2001 kernels w/o the module/drivce name.   */
     if (RT_SUCCESS(rc))
@@ -651 +667 @@
         char szMsg[728 + 1];
         RT_ZERO(szMsg);
-        rc = DBGFR3MemRead(pThis->pUVM, 0, &HitAddr, szMsg, sizeof(szMsg) - 1);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &HitAddr, szMsg, sizeof(szMsg) - 1);
         if (szMsg[0] != '\0')
         {
@@ -681 +697 @@
  * @copydoc DBGFOSREG::pfnStackUnwindAssist
  */
-static DECLCALLBACK(int) dbgDiggerOS2StackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
-                                                       PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
-                                                       uint64_t *puScratch)
-{
-    RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
+static DECLCALLBACK(int) dbgDiggerOS2StackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
+                                                       PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx,
+                                                       RTDBGAS hAs, uint64_t *puScratch)
+{
+    RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
     return VINF_SUCCESS;
 }
@@ -693 +709 @@
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
-static DECLCALLBACK(void *) dbgDiggerOS2QueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
-{
-    RT_NOREF3(pUVM, pvData, enmIf);
+static DECLCALLBACK(void *) dbgDiggerOS2QueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
+{
+    RT_NOREF(pUVM, pVMM, pvData, enmIf);
     return NULL;
 }
@@ -703 +719 @@
  * @copydoc DBGFOSREG::pfnQueryVersion
  */
-static DECLCALLBACK(int)  dbgDiggerOS2QueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerOS2QueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
+                                                   char *pszVersion, size_t cchVersion)
+{
     PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
+    RT_NOREF(pUVM, pVMM);
     Assert(pThis->fValid);
+
     char *achOS2ProductType[32];
     char *pszOS2ProductType = (char *)achOS2ProductType;
@@ -748 +766 @@
  * @copydoc DBGFOSREG::pfnTerm
  */
-static DECLCALLBACK(void)  dbgDiggerOS2Term(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void)  dbgDiggerOS2Term(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
     PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
     Assert(pThis->fValid);
 
-    DBGFR3InfoDeregisterExternal(pUVM, "sas");
-    DBGFR3InfoDeregisterExternal(pUVM, "gis");
-    DBGFR3InfoDeregisterExternal(pUVM, "lis");
-    DBGFR3InfoDeregisterExternal(pUVM, "panic");
+    pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "sas");
+    pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "gis");
+    pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "lis");
+    pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "panic");
 
     pThis->fValid = false;
@@ -766 +783 @@
  * @copydoc DBGFOSREG::pfnRefresh
  */
-static DECLCALLBACK(int)  dbgDiggerOS2Refresh(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerOS2Refresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
@@ -775 +792 @@
      * For now we'll flush and reload everything.
      */
-    RTDBGAS hDbgAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     if (hDbgAs != NIL_RTDBGAS)
     {
@@ -795 +812 @@
     }
 
-    dbgDiggerOS2Term(pUVM, pvData);
-    return dbgDiggerOS2Init(pUVM, pvData);
+    dbgDiggerOS2Term(pUVM, pVMM, pvData);
+    return dbgDiggerOS2Init(pUVM, pVMM, pvData);
 }
 
@@ -847 +864 @@
 
 
-static void dbgdiggerOS2ProcessModule(PUVM pUVM, PDBGDIGGEROS2 pThis, DBGDIGGEROS2BUF *pBuf,
+static void dbgdiggerOS2ProcessModule(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGEROS2 pThis, DBGDIGGEROS2BUF *pBuf,
                                       const char *pszCacheSubDir, RTDBGAS hAs, RTDBGCFG hDbgCfg)
 {
@@ -877 +894 @@
      */
     DBGFADDRESS     Addr;
-    int rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, Mte.mte_swapmte), &pBuf->smte, sizeof(pBuf->smte));
+    int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Mte.mte_swapmte),
+                                    &pBuf->smte, sizeof(pBuf->smte));
     if (RT_FAILURE(rc))
     {
@@ -900 +918 @@
     {
         uint32_t cbToRead = RT_MIN(SwapMte.smte_path, sizeof(szModPath) - 1);
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_path), szModPath, cbToRead);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_path),
+                                    szModPath, cbToRead);
         szModPath[cbToRead] = '\0';
     }
@@ -922 +941 @@
      * Read the object table into the buffer.
      */
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_objtab),
-                       &pBuf->aOtes[0], sizeof(pBuf->aOtes[0]) * SwapMte.smte_objcnt);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_objtab),
+                                &pBuf->aOtes[0], sizeof(pBuf->aOtes[0]) * SwapMte.smte_objcnt);
     if (RT_FAILURE(rc))
     {
@@ -1036 +1055 @@
  * @copydoc DBGFOSREG::pfnInit
  */
-static DECLCALLBACK(int)  dbgDiggerOS2Init(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerOS2Init(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
@@ -1049 +1068 @@
      */
     /* Version info is at GIS:15h (major/minor/revision). */
-    rc = DBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, pThis->selGis, 0x15);
+    rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, pThis->selGis, 0x15);
     if (RT_FAILURE(rc))
         return VERR_NOT_SUPPORTED;
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, uBuf.au32, sizeof(uint32_t));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, uBuf.au32, sizeof(uint32_t));
     if (RT_FAILURE(rc))
         return VERR_NOT_SUPPORTED;
@@ -1064 +1083 @@
      * Try use SAS to find the module list.
      */
-    rc = DBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00);
+    rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00);
     if (RT_SUCCESS(rc))
     {
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sas, sizeof(uBuf.sas));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sas, sizeof(uBuf.sas));
         if (RT_SUCCESS(rc))
         {
-            rc = DBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, uBuf.sas.SAS_vm_data);
+            rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, uBuf.sas.SAS_vm_data);
             if (RT_SUCCESS(rc))
-                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sasvm, sizeof(uBuf.sasvm));
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sasvm, sizeof(uBuf.sasvm));
             if (RT_SUCCESS(rc))
             {
@@ -1078 +1097 @@
                  * Work the module list.
                  */
-                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uBuf.sasvm.SAS_vm_all_mte),
-                                   &uBuf.au32[0], sizeof(uBuf.au32[0]));
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.sasvm.SAS_vm_all_mte),
+                                            &uBuf.au32[0], sizeof(uBuf.au32[0]));
                 if (RT_SUCCESS(rc))
                 {
                     uint32_t uOs2Krnl = UINT32_MAX;
-                    RTDBGCFG hDbgCfg  = DBGFR3AsGetConfig(pUVM); /* (don't release this) */
-                    RTDBGAS  hAs      = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_GLOBAL);
+                    RTDBGCFG hDbgCfg  = pVMM->pfnDBGFR3AsGetConfig(pUVM); /* (don't release this) */
+                    RTDBGAS  hAs      = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_GLOBAL);
 
                     char szCacheSubDir[24];
                     RTStrPrintf(szCacheSubDir, sizeof(szCacheSubDir), "os2-%u.%u", pThis->OS2MajorVersion, pThis->OS2MinorVersion);
 
-                    DBGFR3AddrFromFlat(pUVM, &Addr, uBuf.au32[0]);
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.au32[0]);
                     while (Addr.FlatPtr != 0 && Addr.FlatPtr != UINT32_MAX)
                     {
-                        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.mte, sizeof(uBuf.mte));
+                        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.mte, sizeof(uBuf.mte));
                         if (RT_FAILURE(rc))
                             break;
@@ -1100 +1119 @@
                             uOs2Krnl = (uint32_t)Addr.FlatPtr;
 
-                        DBGFR3AddrFromFlat(pUVM, &Addr, uBuf.mte.mte_link);
-                        dbgdiggerOS2ProcessModule(pUVM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg);
+                        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.mte.mte_link);
+                        dbgdiggerOS2ProcessModule(pUVM, pVMM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg);
                     }
 
@@ -1108 +1127 @@
                     if (uOs2Krnl != UINT32_MAX)
                     {
-                        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uOs2Krnl),
-                                           &uBuf.mte, sizeof(uBuf.mte));
+                        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uOs2Krnl),
+                                                    &uBuf.mte, sizeof(uBuf.mte));
                         if (RT_SUCCESS(rc))
                         {
                             LogRel(("DbgDiggerOs2: Module @ %#010RX32: %.8s %#x %#x [again]\n", (uint32_t)Addr.FlatPtr,
                                     uBuf.mte.mte_modname, uBuf.mte.mte_flags1, uBuf.mte.mte_flags2));
-                            dbgdiggerOS2ProcessModule(pUVM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg);
+                            dbgdiggerOS2ProcessModule(pUVM, pVMM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg);
                         }
                     }
@@ -1127 +1146 @@
      * Register info handlers.
      */
-    DBGFR3InfoRegisterExternal(pUVM, "sas",   "Dumps the OS/2 system anchor block (SAS).", dbgDiggerOS2InfoSas, pThis);
-    DBGFR3InfoRegisterExternal(pUVM, "gis",   "Dumps the OS/2 global info segment (GIS).", dbgDiggerOS2InfoGis, pThis);
-    DBGFR3InfoRegisterExternal(pUVM, "lis",   "Dumps the OS/2 local info segment (current process).", dbgDiggerOS2InfoLis, pThis);
-    DBGFR3InfoRegisterExternal(pUVM, "panic", "Dumps the OS/2 system panic message.",      dbgDiggerOS2InfoPanic, pThis);
+    pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "sas",   "Dumps the OS/2 system anchor block (SAS).", dbgDiggerOS2InfoSas, pThis);
+    pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "gis",   "Dumps the OS/2 global info segment (GIS).", dbgDiggerOS2InfoGis, pThis);
+    pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "lis",   "Dumps the OS/2 local info segment (current process).", dbgDiggerOS2InfoLis, pThis);
+    pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "panic", "Dumps the OS/2 system panic message.",      dbgDiggerOS2InfoPanic, pThis);
 
     return VINF_SUCCESS;
@@ -1139 +1158 @@
  * @copydoc DBGFOSREG::pfnProbe
  */
-static DECLCALLBACK(bool)  dbgDiggerOS2Probe(PUVM pUVM, void *pvData)
+static DECLCALLBACK(bool)  dbgDiggerOS2Probe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGEROS2   pThis = (PDBGDIGGEROS2)pvData;
@@ -1154 +1173 @@
 
     /*
-     * If the DWORD at 70:0 contains 'SAS ' it's quite unlikely that this wouldn't be OS/2.
+     * If the DWORD at 70:0 is 'SAS ' it's quite unlikely that this wouldn't be OS/2.
      * Note: The SAS layout is similar between 16-bit and 32-bit OS/2, but not identical.
      * 32-bit OS/2 will have the flat kernel data selector at SAS:06. The selector is 168h
@@ -1162 +1181 @@
      */
     do {
-        rc = DBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00);
+        rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00);
         if (RT_FAILURE(rc))
             break;
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, u.au32, 256);
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, u.au32, 256);
         if (RT_FAILURE(rc))
             break;
@@ -1200 +1219 @@
  * @copydoc DBGFOSREG::pfnDestruct
  */
-static DECLCALLBACK(void)  dbgDiggerOS2Destruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
+static DECLCALLBACK(void)  dbgDiggerOS2Destruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
 }
 
@@ -1209 +1228 @@
  * @copydoc DBGFOSREG::pfnConstruct
  */
-static DECLCALLBACK(int)  dbgDiggerOS2Construct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerOS2Construct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
     PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
     pThis->fValid = false;
@@ -1217 +1235 @@
     pThis->enmVer = DBGDIGGEROS2VER_UNKNOWN;
     pThis->pUVM   = pUVM;
+    pThis->pVMM   = pVMM;
     return VINF_SUCCESS;
 }

trunk/src/VBox/Debugger/DBGPlugInSolaris.cpp

@@ -24 +24 @@
 #include "DBGPlugInCommonELF.h"
 #include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <iprt/asm.h>
 #include <iprt/err.h>
@@ -351 +352 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int)  dbgDiggerSolarisInit(PUVM pUVM, void *pvData);
+static DECLCALLBACK(int)  dbgDiggerSolarisInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
 
 
@@ -358 +359 @@
  * @copydoc DBGFOSREG::pfnStackUnwindAssist
  */
-static DECLCALLBACK(int) dbgDiggerSolarisStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
-                                                           PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
-                                                           uint64_t *puScratch)
-{
-    RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
+static DECLCALLBACK(int) dbgDiggerSolarisStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
+                                                           PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState,
+                                                           PCCPUMCTX pInitialCtx, RTDBGAS hAs, uint64_t *puScratch)
+{
+    RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
     return VINF_SUCCESS;
 }
@@ -370 +371 @@
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
-static DECLCALLBACK(void *) dbgDiggerSolarisQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
-{
-    RT_NOREF3(pUVM, pvData, enmIf);
+static DECLCALLBACK(void *) dbgDiggerSolarisQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
+{
+    RT_NOREF(pUVM, pVMM, pvData, enmIf);
     return NULL;
 }
@@ -380 +381 @@
  * @copydoc DBGFOSREG::pfnQueryVersion
  */
-static DECLCALLBACK(int)  dbgDiggerSolarisQueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
+static DECLCALLBACK(int)  dbgDiggerSolarisQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
+                                                       char *pszVersion, size_t cchVersion)
 {
     PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
@@ -392 +394 @@
     DBGFADDRESS Addr;
     RTDBGSYMBOL SymUtsName;
-    int rc = DBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "utsname", &SymUtsName, NULL);
+    int rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "utsname", &SymUtsName, NULL);
     if (RT_SUCCESS(rc))
-        rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, SymUtsName.Value), &UtsName, sizeof(UtsName));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SymUtsName.Value),
+                                    &UtsName, sizeof(UtsName));
     if (RT_FAILURE(rc))
     {
@@ -402 +405 @@
         memset(&UtsName, '\0', sizeof(UtsName));
         strcpy(&UtsName.sysname[0], "SunOS");
-        rc = DBGFR3MemScan(pUVM, 0, &pThis->AddrUnixData, SOL_UNIX_MAX_DATA_SEG_SIZE, 1,
-                           &UtsName.sysname[0], sizeof(UtsName.sysname), &Addr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &pThis->AddrUnixData, SOL_UNIX_MAX_DATA_SEG_SIZE, 1,
+                                    &UtsName.sysname[0], sizeof(UtsName.sysname), &Addr);
         if (RT_SUCCESS(rc))
-            rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Addr.FlatPtr - RT_OFFSETOF(SOL_utsname_t, sysname)),
-                               &UtsName, sizeof(UtsName));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr,
+                                                                             Addr.FlatPtr - RT_OFFSETOF(SOL_utsname_t, sysname)),
+                                        &UtsName, sizeof(UtsName));
     }
 
@@ -442 +446 @@
  * @param   pModCtl Pointer to the modctl structure.
  */
-static void dbgDiggerSolarisProcessModCtl32(PUVM pUVM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
+static void dbgDiggerSolarisProcessModCtl32(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
 {
     RT_NOREF1(pThis);
@@ -461 +465 @@
     char szModName[64];
     DBGFADDRESS Addr;
-    int rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_modname), szModName, sizeof(szModName));
+    int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_modname),
+                                          szModName, sizeof(szModName));
     if (RT_FAILURE(rc))
         return;
@@ -469 +474 @@
     AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_filename, v9_32.mod_filename);
     char szFilename[256];
-    rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_filename), szFilename, sizeof(szFilename));
+    rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_filename),
+                                      szFilename, sizeof(szFilename));
     if (RT_FAILURE(rc))
         strcpy(szFilename, szModName);
@@ -480 +486 @@
     AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_mp, v9_32.mod_mp);
     struct SOL32_module Module;
-    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_mp), &Module, sizeof(Module));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_mp), &Module, sizeof(Module));
     if (RT_FAILURE(rc))
         return;
@@ -550 +556 @@
     if (!paShdrs)
         return;
-    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
     if (RT_SUCCESS(rc))
     {
@@ -556 +562 @@
         if (pvSymSpace)
         {
-            rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace), pvSymSpace, Module.symsize);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace),
+                                        pvSymSpace, Module.symsize);
             if (RT_SUCCESS(rc))
             {
@@ -571 +578 @@
                 cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
 
-                DBGDiggerCommonParseElf32Mod(pUVM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
+                DBGDiggerCommonParseElf32Mod(pUVM, pVMM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
                                              &Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
                                              SOL32_MIN_KRNL_ADDR, SOL32_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
@@ -591 +598 @@
  * @param   pModCtl Pointer to the modctl structure.
  */
-static void dbgDiggerSolarisProcessModCtl64(PUVM pUVM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
+static void dbgDiggerSolarisProcessModCtl64(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
 {
     RT_NOREF1(pThis);
@@ -610 +617 @@
     char szModName[64];
     DBGFADDRESS Addr;
-    int rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_modname), szModName, sizeof(szModName));
+    int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_modname),
+                                          szModName, sizeof(szModName));
     if (RT_FAILURE(rc))
         return;
@@ -618 +626 @@
     AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_filename, v9_64.mod_filename);
     char szFilename[256];
-    rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_filename), szFilename, sizeof(szFilename));
+    rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_filename),
+                                      szFilename, sizeof(szFilename));
     if (RT_FAILURE(rc))
         strcpy(szFilename, szModName);
@@ -629 +638 @@
     AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_mp, v9_64.mod_mp);
     struct SOL64_module Module;
-    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_mp), &Module, sizeof(Module));
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_mp), &Module, sizeof(Module));
     if (RT_FAILURE(rc))
         return;
@@ -698 +707 @@
     if (!paShdrs)
         return;
-    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
     if (RT_SUCCESS(rc))
     {
@@ -704 +713 @@
         if (pvSymSpace)
         {
-            rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace), pvSymSpace, Module.symsize);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace),
+                                        pvSymSpace, Module.symsize);
             if (RT_SUCCESS(rc))
             {
@@ -719 +729 @@
                 cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
 
-                DBGDiggerCommonParseElf64Mod(pUVM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
+                DBGDiggerCommonParseElf64Mod(pUVM, pVMM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
                                              &Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
                                              SOL64_MIN_KRNL_ADDR, SOL64_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
@@ -735 +745 @@
  * @copydoc DBGFOSREG::pfnTerm
  */
-static DECLCALLBACK(void)  dbgDiggerSolarisTerm(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(void)  dbgDiggerSolarisTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
     PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
+    RT_NOREF(pUVM, pVMM);
     Assert(pThis->fValid);
 
@@ -748 +758 @@
  * @copydoc DBGFOSREG::pfnRefresh
  */
-static DECLCALLBACK(int)  dbgDiggerSolarisRefresh(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerSolarisRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
-    NOREF(pThis);
+    RT_NOREF(pThis);
     Assert(pThis->fValid);
 
@@ -757 +767 @@
      * For now we'll flush and reload everything.
      */
-    RTDBGAS hDbgAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     if (hDbgAs != NIL_RTDBGAS)
     {
@@ -777 +787 @@
     }
 
-    dbgDiggerSolarisTerm(pUVM, pvData);
-    return dbgDiggerSolarisInit(pUVM, pvData);
+    dbgDiggerSolarisTerm(pUVM, pVMM, pvData);
+    return dbgDiggerSolarisInit(pUVM, pVMM, pvData);
 }
 
@@ -785 +795 @@
  * @copydoc DBGFOSREG::pfnInit
  */
-static DECLCALLBACK(int)  dbgDiggerSolarisInit(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerSolarisInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
@@ -795 +805 @@
      * On Solaris the kernel and is the global address space.
      */
-    DBGFR3AsSetAlias(pUVM, DBGF_AS_KERNEL, DBGF_AS_GLOBAL);
+    pVMM->pfnDBGFR3AsSetAlias(pUVM, DBGF_AS_KERNEL, DBGF_AS_GLOBAL);
 
 /** @todo Use debug_info, build 7x / S10U6. */
@@ -803 +813 @@
      * We know it resides in the unix data segment.
      */
-    DBGFR3AddrFromFlat(pUVM, &pThis->AddrUnixModCtl, 0);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrUnixModCtl, 0);
 
     DBGFADDRESS     CurAddr = pThis->AddrUnixData;
     DBGFADDRESS     MaxAddr;
-    DBGFR3AddrFromFlat(pUVM, &MaxAddr, CurAddr.FlatPtr + SOL_UNIX_MAX_DATA_SEG_SIZE);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &MaxAddr, CurAddr.FlatPtr + SOL_UNIX_MAX_DATA_SEG_SIZE);
     const uint8_t  *pbExpr = (const uint8_t *)&pThis->AddrUnixText.FlatPtr;
     const uint32_t  cbExpr = pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
@@ -814 +824 @@
     {
         DBGFADDRESS HitAddr;
-        rc = DBGFR3MemScan(pUVM, 0, &CurAddr, MaxAddr.FlatPtr - CurAddr.FlatPtr, 1, pbExpr, cbExpr, &HitAddr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &CurAddr, MaxAddr.FlatPtr - CurAddr.FlatPtr, 1, pbExpr, cbExpr, &HitAddr);
         if (RT_FAILURE(rc))
             break;
@@ -826 +836 @@
         if (pThis->f64Bit)
         {
-            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
             SOL64v11_modctl_t ModCtlv11;
-            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
             if (RT_SUCCESS(rc))
             {
@@ -848 +858 @@
                     char szUnix[5];
                     DBGFADDRESS NameAddr;
-                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
-                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
+                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
                     if (RT_SUCCESS(rc))
                     {
@@ -866 +876 @@
         else
         {
-            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
             SOL32v11_modctl_t ModCtlv11;
-            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
             if (RT_SUCCESS(rc))
             {
@@ -888 +898 @@
                     char szUnix[5];
                     DBGFADDRESS NameAddr;
-                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
-                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
+                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
                     if (RT_SUCCESS(rc))
                     {
@@ -908 +918 @@
         if (pThis->f64Bit)
         {
-            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL64v9_modctl_t, mod_text));
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL64v9_modctl_t, mod_text));
             SOL64v9_modctl_t ModCtlv9;
-            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
             if (RT_SUCCESS(rc))
             {
@@ -928 +938 @@
                     char szUnix[5];
                     DBGFADDRESS NameAddr;
-                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
-                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
+                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
                     if (RT_SUCCESS(rc))
                     {
@@ -946 +956 @@
         else
         {
-            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v9_modctl_t, mod_text));
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v9_modctl_t, mod_text));
             SOL32v9_modctl_t ModCtlv9;
-            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
             if (RT_SUCCESS(rc))
             {
@@ -966 +976 @@
                     char szUnix[5];
                     DBGFADDRESS NameAddr;
-                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
-                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
+                    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
                     if (RT_SUCCESS(rc))
                     {
@@ -984 +994 @@
 
         /* next */
-        DBGFR3AddrFromFlat(pUVM, &CurAddr, HitAddr.FlatPtr + cbExpr);
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, HitAddr.FlatPtr + cbExpr);
     }
 
@@ -998 +1008 @@
             /* read it */
             SOL_modctl_t ModCtl;
-            rc = DBGFR3MemRead(pUVM, 0, &CurAddr, &ModCtl, cbModCtl);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &CurAddr, &ModCtl, cbModCtl);
             if (RT_FAILURE(rc))
             {
@@ -1007 +1017 @@
             /* process it. */
             if (pThis->f64Bit)
-                dbgDiggerSolarisProcessModCtl64(pUVM, pThis, &ModCtl);
+                dbgDiggerSolarisProcessModCtl64(pUVM, pVMM, pThis, &ModCtl);
             else
-                dbgDiggerSolarisProcessModCtl32(pUVM, pThis, &ModCtl);
+                dbgDiggerSolarisProcessModCtl32(pUVM, pVMM, pThis, &ModCtl);
 
             /* next */
@@ -1020 +1030 @@
                     break;
                 }
-                DBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_64.mod_next);
+                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_64.mod_next);
             }
             else
@@ -1030 +1040 @@
                     break;
                 }
-                DBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_32.mod_next);
+                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_32.mod_next);
             }
             if (++iMod >= 1024)
@@ -1048 +1058 @@
  * @copydoc DBGFOSREG::pfnProbe
  */
-static DECLCALLBACK(bool)  dbgDiggerSolarisProbe(PUVM pUVM, void *pvData)
+static DECLCALLBACK(bool)  dbgDiggerSolarisProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
@@ -1059 +1069 @@
 
     /* 32-bit search range. */
-    DBGFR3AddrFromFlat(pUVM, &Addr, 0xfe800000);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, 0xfe800000);
     RTGCUINTPTR cbRange = 0xfec00000 - 0xfe800000;
 
     DBGFADDRESS HitAddr;
     static const uint8_t s_abSunRelease[] = "SunOS Release ";
-    int rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
+    int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
     if (RT_FAILURE(rc))
     {
         /* 64-bit.... */
-        DBGFR3AddrFromFlat(pUVM, &Addr, UINT64_C(0xfffffffffb800000));
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, UINT64_C(0xfffffffffb800000));
         cbRange = UINT64_C(0xfffffffffbd00000) - UINT64_C(0xfffffffffb800000);
-        rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
         if (RT_FAILURE(rc))
             return false;
@@ -1081 +1091 @@
     static const uint8_t s_abSMI[] = "Sun Microsystems, Inc.";
     static const uint8_t s_abORCL[] = "Oracle and/or its affiliates.";
-    rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSMI, sizeof(s_abSMI) - 1, &HitAddr);
+    rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSMI, sizeof(s_abSMI) - 1, &HitAddr);
     if (RT_FAILURE(rc))
     {
         /* Try the alternate copyright string. */
-        rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abORCL, sizeof(s_abORCL) - 1, &HitAddr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abORCL, sizeof(s_abORCL) - 1, &HitAddr);
         if (RT_FAILURE(rc))
             return false;
@@ -1094 +1104 @@
      */
     pThis->AddrUnixText = Addr;
-    DBGFR3AddrAdd(&Addr, SOL_UNIX_MAX_CODE_SEG_SIZE);
+    pVMM->pfnDBGFR3AddrAdd(&Addr, SOL_UNIX_MAX_CODE_SEG_SIZE);
     pThis->AddrUnixData = Addr;
     pThis->f64Bit       = f64Bit;
@@ -1105 +1115 @@
  * @copydoc DBGFOSREG::pfnDestruct
  */
-static DECLCALLBACK(void)  dbgDiggerSolarisDestruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
-
+static DECLCALLBACK(void)  dbgDiggerSolarisDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
 }
 
@@ -1115 +1124 @@
  * @copydoc DBGFOSREG::pfnConstruct
  */
-static DECLCALLBACK(int)  dbgDiggerSolarisConstruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
+static DECLCALLBACK(int)  dbgDiggerSolarisConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
     return VINF_SUCCESS;
 }

trunk/src/VBox/Debugger/DBGPlugInWinNt.cpp

@@ -25 +25 @@
 #include <VBox/vmm/cpumctx.h>
 #include <VBox/vmm/mm.h>
+#include <VBox/vmm/vmmr3vtable.h>
 #include <VBox/err.h>
 #include <VBox/param.h>
@@ -321 +322 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static DECLCALLBACK(int)  dbgDiggerWinNtInit(PUVM pUVM, void *pvData);
+static DECLCALLBACK(int)  dbgDiggerWinNtInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
 
 
@@ -341 +342 @@
  * @param   pThis           The instance data.
  * @param   pUVM            The user mode VM handle.
- */
-static void dbgDiggerWinNtResolveKpcr(PDBGDIGGERWINNT pThis, PUVM pUVM)
+ * @param   pVMM            The VMM function table.
+ */
+static void dbgDiggerWinNtResolveKpcr(PDBGDIGGERWINNT pThis, PUVM pUVM, PCVMMR3VTABLE pVMM)
 {
     /*
@@ -352 +354 @@
      * match what we expect.
      */
-    VMCPUID cCpus = DBGFR3CpuGetCount(pUVM);
+    VMCPUID cCpus = pVMM->pfnDBGFR3CpuGetCount(pUVM);
     pThis->paKpcrAddr = (PDBGFADDRESS)RTMemAllocZ(cCpus * 2 * sizeof(DBGFADDRESS));
     if (RT_LIKELY(pThis->paKpcrAddr))
@@ -370 +372 @@
                 uint32_t GCPtrKpcrBase = 0;
 
-                rc = DBGFR3RegCpuQueryU32(pUVM, idCpu, DBGFREG_FS_BASE, &GCPtrKpcrBase);
+                rc = pVMM->pfnDBGFR3RegCpuQueryU32(pUVM, idCpu, DBGFREG_FS_BASE, &GCPtrKpcrBase);
                 if (   RT_SUCCESS(rc)
                     && WINNT32_VALID_ADDRESS(GCPtrKpcrBase))
@@ -394 +396 @@
 
                     LogFlow(("DigWinNt/KPCR[%u]: GS Base %RGv\n", idCpu, GCPtrKpcrBase));
-                    DBGFR3AddrFromFlat(pUVM, pKpcrAddr, GCPtrKpcrBase);
-
-                    rc = DBGFR3MemRead(pUVM, idCpu, pKpcrAddr, &Kpcr, sizeof(Kpcr));
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, pKpcrAddr, GCPtrKpcrBase);
+
+                    rc = pVMM->pfnDBGFR3MemRead(pUVM, idCpu, pKpcrAddr, &Kpcr, sizeof(Kpcr));
                     if (RT_SUCCESS(rc))
                     {
@@ -402 +404 @@
                         uint32_t GCPtrIdt = 0;
 
-                        rc = DBGFR3RegCpuQueryU32(pUVM, idCpu, DBGFREG_GDTR_BASE, &GCPtrGdt);
+                        rc = pVMM->pfnDBGFR3RegCpuQueryU32(pUVM, idCpu, DBGFREG_GDTR_BASE, &GCPtrGdt);
                         if (RT_SUCCESS(rc))
-                            rc = DBGFR3RegCpuQueryU32(pUVM, idCpu, DBGFREG_IDTR_BASE, &GCPtrIdt);
+                            rc = pVMM->pfnDBGFR3RegCpuQueryU32(pUVM, idCpu, DBGFREG_IDTR_BASE, &GCPtrIdt);
                         if (RT_SUCCESS(rc))
                         {
@@ -411 +413 @@
                                 && Kpcr.GCPtrSelf == pKpcrAddr->FlatPtr)
                             {
-                                DBGFR3AddrFromFlat(pUVM, pKpcrbAddr, Kpcr.GCPtrCurrentPrcb);
+                                pVMM->pfnDBGFR3AddrFromFlat(pUVM, pKpcrbAddr, Kpcr.GCPtrCurrentPrcb);
                                 LogRel(("DigWinNt/KPCR[%u]: KPCR=%RGv KPCRB=%RGv\n", idCpu, pKpcrAddr->FlatPtr, pKpcrbAddr->FlatPtr));
 
@@ -428 +430 @@
                                     DBGFADDRESS AddrKdVersBlock;
 
-                                    DBGFR3AddrFromFlat(pUVM, &AddrKdVersBlock, Kpcr.GCPtrKdVersionBlock);
-                                    rc = DBGFR3MemRead(pUVM, idCpu, &AddrKdVersBlock, &KdVersBlock, sizeof(KdVersBlock));
+                                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrKdVersBlock, Kpcr.GCPtrKdVersionBlock);
+                                    rc = pVMM->pfnDBGFR3MemRead(pUVM, idCpu, &AddrKdVersBlock, &KdVersBlock, sizeof(KdVersBlock));
                                     if (RT_SUCCESS(rc))
                                         pThis->NtBuildNumber = KdVersBlock.MinorVersion;
@@ -449 +451 @@
                 /* Read GS base which points to the base of the KPCR for each CPU. */
                 RTGCUINTPTR GCPtrTmp = 0;
-                rc = DBGFR3RegCpuQueryU64(pUVM, idCpu, DBGFREG_GS_BASE, &GCPtrTmp);
+                rc = pVMM->pfnDBGFR3RegCpuQueryU64(pUVM, idCpu, DBGFREG_GS_BASE, &GCPtrTmp);
                 if (   RT_SUCCESS(rc)
                     && !WINNT64_VALID_ADDRESS(GCPtrTmp))
@@ -457 +459 @@
                      * read the GS kernel base MSR instead.
                      */
-                    rc = DBGFR3RegCpuQueryU64(pUVM, idCpu, DBGFREG_MSR_K8_KERNEL_GS_BASE, &GCPtrTmp);
+                    rc = pVMM->pfnDBGFR3RegCpuQueryU64(pUVM, idCpu, DBGFREG_MSR_K8_KERNEL_GS_BASE, &GCPtrTmp);
                 }
 
@@ -464 +466 @@
                 {
                     LogFlow(("DigWinNt/KPCR[%u]: GS Base %RGv\n", idCpu, GCPtrTmp));
-                    DBGFR3AddrFromFlat(pUVM, pKpcrAddr, GCPtrTmp);
-
-                    rc = DBGFR3RegCpuQueryU64(pUVM, idCpu, DBGFREG_GDTR_BASE, &GCPtrTmp);
+                    pVMM->pfnDBGFR3AddrFromFlat(pUVM, pKpcrAddr, GCPtrTmp);
+
+                    rc = pVMM->pfnDBGFR3RegCpuQueryU64(pUVM, idCpu, DBGFREG_GDTR_BASE, &GCPtrTmp);
                     if (RT_SUCCESS(rc))
                     {
@@ -482 +484 @@
                         } Kpcr;
 
-                        rc = DBGFR3MemRead(pUVM, idCpu, pKpcrAddr, &Kpcr, sizeof(Kpcr));
+                        rc = pVMM->pfnDBGFR3MemRead(pUVM, idCpu, pKpcrAddr, &Kpcr, sizeof(Kpcr));
                         if (RT_SUCCESS(rc))
                         {
@@ -489 +491 @@
                                 /** @todo && TSS */ )
                             {
-                                DBGFR3AddrFromFlat(pUVM, pKpcrbAddr, Kpcr.GCPtrCurrentPrcb);
+                                pVMM->pfnDBGFR3AddrFromFlat(pUVM, pKpcrbAddr, Kpcr.GCPtrCurrentPrcb);
                                 LogRel(("DigWinNt/KPCR[%u]: KPCR=%RGv KPCRB=%RGv\n", idCpu, pKpcrAddr->FlatPtr, pKpcrbAddr->FlatPtr));
                             }
@@ -525 +527 @@
  * @param   pThis           The instance data.
  * @param   pUVM            The user mode VM handle.
+ * @param   pVMM            The VMM function table.
  * @param   pszName         The module name.
  * @param   pszFilename     The image filename.
@@ -530 +533 @@
  * @param   cbImage         The size of the image.
  */
-static void dbgDiggerWinNtProcessImage(PDBGDIGGERWINNT pThis, PUVM pUVM, const char *pszName, const char *pszFilename,
-                                       PCDBGFADDRESS pImageAddr, uint32_t cbImage)
+static void dbgDiggerWinNtProcessImage(PDBGDIGGERWINNT pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, const char *pszName,
+                                       const char *pszFilename, PCDBGFADDRESS pImageAddr, uint32_t cbImage)
 {
     LogFlow(("DigWinNt: %RGp %#x %s\n", pImageAddr->FlatPtr, cbImage, pszName));
@@ -550 +553 @@
     RTERRINFOSTATIC ErrInfo;
     RTDBGMOD        hDbgMod = NIL_RTDBGMOD;
-    int rc = DBGFR3ModInMem(pUVM, pImageAddr, pThis->fNt31 ? DBGFMODINMEM_F_PE_NT31 : 0, pszName, pszFilename,
-                            pThis->f32Bit ? RTLDRARCH_X86_32 : RTLDRARCH_AMD64, cbImage,
-                            &hDbgMod, RTErrInfoInitStatic(&ErrInfo));
+    int rc = pVMM->pfnDBGFR3ModInMem(pUVM, pImageAddr, pThis->fNt31 ? DBGFMODINMEM_F_PE_NT31 : 0, pszName, pszFilename,
+                                     pThis->f32Bit ? RTLDRARCH_X86_32 : RTLDRARCH_AMD64, cbImage,
+                                     &hDbgMod, RTErrInfoInitStatic(&ErrInfo));
     if (RT_SUCCESS(rc))
     {
@@ -564 +567 @@
          * Link the module.
          */
-        RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+        RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
         if (hAs != NIL_RTDBGAS)
             rc = RTDbgAsModuleLink(hAs, hDbgMod, pImageAddr->FlatPtr, RTDBGASLINK_FLAGS_REPLACE /*fFlags*/);
@@ -627 +630 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryVersion}
  */
-static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryVersion(struct DBGFOSIWINNT *pThis, PUVM pUVM,
+static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryVersion(struct DBGFOSIWINNT *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
                                                            uint32_t *puVersMajor, uint32_t *puVersMinor,
                                                            uint32_t *puBuildNumber, bool *pf32Bit)
 {
-    RT_NOREF(pUVM);
     PDBGDIGGERWINNT pData = RT_FROM_MEMBER(pThis, DBGDIGGERWINNT, IWinNt);
+    RT_NOREF(pUVM, pVMM);
 
     if (puVersMajor)
@@ -649 +652 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryKernelPtrs}
  */
-static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryKernelPtrs(struct DBGFOSIWINNT *pThis, PUVM pUVM,
+static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryKernelPtrs(struct DBGFOSIWINNT *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
                                                               PRTGCUINTPTR pGCPtrKernBase, PRTGCUINTPTR pGCPtrPsLoadedModuleList)
 {
-    RT_NOREF(pUVM);
     PDBGDIGGERWINNT pData = RT_FROM_MEMBER(pThis, DBGDIGGERWINNT, IWinNt);
+    RT_NOREF(pUVM, pVMM);
 
     *pGCPtrKernBase           = pData->KernelAddr.FlatPtr;
@@ -664 +667 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryKpcrForVCpu}
  */
-static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryKpcrForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, VMCPUID idCpu,
-                                                               PRTGCUINTPTR pKpcr, PRTGCUINTPTR pKpcrb)
+static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryKpcrForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                                               VMCPUID idCpu, PRTGCUINTPTR pKpcr, PRTGCUINTPTR pKpcrb)
 {
     PDBGDIGGERWINNT pData = RT_FROM_MEMBER(pThis, DBGDIGGERWINNT, IWinNt);
@@ -672 +675 @@
         return VERR_NOT_SUPPORTED;
 
-    AssertReturn(idCpu < DBGFR3CpuGetCount(pUVM), VERR_INVALID_PARAMETER);
+    AssertReturn(idCpu < pVMM->pfnDBGFR3CpuGetCount(pUVM), VERR_INVALID_CPU_ID);
 
     if (pKpcr)
@@ -685 +688 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryCurThrdForVCpu}
  */
-static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryCurThrdForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, VMCPUID idCpu,
-                                                                  PRTGCUINTPTR pCurThrd)
+static DECLCALLBACK(int) dbgDiggerWinNtIWinNt_QueryCurThrdForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                                                  VMCPUID idCpu, PRTGCUINTPTR pCurThrd)
 {
     PDBGDIGGERWINNT pData = RT_FROM_MEMBER(pThis, DBGDIGGERWINNT, IWinNt);
@@ -693 +696 @@
         return VERR_NOT_SUPPORTED;
 
-    AssertReturn(idCpu < DBGFR3CpuGetCount(pUVM), VERR_INVALID_PARAMETER);
+    AssertReturn(idCpu < pVMM->pfnDBGFR3CpuGetCount(pUVM), VERR_INVALID_CPU_ID);
 
     DBGFADDRESS AddrCurThrdPtr = pData->paKpcrbAddr[idCpu];
-    DBGFR3AddrAdd(&AddrCurThrdPtr, 0x08); /** @todo Make this prettier. */
-    return DBGFR3MemRead(pUVM, idCpu, &AddrCurThrdPtr, pCurThrd, sizeof(*pCurThrd));
+    pVMM->pfnDBGFR3AddrAdd(&AddrCurThrdPtr, 0x08); /** @todo Make this prettier. */
+    return pVMM->pfnDBGFR3MemRead(pUVM, idCpu, &AddrCurThrdPtr, pCurThrd, sizeof(*pCurThrd));
 }
 
@@ -704 +707 @@
  * @copydoc DBGFOSREG::pfnStackUnwindAssist
  */
-static DECLCALLBACK(int) dbgDiggerWinNtStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
-                                                         PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
-                                                         uint64_t *puScratch)
+static DECLCALLBACK(int) dbgDiggerWinNtStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
+                                                         PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx,
+                                                         RTDBGAS hAs, uint64_t *puScratch)
 {
     Assert(pInitialCtx);
@@ -816 +819 @@
                         /* Resize the array, zeroing the extension. */
                         if (pFrame->cSureRegs)
-                            paSureRegs = (PDBGFREGVALEX)MMR3HeapRealloc(pFrame->paSureRegs, iReg * sizeof(paSureRegs[0]));
+                            paSureRegs = (PDBGFREGVALEX)pVMM->pfnMMR3HeapRealloc(pFrame->paSureRegs, iReg * sizeof(paSureRegs[0]));
                         else
-                            paSureRegs = (PDBGFREGVALEX)MMR3HeapAllocU(pUVM, MM_TAG_DBGF_STACK, iReg * sizeof(paSureRegs[0]));
+                            paSureRegs = (PDBGFREGVALEX)pVMM->pfnMMR3HeapAllocU(pUVM, MM_TAG_DBGF_STACK, iReg * sizeof(paSureRegs[0]));
                         AssertReturn(paSureRegs, VERR_NO_MEMORY);
 
@@ -835 +838 @@
     }
 
-    RT_NOREF(pUVM, pvData, idCpu, hAs, pInitialCtx, puScratch);
+    RT_NOREF(pUVM, pVMM, pvData, idCpu, hAs, pInitialCtx, puScratch);
     return VINF_SUCCESS;
 }
@@ -843 +846 @@
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
-static DECLCALLBACK(void *) dbgDiggerWinNtQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
-{
-    RT_NOREF(pUVM);
+static DECLCALLBACK(void *) dbgDiggerWinNtQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERWINNT pThis = (PDBGDIGGERWINNT)pvData;
 
@@ -861 +864 @@
  * @copydoc DBGFOSREG::pfnQueryVersion
  */
-static DECLCALLBACK(int)  dbgDiggerWinNtQueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerWinNtQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
+                                                     char *pszVersion, size_t cchVersion)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERWINNT pThis = (PDBGDIGGERWINNT)pvData;
     Assert(pThis->fValid);
+
     const char *pszNtProductType;
     switch (pThis->NtProductType)
@@ -874 +879 @@
         default:                        pszNtProductType = "";              break;
     }
+
     RTStrPrintf(pszVersion, cchVersion, "%u.%u-%s%s (BuildNumber %u)", pThis->NtMajorVersion, pThis->NtMinorVersion,
                 pThis->f32Bit ? "x86" : "AMD64", pszNtProductType, pThis->NtBuildNumber);
@@ -883 +889 @@
  * @copydoc DBGFOSREG::pfnTerm
  */
-static DECLCALLBACK(void)  dbgDiggerWinNtTerm(PUVM pUVM, void *pvData)
+static DECLCALLBACK(void)  dbgDiggerWinNtTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     RT_NOREF1(pUVM);
@@ -893 +899 @@
      * we must unlink and ditch the modules we created.
      */
-    RTDBGAS hDbgAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
     if (hDbgAs != NIL_RTDBGAS)
     {
@@ -927 +933 @@
  * @copydoc DBGFOSREG::pfnRefresh
  */
-static DECLCALLBACK(int)  dbgDiggerWinNtRefresh(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerWinNtRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERWINNT pThis = (PDBGDIGGERWINNT)pvData;
@@ -936 +942 @@
      * For now we'll flush and reload everything.
      */
-    dbgDiggerWinNtTerm(pUVM, pvData);
-
-    return dbgDiggerWinNtInit(pUVM, pvData);
+    dbgDiggerWinNtTerm(pUVM, pVMM, pvData);
+
+    return dbgDiggerWinNtInit(pUVM, pVMM, pvData);
 }
 
@@ -945 +951 @@
  * @copydoc DBGFOSREG::pfnInit
  */
-static DECLCALLBACK(int)  dbgDiggerWinNtInit(PUVM pUVM, void *pvData)
+static DECLCALLBACK(int)  dbgDiggerWinNtInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERWINNT pThis = (PDBGDIGGERWINNT)pvData;
@@ -962 +968 @@
      * Figure the NT version.
      */
-    DBGFR3AddrFromFlat(pUVM, &Addr, pThis->f32Bit ? NTKUSERSHAREDDATA_WINNT32 : NTKUSERSHAREDDATA_WINNT64);
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &u, PAGE_SIZE);
+    pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pThis->f32Bit ? NTKUSERSHAREDDATA_WINNT32 : NTKUSERSHAREDDATA_WINNT64);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &u, PAGE_SIZE);
     if (RT_SUCCESS(rc))
     {
@@ -995 +1001 @@
         /* Read the validate the MTE. */
         NTMTE Mte;
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &Mte, pThis->f32Bit ? sizeof(Mte.vX_32) : sizeof(Mte.vX_64));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &Mte, pThis->f32Bit ? sizeof(Mte.vX_32) : sizeof(Mte.vX_64));
         if (RT_FAILURE(rc))
             break;
@@ -1036 +1042 @@
         /* Read the full name. */
         DBGFADDRESS AddrName;
-        DBGFR3AddrFromFlat(pUVM, &AddrName, WINNT_UNION(pThis, &Mte, FullDllName.Buffer));
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrName, WINNT_UNION(pThis, &Mte, FullDllName.Buffer));
         uint16_t    cbName = WINNT_UNION(pThis, &Mte, FullDllName.Length);
         if (cbName < sizeof(u))
-            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrName, &u, cbName);
+            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrName, &u, cbName);
         else
             rc = VERR_OUT_OF_RANGE;
         if (RT_FAILURE(rc))
         {
-            DBGFR3AddrFromFlat(pUVM, &AddrName, WINNT_UNION(pThis, &Mte, BaseDllName.Buffer));
+            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrName, WINNT_UNION(pThis, &Mte, BaseDllName.Buffer));
             cbName = WINNT_UNION(pThis, &Mte, BaseDllName.Length);
             if (cbName < sizeof(u))
-                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrName, &u, cbName);
+                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrName, &u, cbName);
             else
                 rc = VERR_OUT_OF_RANGE;
@@ -1064 +1070 @@
                 /* Read the start of the PE image and pass it along to a worker. */
                 DBGFADDRESS ImageAddr;
-                DBGFR3AddrFromFlat(pUVM, &ImageAddr, WINNT_UNION(pThis, &Mte, DllBase));
-                dbgDiggerWinNtProcessImage(pThis, pUVM, pszModName, pszFilename, &ImageAddr, cbImageMte);
+                pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ImageAddr, WINNT_UNION(pThis, &Mte, DllBase));
+                dbgDiggerWinNtProcessImage(pThis, pUVM, pVMM, pszModName, pszFilename, &ImageAddr, cbImageMte);
                 RTStrFree(pszFilename);
             }
@@ -1072 +1078 @@
         /* next */
         AddrPrev = Addr;
-        DBGFR3AddrFromFlat(pUVM, &Addr, WINNT_UNION(pThis, &Mte, InLoadOrderLinks.Flink));
+        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, WINNT_UNION(pThis, &Mte, InLoadOrderLinks.Flink));
     } while (   Addr.FlatPtr != pThis->KernelMteAddr.FlatPtr
              && Addr.FlatPtr != pThis->PsLoadedModuleListAddr.FlatPtr);
 
     /* Try resolving the KPCR and KPCRB addresses for each vCPU. */
-    dbgDiggerWinNtResolveKpcr(pThis, pUVM);
+    dbgDiggerWinNtResolveKpcr(pThis, pUVM, pVMM);
 
     pThis->fValid = true;
@@ -1087 +1093 @@
  * @copydoc DBGFOSREG::pfnProbe
  */
-static DECLCALLBACK(bool)  dbgDiggerWinNtProbe(PUVM pUVM, void *pvData)
+static DECLCALLBACK(bool)  dbgDiggerWinNtProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
 {
     PDBGDIGGERWINNT pThis = (PDBGDIGGERWINNT)pvData;
@@ -1111 +1117 @@
      * NT only runs in protected or long mode.
      */
-    CPUMMODE const enmMode = DBGFR3CpuGetMode(pUVM, 0 /*idCpu*/);
+    CPUMMODE const enmMode = pVMM->pfnDBGFR3CpuGetMode(pUVM, 0 /*idCpu*/);
     if (enmMode != CPUMMODE_PROTECTED && enmMode != CPUMMODE_LONG)
         return false;
@@ -1126 +1132 @@
     uint64_t uIdtrBase = 0;
     uint16_t uIdtrLimit = 0;
-    int rc = DBGFR3RegCpuQueryXdtr(pUVM, 0, DBGFREG_IDTR, &uIdtrBase, &uIdtrLimit);
+    int rc = pVMM->pfnDBGFR3RegCpuQueryXdtr(pUVM, 0, DBGFREG_IDTR, &uIdtrBase, &uIdtrLimit);
     AssertRCReturn(rc, false);
 
@@ -1133 +1139 @@
         return false;
 
-    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uIdtrBase), &u, cbMinIdtr);
+    rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uIdtrBase), &u, cbMinIdtr);
     if (RT_FAILURE(rc))
         return false;
@@ -1167 +1173 @@
      */
     DBGFADDRESS KernelAddr;
-    for (DBGFR3AddrFromFlat(pUVM, &KernelAddr, uKrnlStart);
+    for (pVMM->pfnDBGFR3AddrFromFlat(pUVM, &KernelAddr, uKrnlStart);
          KernelAddr.FlatPtr < uKrnlEnd;
          KernelAddr.FlatPtr += PAGE_SIZE)
@@ -1173 +1179 @@
         bool fNt31 = false;
         DBGFADDRESS const RetryAddress = KernelAddr;
-        rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, uEnd - KernelAddr.FlatPtr,
-                           8, "PAGELK\0", sizeof("PAGELK\0"), &KernelAddr);
+        rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, uEnd - KernelAddr.FlatPtr,
+                                    8, "PAGELK\0", sizeof("PAGELK\0"), &KernelAddr);
         if (   rc == VERR_DBGF_MEM_NOT_FOUND
             && enmMode != CPUMMODE_LONG)
@@ -1180 +1186 @@
             /* NT3.1 didn't have a PAGELK section, so look for _TEXT instead.  The
                following VirtualSize is zero, so check for that too. */
-            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &RetryAddress, uEnd - RetryAddress.FlatPtr,
-                               8, "_TEXT\0\0\0\0\0\0", sizeof("_TEXT\0\0\0\0\0\0"), &KernelAddr);
+            rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &RetryAddress, uEnd - RetryAddress.FlatPtr,
+                                        8, "_TEXT\0\0\0\0\0\0", sizeof("_TEXT\0\0\0\0\0\0"), &KernelAddr);
             fNt31 = true;
         }
         if (RT_FAILURE(rc))
             break;
-        DBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & PAGE_OFFSET_MASK);
+        pVMM->pfnDBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & PAGE_OFFSET_MASK);
 
         /* MZ + PE header. */
-        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, &u, sizeof(u));
+        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, &u, sizeof(u));
         if (    RT_SUCCESS(rc)
             &&  u.MzHdr.e_magic == IMAGE_DOS_SIGNATURE
@@ -1214 +1220 @@
                     uMte.v32.SizeOfImage = !fNt31 ? pHdrs->OptionalHeader.SizeOfImage : 0; /* NT 3.1 didn't set the size. */
                     DBGFADDRESS HitAddr;
-                    rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, uEnd - KernelAddr.FlatPtr,
-                                       4 /*align*/, &uMte.v32.DllBase, 3 * sizeof(uint32_t), &HitAddr);
+                    rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, uEnd - KernelAddr.FlatPtr,
+                                                4 /*align*/, &uMte.v32.DllBase, 3 * sizeof(uint32_t), &HitAddr);
                     while (RT_SUCCESS(rc))
                     {
                         /* check the name. */
                         DBGFADDRESS MteAddr = HitAddr;
-                        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrSub(&MteAddr, RT_OFFSETOF(NTMTE32, DllBase)),
-                                           &uMte2.v32, sizeof(uMte2.v32));
+                        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                    pVMM->pfnDBGFR3AddrSub(&MteAddr, RT_OFFSETOF(NTMTE32, DllBase)),
+                                                    &uMte2.v32, sizeof(uMte2.v32));
                         if (    RT_SUCCESS(rc)
                             &&  uMte2.v32.DllBase     == uMte.v32.DllBase
@@ -1233 +1240 @@
                            )
                         {
-                            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v32.BaseDllName.Buffer),
-                                               u.wsz, uMte2.v32.BaseDllName.Length);
+                            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v32.BaseDllName.Buffer),
+                                                        u.wsz, uMte2.v32.BaseDllName.Length);
                             u.wsz[uMte2.v32.BaseDllName.Length / 2] = '\0';
                             if (    RT_SUCCESS(rc)
@@ -1242 +1250 @@
                                )
                             {
-                                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
-                                                   DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v32.InLoadOrderLinks.Blink),
-                                                   &uMte3.v32, RT_SIZEOFMEMB(NTMTE32, InLoadOrderLinks));
+                                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr,
+                                                                                        uMte2.v32.InLoadOrderLinks.Blink),
+                                                            &uMte3.v32, RT_SIZEOFMEMB(NTMTE32, InLoadOrderLinks));
                                 if (   RT_SUCCESS(rc)
                                     && uMte3.v32.InLoadOrderLinks.Flink == MteAddr.FlatPtr
@@ -1268 +1277 @@
 
                         /* next */
-                        DBGFR3AddrAdd(&HitAddr, 4);
+                        pVMM->pfnDBGFR3AddrAdd(&HitAddr, 4);
                         if (HitAddr.FlatPtr < uEnd)
-                            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, uEnd - HitAddr.FlatPtr,
-                                               4 /*align*/, &uMte.v32.DllBase, 3 * sizeof(uint32_t), &HitAddr);
+                            rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, uEnd - HitAddr.FlatPtr,
+                                                        4 /*align*/, &uMte.v32.DllBase, 3 * sizeof(uint32_t), &HitAddr);
                         else
                             rc = VERR_DBGF_MEM_NOT_FOUND;
@@ -1297 +1306 @@
                     DBGFADDRESS ScanAddr;
                     DBGFADDRESS HitAddr;
-                    rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &ScanAddr, uStart),
-                                       uEnd - uStart, 8 /*align*/, &uMte.v64.DllBase, 5 * sizeof(uint32_t), &HitAddr);
+                    rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ScanAddr, uStart),
+                                                uEnd - uStart, 8 /*align*/, &uMte.v64.DllBase, 5 * sizeof(uint32_t), &HitAddr);
                     while (RT_SUCCESS(rc))
                     {
                         /* Read the start of the MTE and check some basic members. */
                         DBGFADDRESS MteAddr = HitAddr;
-                        rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrSub(&MteAddr, RT_OFFSETOF(NTMTE64, DllBase)),
-                                           &uMte2.v64, sizeof(uMte2.v64));
+                        rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                    pVMM->pfnDBGFR3AddrSub(&MteAddr, RT_OFFSETOF(NTMTE64, DllBase)),
+                                                    &uMte2.v64, sizeof(uMte2.v64));
                         if (    RT_SUCCESS(rc)
                             &&  uMte2.v64.DllBase     == uMte.v64.DllBase
@@ -1317 +1327 @@
                         {
                             /* Try read the base name and compare with known NT kernel names. */
-                            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v64.BaseDllName.Buffer),
-                                               u.wsz, uMte2.v64.BaseDllName.Length);
+                            rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                        pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v64.BaseDllName.Buffer),
+                                                        u.wsz, uMte2.v64.BaseDllName.Length);
                             u.wsz[uMte2.v64.BaseDllName.Length / 2] = '\0';
                             if (    RT_SUCCESS(rc)
@@ -1328 +1339 @@
                                 /* Read the link entry of the previous entry in the list and check that its
                                    forward pointer points at the MTE we've found. */
-                                rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
-                                                   DBGFR3AddrFromFlat(pUVM, &Addr, uMte2.v64.InLoadOrderLinks.Blink),
-                                                   &uMte3.v64, RT_SIZEOFMEMB(NTMTE64, InLoadOrderLinks));
+                                rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                                                            pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr,
+                                                                                        uMte2.v64.InLoadOrderLinks.Blink),
+                                                            &uMte3.v64, RT_SIZEOFMEMB(NTMTE64, InLoadOrderLinks));
                                 if (   RT_SUCCESS(rc)
                                     && uMte3.v64.InLoadOrderLinks.Flink == MteAddr.FlatPtr
@@ -1354 +1366 @@
 
                         /* next */
-                        DBGFR3AddrAdd(&HitAddr, 8);
+                        pVMM->pfnDBGFR3AddrAdd(&HitAddr, 8);
                         if (HitAddr.FlatPtr < uEnd)
-                            rc = DBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, uEnd - HitAddr.FlatPtr,
-                                               8 /*align*/, &uMte.v64.DllBase, 3 * sizeof(uint32_t), &HitAddr);
+                            rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &HitAddr, uEnd - HitAddr.FlatPtr,
+                                                        8 /*align*/, &uMte.v64.DllBase, 3 * sizeof(uint32_t), &HitAddr);
                         else
                             rc = VERR_DBGF_MEM_NOT_FOUND;
@@ -1372 +1384 @@
  * @copydoc DBGFOSREG::pfnDestruct
  */
-static DECLCALLBACK(void)  dbgDiggerWinNtDestruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF2(pUVM, pvData);
+static DECLCALLBACK(void)  dbgDiggerWinNtDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM, pvData);
 }
 
@@ -1381 +1393 @@
  * @copydoc DBGFOSREG::pfnConstruct
  */
-static DECLCALLBACK(int)  dbgDiggerWinNtConstruct(PUVM pUVM, void *pvData)
-{
-    RT_NOREF1(pUVM);
+static DECLCALLBACK(int)  dbgDiggerWinNtConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
+{
+    RT_NOREF(pUVM, pVMM);
     PDBGDIGGERWINNT pThis = (PDBGDIGGERWINNT)pvData;
     pThis->fValid      = false;

trunk/src/VBox/Debugger/Makefile.kmk

@@ -73 +73 @@
 DbgPlugInDiggers_LIBS = \
         $(PATH_STAGE_LIB)/DisasmR3$(VBOX_SUFF_LIB) \
-        $(if-expr "$(LIB_VMM)" == "$(VBOX_LIB_VMM_LAZY)",$(LIB_REM),) \
-        $(VBOX_LIB_VMM_LAZY) \
         $(LIB_RUNTIME)
 $(call VBOX_SET_VER_INFO_DLL,DbgPlugInDiggers,VirtualBox Debugger Guest OS Digger Plug-in)
@@ -117 +115 @@
         -install_name $(VBOX_DYLD_EXECUTABLE_PATH)/VBoxDbg.dylib
 $(call VBOX_SET_VER_INFO_DLL,VBoxDbg,VirtualBox Debugger GUI)
-
- ifdef VBOX_WITH_TESTCASES
-#
-# The VBoxDbg testcase (Qt).
-#
-PROGRAMS += tstVBoxDbg
-tstVBoxDbg_TEMPLATE     = VBOXQTGUIEXE
-tstVBoxDbg_USES         = qt5
-tstVBoxDbg_QTTOOL       = QT5
-tstVBoxDbg_QT_MODULES   = Core Gui Widgets
-tstVBoxDbg_LIBS.linux   += xcb
-tstVBoxDbg_LIBS.solaris += xcb
-tstVBoxDbg_LIBS.freebsd += xcb
-tstVBoxDbg_SOURCES      = testcase/tstVBoxDbg.cpp
-tstVBoxDbg_LIBS         = \
-        $(LIB_VMM) \
-        $(LIB_REM) \
-        $(LIB_RUNTIME)
-  ifeq ($(KBUILD_TARGET),win)
-tstVBoxDbg_LIBS        += \
-        $(PATH_STAGE_LIB)/VBoxDbg.lib
-  else
-tstVBoxDbg_LIBS        += \
-        $(PATH_STAGE_BIN)/VBoxDbg$(VBOX_SUFF_DLL)
-  endif
- endif # TESTCASES
 endif # Qt
 

trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp

@@ -842 +842 @@
 }
 
+VMMR3DECL(PCVMMR3VTABLE) VMMR3GetVTable(void)
+{
+    return NULL;
+}
 
 VMMR3DECL(PVM) VMR3GetVM(PUVM pUVM)

trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp

@@ -1008 +1008 @@
             {
                 uint32_t cMessages = aMaxMessages == 0 ? UINT32_MAX : aMaxMessages;
-                vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), 0 /*fFlags*/, cMessages,
+                vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), ptrVM.vtable(), 0 /*fFlags*/, cMessages,
                                                 aDmesg.mutableRaw(), cbBuf, &cbActual);
 
@@ -1017 +1017 @@
                     vrc = aDmesg.reserveNoThrow(cbBuf);
                     if (RT_SUCCESS(vrc))
-                        vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), 0 /*fFlags*/, cMessages,
+                        vrc = pDmesg->pfnQueryKernelLog(pDmesg, ptrVM.rawUVM(), ptrVM.vtable(), 0 /*fFlags*/, cMessages,
                                                         aDmesg.mutableRaw(), cbBuf, &cbActual);
                 }

trunk/src/VBox/VMM/VMMR3/CFGM.cpp

@@ -60 +60 @@
 #include <VBox/vmm/dbgf.h>
 #include <VBox/vmm/mm.h>
+#include <VBox/vmm/vmm.h>
 #include "CFGMInternal.h"
 #include <VBox/vmm/vm.h>
 #include <VBox/vmm/uvm.h>
-#include <VBox/vmm/vmmr3vtable.h>
 #include <VBox/err.h>
 

trunk/src/VBox/VMM/VMMR3/DBGFOS.cpp

@@ -23 +23 @@
 #include <VBox/vmm/dbgf.h>
 #include <VBox/vmm/mm.h>
+#include <VBox/vmm/vmm.h>
 #include "DBGFInternal.h"
 #include <VBox/vmm/uvm.h>
@@ -116 +117 @@
     if (pUVM->dbgf.s.pCurOS)
     {
-        pUVM->dbgf.s.pCurOS->pReg->pfnTerm(pUVM, pUVM->dbgf.s.pCurOS->abData);
+        pUVM->dbgf.s.pCurOS->pReg->pfnTerm(pUVM, VMMR3GetVTable(), pUVM->dbgf.s.pCurOS->abData);
         pUVM->dbgf.s.pCurOS = NULL;
     }
@@ -144 +145 @@
         pUVM->dbgf.s.pOSHead = pOS->pNext;
         if (pOS->pReg->pfnDestruct)
-            pOS->pReg->pfnDestruct(pUVM, pOS->abData);
+            pOS->pReg->pfnDestruct(pUVM, VMMR3GetVTable(), pOS->abData);
 
         PDBGFOSEMTWRAPPER pFree = pOS->pWrapperHead;
@@ -189 +190 @@
     pOS->pReg = pReg;
 
-    int rc = pOS->pReg->pfnConstruct(pUVM, pOS->abData);
+    int rc = pOS->pReg->pfnConstruct(pUVM, VMMR3GetVTable(), pOS->abData);
     if (RT_SUCCESS(rc))
     {
@@ -200 +201 @@
     {
         if (pOS->pReg->pfnDestruct)
-            pOS->pReg->pfnDestruct(pUVM, pOS->abData);
+            pOS->pReg->pfnDestruct(pUVM, VMMR3GetVTable(), pOS->abData);
         MMR3HeapFree(pOS);
     }
@@ -291 +292 @@
      */
     if (fWasCurOS)
-        pOS->pReg->pfnTerm(pUVM, pOS->abData);
+        pOS->pReg->pfnTerm(pUVM, VMMR3GetVTable(), pOS->abData);
     if (pOS->pReg->pfnDestruct)
-        pOS->pReg->pfnDestruct(pUVM, pOS->abData);
+        pOS->pReg->pfnDestruct(pUVM, VMMR3GetVTable(), pOS->abData);
 
     PDBGFOSEMTWRAPPER pFree = pOS->pWrapperHead;
@@ -371 +372 @@
 
     for (PDBGFOS pNewOS = pUVM->dbgf.s.pOSHead; pNewOS; pNewOS = pNewOS->pNext)
-        if (pNewOS->pReg->pfnProbe(pUVM, pNewOS->abData))
+        if (pNewOS->pReg->pfnProbe(pUVM, VMMR3GetVTable(), pNewOS->abData))
         {
             int rc;
             pUVM->dbgf.s.pCurOS = pNewOS;
             if (pOldOS == pNewOS)
-                rc = pNewOS->pReg->pfnRefresh(pUVM, pNewOS->abData);
+                rc = pNewOS->pReg->pfnRefresh(pUVM, VMMR3GetVTable(), pNewOS->abData);
             else
             {
                 if (pOldOS)
-                    pOldOS->pReg->pfnTerm(pUVM, pNewOS->abData);
-                rc = pNewOS->pReg->pfnInit(pUVM, pNewOS->abData);
+                    pOldOS->pReg->pfnTerm(pUVM, VMMR3GetVTable(), pNewOS->abData);
+                rc = pNewOS->pReg->pfnInit(pUVM, VMMR3GetVTable(), pNewOS->abData);
             }
             if (pszName && cchName)
@@ -392 +393 @@
     /* not found */
     if (pOldOS)
-        pOldOS->pReg->pfnTerm(pUVM, pOldOS->abData);
+        pOldOS->pReg->pfnTerm(pUVM, VMMR3GetVTable(), pOldOS->abData);
 
     DBGF_OS_WRITE_UNLOCK(pUVM);
@@ -463 +464 @@
         if (pszVersion && cchVersion)
         {
-            int rc2 = pUVM->dbgf.s.pCurOS->pReg->pfnQueryVersion(pUVM, pUVM->dbgf.s.pCurOS->abData, pszVersion, cchVersion);
+            int rc2 = pUVM->dbgf.s.pCurOS->pReg->pfnQueryVersion(pUVM, VMMR3GetVTable(),  pUVM->dbgf.s.pCurOS->abData,
+                                                                 pszVersion, cchVersion);
             if (RT_FAILURE(rc2) || rc == VINF_SUCCESS)
                 rc = rc2;
@@ -516 +518 @@
  * @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog, Generic EMT wrapper.}
  */
-static DECLCALLBACK(int) dbgfR3OSEmtIDmesg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, uint32_t fFlags, uint32_t cMessages,
-                                                          char *pszBuf, size_t cbBuf, size_t *pcbActual)
+static DECLCALLBACK(int) dbgfR3OSEmtIDmesg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, uint32_t fFlags,
+                                                          uint32_t cMessages, char *pszBuf, size_t cbBuf, size_t *pcbActual)
 {
     PDBGFOSEMTWRAPPER pWrapper = RT_FROM_MEMBER(pThis, DBGFOSEMTWRAPPER, uWrapper.Dmesg);
@@ -529 +531 @@
 
     return VMR3ReqPriorityCallWaitU(pWrapper->pUVM, 0 /*idDstCpu*/,
-                                   (PFNRT)pWrapper->uDigger.pDmesg->pfnQueryKernelLog, 7,
-                                    pWrapper->uDigger.pDmesg, pUVM, fFlags, cMessages, pszBuf, cbBuf, pcbActual);
+                                   (PFNRT)pWrapper->uDigger.pDmesg->pfnQueryKernelLog, 8,
+                                    pWrapper->uDigger.pDmesg, pUVM, pVMM, fFlags, cMessages, pszBuf, cbBuf, pcbActual);
 
 }
@@ -538 +540 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryVersion, Generic EMT wrapper.}
  */
-static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryVersion(PDBGFOSIWINNT pThis, PUVM pUVM, uint32_t *puVersMajor, uint32_t *puVersMinor,
-                                                        uint32_t *puBuildNumber, bool *pf32Bit)
+static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryVersion(PDBGFOSIWINNT pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, uint32_t *puVersMajor,
+                                                        uint32_t *puVersMinor, uint32_t *puBuildNumber, bool *pf32Bit)
 {
     PDBGFOSEMTWRAPPER pWrapper = RT_FROM_MEMBER(pThis, DBGFOSEMTWRAPPER, uWrapper.WinNt);
@@ -546 +548 @@
 
     return VMR3ReqPriorityCallWaitU(pWrapper->pUVM, 0 /*idDstCpu*/,
-                                   (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryVersion, 6,
-                                    pWrapper->uDigger.pWinNt, pUVM, puVersMajor, puVersMinor,
+                                   (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryVersion, 7,
+                                    pWrapper->uDigger.pWinNt, pUVM, pVMM, puVersMajor, puVersMinor,
                                     puBuildNumber, pf32Bit);
 }
@@ -555 +557 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryKernelPtrs, Generic EMT wrapper.}
  */
-static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryKernelPtrs(PDBGFOSIWINNT pThis, PUVM pUVM,
+static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryKernelPtrs(PDBGFOSIWINNT pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
                                                            PRTGCUINTPTR pGCPtrKernBase, PRTGCUINTPTR pGCPtrPsLoadedModuleList)
 {
@@ -563 +565 @@
 
     return VMR3ReqPriorityCallWaitU(pWrapper->pUVM, 0 /*idDstCpu*/,
-                                   (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryKernelPtrs, 4,
-                                    pWrapper->uDigger.pWinNt, pUVM, pGCPtrKernBase, pGCPtrPsLoadedModuleList);
+                                   (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryKernelPtrs, 5,
+                                    pWrapper->uDigger.pWinNt, pUVM, pVMM, pGCPtrKernBase, pGCPtrPsLoadedModuleList);
 }
 
@@ -571 +573 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryKpcrForVCpu, Generic EMT wrapper.}
  */
-static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryKpcrForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, VMCPUID idCpu,
-                                                            PRTGCUINTPTR pKpcr, PRTGCUINTPTR pKpcrb)
+static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryKpcrForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                                            VMCPUID idCpu, PRTGCUINTPTR pKpcr, PRTGCUINTPTR pKpcrb)
 {
     PDBGFOSEMTWRAPPER pWrapper = RT_FROM_MEMBER(pThis, DBGFOSEMTWRAPPER, uWrapper.WinNt);
@@ -579 +581 @@
 
     return VMR3ReqPriorityCallWaitU(pWrapper->pUVM, 0 /*idDstCpu*/,
-                                    (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryKpcrForVCpu, 5,
-                                    pWrapper->uDigger.pWinNt, pUVM, idCpu, pKpcr, pKpcrb);
+                                    (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryKpcrForVCpu, 6,
+                                    pWrapper->uDigger.pWinNt, pUVM, pVMM, idCpu, pKpcr, pKpcrb);
 }
 
@@ -587 +589 @@
  * @interface_method_impl{DBGFOSIWINNT,pfnQueryCurThrdForVCpu, Generic EMT wrapper.}
  */
-static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryCurThrdForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, VMCPUID idCpu,
-                                                               PRTGCUINTPTR pCurThrd)
+static DECLCALLBACK(int) dbgfR3OSEmtIWinNt_QueryCurThrdForVCpu(struct DBGFOSIWINNT *pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
+                                                               VMCPUID idCpu, PRTGCUINTPTR pCurThrd)
 {
     PDBGFOSEMTWRAPPER pWrapper = RT_FROM_MEMBER(pThis, DBGFOSEMTWRAPPER, uWrapper.WinNt);
@@ -595 +597 @@
 
     return VMR3ReqPriorityCallWaitU(pWrapper->pUVM, 0 /*idDstCpu*/,
-                                    (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryCurThrdForVCpu, 4,
-                                    pWrapper->uDigger.pWinNt, pUVM, idCpu, pCurThrd);
+                                    (PFNRT)pWrapper->uDigger.pWinNt->pfnQueryCurThrdForVCpu, 5,
+                                    pWrapper->uDigger.pWinNt, pUVM, pVMM, idCpu, pCurThrd);
 }
 
@@ -622 +624 @@
     {
         void *pvDiggerIf;
-        pvDiggerIf = pOS->pReg->pfnQueryInterface(pUVM, pUVM->dbgf.s.pCurOS->abData, enmIf);
+        pvDiggerIf = pOS->pReg->pfnQueryInterface(pUVM, VMMR3GetVTable(), pUVM->dbgf.s.pCurOS->abData, enmIf);
         if (pvDiggerIf)
         {
@@ -730 +732 @@
         PDBGFOS pOS = pUVM->dbgf.s.pCurOS;
         if (pOS)
-            rc = pOS->pReg->pfnStackUnwindAssist(pUVM, pUVM->dbgf.s.pCurOS->abData, idCpu, pFrame,
+            rc = pOS->pReg->pfnStackUnwindAssist(pUVM, VMMR3GetVTable(), pUVM->dbgf.s.pCurOS->abData, idCpu, pFrame,
                                                  pState, pInitialCtx, hAs, puScratch);
         DBGF_OS_READ_UNLOCK(pUVM);

trunk/src/VBox/VMM/VMMR3/DBGFR3PlugIn.cpp

@@ -23 +23 @@
 #include <VBox/vmm/dbgf.h>
 #include <VBox/vmm/mm.h>
+#include <VBox/vmm/vmm.h>
 #include "DBGFInternal.h"
 #include <VBox/vmm/uvm.h>
@@ -367 +368 @@
          * Try initialize it.
          */
-        rc = pPlugIn->pfnEntry(DBGFPLUGINOP_INIT, pUVM, VBOX_VERSION);
+        rc = pPlugIn->pfnEntry(DBGFPLUGINOP_INIT, pUVM, VMMR3GetVTable(), VBOX_VERSION);
         if (RT_SUCCESS(rc))
         {
@@ -538 +539 @@
             pUVM->dbgf.s.pPlugInHead = pPlugIn->pNext;
 
-        pPlugIn->pfnEntry(DBGFPLUGINOP_TERM, pUVM, 0);
+        pPlugIn->pfnEntry(DBGFPLUGINOP_TERM, pUVM, VMMR3GetVTable(), 0);
         RTLdrClose(pPlugIn->hLdrMod);
 
@@ -568 +569 @@
         pUVM->dbgf.s.pPlugInHead = pPlugin->pNext;
 
-        pPlugin->pfnEntry(DBGFPLUGINOP_TERM, pUVM, 0);
+        pPlugin->pfnEntry(DBGFPLUGINOP_TERM, pUVM, VMMR3GetVTable(), 0);
 
         int rc2 = RTLdrClose(pPlugin->hLdrMod);

trunk/src/VBox/VMM/VMMR3/SSM.cpp

@@ -150 +150 @@
 #include <VBox/vmm/pdmcritsect.h>
 #include <VBox/vmm/mm.h>
+#include <VBox/vmm/vmm.h>
 #include "SSMInternal.h"
 #include <VBox/vmm/vm.h>
 #include <VBox/vmm/uvm.h>
-#include <VBox/vmm/vmmr3vtable.h>
 #include <VBox/err.h>
 #include <VBox/log.h>

trunk/src/VBox/VMM/VMMR3/VM.cpp

@@ -68 +68 @@
 #include "VMInternal.h"
 #include <VBox/vmm/vmcc.h>
-#include <VBox/vmm/vmmr3vtable.h>
 
 #include <VBox/sup.h>