VirtualBox

Changeset 55000 in vbox for trunk/src


Ignore:
Timestamp:
Mar 29, 2015 4:42:16 PM (10 years ago)
Author:
vboxsync
Message:

CPUMCTXCORE elimination.

Location:
trunk/src/VBox/VMM
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r54862 r55000  
    22602260 * @returns VBox status. (recompiler failure)
    22612261 * @param   pVCpu       Pointer to the VMCPU.
    2262  * @param   pCtxCore    The context core (for trap usage).
    22632262 * @see     @ref pg_raw
    22642263 */
    2265 VMM_INT_DECL(int) CPUMRawEnter(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore)
     2264VMM_INT_DECL(int) CPUMRawEnter(PVMCPU pVCpu)
    22662265{
    22672266    PVM pVM = pVCpu->CTX_SUFF(pVM);
    … …  
    22692268    Assert(!pVCpu->cpum.s.fRawEntered);
    22702269    Assert(!pVCpu->cpum.s.fRemEntered);
    2271     if (!pCtxCore)
    2272         pCtxCore = CPUMCTX2CORE(&pVCpu->cpum.s.Guest);
     2270    PCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
    22732271
    22742272    /*
    22752273     * Are we in Ring-0?
    22762274     */
    2277     if (    pCtxCore->ss.Sel
    2278         &&  (pCtxCore->ss.Sel & X86_SEL_RPL) == 0
    2279         &&  !pCtxCore->eflags.Bits.u1VM)
     2275    if (    pCtx->ss.Sel
     2276        &&  (pCtx->ss.Sel & X86_SEL_RPL) == 0
     2277        &&  !pCtx->eflags.Bits.u1VM)
    22802278    {
    22812279        /*
    22822280         * Enter execution mode.
    22832281         */
    2284         PATMRawEnter(pVM, pCtxCore);
     2282        PATMRawEnter(pVM, pCtx);
    22852283
    22862284        /*
    22872285         * Set CPL to Ring-1.
    22882286         */
    2289         pCtxCore->ss.Sel |= 1;
    2290         if (    pCtxCore->cs.Sel
    2291             &&  (pCtxCore->cs.Sel & X86_SEL_RPL) == 0)
    2292             pCtxCore->cs.Sel |= 1;
     2287        pCtx->ss.Sel |= 1;
     2288        if (    pCtx->cs.Sel
     2289            &&  (pCtx->cs.Sel & X86_SEL_RPL) == 0)
     2290            pCtx->cs.Sel |= 1;
    22932291    }
    22942292    else
    … …  
    22962294# ifdef VBOX_WITH_RAW_RING1
    22972295        if (    EMIsRawRing1Enabled(pVM)
    2298             &&  !pCtxCore->eflags.Bits.u1VM
    2299             &&  (pCtxCore->ss.Sel & X86_SEL_RPL) == 1)
     2296            &&  !pCtx->eflags.Bits.u1VM
     2297            &&  (pCtx->ss.Sel & X86_SEL_RPL) == 1)
    23002298        {
    23012299            /* Set CPL to Ring-2. */
    2302             pCtxCore->ss.Sel = (pCtxCore->ss.Sel & ~X86_SEL_RPL) | 2;
    2303             if (pCtxCore->cs.Sel && (pCtxCore->cs.Sel & X86_SEL_RPL) == 1)
    2304                 pCtxCore->cs.Sel = (pCtxCore->cs.Sel & ~X86_SEL_RPL) | 2;
     2300            pCtx->ss.Sel = (pCtx->ss.Sel & ~X86_SEL_RPL) | 2;
     2301            if (pCtx->cs.Sel && (pCtx->cs.Sel & X86_SEL_RPL) == 1)
     2302                pCtx->cs.Sel = (pCtx->cs.Sel & ~X86_SEL_RPL) | 2;
    23052303        }
    23062304# else
    2307         AssertMsg((pCtxCore->ss.Sel & X86_SEL_RPL) >= 2 || pCtxCore->eflags.Bits.u1VM,
     2305        AssertMsg((pCtx->ss.Sel & X86_SEL_RPL) >= 2 || pCtx->eflags.Bits.u1VM,
    23082306                  ("ring-1 code not supported\n"));
    23092307# endif
    … …  
    23112309         * PATM takes care of IOPL and IF flags for Ring-3 and Ring-2 code as well.
    23122310         */
    2313         PATMRawEnter(pVM, pCtxCore);
     2311        PATMRawEnter(pVM, pCtx);
    23142312    }
    23152313
    … …  
    23172315     * Assert sanity.
    23182316     */
    2319     AssertMsg((pCtxCore->eflags.u32 & X86_EFL_IF), ("X86_EFL_IF is clear\n"));
    2320     AssertReleaseMsg(pCtxCore->eflags.Bits.u2IOPL == 0,
    2321                      ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss.Sel & X86_SEL_RPL));
     2317    AssertMsg((pCtx->eflags.u32 & X86_EFL_IF), ("X86_EFL_IF is clear\n"));
     2318    AssertReleaseMsg(pCtx->eflags.Bits.u2IOPL == 0,
     2319                     ("X86_EFL_IOPL=%d CPL=%d\n", pCtx->eflags.Bits.u2IOPL, pCtx->ss.Sel & X86_SEL_RPL));
    23222320    Assert((pVCpu->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)) == (X86_CR0_PG | X86_CR0_PE | X86_CR0_WP));
    23232321
    2324     pCtxCore->eflags.u32        |= X86_EFL_IF; /* paranoia */
     2322    pCtx->eflags.u32        |= X86_EFL_IF; /* paranoia */
    23252323
    23262324    pVCpu->cpum.s.fRawEntered = true;
    … …  
    23372335 * @param   pVCpu       Pointer to the VMCPU.
    23382336 * @param   rc          Raw mode return code
    2339  * @param   pCtxCore    The context core (for trap usage).
    23402337 * @see     @ref pg_raw
    23412338 */
    2342 VMM_INT_DECL(int) CPUMRawLeave(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, int rc)
     2339VMM_INT_DECL(int) CPUMRawLeave(PVMCPU pVCpu, int rc)
    23432340{
    23442341    PVM pVM = pVCpu->CTX_SUFF(pVM);
    … …  
    23532350
    23542351    PCPUMCTX pCtx = &pVCpu->cpum.s.Guest;
    2355     if (!pCtxCore)
    2356         pCtxCore = CPUMCTX2CORE(pCtx);
    2357     Assert(pCtxCore->eflags.Bits.u1VM || (pCtxCore->ss.Sel & X86_SEL_RPL));
    2358     AssertMsg(pCtxCore->eflags.Bits.u1VM || pCtxCore->eflags.Bits.u2IOPL < (unsigned)(pCtxCore->ss.Sel & X86_SEL_RPL),
    2359               ("X86_EFL_IOPL=%d CPL=%d\n", pCtxCore->eflags.Bits.u2IOPL, pCtxCore->ss.Sel & X86_SEL_RPL));
     2352    Assert(pCtx->eflags.Bits.u1VM || (pCtx->ss.Sel & X86_SEL_RPL));
     2353    AssertMsg(pCtx->eflags.Bits.u1VM || pCtx->eflags.Bits.u2IOPL < (unsigned)(pCtx->ss.Sel & X86_SEL_RPL),
     2354              ("X86_EFL_IOPL=%d CPL=%d\n", pCtx->eflags.Bits.u2IOPL, pCtx->ss.Sel & X86_SEL_RPL));
    23602355
    23612356    /*
    23622357     * Are we executing in raw ring-1?
    23632358     */
    2364     if (    (pCtxCore->ss.Sel & X86_SEL_RPL) == 1
    2365         &&  !pCtxCore->eflags.Bits.u1VM)
     2359    if (    (pCtx->ss.Sel & X86_SEL_RPL) == 1
     2360        &&  !pCtx->eflags.Bits.u1VM)
    23662361    {
    23672362        /*
    23682363         * Leave execution mode.
    23692364         */
    2370         PATMRawLeave(pVM, pCtxCore, rc);
     2365        PATMRawLeave(pVM, pCtx, rc);
    23712366        /* Not quite sure if this is really required, but shouldn't harm (too much anyways). */
    23722367        /** @todo See what happens if we remove this. */
    2373         if ((pCtxCore->ds.Sel & X86_SEL_RPL) == 1)
    2374             pCtxCore->ds.Sel &= ~X86_SEL_RPL;
    2375         if ((pCtxCore->es.Sel & X86_SEL_RPL) == 1)
    2376             pCtxCore->es.Sel &= ~X86_SEL_RPL;
    2377         if ((pCtxCore->fs.Sel & X86_SEL_RPL) == 1)
    2378             pCtxCore->fs.Sel &= ~X86_SEL_RPL;
    2379         if ((pCtxCore->gs.Sel & X86_SEL_RPL) == 1)
    2380             pCtxCore->gs.Sel &= ~X86_SEL_RPL;
     2368        if ((pCtx->ds.Sel & X86_SEL_RPL) == 1)
     2369            pCtx->ds.Sel &= ~X86_SEL_RPL;
     2370        if ((pCtx->es.Sel & X86_SEL_RPL) == 1)
     2371            pCtx->es.Sel &= ~X86_SEL_RPL;
     2372        if ((pCtx->fs.Sel & X86_SEL_RPL) == 1)
     2373            pCtx->fs.Sel &= ~X86_SEL_RPL;
     2374        if ((pCtx->gs.Sel & X86_SEL_RPL) == 1)
     2375            pCtx->gs.Sel &= ~X86_SEL_RPL;
    23812376
    23822377        /*
    23832378         * Ring-1 selector => Ring-0.
    23842379         */
    2385         pCtxCore->ss.Sel &= ~X86_SEL_RPL;
    2386         if ((pCtxCore->cs.Sel & X86_SEL_RPL) == 1)
    2387             pCtxCore->cs.Sel &= ~X86_SEL_RPL;
     2380        pCtx->ss.Sel &= ~X86_SEL_RPL;
     2381        if ((pCtx->cs.Sel & X86_SEL_RPL) == 1)
     2382            pCtx->cs.Sel &= ~X86_SEL_RPL;
    23882383    }
    23892384    else
    … …  
    23922387         * PATM is taking care of the IOPL and IF flags for us.
    23932388         */
    2394         PATMRawLeave(pVM, pCtxCore, rc);
    2395         if (!pCtxCore->eflags.Bits.u1VM)
     2389        PATMRawLeave(pVM, pCtx, rc);
     2390        if (!pCtx->eflags.Bits.u1VM)
    23962391        {
    23972392# ifdef VBOX_WITH_RAW_RING1
    23982393            if (    EMIsRawRing1Enabled(pVM)
    2399                 &&  (pCtxCore->ss.Sel & X86_SEL_RPL) == 2)
     2394                &&  (pCtx->ss.Sel & X86_SEL_RPL) == 2)
    24002395            {
    24012396                /* Not quite sure if this is really required, but shouldn't harm (too much anyways). */
    24022397                /** @todo See what happens if we remove this. */
    2403                 if ((pCtxCore->ds.Sel & X86_SEL_RPL) == 2)
    2404                     pCtxCore->ds.Sel = (pCtxCore->ds.Sel & ~X86_SEL_RPL) | 1;
    2405                 if ((pCtxCore->es.Sel & X86_SEL_RPL) == 2)
    2406                     pCtxCore->es.Sel = (pCtxCore->es.Sel & ~X86_SEL_RPL) | 1;
    2407                 if ((pCtxCore->fs.Sel & X86_SEL_RPL) == 2)
    2408                     pCtxCore->fs.Sel = (pCtxCore->fs.Sel & ~X86_SEL_RPL) | 1;
    2409                 if ((pCtxCore->gs.Sel & X86_SEL_RPL) == 2)
    2410                     pCtxCore->gs.Sel = (pCtxCore->gs.Sel & ~X86_SEL_RPL) | 1;
     2398                if ((pCtx->ds.Sel & X86_SEL_RPL) == 2)
     2399                    pCtx->ds.Sel = (pCtx->ds.Sel & ~X86_SEL_RPL) | 1;
     2400                if ((pCtx->es.Sel & X86_SEL_RPL) == 2)
     2401                    pCtx->es.Sel = (pCtx->es.Sel & ~X86_SEL_RPL) | 1;
     2402                if ((pCtx->fs.Sel & X86_SEL_RPL) == 2)
     2403                    pCtx->fs.Sel = (pCtx->fs.Sel & ~X86_SEL_RPL) | 1;
     2404                if ((pCtx->gs.Sel & X86_SEL_RPL) == 2)
     2405                    pCtx->gs.Sel = (pCtx->gs.Sel & ~X86_SEL_RPL) | 1;
    24112406
    24122407                /*
    24132408                 * Ring-2 selector => Ring-1.
    24142409                 */
    2415                 pCtxCore->ss.Sel = (pCtxCore->ss.Sel & ~X86_SEL_RPL) | 1;
    2416                 if ((pCtxCore->cs.Sel & X86_SEL_RPL) == 2)
    2417                     pCtxCore->cs.Sel = (pCtxCore->cs.Sel & ~X86_SEL_RPL) | 1;
     2410                pCtx->ss.Sel = (pCtx->ss.Sel & ~X86_SEL_RPL) | 1;
     2411                if ((pCtx->cs.Sel & X86_SEL_RPL) == 2)
     2412                    pCtx->cs.Sel = (pCtx->cs.Sel & ~X86_SEL_RPL) | 1;
    24182413            }
    24192414            else
    … …  
    24212416# endif
    24222417                /** @todo See what happens if we remove this. */
    2423                 if ((pCtxCore->ds.Sel & X86_SEL_RPL) == 1)
    2424                     pCtxCore->ds.Sel &= ~X86_SEL_RPL;
    2425                 if ((pCtxCore->es.Sel & X86_SEL_RPL) == 1)
    2426                     pCtxCore->es.Sel &= ~X86_SEL_RPL;
    2427                 if ((pCtxCore->fs.Sel & X86_SEL_RPL) == 1)
    2428                     pCtxCore->fs.Sel &= ~X86_SEL_RPL;
    2429                 if ((pCtxCore->gs.Sel & X86_SEL_RPL) == 1)
    2430                     pCtxCore->gs.Sel &= ~X86_SEL_RPL;
     2418                if ((pCtx->ds.Sel & X86_SEL_RPL) == 1)
     2419                    pCtx->ds.Sel &= ~X86_SEL_RPL;
     2420                if ((pCtx->es.Sel & X86_SEL_RPL) == 1)
     2421                    pCtx->es.Sel &= ~X86_SEL_RPL;
     2422                if ((pCtx->fs.Sel & X86_SEL_RPL) == 1)
     2423                    pCtx->fs.Sel &= ~X86_SEL_RPL;
     2424                if ((pCtx->gs.Sel & X86_SEL_RPL) == 1)
     2425                    pCtx->gs.Sel &= ~X86_SEL_RPL;
    24312426# ifdef VBOX_WITH_RAW_RING1
    24322427            }
    … …  
    24502445#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    24512446    if (pVCpu->cpum.s.fRawEntered)
    2452         PATMRawSetEFlags(pVCpu->CTX_SUFF(pVM), CPUMCTX2CORE(&pVCpu->cpum.s.Guest), fEfl);
     2447        PATMRawSetEFlags(pVCpu->CTX_SUFF(pVM), &pVCpu->cpum.s.Guest, fEfl);
    24532448    else
    24542449#endif
    … …  
    24672462#ifdef VBOX_WITH_RAW_MODE_NOT_R0
    24682463    if (pVCpu->cpum.s.fRawEntered)
    2469         return PATMRawGetEFlags(pVCpu->CTX_SUFF(pVM), CPUMCTX2CORE(&pVCpu->cpum.s.Guest));
     2464        return PATMRawGetEFlags(pVCpu->CTX_SUFF(pVM), &pVCpu->cpum.s.Guest);
    24702465#endif
    24712466    return pVCpu->cpum.s.Guest.eflags.u32;

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

    r54898 r55000  
    844844                               && PATMIsPatchGCAddr(IEMCPU_TO_VM(pIemCpu), pCtx->eip);
    845845    if (!pIemCpu->fInPatchCode)
    846         CPUMRawLeave(pVCpu, CPUMCTX2CORE(pCtx), VINF_SUCCESS);
     846        CPUMRawLeave(pVCpu, VINF_SUCCESS);
    847847#endif
    848848}
    … …  
    914914                               && PATMIsPatchGCAddr(IEMCPU_TO_VM(pIemCpu), pCtx->eip);
    915915    if (!pIemCpu->fInPatchCode)
    916         CPUMRawLeave(pVCpu, CPUMCTX2CORE(pCtx), VINF_SUCCESS);
     916        CPUMRawLeave(pVCpu, VINF_SUCCESS);
    917917#endif
    918918
    … …  
    1067910679{
    1068010680    if (!pIemCpu->fInPatchCode)
    10681         CPUMRawEnter(pVCpu, CPUMCTX2CORE(pCtx));
     10681        CPUMRawEnter(pVCpu);
    1068210682    return rcStrict;
    1068310683}

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

    r54763 r55000  
    4646 *
    4747 * @param   pVM         Pointer to the VM.
    48  * @param   pCtxCore    The cpu context core.
     48 * @param   pCtx        The cpu context.
    4949 * @see     pg_raw
    5050 */
    51 VMM_INT_DECL(void) PATMRawEnter(PVM pVM, PCPUMCTXCORE pCtxCore)
     51VMM_INT_DECL(void) PATMRawEnter(PVM pVM, PCPUMCTX pCtx)
    5252{
    5353    Assert(!HMIsEnabled(pVM));
    … …  
    5757     * For all cases where it isn't, IOPL will be safe and IF will be set.
    5858     */
    59     uint32_t efl = pCtxCore->eflags.u32;
     59    uint32_t efl = pCtx->eflags.u32;
    6060    CTXSUFF(pVM->patm.s.pGCState)->uVMFlags = efl & PATM_VIRTUAL_FLAGS_MASK;
    6161
    62     AssertMsg((efl & X86_EFL_IF) || PATMShouldUseRawMode(pVM, (RTRCPTR)pCtxCore->eip),
     62    AssertMsg((efl & X86_EFL_IF) || PATMShouldUseRawMode(pVM, (RTRCPTR)pCtx->eip),
    6363              ("X86_EFL_IF is clear and PATM is disabled! (eip=%RRv eflags=%08x fPATM=%d pPATMGC=%RRv-%RRv\n",
    64                pCtxCore->eip, pCtxCore->eflags.u32, PATMIsEnabled(pVM), pVM->patm.s.pPatchMemGC,
     64               pCtx->eip, pCtx->eflags.u32, PATMIsEnabled(pVM), pVM->patm.s.pPatchMemGC,
    6565               pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem));
    6666
    67     AssertReleaseMsg(CTXSUFF(pVM->patm.s.pGCState)->fPIF || PATMIsPatchGCAddr(pVM, pCtxCore->eip),
    68                      ("fPIF=%d eip=%RRv\n", pVM->patm.s.CTXSUFF(pGCState)->fPIF, pCtxCore->eip));
     67    AssertReleaseMsg(CTXSUFF(pVM->patm.s.pGCState)->fPIF || PATMIsPatchGCAddr(pVM, pCtx->eip),
     68                     ("fPIF=%d eip=%RRv\n", pVM->patm.s.CTXSUFF(pGCState)->fPIF, pCtx->eip));
    6969
    7070    efl &= ~PATM_VIRTUAL_FLAGS_MASK;
    7171    efl |= X86_EFL_IF;
    72     pCtxCore->eflags.u32 = efl;
     72    pCtx->eflags.u32 = efl;
    7373
    7474#ifdef IN_RING3
    … …  
    121121 *
    122122 * @param   pVM         Pointer to the VM.
    123  * @param   pCtxCore    The cpu context core.
     123 * @param   pCtx        The cpu context.
    124124 * @param   rawRC       Raw mode return code
    125125 * @see     @ref pg_raw
    126126 */
    127 VMM_INT_DECL(void) PATMRawLeave(PVM pVM, PCPUMCTXCORE pCtxCore, int rawRC)
     127VMM_INT_DECL(void) PATMRawLeave(PVM pVM, PCPUMCTX pCtx, int rawRC)
    128128{
    129129    Assert(!HMIsEnabled(pVM));
    130     bool fPatchCode = PATMIsPatchGCAddr(pVM, pCtxCore->eip);
     130    bool fPatchCode = PATMIsPatchGCAddr(pVM, pCtx->eip);
    131131
    132132    /*
    133133     * We will only be called if PATMRawEnter was previously called.
    134134     */
    135     uint32_t efl = pCtxCore->eflags.u32;
     135    uint32_t efl = pCtx->eflags.u32;
    136136    efl = (efl & ~PATM_VIRTUAL_FLAGS_MASK) | (CTXSUFF(pVM->patm.s.pGCState)->uVMFlags & PATM_VIRTUAL_FLAGS_MASK);
    137     pCtxCore->eflags.u32 = efl;
     137    pCtx->eflags.u32 = efl;
    138138    CTXSUFF(pVM->patm.s.pGCState)->uVMFlags = X86_EFL_IF;
    139139
    140     AssertReleaseMsg((efl & X86_EFL_IF) || fPatchCode || rawRC == VINF_PATM_PENDING_IRQ_AFTER_IRET || RT_FAILURE(rawRC), ("Inconsistent state at %RRv rc=%Rrc\n", pCtxCore->eip, rawRC));
    141     AssertReleaseMsg(CTXSUFF(pVM->patm.s.pGCState)->fPIF || fPatchCode || RT_FAILURE(rawRC), ("fPIF=%d eip=%RRv rc=%Rrc\n", CTXSUFF(pVM->patm.s.pGCState)->fPIF, pCtxCore->eip, rawRC));
     140    AssertReleaseMsg((efl & X86_EFL_IF) || fPatchCode || rawRC == VINF_PATM_PENDING_IRQ_AFTER_IRET || RT_FAILURE(rawRC), ("Inconsistent state at %RRv rc=%Rrc\n", pCtx->eip, rawRC));
     141    AssertReleaseMsg(CTXSUFF(pVM->patm.s.pGCState)->fPIF || fPatchCode || RT_FAILURE(rawRC), ("fPIF=%d eip=%RRv rc=%Rrc\n", CTXSUFF(pVM->patm.s.pGCState)->fPIF, pCtx->eip, rawRC));
    142142
    143143#ifdef IN_RING3
    … …  
    159159            {
    160160                PATMTRANSSTATE  enmState;
    161                 RTRCPTR         pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pCtxCore->eip, &enmState);
     161                RTRCPTR         pOrgInstrGC = PATMR3PatchToGCPtr(pVM, pCtx->eip, &enmState);
    162162
    163163                AssertRelease(pOrgInstrGC);
    … …  
    167167                {
    168168                    Assert(!patmFindActivePatchByEntrypoint(pVM, pOrgInstrGC));
    169                     Log(("Switchback from %RRv to %RRv (Psp=%x)\n", pCtxCore->eip, pOrgInstrGC, CTXSUFF(pVM->patm.s.pGCState)->Psp));
     169                    Log(("Switchback from %RRv to %RRv (Psp=%x)\n", pCtx->eip, pOrgInstrGC, CTXSUFF(pVM->patm.s.pGCState)->Psp));
    170170                    STAM_COUNTER_INC(&pVM->patm.s.StatSwitchBack);
    171                     pCtxCore->eip = pOrgInstrGC;
     171                    pCtx->eip = pOrgInstrGC;
    172172                    fPatchCode = false; /* to reset the stack ptr */
    173173
    … …  
    176176                else
    177177                {
    178                     LogFlow(("Patch address %RRv can't be interrupted (state=%d)!\n",  pCtxCore->eip, enmState));
     178                    LogFlow(("Patch address %RRv can't be interrupted (state=%d)!\n",  pCtx->eip, enmState));
    179179                    STAM_COUNTER_INC(&pVM->patm.s.StatSwitchBackFail);
    180180                }
    … …  
    182182            else
    183183            {
    184                 LogFlow(("Patch address %RRv can't be interrupted (fPIF=%d)!\n",  pCtxCore->eip, CTXSUFF(pVM->patm.s.pGCState)->fPIF));
     184                LogFlow(("Patch address %RRv can't be interrupted (fPIF=%d)!\n",  pCtx->eip, CTXSUFF(pVM->patm.s.pGCState)->fPIF));
    185185                STAM_COUNTER_INC(&pVM->patm.s.StatSwitchBackFail);
    186186            }
    … …  
    192192     * a single original guest instruction.
    193193     */
    194     AssertMsg(!fPatchCode, ("eip=%RRv\n", pCtxCore->eip));
     194    AssertMsg(!fPatchCode, ("eip=%RRv\n", pCtx->eip));
    195195#endif /* !IN_RING3 */
    196196
    197197    if (!fPatchCode)
    198198    {
    199         if (CTXSUFF(pVM->patm.s.pGCState)->GCPtrInhibitInterrupts == (RTRCPTR)pCtxCore->eip)
     199        if (CTXSUFF(pVM->patm.s.pGCState)->GCPtrInhibitInterrupts == (RTRCPTR)pCtx->eip)
    200200        {
    201             EMSetInhibitInterruptsPC(VMMGetCpu0(pVM), pCtxCore->eip);
     201            EMSetInhibitInterruptsPC(VMMGetCpu0(pVM), pCtx->eip);
    202202        }
    203203        CTXSUFF(pVM->patm.s.pGCState)->GCPtrInhibitInterrupts = 0;
    … …  
    220220 * @returns The eflags.
    221221 * @param   pVM         Pointer to the VM.
    222  * @param   pCtxCore    The context core.
    223  */
    224 VMM_INT_DECL(uint32_t) PATMRawGetEFlags(PVM pVM, PCCPUMCTXCORE pCtxCore)
     222 * @param   pCtx        The guest cpu context.
     223 */
     224VMM_INT_DECL(uint32_t) PATMRawGetEFlags(PVM pVM, PCCPUMCTX pCtx)
    225225{
    226226    Assert(!HMIsEnabled(pVM));
    227     uint32_t efl = pCtxCore->eflags.u32;
     227    uint32_t efl = pCtx->eflags.u32;
    228228    efl &= ~PATM_VIRTUAL_FLAGS_MASK;
    229229    efl |= pVM->patm.s.CTXSUFF(pGCState)->uVMFlags & PATM_VIRTUAL_FLAGS_MASK;
    … …  
    236236 *
    237237 * @param   pVM         Pointer to the VM.
    238  * @param   pCtxCore    The context core.
     238 * @param   pCtx        The guest cpu context.
    239239 * @param   efl         The new EFLAGS value.
    240240 */
    241 VMM_INT_DECL(void) PATMRawSetEFlags(PVM pVM, PCPUMCTXCORE pCtxCore, uint32_t efl)
     241VMM_INT_DECL(void) PATMRawSetEFlags(PVM pVM, PCPUMCTX pCtx, uint32_t efl)
    242242{
    243243    Assert(!HMIsEnabled(pVM));
    … …  
    245245    efl &= ~PATM_VIRTUAL_FLAGS_MASK;
    246246    efl |= X86_EFL_IF;
    247     pCtxCore->eflags.u32 = efl;
     247    pCtx->eflags.u32 = efl;
    248248}
    249249
    … …  
    478478 *
    479479 * @param   pVM         Pointer to the VM.
    480  * @param   pCtxCore    The relevant core context.
    481  * @param   pCpu        Disassembly context
    482  */
    483 VMMDECL(int) PATMSysCall(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu)
    484 {
    485     PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(VMMGetCpu0(pVM));
     480 * @param   pCtx        The relevant guest cpu context.
     481 * @param   pCpu        Disassembly state.
     482 */
     483VMMDECL(int) PATMSysCall(PVM pVM, PCPUMCTX pCtx, PDISCPUSTATE pCpu)
     484{
     485    Assert(CPUMQueryGuestCtxPtr(VMMGetCpu0(pVM)) == pCtx);
    486486    AssertReturn(!HMIsEnabled(pVM), VERR_PATM_HM_IPE);
    487487
    … …  
    489489    {
    490490        if (    pCtx->SysEnter.cs == 0
    491             ||  pRegFrame->eflags.Bits.u1VM
    492             ||  (pRegFrame->cs.Sel & X86_SEL_RPL) != 3
     491            ||  pCtx->eflags.Bits.u1VM
     492            ||  (pCtx->cs.Sel & X86_SEL_RPL) != 3
    493493            ||  pVM->patm.s.pfnSysEnterPatchGC == 0
    494494            ||  pVM->patm.s.pfnSysEnterGC != (RTRCPTR)(RTRCUINTPTR)pCtx->SysEnter.eip
    495             ||  !(PATMRawGetEFlags(pVM, pRegFrame) & X86_EFL_IF))
     495            ||  !(PATMRawGetEFlags(pVM, pCtx) & X86_EFL_IF))
    496496            goto end;
    497497
    498         Log2(("PATMSysCall: sysenter from %RRv to %RRv\n", pRegFrame->eip, pVM->patm.s.pfnSysEnterPatchGC));
     498        Log2(("PATMSysCall: sysenter from %RRv to %RRv\n", pCtx->eip, pVM->patm.s.pfnSysEnterPatchGC));
    499499        /** @todo the base and limit are forced to 0 & 4G-1 resp. We assume the selector is wide open here. */
    500500        /** @note The Intel manual suggests that the OS is responsible for this. */
    501         pRegFrame->cs.Sel      = (pCtx->SysEnter.cs & ~X86_SEL_RPL) | 1;
    502         pRegFrame->eip         = /** @todo ugly conversion! */(uint32_t)pVM->patm.s.pfnSysEnterPatchGC;
    503         pRegFrame->ss.Sel      = pRegFrame->cs.Sel + 8;     /* SysEnter.cs + 8 */
    504         pRegFrame->esp         = pCtx->SysEnter.esp;
    505         pRegFrame->eflags.u32 &= ~(X86_EFL_VM | X86_EFL_RF);
    506         pRegFrame->eflags.u32 |= X86_EFL_IF;
     501        pCtx->cs.Sel      = (pCtx->SysEnter.cs & ~X86_SEL_RPL) | 1;
     502        pCtx->eip         = /** @todo ugly conversion! */(uint32_t)pVM->patm.s.pfnSysEnterPatchGC;
     503        pCtx->ss.Sel      = pCtx->cs.Sel + 8;     /* SysEnter.cs + 8 */
     504        pCtx->esp         = pCtx->SysEnter.esp;
     505        pCtx->eflags.u32 &= ~(X86_EFL_VM | X86_EFL_RF);
     506        pCtx->eflags.u32 |= X86_EFL_IF;
    507507
    508508        /* Turn off interrupts. */
    … …  
    516516    {
    517517        if (    pCtx->SysEnter.cs == 0
    518             ||  (pRegFrame->cs.Sel & X86_SEL_RPL) != 1
    519             ||  pRegFrame->eflags.Bits.u1VM
    520             ||  !(PATMRawGetEFlags(pVM, pRegFrame) & X86_EFL_IF))
     518            ||  (pCtx->cs.Sel & X86_SEL_RPL) != 1
     519            ||  pCtx->eflags.Bits.u1VM
     520            ||  !(PATMRawGetEFlags(pVM, pCtx) & X86_EFL_IF))
    521521            goto end;
    522522
    523         Log2(("PATMSysCall: sysexit from %RRv to %RRv\n", pRegFrame->eip, pRegFrame->edx));
    524 
    525         pRegFrame->cs.Sel      = ((pCtx->SysEnter.cs + 16) & ~X86_SEL_RPL) | 3;
    526         pRegFrame->eip         = pRegFrame->edx;
    527         pRegFrame->ss.Sel      = pRegFrame->cs.Sel + 8;  /* SysEnter.cs + 24 */
    528         pRegFrame->esp         = pRegFrame->ecx;
     523        Log2(("PATMSysCall: sysexit from %RRv to %RRv\n", pCtx->eip, pCtx->edx));
     524
     525        pCtx->cs.Sel      = ((pCtx->SysEnter.cs + 16) & ~X86_SEL_RPL) | 3;
     526        pCtx->eip         = pCtx->edx;
     527        pCtx->ss.Sel      = pCtx->cs.Sel + 8;  /* SysEnter.cs + 24 */
     528        pCtx->esp         = pCtx->ecx;
    529529
    530530        STAM_COUNTER_INC(&pVM->patm.s.StatSysExit);

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

    r54737 r55000  
    129129     * Resume execution.
    130130     */
    131     CPUMRawEnter(pVCpu, NULL);
     131    CPUMRawEnter(pVCpu);
    132132    CPUMSetHyperEFlags(pVCpu, CPUMGetHyperEFlags(pVCpu) | X86_EFL_RF);
    133133    rc = VMMR3ResumeHyper(pVM, pVCpu);
    134134    Log(("emR3RawResumeHyper: cs:eip=%RTsel:%RGr efl=%RGr - returned from GC with rc=%Rrc\n", pCtx->cs.Sel, pCtx->eip, pCtx->eflags, rc));
    135     rc = CPUMRawLeave(pVCpu, NULL, rc);
     135    rc = CPUMRawLeave(pVCpu, rc);
    136136    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    137137
    … …  
    191191     * We do not start time or anything, if anything we should just do a few nanoseconds.
    192192     */
    193     CPUMRawEnter(pVCpu, NULL);
     193    CPUMRawEnter(pVCpu);
    194194    do
    195195    {
    … …  
    204204    } while (   rc == VINF_SUCCESS
    205205             || rc == VINF_EM_RAW_INTERRUPT);
    206     rc = CPUMRawLeave(pVCpu, NULL, rc);
     206    rc = CPUMRawLeave(pVCpu, rc);
    207207    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    208208
    … …  
    14291429         * and perhaps EIP) needs to be stored with PATM.
    14301430         */
    1431         rc = CPUMRawEnter(pVCpu, NULL);
     1431        rc = CPUMRawEnter(pVCpu);
    14321432        if (rc != VINF_SUCCESS)
    14331433        {
    … …  
    14531453                if (rc != VINF_SUCCESS)
    14541454                {
    1455                     rc = CPUMRawLeave(pVCpu, NULL, rc);
     1455                    rc = CPUMRawLeave(pVCpu, rc);
    14561456                    break;
    14571457                }
    … …  
    15131513         * execution FFs before doing anything else.
    15141514         */
    1515         rc = CPUMRawLeave(pVCpu, NULL, rc);
     1515        rc = CPUMRawLeave(pVCpu, rc);
    15161516        VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_RESUME_GUEST_MASK);
    15171517        if (    VM_FF_IS_PENDING(pVM, VM_FF_HIGH_PRIORITY_POST_MASK)

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

    r51726 r55000  
    824824    else if (!strcmp(pszSymbol, "g_TRPMCPU"))
    825825        *pRCPtrValue = VM_RC_ADDR(pVM, &pVM->aCpus[0].trpm);
     826    else if (!strcmp(pszSymbol, "g_trpmGuestCtx"))
     827    {
     828        PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(VMMGetCpuById(pVM, 0));
     829        *pRCPtrValue = VM_RC_ADDR(pVM, pCtx);
     830    }
     831    else if (!strcmp(pszSymbol, "g_trpmHyperCtx"))
     832    {
     833        PCPUMCTX pCtx = CPUMGetHyperCtxPtr(VMMGetCpuById(pVM, 0));
     834        *pRCPtrValue = VM_RC_ADDR(pVM, pCtx);
     835    }
    826836    else if (!strcmp(pszSymbol, "g_trpmGuestCtxCore"))
    827837    {

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

    r53466 r55000  
    824824        case OP_SYSEXIT:
    825825        case OP_SYSRET:
    826             rc = PATMSysCall(pVM, pRegFrame, pCpu);
     826            rc = PATMSysCall(pVM, CPUMCTX_FROM_CORE(pRegFrame), pCpu);
    827827            TRPM_EXIT_DBG_HOOK(0xd);
    828828            return trpmGCExitTrap(pVM, pVCpu, rc, pRegFrame);
    … …  
    928928        case OP_SYSENTER:
    929929#ifdef PATM_EMULATE_SYSENTER
    930             rc = PATMSysCall(pVM, pRegFrame, pCpu);
     930            rc = PATMSysCall(pVM, CPUMCTX_FROM_CORE(pRegFrame), pCpu);
    931931            if (rc == VINF_SUCCESS)
    932932            {
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