VirtualBox

Changeset 87594 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Feb 3, 2021 8:23:46 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
142626
Message:

VMM/DBGF,Debugger: Removed the !defined(VBOX_WITH_LOTS_OF_DBGF_BPS) code. bugref:9837

Location:
trunk/src/VBox/VMM
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/Makefile.kmk

    r87477 r87594  
    7171ifdef VBOX_WITH_DBGF_TRACING
    7272VBoxVMM_DEFS    += VBOX_WITH_DBGF_TRACING
    73 endif
    74 ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    75 VBoxVMM_DEFS    += VBOX_WITH_LOTS_OF_DBGF_BPS
    7673endif
    7774ifdef VBOX_WITH_DBGF_FLOW_TRACING
    … …  
    10299        VMMR3/DBGFAddr.cpp \
    103100        VMMR3/DBGFAddrSpace.cpp \
    104         $(if-expr defined(VBOX_WITH_LOTS_OF_DBGF_BPS), VMMR3/DBGFR3Bp.cpp, VMMR3/DBGFBp.cpp) \
     101        VMMR3/DBGFR3Bp.cpp \
    105102        VMMR3/DBGFR3BugCheck.cpp \
    106103        VMMR3/DBGFCoreWrite.cpp \
    … …  
    176173        VMMAll/CPUMAllMsrs.cpp \
    177174        VMMAll/DBGFAll.cpp \
    178         $(if-expr defined(VBOX_WITH_LOTS_OF_DBGF_BPS), VMMAll/DBGFAllBp.cpp,) \
     175        VMMAll/DBGFAllBp.cpp \
    179176        $(if-expr defined(VBOX_WITH_DBGF_TRACING), VMMAll/DBGFAllTracer.cpp,) \
    180177        VMMAll/HMAll.cpp \
    … …  
    463460VMMR0_DEFS     += VBOX_WITH_DBGF_TRACING
    464461 endif
    465  ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    466 VMMR0_DEFS     += VBOX_WITH_LOTS_OF_DBGF_BPS
    467  endif
    468462 ifdef VBOX_WITH_VMM_R0_SWITCH_STACK
    469463VMMR0_DEFS     += VMM_R0_SWITCH_STACK
    … …  
    488482        VMMR0/CPUMR0A.asm \
    489483        VMMR0/DBGFR0.cpp \
    490         $(if-expr defined(VBOX_WITH_LOTS_OF_DBGF_BPS), VMMR0/DBGFR0Bp.cpp,) \
     484        VMMR0/DBGFR0Bp.cpp \
    491485        $(if-expr defined(VBOX_WITH_DBGF_TRACING), VMMR0/DBGFR0Tracer.cpp,) \
    492486        VMMR0/GIMR0.cpp \

  • trunk/src/VBox/VMM/VMMAll/DBGFAll.cpp

    r86667 r87594  
    5050{
    5151    RTGCUINTREG uDr7 = X86_DR7_GD | X86_DR7_GE | X86_DR7_LE | X86_DR7_RA1_MASK;
    52 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    53     PDBGFBP     pBp = &pVM->dbgf.s.aHwBreakpoints[0];
    54     unsigned    cLeft = RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints);
    55     while (cLeft-- > 0)
    56     {
    57         if (    pBp->enmType == DBGFBPTYPE_REG
    58             &&  pBp->fEnabled)
    59         {
    60             static const uint8_t s_au8Sizes[8] =
    61             {
    62                 X86_DR7_LEN_BYTE, X86_DR7_LEN_BYTE, X86_DR7_LEN_WORD, X86_DR7_LEN_BYTE,
    63                 X86_DR7_LEN_DWORD,X86_DR7_LEN_BYTE, X86_DR7_LEN_BYTE, X86_DR7_LEN_QWORD
    64             };
    65             uDr7 |= X86_DR7_G(pBp->u.Reg.iReg)
    66                  |  X86_DR7_RW(pBp->u.Reg.iReg, pBp->u.Reg.fType)
    67                  |  X86_DR7_LEN(pBp->u.Reg.iReg, s_au8Sizes[pBp->u.Reg.cb]);
    68         }
    69         pBp++;
    70     }
    71 #else
    7252    for (uint32_t i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); i++)
    7353    {
    74         PCDBGFBPHW  pBp = &pVM->dbgf.s.aHwBreakpoints[i];
    75 
    76         if (    pBp->hBp != NIL_DBGFBP
    77             &&  pBp->fEnabled)
     54        if (   pVM->dbgf.s.aHwBreakpoints[i].fEnabled
     55            && pVM->dbgf.s.aHwBreakpoints[i].hBp != NIL_DBGFBP)
    7856        {
    7957            static const uint8_t s_au8Sizes[8] =
    … …  
    8361            };
    8462            uDr7 |= X86_DR7_G(i)
    85                  |  X86_DR7_RW(i, pBp->fType)
    86                  |  X86_DR7_LEN(i, s_au8Sizes[pBp->cb]);
    87         }
    88         pBp++;
     63                 |  X86_DR7_RW(i, pVM->dbgf.s.aHwBreakpoints[i].fType)
     64                 |  X86_DR7_LEN(i, s_au8Sizes[pVM->dbgf.s.aHwBreakpoints[i].cb]);
     65        }
    8966    }
    90 #endif
    9167    return uDr7;
    9268}
    … …  
    10177VMM_INT_DECL(RTGCUINTREG) DBGFBpGetDR0(PVM pVM)
    10278{
    103 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    104     PCDBGFBP    pBp = &pVM->dbgf.s.aHwBreakpoints[0];
    105     Assert(pBp->u.Reg.iReg == 0);
    106     return pBp->u.Reg.GCPtr;
    107 #else
    108     PCDBGFBPHW pBp = &pVM->dbgf.s.aHwBreakpoints[0];
    109     return pBp->GCPtr;
    110 #endif
     79    return pVM->dbgf.s.aHwBreakpoints[0].GCPtr;
    11180}
    11281
    … …  
    12089VMM_INT_DECL(RTGCUINTREG) DBGFBpGetDR1(PVM pVM)
    12190{
    122 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    123     PCDBGFBP    pBp = &pVM->dbgf.s.aHwBreakpoints[1];
    124     Assert(pBp->u.Reg.iReg == 1);
    125     return pBp->u.Reg.GCPtr;
    126 #else
    127     PCDBGFBPHW pBp = &pVM->dbgf.s.aHwBreakpoints[1];
    128     return pBp->GCPtr;
    129 #endif
     91    return pVM->dbgf.s.aHwBreakpoints[1].GCPtr;
    13092}
    13193
    … …  
    139101VMM_INT_DECL(RTGCUINTREG) DBGFBpGetDR2(PVM pVM)
    140102{
    141 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    142     PCDBGFBP    pBp = &pVM->dbgf.s.aHwBreakpoints[2];
    143     Assert(pBp->u.Reg.iReg == 2);
    144     return pBp->u.Reg.GCPtr;
    145 #else
    146     PCDBGFBPHW pBp = &pVM->dbgf.s.aHwBreakpoints[2];
    147     return pBp->GCPtr;
    148 #endif
     103    return pVM->dbgf.s.aHwBreakpoints[2].GCPtr;
    149104}
    150105
    … …  
    158113VMM_INT_DECL(RTGCUINTREG) DBGFBpGetDR3(PVM pVM)
    159114{
    160 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    161     PCDBGFBP    pBp = &pVM->dbgf.s.aHwBreakpoints[3];
    162     Assert(pBp->u.Reg.iReg == 3);
    163     return pBp->u.Reg.GCPtr;
    164 #else
    165     PCDBGFBPHW pBp = &pVM->dbgf.s.aHwBreakpoints[3];
    166     return pBp->GCPtr;
    167 #endif
     115    return pVM->dbgf.s.aHwBreakpoints[3].GCPtr;
    168116}
    169117
    … …  
    204152VMM_INT_DECL(bool) DBGFBpIsInt3Armed(PVM pVM)
    205153{
    206 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
     154    /** @todo There was a todo here and returning false when I (bird) removed
     155     *        VBOX_WITH_LOTS_OF_DBGF_BPS, so this might not be correct. */
    207156    return pVM->dbgf.s.cEnabledInt3Breakpoints > 0;
    208 #else
    209     RT_NOREF(pVM);
    210     return false; /** @todo */
    211 #endif
    212157}
    213158
    … …  
    222167 *          been updated appropriately.
    223168 *
    224  * @param   pVM        The cross context VM structure.
     169 * @param   pVM         The cross context VM structure.
    225170 * @param   pVCpu       The cross context virtual CPU structure of the calling EMT.
    226171 * @param   pCtx        The CPU context for the calling EMT.
    … …  
    241186        for (unsigned iBp = 0; iBp < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); iBp++)
    242187        {
    243 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    244             if (   pVM->dbgf.s.aHwBreakpoints[iBp].u.Reg.fType == X86_DR7_RW_IO
     188            if (   pVM->dbgf.s.aHwBreakpoints[iBp].fType == X86_DR7_RW_IO
    245189                && pVM->dbgf.s.aHwBreakpoints[iBp].fEnabled
    246                 && pVM->dbgf.s.aHwBreakpoints[iBp].enmType     == DBGFBPTYPE_REG )
     190                && pVM->dbgf.s.aHwBreakpoints[iBp].hBp   == NIL_DBGFBP) /** @todo r=bird: this cannot be right... */
    247191            {
    248                 uint8_t  cbReg      = pVM->dbgf.s.aHwBreakpoints[iBp].u.Reg.cb; Assert(RT_IS_POWER_OF_TWO(cbReg));
    249                 uint64_t uDrXFirst  = pVM->dbgf.s.aHwBreakpoints[iBp].u.Reg.GCPtr & ~(uint64_t)(cbReg - 1);
     192                uint8_t  cbReg      = pVM->dbgf.s.aHwBreakpoints[iBp].cb; Assert(RT_IS_POWER_OF_TWO(cbReg));
     193                uint64_t uDrXFirst  = pVM->dbgf.s.aHwBreakpoints[iBp].GCPtr & ~(uint64_t)(cbReg - 1);
    250194                uint64_t uDrXLast   = uDrXFirst + cbReg - 1;
    251195                if (uDrXFirst <= uIoPortLast && uDrXLast >= uIoPortFirst)
    252196                {
    253197                    /* (See also DBGFRZTrap01Handler.) */
    254                     pVCpu->dbgf.s.iActiveBp = pVM->dbgf.s.aHwBreakpoints[iBp].iBp;
    255                     pVCpu->dbgf.s.fSingleSteppingRaw = false;
    256 
    257                     LogFlow(("DBGFBpCheckIo: hit hw breakpoint %d at %04x:%RGv (iop %#x)\n",
    258                              pVM->dbgf.s.aHwBreakpoints[iBp].iBp, pCtx->cs.Sel, pCtx->rip, uIoPort));
    259                     return VINF_EM_DBG_BREAKPOINT;
    260                 }
    261             }
    262 #else
    263             PCDBGFBPHW  pBp = &pVM->dbgf.s.aHwBreakpoints[iBp];
    264 
    265             if (   pBp->fType == X86_DR7_RW_IO
    266                 && pBp->hBp == NIL_DBGFBP
    267                 && pBp->fEnabled)
    268             {
    269                 uint8_t  cbReg      = pBp->cb; Assert(RT_IS_POWER_OF_TWO(cbReg));
    270                 uint64_t uDrXFirst  = pBp->GCPtr & ~(uint64_t)(cbReg - 1);
    271                 uint64_t uDrXLast   = uDrXFirst + cbReg - 1;
    272                 if (uDrXFirst <= uIoPortLast && uDrXLast >= uIoPortFirst)
    273                 {
    274                     /* (See also DBGFRZTrap01Handler.) */
    275                     pVCpu->dbgf.s.hBpActive = pBp->hBp;
     198                    pVCpu->dbgf.s.hBpActive = pVM->dbgf.s.aHwBreakpoints[iBp].hBp;
    276199                    pVCpu->dbgf.s.fSingleSteppingRaw = false;
    277200
    … …  
    281204                }
    282205            }
    283 #endif
    284206        }
    285207    }

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

    r87132 r87594  
    3232#include <iprt/assert.h>
    3333
    34 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    35 # include "DBGFInline.h"
    36 #endif
     34#include "DBGFInline.h"
    3735
    3836
    … …  
    4240
    4341
    44 /*********************************************************************************************************************************
    45 *   Internal Functions                                                                                                           *
    46 *********************************************************************************************************************************/
    47 
    48 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    4942/**
    5043 * Returns the internal breakpoint state for the given handle.
    … …  
    5649 *                              on success, optional.
    5750 */
    58 # ifdef IN_RING0
     51#ifdef IN_RING0
    5952DECLINLINE(PDBGFBPINT) dbgfBpGetByHnd(PVMCC pVM, DBGFBP hBp, PDBGFBPINTR0 *ppBpR0)
    60 # else
     53#else
    6154DECLINLINE(PDBGFBPINT) dbgfBpGetByHnd(PVMCC pVM, DBGFBP hBp)
    62 # endif
     55#endif
    6356{
    6457    uint32_t idChunk  = DBGF_BP_HND_GET_CHUNK_ID(hBp);
    … …  
    6861    AssertReturn(idxEntry < DBGF_BP_COUNT_PER_CHUNK, NULL);
    6962
    70 # ifdef IN_RING0
     63#ifdef IN_RING0
    7164    PDBGFBPCHUNKR0 pBpChunk = &pVM->dbgfr0.s.aBpChunks[idChunk];
    7265    AssertPtrReturn(pBpChunk->CTX_SUFF(paBpBaseShared), NULL);
    … …  
    7568        *ppBpR0 = &pBpChunk->paBpBaseR0Only[idxEntry];
    7669    return &pBpChunk->CTX_SUFF(paBpBaseShared)[idxEntry];
    77 # elif defined(IN_RING3)
     70
     71#elif defined(IN_RING3)
    7872    PUVM pUVM = pVM->pUVM;
    7973    PDBGFBPCHUNKR3 pBpChunk = &pUVM->dbgf.s.aBpChunks[idChunk];
    … …  
    8175
    8276    return &pBpChunk->CTX_SUFF(pBpBase)[idxEntry];
    83 # else
    84 #  error "Unsupported host context"
    85 # endif
     77
     78#else
     79# error "Unsupported context"
     80#endif
    8681}
    8782
    … …  
    10499    AssertReturn(idxEntry < DBGF_BP_L2_TBL_ENTRIES_PER_CHUNK, NULL);
    105100
    106 # ifdef IN_RING0
     101#ifdef IN_RING0
    107102    PDBGFBPL2TBLCHUNKR0 pL2Chunk = &pVM->dbgfr0.s.aBpL2TblChunks[idChunk];
    108103    AssertPtrReturn(pL2Chunk->CTX_SUFF(paBpL2TblBaseShared), NULL);
    109104
    110105    return &pL2Chunk->CTX_SUFF(paBpL2TblBaseShared)[idxEntry];
    111 # elif defined(IN_RING3)
     106#elif defined(IN_RING3)
    112107    PUVM pUVM = pVM->pUVM;
    113108    PDBGFBPL2TBLCHUNKR3 pL2Chunk = &pUVM->dbgf.s.aBpL2TblChunks[idChunk];
    … …  
    116111
    117112    return &pL2Chunk->CTX_SUFF(pL2Base)[idxEntry];
    118 # endif
    119 }
    120 
    121 
    122 # ifdef IN_RING0
     113#endif
     114}
     115
     116
     117#ifdef IN_RING0
    123118/**
    124119 * Returns the internal breakpoint owner state for the given handle.
    … …  
    140135    return pBpOwnerR0;
    141136}
    142 # endif
     137#endif
    143138
    144139
    … …  
    154149 * @param   pBpR0       The ring-0 only breakpoint state.
    155150 */
    156 # ifdef IN_RING0
    157 DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame,
    158                           DBGFBP hBp, PDBGFBPINT pBp, PDBGFBPINTR0 pBpR0)
    159 # else
    160 DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame,
    161                           DBGFBP hBp, PDBGFBPINT pBp)
    162 # endif
     151#ifdef IN_RING0
     152DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame, DBGFBP hBp, PDBGFBPINT pBp, PDBGFBPINTR0 pBpR0)
     153#else
     154DECLINLINE(int) dbgfBpHit(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame, DBGFBP hBp, PDBGFBPINT pBp)
     155#endif
    163156{
    164157    uint64_t cHits = ASMAtomicIncU64(&pBp->Pub.cHits); RT_NOREF(cHits);
    … …  
    169162
    170163    int rc = VINF_EM_DBG_BREAKPOINT;
    171 # ifdef IN_RING0
     164#ifdef IN_RING0
    172165    PCDBGFBPOWNERINTR0 pBpOwnerR0 = dbgfR0BpOwnerGetByHnd(pVM,
    173166                                                            pBpR0->fInUse
    … …  
    208201        pVCpu->dbgf.s.hBpActive              = hBp;
    209202    }
    210 # else
     203#else
    211204    RT_NOREF(pVM);
    212205    pVCpu->dbgf.s.fBpInvokeOwnerCallback = true;
    213206    pVCpu->dbgf.s.hBpActive = hBp;
    214 # endif
     207#endif
    215208
    216209    return rc;
    … …  
    249242
    250243            /* Query the internal breakpoint state from the handle. */
    251 # ifdef IN_RING0
     244#ifdef IN_RING3
     245            PDBGFBPINT   pBp = dbgfBpGetByHnd(pVM, hBp);
     246#else
    252247            PDBGFBPINTR0 pBpR0 = NULL;
    253             PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
    254 # else
    255             PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp);
    256 # endif
     248            PDBGFBPINT   pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
     249#endif
    257250            if (   pBp
    258251                && DBGF_BP_PUB_GET_TYPE(pBp->Pub.fFlagsAndType) == DBGFBPTYPE_INT3)
    259                 return dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp
    260 # ifdef IN_RING0
    261                                  , pBpR0
    262 # endif
    263                                  );
     252#ifdef IN_RING3
     253                return dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp);
     254#else
     255                return dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp, pBpR0);
     256#endif
    264257
    265258            /* The entry got corrupted, just abort. */
    … …  
    280273    return VERR_DBGF_BP_L2_LOOKUP_FAILED;
    281274}
    282 #endif /* !VBOX_WITH_LOTS_OF_DBGF_BPS */
    283275
    284276
    … …  
    309301    {
    310302        for (unsigned iBp = 0; iBp < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); iBp++)
    311         {
    312 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    313             if (    ((uint32_t)uDr6 & RT_BIT_32(iBp))
    314                 &&  pVM->dbgf.s.aHwBreakpoints[iBp].enmType == DBGFBPTYPE_REG)
    315             {
    316                 pVCpu->dbgf.s.iActiveBp = pVM->dbgf.s.aHwBreakpoints[iBp].iBp;
    317                 pVCpu->dbgf.s.fSingleSteppingRaw = false;
    318                 LogFlow(("DBGFRZTrap03Handler: hit hw breakpoint %d at %04x:%RGv\n",
    319                          pVM->dbgf.s.aHwBreakpoints[iBp].iBp, pRegFrame->cs.Sel, pRegFrame->rip));
    320 
    321                 return VINF_EM_DBG_BREAKPOINT;
    322             }
    323 #else
    324303            if (    ((uint32_t)uDr6 & RT_BIT_32(iBp))
    325304                &&  pVM->dbgf.s.aHwBreakpoints[iBp].hBp != NIL_DBGFBP)
    … …  
    332311                return VINF_EM_DBG_BREAKPOINT;
    333312            }
    334 #endif
    335         }
    336313    }
    337314
    … …  
    340317     * Are we single stepping or is it the guest?
    341318     */
    342     if (    (uDr6 & X86_DR6_BS)
    343         &&  (pVCpu->dbgf.s.fSingleSteppingRaw || fAltStepping))
     319    if (   (uDr6 & X86_DR6_BS)
     320        && (pVCpu->dbgf.s.fSingleSteppingRaw || fAltStepping))
    344321    {
    345322        pVCpu->dbgf.s.fSingleSteppingRaw = false;
    … …  
    366343VMM_INT_DECL(int) DBGFTrap03Handler(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame)
    367344{
    368 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    369     /*
    370      * Get the trap address and look it up in the breakpoint table.
    371      * Don't bother if we don't have any breakpoints.
    372      */
    373     unsigned cToSearch = pVM->dbgf.s.Int3.cToSearch;
    374     if (cToSearch > 0)
    375     {
    376         RTGCPTR pPc;
    377         int rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss.Sel, pRegFrame->cs.Sel, &pRegFrame->cs,
    378                                               pRegFrame->rip /* no -1 in R0 */,
    379                                               &pPc);
    380         AssertRCReturn(rc, rc);
    381 
    382         unsigned iBp = pVM->dbgf.s.Int3.iStartSearch;
    383         while (cToSearch-- > 0)
    384         {
    385             if (   pVM->dbgf.s.aBreakpoints[iBp].u.GCPtr == (RTGCUINTPTR)pPc
    386                 && pVM->dbgf.s.aBreakpoints[iBp].enmType == DBGFBPTYPE_INT3)
    387             {
    388                 pVM->dbgf.s.aBreakpoints[iBp].cHits++;
    389                 pVCpu->dbgf.s.iActiveBp = pVM->dbgf.s.aBreakpoints[iBp].iBp;
    390 
    391                 LogFlow(("DBGFRZTrap03Handler: hit breakpoint %d at %RGv (%04x:%RGv) cHits=0x%RX64\n",
    392                          pVM->dbgf.s.aBreakpoints[iBp].iBp, pPc, pRegFrame->cs.Sel, pRegFrame->rip,
    393                          pVM->dbgf.s.aBreakpoints[iBp].cHits));
    394                 return VINF_EM_DBG_BREAKPOINT;
    395             }
    396             iBp++;
    397         }
    398     }
    399 #else
    400 # if defined(IN_RING0)
     345#if defined(IN_RING0)
    401346    uint32_t volatile *paBpLocL1 = pVM->dbgfr0.s.CTX_SUFF(paBpLocL1);
    402 # elif defined(IN_RING3)
     347#elif defined(IN_RING3)
    403348    PUVM pUVM = pVM->pUVM;
    404349    uint32_t volatile *paBpLocL1 = pUVM->dbgf.s.CTX_SUFF(paBpLocL1);
    405 # else
    406 #  error "Unsupported host context"
    407 # endif
     350#else
     351# error "Unsupported host context"
     352#endif
    408353    if (paBpLocL1)
    409354    {
    … …  
    427372
    428373                /* Query the internal breakpoint state from the handle. */
    429 #ifdef IN_RING0
     374#ifdef IN_RING3
     375                PDBGFBPINT   pBp = dbgfBpGetByHnd(pVM, hBp);
     376#else
    430377                PDBGFBPINTR0 pBpR0 = NULL;
    431 #endif
    432                 PDBGFBPINT pBp = dbgfBpGetByHnd(pVM, hBp
    433 #ifdef IN_RING0
    434                                                 , &pBpR0
    435 #endif
    436                                                 );
     378                PDBGFBPINT   pBp = dbgfBpGetByHnd(pVM, hBp, &pBpR0);
     379#endif
    437380                if (   pBp
    438381                    && DBGF_BP_PUB_GET_TYPE(pBp->Pub.fFlagsAndType) == DBGFBPTYPE_INT3)
    439382                {
    440383                    if (pBp->Pub.u.Int3.GCPtr == (RTGCUINTPTR)GCPtrBp)
    441                         rc = dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp
    442 #ifdef IN_RING0
    443                                        , pBpR0
    444 #endif
    445                                        );
     384#ifdef IN_RING3
     385                        rc = dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp);
     386#else
     387                        rc = dbgfBpHit(pVM, pVCpu, pRegFrame, hBp, pBp, pBpR0);
     388#endif
    446389                    /* else: Genuine guest trap. */
    447390                }
    … …  
    459402        return rc;
    460403    }
    461 #endif /* !VBOX_WITH_LOTS_OF_DBGF_BPS */
    462404
    463405    return VINF_EM_RAW_GUEST_TRAP;

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

    r86699 r87594  
    4040
    4141
    42 /*********************************************************************************************************************************
    43 *   Internal Functions                                                                                                           *
    44 *********************************************************************************************************************************/
    4542
    4643/**
    … …  
    5653    pGVM->dbgfr0.s.pTracerR0 = NULL;
    5754
    58 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    5955    dbgfR0BpInit(pGVM);
    60 #endif
    6156}
    6257
    … …  
    7368#endif
    7469
    75 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    7670    dbgfR0BpDestroy(pGVM);
    77 #endif
    7871}
    7972

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

    r87591 r87594  
    22572257            if (!pReqHdr || u64Arg)
    22582258                return VERR_INVALID_PARAMETER;
    2259 #if 0 /** @todo */
     2259# if 0 /** @todo */
    22602260            rc = DBGFR0TracerGenCallReqHandler(pGVM, (PDBGFTRACERGENCALLREQ)pReqHdr, idCpu);
    2261 #else
     2261# else
    22622262            rc = VERR_NOT_IMPLEMENTED;
    2263 #endif
    2264             VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
    2265             break;
    2266         }
    2267 #endif
    2268 
    2269 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
     2263# endif
     2264            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     2265            break;
     2266        }
     2267#endif
     2268
    22702269        case VMMR0_DO_DBGF_BP_INIT:
    22712270        {
    … …  
    23032302            break;
    23042303        }
    2305 #endif
    23062304
    23072305        /*
    … …  
    24072405            case VMMR0_DO_IOM_GROW_IO_PORTS:
    24082406            case VMMR0_DO_IOM_GROW_IO_PORT_STATS:
    2409 
    2410 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    24112407            case VMMR0_DO_DBGF_BP_INIT:
    24122408            case VMMR0_DO_DBGF_BP_CHUNK_ALLOC:
    24132409            case VMMR0_DO_DBGF_BP_L2_TBL_CHUNK_ALLOC:
    2414 #endif
    24152410            {
    24162411                PGVMCPU        pGVCpu        = &pGVM->aCpus[idCpu];

  • trunk/src/VBox/VMM/VMMR3/DBGF.cpp

    r86755 r87594  
    149149                if (RT_SUCCESS(rc))
    150150                {
    151 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    152                     rc = dbgfR3BpInit(pVM);
    153 #else
    154151                    rc = dbgfR3BpInit(pUVM);
    155 #endif
    156152                    if (RT_SUCCESS(rc))
    157153                    {
    … …  
    178174                            dbgfR3OSTermPart2(pUVM);
    179175                        }
    180 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    181176                        dbgfR3BpTerm(pUVM);
    182 #endif
    183177                    }
    184178                    dbgfR3AsTerm(pUVM);
    … …  
    210204    dbgfR3PlugInTerm(pUVM);
    211205    dbgfR3OSTermPart2(pUVM);
    212 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    213206    dbgfR3BpTerm(pUVM);
    214 #endif
    215207    dbgfR3AsTerm(pUVM);
    216208    dbgfR3RegTerm(pUVM);
    … …  
    785777     */
    786778    DBGFEVENT DbgEvent;
    787 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    788     RTUINT iBp = DbgEvent.u.Bp.hBp = pVCpu->dbgf.s.iActiveBp;
    789     pVCpu->dbgf.s.iActiveBp = ~0U;
    790     if (iBp != ~0U)
    791     {
    792         DbgEvent.enmCtx = DBGFEVENTCTX_RAW;
    793         return dbgfR3SendEventWaitEx(pVM, pVCpu, enmEvent, DBGFEVENTCTX_RAW, &DbgEvent.u, sizeof(DbgEvent.u.Bp));
    794     }
    795 #else
    796779    DbgEvent.u.Bp.hBp = pVCpu->dbgf.s.hBpActive;
    797780    pVCpu->dbgf.s.hBpActive = NIL_DBGFBP;
    … …  
    801784        return dbgfR3SendEventWaitEx(pVM, pVCpu, enmEvent, DBGFEVENTCTX_RAW, &DbgEvent.u, sizeof(DbgEvent.u.Bp));
    802785    }
    803 #endif
    804 
    805 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    806     AssertFailed(); /** @todo this should be obsolete now...   */
    807 
    808     /* REM breakpoints has be been searched for. */
    809 #if 0   /** @todo get flat PC api! */
    810     uint32_t eip = CPUMGetGuestEIP(pVM);
    811 #else
    812     PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
    813     RTGCPTR  eip = pCtx->rip + pCtx->cs.u64Base;
    814 #endif
    815     for (size_t i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); i++)
    816         if (    pVM->dbgf.s.aBreakpoints[i].enmType == DBGFBPTYPE_REM
    817             &&  pVM->dbgf.s.aBreakpoints[i].u.Rem.GCPtr == eip)
    818         {
    819             DbgEvent.u.Bp.hBp = pVM->dbgf.s.aBreakpoints[i].iBp;
    820             break;
    821         }
    822     AssertMsg(DbgEvent.u.Bp.hBp != ~0U, ("eip=%08x\n", eip));
    823     return dbgfR3SendEventWaitEx(pVM, pVCpu, enmEvent, DBGFEVENTCTX_REM, &DbgEvent.u, sizeof(DbgEvent.u.Bp));
    824 #else
     786
    825787    return VERR_DBGF_IPE_1;
    826 #endif
    827788}
    828789

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

    r87130 r87594  
    839839
    840840            case VINF_EM_DBG_BREAKPOINT:
    841 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    842841                rc = DBGFR3BpHit(pVM, pVCpu);
    843 #else
    844                 rc = DBGFR3EventBreakpoint(pVM, DBGFEVENT_BREAKPOINT);
    845 #endif
    846842                break;
    847843

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

    r87130 r87594  
    5555
    5656
    57 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    5857/** @name Global breakpoint table handling defines.
    5958 * @{ */
    … …  
    8180#define DBGF_BP_L2_TBL_CHUNK_COUNT          (DBGF_BP_L2_TBL_ENTRY_COUNT_MAX / DBGF_BP_L2_TBL_ENTRIES_PER_CHUNK)
    8281/** @} */
    83 #endif
    8482
    8583
    … …  
    775773
    776774
    777 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    778 /**
    779  * Breakpoint search optimization.
    780  */
    781 typedef struct DBGFBPSEARCHOPT
    782 {
    783     /** Where to start searching for hits.
    784      * (First enabled is #DBGF::aBreakpoints[iStartSearch]). */
    785     uint32_t volatile       iStartSearch;
    786     /** The number of aBreakpoints entries to search.
    787      * (Last enabled is #DBGF::aBreakpoints[iStartSearch + cToSearch - 1])  */
    788     uint32_t volatile       cToSearch;
    789 } DBGFBPSEARCHOPT;
    790 /** Pointer to a breakpoint search optimziation structure. */
    791 typedef DBGFBPSEARCHOPT *PDBGFBPSEARCHOPT;
    792 #else
    793 
    794775/** An invalid breakpoint chunk ID. */
    795776#define DBGF_BP_CHUNK_ID_INVALID                    UINT32_MAX
    … …  
    10871068/** Pointer to a breakpoint L2 lookup table chunk - Ring-0 Ptr. */
    10881069typedef R0PTRTYPE(DBGFBPL2TBLCHUNKR0 *) PDBGFBPL2TBLCHUNKR0;
    1089 #endif
    10901070
    10911071
    … …  
    11171097    /** The number of enabled hardware I/O breakpoints. */
    11181098    uint8_t                     cEnabledHwIoBreakpoints;
    1119 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
     1099    uint8_t                     au8Alignment1[2]; /**< Alignment padding. */
    11201100    /** The number of enabled INT3 breakpoints. */
    1121     uint8_t                     cEnabledInt3Breakpoints;
    1122     uint8_t                     abPadding; /**< Unused padding space up for grabs. */
    1123     uint32_t                    uPadding;
    1124 #else
    1125     uint16_t                    u16Pad; /**< Unused padding space up for grabs. */
    1126     /** The number of enabled INT3 breakpoints. */
    1127     volatile uint32_t           cEnabledInt3Breakpoints;
    1128 #endif
     1101    uint32_t volatile           cEnabledInt3Breakpoints;
    11291102
    11301103    /** Debugger Attached flag.
    … …  
    11611134    } SteppingFilter;
    11621135
    1163     uint32_t                    u32Padding[2]; /**< Alignment padding. */
    1164 
    1165 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    1166     /** Array of hardware breakpoints. (0..3)
    1167      * This is shared among all the CPUs because life is much simpler that way. */
    1168     DBGFBP                      aHwBreakpoints[4];
    1169     /** Array of int 3 and REM breakpoints. (4..)
    1170      * @remark This is currently a fixed size array for reasons of simplicity. */
    1171     DBGFBP                      aBreakpoints[32];
    1172 
    1173     /** MMIO breakpoint search optimizations. */
    1174     DBGFBPSEARCHOPT             Mmio;
    1175     /** I/O port breakpoint search optimizations. */
    1176     DBGFBPSEARCHOPT             PortIo;
    1177     /** INT3 breakpoint search optimizations. */
    1178     DBGFBPSEARCHOPT             Int3;
    1179 #else
     1136    uint32_t                    au32Alignment2[2]; /**< Alignment padding. */
     1137
    11801138    /** @name Breakpoint handling related state.
    11811139     * @{ */
    11821140    /** Array of hardware breakpoints (0..3).
    11831141     * This is shared among all the CPUs because life is much simpler that way. */
    1184     DBGFBPHW                        aHwBreakpoints[4];
     1142    DBGFBPHW                    aHwBreakpoints[4];
    11851143    /** @} */
    1186 #endif
    11871144
    11881145    /**
    … …  
    12491206    uint32_t                offVM;
    12501207
    1251 #ifndef VBOX_WITH_LOTS_OF_DBGF_BPS
    1252     /** Current active breakpoint (id).
    1253      * This is ~0U if not active. It is set when a execution engine
    1254      * encounters a breakpoint and returns VINF_EM_DBG_BREAKPOINT. This is
    1255      * currently not used for REM breakpoints because of the lazy coupling
    1256      * between VBox and REM.
    1257      *
    1258      * @todo drop this in favor of aEvents!  */
    1259     uint32_t                iActiveBp;
    1260 #else
     1208    /** Flag whether the to invoke any owner handlers in ring-3 before dropping into the debugger. */
     1209    bool                    fBpInvokeOwnerCallback;
     1210    /** Set if we're singlestepping in raw mode.
     1211     * This is checked and cleared in the \#DB handler. */
     1212    bool                    fSingleSteppingRaw;
     1213    /** Alignment padding. */
     1214    bool                    afPadding[2];
    12611215    /** Current active breakpoint handle.
    12621216     * This is NIL_DBGFBP if not active. It is set when a execution engine
    … …  
    12651219     * @todo drop this in favor of aEvents!  */
    12661220    DBGFBP                  hBpActive;
    1267     /** Flag whether the to invoke any owner handlers in ring-3 before dropping into the debugger. */
    1268     bool                    fBpInvokeOwnerCallback;
    1269 #endif
    1270     /** Set if we're singlestepping in raw mode.
    1271      * This is checked and cleared in the \#DB handler. */
    1272     bool                    fSingleSteppingRaw;
    1273 
    1274     /** Alignment padding. */
    1275     bool                    afPadding[3];
    12761221
    12771222    /** The number of events on the stack (aEvents).
    … …  
    13261271    R0PTRTYPE(struct DBGFTRACERINSR0 *) pTracerR0;
    13271272
    1328 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    13291273    /** @name Breakpoint handling related state, Ring-0 only part.
    13301274     * @{ */
    … …  
    13491293    bool                                fInit;
    13501294    /** @} */
    1351 #endif
    13521295} DBGFR0PERVM;
    13531296
    … …  
    14241367    /** @} */
    14251368
    1426 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    14271369    /** @name Breakpoint handling related state.
    14281370     * @{ */
    … …  
    14421384    RTSEMFASTMUTEX                  hMtxBpL2Wr;
    14431385    /** @} */
    1444 #endif
    14451386
    14461387    /** The type database lock. */
    … …  
    14901431void dbgfR3AsTerm(PUVM pUVM);
    14911432void dbgfR3AsRelocate(PUVM pUVM, RTGCUINTPTR offDelta);
    1492 #ifdef VBOX_WITH_LOTS_OF_DBGF_BPS
    14931433DECLHIDDEN(int) dbgfR3BpInit(PUVM pUVM);
    14941434DECLHIDDEN(int) dbgfR3BpTerm(PUVM pUVM);
    1495 #else
    1496 int  dbgfR3BpInit(PVM pVM);
    1497 #endif
    14981435int  dbgfR3InfoInit(PUVM pUVM);
    14991436int  dbgfR3InfoTerm(PUVM pUVM);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette