Changeset 87107 in vbox for trunk/src

Timestamp:

Dec 19, 2020 3:10:18 PM (4 years ago)

Author:

vboxsync

Message:

VMM/DBGF: Started implementing the breakpoint owner management, bugref:9837

Location:

trunk/src/VBox/VMM

Files:

• VMMR0/DBGFR0Bp.cpp (modified) (5 diffs)
• VMMR0/VMMR0.cpp (modified) (1 diff)
• VMMR3/DBGFR3Bp.cpp (modified) (11 diffs)
• include/DBGFInternal.h (modified) (4 diffs)

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

@@ -52 +52 @@
 DECLHIDDEN(void) dbgfR0BpInit(PGVM pGVM)
 {
+    pGVM->dbgfr0.s.hMemObjBpOwners = NIL_RTR0MEMOBJ;
+    pGVM->dbgfr0.s.hMapObjBpOwners = NIL_RTR0MEMOBJ;
+    //pGVM->dbgfr0.s.paBpOwnersR0    = NULL;
+
     for (uint32_t i = 0; i < RT_ELEMENTS(pGVM->dbgfr0.s.aBpChunks); i++)
     {
@@ -87 +91 @@
 DECLHIDDEN(void) dbgfR0BpDestroy(PGVM pGVM)
 {
+    if (pGVM->dbgfr0.s.hMemObjBpOwners != NIL_RTR0MEMOBJ)
+    {
+        Assert(pGVM->dbgfr0.s.hMapObjBpOwners != NIL_RTR0MEMOBJ);
+        AssertPtr(pGVM->dbgfr0.s.paBpOwnersR0);
+
+        RTR0MEMOBJ hMemObj = pGVM->dbgfr0.s.hMapObjBpOwners;
+        pGVM->dbgfr0.s.hMapObjBpOwners = NIL_RTR0MEMOBJ;
+        RTR0MemObjFree(hMemObj, true);
+
+        hMemObj = pGVM->dbgfr0.s.hMemObjBpOwners;
+        pGVM->dbgfr0.s.hMemObjBpOwners = NIL_RTR0MEMOBJ;
+        RTR0MemObjFree(hMemObj, true);
+    }
+
     if (pGVM->dbgfr0.s.fInit)
     {
@@ -208 +226 @@
         *ppaBpLocL1R3 = RTR0MemObjAddressR3(hMapObj);
         pGVM->dbgfr0.s.fInit = true;
+        return rc;
+    }
+
+    RTR0MemObjFree(hMemObj, true);
+    return rc;
+}
+
+
+/**
+ * Worker for DBGFR0BpOwnerInitReqHandler() that does the actual initialization.
+ *
+ * @returns VBox status code.
+ * @param   pGVM            The global (ring-0) VM structure.
+ * @param   ppaBpOwnerR3    Where to return the ring-3 breakpoint owner table base address on success.
+ * @thread  EMT(0)
+ */
+static int dbgfR0BpOwnerInitWorker(PGVM pGVM, R3PTRTYPE(void *) *ppaBpOwnerR3)
+{
+    /*
+     * Figure out how much memory we need for the L1 lookup table and allocate it.
+     */
+    uint32_t const cbBpOwnerR0 = RT_ALIGN_32(DBGF_BP_OWNER_COUNT_MAX * sizeof(DBGFBPOWNERINTR0), PAGE_SIZE);
+    uint32_t const cbBpOwnerR3 = RT_ALIGN_32(DBGF_BP_OWNER_COUNT_MAX * sizeof(DBGFBPOWNERINT), PAGE_SIZE);
+    uint32_t const cbTotal     = RT_ALIGN_32(cbBpOwnerR0 + cbBpOwnerR3, PAGE_SIZE);
+
+    RTR0MEMOBJ hMemObj;
+    int rc = RTR0MemObjAllocPage(&hMemObj, cbTotal, false /*fExecutable*/);
+    if (RT_FAILURE(rc))
+        return rc;
+    RT_BZERO(RTR0MemObjAddress(hMemObj), cbTotal);
+
+    /* Map it. */
+    RTR0MEMOBJ hMapObj;
+    rc = RTR0MemObjMapUserEx(&hMapObj, hMemObj, (RTR3PTR)-1, 0, RTMEM_PROT_READ | RTMEM_PROT_WRITE, RTR0ProcHandleSelf(),
+                             cbBpOwnerR0 /*offSub*/, cbBpOwnerR3);
+    if (RT_SUCCESS(rc))
+    {
+        pGVM->dbgfr0.s.hMemObjBpOwners = hMemObj;
+        pGVM->dbgfr0.s.hMapObjBpOwners = hMapObj;
+        pGVM->dbgfr0.s.paBpOwnersR0    = (PDBGFBPOWNERINTR0)RTR0MemObjAddress(hMemObj);
+
+        /*
+         * We're done.
+         */
+        *ppaBpOwnerR3 = RTR0MemObjAddressR3(hMapObj);
         return rc;
     }
@@ -349 +412 @@
 
 /**
- * Used by ring-3 DBGF to allocate a given chunk in the global breakpoint table.
+ * Used by ring-3 DBGF to initialize the breakpoint owner table for operation.
  *
  * @returns VBox status code.
@@ -356 +419 @@
  * @thread  EMT(0)
  */
+VMMR0_INT_DECL(int) DBGFR0BpOwnerInitReqHandler(PGVM pGVM, PDBGFBPOWNERINITREQ pReq)
+{
+    LogFlow(("DBGFR0BpOwnerInitReqHandler:\n"));
+
+    /*
+     * Validate the request.
+     */
+    AssertReturn(pReq->Hdr.cbReq == sizeof(*pReq), VERR_INVALID_PARAMETER);
+
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, 0);
+    AssertRCReturn(rc, rc);
+
+    AssertReturn(!pGVM->dbgfr0.s.paBpOwnersR0, VERR_WRONG_ORDER);
+
+    return dbgfR0BpOwnerInitWorker(pGVM, &pReq->paBpOwnerR3);
+}
+
+
+/**
+ * Used by ring-3 DBGF to allocate a given chunk in the global breakpoint table.
+ *
+ * @returns VBox status code.
+ * @param   pGVM    The global (ring-0) VM structure.
+ * @param   pReq    Pointer to the request buffer.
+ * @thread  EMT(0)
+ */
 VMMR0_INT_DECL(int) DBGFR0BpChunkAllocReqHandler(PGVM pGVM, PDBGFBPCHUNKALLOCREQ pReq)
 {

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

@@ -2296 +2296 @@
             break;
         }
+
+        case VMMR0_DO_DBGF_BP_OWNER_INIT:
+        {
+            if (!pReqHdr || u64Arg || idCpu != 0)
+                return VERR_INVALID_PARAMETER;
+            rc = DBGFR0BpOwnerInitReqHandler(pGVM, (PDBGFBPOWNERINITREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+            break;
+        }
 #endif
 

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

@@ -182 +182 @@
     PVM pVM = pUVM->pVM;
 
+    //pUVM->dbgf.s.paBpOwnersR3       = NULL;
+    //pUVM->dbgf.s.pbmBpOwnersAllocR3 = NULL;
+
     /* Init hardware breakpoint states. */
     for (uint32_t i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); i++)
@@ -227 +230 @@
 DECLHIDDEN(int) dbgfR3BpTerm(PUVM pUVM)
 {
+    if (pUVM->dbgf.s.pbmBpOwnersAllocR3)
+    {
+        RTMemFree((void *)pUVM->dbgf.s.pbmBpOwnersAllocR3);
+        pUVM->dbgf.s.pbmBpOwnersAllocR3 = NULL;
+    }
+
     /* Free all allocated chunk bitmaps (the chunks itself are destroyed during ring-0 VM destruction). */
     for (uint32_t i = 0; i < RT_ELEMENTS(pUVM->dbgf.s.aBpChunks); i++)
@@ -314 +323 @@
     /* Gather all EMTs and call into ring-0 to initialize the breakpoint manager. */
     return VMMR3EmtRendezvous(pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, dbgfR3BpInitEmtWorker, NULL /*pvUser*/);
+}
+
+
+/**
+ * @callback_method_impl{FNVMMEMTRENDEZVOUS}
+ */
+static DECLCALLBACK(VBOXSTRICTRC) dbgfR3BpOwnerInitEmtWorker(PVM pVM, PVMCPU pVCpu, void *pvUser)
+{
+    RT_NOREF(pvUser);
+
+    VMCPU_ASSERT_EMT(pVCpu);
+    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
+
+    /*
+     * The initialization will be done on EMT(0). It is possible that multiple
+     * initialization attempts are done because dbgfR3BpOwnerEnsureInit() can be called
+     * from racing non EMT threads when trying to create a breakpoint owner for the first time.
+     * Just fake success if the pointers are initialized already, meaning that a previous rendezvous
+     * successfully initialized the breakpoint owner table.
+     */
+    int rc = VINF_SUCCESS;
+    PUVM pUVM = pVM->pUVM;
+    if (   pVCpu->idCpu == 0
+        && !pUVM->dbgf.s.pbmBpOwnersAllocR3)
+    {
+        pUVM->dbgf.s.pbmBpOwnersAllocR3 = (volatile void *)RTMemAllocZ(DBGF_BP_OWNER_COUNT_MAX / 8);
+        if (pUVM->dbgf.s.pbmBpOwnersAllocR3)
+        {
+            DBGFBPOWNERINITREQ Req;
+            Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
+            Req.Hdr.cbReq    = sizeof(Req);
+            Req.paBpOwnerR3  = NULL;
+            rc = VMMR3CallR0Emt(pVM, pVCpu, VMMR0_DO_DBGF_BP_OWNER_INIT, 0 /*u64Arg*/, &Req.Hdr);
+            AssertLogRelMsgRC(rc, ("VMMR0_DO_DBGF_BP_OWNER_INIT failed: %Rrc\n", rc));
+            if (RT_SUCCESS(rc))
+            {
+                pUVM->dbgf.s.paBpOwnersR3 = (PDBGFBPOWNERINT)Req.paBpOwnerR3;
+                return VINF_SUCCESS;
+            }
+
+            RTMemFree((void *)pUVM->dbgf.s.pbmBpOwnersAllocR3);
+            pUVM->dbgf.s.pbmBpOwnersAllocR3 = NULL;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Ensures that the breakpoint manager is fully initialized.
+ *
+ * @returns VBox status code.
+ * @param   pUVM                The user mode VM handle.
+ *
+ * @thread Any thread.
+ */
+static int dbgfR3BpOwnerEnsureInit(PUVM pUVM)
+{
+    /* If the allocation bitmap is allocated initialization succeeded before. */
+    if (RT_LIKELY(pUVM->dbgf.s.pbmBpOwnersAllocR3))
+        return VINF_SUCCESS;
+
+    /* Gather all EMTs and call into ring-0 to initialize the breakpoint manager. */
+    return VMMR3EmtRendezvous(pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, dbgfR3BpOwnerInitEmtWorker, NULL /*pvUser*/);
+}
+
+
+/**
+ * Returns the internal breakpoint owner state for the given handle.
+ *
+ * @returns Pointer to the internal breakpoint owner state or NULL if the handle is invalid.
+ * @param   pUVM                The user mode VM handle.
+ * @param   hBpOwner            The breakpoint owner handle to resolve.
+ */
+DECLINLINE(PDBGFBPOWNERINT) dbgfR3BpOwnerGetByHnd(PUVM pUVM, DBGFBPOWNER hBpOwner)
+{
+    AssertReturn(hBpOwner < DBGF_BP_OWNER_COUNT_MAX, NULL);
+    AssertPtrReturn(pUVM->dbgf.s.pbmBpOwnersAllocR3, NULL);
+
+    AssertReturn(ASMBitTest(pUVM->dbgf.s.pbmBpOwnersAllocR3, hBpOwner), NULL);
+    return &pUVM->dbgf.s.paBpOwnersR3[hBpOwner];
+}
+
+
+/**
+ * Retains the given breakpoint owner handle for use.
+ *
+ * @returns VBox status code.
+ * @retval VERR_INVALID_HANDLE if the given breakpoint owner handle is invalid.
+ * @param   pUVM                The user mode VM handle.
+ * @param   hBpOwner            The breakpoint owner handle to retain, NIL_DBGFOWNER is accepted without doing anything.
+ */
+DECLINLINE(int) dbgfR3BpOwnerRetain(PUVM pUVM, DBGFBPOWNER hBpOwner)
+{
+    if (hBpOwner == NIL_DBGFBPOWNER)
+        return VINF_SUCCESS;
+
+    PDBGFBPOWNERINT pBpOwner = dbgfR3BpOwnerGetByHnd(pUVM, hBpOwner);
+    if (pBpOwner)
+    {
+        ASMAtomicIncU32(&pBpOwner->cRefs);
+        return VINF_SUCCESS;
+    }
+
+    return VERR_INVALID_HANDLE;
+}
+
+
+/**
+ * Releases the given breakpoint owner handle.
+ *
+ * @returns VBox status code.
+ * @retval VERR_INVALID_HANDLE if the given breakpoint owner handle is invalid.
+ * @param   pUVM                The user mode VM handle.
+ * @param   hBpOwner            The breakpoint owner handle to retain, NIL_DBGFOWNER is accepted without doing anything.
+ */
+DECLINLINE(int) dbgfR3BpOwnerRelease(PUVM pUVM, DBGFBPOWNER hBpOwner)
+{
+    if (hBpOwner == NIL_DBGFBPOWNER)
+        return VINF_SUCCESS;
+
+    PDBGFBPOWNERINT pBpOwner = dbgfR3BpOwnerGetByHnd(pUVM, hBpOwner);
+    if (pBpOwner)
+    {
+        Assert(pBpOwner->cRefs > 1);
+        ASMAtomicDecU32(&pBpOwner->cRefs);
+        return VINF_SUCCESS;
+    }
+
+    return VERR_INVALID_HANDLE;
 }
 
@@ -438 +580 @@
                          PDBGFBPINT *ppBp)
 {
+    int rc = dbgfR3BpOwnerRetain(pUVM, hOwner);
+    if (RT_FAILURE(rc))
+        return rc;
+
     /*
      * Search for a chunk having a free entry, allocating new chunks
@@ -452 +598 @@
         if (idChunk == DBGF_BP_CHUNK_ID_INVALID)
         {
-            int rc = dbgfR3BpChunkAlloc(pUVM, i);
+            rc = dbgfR3BpChunkAlloc(pUVM, i);
             if (RT_FAILURE(rc))
             {
@@ -509 +655 @@
     }
 
+    rc = dbgfR3BpOwnerRelease(pUVM, hOwner); AssertRC(rc);
     return VERR_DBGF_NO_MORE_BP_SLOTS;
 }
@@ -534 +681 @@
 
     /** @todo Need a trip to Ring-0 if an owner is assigned with a Ring-0 part to clear the breakpoint. */
-    /** @todo Release owner. */
+    int rc = dbgfR3BpOwnerRelease(pUVM, pBp->Pub.hOwner); AssertRC(rc); RT_NOREF(rc);
     memset(pBp, 0, sizeof(*pBp));
 
@@ -1549 +1696 @@
  *
  * @returns VBox status code.
+ * @retval  VERR_DBGF_BP_OWNER_NO_MORE_HANDLES if there are no more free owner handles available.
  * @param   pUVM                The user mode VM handle.
  * @param   pfnBpHit            The R3 callback which is called when a breakpoint with the owner handle is hit.
  * @param   phBpOwner           Where to store the owner handle on success.
+ *
+ * @thread Any thread but might defer work to EMT on the first call.
  */
 VMMR3DECL(int) DBGFR3BpOwnerCreate(PUVM pUVM, PFNDBGFBPHIT pfnBpHit, PDBGFBPOWNER phBpOwner)
@@ -1562 +1712 @@
     AssertPtrReturn(phBpOwner, VERR_INVALID_POINTER);
 
-    return VERR_NOT_IMPLEMENTED;
+    int rc = dbgfR3BpOwnerEnsureInit(pUVM);
+    AssertRCReturn(rc ,rc);
+
+    /* Try to find a free entry in the owner table. */
+    for (;;)
+    {
+        /* Scan the associated bitmap for a free entry. */
+        int32_t iClr = ASMBitFirstClear(pUVM->dbgf.s.pbmBpOwnersAllocR3, DBGF_BP_OWNER_COUNT_MAX);
+        if (iClr != -1)
+        {
+            /*
+             * Try to allocate, we could get raced here as well. In that case
+             * we try again.
+             */
+            if (!ASMAtomicBitTestAndSet(pUVM->dbgf.s.pbmBpOwnersAllocR3, iClr))
+            {
+                PDBGFBPOWNERINT pBpOwner = &pUVM->dbgf.s.paBpOwnersR3[iClr];
+                pBpOwner->cRefs      = 1;
+                pBpOwner->pfnBpHitR3 = pfnBpHit;
+
+                *phBpOwner = (DBGFBPOWNER)iClr;
+                return VINF_SUCCESS;
+            }
+            /* else Retry with another spot. */
+        }
+        else /* no free entry in bitmap, out of entries. */
+        {
+            rc = VERR_DBGF_BP_OWNER_NO_MORE_HANDLES;
+            break;
+        }
+    }
+
+    return rc;
 }
 
@@ -1570 +1752 @@
  *
  * @returns VBox status code.
+ * @retval  VERR_INVALID_HANDLE if the given owner handle is invalid.
  * @retval  VERR_DBGF_OWNER_BUSY if there are still breakpoints set with the given owner handle.
  * @param   pUVM                The user mode VM handle.
@@ -1582 +1765 @@
     AssertReturn(hBpOwner != NIL_DBGFBPOWNER, VERR_INVALID_HANDLE);
 
-    return VERR_NOT_IMPLEMENTED;
+    int rc = dbgfR3BpOwnerEnsureInit(pUVM);
+    AssertRCReturn(rc ,rc);
+
+    PDBGFBPOWNERINT pBpOwner = dbgfR3BpOwnerGetByHnd(pUVM, hBpOwner);
+    if (RT_LIKELY(pBpOwner))
+    {
+        if (ASMAtomicReadU32(&pBpOwner->cRefs) == 1)
+        {
+            pBpOwner->pfnBpHitR3 = NULL;
+            ASMAtomicDecU32(&pBpOwner->cRefs);
+            ASMAtomicBitClear(pUVM->dbgf.s.pbmBpOwnersAllocR3, hBpOwner);
+        }
+        else
+            rc = VERR_DBGF_OWNER_BUSY;
+    }
+    else
+        rc = VERR_INVALID_HANDLE;
+
+    return rc;
 }
 

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

@@ -58 +58 @@
 /** @name Global breakpoint table handling defines.
  * @{ */
+/** Maximum number of breakpoint owners supported (power of two). */
+#define DBGF_BP_OWNER_COUNT_MAX             _32K
 /** Maximum number of breakpoints supported (power of two). */
 #define DBGF_BP_COUNT_MAX                   _1M
@@ -829 +831 @@
 
 /**
+ * The internal breakpoint owner state, shared part.
+ */
+typedef struct DBGFBPOWNERINT
+{
+    /** Reference counter indicating how man breakpoints use this owner currently. */
+    volatile uint32_t           cRefs;
+    /** Padding. */
+    uint32_t                    u32Pad0;
+    /** Callback to call when a breakpoint has hit, Ring-3 Ptr. */
+    R3PTRTYPE(PFNDBGFBPHIT)     pfnBpHitR3;
+} DBGFBPOWNERINT;
+AssertCompileSize(DBGFBPOWNERINT, 16);
+/** Pointer to an internal breakpoint owner state, shared part. */
+typedef DBGFBPOWNERINT *PDBGFBPOWNERINT;
+/** Pointer to a constant internal breakpoint owner state, shared part. */
+typedef const DBGFBPOWNERINT *PCDBGFBPOWNERINT;
+
+
+/**
+ * The internal breakpoint owner state, Ring-0 part.
+ */
+typedef struct DBGFBPOWNERINTR0
+{
+    /** Reference counter indicating how man breakpoints use this owner currently. */
+    volatile uint32_t           cRefs;
+    /** Padding. */
+    uint32_t                    u32Pad0;
+    /** Callback to call when a breakpoint has hit, Ring-0 Ptr. */
+    R0PTRTYPE(PFNDBGFBPHIT)     pfnBpHitR0;
+} DBGFBPOWNERINTR0;
+AssertCompileSize(DBGFBPOWNERINTR0, 16);
+/** Pointer to an internal breakpoint owner state, shared part. */
+typedef DBGFBPOWNERINTR0 *PDBGFBPOWNERINTR0;
+/** Pointer to a constant internal breakpoint owner state, shared part. */
+typedef const DBGFBPOWNERINTR0 *PCDBGFBPOWNERINTR0;
+
+
+/**
  * The internal breakpoint state, shared part.
  */
@@ -1285 +1325 @@
     /** @name Breakpoint handling related state, Ring-0 only part.
      * @{ */
+    /** The breakpoint owner table memory object. */
+    RTR0MEMOBJ                          hMemObjBpOwners;
+    /** The breakpoint owner table mapping object. */
+    RTR0MEMOBJ                          hMapObjBpOwners;
+    /** Base pointer to the breakpoint owners table. */
+    R0PTRTYPE(PDBGFBPOWNERINTR0)        paBpOwnersR0;
+
     /** Global breakpoint table chunk array. */
     DBGFBPCHUNKR0                       aBpChunks[DBGF_BP_CHUNK_COUNT];
@@ -1376 +1423 @@
     /** @name Breakpoint handling related state.
      * @{ */
+    /** Base pointer to the breakpoint owners table. */
+    R3PTRTYPE(PDBGFBPOWNERINT)      paBpOwnersR3;
+    /** Pointer to the bitmap denoting occupied owner entries. */
+    R3PTRTYPE(volatile void *)      pbmBpOwnersAllocR3;
+
     /** Global breakpoint table chunk array. */
     DBGFBPCHUNKR3                   aBpChunks[DBGF_BP_CHUNK_COUNT];