Changeset 87130 in vbox for trunk/src

Timestamp:

Dec 27, 2020 7:32:53 PM (4 years ago)

Author:

vboxsync

Message:

VMM: More owner handling code for bugref:9837

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/DBGFAllBp.cpp (modified) (3 diffs)
• VMMR3/DBGFR3Bp.cpp (modified) (2 diffs)
• VMMR3/EM.cpp (modified) (1 diff)
• include/DBGFInternal.h (modified) (2 diffs)

trunk/src/VBox/VMM/VMMAll/DBGFAllBp.cpp

@@ -21 +21 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DBGF
+#define VMCPU_INCL_CPUM_GST_CTX
 #include <VBox/vmm/dbgf.h>
+#include <VBox/vmm/iem.h>
+#include <VBox/vmm/pgm.h>
 #include <VBox/vmm/selm.h>
 #include <VBox/log.h>
@@ -117 +120 @@
 
 
+# ifdef IN_RING0
+/**
+ * Returns the internal breakpoint owner state for the given handle.
+ *
+ * @returns Pointer to the internal ring-0 breakpoint owner state or NULL if the handle is invalid.
+ * @param   pVM                 The cross context VM structure.
+ * @param   hBpOwner            The breakpoint owner handle to resolve.
+ */
+DECLINLINE(PCDBGFBPOWNERINTR0) dbgfR0BpOwnerGetByHnd(PVMCC pVM, DBGFBPOWNER hBpOwner)
+{
+    if (hBpOwner == NIL_DBGFBPOWNER)
+        return NULL;
+
+    AssertReturn(hBpOwner < DBGF_BP_OWNER_COUNT_MAX, NULL);
+
+    PCDBGFBPOWNERINTR0 pBpOwnerR0 = &pVM->dbgfr0.s.paBpOwnersR0[hBpOwner];
+    AssertReturn(pBpOwnerR0->cRefs > 1, NULL);
+
+    return pBpOwnerR0;
+}
+# endif
+
+
 /**
  * Executes the actions associated with the given breakpoint.
@@ -137 +163 @@
 {
     uint64_t cHits = ASMAtomicIncU64(&pBp->Pub.cHits);
-    pVCpu->dbgf.s.hBpActive = hBp;
-
-    /** @todo Owner handling. */
-    RT_NOREF(pVM, pRegFrame);
-#ifdef IN_RING0
-    RT_NOREF(pBpR0);
-#endif
-
+
+    RT_NOREF(pRegFrame);
     LogFlow(("dbgfBpHit: hit breakpoint %u at %04x:%RGv cHits=0x%RX64\n",
              hBp, pRegFrame->cs.Sel, pRegFrame->rip, cHits));
-    return VINF_EM_DBG_BREAKPOINT;
+
+    int rc = VINF_EM_DBG_BREAKPOINT;
+# ifdef IN_RING0
+    PCDBGFBPOWNERINTR0 pBpOwnerR0 = dbgfR0BpOwnerGetByHnd(pVM,
+                                                            pBpR0->fInUse
+                                                          ? pBpR0->hOwner
+                                                          : NIL_DBGFBPOWNER);
+    if (pBpOwnerR0)
+    {
+        VBOXSTRICTRC rcStrict = pBpOwnerR0->pfnBpHitR0(pVM, pVCpu->idCpu, pBpR0->pvUserR0, hBp, &pBp->Pub);
+        if (rcStrict == VINF_SUCCESS)
+        {
+            uint8_t abInstr[DBGF_BP_INSN_MAX];
+            RTGCPTR const GCPtrInstr = pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base;
+            rc = PGMPhysSimpleReadGCPtr(pVCpu, &abInstr[0], GCPtrInstr, sizeof(abInstr));
+            AssertRC(rc);
+            if (RT_SUCCESS(rc))
+            {
+                /* Replace the int3 with the original instruction byte. */
+                abInstr[0] = pBp->Pub.u.Int3.bOrg;
+                rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), GCPtrInstr, &abInstr[0], sizeof(abInstr));
+                rc = VBOXSTRICTRC_VAL(rcStrict);
+            }
+        }
+        else if (   rcStrict == VINF_DBGF_BP_HALT
+                 || rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
+        {
+            pVCpu->dbgf.s.hBpActive = hBp;
+            if (rcStrict == VINF_DBGF_R3_BP_OWNER_DEFER)
+                pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
+            else
+                pVCpu->dbgf.s.fBpInvokeOwnerCallback = false;
+        }
+        else /* Guru meditation. */
+            rc = VERR_DBGF_BP_OWNER_CALLBACK_WRONG_STATUS;
+    }
+    else
+    {
+        pVCpu->dbgf.s.fBpInvokeOwnerCallback = true; /* Need to check this for ring-3 only owners. */
+        pVCpu->dbgf.s.hBpActive              = hBp;
+    }
+# else
+    RT_NOREF(pVM);
+    pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
+    pVCpu->dbgf.s.hBpActive = hBp;
+# endif
+
+    return rc;
 }
 

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

@@ -142 +142 @@
 *********************************************************************************************************************************/
 #define LOG_GROUP LOG_GROUP_DBGF
+#define VMCPU_INCL_CPUM_GST_CTX
 #include <VBox/vmm/dbgf.h>
 #include <VBox/vmm/selm.h>
@@ -2326 +2327 @@
 }
 
+
+/**
+ * Called whenever a breakpoint event needs to be serviced in ring-3 to decide what to do.
+ *
+ * @returns VBox status code.
+ * @param   pVM         The cross context VM structure.
+ * @param   pVCpu       The vCPU the breakpoint event happened on.
+ *
+ * @thread EMT
+ */
+VMMR3_INT_DECL(int) DBGFR3BpHit(PVM pVM, PVMCPU pVCpu)
+{
+    /* Send it straight into the debugger?. */
+    if (pVCpu->dbgf.s.fBpInvokeOwnerCallback)
+    {
+        DBGFBP hBp = pVCpu->dbgf.s.hBpActive;
+        PDBGFBPINT pBp = dbgfR3BpGetByHnd(pVM->pUVM, pVCpu->dbgf.s.hBpActive);
+        AssertReturn(pBp, VERR_DBGF_BP_IPE_9);
+
+        /* Resolve owner (can be NIL_DBGFBPOWNER) and invoke callback if there is one. */
+        PCDBGFBPOWNERINT pBpOwner = dbgfR3BpOwnerGetByHnd(pVM->pUVM, pBp->Pub.hOwner);
+        if (pBpOwner)
+        {
+            VBOXSTRICTRC rcStrict = pBpOwner->pfnBpHitR3(pVM, pVCpu->idCpu, pBp->pvUserR3, hBp, &pBp->Pub);
+            if (rcStrict == VINF_SUCCESS)
+            {
+                uint8_t abInstr[DBGF_BP_INSN_MAX];
+                RTGCPTR const GCPtrInstr = pVCpu->cpum.GstCtx.rip + pVCpu->cpum.GstCtx.cs.u64Base;
+                int rc = PGMPhysSimpleReadGCPtr(pVCpu, &abInstr[0], GCPtrInstr, sizeof(abInstr));
+                AssertRC(rc);
+                if (RT_SUCCESS(rc))
+                {
+                    /* Replace the int3 with the original instruction byte. */
+                    abInstr[0] = pBp->Pub.u.Int3.bOrg;
+                    rcStrict = IEMExecOneWithPrefetchedByPC(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), GCPtrInstr, &abInstr[0], sizeof(abInstr));
+                    return VBOXSTRICTRC_VAL(rcStrict);
+                }
+            }
+            else if (rcStrict != VINF_DBGF_BP_HALT) /* Guru meditation. */
+                return VERR_DBGF_BP_OWNER_CALLBACK_WRONG_STATUS;
+            /* else: Halt in the debugger. */
+        }
+    }
+
+    return DBGFR3EventBreakpoint(pVM, DBGFEVENT_BREAKPOINT);
+}
+

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

@@ -839 +839 @@
 
             case VINF_EM_DBG_BREAKPOINT:
+#ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
+                rc = DBGFR3BpHit(pVM, pVCpu);
+#else
                 rc = DBGFR3EventBreakpoint(pVM, DBGFEVENT_BREAKPOINT);
+#endif
                 break;
 

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

@@ -68 +68 @@
 /** Number of chunks required to support all breakpoints. */
 #define DBGF_BP_CHUNK_COUNT                 (DBGF_BP_COUNT_MAX / DBGF_BP_COUNT_PER_CHUNK)
+/** Maximum number of instruction bytes when executing breakpointed instructions. */
+#define DBGF_BP_INSN_MAX                    16
 /** @} */
 
@@ -1263 +1265 @@
      * @todo drop this in favor of aEvents!  */
     DBGFBP                  hBpActive;
+    /** Flag whether the to invoke any owner handlers in ring-3 before dropping into the debugger. */
+    bool                    fBpInvokeOwnerCallback;
 #endif
     /** Set if we're singlestepping in raw mode.