VirtualBox

Changeset 42373 in vbox


Ignore:
Timestamp:
Jul 25, 2012 7:18:33 AM (12 years ago)
Author:
vboxsync
Message:

VMM: invpg -> invlpg, some cleanup.

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r42024 r42373  
    475475/** 13 Guest software attempted to execute INVD. */
    476476#define VMX_EXIT_INVD               13
    477 /** 14 Guest software attempted to execute INVPG. */
    478 #define VMX_EXIT_INVPG              14
     477/** 14 Guest software attempted to execute INVLPG. */
     478#define VMX_EXIT_INVLPG             14
    479479/** 15 Guest software attempted to execute RDPMC. */
    480480#define VMX_EXIT_RDPMC              15

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

    r42317 r42373  
    201201
    202202/**
    203  * Locks REM execution to a single VCpu
     203 * Locks REM execution to a single VCPU.
    204204 *
    205205 * @param   pVM         Pointer to the VM.
    … …  
    666666
    667667/**
    668  * Interpret CPUID given the parameters in the CPU context
     668 * Interpret CPUID given the parameters in the CPU context.
    669669 *
    670670 * @returns VBox status code.
    … …  
    694694
    695695/**
    696  * Interpret RDTSC
     696 * Interpret RDTSC.
    697697 *
    698698 * @returns VBox status code.
    … …  
    721721
    722722/**
    723  * Interpret RDTSCP
     723 * Interpret RDTSCP.
    724724 *
    725725 * @returns VBox status code.
    … …  
    756756
    757757/**
    758  * Interpret RDPMC
     758 * Interpret RDPMC.
    759759 *
    760760 * @returns VBox status code.
    … …  
    856856
    857857
    858 
    859 /* VT-x only: */
    860 
    861 /**
    862  * Interpret INVLPG
     858/**
     859 * Interpret INVLPG.
    863860 *
    864861 * @returns VBox status code.
    … …  
    866863 * @param   pVCpu       Pointer to the VMCPU.
    867864 * @param   pRegFrame   The register frame.
    868  * @param   pAddrGC     Operand address
     865 * @param   pAddrGC     Operand address.
    869866 *
    870867 */
    … …  
    890887
    891888
    892 /**
    893  * Update CRx
     889/* VT-x only: */
     890
     891/**
     892 * Update CRx.
    894893 *
    895894 * @returns VBox status code.
    … …  
    10321031
    10331032/**
    1034  * Interpret CRx write
     1033 * Interpret CRx write.
    10351034 *
    10361035 * @returns VBox status code.
    … …  
    10641063
    10651064/**
    1066  * Interpret LMSW
     1065 * Interpret LMSW.
    10671066 *
    10681067 * @returns VBox status code.
    … …  
    10861085
    10871086
    1088 
    1089 /**
    1090  * Interpret CLTS
     1087/**
     1088 * Interpret CLTS.
    10911089 *
    10921090 * @returns VBox status code.
    … …  
    11071105
    11081106/**
    1109  * Interpret CRx read
     1107 * Interpret CRx read.
    11101108 *
    11111109 * @returns VBox status code.
    … …  
    11401138
    11411139/**
    1142  * Interpret DRx write
     1140 * Interpret DRx write.
    11431141 *
    11441142 * @returns VBox status code.
    … …  
    11791177
    11801178/**
    1181  * Interpret DRx read
     1179 * Interpret DRx read.
    11821180 *
    11831181 * @returns VBox status code.

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

    r42345 r42373  
    5454*   Internal Functions                                                         *
    5555*******************************************************************************/
    56 static int  hmR0SvmInterpretInvpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t uASID);
     56static int  hmR0SvmInterpretInvlpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame);
    5757static int  hmR0SvmEmulateTprVMMCall(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx);
    5858static void hmR0SvmSetMSRPermission(PVMCPU pVCpu, unsigned ulMSR, bool fRead, bool fWrite);
    … …  
    22492249    }
    22502250
    2251     case SVM_EXIT_INVLPG:               /* Guest software attempted to execute INVPG. */
     2251    case SVM_EXIT_INVLPG:               /* Guest software attempted to execute INVLPG. */
    22522252    {
    22532253        Log2(("SVM: invlpg\n"));
    2254         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInvpg);
     2254        STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInvlpg);
    22552255
    22562256        Assert(!pVM->hwaccm.s.fNestedPaging);
    22572257
    22582258        /* Truly a pita. Why can't SVM give the same information as VT-x? */
    2259         rc = hmR0SvmInterpretInvpg(pVM, pVCpu, CPUMCTX2CORE(pCtx), pVMCB->ctrl.TLBCtrl.n.u32ASID);
     2259        rc = hmR0SvmInterpretInvlpg(pVM, pVCpu, CPUMCTX2CORE(pCtx));
    22602260        if (rc == VINF_SUCCESS)
    22612261        {
    … …  
    29282928
    29292929/**
    2930  * Interprets INVLPG.
     2930 * Worker for Interprets INVLPG.
    29312931 *
    29322932 * @return VBox status code.
    … …  
    29342934 * @param   pCpu            Pointer to the CPU info struct.
    29352935 * @param   pRegFrame       Pointer to the register frame.
    2936  * @param   ASID            Tagged TLB id for the guest.
    29372936 */
    2938 static int hmR0svmInterpretInvlPg(PVMCPU pVCpu, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, uint32_t uASID)
     2937static int hmR0svmInterpretInvlPgEx(PVMCPU pVCpu, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame)
    29392938{
    29402939    DISQPVPARAMVAL param1;
    29412940    RTGCPTR     addr;
    2942     NOREF(uASID);
    29432941
    29442942    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->Param1, &param1, DISQPVWHICH_SRC);
    … …  
    29812979 * @param   pVM         Pointer to the VM.
    29822980 * @param   pRegFrame   Pointer to the register frame.
    2983  * @param   ASID        Tagged TLB id for the guest.
    29842981 *
    29852982 * @remarks Updates the EIP if an instruction was executed successfully.
    29862983 */
    2987 static int hmR0SvmInterpretInvpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t uASID)
     2984static int hmR0SvmInterpretInvlpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
    29882985{
    29892986    /*
    … …  
    29962993        if (RT_SUCCESS(rc) && pDis->pCurInstr->uOpcode == OP_INVLPG)
    29972994        {
    2998             rc = hmR0svmInterpretInvlPg(pVCpu, pDis, pRegFrame, uASID);
     2995            rc = hmR0svmInterpretInvlPgEx(pVCpu, pDis, pRegFrame);
    29992996            if (RT_SUCCESS(rc))
    30002997                pRegFrame->rip += pDis->cbInstr; /* Move on to the next instruction. */

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

    r42343 r42373  
    36603660                    switch (pDis->pCurInstr->uOpcode)
    36613661                    {
    3662                     case OP_CLI:
    3663                         pCtx->eflags.Bits.u1IF = 0;
    3664                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCli);
    3665                         break;
    3666 
    3667                     case OP_STI:
    3668                         pCtx->eflags.Bits.u1IF = 1;
    3669                         EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + pDis->cbInstr);
    3670                         Assert(VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
    3671                         rc2 = VMXWriteVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE,
    3672                                            VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE_BLOCK_STI);
    3673                         AssertRC(rc2);
    3674                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitSti);
    3675                         break;
    3676 
    3677                     case OP_HLT:
    3678                         fUpdateRIP = false;
    3679                         rc = VINF_EM_HALT;
    3680                         pCtx->rip += pDis->cbInstr;
    3681                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitHlt);
    3682                         break;
    3683 
    3684                     case OP_POPF:
    3685                     {
    3686                         RTGCPTR   GCPtrStack;
    3687                         uint32_t  cbParm;
    3688                         uint32_t  uMask;
    3689                         X86EFLAGS eflags;
    3690 
    3691                         if (pDis->fPrefix & DISPREFIX_OPSIZE)
     3662                        case OP_CLI:
     3663                            pCtx->eflags.Bits.u1IF = 0;
     3664                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitCli);
     3665                            break;
     3666
     3667                        case OP_STI:
     3668                            pCtx->eflags.Bits.u1IF = 1;
     3669                            EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + pDis->cbInstr);
     3670                            Assert(VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
     3671                            rc2 = VMXWriteVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE,
     3672                                               VMX_VMCS_GUEST_INTERRUPTIBILITY_STATE_BLOCK_STI);
     3673                            AssertRC(rc2);
     3674                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitSti);
     3675                            break;
     3676
     3677                        case OP_HLT:
     3678                            fUpdateRIP = false;
     3679                            rc = VINF_EM_HALT;
     3680                            pCtx->rip += pDis->cbInstr;
     3681                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitHlt);
     3682                            break;
     3683
     3684                        case OP_POPF:
    36923685                        {
    3693                             cbParm = 4;
    3694                             uMask  = 0xffffffff;
    3695                         }
    3696                         else
    3697                         {
    3698                             cbParm = 2;
    3699                             uMask  = 0xffff;
    3700                         }
    3701 
    3702                         rc2 = SELMToFlatEx(pVCpu, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
    3703                         if (RT_FAILURE(rc2))
    3704                         {
    3705                             rc = VERR_EM_INTERPRETER;
     3686                            RTGCPTR   GCPtrStack;
     3687                            uint32_t  cbParm;
     3688                            uint32_t  uMask;
     3689                            X86EFLAGS eflags;
     3690
     3691                            if (pDis->fPrefix & DISPREFIX_OPSIZE)
     3692                            {
     3693                                cbParm = 4;
     3694                                uMask  = 0xffffffff;
     3695                            }
     3696                            else
     3697                            {
     3698                                cbParm = 2;
     3699                                uMask  = 0xffff;
     3700                            }
     3701
     3702                            rc2 = SELMToFlatEx(pVCpu, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
     3703                            if (RT_FAILURE(rc2))
     3704                            {
     3705                                rc = VERR_EM_INTERPRETER;
     3706                                break;
     3707                            }
     3708                            eflags.u = 0;
     3709                            rc2 = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
     3710                            if (RT_FAILURE(rc2))
     3711                            {
     3712                                rc = VERR_EM_INTERPRETER;
     3713                                break;
     3714                            }
     3715                            LogFlow(("POPF %x -> %RGv mask=%x\n", eflags.u, pCtx->rsp, uMask));
     3716                            pCtx->eflags.u = (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask))
     3717                                            | (eflags.u & X86_EFL_POPF_BITS & uMask);
     3718                            /* RF cleared when popped in real mode; see pushf description in AMD manual. */
     3719                            pCtx->eflags.Bits.u1RF = 0;
     3720                            pCtx->esp += cbParm;
     3721                            pCtx->esp &= uMask;
     3722
     3723                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPopf);
    37063724                            break;
    37073725                        }
    3708                         eflags.u = 0;
    3709                         rc2 = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
    3710                         if (RT_FAILURE(rc2))
     3726
     3727                        case OP_PUSHF:
    37113728                        {
    3712                             rc = VERR_EM_INTERPRETER;
     3729                            RTGCPTR   GCPtrStack;
     3730                            uint32_t  cbParm;
     3731                            uint32_t  uMask;
     3732                            X86EFLAGS eflags;
     3733
     3734                            if (pDis->fPrefix & DISPREFIX_OPSIZE)
     3735                            {
     3736                                cbParm = 4;
     3737                                uMask  = 0xffffffff;
     3738                            }
     3739                            else
     3740                            {
     3741                                cbParm = 2;
     3742                                uMask  = 0xffff;
     3743                            }
     3744
     3745                            rc2 = SELMToFlatEx(pVCpu, DISSELREG_SS, CPUMCTX2CORE(pCtx), (pCtx->esp - cbParm) & uMask, 0,
     3746                                               &GCPtrStack);
     3747                            if (RT_FAILURE(rc2))
     3748                            {
     3749                                rc = VERR_EM_INTERPRETER;
     3750                                break;
     3751                            }
     3752                            eflags = pCtx->eflags;
     3753                            /* RF & VM cleared when pushed in real mode; see pushf description in AMD manual. */
     3754                            eflags.Bits.u1RF = 0;
     3755                            eflags.Bits.u1VM = 0;
     3756
     3757                            rc2 = PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
     3758                            if (RT_FAILURE(rc2))
     3759                            {
     3760                                rc = VERR_EM_INTERPRETER;
     3761                                break;
     3762                            }
     3763                            LogFlow(("PUSHF %x -> %RGv\n", eflags.u, GCPtrStack));
     3764                            pCtx->esp -= cbParm;
     3765                            pCtx->esp &= uMask;
     3766                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPushf);
    37133767                            break;
    37143768                        }
    3715                         LogFlow(("POPF %x -> %RGv mask=%x\n", eflags.u, pCtx->rsp, uMask));
    3716                         pCtx->eflags.u = (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask)) | (eflags.u & X86_EFL_POPF_BITS & uMask);
    3717                         /* RF cleared when popped in real mode; see pushf description in AMD manual. */
    3718                         pCtx->eflags.Bits.u1RF = 0;
    3719                         pCtx->esp += cbParm;
    3720                         pCtx->esp &= uMask;
    3721 
    3722                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPopf);
    3723                         break;
    3724                     }
    3725 
    3726                     case OP_PUSHF:
    3727                     {
    3728                         RTGCPTR   GCPtrStack;
    3729                         uint32_t  cbParm;
    3730                         uint32_t  uMask;
    3731                         X86EFLAGS eflags;
    3732 
    3733                         if (pDis->fPrefix & DISPREFIX_OPSIZE)
     3769
     3770                        case OP_IRET:
    37343771                        {
    3735                             cbParm = 4;
    3736                             uMask  = 0xffffffff;
    3737                         }
    3738                         else
    3739                         {
    3740                             cbParm = 2;
    3741                             uMask  = 0xffff;
    3742                         }
    3743 
    3744                         rc2 = SELMToFlatEx(pVCpu, DISSELREG_SS, CPUMCTX2CORE(pCtx), (pCtx->esp - cbParm) & uMask, 0,
    3745                                            &GCPtrStack);
    3746                         if (RT_FAILURE(rc2))
    3747                         {
    3748                             rc = VERR_EM_INTERPRETER;
     3772                            RTGCPTR   GCPtrStack;
     3773                            uint32_t  uMask = 0xffff;
     3774                            uint16_t  aIretFrame[3];
     3775
     3776                            if (pDis->fPrefix & (DISPREFIX_OPSIZE | DISPREFIX_ADDRSIZE))
     3777                            {
     3778                                rc = VERR_EM_INTERPRETER;
     3779                                break;
     3780                            }
     3781
     3782                            rc2 = SELMToFlatEx(pVCpu, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
     3783                            if (RT_FAILURE(rc2))
     3784                            {
     3785                                rc = VERR_EM_INTERPRETER;
     3786                                break;
     3787                            }
     3788                            rc2 = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame));
     3789                            if (RT_FAILURE(rc2))
     3790                            {
     3791                                rc = VERR_EM_INTERPRETER;
     3792                                break;
     3793                            }
     3794                            pCtx->ip            = aIretFrame[0];
     3795                            pCtx->cs.Sel        = aIretFrame[1];
     3796                            pCtx->cs.ValidSel   = aIretFrame[1];
     3797                            pCtx->cs.u64Base    = (uint32_t)pCtx->cs.Sel << 4;
     3798                            pCtx->eflags.u      =   (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask))
     3799                                                  | (aIretFrame[2] & X86_EFL_POPF_BITS & uMask);
     3800                            pCtx->sp           += sizeof(aIretFrame);
     3801
     3802                            LogFlow(("iret to %04x:%x\n", pCtx->cs.Sel, pCtx->ip));
     3803                            fUpdateRIP = false;
     3804                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIret);
    37493805                            break;
    37503806                        }
    3751                         eflags = pCtx->eflags;
    3752                         /* RF & VM cleared when pushed in real mode; see pushf description in AMD manual. */
    3753                         eflags.Bits.u1RF = 0;
    3754                         eflags.Bits.u1VM = 0;
    3755 
    3756                         rc2 = PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
    3757                         if (RT_FAILURE(rc2))
    3758                         {
    3759                             rc = VERR_EM_INTERPRETER;
    3760                             break;
    3761                         }
    3762                         LogFlow(("PUSHF %x -> %RGv\n", eflags.u, GCPtrStack));
    3763                         pCtx->esp -= cbParm;
    3764                         pCtx->esp &= uMask;
    3765                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitPushf);
    3766                         break;
    3767                     }
    3768 
    3769                     case OP_IRET:
    3770                     {
    3771                         RTGCPTR   GCPtrStack;
    3772                         uint32_t  uMask = 0xffff;
    3773                         uint16_t  aIretFrame[3];
    3774 
    3775                         if (pDis->fPrefix & (DISPREFIX_OPSIZE | DISPREFIX_ADDRSIZE))
    3776                         {
    3777                             rc = VERR_EM_INTERPRETER;
    3778                             break;
    3779                         }
    3780 
    3781                         rc2 = SELMToFlatEx(pVCpu, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
    3782                         if (RT_FAILURE(rc2))
    3783                         {
    3784                             rc = VERR_EM_INTERPRETER;
    3785                             break;
    3786                         }
    3787                         rc2 = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame));
    3788                         if (RT_FAILURE(rc2))
    3789                         {
    3790                             rc = VERR_EM_INTERPRETER;
    3791                             break;
    3792                         }
    3793                         pCtx->ip            = aIretFrame[0];
    3794                         pCtx->cs.Sel        = aIretFrame[1];
    3795                         pCtx->cs.ValidSel   = aIretFrame[1];
    3796                         pCtx->cs.u64Base    = (uint32_t)pCtx->cs.Sel << 4;
    3797                         pCtx->eflags.u      =   (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask))
    3798                                               | (aIretFrame[2] & X86_EFL_POPF_BITS & uMask);
    3799                         pCtx->sp           += sizeof(aIretFrame);
    3800 
    3801                         LogFlow(("iret to %04x:%x\n", pCtx->cs.Sel, pCtx->ip));
    3802                         fUpdateRIP = false;
    3803                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIret);
    3804                         break;
    3805                     }
    3806 
    3807                     case OP_INT:
    3808                     {
    3809                         uint32_t intInfo2;
    3810 
    3811                         LogFlow(("Realmode: INT %x\n", pDis->Param1.uValue & 0xff));
    3812                         intInfo2  = pDis->Param1.uValue & 0xff;
    3813                         intInfo2 |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
    3814                         intInfo2 |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
    3815 
    3816                         rc = hmR0VmxInjectEvent(pVM, pVCpu, pCtx, intInfo2, cbOp, 0);
    3817                         AssertRC(VBOXSTRICTRC_VAL(rc));
    3818                         fUpdateRIP = false;
    3819                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
    3820                         break;
    3821                     }
    3822 
    3823                     case OP_INTO:
    3824                     {
    3825                         if (pCtx->eflags.Bits.u1OF)
     3807
     3808                        case OP_INT:
    38263809                        {
    38273810                            uint32_t intInfo2;
    38283811
    3829                             LogFlow(("Realmode: INTO\n"));
    3830                             intInfo2  = X86_XCPT_OF;
     3812                            LogFlow(("Realmode: INT %x\n", pDis->Param1.uValue & 0xff));
     3813                            intInfo2  = pDis->Param1.uValue & 0xff;
    38313814                            intInfo2 |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
    38323815                            intInfo2 |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
    … …  
    38363819                            fUpdateRIP = false;
    38373820                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
     3821                            break;
    38383822                        }
    3839                         break;
    3840                     }
    3841 
    3842                     case OP_INT3:
    3843                     {
    3844                         uint32_t intInfo2;
    3845 
    3846                         LogFlow(("Realmode: INT 3\n"));
    3847                         intInfo2  = 3;
    3848                         intInfo2 |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
    3849                         intInfo2 |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
    3850 
    3851                         rc = hmR0VmxInjectEvent(pVM, pVCpu, pCtx, intInfo2, cbOp, 0);
    3852                         AssertRC(VBOXSTRICTRC_VAL(rc));
    3853                         fUpdateRIP = false;
    3854                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
    3855                         break;
    3856                     }
    3857 
    3858                     default:
    3859                         rc = EMInterpretInstructionDisasState(pVCpu, pDis, CPUMCTX2CORE(pCtx), 0, EMCODETYPE_SUPERVISOR);
    3860                         fUpdateRIP = false;
    3861                         break;
     3823
     3824                        case OP_INTO:
     3825                        {
     3826                            if (pCtx->eflags.Bits.u1OF)
     3827                            {
     3828                                uint32_t intInfo2;
     3829
     3830                                LogFlow(("Realmode: INTO\n"));
     3831                                intInfo2  = X86_XCPT_OF;
     3832                                intInfo2 |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
     3833                                intInfo2 |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
     3834
     3835                                rc = hmR0VmxInjectEvent(pVM, pVCpu, pCtx, intInfo2, cbOp, 0);
     3836                                AssertRC(VBOXSTRICTRC_VAL(rc));
     3837                                fUpdateRIP = false;
     3838                                STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
     3839                            }
     3840                            break;
     3841                        }
     3842
     3843                        case OP_INT3:
     3844                        {
     3845                            uint32_t intInfo2;
     3846
     3847                            LogFlow(("Realmode: INT 3\n"));
     3848                            intInfo2  = 3;
     3849                            intInfo2 |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
     3850                            intInfo2 |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
     3851
     3852                            rc = hmR0VmxInjectEvent(pVM, pVCpu, pCtx, intInfo2, cbOp, 0);
     3853                            AssertRC(VBOXSTRICTRC_VAL(rc));
     3854                            fUpdateRIP = false;
     3855                            STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInt);
     3856                            break;
     3857                        }
     3858
     3859                        default:
     3860                            rc = EMInterpretInstructionDisasState(pVCpu, pDis, CPUMCTX2CORE(pCtx), 0, EMCODETYPE_SUPERVISOR);
     3861                            fUpdateRIP = false;
     3862                            break;
    38623863                    }
    38633864
    … …  
    38953896                switch (vector)
    38963897                {
    3897                     case X86_XCPT_DE:
    3898                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestDE);
    3899                         break;
    3900                     case X86_XCPT_UD:
    3901                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestUD);
    3902                         break;
    3903                     case X86_XCPT_SS:
    3904                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestSS);
    3905                         break;
    3906                     case X86_XCPT_NP:
    3907                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestNP);
    3908                         break;
    3909                     case X86_XCPT_XF:
    3910                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestXF);
    3911                         break;
     3898                    case X86_XCPT_DE: STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestDE); break;
     3899                    case X86_XCPT_UD: STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestUD); break;
     3900                    case X86_XCPT_SS: STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestSS); break;
     3901                    case X86_XCPT_NP: STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestNP); break;
     3902                    case X86_XCPT_XF: STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitGuestXF); break;
    39123903                }
    39133904
    … …  
    41674158    }
    41684159
    4169     case VMX_EXIT_INVPG:                /* 14 Guest software attempted to execute INVPG. */
     4160    case VMX_EXIT_INVLPG:               /* 14 Guest software attempted to execute INVLPG. */
    41704161    {
    41714162        Log2(("VMX: invlpg\n"));
    41724163        Assert(!pVM->hwaccm.s.fNestedPaging);
    41734164
    4174         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInvpg);
     4165        STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitInvlpg);
    41754166        rc = EMInterpretInvlpg(pVM, pVCpu, CPUMCTX2CORE(pCtx), exitQualification);
    41764167        if (rc == VINF_SUCCESS)
    … …  
    47354726    case VMX_EXIT_CPUID:                /* 10 Guest software attempted to execute CPUID. */
    47364727    case VMX_EXIT_RDTSC:                /* 16 Guest software attempted to execute RDTSC. */
    4737     case VMX_EXIT_INVPG:                /* 14 Guest software attempted to execute INVPG. */
     4728    case VMX_EXIT_INVLPG:               /* 14 Guest software attempted to execute INVLPG. */
    47384729    case VMX_EXIT_CRX_MOVE:             /* 28 Control-register accesses. */
    47394730    case VMX_EXIT_DRX_MOVE:             /* 29 Debug-register accesses. */

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

    r42186 r42373  
    11/* $Id$ */
    22/** @file
    3  * HWACCM - Intel/AMD VM Hardware Support Manager
     3 * HWACCM - Intel/AMD VM Hardware Support Manager.
    44 */
    55
    … …  
    7373    EXIT_REASON(VMX_EXIT_HLT                , 12, "Guest software attempted to execute HLT."),
    7474    EXIT_REASON(VMX_EXIT_INVD               , 13, "Guest software attempted to execute INVD."),
    75     EXIT_REASON(VMX_EXIT_INVPG              , 14, "Guest software attempted to execute INVPG."),
     75    EXIT_REASON(VMX_EXIT_INVLPG             , 14, "Guest software attempted to execute INVLPG."),
    7676    EXIT_REASON(VMX_EXIT_RDPMC              , 15, "Guest software attempted to execute RDPMC."),
    7777    EXIT_REASON(VMX_EXIT_RDTSC              , 16, "Guest software attempted to execute RDTSC."),
    … …  
    510510        HWACCM_REG_COUNTER(&pVCpu->hwaccm.s.StatExitGuestXF,            "/HWACCM/CPU%d/Exit/Trap/Gst/#XF");
    511511        HWACCM_REG_COUNTER(&pVCpu->hwaccm.s.StatExitGuestXcpUnk,        "/HWACCM/CPU%d/Exit/Trap/Gst/Other");
    512         HWACCM_REG_COUNTER(&pVCpu->hwaccm.s.StatExitInvpg,              "/HWACCM/CPU%d/Exit/Instr/Invlpg");
     512        HWACCM_REG_COUNTER(&pVCpu->hwaccm.s.StatExitInvlpg,             "/HWACCM/CPU%d/Exit/Instr/Invlpg");
    513513        HWACCM_REG_COUNTER(&pVCpu->hwaccm.s.StatExitInvd,               "/HWACCM/CPU%d/Exit/Instr/Invd");
    514514        HWACCM_REG_COUNTER(&pVCpu->hwaccm.s.StatExitCpuid,              "/HWACCM/CPU%d/Exit/Instr/Cpuid");

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

    r42344 r42373  
    785785    STAMCOUNTER             StatExitGuestXF;
    786786    STAMCOUNTER             StatExitGuestXcpUnk;
    787     STAMCOUNTER             StatExitInvpg;
     787    STAMCOUNTER             StatExitInvlpg;
    788788    STAMCOUNTER             StatExitInvd;
    789789    STAMCOUNTER             StatExitCpuid;
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