VirtualBox

Changeset 30263 in vbox for trunk/src


Ignore:
Timestamp:
Jun 16, 2010 6:31:42 PM (15 years ago)
Author:
vboxsync
Message:

VMM,REM: Only invalidate hidden registers when using raw-mode. Fixes save restore during mode switching code like the windows boot menu. (#5057)

Location:
trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r30164 r30263  
    6363*******************************************************************************/
    6464/** The current saved state version. */
    65 #define CPUM_SAVED_STATE_VERSION                11
     65#define CPUM_SAVED_STATE_VERSION                12
     66/** The saved state version of 3.2, 3.1 and 3.3 trunk before the hidden
     67 * selector register change (CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID). */
     68#define CPUM_SAVED_STATE_VERSION_VER3_2         11
    6669/** The saved state version of 3.0 and 3.1 trunk before the teleportation
    6770 * changes. */
    … …  
    20652068     */
    20662069    if (    uVersion != CPUM_SAVED_STATE_VERSION
     2070        &&  uVersion != CPUM_SAVED_STATE_VERSION_VER3_2
    20672071        &&  uVersion != CPUM_SAVED_STATE_VERSION_VER3_0
    20682072        &&  uVersion != CPUM_SAVED_STATE_VERSION_VER2_1_NOMSR
    … …  
    21342138            }
    21352139        }
     2140
     2141        /* Older states does not set CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID for
     2142           raw-mode guest, so we have to do it ourselves. */
     2143        if (   uVersion <= CPUM_SAVED_STATE_VERSION_VER3_2
     2144            && !HWACCMIsEnabled(pVM))
     2145            for (VMCPUID iCpu = 0; iCpu < pVM->cCpus; iCpu++)
     2146                pVM->aCpus[iCpu].cpum.s.fChanged |= CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID;
    21362147    }
    21372148
    … …  
    22722283        return VERR_INTERNAL_ERROR_2;
    22732284    }
    2274 
    22752285    return VINF_SUCCESS;
    22762286}
    … …  
    35743584        &&   pCtx->eflags.Bits.u1VM == 0)
    35753585    {
    3576         if (CPUMAreHiddenSelRegsValid(pVM))
     3586        if (CPUMAreHiddenSelRegsValid(pVCpu))
    35773587        {
    35783588            State.f64Bits         = enmMode >= PGMMODE_AMD64 && pCtx->csHid.Attr.n.u1Long;
    … …  
    37683778    return (RCPTRTYPE(PCCPUMCPUID))VM_RC_ADDR(pVM, &pVM->cpum.s.GuestCpuIdDef);
    37693779}
     3780
     3781
     3782/**
     3783 * Transforms the guest CPU state to raw-ring mode.
     3784 *
     3785 * This function will change the any of the cs and ss register with DPL=0 to DPL=1.
     3786 *
     3787 * @returns VBox status. (recompiler failure)
     3788 * @param   pVCpu       The VMCPU handle.
     3789 * @param   pCtxCore    The context core (for trap usage).
     3790 * @see     @ref pg_raw
     3791 */
     3792VMMR3DECL(int) CPUMR3RawEnter(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore)
     3793{
     3794    PVM pVM = pVCpu->CTX_SUFF(pVM);
     3795
     3796    Assert(!pVCpu->cpum.s.fRawEntered);
     3797    Assert(!pVCpu->cpum.s.fRemEntered);
     3798    if (!pCtxCore)
     3799        pCtxCore = CPUMCTX2CORE(&pVCpu->cpum.s.Guest);
     3800
     3801    /*
     3802     * Are we in Ring-0?
     3803     */
     3804    if (    pCtxCore->ss && (pCtxCore->ss & X86_SEL_RPL) == 0
     3805        &&  !pCtxCore->eflags.Bits.u1VM)
     3806    {
     3807        /*
     3808         * Enter execution mode.
     3809         */
     3810        PATMRawEnter(pVM, pCtxCore);
     3811
     3812        /*
     3813         * Set CPL to Ring-1.
     3814         */
     3815        pCtxCore->ss |= 1;
     3816        if (pCtxCore->cs && (pCtxCore->cs & X86_SEL_RPL) == 0)
     3817            pCtxCore->cs |= 1;
     3818    }
     3819    else
     3820    {
     3821        AssertMsg((pCtxCore->ss & X86_SEL_RPL) >= 2 || pCtxCore->eflags.Bits.u1VM,
     3822                  ("ring-1 code not supported\n"));
     3823        /*
     3824         * PATM takes care of IOPL and IF flags for Ring-3 and Ring-2 code as well.
     3825         */
     3826        PATMRawEnter(pVM, pCtxCore);
     3827    }
     3828
     3829    /*
     3830     * Invalidate the hidden registers.
     3831     */
     3832    pVCpu->cpum.s.fChanged |= CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID;
     3833
     3834    /*
     3835     * Assert sanity.
     3836     */
     3837    AssertMsg((pCtxCore->eflags.u32 & X86_EFL_IF), ("X86_EFL_IF is clear\n"));
     3838    AssertReleaseMsg(   pCtxCore->eflags.Bits.u2IOPL < (unsigned)(pCtxCore->ss & X86_SEL_RPL)
     3839                     || pCtxCore->eflags.Bits.u1VM,
     3840                     ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss & X86_SEL_RPL));
     3841    Assert((pVCpu->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)) == (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP));
     3842
     3843    pCtxCore->eflags.u32        |= X86_EFL_IF; /* paranoia */
     3844
     3845    pVCpu->cpum.s.fRawEntered = true;
     3846    return VINF_SUCCESS;
     3847}
     3848
     3849
     3850/**
     3851 * Transforms the guest CPU state from raw-ring mode to correct values.
     3852 *
     3853 * This function will change any selector registers with DPL=1 to DPL=0.
     3854 *
     3855 * @returns Adjusted rc.
     3856 * @param   pVCpu       The VMCPU handle.
     3857 * @param   rc          Raw mode return code
     3858 * @param   pCtxCore    The context core (for trap usage).
     3859 * @see     @ref pg_raw
     3860 */
     3861VMMR3DECL(int) CPUMR3RawLeave(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, int rc)
     3862{
     3863    PVM pVM = pVCpu->CTX_SUFF(pVM);
     3864
     3865    /*
     3866     * Don't leave if we've already left (in GC).
     3867     */
     3868    Assert(pVCpu->cpum.s.fRawEntered);
     3869    Assert(!pVCpu->cpum.s.fRemEntered);
     3870    if (!pVCpu->cpum.s.fRawEntered)
     3871        return rc;
     3872    pVCpu->cpum.s.fRawEntered = false;
     3873
     3874    PCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
     3875    if (!pCtxCore)
     3876        pCtxCore = CPUMCTX2CORE(pCtx);
     3877    Assert(pCtxCore->eflags.Bits.u1VM || (pCtxCore->ss & X86_SEL_RPL));
     3878    AssertMsg(pCtxCore->eflags.Bits.u1VM || pCtxCore->eflags.Bits.u2IOPL < (unsigned)(pCtxCore->ss & X86_SEL_RPL),
     3879              ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss & X86_SEL_RPL));
     3880
     3881    /*
     3882     * Are we executing in raw ring-1?
     3883     */
     3884    if (    (pCtxCore->ss & X86_SEL_RPL) == 1
     3885        &&  !pCtxCore->eflags.Bits.u1VM)
     3886    {
     3887        /*
     3888         * Leave execution mode.
     3889         */
     3890        PATMRawLeave(pVM, pCtxCore, rc);
     3891        /* Not quite sure if this is really required, but shouldn't harm (too much anyways). */
     3892        /** @todo See what happens if we remove this. */
     3893        if ((pCtxCore->ds & X86_SEL_RPL) == 1)
     3894            pCtxCore->ds &= ~X86_SEL_RPL;
     3895        if ((pCtxCore->es & X86_SEL_RPL) == 1)
     3896            pCtxCore->es &= ~X86_SEL_RPL;
     3897        if ((pCtxCore->fs & X86_SEL_RPL) == 1)
     3898            pCtxCore->fs &= ~X86_SEL_RPL;
     3899        if ((pCtxCore->gs & X86_SEL_RPL) == 1)
     3900            pCtxCore->gs &= ~X86_SEL_RPL;
     3901
     3902        /*
     3903         * Ring-1 selector => Ring-0.
     3904         */
     3905        pCtxCore->ss &= ~X86_SEL_RPL;
     3906        if ((pCtxCore->cs & X86_SEL_RPL) == 1)
     3907            pCtxCore->cs &= ~X86_SEL_RPL;
     3908    }
     3909    else
     3910    {
     3911        /*
     3912         * PATM is taking care of the IOPL and IF flags for us.
     3913         */
     3914        PATMRawLeave(pVM, pCtxCore, rc);
     3915        if (!pCtxCore->eflags.Bits.u1VM)
     3916        {
     3917            /** @todo See what happens if we remove this. */
     3918            if ((pCtxCore->ds & X86_SEL_RPL) == 1)
     3919                pCtxCore->ds &= ~X86_SEL_RPL;
     3920            if ((pCtxCore->es & X86_SEL_RPL) == 1)
     3921                pCtxCore->es &= ~X86_SEL_RPL;
     3922            if ((pCtxCore->fs & X86_SEL_RPL) == 1)
     3923                pCtxCore->fs &= ~X86_SEL_RPL;
     3924            if ((pCtxCore->gs & X86_SEL_RPL) == 1)
     3925                pCtxCore->gs &= ~X86_SEL_RPL;
     3926        }
     3927    }
     3928
     3929    return rc;
     3930}
     3931
     3932
     3933/**
     3934 * Enters REM, gets and resets the changed flags (CPUM_CHANGED_*).
     3935 *
     3936 * Only REM should ever call this function!
     3937 *
     3938 * @returns The changed flags.
     3939 * @param   pVCpu       The VMCPU handle.
     3940 * @param   puCpl       Where to return the current privilege level (CPL).
     3941 */
     3942VMMR3DECL(uint32_t) CPUMR3RemEnter(PVMCPU pVCpu, uint32_t *puCpl)
     3943{
     3944    Assert(!pVCpu->cpum.s.fRawEntered);
     3945    Assert(!pVCpu->cpum.s.fRemEntered);
     3946
     3947    /*
     3948     * Get the CPL first.
     3949     */
     3950    *puCpl = CPUMGetGuestCPL(pVCpu, CPUMCTX2CORE(&pVCpu->cpum.s.Guest));
     3951
     3952    /*
     3953     * Get and reset the flags, leaving CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID set.
     3954     */
     3955    uint32_t fFlags = pVCpu->cpum.s.fChanged;
     3956    pVCpu->cpum.s.fChanged &= CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID; /* leave it set */
     3957
     3958    /** @todo change the switcher to use the fChanged flags. */
     3959    if (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_SINCE_REM)
     3960    {
     3961        fFlags |= CPUM_CHANGED_FPU_REM;
     3962        pVCpu->cpum.s.fUseFlags &= ~CPUM_USED_FPU_SINCE_REM;
     3963    }
     3964
     3965    pVCpu->cpum.s.fRemEntered = true;
     3966    return fFlags;
     3967}
     3968
     3969
     3970/**
     3971 * Leaves REM and works the CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID flag.
     3972 *
     3973 * @param   pVCpu               The virtual CPU handle.
     3974 * @param   fNoOutOfSyncSels    This is @c false if there are out of sync
     3975 *                              registers.
     3976 */
     3977VMMR3DECL(void) CPUMR3RemLeave(PVMCPU pVCpu, bool fNoOutOfSyncSels)
     3978{
     3979    Assert(!pVCpu->cpum.s.fRawEntered);
     3980    Assert(pVCpu->cpum.s.fRemEntered);
     3981
     3982    if (fNoOutOfSyncSels)
     3983        pVCpu->cpum.s.fChanged &= ~CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID;
     3984    else
     3985        pVCpu->cpum.s.fChanged |= ~CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID;
     3986
     3987    pVCpu->cpum.s.fRemEntered = false;
     3988}
     3989

  • trunk/src/VBox/VMM/CPUMInternal.h

    r30164 r30263  
    294294    } CR4;
    295295
    296     /** Have we entered rawmode? */
    297     bool                    fRawEntered;
    298296    /** Synthetic CPU type? */
    299297    bool                    fSyntheticCpu;
    … …  
    303301     * This is used to verify load order dependencies (PGM). */
    304302    bool                    fPendingRestore;
    305 #if HC_ARCH_BITS == 64
    306     uint8_t                 abPadding[4];
    307 #endif
     303    uint8_t                 abPadding[HC_ARCH_BITS == 64 ? 5 : 1];
    308304
    309305    /** The standard set of CpuId leafs. */
    … …  
    390386    uint32_t                u32RetCode;
    391387
     388    /** Have we entered raw-mode? */
     389    bool                    fRawEntered;
     390    /** Have we entered the recompiler? */
     391    bool                    fRemEntered;
     392
    392393    /** Align the structure on a 64-byte boundrary. */
    393     uint8_t                 abPadding2[HC_ARCH_BITS == 32 ? 36 : 28];
     394    uint8_t                 abPadding2[HC_ARCH_BITS == 32 ? 34 : 26];
    394395} CPUMCPU, *PCPUMCPU;
    395396/** Pointer to the CPUMCPU instance data residing in the shared VMCPU structure. */

  • trunk/src/VBox/VMM/CPUMInternal.mac

    r30184 r30263  
    6767    .CR4.OrMask           resd    1
    6868    ; entered rawmode?
    69     .fRawEntered          resb    1
    7069    .fSyntheticCpu        resb    1
    7170    .u8PortableCpuIdLevel resb    1
    7271    .fPendingRestore      resb    1
    7372%if RTHCPTR_CB == 8
    74     .abPadding            resb    4
     73    .abPadding            resb    5
    7574%else
    76 ;    .abPadding            resb    0
     75    .abPadding            resb    1
    7776%endif
    7877
    … …  
    418417    .offCPUM              resd    1
    419418    .u32RetCode           resd    1
     419    .fRawEntered          resb    1
     420    .fRemEntered          resb    1
    420421
    421422%if RTHCPTR_CB == 8
    422     .abPadding2           resb    28
     423    .abPadding2           resb    26
    423424%else
    424     .abPadding2           resb    36
     425    .abPadding2           resb    34
    425426%endif
    426427

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

    r28800 r30263  
    339339
    340340    if (    pHiddenSel
    341         &&  CPUMAreHiddenSelRegsValid(pVM))
     341        &&  CPUMAreHiddenSelRegsValid(pVCpu))
    342342    {
    343343        SelInfo.Sel                     = Sel;
    … …  
    379379        SelInfo.u.Raw.Gen.u4LimitHigh   = 0xf;
    380380
    381         if (CPUMAreHiddenSelRegsValid(pVM))
     381        if (CPUMAreHiddenSelRegsValid(pVCpu))
    382382        {   /* Assume the current CS defines the execution mode. */
    383383            pCtxCore   = CPUMGetGuestCtxCore(pVCpu);

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

    r29329 r30263  
    183183     * Resume execution.
    184184     */
    185     CPUMRawEnter(pVCpu, NULL);
     185    CPUMR3RawEnter(pVCpu, NULL);
    186186    CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) | X86_EFL_RF);
    187187    rc = VMMR3ResumeHyper(pVM, pVCpu);
    188188    Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr - returned from GC with rc=%Rrc\n", pCtx->cs, pCtx->eip, pCtx->eflags, rc));
    189     rc = CPUMRawLeave(pVCpu, NULL, rc);
     189    rc = CPUMR3RawLeave(pVCpu, NULL, rc);
    190190    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    191191
    … …  
    244244     * We do not start time or anything, if anything we should just do a few nanoseconds.
    245245     */
    246     CPUMRawEnter(pVCpu, NULL);
     246    CPUMR3RawEnter(pVCpu, NULL);
    247247    do
    248248    {
    … …  
    257257    } while (   rc == VINF_SUCCESS
    258258             || rc == VINF_EM_RAW_INTERRUPT);
    259     rc = CPUMRawLeave(pVCpu, NULL, rc);
     259    rc = CPUMR3RawLeave(pVCpu, NULL, rc);
    260260    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    261261
    … …  
    14771477         * and perhaps EIP) needs to be stored with PATM.
    14781478         */
    1479         rc = CPUMRawEnter(pVCpu, NULL);
     1479        rc = CPUMR3RawEnter(pVCpu, NULL);
    14801480        if (rc != VINF_SUCCESS)
    14811481        {
    … …  
    15001500                if (rc != VINF_SUCCESS)
    15011501                {
    1502                     rc = CPUMRawLeave(pVCpu, NULL, rc);
     1502                    rc = CPUMR3RawLeave(pVCpu, NULL, rc);
    15031503                    break;
    15041504                }
    … …  
    15421542         * execution FFs before doing anything else.
    15431543         */
    1544         rc = CPUMRawLeave(pVCpu, NULL, rc);
     1544        rc = CPUMR3RawLeave(pVCpu, NULL, rc);
    15451545        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    15461546        if (    VM_FF_ISPENDING(pVM, VM_FF_HIGH_PRIORITY_POST_MASK)

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

    r30164 r30263  
    18541854
    18551855
    1856 
    1857 #ifndef IN_RING0  /** @todo I don't think we need this in R0, so move it to CPUMAll.cpp? */
    1858 
    1859 /**
    1860  * Transforms the guest CPU state to raw-ring mode.
    1861  *
    1862  * This function will change the any of the cs and ss register with DPL=0 to DPL=1.
    1863  *
    1864  * @returns VBox status. (recompiler failure)
    1865  * @param   pVCpu       The VMCPU handle.
    1866  * @param   pCtxCore    The context core (for trap usage).
    1867  * @see     @ref pg_raw
    1868  */
    1869 VMMDECL(int) CPUMRawEnter(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore)
    1870 {
    1871     PVM pVM = pVCpu->CTX_SUFF(pVM);
    1872 
    1873     Assert(!pVM->cpum.s.fRawEntered);
    1874     if (!pCtxCore)
    1875         pCtxCore = CPUMCTX2CORE(&pVCpu->cpum.s.Guest);
    1876 
    1877     /*
    1878      * Are we in Ring-0?
    1879      */
    1880     if (    pCtxCore->ss && (pCtxCore->ss & X86_SEL_RPL) == 0
    1881         &&  !pCtxCore->eflags.Bits.u1VM)
    1882     {
    1883         /*
    1884          * Enter execution mode.
    1885          */
    1886         PATMRawEnter(pVM, pCtxCore);
    1887 
    1888         /*
    1889          * Set CPL to Ring-1.
    1890          */
    1891         pCtxCore->ss |= 1;
    1892         if (pCtxCore->cs && (pCtxCore->cs & X86_SEL_RPL) == 0)
    1893             pCtxCore->cs |= 1;
    1894     }
    1895     else
    1896     {
    1897         AssertMsg((pCtxCore->ss & X86_SEL_RPL) >= 2 || pCtxCore->eflags.Bits.u1VM,
    1898                   ("ring-1 code not supported\n"));
    1899         /*
    1900          * PATM takes care of IOPL and IF flags for Ring-3 and Ring-2 code as well.
    1901          */
    1902         PATMRawEnter(pVM, pCtxCore);
    1903     }
    1904 
    1905     /*
    1906      * Assert sanity.
    1907      */
    1908     AssertMsg((pCtxCore->eflags.u32 & X86_EFL_IF), ("X86_EFL_IF is clear\n"));
    1909     AssertReleaseMsg(   pCtxCore->eflags.Bits.u2IOPL < (unsigned)(pCtxCore->ss & X86_SEL_RPL)
    1910                      || pCtxCore->eflags.Bits.u1VM,
    1911                      ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss & X86_SEL_RPL));
    1912     Assert((pVCpu->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)) == (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP));
    1913     pCtxCore->eflags.u32        |= X86_EFL_IF; /* paranoia */
    1914 
    1915     pVM->cpum.s.fRawEntered = true;
    1916     return VINF_SUCCESS;
    1917 }
    1918 
    1919 
    1920 /**
    1921  * Transforms the guest CPU state from raw-ring mode to correct values.
    1922  *
    1923  * This function will change any selector registers with DPL=1 to DPL=0.
    1924  *
    1925  * @returns Adjusted rc.
    1926  * @param   pVCpu       The VMCPU handle.
    1927  * @param   rc          Raw mode return code
    1928  * @param   pCtxCore    The context core (for trap usage).
    1929  * @see     @ref pg_raw
    1930  */
    1931 VMMDECL(int) CPUMRawLeave(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, int rc)
    1932 {
    1933     PVM pVM = pVCpu->CTX_SUFF(pVM);
    1934 
    1935     /*
    1936      * Don't leave if we've already left (in GC).
    1937      */
    1938     Assert(pVM->cpum.s.fRawEntered);
    1939     if (!pVM->cpum.s.fRawEntered)
    1940         return rc;
    1941     pVM->cpum.s.fRawEntered = false;
    1942 
    1943     PCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
    1944     if (!pCtxCore)
    1945         pCtxCore = CPUMCTX2CORE(pCtx);
    1946     Assert(pCtxCore->eflags.Bits.u1VM || (pCtxCore->ss & X86_SEL_RPL));
    1947     AssertMsg(pCtxCore->eflags.Bits.u1VM || pCtxCore->eflags.Bits.u2IOPL < (unsigned)(pCtxCore->ss & X86_SEL_RPL),
    1948               ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss & X86_SEL_RPL));
    1949 
    1950     /*
    1951      * Are we executing in raw ring-1?
    1952      */
    1953     if (    (pCtxCore->ss & X86_SEL_RPL) == 1
    1954         &&  !pCtxCore->eflags.Bits.u1VM)
    1955     {
    1956         /*
    1957          * Leave execution mode.
    1958          */
    1959         PATMRawLeave(pVM, pCtxCore, rc);
    1960         /* Not quite sure if this is really required, but shouldn't harm (too much anyways). */
    1961         /** @todo See what happens if we remove this. */
    1962         if ((pCtxCore->ds & X86_SEL_RPL) == 1)
    1963             pCtxCore->ds &= ~X86_SEL_RPL;
    1964         if ((pCtxCore->es & X86_SEL_RPL) == 1)
    1965             pCtxCore->es &= ~X86_SEL_RPL;
    1966         if ((pCtxCore->fs & X86_SEL_RPL) == 1)
    1967             pCtxCore->fs &= ~X86_SEL_RPL;
    1968         if ((pCtxCore->gs & X86_SEL_RPL) == 1)
    1969             pCtxCore->gs &= ~X86_SEL_RPL;
    1970 
    1971         /*
    1972          * Ring-1 selector => Ring-0.
    1973          */
    1974         pCtxCore->ss &= ~X86_SEL_RPL;
    1975         if ((pCtxCore->cs & X86_SEL_RPL) == 1)
    1976             pCtxCore->cs &= ~X86_SEL_RPL;
    1977     }
    1978     else
    1979     {
    1980         /*
    1981          * PATM is taking care of the IOPL and IF flags for us.
    1982          */
    1983         PATMRawLeave(pVM, pCtxCore, rc);
    1984         if (!pCtxCore->eflags.Bits.u1VM)
    1985         {
    1986             /** @todo See what happens if we remove this. */
    1987             if ((pCtxCore->ds & X86_SEL_RPL) == 1)
    1988                 pCtxCore->ds &= ~X86_SEL_RPL;
    1989             if ((pCtxCore->es & X86_SEL_RPL) == 1)
    1990                 pCtxCore->es &= ~X86_SEL_RPL;
    1991             if ((pCtxCore->fs & X86_SEL_RPL) == 1)
    1992                 pCtxCore->fs &= ~X86_SEL_RPL;
    1993             if ((pCtxCore->gs & X86_SEL_RPL) == 1)
    1994                 pCtxCore->gs &= ~X86_SEL_RPL;
    1995         }
    1996     }
    1997 
    1998     return rc;
    1999 }
    2000 
     1856#ifndef IN_RING0
    20011857/**
    20021858 * Updates the EFLAGS while we're in raw-mode.
    … …  
    20101866    PVM pVM = pVCpu->CTX_SUFF(pVM);
    20111867
    2012     if (!pVM->cpum.s.fRawEntered)
     1868    if (!pVCpu->cpum.s.fRawEntered)
    20131869    {
    20141870        pCtxCore->eflags.u32 = eflags;
    … …  
    20171873    PATMRawSetEFlags(pVM, pCtxCore, eflags);
    20181874}
    2019 
    20201875#endif /* !IN_RING0 */
     1876
    20211877
    20221878/**
    … …  
    20341890    PVM pVM = pVCpu->CTX_SUFF(pVM);
    20351891
    2036     if (!pVM->cpum.s.fRawEntered)
     1892    if (!pVCpu->cpum.s.fRawEntered)
    20371893        return pCtxCore->eflags.u32;
    20381894    return PATMRawGetEFlags(pVM, pCtxCore);
    20391895#endif
    2040 }
    2041 
    2042 
    2043 /**
    2044  * Gets and resets the changed flags (CPUM_CHANGED_*).
    2045  * Only REM should call this function.
    2046  *
    2047  * @returns The changed flags.
    2048  * @param   pVCpu       The VMCPU handle.
    2049  */
    2050 VMMDECL(unsigned) CPUMGetAndClearChangedFlagsREM(PVMCPU pVCpu)
    2051 {
    2052     unsigned fFlags = pVCpu->cpum.s.fChanged;
    2053     pVCpu->cpum.s.fChanged = 0;
    2054     /** @todo change the switcher to use the fChanged flags. */
    2055     if (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_SINCE_REM)
    2056     {
    2057         fFlags |= CPUM_CHANGED_FPU_REM;
    2058         pVCpu->cpum.s.fUseFlags &= ~CPUM_USED_FPU_SINCE_REM;
    2059     }
    2060     return fFlags;
    20611896}
    20621897
    … …  
    21692004
    21702005/**
    2171  * Mark the guest's debug state as inactive
     2006 * Mark the guest's debug state as inactive.
    21722007 *
    21732008 * @returns boolean
    … …  
    21812016
    21822017/**
    2183  * Mark the hypervisor's debug state as inactive
     2018 * Mark the hypervisor's debug state as inactive.
    21842019 *
    21852020 * @returns boolean
    … …  
    21922027
    21932028/**
    2194  * Checks if the hidden selector registers are valid
     2029 * Checks if the hidden selector registers are valid for the specified CPU.
     2030 *
    21952031 * @returns true if they are.
    21962032 * @returns false if not.
    2197  * @param   pVM     The VM handle.
    2198  */
    2199 VMMDECL(bool) CPUMAreHiddenSelRegsValid(PVM pVM)
    2200 {
    2201     return HWACCMIsEnabled(pVM);
     2033 * @param   pVCpu     The VM handle.
     2034 */
     2035VMMDECL(bool) CPUMAreHiddenSelRegsValid(PVMCPU pVCpu)
     2036{
     2037    bool const fRc = !(pVCpu->cpum.s.fChanged & CPUM_CHANGED_HIDDEN_SEL_REGS_INVALID);
     2038    Assert(fRc || !HWACCMIsEnabled(pVCpu->CTX_SUFF(pVM)));
     2039    Assert(!pVCpu->cpum.s.fRemEntered);
     2040    return fRc;
    22022041}
    22032042
    … …  
    22152054    uint32_t cpl;
    22162055
    2217     if (CPUMAreHiddenSelRegsValid(pVCpu->CTX_SUFF(pVM)))
     2056    if (CPUMAreHiddenSelRegsValid(pVCpu))
    22182057    {
    22192058        /*

  • trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r29676 r30263  
    773773                             */
    774774                            RTGCPTR PC;
    775                             rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &PC);
     775                            rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
     776                                                              &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &PC);
    776777                            if (rc == VINF_SUCCESS)
    777778                            {

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

    r28800 r30263  
    9898    {
    9999        RTGCUINTPTR uFlat = (RTGCUINTPTR)Addr & 0xffff;
    100         if (CPUMAreHiddenSelRegsValid(pVM))
     100        if (CPUMAreHiddenSelRegsValid(pVCpu))
    101101            uFlat += pHiddenSel->u64Base;
    102102        else
    … …  
    106106
    107107#ifdef IN_RING0
    108     Assert(CPUMAreHiddenSelRegsValid(pVM));
     108    Assert(CPUMAreHiddenSelRegsValid(pVCpu));
    109109#else
    110110    /** @todo when we're in 16 bits mode, we should cut off the address as well.. */
    111     if (!CPUMAreHiddenSelRegsValid(pVM))
     111    if (!CPUMAreHiddenSelRegsValid(pVCpu))
    112112        return SELMToFlatBySel(pVM, Sel, Addr);
    113113#endif
    … …  
    170170        {
    171171            if (    pHiddenSel
    172                 &&  CPUMAreHiddenSelRegsValid(pVM))
     172                &&  CPUMAreHiddenSelRegsValid(pVCpu))
    173173                *ppvGC = (RTGCPTR)(pHiddenSel->u64Base + uFlat);
    174174            else
    … …  
    186186#ifndef IN_RC
    187187    if (    pHiddenSel
    188         &&  CPUMAreHiddenSelRegsValid(pVM))
     188        &&  CPUMAreHiddenSelRegsValid(pVCpu))
    189189    {
    190190        bool fCheckLimit = true;
    … …  
    460460 * @remarks Don't use when in long mode.
    461461 */
    462 VMMDECL(int) SELMToFlatBySelEx(PVM pVM, X86EFLAGS eflags, RTSEL Sel, RTGCPTR Addr, CPUMSELREGHID *pHiddenSel, unsigned fFlags, PRTGCPTR ppvGC, uint32_t *pcb)
     462VMMDECL(int) SELMToFlatBySelEx(PVM pVM, X86EFLAGS eflags, RTSEL Sel, RTGCPTR Addr, PCCPUMSELREGHID pHiddenSel, unsigned fFlags, PRTGCPTR ppvGC, uint32_t *pcb)
    463463{
    464464    PVMCPU pVCpu = VMMGetCpu(pVM);
    … …  
    476476        {
    477477            if (    pHiddenSel
    478                 &&  CPUMAreHiddenSelRegsValid(pVM))
     478                &&  CPUMAreHiddenSelRegsValid(pVCpu))
    479479                *ppvGC = (RTGCPTR)(pHiddenSel->u64Base + uFlat);
    480480            else
    … …  
    493493    /** @todo when we're in 16 bits mode, we should cut off the address as well.. */
    494494    if (    pHiddenSel
    495         &&  CPUMAreHiddenSelRegsValid(pVM))
     495        &&  CPUMAreHiddenSelRegsValid(pVCpu))
    496496    {
    497497        u1Present     = pHiddenSel->Attr.n.u1Present;
    … …  
    665665 *
    666666 * @returns VINF_SUCCESS.
    667  * @param   pVM     VM Handle.
     667 * @param   pVCpu   The Virtual CPU handle.
    668668 * @param   SelCS   Selector part.
    669669 * @param   pHidCS  The hidden CS register part. Optional.
    … …  
    671671 * @param   ppvFlat Where to store the flat address.
    672672 */
    673 DECLINLINE(int) selmValidateAndConvertCSAddrRealMode(PVM pVM, RTSEL SelCS, PCPUMSELREGHID pHidCS, RTGCPTR Addr, PRTGCPTR ppvFlat)
     673DECLINLINE(int) selmValidateAndConvertCSAddrRealMode(PVMCPU pVCpu, RTSEL SelCS, PCCPUMSELREGHID pHidCS, RTGCPTR Addr,
     674                                                     PRTGCPTR ppvFlat)
    674675{
    675676    RTGCUINTPTR uFlat = (RTGCUINTPTR)Addr & 0xffff;
    676     if (!pHidCS || !CPUMAreHiddenSelRegsValid(pVM))
     677    if (!pHidCS || !CPUMAreHiddenSelRegsValid(pVCpu))
    677678        uFlat += ((RTGCUINTPTR)SelCS << 4);
    678679    else
    … …  
    690691 * @returns VBox status code.
    691692 * @param   pVM     VM Handle.
     693 * @param   pVCpu   The virtual CPU handle.
    692694 * @param   SelCPL  Current privilege level. Get this from SS - CS might be conforming!
    693695 *                  A full selector can be passed, we'll only use the RPL part.
    … …  
    697699 * @param   pcBits  Where to store the segment bitness (16/32/64). Optional.
    698700 */
    699 DECLINLINE(int) selmValidateAndConvertCSAddrStd(PVM pVM, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr, PRTGCPTR ppvFlat, uint32_t *pcBits)
    700 {
    701     Assert(!CPUMAreHiddenSelRegsValid(pVM));
    702 
     701DECLINLINE(int) selmValidateAndConvertCSAddrStd(PVM pVM, PVMCPU pVCpu, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr,
     702                                                PRTGCPTR ppvFlat, uint32_t *pcBits)
     703{
    703704    /** @todo validate limit! */
    704705    X86DESC    Desc;
    … …  
    771772 * @param   ppvFlat Where to store the flat address.
    772773 */
    773 DECLINLINE(int) selmValidateAndConvertCSAddrHidden(PVMCPU pVCpu, RTSEL SelCPL, RTSEL SelCS, PCPUMSELREGHID pHidCS, RTGCPTR Addr, PRTGCPTR ppvFlat)
     774DECLINLINE(int) selmValidateAndConvertCSAddrHidden(PVMCPU pVCpu, RTSEL SelCPL, RTSEL SelCS, PCCPUMSELREGHID pHidCS,
     775                                                   RTGCPTR Addr, PRTGCPTR ppvFlat)
    774776{
    775777    /*
    … …  
    849851    {
    850852        *pcBits = 16;
    851         return selmValidateAndConvertCSAddrRealMode(pVM, SelCS, NULL, Addr, ppvFlat);
    852     }
    853     return selmValidateAndConvertCSAddrStd(pVM, SelCPL, SelCS, Addr, ppvFlat, pcBits);
     853        return selmValidateAndConvertCSAddrRealMode(pVCpu, SelCS, NULL, Addr, ppvFlat);
     854    }
     855    Assert(!CPUMAreHiddenSelRegsValid(pVCpu));
     856    return selmValidateAndConvertCSAddrStd(pVM, pVCpu, SelCPL, SelCS, Addr, ppvFlat, pcBits);
    854857}
    855858#endif /* IN_RC */
    … …  
    869872 * @param   ppvFlat      Where to store the flat address.
    870873 */
    871 VMMDECL(int) SELMValidateAndConvertCSAddr(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, CPUMSELREGHID *pHiddenCSSel, RTGCPTR Addr, PRTGCPTR ppvFlat)
     874VMMDECL(int) SELMValidateAndConvertCSAddr(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, PCCPUMSELREGHID pHiddenCSSel,
     875                                          RTGCPTR Addr, PRTGCPTR ppvFlat)
    872876{
    873877    PVMCPU pVCpu = VMMGetCpu(pVM);
    … …  
    875879    if (    eflags.Bits.u1VM
    876880        ||  CPUMIsGuestInRealMode(pVCpu))
    877         return selmValidateAndConvertCSAddrRealMode(pVM, SelCS, pHiddenCSSel, Addr, ppvFlat);
     881        return selmValidateAndConvertCSAddrRealMode(pVCpu, SelCS, pHiddenCSSel, Addr, ppvFlat);
    878882
    879883#ifdef IN_RING0
    880     Assert(CPUMAreHiddenSelRegsValid(pVM));
     884    Assert(CPUMAreHiddenSelRegsValid(pVCpu));
    881885#else
    882886    /** @todo when we're in 16 bits mode, we should cut off the address as well? (like in selmValidateAndConvertCSAddrRealMode) */
    883     if (!CPUMAreHiddenSelRegsValid(pVM))
    884         return selmValidateAndConvertCSAddrStd(pVM, SelCPL, SelCS, Addr, ppvFlat, NULL);
     887    if (!CPUMAreHiddenSelRegsValid(pVCpu) || !pHiddenCSSel)
     888        return selmValidateAndConvertCSAddrStd(pVM, pVCpu, SelCPL, SelCS, Addr, ppvFlat, NULL);
    885889#endif
    886890    return selmValidateAndConvertCSAddrHidden(pVCpu, SelCPL, SelCS, pHiddenCSSel, Addr, ppvFlat);
    … …  
    894898 * @returns DISCPUMODE according to the selector type (16, 32 or 64 bits)
    895899 * @param   pVM     VM Handle.
     900 * @param   pVCpu   The virtual CPU handle.
    896901 * @param   Sel     The selector.
    897902 */
    898 static DISCPUMODE selmGetCpuModeFromSelector(PVM pVM, RTSEL Sel)
    899 {
    900     Assert(!CPUMAreHiddenSelRegsValid(pVM));
     903static DISCPUMODE selmGetCpuModeFromSelector(PVM pVM, PVMCPU pVCpu, RTSEL Sel)
     904{
     905    Assert(!CPUMAreHiddenSelRegsValid(pVCpu));
    901906
    902907    /** @todo validate limit! */
    … …  
    924929 * @param   pHiddenSel The hidden selector register.
    925930 */
    926 VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVM pVM, X86EFLAGS eflags, RTSEL Sel, CPUMSELREGHID *pHiddenSel)
     931VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVM pVM, X86EFLAGS eflags, RTSEL Sel, PCCPUMSELREGHID pHiddenSel)
    927932{
    928933    PVMCPU pVCpu = VMMGetCpu(pVM);
    929934#ifdef IN_RING0
    930     Assert(CPUMAreHiddenSelRegsValid(pVM));
     935    Assert(CPUMAreHiddenSelRegsValid(pVCpu));
    931936#else  /* !IN_RING0 */
    932     if (!CPUMAreHiddenSelRegsValid(pVM))
     937    if (!CPUMAreHiddenSelRegsValid(pVCpu))
    933938    {
    934939        /*
    … …  
    939944            return CPUMODE_16BIT;
    940945
    941         return selmGetCpuModeFromSelector(pVM, Sel);
     946        return selmGetCpuModeFromSelector(pVM, pVCpu, Sel);
    942947    }
    943948#endif /* !IN_RING0 */
    … …  
    947952
    948953    /* Else compatibility or 32 bits mode. */
    949     return (pHiddenSel->Attr.n.u1DefBig) ? CPUMODE_32BIT : CPUMODE_16BIT;
     954    return pHiddenSel->Attr.n.u1DefBig ? CPUMODE_32BIT : CPUMODE_16BIT;
    950955}
    951956

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

    r29250 r30263  
    358358 * @internal
    359359 */
    360 VMMDECL(int) TRPMForwardTrap(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t iGate, uint32_t opsize, TRPMERRORCODE enmError, TRPMEVENT enmType, int32_t iOrgTrap)
     360VMMDECL(int) TRPMForwardTrap(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t iGate, uint32_t opsize,
     361                             TRPMERRORCODE enmError, TRPMEVENT enmType, int32_t iOrgTrap)
    361362{
    362363#ifdef TRPM_FORWARD_TRAPS_IN_GC

  • trunk/src/VBox/VMM/VMMGC/TRPMGC.cpp

    r28800 r30263  
    175175     */
    176176    RTGCPTR PC;
    177     int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &PC);
     177    int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     178                                          (RTGCPTR)pRegFrame->eip, &PC);
    178179    if (rc == VINF_SUCCESS)
    179180    {

  • trunk/src/VBox/VMM/VMMGC/TRPMGCHandlers.cpp

    r30160 r30263  
    380380         */
    381381        RTGCPTR PC;
    382         rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &PC);
     382        rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     383                                          (RTGCPTR)pRegFrame->eip, &PC);
    383384        if (RT_FAILURE(rc))
    384385        {
    … …  
    507508     */
    508509    RTGCPTR GCPtr;
    509     if (SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &GCPtr) == VINF_SUCCESS)
     510    if (   SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     511                                        (RTGCPTR)pRegFrame->eip, &GCPtr)
     512        == VINF_SUCCESS)
    510513    {
    511514        uint8_t *pu8Code = (uint8_t *)(uintptr_t)GCPtr;

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

    r30181 r30263  
    27422742    {
    27432743        RTGCPTR pbCode;
    2744         int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid, (RTGCPTR)pRegFrame->rip, &pbCode);
     2744        int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
     2745                                              &pRegFrame->csHid, (RTGCPTR)pRegFrame->rip, &pbCode);
    27452746        if (RT_SUCCESS(rc))
    27462747        {

  • trunk/src/recompiler/VBoxREMWrapper.cpp

    r29333 r30263  
    545545};
    546546
     547static const REMPARMDESC g_aArgsCPUMR3RemEnter[] =
     548{
     549    { REMPARMDESC_FLAGS_INT,        sizeof(PVMCPU),             NULL },
     550    { REMPARMDESC_FLAGS_INT,        sizeof(uint32_t *),         NULL }
     551};
     552
     553static const REMPARMDESC g_aArgsCPUMR3RemLeave[] =
     554{
     555    { REMPARMDESC_FLAGS_INT,        sizeof(PVMCPU),             NULL },
     556    { REMPARMDESC_FLAGS_INT,        sizeof(bool),               NULL }
     557};
     558
    547559static const REMPARMDESC g_aArgsCPUMSetChangedFlags[] =
    548560{
    … …  
    11701182static REMFNDESC g_aVMMImports[] =
    11711183{
    1172     { "CPUMAreHiddenSelRegsValid",              VMM_FN(CPUMAreHiddenSelRegsValid),      &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(bool),       NULL },
    1173     { "CPUMGetAndClearChangedFlagsREM",         VMM_FN(CPUMGetAndClearChangedFlagsREM), &g_aArgsVM[0],                              RT_ELEMENTS(g_aArgsVM),                                REMFNDESC_FLAGS_RET_INT,    sizeof(unsigned),   NULL },
     1184    { "CPUMAreHiddenSelRegsValid",              VMM_FN(CPUMAreHiddenSelRegsValid),      &g_aArgsVMCPU[0],                           RT_ELEMENTS(g_aArgsVMCPU),                             REMFNDESC_FLAGS_RET_INT,    sizeof(bool),       NULL },
     1185    { "CPUMR3RemEnter",                         VMM_FN(CPUMR3RemEnter),                 &g_aArgsCPUMR3RemEnter[0],                  RT_ELEMENTS(g_aArgsCPUMR3RemEnter),                    REMFNDESC_FLAGS_RET_INT,    sizeof(uint32_t),   NULL },
     1186    { "CPUMR3RemLeave",                         VMM_FN(CPUMR3RemLeave),                 &g_aArgsCPUMR3RemLeave[0],                  RT_ELEMENTS(g_aArgsCPUMR3RemLeave),                    REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    11741187    { "CPUMSetChangedFlags",                    VMM_FN(CPUMSetChangedFlags),            &g_aArgsCPUMSetChangedFlags[0],             RT_ELEMENTS(g_aArgsCPUMSetChangedFlags),               REMFNDESC_FLAGS_RET_VOID,   0,                  NULL },
    11751188    { "CPUMGetGuestCPL",                        VMM_FN(CPUMGetGuestCPL),                &g_aArgsCPUMGetGuestCpl[0],                 RT_ELEMENTS(g_aArgsCPUMGetGuestCpl),                   REMFNDESC_FLAGS_RET_INT,    sizeof(unsigned),   NULL },

  • trunk/src/recompiler/VBoxRecompiler.c

    r29333 r30263  
    17981798    TRPMEVENT               enmType;
    17991799    uint8_t                 u8TrapNo;
     1800    uint32_t                uCpl;
    18001801    int                     rc;
    18011802
    … …  
    18051806    pVM->rem.s.Env.pVCpu = pVCpu;
    18061807    pCtx = pVM->rem.s.pCtx = CPUMQueryGuestCtxPtr(pVCpu);
    1807     fHiddenSelRegsValid = CPUMAreHiddenSelRegsValid(pVM);
     1808    fHiddenSelRegsValid = CPUMAreHiddenSelRegsValid(pVCpu); /// @todo move this down and use fFlags.
    18081809
    18091810    Assert(!pVM->rem.s.fInREM);
    … …  
    19271928     * Registers which are rarely changed and require special handling / order when changed.
    19281929     */
    1929     fFlags = CPUMGetAndClearChangedFlagsREM(pVCpu);
    1930     LogFlow(("CPUMGetAndClearChangedFlagsREM %x\n", fFlags));
     1930    fFlags = CPUMR3RemEnter(pVCpu, &uCpl);
     1931    LogFlow(("CPUMR3RemEnter %x %x\n", fFlags, uCpl));
    19311932    if (fFlags & (  CPUM_CHANGED_CR4  | CPUM_CHANGED_CR3  | CPUM_CHANGED_CR0
    19321933                  | CPUM_CHANGED_GDTR | CPUM_CHANGED_IDTR | CPUM_CHANGED_LDTR
    … …  
    20412042
    20422043        /* Set current CPL */
    2043         cpu_x86_set_cpl(&pVM->rem.s.Env, CPUMGetGuestCPL(pVCpu, CPUMCTX2CORE(pCtx)));
     2044        cpu_x86_set_cpl(&pVM->rem.s.Env, uCpl);
    20442045
    20452046        cpu_x86_load_seg_cache(&pVM->rem.s.Env, R_CS, pCtx->cs, pCtx->csHid.u64Base, pCtx->csHid.u32Limit, (pCtx->csHid.Attr.u << 8) & 0xFFFFFF);
    … …  
    20572058            Log2(("REMR3State: SS changed from %04x to %04x!\n", pVM->rem.s.Env.segs[R_SS].selector, pCtx->ss));
    20582059
    2059             cpu_x86_set_cpl(&pVM->rem.s.Env, CPUMGetGuestCPL(pVCpu, CPUMCTX2CORE(pCtx)));
     2060            cpu_x86_set_cpl(&pVM->rem.s.Env, uCpl);
    20602061            sync_seg(&pVM->rem.s.Env, R_SS, pCtx->ss);
    20612062#ifdef VBOX_WITH_STATISTICS
    … …  
    24752476     * We're not longer in REM mode.
    24762477     */
     2478    CPUMR3RemLeave(pVCpu,
     2479                      HWACCMIsEnabled(pVM)
     2480                   || (  pVM->rem.s.Env.segs[R_SS].newselector
     2481                       | pVM->rem.s.Env.segs[R_GS].newselector
     2482                       | pVM->rem.s.Env.segs[R_FS].newselector
     2483                       | pVM->rem.s.Env.segs[R_ES].newselector
     2484                       | pVM->rem.s.Env.segs[R_DS].newselector
     2485                       | pVM->rem.s.Env.segs[R_CS].newselector) == 0
     2486                   );
    24772487    VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_EXEC_REM);
    24782488    pVM->rem.s.fInREM    = false;
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