VirtualBox

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


Ignore:
Timestamp:
Aug 15, 2019 7:29:37 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
132736
Message:

VMM,++: Refactoring code to use VMMC & VMMCPUCC. bugref:9217

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

Legend:

Unmodified
Added
Removed

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

    r80253 r80281  
    847847    uValue &= ~((UINT64_C(0x1f) << 40) | RT_BIT_64(46));
    848848
    849     PVM      pVM            = pVCpu->CTX_SUFF(pVM);
     849    PVMCC    pVM            = pVCpu->CTX_SUFF(pVM);
    850850    uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
    851851    uint64_t uTscHz         = TMCpuTicksPerSecond(pVM);
    … …  
    18001800
    18011801    uint64_t uValue;
    1802     PVM      pVM            = pVCpu->CTX_SUFF(pVM);
     1802    PVMCC    pVM            = pVCpu->CTX_SUFF(pVM);
    18031803    uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
    18041804    if (pVM->cpum.s.GuestFeatures.uModel >= 2)
    … …  
    18971897
    18981898    /* Just indicate a fixed TSC, no turbo boost, no programmable anything. */
    1899     PVM      pVM            = pVCpu->CTX_SUFF(pVM);
     1899    PVMCC    pVM            = pVCpu->CTX_SUFF(pVM);
    19001900    uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
    19011901    uint64_t uTscHz         = TMCpuTicksPerSecond(pVM);
    … …  
    19201920    uint64_t uValue = pRange->uValue & ~UINT64_C(0x1ff00);
    19211921
    1922     PVM      pVM            = pVCpu->CTX_SUFF(pVM);
     1922    PVMCC    pVM            = pVCpu->CTX_SUFF(pVM);
    19231923    uint64_t uScalableBusHz = CPUMGetGuestScalableBusFrequency(pVM);
    19241924    uint64_t uTscHz         = TMCpuTicksPerSecond(pVM);

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

    r80253 r80281  
    308308 * @thread  EMT
    309309 */
    310 VMM_INT_DECL(int) EMUnhaltAndWakeUp(PVM pVM, PVMCPU pVCpuDst)
     310VMM_INT_DECL(int) EMUnhaltAndWakeUp(PVMCC pVM, PVMCPUCC pVCpuDst)
    311311{
    312312    /*
    … …  
    327327
    328328#elif defined(IN_RING3)
    329     int rc = SUPR3CallVMMR0(pVM->pVMR0, pVCpuDst->idCpu, VMMR0_DO_GVMM_SCHED_WAKE_UP, NULL /* pvArg */);
     329    int rc = SUPR3CallVMMR0(VMCC_GET_VMR0_FOR_CALL(pVM), pVCpuDst->idCpu, VMMR0_DO_GVMM_SCHED_WAKE_UP, NULL /* pvArg */);
    330330    AssertRC(rc);
    331331
    … …  
    972972static DECLCALLBACK(int) emReadBytes(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
    973973{
    974     PVMCPU      pVCpu    = (PVMCPU)pDis->pvUser;
     974    PVMCPUCC    pVCpu    = (PVMCPUCC)pDis->pvUser;
    975975    RTUINTPTR   uSrcAddr = pDis->uInstrAddr + offInstr;
    976976
    … …  
    10251025 * @param   pcbInstr        Where to return the instruction size. (optional)
    10261026 */
    1027 VMM_INT_DECL(int) EMInterpretDisasCurrent(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, unsigned *pcbInstr)
     1027VMM_INT_DECL(int) EMInterpretDisasCurrent(PVMCC pVM, PVMCPUCC pVCpu, PDISCPUSTATE pDis, unsigned *pcbInstr)
    10281028{
    10291029    PCPUMCTXCORE pCtxCore = CPUMCTX2CORE(CPUMQueryGuestCtxPtr(pVCpu));
    … …  
    10601060 * @param   pcbInstr        Where to return the instruction size. (optional)
    10611061 */
    1062 VMM_INT_DECL(int) EMInterpretDisasOneEx(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtrInstr, PCCPUMCTXCORE pCtxCore,
     1062VMM_INT_DECL(int) EMInterpretDisasOneEx(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINTPTR GCPtrInstr, PCCPUMCTXCORE pCtxCore,
    10631063                                        PDISCPUSTATE pDis, unsigned *pcbInstr)
    10641064{
    … …  
    10931093 *          to worry about e.g. invalid modrm combinations (!)
    10941094 */
    1095 VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstruction(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
     1095VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstruction(PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
    10961096{
    10971097    Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
    … …  
    11281128 *          to worry about e.g. invalid modrm combinations (!)
    11291129 */
    1130 VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstructionEx(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbWritten)
     1130VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstructionEx(PVMCPUCC pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbWritten)
    11311131{
    11321132    LogFlow(("EMInterpretInstructionEx %RGv fault %RGv\n", (RTGCPTR)pRegFrame->rip, pvFault));
    … …  
    11711171 *          Make sure this can't happen!! (will add some assertions/checks later)
    11721172 */
    1173 VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstructionDisasState(PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame,
     1173VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstructionDisasState(PVMCPUCC pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame,
    11741174                                                            RTGCPTR pvFault, EMCODETYPE enmCodeType)
    11751175{

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

    r80268 r80281  
    241241 * @param   pVM         The cross context VM structure.
    242242 */
    243 VMM_INT_DECL(bool) GIMIsParavirtTscEnabled(PVM pVM)
     243VMM_INT_DECL(bool) GIMIsParavirtTscEnabled(PVMCC pVM)
    244244{
    245245    switch (pVM->gim.s.enmProviderId)

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

    r80268 r80281  
    104104            if (uHyperArg1 < pVM->cCpus)
    105105            {
    106                 PVMCPU pVCpuDst = pVM->CTX_SUFF(apCpus)[uHyperArg1];  /* ASSUMES pVCpu index == ApicId of the VCPU. */
     106                PVMCPUCC pVCpuDst = VMCC_GET_CPU(pVM, uHyperArg1); /* ASSUMES pVCpu index == ApicId of the VCPU. */
    107107                EMUnhaltAndWakeUp(pVM, pVCpuDst);
    108108                uHyperRet = KVM_HYPERCALL_RET_SUCCESS;
    … …  
    231231{
    232232    NOREF(pRange);
    233     PVM        pVM  = pVCpu->CTX_SUFF(pVM);
     233    PVMCC      pVM  = pVCpu->CTX_SUFF(pVM);
    234234    PGIMKVMCPU pKvmCpu = &pVCpu->gim.s.u.KvmCpu;
    235235
    … …  
    439439 * @thread  EMT(pVCpu).
    440440 */
    441 VMM_INT_DECL(VBOXSTRICTRC) gimKvmXcptUD(PVM pVM, PVMCPUCC pVCpu, PCPUMCTX pCtx, PDISCPUSTATE pDis, uint8_t *pcbInstr)
     441VMM_INT_DECL(VBOXSTRICTRC) gimKvmXcptUD(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTX pCtx, PDISCPUSTATE pDis, uint8_t *pcbInstr)
    442442{
    443443    VMCPU_ASSERT_EMT(pVCpu);

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

    r80268 r80281  
    323323 *
    324324 * @returns @c true if it is suitable, @c false otherwise.
     325 * @param   pVM     The cross context VM structure.
    325326 * @param   pVCpu   The cross context virtual CPU structure.
    326327 * @param   pCtx    Pointer to the guest CPU context.
    … …  
    329330 *          pVCpu->cpum.GstCtx.
    330331 */
    331 VMMDECL(bool) HMCanExecuteGuest(PVMCPUCC pVCpu, PCCPUMCTX pCtx)
    332 {
    333     PVM pVM = pVCpu->CTX_SUFF(pVM);
     332VMMDECL(bool) HMCanExecuteGuest(PVMCC pVM, PVMCPUCC pVCpu, PCCPUMCTX pCtx)
     333{
    334334    Assert(HMIsEnabled(pVM));
    335335
    … …  
    380380 * @param   GCVirt      Page to invalidate.
    381381 */
    382 VMM_INT_DECL(int) HMInvalidatePage(PVMCPU pVCpu, RTGCPTR GCVirt)
     382VMM_INT_DECL(int) HMInvalidatePage(PVMCPUCC pVCpu, RTGCPTR GCVirt)
    383383{
    384384    STAM_COUNTER_INC(&pVCpu->hm.s.StatFlushPageManual);
    … …  
    514514    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    515515    {
    516         PVMCPU pVCpu = VMCC_GET_CPU(pVM, idCpu);
     516        PVMCPUCC pVCpu = VMCC_GET_CPU(pVM, idCpu);
    517517
    518518        /* Nothing to do if a TLB flush is already pending; the VCPU should
    … …  
    551551    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
    552552    {
    553         PVMCPU pVCpu = VMCC_GET_CPU(pVM, idCpu);
     553        PVMCPUCC pVCpu = VMCC_GET_CPU(pVM, idCpu);
    554554
    555555        /* Nothing to do if a TLB flush is already pending; the VCPU should
    … …  
    702702 * @param   pVM         The cross context VM structure.
    703703 */
    704 VMM_INT_DECL(bool) HMHasPendingIrq(PVM pVM)
    705 {
    706     PVMCPU pVCpu = VMMGetCpu(pVM);
     704VMM_INT_DECL(bool) HMHasPendingIrq(PVMCC pVM)
     705{
     706    PVMCPUCC pVCpu = VMMGetCpu(pVM);
    707707    return !!pVCpu->hm.s.Event.fPending;
    708708}

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

    r80268 r80281  
    667667 *          state, make sure REM (which supplies a partial state) is updated.
    668668 */
    669 VMM_INT_DECL(bool) HMCanExecuteVmxGuest(PVMCC pVM, PVMCPU pVCpu, PCCPUMCTX pCtx)
     669VMM_INT_DECL(bool) HMCanExecuteVmxGuest(PVMCC pVM, PVMCPUCC pVCpu, PCCPUMCTX pCtx)
    670670{
    671671    Assert(HMIsEnabled(pVM));

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

    r80268 r80281  
    83128312     * Do the writing.
    83138313     */
    8314     PVM          pVM = pVCpu->CTX_SUFF(pVM);
     8314    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    83158315    if (!pVCpu->iem.s.aMemBbMappings[iMemMap].fUnassigned)
    83168316    {
    … …  
    85158515    GCPhysSecond &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
    85168516
    8517     PVM pVM = pVCpu->CTX_SUFF(pVM);
     8517    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    85188518
    85198519    /*
    … …  
    1429314293             */
    1429414294            uint32_t cMaxInstructionsGccStupidity = cMaxInstructions;
    14295             PVM pVM = pVCpu->CTX_SUFF(pVM);
     14295            PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    1429614296            for (;;)
    1429714297            {

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

    r80268 r80281  
    379379     * Read the guest VMCB.
    380380     */
    381     PVM pVM = pVCpu->CTX_SUFF(pVM);
     381    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    382382    int rc = PGMPhysSimpleReadGCPhys(pVM, pVCpu->cpum.GstCtx.hwvirt.svm.CTX_SUFF(pVmcb), GCPhysVmcb, sizeof(SVMVMCB));
    383383    if (RT_SUCCESS(rc))

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

    r80268 r80281  
    789789 * @param   pRange              The range to free.
    790790 */
    791 void iomMmioFreeRange(PVM pVM, PIOMMMIORANGE pRange)
     791void iomMmioFreeRange(PVMCC pVM, PIOMMMIORANGE pRange)
    792792{
    793793    MMHyperFree(pVM, pRange);

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

    r80268 r80281  
    585585 * @param   pvUser      Pointer to the MMIO ring-3 range entry.
    586586 */
    587 static VBOXSTRICTRC iomMmioCommonPfHandler(PVM pVM, PVMCPUCC pVCpu, uint32_t uErrorCode, PCPUMCTXCORE pCtxCore,
     587static VBOXSTRICTRC iomMmioCommonPfHandler(PVMCC pVM, PVMCPUCC pVCpu, uint32_t uErrorCode, PCPUMCTXCORE pCtxCore,
    588588                                           RTGCPHYS GCPhysFault, void *pvUser)
    589589{
    … …  
    11031103 *                          for the time being.
    11041104 */
    1105 VMMDECL(int) IOMMMIOMapMMIO2Page(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags)
     1105VMMDECL(int) IOMMMIOMapMMIO2Page(PVMCC pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags)
    11061106{
    11071107    /* Currently only called from the VGA device during MMIO. */
    11081108    Log(("IOMMMIOMapMMIO2Page %RGp -> %RGp flags=%RX64\n", GCPhys, GCPhysRemapped, fPageFlags));
    11091109    AssertReturn(fPageFlags == (X86_PTE_RW | X86_PTE_P), VERR_INVALID_PARAMETER);
    1110     PVMCPU pVCpu = VMMGetCpu(pVM);
     1110    PVMCPUCC pVCpu = VMMGetCpu(pVM);
    11111111
    11121112    /* This currently only works in real mode, protected mode without paging or with nested paging. */
    … …  
    11761176 *                          for the time being.
    11771177 */
    1178 VMMDECL(int) IOMMMIOMapMMIOHCPage(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint64_t fPageFlags)
     1178VMMDECL(int) IOMMMIOMapMMIOHCPage(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint64_t fPageFlags)
    11791179{
    11801180    /* Currently only called from VT-x code during a page fault. */
    … …  
    12261226 * @param   GCPhys          Physical address that's part of the MMIO region to be reset.
    12271227 */
    1228 VMMDECL(int) IOMMMIOResetRegion(PVM pVM, RTGCPHYS GCPhys)
     1228VMMDECL(int) IOMMMIOResetRegion(PVMCC pVM, RTGCPHYS GCPhys)
    12291229{
    12301230    Log(("IOMMMIOResetRegion %RGp\n", GCPhys));
    12311231
    1232     PVMCPU pVCpu = VMMGetCpu(pVM);
     1232    PVMCPUCC pVCpu = VMMGetCpu(pVM);
    12331233
    12341234    /* This currently only works in real mode, protected mode without paging or with nested paging. */

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

    r80268 r80281  
    157157 * @param   pVM     The cross context VM structure.
    158158 */
    159 static int mmHyperLock(PVM pVM)
     159static int mmHyperLock(PVMCC pVM)
    160160{
    161161    PMMHYPERHEAP pHeap = pVM->mm.s.CTX_SUFF(pHyperHeap);
    … …  
    329329 * Wrapper for mmHyperAllocInternal
    330330 */
    331 VMMDECL(int) MMHyperAlloc(PVM pVM, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv)
     331VMMDECL(int) MMHyperAlloc(PVMCC pVM, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv)
    332332{
    333333    int rc = mmHyperLock(pVM);
    … …  
    357357 *                      memory.
    358358 */
    359 VMMDECL(int) MMHyperDupMem(PVM pVM, const void *pvSrc, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv)
     359VMMDECL(int) MMHyperDupMem(PVMCC pVM, const void *pvSrc, size_t cb, unsigned uAlignment, MMTAG enmTag, void **ppv)
    360360{
    361361    int rc = MMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
    … …  
    933933 * Wrapper for mmHyperFreeInternal
    934934 */
    935 VMMDECL(int) MMHyperFree(PVM pVM, void *pv)
     935VMMDECL(int) MMHyperFree(PVMCC pVM, void *pv)
    936936{
    937937    int rc;
    … …  
    12161216 * @param   pVM         The cross context VM structure.
    12171217 */
    1218 VMMDECL(void) MMHyperHeapCheck(PVM pVM)
     1218VMMDECL(void) MMHyperHeapCheck(PVMCC pVM)
    12191219{
    12201220#ifdef MMHYPER_HEAP_STRICT

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

    r80268 r80281  
    7373    }
    7474
    75     PVM pVM = pVCpu->CTX_SUFF(pVM);
     75    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    7676    pdmLock(pVM);
    7777
    … …  
    118118 * @param   uTagSrc         The IRQ tag and source tracer ID.
    119119 */
    120 VMMDECL(int) PDMIsaSetIrq(PVM pVM, uint8_t u8Irq, uint8_t u8Level, uint32_t uTagSrc)
     120VMMDECL(int) PDMIsaSetIrq(PVMCC pVM, uint8_t u8Irq, uint8_t u8Level, uint32_t uTagSrc)
    121121{
    122122    pdmLock(pVM);
    … …  
    264264 * @param   pVM     The cross context VM structure.
    265265 */
    266 void pdmLock(PVM pVM)
     266void pdmLock(PVMCC pVM)
    267267{
    268268#ifdef IN_RING3
    … …  
    285285 * @param   rc      The RC to return in GC or R0 when we can't get the lock.
    286286 */
    287 int pdmLockEx(PVM pVM, int rc)
     287int pdmLockEx(PVMCC pVM, int rc)
    288288{
    289289    return PDMCritSectEnter(&pVM->pdm.s.CritSect, rc);
    … …  
    296296 * @param   pVM     The cross context VM structure.
    297297 */
    298 void pdmUnlock(PVM pVM)
     298void pdmUnlock(PVMCC pVM)
    299299{
    300300    PDMCritSectLeave(&pVM->pdm.s.CritSect);

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

    r80268 r80281  
    7878    AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, ("%RX32\n", pCritSect->s.Core.u32Magic),
    7979                    NIL_RTNATIVETHREAD);
    80     PVM             pVM         = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
    81     PVMCPU          pVCpu       = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     80    PVMCC           pVM         = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
     81    PVMCPUCC        pVCpu       = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    8282    RTNATIVETHREAD  hNativeSelf = pVCpu->hNativeThread;       Assert(hNativeSelf != NIL_RTNATIVETHREAD);
    8383#endif
    … …  
    202202                 it without creating a race with PDMCritSectLeave, resulting in
    203203                 spurious wakeups. */
    204         PVM     pVM   = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
    205         PVMCPU  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     204        PVMCC     pVM   = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
     205        PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    206206        rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_PREEMPT, NULL);
    207207        AssertRC(rc);
    … …  
    314314        {
    315315            STAM_REL_COUNTER_ADD(&pCritSect->s.StatContentionRZLock, 1000000000);
    316             PVM     pVM   = pCritSect->s.CTX_SUFF(pVM);
    317             PVMCPU  pVCpu = VMMGetCpu(pVM);
     316            PVMCC     pVM   = pCritSect->s.CTX_SUFF(pVM);
     317            PVMCPUCC  pVCpu = VMMGetCpu(pVM);
    318318            HMR0Leave(pVM, pVCpu);
    319319            RTThreadPreemptRestore(NIL_RTTHREAD, XXX);
    … …  
    343343    if (rcBusy == VINF_SUCCESS)
    344344    {
    345         PVM     pVM   = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
    346         PVMCPU  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     345        PVMCC     pVM   = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
     346        PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    347347        return VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_PDM_CRIT_SECT_ENTER, MMHyperCCToR3(pVM, pCritSect));
    348348    }
    … …  
    696696         * Queue the request.
    697697         */
    698         PVM         pVM   = pCritSect->s.CTX_SUFF(pVM);     AssertPtr(pVM);
    699         PVMCPU      pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
     698        PVMCC       pVM   = pCritSect->s.CTX_SUFF(pVM);     AssertPtr(pVM);
     699        PVMCPUCC    pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
    700700        uint32_t    i     = pVCpu->pdm.s.cQueuedCritSectLeaves++;
    701701        LogFlow(("PDMCritSectLeave: [%d]=%p => R3\n", i, pCritSect));
    … …  
    758758    return RTCritSectIsOwner(&pCritSect->s.Core);
    759759#else
    760     PVM     pVM   = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
    761     PVMCPU  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     760    PVMCC     pVM   = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
     761    PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    762762    if (pCritSect->s.Core.NativeThreadOwner != pVCpu->hNativeThread)
    763763        return false;

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

    r80268 r80281  
    8383    AssertMsgReturn(pThis->s.Core.u32Magic == RTCRITSECTRW_MAGIC, ("%RX32\n", pThis->s.Core.u32Magic),
    8484                    NIL_RTNATIVETHREAD);
    85     PVM             pVM         = pThis->s.CTX_SUFF(pVM);   AssertPtr(pVM);
    86     PVMCPU          pVCpu       = VMMGetCpu(pVM);           AssertPtr(pVCpu);
     85    PVMCC           pVM         = pThis->s.CTX_SUFF(pVM);   AssertPtr(pVM);
     86    PVMCPUCC        pVCpu       = VMMGetCpu(pVM);           AssertPtr(pVCpu);
    8787    RTNATIVETHREAD  hNativeSelf = pVCpu->hNativeThread;     Assert(hNativeSelf != NIL_RTNATIVETHREAD);
    8888#endif
    … …  
    132132static void pdmR0CritSectRwYieldToRing3(PPDMCRITSECTRW pThis)
    133133{
    134     PVM     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
    135     PVMCPU  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     134    PVMCC     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
     135    PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    136136    int rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_PREEMPT, NULL);
    137137    AssertRC(rc);
    … …  
    380380                if (rcBusy == VINF_SUCCESS)
    381381                {
    382                     PVM     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
    383                     PVMCPU  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     382                    PVMCC     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
     383                    PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    384384                    /** @todo Should actually do this in via VMMR0.cpp instead of going all the way
    385385                     *        back to ring-3. Goes for both kind of crit sects. */
    … …  
    622622                {
    623623                    /* Queue the exit request (ring-3). */
    624                     PVM         pVM   = pThis->s.CTX_SUFF(pVM);         AssertPtr(pVM);
    625                     PVMCPU      pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
     624                    PVMCC       pVM   = pThis->s.CTX_SUFF(pVM);         AssertPtr(pVM);
     625                    PVMCPUCC    pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
    626626                    uint32_t    i     = pVCpu->pdm.s.cQueuedCritSectRwShrdLeaves++;
    627627                    LogFlow(("PDMCritSectRwLeaveShared: [%d]=%p => R3 c=%d (%#llx)\n", i, pThis, c, u64State));
    … …  
    923923            {
    924924                Assert(!fTryOnly);
    925                 PVM     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
    926                 PVMCPU  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
     925                PVMCC     pVM   = pThis->s.CTX_SUFF(pVM);     AssertPtr(pVM);
     926                PVMCPUCC  pVCpu = VMMGetCpu(pVM);             AssertPtr(pVCpu);
    927927                /** @todo Should actually do this in via VMMR0.cpp instead of going all the way
    928928                 *        back to ring-3. Goes for both kind of crit sects. */
    … …  
    11981198             * so queue the exit request (ring-3).
    11991199             */
    1200             PVM         pVM   = pThis->s.CTX_SUFF(pVM);         AssertPtr(pVM);
    1201             PVMCPU      pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
     1200            PVMCC       pVM   = pThis->s.CTX_SUFF(pVM);         AssertPtr(pVM);
     1201            PVMCPUCC    pVCpu = VMMGetCpu(pVM);                 AssertPtr(pVCpu);
    12021202            uint32_t    i     = pVCpu->pdm.s.cQueuedCritSectRwExclLeaves++;
    12031203            LogFlow(("PDMCritSectRwLeaveShared: [%d]=%p => R3\n", i, pThis));

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

    r80268 r80281  
    12181218VMMDECL(int) PGMInvalidatePage(PVMCPUCC pVCpu, RTGCPTR GCPtrPage)
    12191219{
    1220     PVM pVM = pVCpu->CTX_SUFF(pVM);
     1220    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    12211221    int rc;
    12221222    Log3(("PGMInvalidatePage: GCPtrPage=%RGv\n", GCPtrPage));
    … …  
    13011301VMMDECL(int) PGMShwGetPage(PVMCPUCC pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
    13021302{
    1303     PVM pVM = pVCpu->CTX_SUFF(pVM);
     1303    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    13041304    pgmLock(pVM);
    13051305
    … …  
    14631463    PX86PDPT       pPdpt    = pgmShwGetPaePDPTPtr(pVCpu);
    14641464    PX86PDPE       pPdpe    = &pPdpt->a[iPdPt];
    1465     PVM            pVM      = pVCpu->CTX_SUFF(pVM);
     1465    PVMCC          pVM      = pVCpu->CTX_SUFF(pVM);
    14661466    PPGMPOOL       pPool    = pVM->pgm.s.CTX_SUFF(pPool);
    14671467    PPGMPOOLPAGE   pShwPage;
    … …  
    15841584static int pgmShwSyncLongModePDPtr(PVMCPUCC pVCpu, RTGCPTR64 GCPtr, X86PGPAEUINT uGstPml4e, X86PGPAEUINT uGstPdpe, PX86PDPAE *ppPD)
    15851585{
    1586     PVM            pVM           = pVCpu->CTX_SUFF(pVM);
     1586    PVMCC          pVM           = pVCpu->CTX_SUFF(pVM);
    15871587    PPGMPOOL       pPool         = pVM->pgm.s.CTX_SUFF(pPool);
    15881588    const unsigned iPml4         = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
    … …  
    17321732static int pgmShwGetEPTPDPtr(PVMCPUCC pVCpu, RTGCPTR64 GCPtr, PEPTPDPT *ppPdpt, PEPTPD *ppPD)
    17331733{
    1734     PVM            pVM   = pVCpu->CTX_SUFF(pVM);
     1734    PVMCC          pVM   = pVCpu->CTX_SUFF(pVM);
    17351735    const unsigned iPml4 = (GCPtr >> EPT_PML4_SHIFT) & EPT_PML4_MASK;
    17361736    PPGMPOOL       pPool = pVM->pgm.s.CTX_SUFF(pPool);
    … …  
    23362336 *                              pointed to must have 4 entries.
    23372337 */
    2338 VMM_INT_DECL(int) PGMGstGetPaePdpes(PVMCPU pVCpu, PX86PDPE paPdpes)
     2338VMM_INT_DECL(int) PGMGstGetPaePdpes(PVMCPUCC pVCpu, PX86PDPE paPdpes)
    23392339{
    23402340    Assert(pVCpu->pgm.s.enmShadowMode == PGMMODE_EPT);
    … …  
    23592359 * @remarks No-long-jump zone!!!
    23602360 */
    2361 VMM_INT_DECL(void) PGMGstUpdatePaePdpes(PVMCPU pVCpu, PCX86PDPE paPdpes)
     2361VMM_INT_DECL(void) PGMGstUpdatePaePdpes(PVMCPUCC pVCpu, PCX86PDPE paPdpes)
    23622362{
    23632363    Assert(pVCpu->pgm.s.enmShadowMode == PGMMODE_EPT);
    … …  
    34003400 * @param   fUseLargePages  Use/not use large pages
    34013401 */
    3402 VMMDECL(int) PGMSetLargePageUsage(PVM pVM, bool fUseLargePages)
     3402VMMDECL(int) PGMSetLargePageUsage(PVMCC pVM, bool fUseLargePages)
    34033403{
    34043404    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    … …  
    34173417 */
    34183418#if (defined(VBOX_STRICT) && defined(IN_RING3)) || defined(DOXYGEN_RUNNING)
    3419 int pgmLockDebug(PVM pVM, RT_SRC_POS_DECL)
     3419int pgmLockDebug(PVMCC pVM, RT_SRC_POS_DECL)
    34203420#else
    3421 int pgmLock(PVM pVM)
     3421int pgmLock(PVMCC pVM)
    34223422#endif
    34233423{

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

    r80268 r80281  
    6161 * @param   pType       Pointer to the type registration.
    6262 */
    63 DECLINLINE(uint32_t) pgmHandlerPhysicalTypeRelease(PVM pVM, PPGMPHYSHANDLERTYPEINT pType)
     63DECLINLINE(uint32_t) pgmHandlerPhysicalTypeRelease(PVMCC pVM, PPGMPHYSHANDLERTYPEINT pType)
    6464{
    6565    AssertMsgReturn(pType->u32Magic == PGMPHYSHANDLERTYPEINT_MAGIC, ("%#x\n", pType->u32Magic), UINT32_MAX);
    … …  
    101101 * @param   hType       The type regiration handle.
    102102 */
    103 VMMDECL(uint32_t) PGMHandlerPhysicalTypeRelease(PVM pVM, PGMPHYSHANDLERTYPE hType)
     103VMMDECL(uint32_t) PGMHandlerPhysicalTypeRelease(PVMCC pVM, PGMPHYSHANDLERTYPE hType)
    104104{
    105105    if (hType != NIL_PGMPHYSHANDLERTYPE)
    … …  
    145145 *                          success.
    146146 */
    147 int pgmHandlerPhysicalExCreate(PVM pVM, PGMPHYSHANDLERTYPE hType, RTR3PTR pvUserR3, RTR0PTR pvUserR0, RTRCPTR pvUserRC,
     147int pgmHandlerPhysicalExCreate(PVMCC pVM, PGMPHYSHANDLERTYPE hType, RTR3PTR pvUserR3, RTR0PTR pvUserR0, RTRCPTR pvUserRC,
    148148                               R3PTRTYPE(const char *) pszDesc, PPGMPHYSHANDLER *ppPhysHandler)
    149149{
    … …  
    202202 *                          success.
    203203 */
    204 int pgmHandlerPhysicalExDup(PVM pVM, PPGMPHYSHANDLER pPhysHandlerSrc, PPGMPHYSHANDLER *ppPhysHandler)
     204int pgmHandlerPhysicalExDup(PVMCC pVM, PPGMPHYSHANDLER pPhysHandlerSrc, PPGMPHYSHANDLER *ppPhysHandler)
    205205{
    206206    return pgmHandlerPhysicalExCreate(pVM,
    … …  
    497497 * @param   pHandler    The handler to free.  NULL if ignored.
    498498 */
    499 int pgmHandlerPhysicalExDestroy(PVM pVM, PPGMPHYSHANDLER pHandler)
     499int pgmHandlerPhysicalExDestroy(PVMCC pVM, PPGMPHYSHANDLER pHandler)
    500500{
    501501    if (pHandler)

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

    r80268 r80281  
    321321 * @param   pVM                 The cross context VM structure.
    322322 */
    323 void pgmPhysInvalidRamRangeTlbs(PVM pVM)
     323void pgmPhysInvalidRamRangeTlbs(PVMCC pVM)
    324324{
    325325    pgmLock(pVM);
    … …  
    567567 * @param   pVM     The cross context VM structure.
    568568 */
    569 void pgmPhysInvalidatePageMapTLB(PVM pVM)
     569void pgmPhysInvalidatePageMapTLB(PVMCC pVM)
    570570{
    571571    pgmLock(pVM);
    … …  
    633633 *          nip back to ring-3/0 in some cases.
    634634 */
    635 static int pgmPhysEnsureHandyPage(PVM pVM)
     635static int pgmPhysEnsureHandyPage(PVMCC pVM)
    636636{
    637637    AssertMsg(pVM->pgm.s.cHandyPages <= RT_ELEMENTS(pVM->pgm.s.aHandyPages), ("%d\n", pVM->pgm.s.cHandyPages));
    … …  
    12251225 * @remarks Called from within the PGM critical section.
    12261226 */
    1227 static int pgmPhysPageMapCommon(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, PPPGMPAGEMAP ppMap, void **ppv)
     1227static int pgmPhysPageMapCommon(PVMCC pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, PPPGMPAGEMAP ppMap, void **ppv)
    12281228{
    12291229    PGM_LOCK_ASSERT_OWNER(pVM);
    … …  
    46314631 * @param   pvUser          User argument for the callback.
    46324632 */
    4633 VMM_INT_DECL(int) PGMPhysNemEnumPagesByState(PVM pVM, PVMCPU pVCpu, uint8_t uMinState,
     4633VMM_INT_DECL(int) PGMPhysNemEnumPagesByState(PVMCC pVM, PVMCPUCC pVCpu, uint8_t uMinState,
    46344634                                             PFNPGMPHYSNEMENUMCALLBACK pfnCallback, void *pvUser)
    46354635{

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

    r80268 r80281  
    5858#endif
    5959
    60 int             pgmPoolTrackFlushGCPhysPTsSlow(PVM pVM, PPGMPAGE pPhysPage);
     60int             pgmPoolTrackFlushGCPhysPTsSlow(PVMCC pVM, PPGMPAGE pPhysPage);
    6161PPGMPOOLPHYSEXT pgmPoolTrackPhysExtAlloc(PVM pVM, uint16_t *piPhysExt);
    6262void            pgmPoolTrackPhysExtFree(PVM pVM, uint16_t iPhysExt);
    … …  
    757757 * @todo VBOXSTRICTRC
    758758 */
    759 static int pgmRZPoolAccessPfHandlerFlush(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
     759static int pgmRZPoolAccessPfHandlerFlush(PVMCC pVM, PVMCPUCC pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
    760760                                         PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
    761761{
    … …  
    878878 * @param   pfReused    Reused state (in/out)
    879879 */
    880 DECLINLINE(int) pgmRZPoolAccessPfHandlerSimple(PVMCC pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
     880DECLINLINE(int) pgmRZPoolAccessPfHandlerSimple(PVMCC pVM, PVMCPUCC pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
    881881                                               PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault, bool *pfReused)
    882882{
    … …  
    36003600 * @param   pPhysPage   The guest page in question.
    36013601 */
    3602 int pgmPoolTrackFlushGCPhysPTsSlow(PVM pVM, PPGMPAGE pPhysPage)
     3602int pgmPoolTrackFlushGCPhysPTsSlow(PVMCC pVM, PPGMPAGE pPhysPage)
    36033603{
    36043604    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
    … …  
    40754075 * @param   iPte        Page table entry
    40764076 */
    4077 uint16_t pgmPoolTrackPhysExtAddref(PVM pVM, PPGMPAGE pPhysPage, uint16_t u16, uint16_t iShwPT, uint16_t iPte)
     4077uint16_t pgmPoolTrackPhysExtAddref(PVMCC pVM, PPGMPAGE pPhysPage, uint16_t u16, uint16_t iShwPT, uint16_t iPte)
    40784078{
    40794079    pgmLock(pVM);
    … …  
    50175017 * @param   ppPage      Where to store the pointer to the page. NULL is stored here on failure.
    50185018 */
    5019 int pgmPoolAlloc(PVM pVM, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, PGMPOOLACCESS enmAccess, bool fA20Enabled,
     5019int pgmPoolAlloc(PVMCC pVM, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, PGMPOOLACCESS enmAccess, bool fA20Enabled,
    50205020                 uint16_t iUser, uint32_t iUserTable, bool fLockPage, PPPGMPOOLPAGE ppPage)
    50215021{

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

    r80268 r80281  
    208208# endif
    209209    PPGMPOOLPAGE pNewShwPageCR3;
    210     PVM          pVM       = pVCpu->CTX_SUFF(pVM);
     210    PVMCC        pVM       = pVCpu->CTX_SUFF(pVM);
    211211
    212212    Assert((HMIsNestedPagingActive(pVM) || VM_IS_NEM_ENABLED(pVM)) == pVM->pgm.s.fNestedPaging);
    … …  
    243243{
    244244#if PGM_TYPE_IS_NESTED_OR_EPT(PGM_SHW_TYPE)
    245     PVM pVM = pVCpu->CTX_SUFF(pVM);
     245    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    246246    if (pVCpu->pgm.s.CTX_SUFF(pShwPageCR3))
    247247    {

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

    r80268 r80281  
    4444 * @param   GCPtrPage   The
    4545 */
    46 VMMDECL(void) REMNotifyInvalidatePage(PVM pVM, RTGCPTR GCPtrPage)
     46VMMDECL(void) REMNotifyInvalidatePage(PVMCC pVM, RTGCPTR GCPtrPage)
    4747{
    4848    /*
    … …  
    8484 * @param   pRec            Notification record to insert
    8585 */
    86 static void remNotifyHandlerInsert(PVM pVM, PREMHANDLERNOTIFICATION pRec)
     86static void remNotifyHandlerInsert(PVMCC pVM, PREMHANDLERNOTIFICATION pRec)
    8787{
    8888    /*
    … …  
    139139 * @param   fHasHCHandler   Set if the handler have a HC callback function.
    140140 */
    141 VMMDECL(void) REMNotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler)
     141VMMDECL(void) REMNotifyHandlerPhysicalRegister(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler)
    142142{
    143143    REMHANDLERNOTIFICATION Rec;
    … …  
    161161 * @param   fRestoreAsRAM   Whether the to restore it as normal RAM or as unassigned memory.
    162162 */
    163 VMMDECL(void) REMNotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
     163VMMDECL(void) REMNotifyHandlerPhysicalDeregister(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
    164164{
    165165    REMHANDLERNOTIFICATION Rec;
    … …  
    185185 * @param   fRestoreAsRAM   Whether the to restore it as normal RAM or as unassigned memory.
    186186 */
    187 VMMDECL(void) REMNotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
     187VMMDECL(void) REMNotifyHandlerPhysicalModify(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
    188188{
    189189    REMHANDLERNOTIFICATION Rec;

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

    r80268 r80281  
    5252 * @param   Addr        Address part.
    5353 */
    54 VMMDECL(RTGCPTR) SELMToFlat(PVM pVM, DISSELREG SelReg, PCPUMCTXCORE pCtxCore, RTGCPTR Addr)
     54VMMDECL(RTGCPTR) SELMToFlat(PVMCC pVM, DISSELREG SelReg, PCPUMCTXCORE pCtxCore, RTGCPTR Addr)
    5555{
    5656    PCPUMSELREG    pSReg;
    57     PVMCPU         pVCpu = VMMGetCpu(pVM);
     57    PVMCPUCC       pVCpu = VMMGetCpu(pVM);
    5858
    5959    int rc = DISFetchRegSegEx(pCtxCore, SelReg, &pSReg); AssertRC(rc);

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

    r80268 r80281  
    192192VMM_INT_DECL(void) TMNotifyStartOfHalt(PVMCPUCC pVCpu)
    193193{
    194     PVM pVM = pVCpu->CTX_SUFF(pVM);
     194    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
    195195
    196196#ifndef VBOX_WITHOUT_NS_ACCOUNTING
    … …  
    11611161 * @param   u64Expire           The expiration time.
    11621162 */
    1163 static int tmTimerVirtualSyncSet(PVM pVM, PTMTIMER pTimer, uint64_t u64Expire)
     1163static int tmTimerVirtualSyncSet(PVMCC pVM, PTMTIMER pTimer, uint64_t u64Expire)
    11641164{
    11651165    STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetVs), a);
    … …  
    12301230VMMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
    12311231{
    1232     PVM pVM = pTimer->CTX_SUFF(pVM);
     1232    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    12331233
    12341234    /* Treat virtual sync timers specially. */
    … …  
    13871387 * @param   pu64Now         Optional pointer where to store the return time
    13881388 */
    1389 DECL_FORCE_INLINE(uint64_t) tmTimerSetRelativeNowWorker(PVM pVM, TMCLOCK enmClock, uint64_t *pu64Now)
     1389DECL_FORCE_INLINE(uint64_t) tmTimerSetRelativeNowWorker(PVMCC pVM, TMCLOCK enmClock, uint64_t *pu64Now)
    13901390{
    13911391    uint64_t u64Now;
    … …  
    14221422 *                          Optional.
    14231423 */
    1424 static int tmTimerSetRelativeOptimizedStart(PVM pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
     1424static int tmTimerSetRelativeOptimizedStart(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    14251425{
    14261426    Assert(!pTimer->offPrev);
    … …  
    14611461 *                              Optional.
    14621462 */
    1463 static int tmTimerVirtualSyncSetRelative(PVM pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
     1463static int tmTimerVirtualSyncSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    14641464{
    14651465    STAM_PROFILE_START(pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelativeVs), a);
    … …  
    15361536VMMDECL(int) TMTimerSetRelative(PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    15371537{
    1538     PVM pVM = pTimer->CTX_SUFF(pVM);
     1538    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    15391539
    15401540    /* Treat virtual sync timers specially. */
    … …  
    17881788 * @param   pTimer              The timer handle.
    17891789 */
    1790 static int tmTimerVirtualSyncStop(PVM pVM, PTMTIMER pTimer)
     1790static int tmTimerVirtualSyncStop(PVMCC pVM, PTMTIMER pTimer)
    17911791{
    17921792    STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerStopVs), a);
    … …  
    18581858VMMDECL(int) TMTimerStop(PTMTIMER pTimer)
    18591859{
    1860     PVM pVM = pTimer->CTX_SUFF(pVM);
     1860    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    18611861
    18621862    /* Treat virtual sync timers specially. */
    … …  
    19651965VMMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer)
    19661966{
    1967     PVM pVM = pTimer->CTX_SUFF(pVM);
     1967    PVMCC pVM = pTimer->CTX_SUFF(pVM);
    19681968
    19691969    uint64_t u64;
    … …  
    25322532 * @param   pVCpu       The cross context virtual CPU structure of the calling EMT.
    25332533 */
    2534 VMM_INT_DECL(uint32_t) TMCalcHostTimerFrequency(PVM pVM, PVMCPU pVCpu)
     2534VMM_INT_DECL(uint32_t) TMCalcHostTimerFrequency(PVMCC pVM, PVMCPUCC pVCpu)
    25352535{
    25362536    uint32_t uHz = tmGetFrequencyHint(pVM);

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

    r80268 r80281  
    4444 * @param   fCheckTimers    Whether to check timers.
    4545 */
    46 DECLINLINE(uint64_t) tmCpuTickGetRawVirtual(PVM pVM, bool fCheckTimers)
     46DECLINLINE(uint64_t) tmCpuTickGetRawVirtual(PVMCC pVM, bool fCheckTimers)
    4747{
    4848    uint64_t u64;

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

    r80268 r80281  
    155155 * Wrapper around the IPRT GIP time methods.
    156156 */
    157 DECLINLINE(uint64_t) tmVirtualGetRawNanoTS(PVM pVM)
     157DECLINLINE(uint64_t) tmVirtualGetRawNanoTS(PVMCC pVM)
    158158{
    159159# ifdef IN_RING3
    … …  
    176176 * @param   pVM     The cross context VM structure.
    177177 */
    178 static uint64_t tmVirtualGetRawNonNormal(PVM pVM)
     178static uint64_t tmVirtualGetRawNonNormal(PVMCC pVM)
    179179{
    180180    /*
    … …  
    204204 * @param   pVM     The cross context VM structure.
    205205 */
    206 DECLINLINE(uint64_t) tmVirtualGetRaw(PVM pVM)
     206DECLINLINE(uint64_t) tmVirtualGetRaw(PVMCC pVM)
    207207{
    208208    if (RT_LIKELY(!pVM->tm.s.fVirtualWarpDrive))
    … …  
    870870 * @param   pVM     The cross context VM structure.
    871871 */
    872 int tmVirtualPauseLocked(PVM pVM)
     872int tmVirtualPauseLocked(PVMCC pVM)
    873873{
    874874    uint32_t c = ASMAtomicDecU32(&pVM->tm.s.cVirtualTicking);
    … …  
    890890 * @param   pVM     The cross context VM structure.
    891891 */
    892 int tmVirtualResumeLocked(PVM pVM)
     892int tmVirtualResumeLocked(PVMCC pVM)
    893893{
    894894    uint32_t c = ASMAtomicIncU32(&pVM->tm.s.cVirtualTicking);

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

    r80268 r80281  
    190190 * @param   enmType             Trap type.
    191191 */
    192 VMMDECL(int) TRPMAssertTrap(PVMCPU pVCpu, uint8_t u8TrapNo, TRPMEVENT enmType)
     192VMMDECL(int) TRPMAssertTrap(PVMCPUCC pVCpu, uint8_t u8TrapNo, TRPMEVENT enmType)
    193193{
    194194    Log2(("TRPMAssertTrap: u8TrapNo=%02x type=%d\n", u8TrapNo, enmType));
    … …  
    223223 * @param   uErrorCode          The error code for the page-fault.
    224224 */
    225 VMMDECL(int) TRPMAssertXcptPF(PVMCPU pVCpu, RTGCUINTPTR uCR2, RTGCUINT uErrorCode)
     225VMMDECL(int) TRPMAssertXcptPF(PVMCPUCC pVCpu, RTGCUINTPTR uCR2, RTGCUINT uErrorCode)
    226226{
    227227    Log2(("TRPMAssertXcptPF: uCR2=%RGv uErrorCode=%RGv\n", uCR2, uErrorCode)); /** @todo RTGCUINT to be fixed. */

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

    r80268 r80281  
    4848 * @thread  Any
    4949 */
    50 VMMDECL(int) VMSetError(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
     50VMMDECL(int) VMSetError(PVMCC pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
    5151{
    5252    va_list args;
    … …  
    7272 * @thread  Any
    7373 */
    74 VMMDECL(int) VMSetErrorV(PVM pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
     74VMMDECL(int) VMSetErrorV(PVMCC pVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list args)
    7575{
    7676#ifdef IN_RING3
    … …  
    204204 * @thread  Any
    205205 */
    206 VMMDECL(int) VMSetRuntimeError(PVM pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
     206VMMDECL(int) VMSetRuntimeError(PVMCC pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, ...)
    207207{
    208208    va_list va;
    … …  
    229229 * @thread  Any
    230230 */
    231 VMMDECL(int) VMSetRuntimeErrorV(PVM pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
     231VMMDECL(int) VMSetRuntimeErrorV(PVMCC pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
    232232{
    233233    Log(("VMSetRuntimeErrorV: fFlags=%#x pszErrorId=%s\n", fFlags, pszErrorId));
    … …  
    397397 * @param   pVM         The VM handle.
    398398 */
    399 VMMDECL(uint32_t) VMGetResetCount(PVM pVM)
     399VMMDECL(uint32_t) VMGetResetCount(PVMCC pVM)
    400400{
    401401    VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);
    … …  
    410410 * @param   pVM         The VM handle.
    411411 */
    412 VMMDECL(uint32_t) VMGetSoftResetCount(PVM pVM)
     412VMMDECL(uint32_t) VMGetSoftResetCount(PVMCC pVM)
    413413{
    414414    VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);
    … …  
    423423 * @param   pVM         The VM handle.
    424424 */
    425 VMMDECL(uint32_t) VMGetHardResetCount(PVM pVM)
     425VMMDECL(uint32_t) VMGetHardResetCount(PVMCC pVM)
    426426{
    427427    VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);

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

    r80268 r80281  
    205205        for (VMCPUID idCpu = 0; idCpu < cCpus; idCpu++)
    206206        {
    207             PVMCPU pVCpu = VMCC_GET_CPU(pVM, idCpu);
     207            PVMCPUCC pVCpu = VMCC_GET_CPU(pVM, idCpu);
    208208            if (pVCpu->idHostCpu == idHostCpu)
    209209                return pVCpu->idCpu;
    … …  
    217217    for (VMCPUID idCpu = 0; idCpu < cCpus; idCpu++)
    218218    {
    219         PVMCPU pVCpu = VMCC_GET_CPU(pVM, idCpu);
     219        PVMCPUCC pVCpu = VMCC_GET_CPU(pVM, idCpu);
    220220        if (pVCpu->hNativeThreadR0 == hThread)
    221221            return pVCpu->idCpu;

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

    r80274 r80281  
    977977                                pHandle->ProcId                 = ProcId;
    978978                                pGVM->pVMR3                     = pVMR3;
     979                                pGVM->pVMR3Unsafe               = pVMR3;
    979980                                pGVM->aCpus[0].hEMT             = hEMT0;
    980981                                pGVM->aCpus[0].hNativeThreadR0  = hEMT0;
    … …  
    10841085                                {
    10851086                                    PVMR3 pVMR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMMapObj);
    1086                                     pVM->pVMR3 = pVMR3;
    10871087                                    AssertPtr((void *)pVMR3);
     1088                                    pVM->pVMR3       = pVMR3;
    10881089
    10891090                                    /* Initialize all the VM pointers. */
    … …  
    12221223    pGVM->cCpus            = cCpus;
    12231224    pGVM->pSession         = pSession;
     1225    pGVM->pSelf            = pGVM;
    12241226
    12251227    /* VM: */
    12261228    pGVM->enmVMState       = VMSTATE_CREATING;
     1229    pGVM->hSelfUnsafe      = hSelf;
    12271230    pGVM->pSessionUnsafe   = pSession;
    1228     pGVM->hSelfUnsafe      = hSelf;
     1231    pGVM->pVMR0ForCall     = pGVM;
    12291232    pGVM->cCpusUnsafe      = cCpus;
    12301233    pGVM->uCpuExecutionCap = 100; /* default is no cap. */

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

    r80191 r80281  
    13871387        if (VM_IS_HM_ENABLED(pVM))
    13881388        {
    1389             if (HMCanExecuteGuest(pVCpu, &pVCpu->cpum.GstCtx))
     1389            if (HMCanExecuteGuest(pVM, pVCpu, &pVCpu->cpum.GstCtx))
    13901390                return EMSTATE_HM;
    13911391        }

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

    r80191 r80281  
    8787    Assert(!(fFlags & ~EM_ONE_INS_FLAGS_MASK));
    8888
    89     if (!HMCanExecuteGuest(pVCpu, &pVCpu->cpum.GstCtx))
     89    if (!HMCanExecuteGuest(pVM, pVCpu, &pVCpu->cpum.GstCtx))
    9090        return VINF_EM_RESCHEDULE;
    9191

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

    r80191 r80281  
    2424#include <VBox/vmm/gmm.h>
    2525#include <VBox/vmm/vmm.h>
    26 #include <VBox/vmm/vm.h>
     26#include <VBox/vmm/vmcc.h>
    2727#include <VBox/sup.h>
    2828#include <VBox/err.h>
    … …  
    309309
    310310    /* Must be callable from any thread, so can't use VMMR3CallR0. */
    311     int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS, 0, &Req.Hdr);
     311    int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GMM_QUERY_HYPERVISOR_MEM_STATS, 0, &Req.Hdr);
    312312    if (rc == VINF_SUCCESS)
    313313    {
    … …  
    444444
    445445    /* Must be callable from any thread, so can't use VMMR3CallR0. */
    446     int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_FIND_DUPLICATE_PAGE, 0, &Req.Hdr);
     446    int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GMM_FIND_DUPLICATE_PAGE, 0, &Req.Hdr);
    447447    if (rc == VINF_SUCCESS)
    448448        return Req.fDuplicate;

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

    r80202 r80281  
    6060#include <VBox/vmm/hm_svm.h>
    6161#include "HMInternal.h"
    62 #include <VBox/vmm/vm.h>
    63 #include <VBox/vmm/uvm.h>
     62#include <VBox/vmm/vmcc.h>
    6463#include <VBox/err.h>
    6564#include <VBox/param.h>
    … …  
    993992     * Enable VT-x or AMD-V on all host CPUs.
    994993     */
    995     rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HM_ENABLE, 0, NULL);
     994    rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /*idCpu*/, VMMR0_DO_HM_ENABLE, 0, NULL);
    996995    if (RT_FAILURE(rc))
    997996    {
    … …  
    15841583     * Call ring-0 to set up the VM.
    15851584     */
    1586     rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /* idCpu */, VMMR0_DO_HM_SETUP_VM, 0 /* u64Arg */, NULL /* pReqHdr */);
     1585    rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /* idCpu */, VMMR0_DO_HM_SETUP_VM, 0 /* u64Arg */, NULL /* pReqHdr */);
    15871586    if (rc != VINF_SUCCESS)
    15881587    {
    … …  
    17671766     * Call ring-0 to set up the VM.
    17681767     */
    1769     int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HM_SETUP_VM, 0, NULL);
     1768    int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /*idCpu*/, VMMR0_DO_HM_SETUP_VM, 0, NULL);
    17701769    if (rc != VINF_SUCCESS)
    17711770    {

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

    r80191 r80281  
    2828#include "MMInternal.h"
    2929#include <VBox/vmm/vm.h>
     30#include <VBox/vmm/gvm.h>
    3031#include <VBox/err.h>
    3132#include <VBox/param.h>
    … …  
    152153        /*
    153154         * Map the VM structure into the hypervisor space.
     155         * Note! Keeping the mappings here for now in case someone is using
     156         *       MMHyperR3ToR0 or similar.
    154157         */
     158        AssertCompileSizeAlignment(VM, PAGE_SIZE);
     159        AssertCompileSizeAlignment(VMCPU, PAGE_SIZE);
    155160#ifdef VBOX_BUGREF_9217
    156         AssertRelease(pVM->cbSelf >= sizeof(VMCPU) * pVM->cCpus + sizeof(*pVM));
     161        AssertCompileSizeAlignment(GVM, PAGE_SIZE);
     162        AssertCompileSizeAlignment(GVMCPU, PAGE_SIZE);
     163        AssertRelease(pVM->cbSelf == sizeof(VM));
     164        AssertRelease(pVM->cbVCpu == sizeof(VMCPU));
     165        RTGCPTR GCPtr;
     166        rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0ForCall, sizeof(VM) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM", &GCPtr);
     167        uint32_t offPages = RT_UOFFSETOF(GVM, aCpus) >> PAGE_SHIFT;
     168        for (uint32_t idCpu = 0; idCpu < pVM->cCpus && RT_SUCCESS(rc); idCpu++, offPages += sizeof(GVMCPU) >> PAGE_SHIFT)
     169        {
     170            PVMCPU pVCpu = pVM->apCpusR3[idCpu];
     171            RTGCPTR GCPtrIgn;
     172            rc = MMR3HyperMapPages(pVM, pVCpu, pVM->pVMR0ForCall + offPages * PAGE_SIZE,
     173                                   sizeof(VMCPU) >> PAGE_SHIFT, &pVM->paVMPagesR3[offPages], "VMCPU", &GCPtrIgn);
     174        }
    157175#else
    158176        AssertRelease(pVM->cbSelf >= sizeof(VMCPU));
     177        RTGCPTR GCPtr;
     178        rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0,
     179                               RT_ALIGN_Z(pVM->cbSelf, PAGE_SIZE) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM",
     180                               &GCPtr);
    159181#endif
    160         RTGCPTR GCPtr;
    161         rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0, RT_ALIGN_Z(pVM->cbSelf, PAGE_SIZE) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM",
    162                                &GCPtr);
    163182        if (RT_SUCCESS(rc))
    164183        {
    … …  
    876895        //pHeap->pbHeapRC           = 0; // set by mmR3HyperHeapMap()
    877896        pHeap->pVMR3                = pVM;
     897#ifdef VBOX_BUGREF_9217
     898        pHeap->pVMR0                = pVM->pVMR0ForCall;
     899#else
    878900        pHeap->pVMR0                = pVM->pVMR0;
     901#endif
    879902        pHeap->pVMRC                = pVM->pVMRC;
    880903        pHeap->cbHeap               = cbAligned - MMYPERHEAP_HDR_SIZE;

  • trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

    r80191 r80281  
    5353#include <VBox/vmm/dbgftrace.h>
    5454#include "NEMInternal.h"
    55 #include <VBox/vmm/vm.h>
     55#include <VBox/vmm/vmcc.h>
    5656
    5757#include <iprt/ldr.h>
    … …  
    12321232                 * Check out our ring-0 capabilities.
    12331233                 */
    1234                 rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_NEM_INIT_VM, 0, NULL);
     1234                rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /*idCpu*/, VMMR0_DO_NEM_INIT_VM, 0, NULL);
    12351235                if (RT_SUCCESS(rc))
    12361236                {

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

    r80191 r80281  
    180180                pCritSect->Core.NativeThreadOwner    = NIL_RTNATIVETHREAD;
    181181                pCritSect->pVMR3                     = pVM;
     182#ifdef VBOX_BUGREF_9217
     183                pCritSect->pVMR0                     = pVM->pVMR0ForCall;
     184#else
    182185                pCritSect->pVMR0                     = pVM->pVMR0;
     186#endif
    183187                pCritSect->pVMRC                     = pVM->pVMRC;
    184188                pCritSect->pvKey                     = pvKey;
    … …  
    277281#endif
    278282                    pCritSect->pVMR3                     = pVM;
     283#ifdef VBOX_BUGREF_9217
     284                    pCritSect->pVMR0                     = pVM->pVMR0ForCall;
     285#else
    279286                    pCritSect->pVMR0                     = pVM->pVMR0;
     287#endif
    280288                    pCritSect->pVMRC                     = pVM->pVMRC;
    281289                    pCritSect->pvKey                     = pvKey;

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

    r80191 r80281  
    3434#include <VBox/vmm/dbgf.h>
    3535#include <VBox/vmm/vmapi.h>
    36 #include <VBox/vmm/vm.h>
    37 #include <VBox/vmm/uvm.h>
    3836#include <VBox/vmm/vmm.h>
     37#include <VBox/vmm/vmcc.h>
    3938
    4039#include <VBox/version.h>
    … …  
    27112710            Req.u32Alignment    = 0;
    27122711            Req.u64Arg          = u64Arg;
    2713             rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER, 0, &Req.Hdr);
     2712            rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_PDM_DEVICE_CALL_REQ_HANDLER, 0, &Req.Hdr);
    27142713        }
    27152714        else

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

    r80191 r80281  
    331331        pDevIns->Internal.s.pDevR3              = paDevs[i].pDev;
    332332        pDevIns->Internal.s.pVMR3               = pVM;
     333#ifdef VBOX_BUGREF_9217
     334        pDevIns->Internal.s.pVMR0               = pVM->pVMR0ForCall;
     335#else
    333336        pDevIns->Internal.s.pVMR0               = pVM->pVMR0;
     337#endif
    334338        pDevIns->Internal.s.pVMRC               = pVM->pVMRC;
    335339        //pDevIns->Internal.s.pLunsR3             = NULL;

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

    r80191 r80281  
    2929#include <VBox/vmm/vmm.h>
    3030#include <VBox/sup.h>
    31 #include <VBox/vmm/vm.h>
     31#include <VBox/vmm/vmcc.h>
     32
    3233#include <VBox/version.h>
    3334#include <VBox/err.h>
    … …  
    722723                    pNew->Internal.s.pDrv           = pDrv;
    723724                    pNew->Internal.s.pVMR3          = pVM;
     725#ifdef VBOX_BUGREF_9217
     726                    pNew->Internal.s.pVMR0          = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0 ? pVM->pVMR0ForCall : NIL_RTR0PTR;
     727#else
    724728                    pNew->Internal.s.pVMR0          = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0 ? pVM->pVMR0 : NIL_RTR0PTR;
     729#endif
    725730                    pNew->Internal.s.pVMRC          = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_RC ? pVM->pVMRC : NIL_RTRCPTR;
    726731                    //pNew->Internal.s.fDetaching     = false;
    … …  
    14781483    if (    uOperation >= VMMR0_DO_SRV_START
    14791484        &&  uOperation <  VMMR0_DO_SRV_END)
    1480         rc = SUPR3CallVMMR0Ex(pDrvIns->Internal.s.pVMR3->pVMR0, NIL_VMCPUID, uOperation, 0, (PSUPVMMR0REQHDR)pvArg);
     1485        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pDrvIns->Internal.s.pVMR3), NIL_VMCPUID, uOperation, 0, (PSUPVMMR0REQHDR)pvArg);
    14811486    else
    14821487    {
    … …  
    17641769        Req.u32Alignment    = 0;
    17651770        Req.u64Arg          = u64Arg;
    1766         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER, 0, &Req.Hdr);
     1771        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_PDM_DRIVER_CALL_REQ_HANDLER, 0, &Req.Hdr);
    17671772    }
    17681773

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

    r80191 r80281  
    8989     */
    9090    pQueue->pVMR3 = pVM;
     91#ifdef VBOX_BUGREF_9217
     92    pQueue->pVMR0 = fRZEnabled ? pVM->pVMR0ForCall : NIL_RTR0PTR;
     93#else
    9194    pQueue->pVMR0 = fRZEnabled ? pVM->pVMR0 : NIL_RTR0PTR;
     95#endif
    9296    pQueue->pVMRC = fRZEnabled ? pVM->pVMRC : NIL_RTRCPTR;
    9397    pQueue->pszName = pszName;

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

    r80191 r80281  
    3333#include <VBox/vmm/pdmdev.h>
    3434#include "PGMInternal.h"
    35 #include <VBox/vmm/vm.h>
    36 #include <VBox/vmm/uvm.h>
     35#include <VBox/vmm/vmcc.h>
     36
    3737#include "PGMInline.h"
     38
    3839#include <VBox/sup.h>
    3940#include <VBox/param.h>
    … …  
    50065007    /* Must be callable from any thread, so can't use VMMR3CallR0. */
    50075008    STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkMap, a);
    5008     rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, 0, &Req.Hdr);
     5009    rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GMM_MAP_UNMAP_CHUNK, 0, &Req.Hdr);
    50095010    STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pStats)->StatChunkMap, a);
    50105011    if (RT_SUCCESS(rc))

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

    r80191 r80281  
    240240     */
    241241    pPool->pVMR3     = pVM;
     242#ifdef VBOX_BUGREF_9217
     243    pPool->pVMR0     = pVM->pVMR0ForCall;
     244#else
    242245    pPool->pVMR0     = pVM->pVMR0;
     246#endif
    243247    pPool->cMaxPages = cMaxPages;
    244248    pPool->cCurPages = PGMPOOL_IDX_FIRST;

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

    r80191 r80281  
    5353#include <VBox/vmm/stam.h>
    5454#include "STAMInternal.h"
    55 #include <VBox/vmm/vm.h>
    56 #include <VBox/vmm/uvm.h>
     55#include <VBox/vmm/vmcc.h>
     56
    5757#include <VBox/err.h>
    5858#include <VBox/dbg.h>
    … …  
    17401740        GVMMReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    17411741        GVMMReq.pSession     = pVM->pSession;
    1742         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GVMM_RESET_STATISTICS, 0, &GVMMReq.Hdr);
     1742        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GVMM_RESET_STATISTICS, 0, &GVMMReq.Hdr);
    17431743    }
    17441744
    … …  
    17491749        GMMReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    17501750        GMMReq.pSession     = pVM->pSession;
    1751         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_RESET_STATISTICS, 0, &GMMReq.Hdr);
     1751        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GMM_RESET_STATISTICS, 0, &GMMReq.Hdr);
    17521752    }
    17531753
    … …  
    24572457                Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    24582458                Req.pSession     = pVM->pSession;
    2459                 int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GVMM_QUERY_STATISTICS, 0, &Req.Hdr);
     2459                int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GVMM_QUERY_STATISTICS, 0, &Req.Hdr);
    24602460                if (RT_SUCCESS(rc))
    24612461                {
    … …  
    25192519                Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
    25202520                Req.pSession     = pVM->pSession;
    2521                 int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GMM_QUERY_STATISTICS, 0, &Req.Hdr);
     2521                int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_GMM_QUERY_STATISTICS, 0, &Req.Hdr);
    25222522                if (RT_SUCCESS(rc))
    25232523                    pUVM->stam.s.GMMStats = Req.Stats;
    … …  
    25292529             */
    25302530            case STAM_REFRESH_GRP_NEM:
    2531                 SUPR3CallVMMR0(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_NEM_UPDATE_STATISTICS, NULL);
     2531                SUPR3CallVMMR0(VMCC_GET_VMR0_FOR_CALL(pVM), NIL_VMCPUID, VMMR0_DO_NEM_UPDATE_STATISTICS, NULL);
    25322532                break;
    25332533

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

    r80191 r80281  
    11511151    {
    11521152        pTimer->pVMRC = pVM->pVMRC;
     1153#ifdef VBOX_BUGREF_9217
     1154        pTimer->pVMR0 = pVM->pVMR0ForCall; /** @todo fix properly */
     1155#else
    11531156        pTimer->pVMR0 = pVM->pVMR0;
     1157#endif
    11541158    }
    11551159}
    … …  
    15291533    pTimer->enmClock        = enmClock;
    15301534    pTimer->pVMR3           = pVM;
     1535#ifdef VBOX_BUGREF_9217
     1536    pTimer->pVMR0           = pVM->pVMR0ForCall; /** @todo fix properly */
     1537#else
    15311538    pTimer->pVMR0           = pVM->pVMR0;
     1539#endif
    15321540    pTimer->pVMRC           = pVM->pVMRC;
    15331541    pTimer->enmState        = TMTIMERSTATE_STOPPED;

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

    r80191 r80281  
    7171#include <VBox/vmm/gim.h>
    7272#include "VMInternal.h"
    73 #include <VBox/vmm/vm.h>
    74 #include <VBox/vmm/uvm.h>
     73#include <VBox/vmm/vmcc.h>
    7574
    7675#include <VBox/sup.h>
    … …  
    584583        PVM pVM = pUVM->pVM = CreateVMReq.pVMR3;
    585584        AssertRelease(VALID_PTR(pVM));
     585#ifdef VBOX_BUGREF_9217
     586        AssertRelease(pVM->pVMR0ForCall == CreateVMReq.pVMR0);
     587#else
    586588        AssertRelease(pVM->pVMR0 == CreateVMReq.pVMR0);
     589#endif
    587590        AssertRelease(pVM->pSession == pUVM->vm.s.pSession);
    588591        AssertRelease(pVM->cCpus == cCpus);
    … …  
    592595
    593596        Log(("VMR3Create: Created pUVM=%p pVM=%p pVMR0=%p hSelf=%#x cCpus=%RU32\n",
    594              pUVM, pVM, pVM->pVMR0, pVM->hSelf, pVM->cCpus));
     597             pUVM, pVM, CreateVMReq.pVMR0, pVM->hSelf, pVM->cCpus));
    595598
    596599        /*
    … …  
    789792{
    790793    Assert(VMMGetCpuId(pVM) == idCpu);
    791     int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, idCpu, VMMR0_DO_GVMM_REGISTER_VMCPU, 0, NULL);
     794    int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), idCpu, VMMR0_DO_GVMM_REGISTER_VMCPU, 0, NULL);
    792795    if (RT_FAILURE(rc))
    793796        LogRel(("idCpu=%u rc=%Rrc\n", idCpu, rc));

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

    r80191 r80281  
    3232#include <VBox/vmm/tm.h>
    3333#include "VMInternal.h"
    34 #include <VBox/vmm/vm.h>
    35 #include <VBox/vmm/uvm.h>
     34#include <VBox/vmm/vmcc.h>
    3635
    3736#include <VBox/err.h>
    … …  
    290289        }
    291290
    292         int rc2 = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
     291        int rc2 = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /*idCpu*/, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
    293292        AssertLogRelRC(rc2);
    294293    }
    … …  
    297296             && (pVM = pUVM->pVM) != NULL)
    298297    {
    299         int rc2 = SUPR3CallVMMR0Ex(pVM->pVMR0, idCpu, VMMR0_DO_GVMM_DEREGISTER_VMCPU, 0, NULL);
     298        int rc2 = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), idCpu, VMMR0_DO_GVMM_DEREGISTER_VMCPU, 0, NULL);
    300299        AssertLogRelRC(rc2);
    301300    }
    … …  
    752751            //RTLogPrintf("loop=%-3d  u64GipTime=%'llu / %'llu   now=%'llu / %'llu\n", cLoops, u64GipTime, u64Delta, u64NowLog, u64GipTime - u64NowLog);
    753752            uint64_t const u64StartSchedHalt   = RTTimeNanoTS();
    754             rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_GVMM_SCHED_HALT, u64GipTime, NULL);
     753            rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), pVCpu->idCpu, VMMR0_DO_GVMM_SCHED_HALT, u64GipTime, NULL);
    755754            uint64_t const u64EndSchedHalt     = RTTimeNanoTS();
    756755            uint64_t const cNsElapsedSchedHalt = u64EndSchedHalt - u64StartSchedHalt;
    … …  
    782781        {
    783782            uint64_t const u64StartSchedYield   = RTTimeNanoTS();
    784             rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_GVMM_SCHED_POLL, false /* don't yield */, NULL);
     783            rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), pVCpu->idCpu, VMMR0_DO_GVMM_SCHED_POLL, false /* don't yield */, NULL);
    785784            uint64_t const cNsElapsedSchedYield = RTTimeNanoTS() - u64StartSchedYield;
    786785            STAM_REL_PROFILE_ADD_PERIOD(&pUVCpu->vm.s.StatHaltYield, cNsElapsedSchedYield);
    … …  
    822821         * anything needs our attention.
    823822         */
    824         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, VMMR0_DO_GVMM_SCHED_HALT, RTTimeNanoTS() + 1000000000 /* +1s */, NULL);
     823        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), pVCpu->idCpu, VMMR0_DO_GVMM_SCHED_HALT, RTTimeNanoTS() + 1000000000 /* +1s */, NULL);
    825824        if (rc == VERR_INTERRUPTED)
    826825            rc = VINF_SUCCESS;
    … …  
    855854        if (enmState == VMCPUSTATE_STARTED_HALTED || pUVCpu->vm.s.fWait)
    856855        {
    857             int rc = SUPR3CallVMMR0Ex(pUVCpu->pVM->pVMR0, pUVCpu->idCpu, VMMR0_DO_GVMM_SCHED_WAKE_UP, 0, NULL);
     856            int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pUVCpu->pVM), pUVCpu->idCpu, VMMR0_DO_GVMM_SCHED_WAKE_UP, 0, NULL);
    858857            AssertRC(rc);
    859858
    … …  
    866865                if (fFlags & VMNOTIFYFF_FLAGS_POKE)
    867866                {
    868                     int rc = SUPR3CallVMMR0Ex(pUVCpu->pVM->pVMR0, pUVCpu->idCpu, VMMR0_DO_GVMM_SCHED_POKE, 0, NULL);
     867                    int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pUVCpu->pVM), pUVCpu->idCpu, VMMR0_DO_GVMM_SCHED_POKE, 0, NULL);
    869868                    AssertRC(rc);
    870869                }
    … …  
    885884    else if (pUVCpu->vm.s.fWait)
    886885    {
    887         int rc = SUPR3CallVMMR0Ex(pUVCpu->pVM->pVMR0, pUVCpu->idCpu, VMMR0_DO_GVMM_SCHED_WAKE_UP, 0, NULL);
     886        int rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pUVCpu->pVM), pUVCpu->idCpu, VMMR0_DO_GVMM_SCHED_WAKE_UP, 0, NULL);
    888887        AssertRC(rc);
    889888    }

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

    r80191 r80281  
    128128#include <VBox/vmm/tm.h>
    129129#include "VMMInternal.h"
    130 #include <VBox/vmm/vm.h>
    131 #include <VBox/vmm/uvm.h>
     130#include <VBox/vmm/vmcc.h>
    132131
    133132#include <VBox/err.h>
    … …  
    273272     * Register the Ring-0 VM handle with the session for fast ioctl calls.
    274273     */
    275     rc = SUPR3SetVMForFastIOCtl(pVM->pVMR0);
     274    rc = SUPR3SetVMForFastIOCtl(VMCC_GET_VMR0_FOR_CALL(pVM));
    276275    if (RT_FAILURE(rc))
    277276        return rc;
    … …  
    383382            if (RT_FAILURE(rc))
    384383                return rc;
    385             pVCpu->vmm.s.pR0LoggerR3->pVM        = pVM->pVMR0;
     384            pVCpu->vmm.s.pR0LoggerR3->pVM        = VMCC_GET_VMR0_FOR_CALL(pVM);
    386385            //pVCpu->vmm.s.pR0LoggerR3->fCreated = false;
    387386            pVCpu->vmm.s.pR0LoggerR3->cbLogger   = (uint32_t)cbLogger;
    … …  
    420419            RTR0PTR      R0PtrVmmLogger = MMHyperR3ToR0(pVM, pVmmLogger);
    421420            pVCpu->vmm.s.pR0RelLoggerR0     = R0PtrVmmLogger;
    422             pVmmLogger->pVM                 = pVM->pVMR0;
     421            pVmmLogger->pVM                 = VMCC_GET_VMR0_FOR_CALL(pVM);
    423422            pVmmLogger->cbLogger            = (uint32_t)cbLogger;
    424423            pVmmLogger->fCreated            = false;
    … …  
    598597        rc = VINF_SUCCESS;
    599598#else
    600         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_VMMR0_INIT, RT_MAKE_U64(VMMGetSvnRev(), vmmGetBuildType()), NULL);
     599        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /*idCpu*/, VMMR0_DO_VMMR0_INIT, RT_MAKE_U64(VMMGetSvnRev(), vmmGetBuildType()), NULL);
    601600#endif
    602601        /*
    … …  
    728727        rc = VINF_SUCCESS;
    729728#else
    730         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_VMMR0_TERM, 0, NULL);
     729        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), 0 /*idCpu*/, VMMR0_DO_VMMR0_TERM, 0, NULL);
    731730#endif
    732731        /*
    … …  
    11041103            rc = VERR_GENERAL_FAILURE;
    11051104#else
    1106             rc = SUPR3CallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HM_RUN, pVCpu->idCpu);
     1105            rc = SUPR3CallVMMR0Fast(VMCC_GET_VMR0_FOR_CALL(pVM), VMMR0_DO_HM_RUN, pVCpu->idCpu);
    11071106            if (RT_LIKELY(rc == VINF_SUCCESS))
    11081107                rc = pVCpu->vmm.s.iLastGZRc;
    … …  
    11521151            rcStrict = VERR_GENERAL_FAILURE;
    11531152#else
    1154             rcStrict = SUPR3CallVMMR0Fast(pVM->pVMR0, enmOperation, pVCpu->idCpu);
     1153            rcStrict = SUPR3CallVMMR0Fast(VMCC_GET_VMR0_FOR_CALL(pVM), enmOperation, pVCpu->idCpu);
    11551154            if (RT_LIKELY(rcStrict == VINF_SUCCESS))
    11561155                rcStrict = pVCpu->vmm.s.iLastGZRc;
    … …  
    23122311        rc = VERR_GENERAL_FAILURE;
    23132312#else
    2314         rc = SUPR3CallVMMR0Ex(pVM->pVMR0, pVCpu->idCpu, enmOperation, u64Arg, pReqHdr);
     2313        rc = SUPR3CallVMMR0Ex(VMCC_GET_VMR0_FOR_CALL(pVM), pVCpu->idCpu, enmOperation, u64Arg, pReqHdr);
    23152314#endif
    23162315        /*

  • trunk/src/VBox/VMM/VMMRZ/CPUMRZ.cpp

    r80274 r80281  
    2424#include <VBox/vmm/cpum.h>
    2525#include "CPUMInternal.h"
    26 #include <VBox/vmm/vm.h>
     26#include <VBox/vmm/vmcc.h>
     27
    2728#include <VBox/err.h>
    2829#include <VBox/log.h>
    … …  
    4445 * @param   pVCpu       The cross context virtual CPU structure.
    4546 */
    46 VMMRZ_INT_DECL(void)    CPUMRZFpuStatePrepareHostCpuForUse(PVMCPU pVCpu)
     47VMMRZ_INT_DECL(void)    CPUMRZFpuStatePrepareHostCpuForUse(PVMCPUCC pVCpu)
    4748{
    4849    pVCpu->cpum.s.fChanged |= CPUM_CHANGED_FPU_REM;
    … …  
    8283 * @param   pVCpu       The cross context virtual CPU structure.
    8384 */
    84 VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeForChange(PVMCPU pVCpu)
     85VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeForChange(PVMCPUCC pVCpu)
    8586{
    8687    CPUMRZFpuStatePrepareHostCpuForUse(pVCpu);
    … …  
    9596 * @param   pVCpu       The cross context virtual CPU structure.
    9697 */
    97 VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeForRead(PVMCPU pVCpu)
     98VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeForRead(PVMCPUCC pVCpu)
    9899{
    99100    if (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_GUEST)
    … …  
    113114 * @param   pVCpu       The cross context virtual CPU structure.
    114115 */
    115 VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeSseForRead(PVMCPU pVCpu)
     116VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeSseForRead(PVMCPUCC pVCpu)
    116117{
    117118#if defined(VBOX_WITH_KERNEL_USING_XMM) && HC_ARCH_BITS == 64
    … …  
    134135 * @param   pVCpu       The cross context virtual CPU structure.
    135136 */
    136 VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeAvxForRead(PVMCPU pVCpu)
     137VMMRZ_INT_DECL(void)    CPUMRZFpuStateActualizeAvxForRead(PVMCPUCC pVCpu)
    137138{
    138139    if (pVCpu->cpum.s.fUseFlags & CPUM_USED_FPU_GUEST)

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

    r80062 r80281  
    14281428                                             uint8_t uVector, uint8_t uPolarity, uint8_t uTriggerMode, uint32_t uSrcTag);
    14291429
    1430 VMM_INT_DECL(bool)            apicPostInterrupt(PVMCPU pVCpu, uint8_t uVector, XAPICTRIGGERMODE enmTriggerMode, uint32_t uSrcTag);
    1431 VMM_INT_DECL(void)            apicStartTimer(PVMCPU pVCpu, uint32_t uInitialCount);
    1432 VMM_INT_DECL(void)            apicClearInterruptFF(PVMCPU pVCpu, PDMAPICIRQ enmType);
    1433 void                          apicInitIpi(PVMCPU pVCpu);
    1434 void                          apicResetCpu(PVMCPU pVCpu, bool fResetApicBaseMsr);
     1430VMM_INT_DECL(bool)            apicPostInterrupt(PVMCPUCC pVCpu, uint8_t uVector, XAPICTRIGGERMODE enmTriggerMode, uint32_t uSrcTag);
     1431VMM_INT_DECL(void)            apicStartTimer(PVMCPUCC pVCpu, uint32_t uInitialCount);
     1432VMM_INT_DECL(void)            apicClearInterruptFF(PVMCPUCC pVCpu, PDMAPICIRQ enmType);
     1433void                          apicInitIpi(PVMCPUCC pVCpu);
     1434void                          apicResetCpu(PVMCPUCC pVCpu, bool fResetApicBaseMsr);
    14351435
    14361436RT_C_DECLS_END

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

    r80268 r80281  
    13211321
    13221322#ifdef IN_RING0
    1323 VMMR0_INT_DECL(int)             gimR0HvInitVM(PVM pVM);
    1324 VMMR0_INT_DECL(int)             gimR0HvTermVM(PVM pVM);
    1325 VMMR0_INT_DECL(int)             gimR0HvUpdateParavirtTsc(PVM pVM, uint64_t u64Offset);
     1323VMMR0_INT_DECL(int)             gimR0HvInitVM(PVMCC pVM);
     1324VMMR0_INT_DECL(int)             gimR0HvTermVM(PVMCC pVM);
     1325VMMR0_INT_DECL(int)             gimR0HvUpdateParavirtTsc(PVMCC pVM, uint64_t u64Offset);
    13261326#endif /* IN_RING0 */
    13271327

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

    r80268 r80281  
    247247
    248248#ifdef IN_RING0
    249 VMMR0_INT_DECL(int)             gimR0KvmInitVM(PVM pVM);
    250 VMMR0_INT_DECL(int)             gimR0KvmTermVM(PVM pVM);
    251 VMMR0_INT_DECL(int)             gimR0KvmUpdateSystemTime(PVM pVM, PVMCPU pVCpu);
     249VMMR0_INT_DECL(int)             gimR0KvmInitVM(PVMCC pVM);
     250VMMR0_INT_DECL(int)             gimR0KvmTermVM(PVMCC pVM);
     251VMMR0_INT_DECL(int)             gimR0KvmUpdateSystemTime(PVMCC pVM, PVMCPUCC pVCpu);
    252252#endif /* IN_RING0 */
    253253
    … …  
    272272VMM_INT_DECL(VBOXSTRICTRC)      gimKvmWriteMsr(PVMCPUCC pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uRawValue);
    273273VMM_INT_DECL(bool)              gimKvmShouldTrapXcptUD(PVM pVM);
    274 VMM_INT_DECL(VBOXSTRICTRC)      gimKvmXcptUD(PVM pVM, PVMCPUCC pVCpu, PCPUMCTX pCtx, PDISCPUSTATE pDis, uint8_t *pcbInstr);
     274VMM_INT_DECL(VBOXSTRICTRC)      gimKvmXcptUD(PVMCC pVM, PVMCPUCC pVCpu, PCPUMCTX pCtx, PDISCPUSTATE pDis, uint8_t *pcbInstr);
    275275VMM_INT_DECL(VBOXSTRICTRC)      gimKvmHypercallEx(PVMCPUCC pVCpu, PCPUMCTX pCtx, unsigned uDisOpcode, uint8_t cbInstr);
    276276

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

    r80274 r80281  
    11711171#ifdef IN_RING0
    11721172VMMR0_INT_DECL(PHMPHYSCPU)  hmR0GetCurrentCpu(void);
    1173 VMMR0_INT_DECL(int)         hmR0EnterCpu(PVMCPU pVCpu);
     1173VMMR0_INT_DECL(int)         hmR0EnterCpu(PVMCPUCC pVCpu);
    11741174
    11751175# ifdef VBOX_STRICT
    … …  
    11791179#  define HM_DUMP_REG_FLAGS_ALL       (HM_DUMP_REG_FLAGS_GPRS | HM_DUMP_REG_FLAGS_FPU | HM_DUMP_REG_FLAGS_MSRS)
    11801180
    1181 VMMR0_INT_DECL(void)        hmR0DumpRegs(PVMCPU pVCpu, uint32_t fFlags);
     1181VMMR0_INT_DECL(void)        hmR0DumpRegs(PVMCPUCC pVCpu, uint32_t fFlags);
    11821182VMMR0_INT_DECL(void)        hmR0DumpDescriptor(PCX86DESCHC pDesc, RTSEL Sel, const char *pszMsg);
    11831183# endif
    11841184
    11851185# ifdef VBOX_WITH_KERNEL_USING_XMM
    1186 DECLASM(int)                hmR0VMXStartVMWrapXMM(RTHCUINT fResume, PCPUMCTX pCtx, void *pvUnused, PVM pVM, PVMCPU pVCpu,
     1186DECLASM(int)                hmR0VMXStartVMWrapXMM(RTHCUINT fResume, PCPUMCTX pCtx, void *pvUnused, PVMCC pVM, PVMCPUCC pVCpu,
    11871187                                                  PFNHMVMXSTARTVM pfnStartVM);
    1188 DECLASM(int)                hmR0SVMRunWrapXMM(RTHCPHYS pVmcbHostPhys, RTHCPHYS pVmcbPhys, PCPUMCTX pCtx, PVM pVM, PVMCPU pVCpu,
     1188DECLASM(int)                hmR0SVMRunWrapXMM(RTHCPHYS pVmcbHostPhys, RTHCPHYS pVmcbPhys, PCPUMCTX pCtx, PVMCC pVM, PVMCPUCC pVCpu,
    11891189                                              PFNHMSVMVMRUN pfnVMRun);
    11901190# endif

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

    r76585 r80281  
    131131 * @param   pRange  The range to release.
    132132 */
    133 DECLINLINE(void) iomMmioReleaseRange(PVM pVM, PIOMMMIORANGE pRange)
     133DECLINLINE(void) iomMmioReleaseRange(PVMCC pVM, PIOMMMIORANGE pRange)
    134134{
    135135    uint32_t cRefs = ASMAtomicDecU32(&pRange->cRefs);

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

    r80090 r80281  
    454454RT_C_DECLS_BEGIN
    455455
    456 void                iomMmioFreeRange(PVM pVM, PIOMMMIORANGE pRange);
     456void                iomMmioFreeRange(PVMCC pVM, PIOMMMIORANGE pRange);
    457457#ifdef IN_RING3
    458458PIOMMMIOSTATS       iomR3MMIOStatsCreate(PVM pVM, RTGCPHYS GCPhys, const char *pszDesc);

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

    r80274 r80281  
    428428#endif
    429429
    430 void    nemHCNativeNotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb);
    431 void    nemHCNativeNotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb,
     430void    nemHCNativeNotifyHandlerPhysicalRegister(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb);
     431void    nemHCNativeNotifyHandlerPhysicalDeregister(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhys, RTGCPHYS cb,
    432432                                                   int fRestoreAsRAM, bool fRestoreAsRAM2);
    433 void    nemHCNativeNotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhysOld,
     433void    nemHCNativeNotifyHandlerPhysicalModify(PVMCC pVM, PGMPHYSHANDLERKIND enmKind, RTGCPHYS GCPhysOld,
    434434                                               RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fRestoreAsRAM);
    435 int     nemHCNativeNotifyPhysPageAllocated(PVM pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
     435int     nemHCNativeNotifyPhysPageAllocated(PVMCC pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
    436436                                           PGMPAGETYPE enmType, uint8_t *pu2State);
    437 void    nemHCNativeNotifyPhysPageProtChanged(PVM pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
     437void    nemHCNativeNotifyPhysPageProtChanged(PVMCC pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint32_t fPageProt,
    438438                                             PGMPAGETYPE enmType, uint8_t *pu2State);
    439 void    nemHCNativeNotifyPhysPageChanged(PVM pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhysPrev, RTHCPHYS HCPhysNew, uint32_t fPageProt,
     439void    nemHCNativeNotifyPhysPageChanged(PVMCC pVM, RTGCPHYS GCPhys, RTHCPHYS HCPhysPrev, RTHCPHYS HCPhysNew, uint32_t fPageProt,
    440440                                         PGMPAGETYPE enmType, uint8_t *pu2State);
    441441

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

    r80274 r80281  
    285285    PVMR3                           pVMR3;
    286286    /** Pointer to the VM - R0Ptr. */
    287     PVMR0                           pVMR0;
     287    R0PTRTYPE(PVMCC)                pVMR0;
    288288    /** Pointer to the VM - GCPtr. */
    289289    PVMRC                           pVMRC;
    … …  
    338338    PVMR3                               pVMR3;
    339339    /** Pointer to the VM - R0Ptr. */
    340     PVMR0                               pVMR0;
     340    R0PTRTYPE(PVMCC)                    pVMR0;
    341341    /** Pointer to the VM - GCPtr. */
    342342    PVMRC                               pVMRC;
    … …  
    13071307#endif /* IN_RING3 */
    13081308
    1309 void        pdmLock(PVM pVM);
    1310 int         pdmLockEx(PVM pVM, int rc);
    1311 void        pdmUnlock(PVM pVM);
     1309void        pdmLock(PVMCC pVM);
     1310int         pdmLockEx(PVMCC pVM, int rc);
     1311void        pdmUnlock(PVMCC pVM);
    13121312
    13131313#if defined(IN_RING3) || defined(IN_RING0)

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

    r80268 r80281  
    38383838
    38393839#if defined(VBOX_STRICT) && defined(IN_RING3)
    3840 int             pgmLockDebug(PVM pVM, RT_SRC_POS_DECL);
     3840int             pgmLockDebug(PVMCC pVM, RT_SRC_POS_DECL);
    38413841# define pgmLock(a_pVM) pgmLockDebug(a_pVM, RT_SRC_POS)
    38423842#else
    3843 int             pgmLock(PVM pVM);
     3843int             pgmLock(PVMCC pVM);
    38443844#endif
    38453845void            pgmUnlock(PVM pVM);
    … …  
    38673867#endif /* !PGM_WITHOUT_MAPPINGS */
    38683868
    3869 int             pgmHandlerPhysicalExCreate(PVM pVM, PGMPHYSHANDLERTYPE hType, RTR3PTR pvUserR3, RTR0PTR pvUserR0,
     3869int             pgmHandlerPhysicalExCreate(PVMCC pVM, PGMPHYSHANDLERTYPE hType, RTR3PTR pvUserR3, RTR0PTR pvUserR0,
    38703870                                           RTRCPTR pvUserRC, R3PTRTYPE(const char *) pszDesc, PPGMPHYSHANDLER *ppPhysHandler);
    3871 int             pgmHandlerPhysicalExDup(PVM pVM, PPGMPHYSHANDLER pPhysHandlerSrc, PPGMPHYSHANDLER *ppPhysHandler);
     3871int             pgmHandlerPhysicalExDup(PVMCC pVM, PPGMPHYSHANDLER pPhysHandlerSrc, PPGMPHYSHANDLER *ppPhysHandler);
    38723872int             pgmHandlerPhysicalExRegister(PVMCC pVM, PPGMPHYSHANDLER pPhysHandler, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast);
    38733873int             pgmHandlerPhysicalExDeregister(PVMCC pVM, PPGMPHYSHANDLER pPhysHandler, int fRestoreAsRAM);
    3874 int             pgmHandlerPhysicalExDestroy(PVM pVM, PPGMPHYSHANDLER pHandler);
     3874int             pgmHandlerPhysicalExDestroy(PVMCC pVM, PPGMPHYSHANDLER pHandler);
    38753875void            pgmR3HandlerPhysicalUpdateAll(PVM pVM);
    38763876bool            pgmHandlerPhysicalIsAll(PVMCC pVM, RTGCPHYS GCPhys);
    … …  
    39043904int             pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys,
    39053905                                PGMPAGETYPE enmNewType);
    3906 void            pgmPhysInvalidRamRangeTlbs(PVM pVM);
    3907 void            pgmPhysInvalidatePageMapTLB(PVM pVM);
     3906void            pgmPhysInvalidRamRangeTlbs(PVMCC pVM);
     3907void            pgmPhysInvalidatePageMapTLB(PVMCC pVM);
    39083908void            pgmPhysInvalidatePageMapTLBEntry(PVM pVM, RTGCPHYS GCPhys);
    39093909PPGMRAMRANGE    pgmPhysGetRangeSlow(PVM pVM, RTGCPHYS GCPhys);
    … …  
    39423942# endif
    39433943#endif
    3944 int             pgmPoolAlloc(PVM pVM, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, PGMPOOLACCESS enmAccess, bool fA20Enabled,
     3944int             pgmPoolAlloc(PVMCC pVM, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, PGMPOOLACCESS enmAccess, bool fA20Enabled,
    39453945                             uint16_t iUser, uint32_t iUserTable, bool fLockPage, PPPGMPOOLPAGE ppPage);
    39463946void            pgmPoolFree(PVM pVM, RTHCPHYS HCPhys, uint16_t iUser, uint32_t iUserTable);
    … …  
    39553955int             pgmPoolTrackUpdateGCPhys(PVMCC pVM, RTGCPHYS GCPhysPage, PPGMPAGE pPhysPage, bool fFlushPTEs, bool *pfFlushTLBs);
    39563956void            pgmPoolTracDerefGCPhysHint(PPGMPOOL pPool, PPGMPOOLPAGE pPage, RTHCPHYS HCPhys, RTGCPHYS GCPhysHint, uint16_t iPte);
    3957 uint16_t        pgmPoolTrackPhysExtAddref(PVM pVM, PPGMPAGE pPhysPage, uint16_t u16, uint16_t iShwPT, uint16_t iPte);
     3957uint16_t        pgmPoolTrackPhysExtAddref(PVMCC pVM, PPGMPAGE pPhysPage, uint16_t u16, uint16_t iShwPT, uint16_t iPte);
    39583958void            pgmPoolTrackPhysExtDerefGCPhys(PPGMPOOL pPool, PPGMPOOLPAGE pPoolPage, PPGMPAGE pPhysPage, uint16_t iPte);
    39593959void            pgmPoolMonitorChainFlush(PPGMPOOL pPool, PPGMPOOLPAGE pPage);

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

    r80268 r80281  
    789789int                     tmCpuTickResumeLocked(PVMCC pVM, PVMCPUCC pVCpu);
    790790
    791 int                     tmVirtualPauseLocked(PVM pVM);
    792 int                     tmVirtualResumeLocked(PVM pVM);
     791int                     tmVirtualPauseLocked(PVMCC pVM);
     792int                     tmVirtualResumeLocked(PVMCC pVM);
    793793DECLCALLBACK(DECLEXPORT(void))      tmVirtualNanoTSBad(PRTTIMENANOTSDATA pData, uint64_t u64NanoTS,
    794794                                                       uint64_t u64DeltaPrev, uint64_t u64PrevNanoTS);

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

    r80274 r80281  
    473473 * @param   pVM         The cross context VM structure.
    474474 */
    475 typedef DECLCALLBACK(int) FNVMMR0SETJMP(PVM pVM, PVMCPU pVCpu);
     475typedef DECLCALLBACK(int) FNVMMR0SETJMP(PVMCC pVM, PVMCPUCC pVCpu);
    476476/** Pointer to FNVMMR0SETJMP(). */
    477477typedef FNVMMR0SETJMP *PFNVMMR0SETJMP;

  • trunk/src/VBox/VMM/testcase/tstSSM.cpp

    r76553 r80281  
    652652                 * Allocate and init the VM structure.
    653653                 */
    654                 PVM pVM;
    655                 rc = SUPR3PageAlloc((sizeof(*pVM) + PAGE_SIZE - 1) >> PAGE_SHIFT, (void **)&pVM);
     654#ifdef VBOX_BUGREF_9217
     655                PVM pVM = (PVM)RTMemPageAllocZ(sizeof(VM) + sizeof(VMCPU));
     656                rc = pVM ? VINF_SUCCESS : VERR_NO_PAGE_MEMORY;
     657#else
     658                PVM    pVM;
     659                size_t cbVM = RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE);
     660                rc = SUPR3PageAlloc(cbVM >> PAGE_SHIFT, (void **)&pVM);
     661#endif
    656662                if (RT_SUCCESS(rc))
    657663                {
    … …  
    660666                    pVM->pUVM = pUVM;
    661667                    pVM->cCpus = 1;
     668
     669#ifdef VBOX_BUGREF_9217
     670                    PVMCPU pVCpu = (PVMCPU)(pVM + 1);
     671                    pVM->apCpusR3[0]= pVCpu;
     672                    pVCpu->pVMR3 = pVM;
     673                    pVCpu->hNativeThread = RTThreadNativeSelf();
     674#else
    662675                    pVM->aCpus[0].pVMR3 = pVM;
    663676                    pVM->aCpus[0].hNativeThread = RTThreadNativeSelf();
     677#endif
    664678
    665679                    pUVM->pVM = pVM;
    … …  
    708722     * Init runtime and static data.
    709723     */
     724#ifdef VBOX_BUGREF_9217
     725    int rc = RTR3InitExe(argc, &argv, 0);
     726    AssertRCReturn(rc, RTEXITCODE_INIT);
     727#else
    710728    RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
     729#endif
    711730    RTPrintf("tstSSM: TESTING...\n");
    712731    initBigMem();
    … …  
    716735     * Create an fake VM structure and init SSM.
    717736     */
     737#ifndef VBOX_BUGREF_9217
    718738    int rc = SUPR3Init(NULL);
    719739    if (RT_FAILURE(rc))
    … …  
    722742        return 1;
    723743    }
     744#endif
    724745    PVM pVM;
    725746    if (createFakeVM(&pVM))

  • trunk/src/VBox/VMM/testcase/tstVMStruct.h

    r80191 r80281  
    14191419    GEN_CHECK_OFF(VM, pUVM);
    14201420    GEN_CHECK_OFF(VM, pVMR3);
     1421#ifdef VBOX_BUGREF_9217
     1422    GEN_CHECK_OFF(VM, pVMR0ForCall);
     1423#else
    14211424    GEN_CHECK_OFF(VM, pVMR0);
     1425#endif
    14221426    GEN_CHECK_OFF(VM, pVMRC);
     1427#if defined(VBOX_BUGREF_9217) && defined(IN_RING0)
     1428    GEN_CHECK_OFF(VM, hSelfUnsafe);
     1429    GEN_CHECK_OFF(VM, cCpusUnsafe);
     1430#else
    14231431    GEN_CHECK_OFF(VM, hSelf);
    14241432    GEN_CHECK_OFF(VM, cCpus);
     1433#endif
    14251434    GEN_CHECK_OFF(VM, uCpuExecutionCap);
    14261435    GEN_CHECK_OFF(VM, cbSelf);
    … …  
    14541463    GEN_CHECK_OFF(VM, cfgm);
    14551464    GEN_CHECK_OFF(VM, apic);
     1465#ifndef VBOX_BUGREF_9217
    14561466    GEN_CHECK_OFF(VM, aCpus);
     1467#endif
    14571468
    14581469
    … …  
    14621473    GEN_CHECK_OFF(VMCPU, pUVCpu);
    14631474    GEN_CHECK_OFF(VMCPU, pVMR3);
     1475#ifndef VBOX_BUGREF_9217
    14641476    GEN_CHECK_OFF(VMCPU, pVMR0);
     1477#endif
    14651478    GEN_CHECK_OFF(VMCPU, pVMRC);
    14661479    GEN_CHECK_OFF(VMCPU, idCpu);

  • trunk/src/VBox/VMM/testcase/tstVMStructSize.cpp

    r80191 r80281  
    254254
    255255    PVM pVM = NULL; NOREF(pVM);
     256#ifndef VBOX_BUGREF_9217
    256257    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0], PAGE_SIZE);
    257258    CHECK_MEMBER_ALIGNMENT(VM, aCpus[1], PAGE_SIZE);
    … …  
    262263    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Hyper, 64);
    263264    CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Hyper, 64);
    264 #ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
     265# ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
    265266    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.pvApicBase, 8);
    266 #endif
     267# endif
    267268
    268269    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].iem.s.DataTlb, 64);
    269270    CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].iem.s.CodeTlb, 64);
     271#endif
    270272
    271273    CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.u64CallRing3Arg, 8);
    … …  
    282284
    283285    /* the VMCPUs are page aligned TLB hit reasons. */
     286#ifndef VBOX_BUGREF_9217
    284287    CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096);
     288#endif
    285289    CHECK_SIZE_ALIGNMENT(VMCPU, 4096);
    286290
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