Changeset 72778 in vbox for trunk/src/VBox/VMM/VMMR0

Timestamp:

Jun 29, 2018 8:02:35 PM (7 years ago)

Author:

vboxsync

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

123320

Message:

VMM,SUPDrv,IPRT: Redirect ring-0 release logging on EMTs to VBox.log.

• VMM: Added release ring-0 logging on EMTs that writes to VBox.log.
• IPRT: Made 'msprog' and 'timeprog' work for ring-0 logging on EMTs.
• IPRT: Removed RTLogSetCustomPrefixCallbackForR0.
• VMM: Removed vmmR0LoggerPrefix that was assoicated with the above API.
• IPRT Fixed missing log prefix on the first log line.
• SUPDrv: Turns out we require actual code for SUPR0GetDefaultLogRelInstanceEx and SUPR0GetDefaultLogInstanceEx.

Note! Requires updating the support driver.

Location:

trunk/src/VBox/VMM/VMMR0

Files:

• GVMMR0.cpp (modified) (3 diffs)
• VMMR0.cpp (modified) (5 diffs)

trunk/src/VBox/VMM/VMMR0/GVMMR0.cpp

@@ -1913 +1913 @@
      * Search the handles in a linear fashion as we don't dare to take the lock (assert).
      */
+/** @todo introduce some pid hash table here, please. */
     for (unsigned i = 1; i < RT_ELEMENTS(pGVMM->aHandles); i++)
     {
@@ -1927 +1928 @@
             PGVM pGVM = pGVMM->aHandles[i].pGVM;
             VMCPUID const cCpus = pGVM->cCpus;
+            ASMCompilerBarrier();
             if (    cCpus < 1
                 ||  cCpus > VMM_MAX_CPU_COUNT)
@@ -1933 +1935 @@
                 if (pGVM->aCpus[idCpu].hEMT == hEMT)
                     return pGVMM->aHandles[i].pVM;
+        }
+    }
+    return NULL;
+}
+
+
+/**
+ * Looks up the GVMCPU belonging to the specified EMT thread.
+ *
+ * This is used by the assertion machinery in VMMR0.cpp to avoid causing
+ * unnecessary kernel panics when the EMT thread hits an assertion. The
+ * call may or not be an EMT thread.
+ *
+ * @returns Pointer to the VM on success, NULL on failure.
+ * @param   hEMT    The native thread handle of the EMT.
+ *                  NIL_RTNATIVETHREAD means the current thread
+ */
+GVMMR0DECL(PGVMCPU) GVMMR0GetGVCpuByEMT(RTNATIVETHREAD hEMT)
+{
+    /*
+     * No Assertions here as we're usually called in a AssertMsgN,
+     * RTAssert*, Log and LogRel contexts.
+     */
+    PGVMM pGVMM = g_pGVMM;
+    if (   !VALID_PTR(pGVMM)
+        || pGVMM->u32Magic != GVMM_MAGIC)
+        return NULL;
+
+    if (hEMT == NIL_RTNATIVETHREAD)
+        hEMT = RTThreadNativeSelf();
+    RTPROCESS ProcId = RTProcSelf();
+
+    /*
+     * Search the handles in a linear fashion as we don't dare to take the lock (assert).
+     */
+/** @todo introduce some pid hash table here, please. */
+    for (unsigned i = 1; i < RT_ELEMENTS(pGVMM->aHandles); i++)
+    {
+        if (   pGVMM->aHandles[i].iSelf == i
+            && pGVMM->aHandles[i].ProcId == ProcId
+            && VALID_PTR(pGVMM->aHandles[i].pvObj)
+            && VALID_PTR(pGVMM->aHandles[i].pVM)
+            && VALID_PTR(pGVMM->aHandles[i].pGVM))
+        {
+            PGVM pGVM = pGVMM->aHandles[i].pGVM;
+            if (pGVMM->aHandles[i].hEMT0 == hEMT)
+                return &pGVM->aCpus[0];
+
+            /* This is fearly safe with the current process per VM approach. */
+            VMCPUID const cCpus = pGVM->cCpus;
+            ASMCompilerBarrier();
+            ASMCompilerBarrier();
+            if (   cCpus < 1
+                || cCpus > VMM_MAX_CPU_COUNT)
+                continue;
+            for (VMCPUID idCpu = 1; idCpu < cCpus; idCpu++)
+                if (pGVM->aCpus[idCpu].hEMT == hEMT)
+                    return &pGVM->aCpus[idCpu];
         }
     }

trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

@@ -390 +390 @@
         return rc;
 
-
 #ifdef LOG_ENABLED
     /*
@@ -2345 +2344 @@
 }
 
-/**
- * Internal R0 logger worker: Custom prefix.
- *
- * @returns Number of chars written.
- *
- * @param   pLogger     The logger instance.
- * @param   pchBuf      The output buffer.
- * @param   cchBuf      The size of the buffer.
- * @param   pvUser      User argument (ignored).
- */
-VMMR0DECL(size_t) vmmR0LoggerPrefix(PRTLOGGER pLogger, char *pchBuf, size_t cchBuf, void *pvUser)
-{
-    NOREF(pvUser);
-#ifdef LOG_ENABLED
-    PVMMR0LOGGER pR0Logger = (PVMMR0LOGGER)((uintptr_t)pLogger - RT_OFFSETOF(VMMR0LOGGER, Logger));
-    if (    !VALID_PTR(pR0Logger)
-        ||  !VALID_PTR(pR0Logger + 1)
-        ||  pLogger->u32Magic != RTLOGGER_MAGIC
-        ||  cchBuf < 2)
-        return 0;
-
-    static const char s_szHex[17] = "0123456789abcdef";
-    VMCPUID const     idCpu       = pR0Logger->idCpu;
-    pchBuf[1] = s_szHex[ idCpu       & 15];
-    pchBuf[0] = s_szHex[(idCpu >> 4) & 15];
-
-    return 2;
-#else
-    NOREF(pLogger); NOREF(pchBuf); NOREF(cchBuf);
-    return 0;
-#endif
-}
-
 #ifdef LOG_ENABLED
 
@@ -2389 +2355 @@
     if (pVCpu->vmm.s.pR0LoggerR0)
         pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
+    if (pVCpu->vmm.s.pR0RelLoggerR0)
+        pVCpu->vmm.s.pR0RelLoggerR0->fFlushingDisabled = true;
 }
 
@@ -2401 +2369 @@
     if (pVCpu->vmm.s.pR0LoggerR0)
         pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = false;
+    if (pVCpu->vmm.s.pR0RelLoggerR0)
+        pVCpu->vmm.s.pR0RelLoggerR0->fFlushingDisabled = false;
 }
 
@@ -2413 +2383 @@
     if (pVCpu->vmm.s.pR0LoggerR0)
         return pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled;
+    if (pVCpu->vmm.s.pR0RelLoggerR0)
+        return pVCpu->vmm.s.pR0RelLoggerR0->fFlushingDisabled;
     return true;
 }
+
 #endif /* LOG_ENABLED */
+
+/**
+ * Override RTLogRelGetDefaultInstanceEx so we can do LogRel to VBox.log from EMTs in ring-0.
+ */
+DECLEXPORT(PRTLOGGER) RTLogRelGetDefaultInstanceEx(uint32_t fFlagsAndGroup)
+{
+    PGVMCPU pGVCpu = GVMMR0GetGVCpuByEMT(NIL_RTNATIVETHREAD);
+    if (pGVCpu)
+    {
+        PVMCPU pVCpu = pGVCpu->pVCpu;
+        if (RT_VALID_PTR(pVCpu))
+        {
+            PVMMR0LOGGER pVmmLogger = pVCpu->vmm.s.pR0RelLoggerR0;
+            if (RT_VALID_PTR(pVmmLogger))
+            {
+                if (   pVmmLogger->fCreated
+                    && pVmmLogger->pVM == pGVCpu->pVM)
+                {
+                    if (pVmmLogger->Logger.fFlags & RTLOGFLAGS_DISABLED)
+                        return NULL;
+                    uint16_t const fFlags = RT_LO_U16(fFlagsAndGroup);
+                    uint16_t const iGroup = RT_HI_U16(fFlagsAndGroup);
+                    if (   iGroup != UINT16_MAX
+                        && (   (  pVmmLogger->Logger.afGroups[iGroup < pVmmLogger->Logger.cGroups ? iGroup : 0]
+                                & (fFlags | (uint32_t)RTLOGGRPFLAGS_ENABLED))
+                            != (fFlags | (uint32_t)RTLOGGRPFLAGS_ENABLED)))
+                        return NULL;
+                    return &pVmmLogger->Logger;
+                }
+            }
+        }
+    }
+    return SUPR0GetDefaultLogRelInstanceEx(fFlagsAndGroup);
+}
+
 
 /**