Changeset 86749 in vbox for trunk/src

Timestamp:

Oct 28, 2020 9:04:02 PM (4 years ago)

Author:

vboxsync

Message:

VMM/DBGF: Implement L2 binary search tree node removal and make the all context breakpoint management code compile in ring-3, completely untested though, bugref:9837

Location:

trunk/src/VBox/VMM

Files:

• Makefile.kmk (modified) (1 diff)
• VMMAll/DBGFAllBp.cpp (modified) (13 diffs)
• VMMR3/DBGFR3Bp.cpp (modified) (4 diffs)

trunk/src/VBox/VMM/Makefile.kmk

@@ -172 +172 @@
         VMMAll/CPUMAllMsrs.cpp \
         VMMAll/DBGFAll.cpp \
+        $(if-expr defined(VBOX_WITH_LOTS_OF_DBGF_BPS), VMMAll/DBGFAllBp.cpp,) \
         $(if-expr defined(VBOX_WITH_DBGF_TRACING), VMMAll/DBGFAllTracer.cpp,) \
         VMMAll/HMAll.cpp \

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

@@ -29 +29 @@
 #include <iprt/assert.h>
 
+#include "DBGFInline.h"
+
 
 #ifdef IN_RC
@@ -40 +42 @@
 
 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
-# ifdef IN_RING0
 /**
  * Returns the internal breakpoint state for the given handle.
@@ -50 +51 @@
  *                              on success, optional.
  */
-DECLINLINE(PDBGFBPINT) dbgfR0BpGetByHnd(PVMCC pVM, DBGFBP hBp, PDBGFBPINTR0 *ppBpR0)
+# ifdef IN_RING0
+DECLINLINE(PDBGFBPINT) dbgfBpGetByHnd(PVMCC pVM, DBGFBP hBp, PDBGFBPINTR0 *ppBpR0)
+# else
+DECLINLINE(PDBGFBPINT) dbgfBpGetByHnd(PVMCC pVM, DBGFBP hBp)
+# endif
 {
     uint32_t idChunk  = DBGF_BP_HND_GET_CHUNK_ID(hBp);
@@ -58 +63 @@
     AssertReturn(idxEntry < DBGF_BP_COUNT_PER_CHUNK, NULL);
 
+# ifdef IN_RING0
     PDBGFBPCHUNKR0 pBpChunk = &pVM->dbgfr0.s.aBpChunks[idChunk];
-    AssertPtrReturn(pBpChunk->paBpBaseSharedR0, NULL);
+    AssertPtrReturn(pBpChunk->CTX_SUFF(paBpBaseShared), NULL);
 
     if (ppBpR0)
         *ppBpR0 = &pBpChunk->paBpBaseR0Only[idxEntry];
-    return &pBpChunk->paBpBaseSharedR0[idxEntry];
+    return &pBpChunk->CTX_SUFF(paBpBaseShared)[idxEntry];
+# elif defined(IN_RING3)
+    PUVM pUVM = pVM->pUVM;
+    PDBGFBPCHUNKR3 pBpChunk = &pUVM->dbgf.s.aBpChunks[idChunk];
+    AssertPtrReturn(pBpChunk->CTX_SUFF(pBpBase), NULL);
+
+    return &pBpChunk->CTX_SUFF(pBpBase)[idxEntry];
+# else
+#  error "Unsupported host context"
+# endif
+}
+
+
+/**
+ * Returns the pointer to the L2 table entry from the given index.
+ *
+ * @returns Current context pointer to the L2 table entry or NULL if the provided index value is invalid.
+ * @param   pVM         The cross context VM structure.
+ * @param   idxL2       The L2 table index to resolve.
+ *
+ * @note The content of the resolved L2 table entry is not validated!.
+ */
+DECLINLINE(PCDBGFBPL2ENTRY) dbgfBpL2GetByIdx(PVMCC pVM, uint32_t idxL2)
+{
+    uint32_t idChunk  = DBGF_BP_L2_IDX_GET_CHUNK_ID(idxL2);
+    uint32_t idxEntry = DBGF_BP_L2_IDX_GET_ENTRY(idxL2);
+
+    AssertReturn(idChunk < DBGF_BP_L2_TBL_CHUNK_COUNT, NULL);
+    AssertReturn(idxEntry < DBGF_BP_L2_TBL_ENTRIES_PER_CHUNK, NULL);
+
+# ifdef IN_RING0
+    PDBGFBPL2TBLCHUNKR0 pL2Chunk = &pVM->dbgfr0.s.aBpL2TblChunks[idChunk];
+    AssertPtrReturn(pL2Chunk->CTX_SUFF(paBpL2TblBaseShared), NULL);
+
+    return &pL2Chunk->CTX_SUFF(paBpL2TblBaseShared)[idxEntry];
+# elif defined(IN_RING3)
+    PUVM pUVM = pVM->pUVM;
+    PDBGFBPL2TBLCHUNKR3 pL2Chunk = &pUVM->dbgf.s.aBpL2TblChunks[idChunk];
+    AssertPtrReturn(pL2Chunk->pbmAlloc, NULL);
+    AssertReturn(ASMBitTest(pL2Chunk->pbmAlloc, idxEntry), NULL);
+
+    return &pL2Chunk->CTX_SUFF(pL2Base)[idxEntry];
+# endif
 }
 
@@ -78 +126 @@
  * @param   pBpR0       The ring-0 only breakpoint state.
  */
-DECLINLINE(int) dbgfR0BpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame,
-                            DBGFBP hBp, PDBGFBPINT pBp, PDBGFBPINTR0 pBpR0)
+# ifdef IN_RING0
+DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame,
+                          DBGFBP hBp, PDBGFBPINT pBp, PDBGFBPINTR0 pBpR0)
+# else
+DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame,
+                          DBGFBP hBp, PDBGFBPINT pBp)
+# endif
 {
     uint64_t cHits = ASMAtomicIncU64(&pBp->Pub.cHits);
@@ -85 +138 @@
 
     /** @todo Owner handling. */
-    RT_NOREF(pVM, pRegFrame, pBpR0);
-
-    LogFlow(("dbgfRZBpHit: hit breakpoint %u at %04x:%RGv cHits=0x%RX64\n",
+    RT_NOREF(pVM, pRegFrame);
+#ifdef IN_RING0
+    RT_NOREF(pBpR0);
+#endif
+
+    LogFlow(("dbgfBpHit: hit breakpoint %u at %04x:%RGv cHits=0x%RX64\n",
              hBp, pRegFrame->cs.Sel, pRegFrame->rip, cHits));
     return VINF_EM_DBG_BREAKPOINT;
-}
-
-
-/**
- * Returns the pointer to the L2 table entry from the given index.
- *
- * @returns Current context pointer to the L2 table entry or NULL if the provided index value is invalid.
- * @param   pVM         The cross context VM structure.
- * @param   idxL2       The L2 table index to resolve.
- *
- * @note The content of the resolved L2 table entry is not validated!.
- */
-DECLINLINE(PCDBGFBPL2ENTRY) dbgfR0BpL2GetByIdx(PVMCC pVM, uint32_t idxL2)
-{
-    uint32_t idChunk  = DBGF_BP_L2_IDX_GET_CHUNK_ID(idxL2);
-    uint32_t idxEntry = DBGF_BP_L2_IDX_GET_ENTRY(idxL2);
-
-    AssertReturn(idChunk < DBGF_BP_L2_TBL_CHUNK_COUNT, NULL);
-    AssertReturn(idxEntry < DBGF_BP_L2_TBL_ENTRIES_PER_CHUNK, NULL);
-
-    PDBGFBPL2TBLCHUNKR0 pL2Chunk = &pVM->dbgfr0.s.aBpL2TblChunks[idChunk];
-    AssertPtrReturn(pL2Chunk->paBpL2TblBaseSharedR0, NULL);
-
-    return &pL2Chunk->CTX_SUFF(paBpL2TblBaseShared)[idxEntry];
 }
 
@@ -132 +164 @@
     /** @todo We don't use the depth right now but abort the walking after a fixed amount of levels. */
     uint8_t iDepth = 32;
-    PCDBGFBPL2ENTRY pL2Entry = dbgfR0BpL2GetByIdx(pVM, idxL2Root);
+    PCDBGFBPL2ENTRY pL2Entry = dbgfBpL2GetByIdx(pVM, idxL2Root);
 
     while (RT_LIKELY(   iDepth-- > 0
@@ -148 +180 @@
 
             /* Query the internal breakpoint state from the handle. */
+# ifdef IN_RING0
             PDBGFBPINTR0 pBpR0 = NULL;
-            PDBGFBPINT pBp = dbgfR0BpGetByHnd(pVM, hBp, &pBpR0);
+            PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
+# else
+            PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp);
+# endif
             if (   pBp
                 && DBGF_BP_PUB_GET_TYPE(pBp->Pub.fFlagsAndType) == DBGFBPTYPE_INT3)
-                return dbgfR0BpHit(pVM, pVCpu, pRegFrame, hBp, pBp, pBpR0);
+                return dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp
+# ifdef IN_RING0
+                                 , pBpR0
+# endif
+                                 );
 
             /* The entry got corrupted, just abort. */
@@ -166 +206 @@
             return VINF_EM_RAW_GUEST_TRAP;
 
-        pL2Entry = dbgfR0BpL2GetByIdx(pVM, idxL2Next);
+        pL2Entry = dbgfBpL2GetByIdx(pVM, idxL2Next);
     }
 
     return VERR_DBGF_BP_L2_LOOKUP_FAILED;
 }
-# endif /* !IN_RING0 */
 #endif /* !VBOX_WITH_LOTS_OF_DBGF_BPS */
 
@@ -290 +329 @@
     }
 #else
-#ifndef IN_RING0
-# error "Todo"
-#endif
-    if (pVM->dbgfr0.s.CTX_SUFF(paBpLocL1))
+# if defined(IN_RING0)
+    uint32_t volatile *paBpLocL1 = pVM->dbgfr0.s.CTX_SUFF(paBpLocL1);
+# elif defined(IN_RING3)
+    PUVM pUVM = pVM->pUVM;
+    uint32_t volatile *paBpLocL1 = pUVM->dbgf.s.CTX_SUFF(paBpLocL1);
+# else
+#  error "Unsupported host context"
+# endif
+    if (paBpLocL1)
     {
         RTGCPTR GCPtrBp;
@@ -302 +346 @@
 
         const uint16_t idxL1      = DBGF_BP_INT3_L1_IDX_EXTRACT_FROM_ADDR(GCPtrBp);
-        const uint32_t u32L1Entry = ASMAtomicReadU32(&pVM->dbgfr0.s.CTX_SUFF(paBpLocL1)[idxL1]);
+        const uint32_t u32L1Entry = ASMAtomicReadU32(&paBpLocL1[idxL1]);
 
         LogFlowFunc(("GCPtrBp=%RGv idxL1=%u u32L1Entry=%#x\n", GCPtrBp, idxL1, u32L1Entry));
@@ -314 +358 @@
 
                 /* Query the internal breakpoint state from the handle. */
+#ifdef IN_RING0
                 PDBGFBPINTR0 pBpR0 = NULL;
-                PDBGFBPINT pBp = dbgfR0BpGetByHnd(pVM, hBp, &pBpR0);
+#endif
+                PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp
+#ifdef IN_RING0
+                                                , &pBpR0
+#endif
+                                                );
                 if (   pBp
                     && DBGF_BP_PUB_GET_TYPE(pBp->Pub.fFlagsAndType) == DBGFBPTYPE_INT3)
                 {
                     if (pBp->Pub.u.Int3.GCPtr == (RTGCUINTPTR)GCPtrBp)
-                        rc = dbgfR0BpHit(pVM, pVCpu, pRegFrame, hBp, pBp, pBpR0);
+                        rc = dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp
+#ifdef IN_RING0
+                                       , pBpR0
+#endif
+                                       );
                     /* else: Genuine guest trap. */
                 }
@@ -333 +387 @@
         }
         /* else: Genuine guest trap. */
+
+        return rc;
     }
 #endif /* !VBOX_WITH_LOTS_OF_DBGF_BPS */

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

@@ -944 +944 @@
 static int dbgfR3BpInt2L2BstNodeInsert(PUVM pUVM, uint32_t idxL2Root, DBGFBP hBp, RTGCUINTPTR GCPtr)
 {
+    GCPtr = DBGF_BP_INT3_L2_KEY_EXTRACT_FROM_ADDR(GCPtr);
+
     /* Allocate a new node first. */
     uint32_t idxL2Nd = 0;
@@ -1022 +1024 @@
 
 /**
+ * Gets the leftmost from the given tree node start index.
+ *
+ * @returns VBox status code.
+ * @param   pUVM                The user mode VM handle.
+ * @param   idxL2Start          The start index to walk from.
+ * @param   pidxL2Leftmost      Where to store the L2 table index of the leftmost entry.
+ * @param   ppL2NdLeftmost      Where to store the pointer to the leftmost L2 table entry.
+ * @param   pidxL2NdLeftParent  Where to store the L2 table index of the leftmost entries parent.
+ * @param   ppL2NdLeftParent    Where to store the pointer to the leftmost L2 table entries parent.
+ */
+static int dbgfR33BpInt3BstGetLeftmostEntryFromNode(PUVM pUVM, uint32_t idxL2Start,
+                                                    uint32_t *pidxL2Leftmost, PDBGFBPL2ENTRY *ppL2NdLeftmost,
+                                                    uint32_t *pidxL2NdLeftParent, PDBGFBPL2ENTRY *ppL2NdLeftParent)
+{
+    uint32_t idxL2Parent = DBGF_BP_L2_ENTRY_IDX_END;
+    PDBGFBPL2ENTRY pL2NdParent = NULL;
+
+    for (;;)
+    {
+        PDBGFBPL2ENTRY pL2Entry = dbgfR3BpL2GetByIdx(pUVM, idxL2Start);
+        AssertPtr(pL2Entry);
+
+        uint32_t idxL2Left = DBGF_BP_L2_ENTRY_GET_IDX_LEFT(pL2Entry->u64LeftRightIdxDepthBpHnd2);
+        if (idxL2Start == DBGF_BP_L2_ENTRY_IDX_END)
+        {
+            *pidxL2Leftmost     = idxL2Start;
+            *ppL2NdLeftmost     = pL2Entry;
+            *pidxL2NdLeftParent = idxL2Parent;
+            *ppL2NdLeftParent   = pL2NdParent;
+            break;
+        }
+
+        idxL2Parent = idxL2Start;
+        idxL2Start  = idxL2Left;
+        pL2NdParent = pL2Entry;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Removes the given node rearranging the tree.
+ *
+ * @returns VBox status code.
+ * @param   pUVM                The user mode VM handle.
+ * @param   idxL1               The index into the L1 table pointing to the binary search tree containing the node.
+ * @param   idxL2Root           The L2 table index where the tree root is located.
+ * @param   idxL2Nd             The node index to remove.
+ * @param   pL2Nd               The L2 table entry to remove.
+ * @param   idxL2NdParent       The parents index, can be DBGF_BP_L2_ENTRY_IDX_END if the root is about to be removed.
+ * @param   pL2NdParent         The parents L2 table entry, can be NULL if the root is about to be removed.
+ * @param   fLeftChild          Flag whether the node is the left child of the parent or the right one.
+ */
+static int dbgfR3BpInt3BstNodeRemove(PUVM pUVM, uint32_t idxL1, uint32_t idxL2Root,
+                                     uint32_t idxL2Nd, PDBGFBPL2ENTRY pL2Nd,
+                                     uint32_t idxL2NdParent, PDBGFBPL2ENTRY pL2NdParent,
+                                     bool fLeftChild)
+{
+    /*
+     * If there are only two nodes remaining the tree will get destroyed and the
+     * L1 entry will be converted to the direct handle type.
+     */
+    uint32_t idxL2Left  = DBGF_BP_L2_ENTRY_GET_IDX_LEFT(pL2Nd->u64LeftRightIdxDepthBpHnd2);
+    uint32_t idxL2Right = DBGF_BP_L2_ENTRY_GET_IDX_RIGHT(pL2Nd->u64LeftRightIdxDepthBpHnd2);
+
+    Assert(idxL2NdParent != DBGF_BP_L2_ENTRY_IDX_END || !pL2NdParent);
+    uint32_t idxL2ParentNew = DBGF_BP_L2_ENTRY_IDX_END;
+    if (idxL2Right == DBGF_BP_L2_ENTRY_IDX_END)
+        idxL2ParentNew = idxL2Left;
+    else
+    {
+        /* Find the leftmost entry of the right subtree and move it to the to be removed nodes location in the tree. */
+        PDBGFBPL2ENTRY pL2NdLeftmostParent   = NULL;
+        PDBGFBPL2ENTRY pL2NdLeftmost         = NULL;
+        uint32_t idxL2NdLeftmostParent = DBGF_BP_L2_ENTRY_IDX_END;
+        uint32_t idxL2Leftmost = DBGF_BP_L2_ENTRY_IDX_END;
+        int rc = dbgfR33BpInt3BstGetLeftmostEntryFromNode(pUVM, idxL2Right, &idxL2Leftmost ,&pL2NdLeftmost,
+                                                          &idxL2NdLeftmostParent, &pL2NdLeftmostParent);
+        AssertRCReturn(rc, rc);
+
+        if (pL2NdLeftmostParent)
+        {
+            /* Rearrange the leftmost entries parents pointer. */
+            dbgfBpL2TblEntryUpdateLeft(pL2NdLeftmostParent, DBGF_BP_L2_ENTRY_GET_IDX_RIGHT(pL2NdLeftmost->u64LeftRightIdxDepthBpHnd2), 0 /*iDepth*/);
+            dbgfBpL2TblEntryUpdateRight(pL2NdLeftmost, idxL2Right, 0 /*iDepth*/);
+        }
+
+        dbgfBpL2TblEntryUpdateLeft(pL2NdLeftmost, idxL2Left, 0 /*iDepth*/);
+
+        /* Update the remove nodes parent to point to the new node. */
+        idxL2ParentNew = idxL2Leftmost;
+    }
+
+    if (pL2NdParent)
+    {
+        /* Asssign the new L2 index to proper parents left or right pointer. */
+        if (fLeftChild)
+            dbgfBpL2TblEntryUpdateLeft(pL2NdParent, idxL2ParentNew, 0 /*iDepth*/);
+        else
+            dbgfBpL2TblEntryUpdateRight(pL2NdParent, idxL2ParentNew, 0 /*iDepth*/);
+    }
+    else
+    {
+        /* The root node is removed, set the new root in the L1 table. */
+        Assert(idxL2ParentNew != DBGF_BP_L2_ENTRY_IDX_END);
+        idxL2Root = idxL2ParentNew;
+        ASMAtomicXchgU32(&pUVM->dbgf.s.paBpLocL1R3[idxL1], DBGF_BP_INT3_L1_ENTRY_CREATE_L2_IDX(idxL2Left));
+    }
+
+    /* Free the node. */
+    dbgfR3BpL2TblEntryFree(pUVM, idxL2Nd, pL2Nd);
+
+    /*
+     * Check whether the old/new root is the only node remaining and convert the L1
+     * table entry to a direct breakpoint handle one in that case.
+     */
+    pL2Nd = dbgfR3BpL2GetByIdx(pUVM, idxL2Root);
+    AssertPtr(pL2Nd);
+    if (   DBGF_BP_L2_ENTRY_GET_IDX_LEFT(pL2Nd->u64LeftRightIdxDepthBpHnd2) == DBGF_BP_L2_ENTRY_IDX_END
+        && DBGF_BP_L2_ENTRY_GET_IDX_RIGHT(pL2Nd->u64LeftRightIdxDepthBpHnd2) == DBGF_BP_L2_ENTRY_IDX_END)
+    {
+        DBGFBP hBp = DBGF_BP_L2_ENTRY_GET_BP_HND(pL2Nd->u64GCPtrKeyAndBpHnd1, pL2Nd->u64LeftRightIdxDepthBpHnd2);
+        dbgfR3BpL2TblEntryFree(pUVM, idxL2Root, pL2Nd);
+        ASMAtomicXchgU32(&pUVM->dbgf.s.paBpLocL1R3[idxL1], DBGF_BP_INT3_L1_ENTRY_CREATE_BP_HND(hBp));
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
  * Removes the given breakpoint handle keyed with the GC pointer from the L2 binary search tree
  * pointed to by the given L2 root index.
@@ -1032 +1166 @@
  * @param   GCPtr               The GC pointer the breakpoint is keyed with.
  */
-static int dbgfR3BpInt2L2BstNodeRemove(PUVM pUVM, uint32_t idxL1, uint32_t idxL2Root, DBGFBP hBp, RTGCUINTPTR GCPtr)
-{
+static int dbgfR3BpInt3L2BstRemove(PUVM pUVM, uint32_t idxL1, uint32_t idxL2Root, DBGFBP hBp, RTGCUINTPTR GCPtr)
+{
+    GCPtr = DBGF_BP_INT3_L2_KEY_EXTRACT_FROM_ADDR(GCPtr);
+
     int rc = RTSemFastMutexRequest(pUVM->dbgf.s.hMtxBpL2Wr); AssertRC(rc);
 
-    RT_NOREF(idxL1, idxL2Root, hBp, GCPtr);
+    uint32_t idxL2Cur = idxL2Root;
+    uint32_t idxL2Parent = DBGF_BP_L2_ENTRY_IDX_END;
+    bool fLeftChild = false;
+    PDBGFBPL2ENTRY pL2EntryParent = NULL;
+    for (;;)
+    {
+        PDBGFBPL2ENTRY pL2Entry = dbgfR3BpL2GetByIdx(pUVM, idxL2Cur);
+        AssertPtr(pL2Entry);
+
+        /* Check whether this node is to be removed.. */
+        RTGCUINTPTR GCPtrL2Entry = DBGF_BP_L2_ENTRY_GET_GCPTR(pL2Entry->u64GCPtrKeyAndBpHnd1);
+        if (GCPtrL2Entry == GCPtr)
+        {
+            Assert(DBGF_BP_L2_ENTRY_GET_BP_HND(pL2Entry->u64GCPtrKeyAndBpHnd1, pL2Entry->u64LeftRightIdxDepthBpHnd2) == hBp);
+
+            rc = dbgfR3BpInt3BstNodeRemove(pUVM, idxL1, idxL2Root, idxL2Cur, pL2Entry,
+                                           idxL2Parent, pL2EntryParent, fLeftChild);
+            break;
+        }
+
+        pL2EntryParent = pL2Entry;
+        idxL2Parent    = idxL2Cur;
+
+        if (GCPtrL2Entry < GCPtr)
+        {
+            fLeftChild = true;
+            idxL2Cur = DBGF_BP_L2_ENTRY_GET_IDX_LEFT(pL2Entry->u64LeftRightIdxDepthBpHnd2);
+        }
+        else
+        {
+            fLeftChild = false;
+            idxL2Cur = DBGF_BP_L2_ENTRY_GET_IDX_RIGHT(pL2Entry->u64LeftRightIdxDepthBpHnd2);
+        }
+
+        AssertBreakStmt(idxL2Cur != DBGF_BP_L2_ENTRY_IDX_END, rc = VERR_DBGF_BP_L2_LOOKUP_FAILED);
+    }
 
     int rc2 = RTSemFastMutexRelease(pUVM->dbgf.s.hMtxBpL2Wr); AssertRC(rc2);
@@ -1132 +1303 @@
                 AssertReturn(DBGF_BP_INT3_L1_ENTRY_GET_TYPE(u32Entry) == DBGF_BP_INT3_L1_ENTRY_TYPE_L2_IDX, VERR_DBGF_BP_IPE_9);
 
-                rc = dbgfR3BpInt2L2BstNodeRemove(pUVM, idxL1, DBGF_BP_INT3_L1_ENTRY_GET_L2_IDX(u32Entry),
-                                                 hBp, pBp->Pub.u.Int3.GCPtr);
+                rc = dbgfR3BpInt3L2BstRemove(pUVM, idxL1, DBGF_BP_INT3_L1_ENTRY_GET_L2_IDX(u32Entry),
+                                             hBp, pBp->Pub.u.Int3.GCPtr);
             }
         }
         else if (u8Type == DBGF_BP_INT3_L1_ENTRY_TYPE_L2_IDX)
-            rc = dbgfR3BpInt2L2BstNodeRemove(pUVM, idxL1, DBGF_BP_INT3_L1_ENTRY_GET_L2_IDX(u32Entry),
-                                             hBp, pBp->Pub.u.Int3.GCPtr);
+            rc = dbgfR3BpInt3L2BstRemove(pUVM, idxL1, DBGF_BP_INT3_L1_ENTRY_GET_L2_IDX(u32Entry),
+                                         hBp, pBp->Pub.u.Int3.GCPtr);
     }