VirtualBox

Changeset 78431 in vbox for trunk/src/VBox


Ignore:
Timestamp:
May 7, 2019 2:01:45 PM (6 years ago)
Author:
vboxsync
Message:

VMM: Started refactoring GVM & VM structures for bugref:9217

Location:
trunk/src/VBox
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/Support/testcase/tstInt.cpp

    r76553 r78431  
    9898                AssertRelease(pVM->pSession == pSession);
    9999                AssertRelease(pVM->cCpus == 1);
     100#ifdef VBOX_WITH_RAW_MODE
    100101                AssertRelease(pVM->offVMCPU == RT_UOFFSETOF(VM, aCpus));
     102#endif
    101103                pVM->enmVMState = VMSTATE_CREATED;
    102104                PVMR0 const pVMR0 = pVM->pVMR0;

  • trunk/src/VBox/VMM/Config.kmk

    r76553 r78431  
    8282 VMM_COMMON_DEFS += VBOX_WITH_MORE_RING0_MEM_MAPPINGS
    8383endif
     84ifdef VBOX_BUGREF_9217
     85 VMM_COMMON_DEFS += VBOX_BUGREF_9217
     86endif
    8487
    8588# VMM_COMMON_DEFS += VBOX_WITH_NS_ACCOUNTING_STATS

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

    r76886 r78431  
    2424#include "CPUMInternal.h"
    2525#include <VBox/vmm/vm.h>
     26#include <VBox/vmm/gvm.h>
    2627#include <VBox/err.h>
    2728#include <VBox/log.h>
    … …  
    334335    if (u32DR7 & X86_DR7_ENABLED_MASK)
    335336    {
     337#ifdef VBOX_BUGREF_9217
     338        PGVM pGVM = (PGVM)pVM;
     339        for (VMCPUID i = 0; i < pGVM->cCpusSafe; i++)
     340            pGVM->aCpus[i].cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HOST;
     341#else
    336342        for (VMCPUID i = 0; i < pVM->cCpus; i++)
    337343            pVM->aCpus[i].cpum.s.fUseFlags |= CPUM_USE_DEBUG_REGS_HOST;
     344#endif
    338345        Log(("CPUMR0Init: host uses debug registers (dr7=%x)\n", u32DR7));
    339346    }

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

    r76553 r78431  
    3939 * @param   pVM             The cross context VM structure.
    4040 */
     41#ifdef VBOX_BUGREF_9217
     42VMMR0_INT_DECL(int) EMR0InitVM(PGVM pGVM)
     43# define pVM pGVM /* temp hack */
     44#else
    4145VMMR0_INT_DECL(int) EMR0InitVM(PGVM pGVM, PVM pVM)
     46#endif
    4247{
    4348    /*
    … …  
    5055                                  && pVM->aCpus[0].em.s.fExitOptimizationEnabledR0PreemptDisabled
    5156                                  && RTThreadPreemptIsPendingTrusty();
     57#ifdef VBOX_BUGREF_9217
     58    for (VMCPUID i = 0; i < pGVM->cCpusSafe; i++)
     59#else
    5260    for (VMCPUID i = 0; i < pGVM->cCpus; i++)
     61#endif
    5362    {
    5463        pVM->aCpus[i].em.s.fExitOptimizationEnabledR0                = fEnabledR0;

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

    r77126 r78431  
    360360*   Internal Functions                                                                                                           *
    361361*********************************************************************************************************************************/
     362#ifdef VBOX_BUGREF_9217
     363static void gvmmR0InitPerVMData(PGVM pGVM, int16_t hSelf, VMCPUID cCpus, PSUPDRVSESSION pSession);
     364#else
    362365static void gvmmR0InitPerVMData(PGVM pGVM);
     366#endif
    363367static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void *pvObj, void *pvGVMM, void *pvHandle);
    364368static int gvmmR0ByGVMandVM(PGVM pGVM, PVM pVM, PGVMM *ppGVMM, bool fTakeUsedLock);
    … …  
    888892                if (RT_SUCCESS(rc))
    889893                {
     894#ifdef VBOX_BUGREF_9217
     895                    /*
     896                     * Allocate memory for the VM structure (combined VM + GVM).
     897                     */
     898                    const uint32_t  cbVM      = RT_UOFFSETOF_DYN(GVM, aCpus[cCpus]);
     899                    const uint32_t  cPages    = RT_ALIGN_32(cbVM, PAGE_SIZE) >> PAGE_SHIFT;
     900                    RTR0MEMOBJ      hVMMemObj = NIL_RTR0MEMOBJ;
     901# if defined(VBOX_WITH_RAW_MODE) || HC_ARCH_BITS == 32
     902                    rc = RTR0MemObjAllocLow(&hVMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
     903# else
     904                    rc = RTR0MemObjAllocPage(&hVMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
     905# endif
     906                    if (RT_SUCCESS(rc))
     907                    {
     908                        PGVM pGVM = (PGVM)RTR0MemObjAddress(hVMMemObj);
     909                        AssertPtr(pGVM);
     910
     911                        /*
     912                         * Initialise the structure.
     913                         */
     914                        RT_BZERO(pGVM, cPages << PAGE_SHIFT);
     915                        gvmmR0InitPerVMData(pGVM, iHandle, cCpus, pSession);
     916                        GMMR0InitPerVMData(pGVM);
     917                        pGVM->gvmm.s.VMMemObj  = hVMMemObj;
     918
     919                        /*
     920                         * Allocate page array.
     921                         * This currently have to be made available to ring-3, but this is should change eventually.
     922                         */
     923                        rc = RTR0MemObjAllocPage(&pGVM->gvmm.s.VMPagesMemObj, cPages * sizeof(SUPPAGE), false /* fExecutable */);
     924                        if (RT_SUCCESS(rc))
     925                        {
     926                            PSUPPAGE paPages = (PSUPPAGE)RTR0MemObjAddress(pGVM->gvmm.s.VMPagesMemObj); AssertPtr(paPages);
     927                            for (uint32_t iPage = 0; iPage < cPages; iPage++)
     928                            {
     929                                paPages[iPage].uReserved = 0;
     930                                paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pGVM->gvmm.s.VMMemObj, iPage);
     931                                Assert(paPages[iPage].Phys != NIL_RTHCPHYS);
     932                            }
     933
     934                            /*
     935                             * Map the page array, VM and VMCPU structures into ring-3.
     936                             */
     937                            AssertCompileSizeAlignment(VM, PAGE_SIZE);
     938                            rc = RTR0MemObjMapUserEx(&pGVM->gvmm.s.VMMapObj, pGVM->gvmm.s.VMMemObj, (RTR3PTR)-1, 0,
     939                                                     RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS,
     940                                                     0 /*offSub*/, sizeof(VM));
     941                            for (VMCPUID i = 0; i < cCpus && RT_SUCCESS(rc); i++)
     942                            {
     943                                AssertCompileSizeAlignment(VMCPU, PAGE_SIZE);
     944                                rc = RTR0MemObjMapUserEx(&pGVM->aCpus[i].gvmm.s.VMCpuMapObj, pGVM->gvmm.s.VMMemObj,
     945                                                         (RTR3PTR)-1, 0, RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS,
     946                                                         RT_UOFFSETOF_DYN(GVM, aCpus[i]), sizeof(VMCPU));
     947                            }
     948                            if (RT_SUCCESS(rc))
     949                                rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMPagesMapObj, pGVM->gvmm.s.VMPagesMemObj, (RTR3PTR)-1,
     950                                                       0 /* uAlignment */, RTMEM_PROT_READ | RTMEM_PROT_WRITE,
     951                                                       NIL_RTR0PROCESS);
     952                            if (RT_SUCCESS(rc))
     953                            {
     954                                /*
     955                                 * Initialize all the VM pointer.
     956                                 */
     957                                PVMR3 pVMR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMMapObj);
     958                                AssertPtr((void *)pVMR3);
     959
     960                                for (VMCPUID i = 0; i < cCpus; i++)
     961                                {
     962                                    pGVM->aCpus[i].pVMR0 = pGVM;
     963                                    pGVM->aCpus[i].pVMR3 = pVMR3;
     964                                    pGVM->apCpus[i] = RTR0MemObjAddressR3(pGVM->aCpus[i].gvmm.s.VMCpuMapObj);
     965                                    AssertPtr((void *)pGVM->apCpus[i]);
     966                                }
     967
     968                                pGVM->paVMPagesR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMPagesMapObj);
     969                                AssertPtr((void *)pGVM->paVMPagesR3);
     970
     971                                /*
     972                                 * Complete the handle - take the UsedLock sem just to be careful.
     973                                 */
     974                                rc = GVMMR0_USED_EXCLUSIVE_LOCK(pGVMM);
     975                                AssertRC(rc);
     976
     977                                pHandle->pVM                    = pGVM;
     978                                pHandle->pGVM                   = pGVM;
     979                                pHandle->hEMT0                  = hEMT0;
     980                                pHandle->ProcId                 = ProcId;
     981                                pGVM->pVMR3                     = pVMR3;
     982                                pGVM->aCpus[0].hEMT             = hEMT0;
     983                                pGVM->aCpus[0].hNativeThreadR0  = hEMT0;
     984                                pGVMM->cEMTs += cCpus;
     985
     986                                /* Associate it with the session and create the context hook for EMT0. */
     987                                rc = SUPR0SetSessionVM(pSession, pGVM, pGVM);
     988                                if (RT_SUCCESS(rc))
     989                                {
     990                                    rc = VMMR0ThreadCtxHookCreateForEmt(&pGVM->aCpus[0]);
     991                                    if (RT_SUCCESS(rc))
     992                                    {
     993                                        /*
     994                                         * Done!
     995                                         */
     996                                        VBOXVMM_R0_GVMM_VM_CREATED(pGVM, pGVM, ProcId, (void *)hEMT0, cCpus);
     997
     998                                        GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
     999                                        gvmmR0CreateDestroyUnlock(pGVMM);
     1000
     1001                                        CPUMR0RegisterVCpuThread(&pGVM->aCpus[0]);
     1002
     1003                                        *ppVM = pGVM;
     1004                                        Log(("GVMMR0CreateVM: pVMR3=%p pGVM=%p hGVM=%d\n", pVMR3, pGVM, iHandle));
     1005                                        return VINF_SUCCESS;
     1006                                    }
     1007
     1008                                    SUPR0SetSessionVM(pSession, NULL, NULL);
     1009                                }
     1010                                GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
     1011                            }
     1012
     1013                            /* Cleanup mappings. */
     1014                            if (pGVM->gvmm.s.VMMapObj != NIL_RTR0MEMOBJ)
     1015                            {
     1016                                RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */);
     1017                                pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
     1018                            }
     1019                            for (VMCPUID i = 0; i < cCpus; i++)
     1020                                if (pGVM->aCpus[i].gvmm.s.VMCpuMapObj != NIL_RTR0MEMOBJ)
     1021                                {
     1022                                    RTR0MemObjFree(pGVM->aCpus[i].gvmm.s.VMCpuMapObj, false /* fFreeMappings */);
     1023                                    pGVM->aCpus[i].gvmm.s.VMCpuMapObj = NIL_RTR0MEMOBJ;
     1024                                }
     1025                            if (pGVM->gvmm.s.VMPagesMapObj != NIL_RTR0MEMOBJ)
     1026                            {
     1027                                RTR0MemObjFree(pGVM->gvmm.s.VMPagesMapObj, false /* fFreeMappings */);
     1028                                pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
     1029                            }
     1030                        }
     1031                    }
     1032
     1033#else
    8901034                    /*
    8911035                     * Allocate the global VM structure (GVM) and initialize it.
    … …  
    9201064                            pVM->cCpus            = cCpus;
    9211065                            pVM->uCpuExecutionCap = 100; /* default is no cap. */
     1066# ifdef VBOX_WITH_RAW_MODE
    9221067                            pVM->offVMCPU         = RT_UOFFSETOF_DYN(VM, aCpus);
     1068# endif
    9231069                            AssertCompileMemberAlignment(VM, cpum, 64);
    9241070                            AssertCompileMemberAlignment(VM, tm, 64);
    … …  
    10221168                        }
    10231169                    }
     1170#endif
    10241171                }
    10251172                /* else: The user wasn't permitted to create this VM. */
    … …  
    10351182                SUPR0ObjRelease(pvObj, pSession);
    10361183
    1037                 SUPR0Printf("GVMMR0CreateVM: failed, rc=%d\n", rc);
     1184                SUPR0Printf("GVMMR0CreateVM: failed, rc=%Rrc\n", rc);
    10381185                return rc;
    10391186            }
    … …  
    10521199
    10531200
     1201#ifdef VBOX_BUGREF_9217
    10541202/**
    10551203 * Initializes the per VM data belonging to GVMM.
    … …  
    10571205 * @param   pGVM        Pointer to the global VM structure.
    10581206 */
     1207static void gvmmR0InitPerVMData(PGVM pGVM, int16_t hSelf, VMCPUID cCpus, PSUPDRVSESSION pSession)
     1208#else
     1209/**
     1210 * Initializes the per VM data belonging to GVMM.
     1211 *
     1212 * @param   pGVM        Pointer to the global VM structure.
     1213 */
    10591214static void gvmmR0InitPerVMData(PGVM pGVM)
     1215#endif
    10601216{
    10611217    AssertCompile(RT_SIZEOFMEMB(GVM,gvmm.s) <= RT_SIZEOFMEMB(GVM,gvmm.padding));
    10621218    AssertCompile(RT_SIZEOFMEMB(GVMCPU,gvmm.s) <= RT_SIZEOFMEMB(GVMCPU,gvmm.padding));
    1063     pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
    1064     pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
    1065     pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
    1066     pGVM->gvmm.s.VMPagesMapObj = NIL_RTR0MEMOBJ;
     1219#ifdef VBOX_BUGREF_9217
     1220    AssertCompileMemberAlignment(VM, cpum, 64);
     1221    AssertCompileMemberAlignment(VM, tm, 64);
     1222
     1223    /* GVM: */
     1224    pGVM->u32Magic         = GVM_MAGIC;
     1225    pGVM->hSelfSafe        = hSelf;
     1226    pGVM->cCpusSafe        = cCpus;
     1227    pGVM->pSessionSafe     = pSession;
     1228
     1229    /* VM: */
     1230    pGVM->enmVMState       = VMSTATE_CREATING;
     1231    pGVM->pVMR0            = pGVM;
     1232    pGVM->pSession         = pSession;
     1233    pGVM->hSelf            = hSelf;
     1234    pGVM->cCpus            = cCpus;
     1235    pGVM->uCpuExecutionCap = 100; /* default is no cap. */
     1236    pGVM->uStructVersion   = 1;
     1237    pGVM->cbSelf           = sizeof(VM);
     1238    pGVM->cbVCpu           = sizeof(VMCPU);
     1239# ifdef VBOX_WITH_RAW_MODE
     1240    pGVM->offVMCPU         = RT_UOFFSETOF_DYN(GVM, aCpus); /** @todo set this when mapping the VM structure into raw-mode context */
     1241# endif
     1242#endif
     1243
     1244    /* GVMM: */
     1245    pGVM->gvmm.s.VMMemObj       = NIL_RTR0MEMOBJ;
     1246    pGVM->gvmm.s.VMMapObj       = NIL_RTR0MEMOBJ;
     1247    pGVM->gvmm.s.VMPagesMemObj  = NIL_RTR0MEMOBJ;
     1248    pGVM->gvmm.s.VMPagesMapObj  = NIL_RTR0MEMOBJ;
    10671249    pGVM->gvmm.s.fDoneVMMR0Init = false;
    10681250    pGVM->gvmm.s.fDoneVMMR0Term = false;
    10691251
     1252    /*
     1253     * Per virtual CPU.
     1254     */
    10701255    for (VMCPUID i = 0; i < pGVM->cCpus; i++)
    10711256    {
    10721257        pGVM->aCpus[i].idCpu                 = i;
     1258#ifdef VBOX_BUGREF_9217
     1259        pGVM->aCpus[i].idCpuSafe             = i;
     1260#endif
    10731261        pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
     1262#ifdef VBOX_BUGREF_9217
     1263        pGVM->aCpus[i].gvmm.s.VMCpuMapObj    = NIL_RTR0MEMOBJ;
     1264#endif
    10741265        pGVM->aCpus[i].hEMT                  = NIL_RTNATIVETHREAD;
    10751266        pGVM->aCpus[i].pGVM                  = pGVM;
     1267#ifndef VBOX_BUGREF_9217
    10761268        pGVM->aCpus[i].pVCpu                 = NULL;
    10771269        pGVM->aCpus[i].pVM                   = NULL;
     1270#endif
     1271#ifdef VBOX_BUGREF_9217
     1272        pGVM->aCpus[i].idHostCpu             = NIL_RTCPUID;
     1273        pGVM->aCpus[i].iHostCpuSet           = UINT32_MAX;
     1274        pGVM->aCpus[i].hNativeThread         = NIL_RTNATIVETHREAD;
     1275        pGVM->aCpus[i].hNativeThreadR0       = NIL_RTNATIVETHREAD;
     1276        pGVM->aCpus[i].enmState              = VMCPUSTATE_STOPPED;
     1277#endif
    10781278    }
    10791279}
    … …  
    11721372    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
    11731373    AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
     1374#ifdef VBOX_BUGREF_9217
     1375    AssertReturn(pGVM == pVM, VERR_INVALID_POINTER);
     1376#else
    11741377    AssertReturn(pGVM->pVM == pVM, VERR_INVALID_POINTER);
     1378#endif
    11751379    AssertMsgReturn(pVM->enmVMState >= VMSTATE_CREATING && pVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pVM->enmVMState),
    11761380                    VERR_WRONG_ORDER);
    … …  
    12501454    {
    12511455        if (    pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ
    1252             &&  RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM->pVM)
     1456#ifdef VBOX_BUGREF_9217
     1457            &&  RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM
     1458#else
     1459            &&  RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM->pVM
     1460#endif
     1461           )
    12531462        {
    12541463            LogFlow(("gvmmR0CleanupVM: Calling VMMR0TermVM\n"));
     1464#ifdef VBOX_BUGREF_9217
     1465            VMMR0TermVM(pGVM, pGVM, NIL_VMCPUID);
     1466#else
    12551467            VMMR0TermVM(pGVM, pGVM->pVM, NIL_VMCPUID);
     1468#endif
    12561469        }
    12571470        else
     1471#ifdef VBOX_BUGREF_9217
     1472            AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pGVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM));
     1473#else
    12581474            AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM->pVM));
     1475#endif
    12591476    }
    12601477
    … …  
    12651482
    12661483    AssertCompile(NIL_RTTHREADCTXHOOK == (RTTHREADCTXHOOK)0); /* Depends on zero initialized memory working for NIL at the moment. */
     1484#ifdef VBOX_BUGREF_9217
     1485    for (VMCPUID idCpu = 0; idCpu < pGVM->cCpusSafe; idCpu++)
     1486#else
    12671487    for (VMCPUID idCpu = 0; idCpu < pGVM->cCpus; idCpu++)
     1488#endif
    12681489    {
    12691490        /** @todo Can we busy wait here for all thread-context hooks to be
    … …  
    12711492         *        solution for not deregistering hooks everytime we're leaving HMR0
    12721493         *        context. */
     1494#ifdef VBOX_BUGREF_9217
     1495        VMMR0ThreadCtxHookDestroyForEmt(&pGVM->aCpus[idCpu]);
     1496#else
    12731497        VMMR0ThreadCtxHookDestroyForEmt(&pGVM->pVM->aCpus[idCpu]);
     1498#endif
    12741499    }
    12751500}
    … …  
    13971622        }
    13981623
     1624#ifndef VBOX_BUGREF_9217
    13991625        if (pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ)
    14001626        {
    … …  
    14021628            pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
    14031629        }
     1630#endif
    14041631
    14051632        for (VMCPUID i = 0; i < pGVM->cCpus; i++)
    … …  
    14101637                pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
    14111638            }
     1639#ifdef VBOX_BUGREF_9217
     1640            if (pGVM->aCpus[i].gvmm.s.VMCpuMapObj != NIL_RTR0MEMOBJ)
     1641            {
     1642                rc = RTR0MemObjFree(pGVM->aCpus[i].gvmm.s.VMCpuMapObj, false /* fFreeMappings */); AssertRC(rc);
     1643                pGVM->aCpus[i].gvmm.s.VMCpuMapObj = NIL_RTR0MEMOBJ;
     1644            }
     1645#endif
    14121646        }
    14131647
    14141648        /* the GVM structure itself. */
    14151649        pGVM->u32Magic |= UINT32_C(0x80000000);
     1650#ifdef VBOX_BUGREF_9217
     1651        Assert(pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ);
     1652        rc = RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, true /*fFreeMappings*/); AssertRC(rc);
     1653#else
    14161654        RTMemFree(pGVM);
     1655#endif
     1656        pGVM = NULL;
    14171657
    14181658        /* Re-acquire the UsedLock before freeing the handle since we're updating handle fields. */
    … …  
    14661706            if (pGVM->aCpus[idCpu].hEMT == NIL_RTNATIVETHREAD)
    14671707            {
     1708#ifdef VBOX_BUGREF_9217
     1709                Assert(pGVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
     1710#else
    14681711                Assert(pVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
     1712#endif
    14691713
    14701714                /* A thread may only be one EMT. */
    … …  
    14771721                     * Do the assignment, then try setup the hook. Undo if that fails.
    14781722                     */
     1723#ifdef VBOX_BUGREF_9217
     1724                    pGVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = RTThreadNativeSelf();
     1725
     1726                    rc = VMMR0ThreadCtxHookCreateForEmt(&pGVM->aCpus[idCpu]);
     1727                    if (RT_SUCCESS(rc))
     1728                        CPUMR0RegisterVCpuThread(&pGVM->aCpus[idCpu]);
     1729                    else
     1730                        pGVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = NIL_RTNATIVETHREAD;
     1731#else
    14791732                    pVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = RTThreadNativeSelf();
    14801733
    … …  
    14841737                    else
    14851738                        pVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = NIL_RTNATIVETHREAD;
     1739#endif
    14861740                }
    14871741            }
    … …  
    15311785             * Do per-EMT cleanups.
    15321786             */
     1787#ifdef VBOX_BUGREF_9217
     1788            VMMR0ThreadCtxHookDestroyForEmt(&pGVM->aCpus[idCpu]);
     1789#else
    15331790            VMMR0ThreadCtxHookDestroyForEmt(&pVM->aCpus[idCpu]);
     1791#endif
    15341792
    15351793            /*
    … …  
    15391797            AssertCompile(~(RTNATIVETHREAD)1 != NIL_RTNATIVETHREAD);
    15401798            pGVM->aCpus[idCpu].hEMT           = ~(RTNATIVETHREAD)1;
     1799#ifdef VBOX_BUGREF_9217
     1800            pGVM->aCpus[idCpu].hNativeThreadR0 = NIL_RTNATIVETHREAD;
     1801#else
    15411802            pVM->aCpus[idCpu].hNativeThreadR0 = NIL_RTNATIVETHREAD;
     1803#endif
    15421804        }
    15431805
    … …  
    15731835    PGVM pGVM = pHandle->pGVM;
    15741836    AssertPtrReturn(pGVM, NULL);
     1837#ifdef VBOX_BUGREF_9217
     1838    AssertReturn(pGVM == pHandle->pVM, NULL);
     1839#else
    15751840    AssertReturn(pGVM->pVM == pHandle->pVM, NULL);
     1841#endif
    15761842
    15771843    return pHandle->pGVM;
    … …  
    16301896
    16311897        pGVM = pHandle->pGVM;
     1898#ifdef VBOX_BUGREF_9217
     1899        if (RT_UNLIKELY(    pHandle->pVM != pVM
     1900                        ||  pHandle->ProcId != ProcId
     1901                        ||  !VALID_PTR(pHandle->pvObj)
     1902                        ||  !VALID_PTR(pGVM)
     1903                        ||  pGVM != pVM))
     1904#else
    16321905        if (RT_UNLIKELY(    pHandle->pVM != pVM
    16331906                        ||  pHandle->ProcId != ProcId
    … …  
    16351908                        ||  !VALID_PTR(pGVM)
    16361909                        ||  pGVM->pVM != pVM))
     1910#endif
    16371911        {
    16381912            GVMMR0_USED_SHARED_UNLOCK(pGVMM);
    … …  
    16521926        if (RT_UNLIKELY(!VALID_PTR(pGVM)))
    16531927            return VERR_INVALID_HANDLE;
     1928#ifdef VBOX_BUGREF_9217
     1929        if (RT_UNLIKELY(pGVM != pVM))
     1930#else
    16541931        if (RT_UNLIKELY(pGVM->pVM != pVM))
     1932#endif
    16551933            return VERR_INVALID_HANDLE;
    16561934    }
    … …  
    16971975    PGVM pGVM = pHandle->pGVM;
    16981976    AssertPtrReturn(pGVM, NULL);
     1977#ifdef VBOX_BUGREF_9217
     1978    AssertReturn(pGVM == pVM, NULL);
     1979#else
    16991980    AssertReturn(pGVM->pVM == pVM, NULL);
     1981#endif
    17001982
    17011983    return pGVM;
    … …  
    17322014                      && ((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0))
    17332015        {
     2016#ifdef VBOX_BUGREF_9217
     2017            if (RT_LIKELY(pGVM == pVM))
     2018#else
    17342019            if (RT_LIKELY(pGVM->pVM == pVM))
     2020#endif
    17352021            {
    17362022                /*
    … …  
    18102096    AssertPtrReturn(pVM,  VERR_INVALID_POINTER);
    18112097    AssertReturn(((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0, VERR_INVALID_POINTER);
     2098#ifdef VBOX_BUGREF_9217
     2099    AssertReturn(pGVM == pVM, VERR_INVALID_VM_HANDLE);
     2100#else
    18122101    AssertReturn(pGVM->pVM == pVM, VERR_INVALID_VM_HANDLE);
     2102#endif
    18132103
    18142104
    … …  
    24892779    {
    24902780        if (idCpu < pGVM->cCpus)
     2781#ifdef VBOX_BUGREF_9217
     2782            rc = gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
     2783#else
    24912784            rc = gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
     2785#endif
    24922786        else
    24932787            rc = VERR_INVALID_CPU_ID;
    … …  
    25432837    {
    25442838        if (idCpu < pGVM->cCpus)
     2839#ifdef VBOX_BUGREF_9217
     2840            rc = gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
     2841#else
    25452842            rc = gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
     2843#endif
    25462844        else
    25472845            rc = VERR_INVALID_CPU_ID;
    … …  
    25932891            else if (VMCPUSET_IS_PRESENT(pPokeSet, idCpu))
    25942892            {
     2893#ifdef VBOX_BUGREF_9217
     2894                gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
     2895#else
    25952896                gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
     2897#endif
    25962898                GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
    25972899            }

  • trunk/src/VBox/VMM/VMMR0/GVMMR0Internal.h

    r76585 r78431  
    3434    /** The event semaphore the EMT thread is blocking on. */
    3535    RTSEMEVENTMULTI     HaltEventMulti;
     36#ifdef VBOX_BUGREF_9217
     37    /** The ring-3 mapping of the VMCPU structure. */
     38    RTR0MEMOBJ          VMCpuMapObj;
     39#endif
    3640    /** The APIC ID of the CPU that EMT was scheduled on the last time we checked. */
    3741    uint8_t             iCpuEmt;

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

    r76553 r78431  
    2727#include <VBox/vmm/mm.h>
    2828#include <VBox/vmm/vm.h>
     29#include <VBox/vmm/gvm.h>
    2930#include <VBox/vmm/vmm.h>
    3031#include <VBox/vmm/patm.h>
    … …  
    458459{
    459460    PDMDEV_ASSERT_DEVINS(pDevIns);
     461#ifdef VBOX_BUGREF_9217
     462    PGVM   pGVM  = (PGVM)pDevIns->Internal.s.pVMR0;
     463    PVMCPU pVCpu = &pGVM->aCpus[0];     /* for PIC we always deliver to CPU 0, MP use APIC */
     464#else
    460465    PVM    pVM   = pDevIns->Internal.s.pVMR0;
    461466    PVMCPU pVCpu = &pVM->aCpus[0];      /* for PIC we always deliver to CPU 0, MP use APIC */
     467#endif
    462468    /** @todo r=ramshankar: Propagating rcRZ and make all callers handle it? */
    463469    APICLocalInterrupt(pVCpu, 0 /* u8Pin */, 1 /* u8Level */, VINF_SUCCESS /* rcRZ */);
    … …  
    469475{
    470476    PDMDEV_ASSERT_DEVINS(pDevIns);
     477#ifdef VBOX_BUGREF_9217
     478    PGVM   pGVM  = (PGVM)pDevIns->Internal.s.pVMR0;
     479    PVMCPU pVCpu = &pGVM->aCpus[0];     /* for PIC we always deliver to CPU 0, MP use APIC */
     480#else
    471481    PVM    pVM   = pDevIns->Internal.s.pVMR0;
    472482    PVMCPU pVCpu = &pVM->aCpus[0];      /* for PIC we always deliver to CPU 0, MP use APIC */
     483#endif
    473484    /** @todo r=ramshankar: Propagating rcRZ and make all callers handle it? */
    474485    APICLocalInterrupt(pVCpu, 0 /* u8Pin */, 0 /* u8Level */, VINF_SUCCESS /* rcRZ */);

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

    r76553 r78431  
    2424#include <VBox/vmm/pgm.h>
    2525#include <VBox/vmm/gmm.h>
    26 #include <VBox/vmm/gvm.h>
    2726#include "PGMInternal.h"
    2827#include <VBox/vmm/vm.h>
     28#include <VBox/vmm/gvm.h>
    2929#include "PGMInline.h"
    3030#include <VBox/log.h>
    … …  
    7878    AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
    7979    AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
     80#ifdef VBOX_BUGREF_9217
     81    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
     82#else
    8083    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pVM->aCpus[idCpu]);
     84#endif
    8185
    8286    /*
    … …  
    201205    AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
    202206    AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
     207#ifdef VBOX_BUGREF_9217
     208    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
     209#else
    203210    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pVM->aCpus[idCpu]);
     211#endif
    204212
    205213    /*
    … …  
    241249    AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
    242250    AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
     251#ifdef VBOX_BUGREF_9217
     252    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
     253#else
    243254    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pVM->aCpus[idCpu]);
     255#endif
    244256    Assert(!pVM->pgm.s.cLargeHandyPages);
    245257

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

    r76553 r78431  
    2525#include "PGMInternal.h"
    2626#include <VBox/vmm/vm.h>
     27#include <VBox/vmm/gvm.h>
    2728#include "PGMInline.h"
    2829#include <VBox/log.h>
    … …  
    5051VMMR0DECL(int) PGMR0SharedModuleCheck(PVM pVM, PGVM pGVM, VMCPUID idCpu, PGMMSHAREDMODULE pModule, PCRTGCPTR64 paRegionsGCPtrs)
    5152{
     53#ifdef VBOX_BUGREF_9217
     54    PVMCPU              pVCpu         = &pGVM->aCpus[idCpu];
     55#else
    5256    PVMCPU              pVCpu         = &pVM->aCpus[idCpu];
     57#endif
    5358    int                 rc            = VINF_SUCCESS;
    5459    bool                fFlushTLBs    = false;
    … …  
    162167
    163168    if (fFlushRemTLBs)
     169#ifdef VBOX_BUGREF_9217
     170        for (VMCPUID idCurCpu = 0; idCurCpu < pGVM->cCpus; idCurCpu++)
     171            CPUMSetChangedFlags(&pGVM->aCpus[idCurCpu], CPUM_CHANGED_GLOBAL_TLB_FLUSH);
     172#else
    164173        for (VMCPUID idCurCpu = 0; idCurCpu < pVM->cCpus; idCurCpu++)
    165174            CPUMSetChangedFlags(&pVM->aCpus[idCurCpu], CPUM_CHANGED_GLOBAL_TLB_FLUSH);
     175#endif
    166176
    167177    return rc;

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

    r76553 r78431  
    395395     * Register the EMT R0 logger instance for VCPU 0.
    396396     */
     397#ifdef VBOX_BUGREF_9217
     398    PVMCPU pVCpu = &pGVM->aCpus[0];
     399#else
    397400    PVMCPU pVCpu = &pVM->aCpus[0];
     401#endif
    398402
    399403    PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
    … …  
    471475                {
    472476                    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
     477#ifdef VBOX_BUGREF_9217
     478                    rc = EMR0InitVM(pGVM);
     479#else
    473480                    rc = EMR0InitVM(pGVM, pVM);
     481#endif
    474482                    if (RT_SUCCESS(rc))
    475483                    {
    … …  
    536544     * Registration of ring 0 loggers.
    537545     */
     546#ifdef VBOX_BUGREF_9217
     547    PVMCPU       pVCpu     = &pGVM->aCpus[idCpu];
     548#else
    538549    PVMCPU       pVCpu     = &pVM->aCpus[idCpu];
     550#endif
    539551    PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
    540552    if (   pR0Logger
    … …  
    717729static int vmmR0DoHalt(PGVM pGVM, PVM pVM, PGVMCPU pGVCpu, PVMCPU pVCpu)
    718730{
     731#ifdef VBOX_BUGREF_9217
     732    Assert(pVCpu == pGVCpu);
     733#else
    719734    Assert(pVCpu == pGVCpu->pVCpu);
     735#endif
    720736
    721737    /*
    … …  
    13001316
    13011317    PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
     1318#ifdef VBOX_BUGREF_9217
     1319    PVMCPU  pVCpu  = pGVCpu;
     1320#else
    13021321    PVMCPU  pVCpu  = &pVM->aCpus[idCpu];
     1322#endif
    13031323    RTNATIVETHREAD const hNativeThread = RTThreadNativeSelf();
    13041324    if (RT_LIKELY(   pGVCpu->hEMT           == hNativeThread
    … …  
    17541774        }
    17551775
     1776#ifdef VBOX_BUGREF_9217
     1777        if (RT_LIKELY(pGVM == pVM))
     1778#else
    17561779        if (RT_LIKELY(pGVM->pVM == pVM))
     1780#endif
    17571781        { /* likely */ }
    17581782        else
    17591783        {
     1784#ifdef VBOX_BUGREF_9217
     1785            SUPR0Printf("vmmR0EntryExWorker: pVM mismatch: got %p, pGVM/pVM=%p\n", pVM, pGVM);
     1786#else
    17601787            SUPR0Printf("vmmR0EntryExWorker: pVM mismatch: got %p, pGVM->pVM=%p\n", pVM, pGVM->pVM);
     1788#endif
    17611789            return VERR_INVALID_PARAMETER;
    17621790        }
    … …  
    19421970            if (RT_UNLIKELY(pVM->cCpus != 1))
    19431971                return VERR_INVALID_PARAMETER;
     1972# ifdef VBOX_BUGREF_9217
     1973            PVMCPU pVCpu = &pGVM->aCpus[idCpu];
     1974# else
    19441975            PVMCPU pVCpu = &pVM->aCpus[idCpu];
     1976# endif
    19451977# ifndef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
    19461978            if (RT_UNLIKELY(!PGMGetHyperCR3(pVCpu)))
    … …  
    25132545            {
    25142546                PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
     2547#ifdef VBOX_BUGREF_9217
     2548                PVMCPU  pVCpu  = pGVCpu;
     2549#else
    25152550                PVMCPU  pVCpu  = &pVM->aCpus[idCpu];
     2551#endif
    25162552                RTNATIVETHREAD hNativeThread = RTThreadNativeSelf();
    25172553                if (RT_LIKELY(   pGVCpu->hEMT           == hNativeThread
    … …  
    26962732    if (pGVCpu)
    26972733    {
     2734#ifdef VBOX_BUGREF_9217
     2735        PVMCPU pVCpu = pGVCpu;
     2736#else
    26982737        PVMCPU pVCpu = pGVCpu->pVCpu;
     2738#endif
    26992739        if (RT_VALID_PTR(pVCpu))
    27002740        {
    … …  
    27032743            {
    27042744                if (   pVmmLogger->fCreated
    2705                     && pVmmLogger->pVM == pGVCpu->pVM)
     2745#ifdef VBOX_BUGREF_9217
     2746                    && pVmmLogger->pVM == pGVCpu->pGVM
     2747#else
     2748                    && pVmmLogger->pVM == pGVCpu->pVM
     2749#endif
     2750                   )
    27062751                {
    27072752                    if (pVmmLogger->Logger.fFlags & RTLOGFLAGS_DISABLED)

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

    r77196 r78431  
    593593        AssertRelease(pVM->cCpus == cCpus);
    594594        AssertRelease(pVM->uCpuExecutionCap == 100);
     595#ifdef VBOX_WITH_RAW_MODE
    595596        AssertRelease(pVM->offVMCPU == RT_UOFFSETOF(VM, aCpus));
     597#endif
    596598        AssertCompileMemberAlignment(VM, cpum, 64);
    597599        AssertCompileMemberAlignment(VM, tm, 64);
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