Changeset 83025 in vbox for trunk

Timestamp:

Feb 7, 2020 6:00:45 PM (5 years ago)

Author:

vboxsync

Message:

VMM/HM: Separate interrupt and exception injected stats.

Location:

trunk/src/VBox/VMM

Files:

• VMMR0/HMSVMR0.cpp (modified) (1 diff)
• VMMR0/HMVMXR0.cpp (modified) (1 diff)
• VMMR3/HM.cpp (modified) (3 diffs)
• include/HMInternal.h (modified) (1 diff)

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

@@ -3300 +3300 @@
     Assert(!pVmcb->ctrl.EventInject.n.u1Valid);
     pVmcb->ctrl.EventInject.u = pEvent->u;
-    STAM_COUNTER_INC(&pVCpu->hm.s.paStatInjectedIrqsR0[pEvent->n.u8Vector & MASK_INJECT_IRQ_STAT]);
+    if (   pVmcb->ctrl.EventInject.n.u3Type == SVM_EVENT_EXCEPTION
+        || pVmcb->ctrl.EventInject.n.u3Type == SVM_EVENT_NMI)
+    {
+        Assert(pEvent->n.u8Vector <= X86_XCPT_LAST);
+        STAM_COUNTER_INC(&pVCpu->hm.s.paStatInjectedXcptsR0[pEvent->n.u8Vector]);
+    }
+    else
+        STAM_COUNTER_INC(&pVCpu->hm.s.paStatInjectedIrqsR0[pEvent->n.u8Vector & MASK_INJECT_IRQ_STAT]);
     RT_NOREF(pVCpu);
 

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

@@ -8652 +8652 @@
 #endif
 
-    STAM_COUNTER_INC(&pVCpu->hm.s.paStatInjectedIrqsR0[uVector & MASK_INJECT_IRQ_STAT]);
+    if (   uIntType == VMX_EXIT_INT_INFO_TYPE_HW_XCPT
+        || uIntType == VMX_EXIT_INT_INFO_TYPE_NMI
+        || uIntType == VMX_EXIT_INT_INFO_TYPE_PRIV_SW_XCPT
+        || uIntType == VMX_EXIT_INT_INFO_TYPE_SW_XCPT)
+    {
+        Assert(uVector <= X86_XCPT_LAST);
+        Assert(uIntType != VMX_EXIT_INT_INFO_TYPE_NMI          || uVector == X86_XCPT_NMI);
+        Assert(uIntType != VMX_EXIT_INT_INFO_TYPE_PRIV_SW_XCPT || uVector == X86_XCPT_DB);
+        STAM_COUNTER_INC(&pVCpu->hm.s.paStatInjectedXcptsR0[uVector]);
+    }
+    else
+        STAM_COUNTER_INC(&pVCpu->hm.s.paStatInjectedIrqsR0[uVector & MASK_INJECT_IRQ_STAT]);
 
     /*

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

@@ -148 +148 @@
 static int                hmR3TermCPU(PVM pVM);
 
+
+/**
+ * Returns the name of the hardware exception.
+ *
+ * @returns The name of the hardware exception.
+ * @param   uVector     The exception vector.
+ */
+static const char *hmR3GetXcptName(uint8_t uVector)
+{
+    switch (uVector)
+    {
+        case X86_XCPT_DE:             return "#DE";
+        case X86_XCPT_DB:             return "#DB";
+        case X86_XCPT_NMI:            return "#NMI";
+        case X86_XCPT_BP:             return "#BP";
+        case X86_XCPT_OF:             return "#OF";
+        case X86_XCPT_BR:             return "#BR";
+        case X86_XCPT_UD:             return "#UD";
+        case X86_XCPT_NM:             return "#NM";
+        case X86_XCPT_DF:             return "#DF";
+        case X86_XCPT_CO_SEG_OVERRUN: return "#CO_SEG_OVERRUN";
+        case X86_XCPT_TS:             return "#TS";
+        case X86_XCPT_NP:             return "#NP";
+        case X86_XCPT_SS:             return "#SS";
+        case X86_XCPT_GP:             return "#GP";
+        case X86_XCPT_PF:             return "#PF";
+        case X86_XCPT_MF:             return "#MF";
+        case X86_XCPT_AC:             return "#AC";
+        case X86_XCPT_MC:             return "#MC";
+        case X86_XCPT_XF:             return "#XF";
+        case X86_XCPT_VE:             return "#VE";
+        case X86_XCPT_CP:             return "#CP";
+        case X86_XCPT_VC:             return "#VC";
+        case X86_XCPT_SX:             return "#SX";
+    }
+    return "Reserved";
+}
 
 
@@ -877 +914 @@
 
         /*
-         * Injected events stats.
+         * Injected interrupts stats.
          */
-        rc = MMHyperAlloc(pVM, sizeof(STAMCOUNTER) * 256, 8, MM_TAG_HM, (void **)&pHmCpu->paStatInjectedIrqs);
-        AssertRCReturn(rc, rc);
-        pHmCpu->paStatInjectedIrqsR0 = MMHyperR3ToR0(pVM, pHmCpu->paStatInjectedIrqs);
-        Assert(pHmCpu->paStatInjectedIrqsR0 != NIL_RTR0PTR);
-        for (unsigned j = 0; j < 255; j++)
-        {
-            rc = STAMR3RegisterF(pVM, &pHmCpu->paStatInjectedIrqs[j], STAMTYPE_COUNTER, STAMVISIBILITY_USED,
-                                 STAMUNIT_OCCURENCES, "Injected events.",
-                                 j <= X86_XCPT_LAST ? "/HM/CPU%u/EventInject/InjectTrap/%02X" : "/HM/CPU%u/EventInject/InjectIRQ/%02X",
-                                 idCpu, j);
-            AssertRC(rc);
+        {
+            uint32_t const cInterrupts = 0xff + 1;
+            rc = MMHyperAlloc(pVM, sizeof(STAMCOUNTER) * cInterrupts, 8, MM_TAG_HM, (void **)&pHmCpu->paStatInjectedIrqs);
+            AssertRCReturn(rc, rc);
+            pHmCpu->paStatInjectedIrqsR0 = MMHyperR3ToR0(pVM, pHmCpu->paStatInjectedIrqs);
+            Assert(pHmCpu->paStatInjectedIrqsR0 != NIL_RTR0PTR);
+            for (unsigned j = 0; j < cInterrupts; j++)
+            {
+                char aszIntrName[64];
+                RTStrPrintf(&aszIntrName[0], sizeof(aszIntrName),  "Interrupt %u", j);
+                rc = STAMR3RegisterF(pVM, &pHmCpu->paStatInjectedIrqs[j], STAMTYPE_COUNTER, STAMVISIBILITY_USED,
+                                     STAMUNIT_OCCURENCES, aszIntrName,
+                                     "/HM/CPU%u/EventInject/InjectIntr/%02X", idCpu, j);
+                AssertRC(rc);
+            }
+        }
+
+        /*
+         * Injected exception stats.
+         */
+        {
+            uint32_t const cXcpts = X86_XCPT_LAST + 1;
+            rc = MMHyperAlloc(pVM, sizeof(STAMCOUNTER) * cXcpts, 8, MM_TAG_HM, (void **)&pHmCpu->paStatInjectedXcpts);
+            AssertRCReturn(rc, rc);
+            pHmCpu->paStatInjectedXcptsR0 = MMHyperR3ToR0(pVM, pHmCpu->paStatInjectedXcpts);
+            Assert(pHmCpu->paStatInjectedXcptsR0 != NIL_RTR0PTR);
+            for (unsigned j = 0; j < cXcpts; j++)
+            {
+                char aszXcptName[64];
+                RTStrPrintf(&aszXcptName[0], sizeof(aszXcptName),  "%s exception", hmR3GetXcptName(j));
+                rc = STAMR3RegisterF(pVM, &pHmCpu->paStatInjectedXcpts[j], STAMTYPE_COUNTER, STAMVISIBILITY_USED,
+                                     STAMUNIT_OCCURENCES, aszXcptName,
+                                     "/HM/CPU%u/EventInject/InjectXcpt/%02X", idCpu, j);
+                AssertRC(rc);
+            }
         }
 
@@ -1911 +1972 @@
             pVCpu->hm.s.paStatInjectedIrqsR0 = NIL_RTR0PTR;
         }
+        if (pVCpu->hm.s.paStatInjectedXcpts)
+        {
+            MMHyperFree(pVM, pVCpu->hm.s.paStatInjectedXcpts);
+            pVCpu->hm.s.paStatInjectedXcpts   = NULL;
+            pVCpu->hm.s.paStatInjectedXcptsR0 = NIL_RTR0PTR;
+        }
 # if defined(VBOX_WITH_NESTED_HWVIRT_SVM) || defined(VBOX_WITH_NESTED_HWVIRT_VMX)
         if (pVCpu->hm.s.paStatNestedExitReason)

trunk/src/VBox/VMM/include/HMInternal.h

@@ -1183 +1183 @@
     R3PTRTYPE(PSTAMCOUNTER) paStatInjectedIrqs;
     R0PTRTYPE(PSTAMCOUNTER) paStatInjectedIrqsR0;
+    R3PTRTYPE(PSTAMCOUNTER) paStatInjectedXcpts;
+    R0PTRTYPE(PSTAMCOUNTER) paStatInjectedXcptsR0;
     R3PTRTYPE(PSTAMCOUNTER) paStatNestedExitReason;
     R0PTRTYPE(PSTAMCOUNTER) paStatNestedExitReasonR0;