VirtualBox

Changeset 74785 in vbox


Ignore:
Timestamp:
Oct 12, 2018 10:14:19 AM (6 years ago)
Author:
vboxsync
Message:

vm.h,VMM: Use VMCPU_FF_IS_SET instead of VMCPU_FF_IS_PENDING when checking a single flag. Added compile time assertion on single flag. bugref:9180

Location:
trunk
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/vm.h

    r74783 r74785  
    673673#define VM_FF_IS_SET(pVM, fFlag)            (((pVM)->fGlobalForcedActions & (fFlag)) == (fFlag))
    674674
     675
    675676/** @def VMCPU_FF_IS_SET
    676677 * Checks if a force action flag is set for the given VCPU.
    … …  
    679680 * @param   fFlag   The flag to check.
    680681 */
    681 #define VMCPU_FF_IS_SET(pVCpu, fFlag)       (((pVCpu)->fLocalForcedActions & (fFlag)) == (fFlag))
     682#if !defined(VBOX_STRICT) || !defined(RT_COMPILER_SUPPORTS_LAMBDA)
     683# define VMCPU_FF_IS_SET(pVCpu, fFlag)      (((pVCpu)->fLocalForcedActions & (fFlag)) == (fFlag))
     684#else
     685# define VMCPU_FF_IS_SET(pVCpu, fFlag) \
     686                   ([](PVMCPU a_pVCpu) -> bool \
     687                   { \
     688                       AssertCompile(RT_IS_POWER_OF_TWO(fFlag)); \
     689                       return (a_pVCpu->fLocalForcedActions & (fFlag)) == (fFlag); \
     690                   }(pVCpu))
     691#endif
    682692
    683693/** @def VM_FF_IS_PENDING
    … …  
    688698 */
    689699#define VM_FF_IS_PENDING(pVM, fFlags)       RT_BOOL((pVM)->fGlobalForcedActions & (fFlags))
     700
     701/** @def VMCPU_FF_IS_PENDING
     702 * Checks if one or more force action in the specified set is pending for the given VCPU.
     703 *
     704 * @param   pVCpu   The cross context virtual CPU structure.
     705 * @param   fFlags  The flags to check for.
     706 */
     707#define VMCPU_FF_IS_PENDING(pVCpu, fFlags)  RT_BOOL((pVCpu)->fLocalForcedActions & (fFlags))
    690708
    691709/** @def VM_FF_TEST_AND_CLEAR
    … …  
    709727#define VMCPU_FF_TEST_AND_CLEAR(pVCpu, iBit) (ASMAtomicBitTestAndClear(&(pVCpu)->fLocalForcedActions, iBit##_BIT))
    710728
    711 /** @def VMCPU_FF_IS_PENDING
    712  * Checks if one or more force action in the specified set is pending for the given VCPU.
    713  *
    714  * @param   pVCpu   The cross context virtual CPU structure.
    715  * @param   fFlags  The flags to check for.
    716  */
    717 #define VMCPU_FF_IS_PENDING(pVCpu, fFlags)  RT_BOOL((pVCpu)->fLocalForcedActions & (fFlags))
    718 
    719729/** @def VM_FF_IS_PENDING_EXCEPT
    720730 * Checks if one or more force action in the specified set is pending while one
    … …  
    725735 * @param   fExcpt  The flags that should not be set.
    726736 */
    727 #define VM_FF_IS_PENDING_EXCEPT(pVM, fFlags, fExcpt)      ( ((pVM)->fGlobalForcedActions & (fFlags)) && !((pVM)->fGlobalForcedActions & (fExcpt)) )
     737#define VM_FF_IS_PENDING_EXCEPT(pVM, fFlags, fExcpt) ( ((pVM)->fGlobalForcedActions & (fFlags)) && !((pVM)->fGlobalForcedActions & (fExcpt)) )
    728738
    729739/** @def VM_IS_EMT

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

    r73285 r74785  
    33413341
    33423342    if (   fHasPendingIntrs
    3343         && !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC))
     3343        && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_APIC))
    33443344        apicSignalNextPendingIntr(pVCpu);
    33453345}

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp.h

    r74709 r74785  
    71897189        {
    71907190            if (   IEM_VMX_IS_PROCCTLS_SET(pVCpu, VMX_PROC_CTLS_INT_WINDOW_EXIT)
    7191                 || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))
     7191                || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))
    71927192            {
    71937193                iemRegAddToRipAndClearRF(pVCpu, cbInstr);

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImplSvmInstr.cpp.h

    r74603 r74785  
    202202             */
    203203            PSVMVMCBCTRL pVmcbMemCtrl = &pVmcbMem->ctrl;
    204             if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))       /* V_IRQ. */
     204            if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))           /* V_IRQ. */
    205205                pVmcbMemCtrl->IntCtrl.n.u1VIrqPending = 0;
    206206            else
    … …  
    212212            pVmcbMemCtrl->IntCtrl.n.u8VTPR = pVmcbCtrl->IntCtrl.n.u8VTPR;           /* V_TPR. */
    213213
    214             if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)          /* Interrupt shadow. */
     214            if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)              /* Interrupt shadow. */
    215215                && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip)
    216216            {
    … …  
    733733            VMCPU_FF_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
    734734        else
    735             Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST));
     735            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST));
    736736
    737737        /*

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImplVmxInstr.cpp.h

    r74784 r74785  
    19251925
    19261926    /* MTF should not be set outside VMX non-root mode. */
    1927     Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_MTF));
     1927    Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_MTF));
    19281928
    19291929    /*
    … …  
    21312131    if (pVmcs->u32PinCtls & VMX_PIN_CTLS_VIRT_NMI)
    21322132    { /** @todo NSTVMX: Virtual-NMI blocking. */ }
    2133     else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     2133    else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    21342134        pVmcs->u32GuestIntrState |= VMX_VMCS_GUEST_INT_STATE_BLOCK_NMI;
    21352135
    2136     if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     2136    if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    21372137        && pVCpu->cpum.GstCtx.rip == EMGetInhibitInterruptsPC(pVCpu))
    21382138    {
    … …  
    57825782        }
    57835783        else
    5784             Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS));
     5784            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS));
    57855785
    57865786        if (pVmcs->u32GuestIntrState & (VMX_VMCS_GUEST_INT_STATE_BLOCK_STI | VMX_VMCS_GUEST_INT_STATE_BLOCK_MOVSS))
    57875787            EMSetInhibitInterruptsPC(pVCpu, pVCpu->cpum.GstCtx.rip);
    57885788        else
    5789             Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
     5789            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
    57905790
    57915791        /* SMI blocking is irrelevant. We don't support SMIs yet. */
    … …  
    59305930    /** @todo Distinguish block-by-MOV-SS from block-by-STI. Currently we
    59315931     *        use block-by-STI here which is not quite correct. */
    5932     if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     5932    if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    59335933        && pVCpu->cpum.GstCtx.rip == EMGetInhibitInterruptsPC(pVCpu))
    59345934    {

  • trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h

    r74517 r74785  
    417417    {
    418418        ADD_REG64(WHvRegisterInterruptState, 0);
    419         if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     419        if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    420420            && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip)
    421421            aValues[iReg - 1].InterruptState.InterruptShadow = 1;
    422         if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     422        if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    423423            aValues[iReg - 1].InterruptState.NmiMasked = 1;
    424424    }
    … …  
    426426    {
    427427        if (   pVCpu->nem.s.fLastInterruptShadow
    428             || (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     428            || (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    429429                && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip))
    430430        {
    431431            ADD_REG64(WHvRegisterInterruptState, 0);
    432             if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     432            if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    433433                && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip)
    434434                aValues[iReg - 1].InterruptState.InterruptShadow = 1;
    … …  
    15751575
    15761576    /* Update interrupt inhibition. */
    1577     if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     1577    if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    15781578    { /* likely */ }
    15791579    else if (pVCpu->cpum.GstCtx.rip != EMGetInhibitInterruptsPC(pVCpu))
    … …  
    16001600
    16011601    /* Update interrupt inhibition. */
    1602     if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     1602    if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    16031603    { /* likely */ }
    16041604    else if (pVCpu->cpum.GstCtx.rip != EMGetInhibitInterruptsPC(pVCpu))
    … …  
    19161916    if (!pHdr->ExecutionState.InterruptShadow)
    19171917    {
    1918         if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     1918        if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    19191919        { /* likely */ }
    19201920        else
    … …  
    19471947    if (!pExitCtx->ExecutionState.InterruptShadow)
    19481948    {
    1949         if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     1949        if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    19501950        { /* likely */ }
    19511951        else
    … …  
    39703970     * We don't currently implement SMIs.
    39713971     */
    3972     AssertReturn(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_SMI), VERR_NEM_IPE_0);
     3972    AssertReturn(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_SMI), VERR_NEM_IPE_0);
    39733973
    39743974    /*
    … …  
    39773977     * for injection via IEM.
    39783978     */
    3979     bool const fPendingNmi = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI);
     3979    bool const fPendingNmi = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI);
    39803980    uint64_t   fNeedExtrn  = CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT | CPUMCTX_EXTRN_RIP | CPUMCTX_EXTRN_RFLAGS
    39813981                           | (fPendingNmi ? CPUMCTX_EXTRN_NEM_WIN_INHIBIT_NMI : 0);
    … …  
    39873987            return rcStrict;
    39883988    }
    3989     bool const fInhibitInterrupts = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     3989    bool const fInhibitInterrupts = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    39903990                                 && EMGetInhibitInterruptsPC(pVCpu) == pVCpu->cpum.GstCtx.rip;
    39913991
    … …  
    39963996    {
    39973997        if (   !fInhibitInterrupts
    3998             && !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     3998            && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    39993999        {
    40004000            VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu,

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

    r70948 r74785  
    7878    memcpy(pvBuf, pvPtr, cbBuf);
    7979    VBOXSTRICTRC rcStrict = selmRCGuestGdtPostWriteCheck(pVM, pVCpu, offGuestGdt, cbBuf, pCtx);
    80     if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_SELM_SYNC_GDT))
     80    if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_SELM_SYNC_GDT))
    8181        STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestGDTHandled);
    8282    else

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

    r72685 r74785  
    801801        if (!VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
    802802        {
    803             Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     803            Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    804804            VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
    805805#if defined(IN_RING3) && defined(VBOX_WITH_REM)
    … …  
    847847                    &&  !VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
    848848                {
    849                     Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     849                    Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    850850                    VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
    851851#if defined(IN_RING3) && defined(VBOX_WITH_REM)
    … …  
    946946            &&  !VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
    947947        {
    948             Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     948            Log5(("TMAll(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    949949            VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
    950950#if defined(IN_RING3) && defined(VBOX_WITH_REM)

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

    r69111 r74785  
    239239            {
    240240                STAM_COUNTER_INC(&pVM->tm.s.StatVirtualGetSetFF);
    241                 Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     241                Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    242242                VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
    243243#ifdef IN_RING3
    … …  
    396396        PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
    397397        VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
    398         Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     398        Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    399399        Log4(("TM: %'RU64/-%'8RU64: exp tmr=>ff [vsghcul]\n", u64, pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp));
    400400        PDMCritSectLeave(&pVM->tm.s.VirtualSyncLock);
    … …  
    484484        PVMCPU pVCpuDst = &pVM->aCpus[pVM->tm.s.idTimerCpu];
    485485        VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);
    486         Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, !!VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     486        Log5(("TMAllVirtual(%u): FF: %d -> 1\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    487487        Log4(("TM: %'RU64/-%'8RU64: exp tmr=>ff [vsgl]\n", u64, pVM->tm.s.offVirtualSync - pVM->tm.s.offVirtualSyncGivenUp));
    488488        PDMCritSectLeave(&pVM->tm.s.VirtualSyncLock);
    … …  
    711711        if (!VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER))
    712712        {
    713             Log5(("TMAllVirtual(%u): FF: %d -> 1 (NoLock)\n", __LINE__, VMCPU_FF_IS_PENDING(pVCpuDst, VMCPU_FF_TIMER)));
     713            Log5(("TMAllVirtual(%u): FF: %d -> 1 (NoLock)\n", __LINE__, VMCPU_FF_IS_SET(pVCpuDst, VMCPU_FF_TIMER)));
    714714            VM_FF_SET(pVM, VM_FF_TM_VIRTUAL_SYNC); /* Hmm? */
    715715            VMCPU_FF_SET(pVCpuDst, VMCPU_FF_TIMER);

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

    r73606 r74785  
    11581158    Assert(pVCpu->CTX_SUFF(pVM)->hm.s.svm.fSupported);
    11591159
    1160     bool const fFlushPending = pVCpu->CTX_SUFF(pVM)->hm.s.svm.fAlwaysFlushTLB || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TLB_FLUSH);
     1160    bool const fFlushPending = pVCpu->CTX_SUFF(pVM)->hm.s.svm.fAlwaysFlushTLB || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TLB_FLUSH);
    11611161
    11621162    /* Skip it if a TLB flush is already pending. */
    … …  
    28062806        {
    28072807            if (  !pVmcbCtrl->IntCtrl.n.u1VIrqPending
    2808                 && VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))
     2808                && VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST))
    28092809                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
    28102810        }
    … …  
    28152815            if (pVmcbCtrl->IntShadow.n.u1IntShadow)
    28162816                EMSetInhibitInterruptsPC(pVCpu, pVmcbGuest->u64RIP);
    2817             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     2817            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    28182818                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
    28192819        }
    … …  
    30223022     */
    30233023    if (   VMMRZCallRing3IsEnabled(pVCpu)
    3024         && VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
     3024        && VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
    30253025    {
    30263026        Assert(pCtx->cr3 == pVmcbGuest->u64CR3);
    … …  
    36693669     *        delivery/window over a physical interrupt (from the outer guest)
    36703670     *        might be pending? */
    3671     bool const fEnableIntWindow = !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
     3671    bool const fEnableIntWindow = !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST);
    36723672    if (!fEnableIntWindow)
    36733673    {
    … …  
    37353735    bool const fVirtualGif = CPUMGetSvmNstGstVGif(pCtx);
    37363736    bool const fIntShadow  = hmR0SvmIsIntrShadowActive(pVCpu);
    3737     bool const fBlockNmi   = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS);
     3737    bool const fBlockNmi   = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
    37383738
    37393739    Log4Func(("fVirtualGif=%RTbool fBlockNmi=%RTbool fIntShadow=%RTbool fIntPending=%RTbool fNmiPending=%RTbool\n",
    37403740              fVirtualGif, fBlockNmi, fIntShadow, VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC),
    3741               VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI)));
     3741              VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI)));
    37423742
    37433743    /** @todo SMI. SMIs take priority over NMIs. */
    … …  
    37483748     * NMIs take priority over maskable interrupts, see AMD spec. 8.5 "Priorities".
    37493749     */
    3750     if (    VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI)
     3750    if (    VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI)
    37513751        && !fBlockNmi)
    37523752    {
    … …  
    38603860    bool const fIntShadow = hmR0SvmIsIntrShadowActive(pVCpu);
    38613861    bool const fBlockInt  = !(pCtx->eflags.u32 & X86_EFL_IF);
    3862     bool const fBlockNmi  = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS);
     3862    bool const fBlockNmi  = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
    38633863
    38643864    Log4Func(("fGif=%RTbool fBlockNmi=%RTbool fBlockInt=%RTbool fIntShadow=%RTbool fIntPending=%RTbool NMI pending=%RTbool\n",
    38653865              fGif, fBlockNmi, fBlockInt, fIntShadow,
    38663866              VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC),
    3867               VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI)));
     3867              VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI)));
    38683868
    38693869    /** @todo SMI. SMIs take priority over NMIs. */
    … …  
    38743874     * NMIs take priority over maskable interrupts, see AMD spec. 8.5 "Priorities".
    38753875     */
    3876     if (    VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI)
     3876    if (    VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI)
    38773877        && !fBlockNmi)
    38783878    {
    … …  
    40024002        if (    Event.n.u3Type   == SVM_EVENT_NMI
    40034003            &&  Event.n.u8Vector == X86_XCPT_NMI
    4004             && !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     4004            && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    40054005        {
    40064006            VMCPU_FF_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
    … …  
    40274027     * but we still need to intercept IRET in order to eventually clear NMI inhibition.
    40284028     */
    4029     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     4029    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    40304030        hmR0SvmSetCtrlIntercept(pVmcb, SVM_CTRL_INTERCEPT_IRET);
    40314031
    … …  
    42094209{
    42104210    Assert(VMMRZCallRing3IsEnabled(pVCpu));
    4211     Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
     4211    Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
    42124212
    42134213    /* Could happen as a result of longjump. */
    4214     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
     4214    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
    42154215        PGMUpdateCR3(pVCpu, CPUMGetGuestCR3(pVCpu));
    42164216
    … …  
    42294229        {
    42304230            int rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4,
    4231                                 VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     4231                                VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    42324232            if (rc != VINF_SUCCESS)
    42334233            {
    … …  
    42494249
    42504250        /* Pending VM request packets, such as hardware interrupts. */
    4251         if (   VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
    4252             || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     4251        if (   VM_FF_IS_SET(pVM, VM_FF_REQUEST)
     4252            || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    42534253        {
    42544254            Log4Func(("Pending VM request forcing us back to ring-3\n"));
    … …  
    60436043
    60446044    /* Update interrupt shadow. */
    6045     if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     6045    if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    60466046        && pCtx->rip != EMGetInhibitInterruptsPC(pVCpu))
    60476047        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
    … …  
    74567456
    74577457    /* Clear NMI blocking. */
    7458     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     7458    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    74597459        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
    74607460

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

    r74604 r74785  
    18481848    LogFlowFunc(("pVCpu=%p GCVirt=%RGv\n", pVCpu, GCVirt));
    18491849
    1850     bool fFlushPending = VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TLB_FLUSH);
     1850    bool fFlushPending = VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TLB_FLUSH);
    18511851    if (!fFlushPending)
    18521852    {
    … …  
    34523452     */
    34533453    uint32_t fIntrState = 0;
    3454     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     3454    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    34553455    {
    34563456        /* If inhibition is active, RIP & RFLAGS should've been accessed
    … …  
    34683468                fIntrState = VMX_VMCS_GUEST_INT_STATE_BLOCK_MOVSS;
    34693469        }
    3470         else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     3470        else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    34713471        {
    34723472            /*
    … …  
    34863486     * See Intel spec. 26.6.1 "Interruptibility state". See @bugref{7445}.
    34873487     */
    3488     if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS)
     3488    if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS)
    34893489        && (pVCpu->hm.s.vmx.u32PinCtls & VMX_PIN_CTLS_VIRT_NMI))
    34903490    {
    … …  
    62106210         * See Intel spec. 30.7.1.2 "Resuming Guest Software after Handling an Exception". See @bugref{7445}.
    62116211         */
    6212         if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS)
     6212        if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS)
    62136213            && uIdtVectorType == VMX_IDT_VECTORING_INFO_TYPE_NMI
    62146214            && (   enmRaise   == IEMXCPTRAISE_PREV_EVENT
    … …  
    63126312         * See Intel spec. 30.7.1.2 "Resuming guest software after handling an exception".
    63136313         */
    6314         if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     6314        if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    63156315        {
    63166316            Log4Func(("Setting VMCPU_FF_BLOCK_NMIS. fValid=%RTbool uExitReason=%u\n",
    … …  
    64966496        if (!u32Val)
    64976497        {
    6498             if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     6498            if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    64996499            {
    65006500                rc =  hmR0VmxImportGuestRip(pVCpu);
    … …  
    65036503            }
    65046504
    6505             if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     6505            if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    65066506                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
    65076507        }
    … …  
    65166516                EMSetInhibitInterruptsPC(pVCpu, pCtx->rip);
    65176517            }
    6518             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     6518            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    65196519                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
    65206520
    65216521            if (u32Val & VMX_VMCS_GUEST_INT_STATE_BLOCK_NMI)
    65226522            {
    6523                 if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     6523                if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    65246524                    VMCPU_FF_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
    65256525            }
    6526             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     6526            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    65276527                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
    65286528        }
    … …  
    68416841    if (VMMRZCallRing3IsEnabled(pVCpu))
    68426842    {
    6843         if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
     6843        if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
    68446844        {
    68456845            Assert(!(ASMAtomicUoReadU64(&pCtx->fExtrn) & CPUMCTX_EXTRN_CR3));
    … …  
    68476847        }
    68486848
    6849         if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
     6849        if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
    68506850            PGMGstUpdatePaePdpes(pVCpu, &pVCpu->hm.s.aPdpes[0]);
    68516851
    6852         Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
    6853         Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
     6852        Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
     6853        Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
    68546854    }
    68556855
    … …  
    69126912        Assert(!(ASMAtomicUoReadU64(&pCtx->fExtrn) & (CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4)));
    69136913        VBOXSTRICTRC rcStrict2 = PGMSyncCR3(pVCpu, pCtx->cr0, pCtx->cr3, pCtx->cr4,
    6914                                             VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
     6914                                            VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
    69156915        if (rcStrict2 != VINF_SUCCESS)
    69166916        {
    … …  
    69336933    /* Pending VM request packets, such as hardware interrupts. */
    69346934    if (   VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
    6935         || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     6935        || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    69366936    {
    69376937        Log4Func(("Pending VM request forcing us back to ring-3\n"));
    … …  
    75197519     */
    75207520                                                               /** @todo SMI. SMIs take priority over NMIs. */
    7521     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NMI))    /* NMI. NMIs take priority over regular interrupts. */
     7521    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NMI))        /* NMI. NMIs take priority over regular interrupts. */
    75227522    {
    75237523        /* On some CPUs block-by-STI also blocks NMIs. See Intel spec. 26.3.1.5 "Checks On Guest Non-Register State". */
    … …  
    85278527     * the below force flags to be set.
    85288528     */
    8529     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
     8529    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
    85308530    {
    85318531        Assert(!(ASMAtomicUoReadU64(&pVCpu->cpum.GstCtx.fExtrn) & CPUMCTX_EXTRN_CR3));
    … …  
    85338533        AssertMsgReturn(rc2 == VINF_SUCCESS || rc2 == VINF_PGM_SYNC_CR3,
    85348534                        ("%Rrc\n", rc2), RT_FAILURE_NP(rc2) ? rc2 : VERR_IPE_UNEXPECTED_INFO_STATUS);
    8535         Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
    8536     }
    8537     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
     8535        Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
     8536    }
     8537    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
    85388538    {
    85398539        PGMGstUpdatePaePdpes(pVCpu, &pVCpu->hm.s.aPdpes[0]);
    8540         Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
     8540        Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
    85418541    }
    85428542
    … …  
    88498849            VMMRZCallRing3Enable(pVCpu);
    88508850
    8851             Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
    8852             Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
     8851            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
     8852            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
    88538853
    88548854#if defined(HMVMX_ALWAYS_SYNC_FULL_GUEST_STATE) || defined(HMVMX_ALWAYS_SAVE_FULL_GUEST_STATE)
    … …  
    1046510465
    1046610466    /* Update interrupt inhibition. */
    10467     if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     10467    if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    1046810468        && pVCpu->cpum.GstCtx.rip != EMGetInhibitInterruptsPC(pVCpu))
    1046910469        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
    … …  
    1129011290    }
    1129111291
    11292     Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS));
     11292    Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS));
    1129311293
    1129411294    /*
    … …  
    1130211302    bool const fBlockSti = RT_BOOL(fIntrState & VMX_VMCS_GUEST_INT_STATE_BLOCK_STI);
    1130311303    if (   fBlockSti
    11304         && VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
     11304        && VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS))
    1130511305    {
    1130611306        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);

  • trunk/src/VBox/VMM/VMMR0/NEMR0Native-win.cpp

    r74517 r74785  
    12191219        pInput->Elements[iReg].Name                 = HvRegisterInterruptState;
    12201220        pInput->Elements[iReg].Value.Reg64          = 0;
    1221         if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     1221        if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    12221222            && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
    12231223            pInput->Elements[iReg].Value.InterruptState.InterruptShadow = 1;
    1224         if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_BLOCK_NMIS))
     1224        if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
    12251225            pInput->Elements[iReg].Value.InterruptState.NmiMasked = 1;
    12261226        iReg++;
    … …  
    12291229    {
    12301230        if (   pVCpu->nem.s.fLastInterruptShadow
    1231             || (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     1231            || (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    12321232                && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip))
    12331233        {
    … …  
    12351235            pInput->Elements[iReg].Name                 = HvRegisterInterruptState;
    12361236            pInput->Elements[iReg].Value.Reg64          = 0;
    1237             if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     1237            if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    12381238                && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
    12391239                pInput->Elements[iReg].Value.InterruptState.InterruptShadow = 1;

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

    r73203 r74785  
    904904        case VINF_EM_RAW_TO_R3:
    905905            STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Total);
    906             if (VM_FF_IS_PENDING(pVM, VM_FF_TM_VIRTUAL_SYNC))
     906            if (VM_FF_IS_SET(pVM, VM_FF_TM_VIRTUAL_SYNC))
    907907                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3TMVirt);
    908             else if (VM_FF_IS_PENDING(pVM, VM_FF_PGM_NEED_HANDY_PAGES))
     908            else if (VM_FF_IS_SET(pVM, VM_FF_PGM_NEED_HANDY_PAGES))
    909909                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3HandyPages);
    910             else if (VM_FF_IS_PENDING(pVM, VM_FF_PDM_QUEUES))
     910            else if (VM_FF_IS_SET(pVM, VM_FF_PDM_QUEUES))
    911911                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3PDMQueues);
    912             else if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
     912            else if (VM_FF_IS_SET(pVM, VM_FF_EMT_RENDEZVOUS))
    913913                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Rendezvous);
    914             else if (VM_FF_IS_PENDING(pVM, VM_FF_PDM_DMA))
     914            else if (VM_FF_IS_SET(pVM, VM_FF_PDM_DMA))
    915915                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3DMA);
    916             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER))
     916            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TIMER))
    917917                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Timer);
    918             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
     918            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PDM_CRITSECT))
    919919                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3CritSect);
    920             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TO_R3))
     920            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TO_R3))
    921921                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3FF);
    922             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_IEM))
     922            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IEM))
    923923                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Iem);
    924             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_IOM))
     924            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IOM))
    925925                STAM_COUNTER_INC(&pVM->vmm.s.StatRZRetToR3Iom);
    926926            else

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

    r73414 r74785  
    299299                       unfortunately required by plugin unloading. */
    300300                    if (   VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
    301                         || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     301                        || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    302302                    {
    303303                        LogFlow(("DBGFR3PowerOff: Processes priority requests...\n"));
    … …  
    392392        /* Process priority stuff. */
    393393        if (   VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
    394             || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     394            || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    395395        {
    396396            int rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, true /*fPriorityOnly*/);
    … …  
    835835            int rc;
    836836            if (    !VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS | VM_FF_REQUEST)
    837                 &&  !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     837                &&  !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    838838            {
    839839                rc = RTSemPingWait(&pVM->dbgf.s.PingPong, cPollHack);
    … …  
    853853            }
    854854            else if (   VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
    855                      || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     855                     || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    856856            {
    857857                LogFlow(("dbgfR3VMMWait: Processes requests...\n"));

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

    r73617 r74785  
    16501650    VBOXVMM_EM_FF_HIGH(pVCpu, pVM->fGlobalForcedActions, pVCpu->fLocalForcedActions, VBOXSTRICTRC_VAL(rc));
    16511651
    1652     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
     1652    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PDM_CRITSECT))
    16531653        PDMCritSectBothFF(pVCpu);
    16541654
    16551655    /* Update CR3 (Nested Paging case for HM). */
    1656     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
     1656    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3))
    16571657    {
    16581658        CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER, rc);
    … …  
    16601660        if (RT_FAILURE(rc2))
    16611661            return rc2;
    1662         Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
     1662        Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_CR3));
    16631663    }
    16641664
    16651665    /* Update PAE PDPEs. This must be done *after* PGMUpdateCR3() and used only by the Nested Paging case for HM. */
    1666     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
     1666    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES))
    16671667    {
    16681668        CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4 | CPUMCTX_EXTRN_EFER, rc);
    … …  
    16731673
    16741674            PGMGstUpdatePaePdpes(pVCpu, pPdpes);
    1675             Assert(!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
     1675            Assert(!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_HM_UPDATE_PAE_PDPES));
    16761676        }
    16771677        else
    … …  
    16801680
    16811681    /* IEM has pending work (typically memory write after INS instruction). */
    1682     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_IEM))
     1682    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IEM))
    16831683        rc = IEMR3ProcessForceFlag(pVM, pVCpu, rc);
    16841684
    16851685    /* IOM has pending work (comitting an I/O or MMIO write). */
    1686     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_IOM))
     1686    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_IOM))
    16871687    {
    16881688        rc = IOMR3ProcessForceFlag(pVM, pVCpu, rc);
    … …  
    16961696
    16971697#ifdef VBOX_WITH_RAW_MODE
    1698     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_CSAM_PENDING_ACTION))
     1698    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_CSAM_PENDING_ACTION))
    16991699        CSAMR3DoPendingAction(pVM, pVCpu);
    17001700#endif
    … …  
    17791779            }
    17801780
    1781             if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST)
     1781            if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INTERRUPT_NESTED_GUEST)
    17821782                && CPUMCanSvmNstGstTakeVirtIntr(pVCpu, &pVCpu->cpum.GstCtx))
    17831783            {
    … …  
    19161916         * Debugger Facility polling.
    19171917         */
    1918         if (   VM_FF_IS_PENDING(pVM, VM_FF_DBGF)
    1919             || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_DBGF) )
     1918        if (   VM_FF_IS_SET(pVM, VM_FF_DBGF)
     1919            || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_DBGF) )
    19201920        {
    19211921            CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
    … …  
    19381938         * CSAM page scanning.
    19391939         */
    1940         if (    !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY)
    1941             &&  VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_CSAM_SCAN_PAGE))
     1940        if (    !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY)
     1941            &&  VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_CSAM_SCAN_PAGE))
    19421942        {
    19431943            /** @todo check for 16 or 32 bits code! (D bit in the code selector) */
    … …  
    20562056     * (Executed in no particular order.)
    20572057     */
    2058     if (    !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY)
     2058    if (    !VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY)
    20592059        &&  VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_NORMAL_PRIORITY_MASK))
    20602060    {
    … …  
    20622062         * Requests from other threads.
    20632063         */
    2064         if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     2064        if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    20652065        {
    20662066            CPUM_IMPORT_EXTRN_RCSTRICT(pVCpu, ~CPUMCTX_EXTRN_KEEPER_MASK, rc);
    … …  
    21002100         * Timers before interrupts.
    21012101         */
    2102         if (    VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER)
     2102        if (    VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TIMER)
    21032103            &&  !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
    21042104            TMR3TimerQueuesDo(pVM);
    … …  
    21222122         *       you might think.
    21232123         */
    2124         if (    VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     2124        if (    VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    21252125            &&  !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY))
    21262126        {
    … …  
    21422142            &&  (!rc || rc >= VINF_EM_RESCHEDULE_HM))
    21432143        {
    2144             if (   !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
     2144            if (   !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    21452145                && !TRPMHasTrap(pVCpu)) /* an interrupt could already be scheduled for dispatching in the recompiler. */
    21462146            {
    … …  
    22102210         */
    22112211        if (   (   VM_FF_IS_PENDING(pVM, VM_FF_DBGF)
    2212                 || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_DBGF) )
     2212                || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_DBGF) )
    22132213            && !VM_FF_IS_PENDING(pVM, VM_FF_PGM_NO_MEMORY) )
    22142214        {
    … …  
    27222722                if (   enmOldState == EMSTATE_HALTED
    27232723                    && (   (pVCpu->em.s.MWait.fWait & EMMWAIT_FLAG_ACTIVE)
    2724                         || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_UNHALT))
     2724                        || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_UNHALT))
    27252725                    && (   enmNewState == EMSTATE_RAW
    27262726                        || enmNewState == EMSTATE_HM
    … …  
    27392739                        pVCpu->em.s.MWait.fWait &= ~(EMMWAIT_FLAG_ACTIVE | EMMWAIT_FLAG_BREAKIRQIF0);
    27402740                    }
    2741                     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_UNHALT))
     2741                    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_UNHALT))
    27422742                    {
    27432743                        LogFlow(("EMR3ExecuteVM: Clearing UNHALT\n"));

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

    r72634 r74785  
    11801180     * PGMSyncCR3+pgmR3PoolClearAll is pending.
    11811181     */
    1182     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TRPM_SYNC_IDT))
    1183     {
    1184         if (   VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PGM_SYNC_CR3)
     1182    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TRPM_SYNC_IDT))
     1183    {
     1184        if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3)
    11851185            && EMIsRawRing0Enabled(pVM)
    11861186            && CSAMIsEnabled(pVM))
    … …  
    11991199     * Sync TSS.
    12001200     */
    1201     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_SELM_SYNC_TSS))
     1201    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_SELM_SYNC_TSS))
    12021202    {
    12031203        int rc = SELMR3SyncTSS(pVM, pVCpu);

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

    r73481 r74785  
    28452845     * when entering other critsects here.
    28462846     */
    2847     if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_PDM_CRITSECT))
     2847    if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PDM_CRITSECT))
    28482848        PDMCritSectBothFF(pVCpu);
    28492849

  • trunk/src/VBox/VMM/VMMRC/SELMRC.cpp

    r74584 r74785  
    331331    }
    332332
    333     if (!VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_SELM_SYNC_GDT))
     333    if (!VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_SELM_SYNC_GDT))
    334334        STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestGDTHandled);
    335335    else
    … …  
    474474
    475475        if (   rcStrict == VINF_SUCCESS
    476             && !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_SELM_SYNC_TSS)
     476            && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_SELM_SYNC_TSS)
    477477            && pVM->selm.s.offGuestIoBitmap != 0)
    478478        {

  • trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp

    r72655 r74785  
    184184            TMTimerPollVoid(pVM, pVCpu);
    185185            Log2(("TMTimerPoll at %08RX32 - VM_FF_TM_VIRTUAL_SYNC=%d VM_FF_TM_VIRTUAL_SYNC=%d\n", pRegFrame->eip,
    186                   VM_FF_IS_PENDING(pVM, VM_FF_TM_VIRTUAL_SYNC), VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER)));
     186                  VM_FF_IS_PENDING(pVM, VM_FF_TM_VIRTUAL_SYNC), VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TIMER)));
    187187        }
    188188    }
    … …  
    241241            }
    242242            /* Pending timer action. */
    243             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TIMER))
     243            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TIMER))
    244244                rc = VINF_EM_RAW_TIMER_PENDING;
    245245            /* The Virtual Sync clock has stopped. */
    … …  
    251251            /* Pending request packets might contain actions that need immediate
    252252               attention, such as pending hardware interrupts. */
    253             else if (   VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
    254                      || VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
     253            else if (   VM_FF_IS_SET(pVM, VM_FF_REQUEST)
     254                     || VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_REQUEST))
    255255                rc = VINF_EM_PENDING_REQUEST;
    256256            /* Pending GDT/LDT/TSS sync. */
    257257            else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_SELM_SYNC_GDT | VMCPU_FF_SELM_SYNC_LDT | VMCPU_FF_SELM_SYNC_TSS))
    258258                rc = VINF_SELM_SYNC_GDT;
    259             else if (VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_TRPM_SYNC_IDT))
     259            else if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TRPM_SYNC_IDT))
    260260                rc = VINF_EM_RAW_TO_R3;
    261261            /* Possibly pending interrupt: dispatch it. */
Note: See TracChangeset for help on using the changeset viewer.

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