Index: /trunk/src/VBox/ExtPacks/VBoxDTrace/VBoxDTraceR0/VBoxDTraceR0.cpp
===================================================================
--- /trunk/src/VBox/ExtPacks/VBoxDTrace/VBoxDTraceR0/VBoxDTraceR0.cpp	(revision 53707)
+++ /trunk/src/VBox/ExtPacks/VBoxDTrace/VBoxDTraceR0/VBoxDTraceR0.cpp	(revision 53708)
@@ -106,4 +106,7 @@
             /** The user context.  */
             PCSUPDRVTRACERUSRCTX    pCtx;
+            /** The argument displacement caused by 64-bit arguments passed directly to
+             *  dtrace_probe. */
+            int                     offArg;
         } ProbeFireUser;
     } u;
@@ -153,4 +156,12 @@
             VBoxDtReleaseThread(pStackData->pThread); \
     } while (0)
+
+
+/** Simple SUPR0Printf-style logging.  */
+#if 0 /*def DEBUG_bird*/
+# define LOG_DTRACE(a) SUPR0Printf a
+#else
+# define LOG_DTRACE(a) do { } while (0)
+#endif
 
 
@@ -1374,5 +1385,7 @@
 static void     vboxDtPOps_Provide(void *pvProv, const dtrace_probedesc_t *pDtProbeDesc)
 {
-    PSUPDRVVDTPROVIDERCORE  pProv        = (PSUPDRVVDTPROVIDERCORE)pvProv;
+    PSUPDRVVDTPROVIDERCORE  pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
+    AssertPtrReturnVoid(pProv);
+    LOG_DTRACE(("%s: %p / %p pDtProbeDesc=%p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, pDtProbeDesc));
 
     if (pDtProbeDesc)
@@ -1382,5 +1395,5 @@
         return;
 
-    dtrace_provider_id_t const idProvider   = pProv->TracerData.DTrace.idProvider;
+    dtrace_provider_id_t const idProvider = pProv->TracerData.DTrace.idProvider;
     AssertPtrReturnVoid(idProvider);
 
@@ -1388,5 +1401,4 @@
     AssertReturnVoid(pProv->pHdr->offProbeLocs != 0);
     uint32_t const  cProbeLocs    = pProv->pHdr->cbProbeLocs / sizeof(VTGPROBELOC);
-
 
     /* Need a buffer for extracting the function names and mangling them in
@@ -1407,5 +1419,5 @@
            we've already reported. */
         PCVTGPROBELOC pProbeLocRO = &pProv->paProbeLocsRO[idxProbeLoc];
-        PVTGDESCPROBE pProbeDesc  = (PVTGDESCPROBE)pProbeLocRO->pbProbe;
+        PVTGDESCPROBE pProbeDesc  = pProbeLocRO->pProbe;
         if (pProbeDesc->idxProvider != idxProv)
             continue;
@@ -1483,4 +1495,5 @@
 
      RTMemFree(pszFnNmBuf);
+     LOG_DTRACE(("%s: returns\n", __FUNCTION__));
 }
 
@@ -1492,4 +1505,7 @@
 {
     PSUPDRVVDTPROVIDERCORE  pProv   = (PSUPDRVVDTPROVIDERCORE)pvProv;
+    LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
+    AssertPtrReturn(pProv->TracerData.DTrace.idProvider, EINVAL);
+
     if (!pProv->TracerData.DTrace.fZombie)
     {
@@ -1497,5 +1513,5 @@
         PVTGPROBELOC32  pProbeLocEn = (PVTGPROBELOC32)(  (uintptr_t)pProv->pvProbeLocsEn + idxProbeLoc * pProv->cbProbeLocsEn);
         PCVTGPROBELOC   pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
-        PCVTGDESCPROBE  pProbeDesc  = (PVTGDESCPROBE)pProbeLocRO->pbProbe;
+        PCVTGDESCPROBE  pProbeDesc  = pProbeLocRO->pProbe;
         uint32_t const  idxProbe    = pProbeDesc->idxEnabled;
 
@@ -1533,4 +1549,9 @@
 {
     PSUPDRVVDTPROVIDERCORE  pProv  = (PSUPDRVVDTPROVIDERCORE)pvProv;
+    AssertPtrReturnVoid(pProv);
+    LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
+    AssertPtrReturnVoid(pvProbe);
+    AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
+
     if (!pProv->TracerData.DTrace.fZombie)
     {
@@ -1538,5 +1559,5 @@
         PVTGPROBELOC32  pProbeLocEn = (PVTGPROBELOC32)(  (uintptr_t)pProv->pvProbeLocsEn + idxProbeLoc * pProv->cbProbeLocsEn);
         PCVTGPROBELOC   pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
-        PCVTGDESCPROBE  pProbeDesc  = (PVTGDESCPROBE)pProbeLocRO->pbProbe;
+        PCVTGDESCPROBE  pProbeDesc  = pProbeLocRO->pProbe;
         uint32_t const  idxProbe    = pProbeDesc->idxEnabled;
 
@@ -1570,9 +1591,14 @@
  */
 static void     vboxDtPOps_GetArgDesc(void *pvProv, dtrace_id_t idProbe, void *pvProbe,
-                                            dtrace_argdesc_t *pArgDesc)
+                                      dtrace_argdesc_t *pArgDesc)
 {
     PSUPDRVVDTPROVIDERCORE  pProv  = (PSUPDRVVDTPROVIDERCORE)pvProv;
     unsigned                uArg   = pArgDesc->dtargd_ndx;
+
     pArgDesc->dtargd_ndx = DTRACE_ARGNONE;
+    AssertPtrReturnVoid(pProv);
+    LOG_DTRACE(("%s: %p / %p - %#x / %p uArg=%d\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, uArg));
+    AssertPtrReturnVoid(pvProbe);
+    AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
 
     if (!pProv->TracerData.DTrace.fZombie)
@@ -1580,5 +1606,5 @@
         uint32_t         idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
         PCVTGPROBELOC    pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
-        PCVTGDESCPROBE   pProbeDesc  = (PVTGDESCPROBE)pProbeLocRO->pbProbe;
+        PCVTGDESCPROBE   pProbeDesc  = pProbeLocRO->pProbe;
         PCVTGDESCARGLIST pArgList    = (PCVTGDESCARGLIST)(  (uintptr_t)pProv->pHdr
                                                           + pProv->pHdr->offArgLists
@@ -1593,11 +1619,11 @@
             {
                 memcpy(pArgDesc->dtargd_native, pszType, cchType + 1);
+                /** @todo mapping? */
                 pArgDesc->dtargd_ndx = uArg;
-                /** @todo mapping? */
+                LOG_DTRACE(("%s: returns dtargd_native = %s\n", __FUNCTION__, pArgDesc->dtargd_native));
                 return;
             }
         }
     }
-
 }
 
@@ -1609,29 +1635,94 @@
                                      int iArg, int cFrames)
 {
-    PVBDTSTACKDATA pData = vboxDtGetStackData();
+    PSUPDRVVDTPROVIDERCORE  pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
+    AssertPtrReturn(pProv, UINT64_MAX);
+    LOG_DTRACE(("%s: %p / %p - %#x / %p iArg=%d cFrames=%u\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, iArg, cFrames));
     AssertReturn(iArg >= 5, UINT64_MAX);
-
-    if (pData->enmCaller == kVBoxDtCaller_ProbeFireKernel)
-        return pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
-
-    if (pData->enmCaller == kVBoxDtCaller_ProbeFireUser)
-    {
-        PCSUPDRVTRACERUSRCTX pCtx = pData->u.ProbeFireUser.pCtx;
+    if (pProv->TracerData.DTrace.fZombie)
+        return UINT64_MAX;
+
+    uint32_t                idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
+    PCVTGPROBELOC           pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
+    PCVTGDESCPROBE          pProbeDesc  = pProbeLocRO->pProbe;
+    PCVTGDESCARGLIST        pArgList    = (PCVTGDESCARGLIST)(  (uintptr_t)pProv->pHdr
+                                                             + pProv->pHdr->offArgLists
+                                                             + pProbeDesc->offArgList);
+    AssertReturn(pProbeDesc->offArgList < pProv->pHdr->cbArgLists, UINT64_MAX);
+
+    PVBDTSTACKDATA          pData = vboxDtGetStackData();
+
+    /*
+     * Get the stack data. This is a wee bit complicated on 32-bit systems
+     * since we want to support 64-bit integer arguments.
+     */
+    uint64_t u64Ret;
+    if (iArg >= 20)
+        u64Ret = UINT64_MAX;
+    else if (pData->enmCaller == kVBoxDtCaller_ProbeFireKernel)
+    {
+#if ARCH_BITS == 64
+        u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
+#else
+        if (   !pArgList->fHaveLargeArgs
+            || iArg >= pArgList->cArgs)
+            u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
+        else
+        {
+            /* Similar to what we did for mac in when calling dtrace_probe(). */
+            uint32_t offArg = 0;
+            for (int i = 5; i < iArg; i++)
+                if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
+                    offArg++;
+            u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg];
+            if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
+                u64Ret |= (uint64_t)pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg + 1] << 32;
+        }
+#endif
+    }
+    else if (pData->enmCaller == kVBoxDtCaller_ProbeFireUser)
+    {
+        int                     offArg    = pData->u.ProbeFireUser.offArg;
+        PCSUPDRVTRACERUSRCTX    pCtx      = pData->u.ProbeFireUser.pCtx;
+        AssertPtrReturn(pCtx, UINT64_MAX);
+
         if (pCtx->cBits == 32)
         {
-            if ((unsigned)iArg < RT_ELEMENTS(pCtx->u.X86.aArgs))
-                return pCtx->u.X86.aArgs[iArg];
-        }
-        else if (pCtx->cBits == 64)
-        {
-            if ((unsigned)iArg < RT_ELEMENTS(pCtx->u.Amd64.aArgs))
-                return pCtx->u.Amd64.aArgs[iArg];
+            if (   !pArgList->fHaveLargeArgs
+                || iArg >= pArgList->cArgs)
+            {
+                if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
+                    u64Ret = pCtx->u.Amd64.aArgs[iArg + offArg];
+                else
+                    u64Ret = UINT64_MAX;
+            }
+            else
+            {
+                for (int i = 5; i < iArg; i++)
+                    if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
+                        offArg++;
+                if (offArg + iArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
+                {
+                    u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
+                    if (   VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType)
+                        && offArg + iArg + 1 < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
+                        u64Ret |= (uint64_t)pCtx->u.X86.aArgs[iArg + offArg + 1] << 32;
+                }
+                else
+                    u64Ret = UINT64_MAX;
+            }
         }
         else
-            AssertFailed();
-    }
-
-    NOREF(pvProbe);
-    return UINT64_MAX;
+        {
+            if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.Amd64.aArgs))
+                u64Ret = pCtx->u.Amd64.aArgs[iArg + offArg];
+            else
+                u64Ret = UINT64_MAX;
+        }
+    }
+    else
+        AssertFailedReturn(UINT64_MAX);
+
+    LOG_DTRACE(("%s: returns %#llx\n", __FUNCTION__, u64Ret));
+    return u64Ret;
 }
 
@@ -1643,4 +1734,9 @@
 {
     PSUPDRVVDTPROVIDERCORE  pProv  = (PSUPDRVVDTPROVIDERCORE)pvProv;
+    AssertPtrReturnVoid(pProv);
+    LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
+    AssertReturnVoid(pProv->TracerData.DTrace.cProvidedProbes > 0);
+    AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
+
     if (!pProv->TracerData.DTrace.fZombie)
     {
@@ -1700,15 +1796,56 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnProbeFireKernel}
  */
-static DECLCALLBACK(void) vbdt_ProbeFireKernel(struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
-                                               uintptr_t uArg3, uintptr_t uArg4)
-{
+static DECLCALLBACK(void) vboxDtTOps_ProbeFireKernel(struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
+                                                     uintptr_t uArg3, uintptr_t uArg4)
+{
+    AssertPtrReturnVoid(pVtgProbeLoc);
+    LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pVtgProbeLoc, pVtgProbeLoc->idProbe));
+    AssertPtrReturnVoid(pVtgProbeLoc->pProbe);
+    AssertPtrReturnVoid(pVtgProbeLoc->pszFunction);
+
     VBDT_SETUP_STACK_DATA(kVBoxDtCaller_ProbeFireKernel);
 
-    pStackData->u.ProbeFireKernel.uCaller      = (uintptr_t)ASMReturnAddress();
-    pStackData->u.ProbeFireKernel.pauStackArgs = &uArg4 + 1;
+    pStackData->u.ProbeFireKernel.pauStackArgs  = &uArg4 + 1;
+
+#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
+    /*
+     * Convert arguments from uintptr_t to uint64_t.
+     */
+    PVTGDESCPROBE   pProbe   = (PVTGDESCPROBE)((PVTGPROBELOC)pVtgProbeLoc)->pbProbe;
+    AssertPtrReturnVoid(pProbe);
+    PVTGOBJHDR      pVtgHdr  = (PVTGOBJHDR)((uintptr_t)pProbe + pProbe->offObjHdr);
+    AssertPtrReturnVoid(pVtgHdr);
+    PVTGDESCARGLIST pArgList = (PVTGDESCARGLIST)((uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbe->offArgList);
+    AssertPtrReturnVoid(pArgList);
+    if (!pArgList->fHaveLargeArgs)
+        dtrace_probe(pVtgProbeLoc->idProbe, uArg0, uArg1, uArg2, uArg3, uArg4);
+    else
+    {
+        uintptr_t *auSrcArgs = &uArg0;
+        uint32_t   iSrcArg   = 0;
+        uint32_t   iDstArg   = 0;
+        uint64_t   au64DstArgs[5];
+
+        while (   iDstArg < RT_ELEMENTS(au64DstArgs)
+               && iSrcArg < pArgList->cArgs)
+        {
+            au64DstArgs[iDstArg] = auSrcArgs[iSrcArg];
+            if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iDstArg].fType))
+                au64DstArgs[iDstArg] |= (uint64_t)auSrcArgs[++iSrcArg] << 32;
+            iSrcArg++;
+            iDstArg++;
+        }
+        while (iDstArg < RT_ELEMENTS(au64DstArgs))
+            au64DstArgs[iDstArg++] = auSrcArgs[iSrcArg++];
+
+        pStackData->u.ProbeFireK.pauStackArgs = &auSrcArgs[iSrcArg];
+        dtrace_probe(pVtgProbeLoc->idProbe, au64DstArgs[0], au64DstArgs[1], au64DstArgs[2], au64DstArgs[3], au64DstArgs[4]);
+    }
+#else
     dtrace_probe(pVtgProbeLoc->idProbe, uArg0, uArg1, uArg2, uArg3, uArg4);
+#endif
 
     VBDT_CLEAR_STACK_DATA();
-    return ;
+    LOG_DTRACE(("%s: returns\n", __FUNCTION__));
 }
 
@@ -1717,10 +1854,57 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnProbeFireUser}
  */
-static DECLCALLBACK(void) vbdt_ProbeFireUser(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, PCSUPDRVTRACERUSRCTX pCtx)
-{
+static DECLCALLBACK(void) vboxDtTOps_ProbeFireUser(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, PCSUPDRVTRACERUSRCTX pCtx,
+                                                   PCVTGOBJHDR pVtgHdr, PCVTGPROBELOC pProbeLocRO)
+{
+    LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pCtx, pCtx->idProbe));
+    AssertPtrReturnVoid(pProbeLocRO);
+    AssertPtrReturnVoid(pVtgHdr);
+
     VBDT_SETUP_STACK_DATA(kVBoxDtCaller_ProbeFireUser);
 
-    pStackData->u.ProbeFireUser.pCtx = pCtx;
     if (pCtx->cBits == 32)
+    {
+        pStackData->u.ProbeFireUser.pCtx   = pCtx;
+        pStackData->u.ProbeFireUser.offArg = 0;
+
+#if ARCH_BITS == 64 || defined(RT_OS_DARWIN)
+        /*
+         * Combine two 32-bit arguments into one 64-bit argument where needed.
+         */
+        PVTGDESCPROBE   pProbeDesc = pProbeLocRO->pProbe;
+        AssertPtrReturnVoid(pProbeDesc);
+        PVTGDESCARGLIST pArgList   = (PVTGDESCARGLIST)((uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbeDesc->offArgList);
+        AssertPtrReturnVoid(pArgList);
+
+        if (!pArgList->fHaveLargeArgs)
+            dtrace_probe(pCtx->idProbe,
+                         pCtx->u.X86.aArgs[0],
+                         pCtx->u.X86.aArgs[1],
+                         pCtx->u.X86.aArgs[2],
+                         pCtx->u.X86.aArgs[3],
+                         pCtx->u.X86.aArgs[4]);
+        else
+        {
+            uint32_t const *auSrcArgs = &pCtx->u.X86.aArgs[0];
+            uint32_t        iSrcArg   = 0;
+            uint32_t        iDstArg   = 0;
+            uint64_t        au64DstArgs[5];
+
+            while (   iDstArg < RT_ELEMENTS(au64DstArgs)
+                   && iSrcArg < pArgList->cArgs)
+            {
+                au64DstArgs[iDstArg] = auSrcArgs[iSrcArg];
+                if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iDstArg].fType))
+                    au64DstArgs[iDstArg] |= (uint64_t)auSrcArgs[++iSrcArg] << 32;
+                iSrcArg++;
+                iDstArg++;
+            }
+            while (iDstArg < RT_ELEMENTS(au64DstArgs))
+                au64DstArgs[iDstArg++] = auSrcArgs[iSrcArg++];
+
+            pStackData->u.ProbeFireUser.offArg = iSrcArg - RT_ELEMENTS(au64DstArgs);
+            dtrace_probe(pCtx->idProbe, au64DstArgs[0], au64DstArgs[1], au64DstArgs[2], au64DstArgs[3], au64DstArgs[4]);
+        }
+#else
         dtrace_probe(pCtx->idProbe,
                      pCtx->u.X86.aArgs[0],
@@ -1729,5 +1913,10 @@
                      pCtx->u.X86.aArgs[3],
                      pCtx->u.X86.aArgs[4]);
+#endif
+    }
     else if (pCtx->cBits == 64)
+    {
+        pStackData->u.ProbeFireUser.pCtx   = pCtx;
+        pStackData->u.ProbeFireUser.offArg = 0;
         dtrace_probe(pCtx->idProbe,
                      pCtx->u.Amd64.aArgs[0],
@@ -1736,8 +1925,10 @@
                      pCtx->u.Amd64.aArgs[3],
                      pCtx->u.Amd64.aArgs[4]);
+    }
     else
         AssertFailed();
 
     VBDT_CLEAR_STACK_DATA();
+    LOG_DTRACE(("%s: returns\n", __FUNCTION__));
 }
 
@@ -1746,6 +1937,6 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnTracerOpen}
  */
-static DECLCALLBACK(int) vbdt_TracerOpen(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uint32_t uCookie, uintptr_t uArg,
-                                         uintptr_t *puSessionData)
+static DECLCALLBACK(int) vboxDtTOps_TracerOpen(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uint32_t uCookie,
+                                               uintptr_t uArg, uintptr_t *puSessionData)
 {
     if (uCookie != RT_MAKE_U32_FROM_U8('V', 'B', 'D', 'T'))
@@ -1766,6 +1957,6 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnTracerClose}
  */
-static DECLCALLBACK(int) vbdt_TracerIoCtl(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData,
-                                          uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal)
+static DECLCALLBACK(int) vboxDtTOps_TracerIoCtl(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData,
+                                                uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal)
 {
     AssertPtrReturn(uSessionData, VERR_INVALID_POINTER);
@@ -1782,5 +1973,5 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnTracerClose}
  */
-static DECLCALLBACK(void) vbdt_TracerClose(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData)
+static DECLCALLBACK(void) vboxDtTOps_TracerClose(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData)
 {
     AssertPtrReturnVoid(uSessionData);
@@ -1796,6 +1987,7 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnProviderRegister}
  */
-static DECLCALLBACK(int) vbdt_ProviderRegister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
-{
+static DECLCALLBACK(int) vboxDtTOps_ProviderRegister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
+{
+    LOG_DTRACE(("%s: %p %s/%s\n", __FUNCTION__, pThis, pCore->pszModName, pCore->pszName));
     AssertReturn(pCore->TracerData.DTrace.idProvider == 0, VERR_INTERNAL_ERROR_3);
     VBDT_SETUP_STACK_DATA(kVBoxDtCaller_Generic);
@@ -1809,4 +2001,6 @@
     vboxDtVtgConvAttr(&DtAttrs.dtpa_args,     &pDesc->AttrArguments);
 
+    /* Note! DTrace may call us back before dtrace_register returns, so we
+             have to point it to pCore->TracerData.DTrace.idProvider. */
     AssertCompile(sizeof(dtrace_provider_id_t) == sizeof(pCore->TracerData.DTrace.idProvider));
     int rc = dtrace_register(pCore->pszName,
@@ -1819,11 +2013,16 @@
     if (!rc)
     {
-        Assert(pCore->TracerData.DTrace.idProvider != 0);
+        LOG_DTRACE(("%s: idProvider=%p\n", __FUNCTION__, pCore->TracerData.DTrace.idProvider));
+        AssertPtr(pCore->TracerData.DTrace.idProvider);
         rc = VINF_SUCCESS;
     }
     else
+    {
+        pCore->TracerData.DTrace.idProvider = 0;
         rc = RTErrConvertFromErrno(rc);
+    }
 
     VBDT_CLEAR_STACK_DATA();
+    LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
     return rc;
 }
@@ -1833,8 +2032,9 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnProviderDeregister}
  */
-static DECLCALLBACK(int) vbdt_ProviderDeregister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
+static DECLCALLBACK(int) vboxDtTOps_ProviderDeregister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
 {
     uintptr_t idProvider = pCore->TracerData.DTrace.idProvider;
-    AssertReturn(idProvider != 0, VERR_INTERNAL_ERROR_4);
+    LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pThis, idProvider));
+    AssertPtrReturn(idProvider, VERR_INTERNAL_ERROR_3);
     VBDT_SETUP_STACK_DATA(kVBoxDtCaller_Generic);
 
@@ -1854,4 +2054,5 @@
 
     VBDT_CLEAR_STACK_DATA();
+    LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
     return rc;
 }
@@ -1861,8 +2062,9 @@
  * interface_method_impl{SUPDRVTRACERREG,pfnProviderDeregisterZombie}
  */
-static DECLCALLBACK(int) vbdt_ProviderDeregisterZombie(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
+static DECLCALLBACK(int) vboxDtTOps_ProviderDeregisterZombie(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
 {
     uintptr_t idProvider = pCore->TracerData.DTrace.idProvider;
-    AssertReturn(idProvider != 0, VERR_INTERNAL_ERROR_4);
+    LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pThis, idProvider));
+    AssertPtrReturn(idProvider, VERR_INTERNAL_ERROR_3);
     Assert(pCore->TracerData.DTrace.fZombie);
     VBDT_SETUP_STACK_DATA(kVBoxDtCaller_Generic);
@@ -1881,4 +2083,5 @@
 
     VBDT_CLEAR_STACK_DATA();
+    LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
     return rc;
 }
@@ -1893,12 +2096,12 @@
     SUPDRVTRACERREG_MAGIC,
     SUPDRVTRACERREG_VERSION,
-    vbdt_ProbeFireKernel,
-    vbdt_ProbeFireUser,
-    vbdt_TracerOpen,
-    vbdt_TracerIoCtl,
-    vbdt_TracerClose,
-    vbdt_ProviderRegister,
-    vbdt_ProviderDeregister,
-    vbdt_ProviderDeregisterZombie,
+    vboxDtTOps_ProbeFireKernel,
+    vboxDtTOps_ProbeFireUser,
+    vboxDtTOps_TracerOpen,
+    vboxDtTOps_TracerIoCtl,
+    vboxDtTOps_TracerClose,
+    vboxDtTOps_ProviderRegister,
+    vboxDtTOps_ProviderDeregister,
+    vboxDtTOps_ProviderDeregisterZombie,
     SUPDRVTRACERREG_MAGIC
 };