VirtualBox

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


Ignore:
Timestamp:
Aug 17, 2019 12:43:24 AM (5 years ago)
Author:
vboxsync
Message:

VMM: Eliminating the VBOX_BUGREF_9217 preprocessor macro. bugref:9217

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h

    r80274 r80334  
    11311131#ifdef IN_RING0
    11321132# ifdef NEM_WIN_WITH_RING0_RUNLOOP
    1133     /** @todo improve and secure this translation */
    1134 #  ifdef VBOX_BUGREF_9217
    11351133    return nemR0WinImportState(pVCpu->pGVM, pVCpu, &pVCpu->cpum.GstCtx, fWhat, true /*fCanUpdateCr3*/);
    1136 #  else
    1137     PGVM pGVM = GVMMR0ByHandle(pVCpu->pVMR0->hSelf);
    1138     AssertReturn(pGVM, VERR_INVALID_VMCPU_HANDLE);
    1139     VMCPUID idCpu = pVCpu->idCpu;
    1140     ASMCompilerBarrier();
    1141     AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_VMCPU_HANDLE);
    1142 
    1143     return nemR0WinImportState(pGVM, &pGVM->aCpus[idCpu], &pVCpu->cpum.GstCtx, fWhat, true /*fCanUpdateCr3*/);
    1144 #  endif
    11451134# else
    11461135    RT_NOREF(pVCpu, fWhat);
    … …  
    12021191#else  /* IN_RING0 */
    12031192# ifdef NEM_WIN_WITH_RING0_RUNLOOP
    1204 #  ifdef VBOX_BUGREF_9217
    12051193    int rc = nemR0WinQueryCpuTick(pVCpu->pGVM, pVCpu, pcTicks, puAux);
    1206 #  else
    1207     /** @todo improve and secure this translation */
    1208     PGVM pGVM = GVMMR0ByHandle(pVCpu->pVMR0->hSelf);
    1209     AssertReturn(pGVM, VERR_INVALID_VMCPU_HANDLE);
    1210     VMCPUID idCpu = pVCpu->idCpu;
    1211     ASMCompilerBarrier();
    1212     AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_VMCPU_HANDLE);
    1213     int rc = nemR0WinQueryCpuTick(pGVM, &pGVM->aCpus[idCpu], pcTicks, puAux);
    1214 #  endif
    12151194    if (RT_SUCCESS(rc) && puAux && !(pVCpu->cpum.GstCtx.fExtrn & CPUMCTX_EXTRN_TSC_AUX))
    12161195        *puAux = CPUMGetGuestTscAux(pVCpu);
    … …  
    12381217#ifdef IN_RING0
    12391218# ifdef NEM_WIN_WITH_RING0_RUNLOOP
    1240 #  ifdef VBOX_BUGREF_9217
    12411219    return nemR0WinResumeCpuTickOnAll(pVM, pVCpu, uPausedTscValue);
    1242 #  else
    1243     /** @todo improve and secure this translation */
    1244     PGVM pGVM = GVMMR0ByHandle(pVM->hSelf);
    1245     AssertReturn(pGVM, VERR_INVALID_VMCPU_HANDLE);
    1246     VMCPUID idCpu = pVCpu->idCpu;
    1247     ASMCompilerBarrier();
    1248     AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_VMCPU_HANDLE);
    1249 
    1250     return nemR0WinResumeCpuTickOnAll(pGVM, &pGVM->aCpus[idCpu], uPausedTscValue);
    1251 #  endif
    12521220# else
    12531221    RT_NOREF(pVM, pVCpu, uPausedTscValue);

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

    r80333 r80334  
    3939 * @param   pVM             The cross context VM structure.
    4040 */
    41 #ifdef VBOX_BUGREF_9217
    4241VMMR0_INT_DECL(int) EMR0InitVM(PGVM pGVM)
    43 #else
    44 VMMR0_INT_DECL(int) EMR0InitVM(PGVM pGVM, PVMCC pVM)
    45 #endif
    4642{
    4743    /*
    4844     * Override ring-0 exit optimizations settings.
    4945     */
    50 #ifdef VBOX_BUGREF_9217
    5146    PVMCPUCC pVCpu0 = &pGVM->aCpus[0];
    52 #else
    53     PVMCPUCC pVCpu0 = VMCC_GET_CPU_0(pVM);
    54 #endif
    55 
    5647    bool fEnabledR0                = pVCpu0->em.s.fExitOptimizationEnabled
    5748                                  && pVCpu0->em.s.fExitOptimizationEnabledR0
    … …  
    6253    for (VMCPUID idCpu = 0; idCpu < pGVM->cCpus; idCpu++)
    6354    {
    64 #ifdef VBOX_BUGREF_9217
    6555        PVMCPUCC pVCpu = &pGVM->aCpus[idCpu];
    66 #else
    67         PVMCPUCC pVCpu = VMCC_GET_CPU(pVM, idCpu);
    68 #endif
    6956        pVCpu->em.s.fExitOptimizationEnabledR0                = fEnabledR0;
    7057        pVCpu->em.s.fExitOptimizationEnabledR0PreemptDisabled = fEnabledR0PreemptDisabled;

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

    r80333 r80334  
    12251225GMMR0DECL(void) GMMR0CleanupVM(PGVM pGVM)
    12261226{
    1227 #ifdef VBOX_BUGREF_9217
    12281227    LogFlow(("GMMR0CleanupVM: pGVM=%p:{.hSelf=%#x}\n", pGVM, pGVM->hSelf));
    1229 #else
    1230     LogFlow(("GMMR0CleanupVM: pGVM=%p:{.pVM=%p, .hSelf=%#x}\n", pGVM, pGVM->pVM, pGVM->hSelf));
    1231 #endif
    12321228
    12331229    PGMM pGMM;
    … …  
    51415137         pGblMod->szName, pGblMod->szVersion, pGblMod->Core.Key, pGblMod->cbModule));
    51425138
    5143 # ifdef VBOX_BUGREF_9217
    51445139    int rc = PGMR0SharedModuleCheck(pArgs->pGVM, pArgs->pGVM, pArgs->idCpu, pGblMod, pRecVM->aRegionsGCPtrs);
    5145 #else
    5146     int rc = PGMR0SharedModuleCheck(pArgs->pGVM->pVM, pArgs->pGVM, pArgs->idCpu, pGblMod, pRecVM->aRegionsGCPtrs);
    5147 # endif
    51485140    if (RT_FAILURE(rc))
    51495141        return rc;

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

    r80319 r80334  
    359359*   Internal Functions                                                                                                           *
    360360*********************************************************************************************************************************/
    361 #ifdef VBOX_BUGREF_9217
    362361static void gvmmR0InitPerVMData(PGVM pGVM, int16_t hSelf, VMCPUID cCpus, PSUPDRVSESSION pSession);
    363 #else
    364 static void gvmmR0InitPerVMData(PGVM pGVM);
    365 #endif
    366362static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void *pvObj, void *pvGVMM, void *pvHandle);
    367363static int gvmmR0ByGVMandVM(PGVM pGVM, PVMCC pVM, PGVMM *ppGVMM, bool fTakeUsedLock);
    … …  
    891887                if (RT_SUCCESS(rc))
    892888                {
    893 #ifdef VBOX_BUGREF_9217
    894889                    /*
    895890                     * Allocate memory for the VM structure (combined VM + GVM).
    … …  
    10291024                    }
    10301025
    1031 #else
    1032                     /*
    1033                      * Allocate the global VM structure (GVM) and initialize it.
    1034                      */
    1035                     PGVM pGVM = (PGVM)RTMemAllocZ(RT_UOFFSETOF_DYN(GVM, aCpus[cCpus]));
    1036                     if (pGVM)
    1037                     {
    1038                         pGVM->u32Magic  = GVM_MAGIC;
    1039                         pGVM->hSelf     = iHandle;
    1040                         pGVM->pVM       = NULL;
    1041                         pGVM->cCpus     = cCpus;
    1042                         pGVM->pSession  = pSession;
    1043 
    1044                         gvmmR0InitPerVMData(pGVM);
    1045                         GMMR0InitPerVMData(pGVM);
    1046 
    1047                         /*
    1048                          * Allocate the shared VM structure and associated page array.
    1049                          */
    1050                         const uint32_t  cbVM   = RT_UOFFSETOF_DYN(VM, aCpus[cCpus]);
    1051                         const uint32_t  cPages = RT_ALIGN_32(cbVM, PAGE_SIZE) >> PAGE_SHIFT;
    1052                         rc = RTR0MemObjAllocLow(&pGVM->gvmm.s.VMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
    1053                         if (RT_SUCCESS(rc))
    1054                         {
    1055                             PVMCC pVM = (PVMCC)RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj); AssertPtr(pVM);
    1056                             memset(pVM, 0, cPages << PAGE_SHIFT);
    1057                             pVM->enmVMState       = VMSTATE_CREATING;
    1058                             pVM->pVMR0            = pVM;
    1059                             pVM->pSession         = pSession;
    1060                             pVM->hSelf            = iHandle;
    1061                             pVM->cbSelf           = cbVM;
    1062                             pVM->cCpus            = cCpus;
    1063                             pVM->uCpuExecutionCap = 100; /* default is no cap. */
    1064                             AssertCompileMemberAlignment(VM, cpum, 64);
    1065                             AssertCompileMemberAlignment(VM, tm, 64);
    1066                             AssertCompileMemberAlignment(VM, aCpus, PAGE_SIZE);
    1067 
    1068                             rc = RTR0MemObjAllocPage(&pGVM->gvmm.s.VMPagesMemObj, cPages * sizeof(SUPPAGE), false /* fExecutable */);
    1069                             if (RT_SUCCESS(rc))
    1070                             {
    1071                                 PSUPPAGE paPages = (PSUPPAGE)RTR0MemObjAddress(pGVM->gvmm.s.VMPagesMemObj); AssertPtr(paPages);
    1072                                 for (uint32_t iPage = 0; iPage < cPages; iPage++)
    1073                                 {
    1074                                     paPages[iPage].uReserved = 0;
    1075                                     paPages[iPage].Phys = RTR0MemObjGetPagePhysAddr(pGVM->gvmm.s.VMMemObj, iPage);
    1076                                     Assert(paPages[iPage].Phys != NIL_RTHCPHYS);
    1077                                 }
    1078 
    1079                                 /*
    1080                                  * Map them into ring-3.
    1081                                  */
    1082                                 rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMMapObj, pGVM->gvmm.s.VMMemObj, (RTR3PTR)-1, 0,
    1083                                                        RTMEM_PROT_READ | RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
    1084                                 if (RT_SUCCESS(rc))
    1085                                 {
    1086                                     PVMR3 pVMR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMMapObj);
    1087                                     AssertPtr((void *)pVMR3);
    1088                                     pVM->pVMR3       = pVMR3;
    1089 
    1090                                     /* Initialize all the VM pointers. */
    1091                                     for (VMCPUID i = 0; i < cCpus; i++)
    1092                                     {
    1093                                         pVM->aCpus[i].idCpu           = i;
    1094                                         pVM->aCpus[i].pVMR0           = pVM;
    1095                                         pVM->aCpus[i].pVMR3           = pVMR3;
    1096                                         pVM->aCpus[i].idHostCpu       = NIL_RTCPUID;
    1097                                         pVM->aCpus[i].hNativeThreadR0 = NIL_RTNATIVETHREAD;
    1098                                         pVM->apCpusR3[i] = pVMR3 + RT_UOFFSETOF_DYN(VM, aCpus[i]);
    1099                                         pVM->apCpusR0[i] = &pVM->aCpus[i];
    1100                                     }
    1101 
    1102                                     rc = RTR0MemObjMapUser(&pGVM->gvmm.s.VMPagesMapObj, pGVM->gvmm.s.VMPagesMemObj, (RTR3PTR)-1,
    1103                                                            0 /* uAlignment */, RTMEM_PROT_READ | RTMEM_PROT_WRITE,
    1104                                                            NIL_RTR0PROCESS);
    1105                                     if (RT_SUCCESS(rc))
    1106                                     {
    1107                                         pVM->paVMPagesR3 = RTR0MemObjAddressR3(pGVM->gvmm.s.VMPagesMapObj);
    1108                                         AssertPtr((void *)pVM->paVMPagesR3);
    1109 
    1110                                         /* complete the handle - take the UsedLock sem just to be careful. */
    1111                                         rc = GVMMR0_USED_EXCLUSIVE_LOCK(pGVMM);
    1112                                         AssertRC(rc);
    1113 
    1114                                         pHandle->pVM                  = pVM;
    1115                                         pHandle->pGVM                 = pGVM;
    1116                                         pHandle->hEMT0                = hEMT0;
    1117                                         pHandle->ProcId               = ProcId;
    1118                                         pGVM->pVM                     = pVM;
    1119                                         pGVM->pVMR3                   = pVMR3;
    1120                                         pGVM->aCpus[0].hEMT           = hEMT0;
    1121                                         pVM->aCpus[0].hNativeThreadR0 = hEMT0;
    1122                                         pGVMM->cEMTs += cCpus;
    1123 
    1124                                         for (VMCPUID i = 0; i < cCpus; i++)
    1125                                         {
    1126                                             pGVM->aCpus[i].pVCpu          = &pVM->aCpus[i];
    1127                                             pGVM->aCpus[i].pVM            = pVM;
    1128                                         }
    1129 
    1130                                         /* Associate it with the session and create the context hook for EMT0. */
    1131                                         rc = SUPR0SetSessionVM(pSession, pGVM, pVM);
    1132                                         if (RT_SUCCESS(rc))
    1133                                         {
    1134                                             rc = VMMR0ThreadCtxHookCreateForEmt(&pVM->aCpus[0]);
    1135                                             if (RT_SUCCESS(rc))
    1136                                             {
    1137                                                 /*
    1138                                                  * Done!
    1139                                                  */
    1140                                                 VBOXVMM_R0_GVMM_VM_CREATED(pGVM, pVM, ProcId, (void *)hEMT0, cCpus);
    1141 
    1142                                                 GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
    1143                                                 gvmmR0CreateDestroyUnlock(pGVMM);
    1144 
    1145                                                 CPUMR0RegisterVCpuThread(&pVM->aCpus[0]);
    1146 
    1147                                                 *ppVM = pVM;
    1148                                                 Log(("GVMMR0CreateVM: pVM=%p pVMR3=%p pGVM=%p hGVM=%d\n", pVM, pVMR3, pGVM, iHandle));
    1149                                                 return VINF_SUCCESS;
    1150                                             }
    1151 
    1152                                             SUPR0SetSessionVM(pSession, NULL, NULL);
    1153                                         }
    1154                                         GVMMR0_USED_EXCLUSIVE_UNLOCK(pGVMM);
    1155                                     }
    1156 
    1157                                     RTR0MemObjFree(pGVM->gvmm.s.VMMapObj, false /* fFreeMappings */);
    1158                                     pGVM->gvmm.s.VMMapObj = NIL_RTR0MEMOBJ;
    1159                                 }
    1160                                 RTR0MemObjFree(pGVM->gvmm.s.VMPagesMemObj, false /* fFreeMappings */);
    1161                                 pGVM->gvmm.s.VMPagesMemObj = NIL_RTR0MEMOBJ;
    1162                             }
    1163                             RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */);
    1164                             pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
    1165                         }
    1166                     }
    1167 #endif
    11681026                }
    11691027                /* else: The user wasn't permitted to create this VM. */
    … …  
    11961054
    11971055
    1198 #ifdef VBOX_BUGREF_9217
    11991056/**
    12001057 * Initializes the per VM data belonging to GVMM.
    … …  
    12031060 */
    12041061static void gvmmR0InitPerVMData(PGVM pGVM, int16_t hSelf, VMCPUID cCpus, PSUPDRVSESSION pSession)
    1205 #else
    1206 /**
    1207  * Initializes the per VM data belonging to GVMM.
    1208  *
    1209  * @param   pGVM        Pointer to the global VM structure.
    1210  */
    1211 static void gvmmR0InitPerVMData(PGVM pGVM)
    1212 #endif
    12131062{
    12141063    AssertCompile(RT_SIZEOFMEMB(GVM,gvmm.s) <= RT_SIZEOFMEMB(GVM,gvmm.padding));
    12151064    AssertCompile(RT_SIZEOFMEMB(GVMCPU,gvmm.s) <= RT_SIZEOFMEMB(GVMCPU,gvmm.padding));
    1216 #ifdef VBOX_BUGREF_9217
    12171065    AssertCompileMemberAlignment(VM, cpum, 64);
    12181066    AssertCompileMemberAlignment(VM, tm, 64);
    … …  
    12351083    pGVM->cbSelf           = sizeof(VM);
    12361084    pGVM->cbVCpu           = sizeof(VMCPU);
    1237 #endif
    12381085
    12391086    /* GVMM: */
    … …  
    12511098    {
    12521099        pGVM->aCpus[i].idCpu                 = i;
    1253 #ifdef VBOX_BUGREF_9217
    12541100        pGVM->aCpus[i].idCpuUnsafe           = i;
    1255 #endif
    12561101        pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
    1257 #ifdef VBOX_BUGREF_9217
    12581102        pGVM->aCpus[i].gvmm.s.VMCpuMapObj    = NIL_RTR0MEMOBJ;
    1259 #endif
    12601103        pGVM->aCpus[i].hEMT                  = NIL_RTNATIVETHREAD;
    12611104        pGVM->aCpus[i].pGVM                  = pGVM;
    1262 #ifndef VBOX_BUGREF_9217
    1263         pGVM->aCpus[i].pVCpu                 = NULL;
    1264         pGVM->aCpus[i].pVM                   = NULL;
    1265 #endif
    1266 #ifdef VBOX_BUGREF_9217
    12671105        pGVM->aCpus[i].idHostCpu             = NIL_RTCPUID;
    12681106        pGVM->aCpus[i].iHostCpuSet           = UINT32_MAX;
    … …  
    12711109        pGVM->aCpus[i].enmState              = VMCPUSTATE_STOPPED;
    12721110        pGVM->aCpus[i].pVCpuR0ForVtg         = &pGVM->aCpus[i];
    1273 #endif
    12741111    }
    12751112}
    … …  
    13681205    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
    13691206    AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
    1370 #ifdef VBOX_BUGREF_9217
    13711207    AssertReturn(pGVM == pVM, VERR_INVALID_POINTER);
    1372 #else
    1373     AssertReturn(pGVM->pVM == pVM, VERR_INVALID_POINTER);
    1374 #endif
    13751208    AssertMsgReturn(pVM->enmVMState >= VMSTATE_CREATING && pVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pVM->enmVMState),
    13761209                    VERR_WRONG_ORDER);
    … …  
    14501283    {
    14511284        if (    pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ
    1452 #ifdef VBOX_BUGREF_9217
    1453             &&  RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM
    1454 #else
    1455             &&  RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM->pVM
    1456 #endif
    1457            )
     1285            &&  RTR0MemObjAddress(pGVM->gvmm.s.VMMemObj) == pGVM)
    14581286        {
    14591287            LogFlow(("gvmmR0CleanupVM: Calling VMMR0TermVM\n"));
    1460 #ifdef VBOX_BUGREF_9217
    14611288            VMMR0TermVM(pGVM, pGVM, NIL_VMCPUID);
    1462 #else
    1463             VMMR0TermVM(pGVM, pGVM->pVM, NIL_VMCPUID);
    1464 #endif
    14651289        }
    14661290        else
    1467 #ifdef VBOX_BUGREF_9217
    14681291            AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pGVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM));
    1469 #else
    1470             AssertMsgFailed(("gvmmR0CleanupVM: VMMemObj=%p pVM=%p\n", pGVM->gvmm.s.VMMemObj, pGVM->pVM));
    1471 #endif
    14721292    }
    14731293
    … …  
    14841304         *        solution for not deregistering hooks everytime we're leaving HMR0
    14851305         *        context. */
    1486 #ifdef VBOX_BUGREF_9217
    14871306        VMMR0ThreadCtxHookDestroyForEmt(&pGVM->aCpus[idCpu]);
    1488 #else
    1489         VMMR0ThreadCtxHookDestroyForEmt(&pGVM->pVM->aCpus[idCpu]);
    1490 #endif
    14911307    }
    14921308}
    … …  
    16141430        }
    16151431
    1616 #ifndef VBOX_BUGREF_9217
    1617         if (pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ)
    1618         {
    1619             rc = RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, false /* fFreeMappings */); AssertRC(rc);
    1620             pGVM->gvmm.s.VMMemObj = NIL_RTR0MEMOBJ;
    1621         }
    1622 #endif
    1623 
    16241432        for (VMCPUID i = 0; i < pGVM->cCpus; i++)
    16251433        {
    … …  
    16291437                pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
    16301438            }
    1631 #ifdef VBOX_BUGREF_9217
    16321439            if (pGVM->aCpus[i].gvmm.s.VMCpuMapObj != NIL_RTR0MEMOBJ)
    16331440            {
    … …  
    16351442                pGVM->aCpus[i].gvmm.s.VMCpuMapObj = NIL_RTR0MEMOBJ;
    16361443            }
    1637 #endif
    16381444        }
    16391445
    16401446        /* the GVM structure itself. */
    16411447        pGVM->u32Magic |= UINT32_C(0x80000000);
    1642 #ifdef VBOX_BUGREF_9217
    16431448        Assert(pGVM->gvmm.s.VMMemObj != NIL_RTR0MEMOBJ);
    16441449        rc = RTR0MemObjFree(pGVM->gvmm.s.VMMemObj, true /*fFreeMappings*/); AssertRC(rc);
    1645 #else
    1646         RTMemFree(pGVM);
    1647 #endif
    16481450        pGVM = NULL;
    16491451
    … …  
    16981500            if (pGVM->aCpus[idCpu].hEMT == NIL_RTNATIVETHREAD)
    16991501            {
    1700 #ifdef VBOX_BUGREF_9217
    17011502                Assert(pGVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
    1702 #else
    1703                 Assert(pVM->aCpus[idCpu].hNativeThreadR0 == NIL_RTNATIVETHREAD);
    1704 #endif
    17051503
    17061504                /* A thread may only be one EMT. */
    … …  
    17131511                     * Do the assignment, then try setup the hook. Undo if that fails.
    17141512                     */
    1715 #ifdef VBOX_BUGREF_9217
    17161513                    pGVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = RTThreadNativeSelf();
    17171514
    … …  
    17211518                    else
    17221519                        pGVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = NIL_RTNATIVETHREAD;
    1723 #else
    1724                     pVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = RTThreadNativeSelf();
    1725 
    1726                     rc = VMMR0ThreadCtxHookCreateForEmt(&pVM->aCpus[idCpu]);
    1727                     if (RT_SUCCESS(rc))
    1728                         CPUMR0RegisterVCpuThread(&pVM->aCpus[idCpu]);
    1729                     else
    1730                         pVM->aCpus[idCpu].hNativeThreadR0 = pGVM->aCpus[idCpu].hEMT = NIL_RTNATIVETHREAD;
    1731 #endif
    17321520                }
    17331521            }
    … …  
    17771565             * Do per-EMT cleanups.
    17781566             */
    1779 #ifdef VBOX_BUGREF_9217
    17801567            VMMR0ThreadCtxHookDestroyForEmt(&pGVM->aCpus[idCpu]);
    1781 #else
    1782             VMMR0ThreadCtxHookDestroyForEmt(&pVM->aCpus[idCpu]);
    1783 #endif
    17841568
    17851569            /*
    … …  
    17891573            AssertCompile(~(RTNATIVETHREAD)1 != NIL_RTNATIVETHREAD);
    17901574            pGVM->aCpus[idCpu].hEMT           = ~(RTNATIVETHREAD)1;
    1791 #ifdef VBOX_BUGREF_9217
    17921575            pGVM->aCpus[idCpu].hNativeThreadR0 = NIL_RTNATIVETHREAD;
    1793 #else
    1794             pVM->aCpus[idCpu].hNativeThreadR0 = NIL_RTNATIVETHREAD;
    1795 #endif
    17961576        }
    17971577
    … …  
    18271607    PGVM pGVM = pHandle->pGVM;
    18281608    AssertPtrReturn(pGVM, NULL);
    1829 #ifdef VBOX_BUGREF_9217
    18301609    AssertReturn(pGVM == pHandle->pVM, NULL);
    1831 #else
    1832     AssertReturn(pGVM->pVM == pHandle->pVM, NULL);
    1833 #endif
    18341610
    18351611    return pHandle->pGVM;
    … …  
    18881664
    18891665        pGVM = pHandle->pGVM;
    1890 #ifdef VBOX_BUGREF_9217
    18911666        if (RT_UNLIKELY(    pHandle->pVM != pVM
    18921667                        ||  pHandle->ProcId != ProcId
    … …  
    18941669                        ||  !VALID_PTR(pGVM)
    18951670                        ||  pGVM != pVM))
    1896 #else
    1897         if (RT_UNLIKELY(    pHandle->pVM != pVM
    1898                         ||  pHandle->ProcId != ProcId
    1899                         ||  !VALID_PTR(pHandle->pvObj)
    1900                         ||  !VALID_PTR(pGVM)
    1901                         ||  pGVM->pVM != pVM))
    1902 #endif
    19031671        {
    19041672            GVMMR0_USED_SHARED_UNLOCK(pGVMM);
    … …  
    19181686        if (RT_UNLIKELY(!VALID_PTR(pGVM)))
    19191687            return VERR_INVALID_HANDLE;
    1920 #ifdef VBOX_BUGREF_9217
    19211688        if (RT_UNLIKELY(pGVM != pVM))
    1922 #else
    1923         if (RT_UNLIKELY(pGVM->pVM != pVM))
    1924 #endif
    19251689            return VERR_INVALID_HANDLE;
    19261690    }
    … …  
    19671731    PGVM pGVM = pHandle->pGVM;
    19681732    AssertPtrReturn(pGVM, NULL);
    1969 #ifdef VBOX_BUGREF_9217
    19701733    AssertReturn(pGVM == pVM, NULL);
    1971 #else
    1972     AssertReturn(pGVM->pVM == pVM, NULL);
    1973 #endif
    19741734
    19751735    return pGVM;
    … …  
    20061766                      && ((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0))
    20071767        {
    2008 #ifdef VBOX_BUGREF_9217
    20091768            if (RT_LIKELY(pGVM == pVM))
    2010 #else
    2011             if (RT_LIKELY(pGVM->pVM == pVM))
    2012 #endif
    20131769            {
    20141770                /*
    … …  
    20381794                         * Some more VM data consistency checks.
    20391795                         */
    2040 #ifdef VBOX_BUGREF_9217
    20411796                        if (RT_LIKELY(   pVM->cCpus == pGVM->cCpus
    20421797                                      && pVM->hSelf == hGVM
    … …  
    20451800                                      && pVM->pSelf == pVM
    20461801                                      ))
    2047 #else
    2048                         if (RT_LIKELY(   pVM->cCpus == pGVM->cCpus
    2049                                       && pVM->hSelf == hGVM
    2050                                       && pVM->enmVMState >= VMSTATE_CREATING
    2051                                       && pVM->enmVMState <= VMSTATE_TERMINATED
    2052                                       && pVM->pVMR0 == pVM
    2053                                       ))
    2054 #endif
    20551802                        {
    20561803                            *ppGVMM = pGVMM;
    … …  
    20981845    AssertPtrReturn(pVM,  VERR_INVALID_POINTER);
    20991846    AssertReturn(((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0, VERR_INVALID_POINTER);
    2100 #ifdef VBOX_BUGREF_9217
    21011847    AssertReturn(pGVM == pVM, VERR_INVALID_VM_HANDLE);
    2102 #else
    2103     AssertReturn(pGVM->pVM == pVM, VERR_INVALID_VM_HANDLE);
    2104 #endif
    2105 
    21061848
    21071849    /*
    … …  
    21361878    AssertReturn(pVM->cCpus == pGVM->cCpus, VERR_INCONSISTENT_VM_HANDLE);
    21371879    AssertReturn(pVM->hSelf == hGVM, VERR_INCONSISTENT_VM_HANDLE);
    2138 #ifndef VBOX_BUGREF_9217
    2139     AssertReturn(pVM->pVMR0 == pVM, VERR_INCONSISTENT_VM_HANDLE);
    2140 #endif
    21411880    AssertReturn(   pVM->enmVMState >= VMSTATE_CREATING
    21421881                 && pVM->enmVMState <= VMSTATE_TERMINATED, VERR_INCONSISTENT_VM_HANDLE);
    … …  
    27832522    {
    27842523        if (idCpu < pGVM->cCpus)
    2785 #ifdef VBOX_BUGREF_9217
    27862524            rc = gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
    2787 #else
    2788             rc = gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
    2789 #endif
    27902525        else
    27912526            rc = VERR_INVALID_CPU_ID;
    … …  
    28412576    {
    28422577        if (idCpu < pGVM->cCpus)
    2843 #ifdef VBOX_BUGREF_9217
    28442578            rc = gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
    2845 #else
    2846             rc = gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
    2847 #endif
    28482579        else
    28492580            rc = VERR_INVALID_CPU_ID;
    … …  
    28952626            else if (VMCPUSET_IS_PRESENT(pPokeSet, idCpu))
    28962627            {
    2897 #ifdef VBOX_BUGREF_9217
    28982628                gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
    2899 #else
    2900                 gvmmR0SchedPokeOne(pGVM, &pVM->aCpus[idCpu]);
    2901 #endif
    29022629                GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
    29032630            }

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

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

  • trunk/src/VBox/VMM/VMMR0/NEMR0Native-win.cpp

    r80274 r80334  
    259259     */
    260260    VMCPU_ASSERT_EMT(pVCpu);
    261 # ifdef VBOX_BUGREF_9217
    262261    if (pvInput)
    263262        AssertReturn(((uintptr_t)pvInput + cbInput) - (uintptr_t)pVCpu <= sizeof(*pVCpu), VERR_INVALID_PARAMETER);
    264263    if (pvOutput)
    265264        AssertReturn(((uintptr_t)pvOutput + cbOutput) - (uintptr_t)pVCpu <= sizeof(*pVCpu), VERR_INVALID_PARAMETER);
    266 # else
    267     PVMCC        pVM  = pGVM->pVM;
    268     size_t const cbVM = RT_UOFFSETOF_DYN(VM, aCpus[pGVM->cCpus]);
    269     if (pvInput)
    270         AssertReturn(((uintptr_t)pvInput + cbInput) - (uintptr_t)pVM <= cbVM, VERR_INVALID_PARAMETER);
    271     if (pvOutput)
    272         AssertReturn(((uintptr_t)pvOutput + cbOutput) - (uintptr_t)pVM <= cbVM, VERR_INVALID_PARAMETER);
    273 # endif
    274265#endif
    275266
    … …  
    277268    int rc = SUPR0IoCtlPerform(pGVM->nemr0.s.pIoCtlCtx, uFunction,
    278269                               pvInput,
    279 #ifdef VBOX_BUGREF_9217
    280270                               pvInput  ? (uintptr_t)pvInput  + pVCpu->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
    281 #else
    282                                pvInput  ? (uintptr_t)pvInput  + pGVM->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
    283 #endif
    284271                               cbInput,
    285272                               pvOutput,
    286 #ifdef VBOX_BUGREF_9217
    287273                               pvOutput ? (uintptr_t)pvOutput + pVCpu->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
    288 #else
    289                                pvOutput ? (uintptr_t)pvOutput + pGVM->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
    290 #endif
    291274                               cbOutput,
    292275                               &rcNt);
    293276    if (RT_SUCCESS(rc) || !NT_SUCCESS((NTSTATUS)rcNt))
    294277        return (NTSTATUS)rcNt;
    295 #ifndef VBOX_BUGREF_9217
    296     RT_NOREF(pVCpu);
    297 #endif
    298278    return STATUS_UNSUCCESSFUL;
    299279}
    … …  
    363343        rc = SUPR0IoCtlSetupForHandle(pGVM->pSession, pVM->nem.s.hPartitionDevice, 0, &pGVM->nemr0.s.pIoCtlCtx);
    364344        AssertLogRelRCReturn(rc, rc);
    365 #ifdef VBOX_BUGREF_9217
    366345        for (VMCPUID idCpu = 0; idCpu < pGVM->cCpus; idCpu++)
    367346        {
    … …  
    369348            pGVCpu->nemr0.s.offRing3ConversionDelta = (uintptr_t)pGVM->aCpus[idCpu].pVCpuR3 - (uintptr_t)pGVCpu;
    370349        }
    371 #else
    372         pGVM->nemr0.s.offRing3ConversionDelta = (uintptr_t)pVM->pVMR3 - (uintptr_t)pGVM->pVM;
    373 #endif
    374350
    375351        /*
    376352         * Get the partition ID.
    377353         */
    378 #ifdef VBOX_BUGREF_9217
    379354        PVMCPUCC pVCpu0 = &pGVM->aCpus[0];
    380 #else
    381         PVMCPUCC pVCpu0 = &pGVM->pVM->aCpus[0];
    382 #endif
    383355        NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pVCpu0, pGVM->nemr0.s.IoCtlGetHvPartitionId.uFunction, NULL, 0,
    384356                                                &pVCpu0->nem.s.uIoCtlBuf.idPartition, sizeof(pVCpu0->nem.s.uIoCtlBuf.idPartition));
    … …  
    650622NEM_TMPL_STATIC int nemR0WinExportState(PGVM pGVM, PGVMCPU pGVCpu, PCPUMCTX pCtx)
    651623{
    652 #ifdef VBOX_BUGREF_9217
    653624    PVMCPUCC                   pVCpu  = pGVCpu;
    654 #else
    655     PVMCPUCC                   pVCpu  = &pGVM->pVM->aCpus[pGVCpu->idCpu];
    656 #endif
    657625    HV_INPUT_SET_VP_REGISTERS *pInput = (HV_INPUT_SET_VP_REGISTERS *)pGVCpu->nemr0.s.HypercallData.pbPage;
    658626    AssertPtrReturn(pInput, VERR_INTERNAL_ERROR_3);
    … …  
    13761344    AssertPtrReturn(pInput, VERR_INTERNAL_ERROR_3);
    13771345    AssertReturn(g_pfnHvlInvokeHypercall, VERR_NEM_MISSING_KERNEL_API);
    1378 #ifdef VBOX_BUGREF_9217
    13791346    Assert(pCtx == &pGVCpu->cpum.GstCtx);
    1380 #else
    1381     Assert(pCtx == &pGVCpu->pVCpu->cpum.GstCtx);
    1382 #endif
    13831347
    13841348    fWhat &= pCtx->fExtrn;
    … …  
    15481512
    15491513# ifdef LOG_ENABLED
    1550 #  ifdef VBOX_BUGREF_9217
    15511514    const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM);
    1552 #  else
    1553     const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM->pVM);
    1554 #  endif
    15551515# endif
    15561516    if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
    … …  
    16161576     * Copy information to the CPUM context.
    16171577     */
    1618 # ifdef VBOX_BUGREF_9217
    16191578    PVMCPUCC pVCpu = pGVCpu;
    1620 # else
    1621     PVMCPUCC pVCpu = &pGVM->pVM->aCpus[pGVCpu->idCpu];
    1622 # endif
    16231579    iReg = 0;
    16241580
    … …  
    24902446#ifdef NEM_WIN_WITH_RING0_RUNLOOP
    24912447    if (pGVM->nemr0.s.fMayUseRing0Runloop)
    2492 # ifdef VBOX_BUGREF_9217
    24932448        return nemHCWinRunGC(pGVM, &pGVM->aCpus[idCpu], pGVM, &pGVM->aCpus[idCpu]);
    2494 # else
    2495     {
    2496         PVMCC pVM = pGVM->pVM;
    2497         return nemHCWinRunGC(pVM, &pVM->aCpus[idCpu], pGVM, &pGVM->aCpus[idCpu]);
    2498     }
    2499 # endif
    25002449    return VERR_NEM_RING3_ONLY;
    25012450#else

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

    r80333 r80334  
    458458{
    459459    PDMDEV_ASSERT_DEVINS(pDevIns);
    460 #ifdef VBOX_BUGREF_9217
    461     PGVM   pGVM  = (PGVM)pDevIns->Internal.s.pVMR0;
     460    PGVM     pGVM  = (PGVM)pDevIns->Internal.s.pVMR0;
    462461    PVMCPUCC pVCpu = &pGVM->aCpus[0];     /* for PIC we always deliver to CPU 0, MP use APIC */
    463 #else
    464     PVMCC    pVM   = pDevIns->Internal.s.pVMR0;
    465     PVMCPUCC pVCpu = VMCC_GET_CPU_0(pVM); /* for PIC we always deliver to CPU 0, MP use APIC */
    466 #endif
    467462    /** @todo r=ramshankar: Propagating rcRZ and make all callers handle it? */
    468463    APICLocalInterrupt(pVCpu, 0 /* u8Pin */, 1 /* u8Level */, VINF_SUCCESS /* rcRZ */);
    … …  
    474469{
    475470    PDMDEV_ASSERT_DEVINS(pDevIns);
    476 #ifdef VBOX_BUGREF_9217
    477     PGVM   pGVM  = (PGVM)pDevIns->Internal.s.pVMR0;
     471    PGVM     pGVM  = (PGVM)pDevIns->Internal.s.pVMR0;
    478472    PVMCPUCC pVCpu = &pGVM->aCpus[0];     /* for PIC we always deliver to CPU 0, MP use APIC */
    479 #else
    480     PVMCC    pVM   = pDevIns->Internal.s.pVMR0;
    481     PVMCPUCC pVCpu = VMCC_GET_CPU_0(pVM); /* for PIC we always deliver to CPU 0, MP use APIC */
    482 #endif
    483473    /** @todo r=ramshankar: Propagating rcRZ and make all callers handle it? */
    484474    APICLocalInterrupt(pVCpu, 0 /* u8Pin */, 0 /* u8Level */, VINF_SUCCESS /* rcRZ */);

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

    r80333 r80334  
    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
    8180    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
    82 #else
    83     PGM_LOCK_ASSERT_OWNER_EX(pVM, VMCC_GET_CPU(pVM, idCpu));
    84 #endif
    8581
    8682    /*
    … …  
    205201    AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
    206202    AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
    207 #ifdef VBOX_BUGREF_9217
    208203    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
    209 #else
    210     PGM_LOCK_ASSERT_OWNER_EX(pVM, VMCC_GET_CPU(pVM, idCpu));
    211 #endif
    212204
    213205    /*
    … …  
    249241    AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
    250242    AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
    251 #ifdef VBOX_BUGREF_9217
    252243    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
    253 #else
    254     PGM_LOCK_ASSERT_OWNER_EX(pVM, VMCC_GET_CPU(pVM, idCpu));
    255 #endif
    256244    Assert(!pVM->pgm.s.cLargeHandyPages);
    257245

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

    r80333 r80334  
    5151VMMR0DECL(int) PGMR0SharedModuleCheck(PVMCC pVM, PGVM pGVM, VMCPUID idCpu, PGMMSHAREDMODULE pModule, PCRTGCPTR64 paRegionsGCPtrs)
    5252{
    53 #ifdef VBOX_BUGREF_9217
    54     PVMCPUCC              pVCpu         = &pGVM->aCpus[idCpu];
    55 #else
    56     PVMCPUCC              pVCpu         = VMCC_GET_CPU(pVM, idCpu);
    57 #endif
     53    PVMCPUCC            pVCpu         = &pGVM->aCpus[idCpu];
    5854    int                 rc            = VINF_SUCCESS;
    5955    bool                fFlushTLBs    = false;
    … …  
    167163
    168164    if (fFlushRemTLBs)
    169 #ifdef VBOX_BUGREF_9217
    170165        for (VMCPUID idCurCpu = 0; idCurCpu < pGVM->cCpus; idCurCpu++)
    171166            CPUMSetChangedFlags(&pGVM->aCpus[idCurCpu], CPUM_CHANGED_GLOBAL_TLB_FLUSH);
    172 #else
    173         for (VMCPUID idCurCpu = 0; idCurCpu < pVM->cCpus; idCurCpu++)
    174             CPUMSetChangedFlags(VMCC_GET_CPU(pVM, idCurCpu), CPUM_CHANGED_GLOBAL_TLB_FLUSH);
    175 #endif
    176167
    177168    return rc;

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

    r80333 r80334  
    395395     * Register the EMT R0 logger instance for VCPU 0.
    396396     */
    397 #ifdef VBOX_BUGREF_9217
    398     PVMCPUCC pVCpu = &pGVM->aCpus[0];
    399 #else
    400397    PVMCPUCC pVCpu = VMCC_GET_CPU_0(pVM);
    401 #endif
    402398
    403399    PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
    … …  
    475471                {
    476472                    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
    477 #ifdef VBOX_BUGREF_9217
    478473                    rc = EMR0InitVM(pGVM);
    479 #else
    480                     rc = EMR0InitVM(pGVM, pVM);
    481 #endif
    482474                    if (RT_SUCCESS(rc))
    483475                    {
    … …  
    544536     * Registration of ring 0 loggers.
    545537     */
    546 #ifdef VBOX_BUGREF_9217
    547538    PVMCPUCC       pVCpu     = &pGVM->aCpus[idCpu];
    548 #else
    549     PVMCPUCC       pVCpu     = VMCC_GET_CPU(pVM, idCpu);
    550 #endif
    551539    PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
    552540    if (   pR0Logger
    … …  
    729717static int vmmR0DoHalt(PGVM pGVM, PVMCC pVM, PGVMCPU pGVCpu, PVMCPUCC pVCpu)
    730718{
    731 #ifdef VBOX_BUGREF_9217
    732719    Assert(pVCpu == pGVCpu);
    733 #else
    734     Assert(pVCpu == pGVCpu->pVCpu);
    735 #endif
    736720
    737721    /*
    … …  
    13091293    }
    13101294
    1311     PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
    1312 #ifdef VBOX_BUGREF_9217
     1295    PGVMCPU   pGVCpu = &pGVM->aCpus[idCpu];
    13131296    PVMCPUCC  pVCpu  = pGVCpu;
    1314 #else
    1315     PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
    1316 #endif
    13171297    RTNATIVETHREAD const hNativeThread = RTThreadNativeSelf();
    13181298    if (RT_LIKELY(   pGVCpu->hEMT           == hNativeThread
    … …  
    16321612        }
    16331613
    1634 #ifdef VBOX_BUGREF_9217
    16351614        if (RT_LIKELY(pGVM == pVM))
    1636 #else
    1637         if (RT_LIKELY(pGVM->pVM == pVM))
    1638 #endif
    16391615        { /* likely */ }
    16401616        else
    16411617        {
    1642 #ifdef VBOX_BUGREF_9217
    16431618            SUPR0Printf("vmmR0EntryExWorker: pVM mismatch: got %p, pGVM/pVM=%p\n", pVM, pGVM);
    1644 #else
    1645             SUPR0Printf("vmmR0EntryExWorker: pVM mismatch: got %p, pGVM->pVM=%p\n", pVM, pGVM->pVM);
    1646 #endif
    16471619            return VERR_INVALID_PARAMETER;
    16481620        }
    … …  
    16561628        }
    16571629
    1658 #ifdef VBOX_BUGREF_9217
    16591630        if (RT_LIKELY(   pVM->enmVMState >= VMSTATE_CREATING
    16601631                      && pVM->enmVMState <= VMSTATE_TERMINATED
    … …  
    16621633                      && pVM->pSession   == pSession
    16631634                      && pVM->pSelf      == pVM))
    1664 #else
    1665         if (RT_LIKELY(   pVM->enmVMState >= VMSTATE_CREATING
    1666                       && pVM->enmVMState <= VMSTATE_TERMINATED
    1667                       && pVM->cCpus      == pGVM->cCpus
    1668                       && pVM->pSession   == pSession
    1669                       && pVM->pVMR0      == pVM))
    1670 #endif
    16711635        { /* likely */ }
    16721636        else
    16731637        {
    1674 #ifdef VBOX_BUGREF_9217
    16751638            SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{.enmVMState=%d, .cCpus=%#x(==%#x), .pSession=%p(==%p), .pSelf=%p(==%p)}! (op=%d)\n",
    16761639                        pVM, pVM->enmVMState, pVM->cCpus, pGVM->cCpus, pVM->pSession, pSession, pVM->pSelf, pVM, enmOperation);
    1677 #else
    1678             SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{.enmVMState=%d, .cCpus=%#x(==%#x), .pSession=%p(==%p), .pVMR0=%p(==%p)}! (op=%d)\n",
    1679                         pVM, pVM->enmVMState, pVM->cCpus, pGVM->cCpus, pVM->pSession, pSession, pVM->pVMR0, pVM, enmOperation);
    1680 #endif
    16811640            return VERR_INVALID_POINTER;
    16821641        }
    … …  
    22942253        && idCpu < pGVM->cCpus
    22952254        && pVM->pSession == pSession
    2296 #ifdef VBOX_BUGREF_9217
    2297         && pVM->pSelf != NULL
    2298 #else
    2299         && pVM->pVMR0 != NULL
    2300 #endif
    2301        )
     2255        && pVM->pSelf != NULL)
    23022256    {
    23032257        switch (enmOperation)
    … …  
    23132267            case VMMR0_DO_VMMR0_TERM:
    23142268            {
    2315                 PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
    2316 #ifdef VBOX_BUGREF_9217
     2269                PGVMCPU   pGVCpu = &pGVM->aCpus[idCpu];
    23172270                PVMCPUCC  pVCpu  = pGVCpu;
    2318 #else
    2319                 PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
    2320 #endif
    23212271                RTNATIVETHREAD hNativeThread = RTThreadNativeSelf();
    23222272                if (RT_LIKELY(   pGVCpu->hEMT           == hNativeThread
    … …  
    24082358
    24092359    PVMCC pVM = pR0Logger->pVM;
    2410     if (    !VALID_PTR(pVM)
    2411 # ifdef VBOX_BUGREF_9217
    2412         ||  pVM->pSelf != pVM
    2413 # else
    2414         ||  pVM->pVMR0 != pVM
    2415 # endif
    2416        )
     2360    if (   !VALID_PTR(pVM)
     2361        || pVM->pSelf != pVM)
    24172362    {
    24182363# ifdef DEBUG
    2419 #  ifdef VBOX_BUGREF_9217
    24202364        SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pSelf=%p! pLogger=%p\n", pVM, pVM->pSelf, pLogger);
    2421 #  else
    2422         SUPR0Printf("vmmR0LoggerFlush: pVM=%p! pVMR0=%p! pLogger=%p\n", pVM, pVM->pVMR0, pLogger);
    2423 #  endif
    24242365# endif
    24252366        return;
    … …  
    25102451    if (pGVCpu)
    25112452    {
    2512 #ifdef VBOX_BUGREF_9217
    25132453        PVMCPUCC pVCpu = pGVCpu;
    2514 #else
    2515         PVMCPUCC pVCpu = pGVCpu->pVCpu;
    2516 #endif
    25172454        if (RT_VALID_PTR(pVCpu))
    25182455        {
    … …  
    25212458            {
    25222459                if (   pVmmLogger->fCreated
    2523 #ifdef VBOX_BUGREF_9217
    2524                     && pVmmLogger->pVM == pGVCpu->pGVM
    2525 #else
    2526                     && pVmmLogger->pVM == pGVCpu->pVM
    2527 #endif
    2528                    )
     2460                    && pVmmLogger->pVM == pGVCpu->pGVM)
    25292461                {
    25302462                    if (pVmmLogger->Logger.fFlags & RTLOGFLAGS_DISABLED)

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

    r80333 r80334  
    157157        AssertCompileSizeAlignment(VM, PAGE_SIZE);
    158158        AssertCompileSizeAlignment(VMCPU, PAGE_SIZE);
    159 #ifdef VBOX_BUGREF_9217
    160159        AssertCompileSizeAlignment(GVM, PAGE_SIZE);
    161160        AssertCompileSizeAlignment(GVMCPU, PAGE_SIZE);
    162161        AssertRelease(pVM->cbSelf == sizeof(VM));
    163162        AssertRelease(pVM->cbVCpu == sizeof(VMCPU));
     163/** @todo get rid of this   */
    164164        RTGCPTR GCPtr;
    165165        rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0ForCall, sizeof(VM) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM", &GCPtr);
    … …  
    172172                                   sizeof(VMCPU) >> PAGE_SHIFT, &pVM->paVMPagesR3[offPages], "VMCPU", &GCPtrIgn);
    173173        }
    174 #else
    175         AssertRelease(pVM->cbSelf >= sizeof(VMCPU));
    176         RTGCPTR GCPtr;
    177         rc = MMR3HyperMapPages(pVM, pVM, pVM->pVMR0,
    178                                RT_ALIGN_Z(pVM->cbSelf, PAGE_SIZE) >> PAGE_SHIFT, pVM->paVMPagesR3, "VM",
    179                                &GCPtr);
    180 #endif
    181174        if (RT_SUCCESS(rc))
    182175        {
    … …  
    894887        //pHeap->pbHeapRC           = 0; // set by mmR3HyperHeapMap()
    895888        pHeap->pVMR3                = pVM;
    896 #ifdef VBOX_BUGREF_9217
    897889        pHeap->pVMR0                = pVM->pVMR0ForCall;
    898 #else
    899         pHeap->pVMR0                = pVM->pVMR0;
    900 #endif
    901890        pHeap->pVMRC                = pVM->pVMRC;
    902891        pHeap->cbHeap               = cbAligned - MMYPERHEAP_HDR_SIZE;

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

    r80333 r80334  
    179179                pCritSect->Core.NativeThreadOwner    = NIL_RTNATIVETHREAD;
    180180                pCritSect->pVMR3                     = pVM;
    181 #ifdef VBOX_BUGREF_9217
    182181                pCritSect->pVMR0                     = pVM->pVMR0ForCall;
    183 #else
    184                 pCritSect->pVMR0                     = pVM->pVMR0;
    185 #endif
    186182                pCritSect->pVMRC                     = pVM->pVMRC;
    187183                pCritSect->pvKey                     = pvKey;
    … …  
    280276#endif
    281277                    pCritSect->pVMR3                     = pVM;
    282 #ifdef VBOX_BUGREF_9217
    283278                    pCritSect->pVMR0                     = pVM->pVMR0ForCall;
    284 #else
    285                     pCritSect->pVMR0                     = pVM->pVMR0;
    286 #endif
    287279                    pCritSect->pVMRC                     = pVM->pVMRC;
    288280                    pCritSect->pvKey                     = pvKey;

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

    r80333 r80334  
    330330        pDevIns->Internal.s.pDevR3              = paDevs[i].pDev;
    331331        pDevIns->Internal.s.pVMR3               = pVM;
    332 #ifdef VBOX_BUGREF_9217
    333332        pDevIns->Internal.s.pVMR0               = pVM->pVMR0ForCall;
    334 #else
    335         pDevIns->Internal.s.pVMR0               = pVM->pVMR0;
    336 #endif
    337333        pDevIns->Internal.s.pVMRC               = pVM->pVMRC;
    338334        //pDevIns->Internal.s.pLunsR3             = NULL;

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

    r80333 r80334  
    722722                    pNew->Internal.s.pDrv           = pDrv;
    723723                    pNew->Internal.s.pVMR3          = pVM;
    724 #ifdef VBOX_BUGREF_9217
    725724                    pNew->Internal.s.pVMR0          = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0 ? pVM->pVMR0ForCall : NIL_RTR0PTR;
    726 #else
    727                     pNew->Internal.s.pVMR0          = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0 ? pVM->pVMR0 : NIL_RTR0PTR;
    728 #endif
    729725                    pNew->Internal.s.pVMRC          = pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_RC ? pVM->pVMRC : NIL_RTRCPTR;
    730726                    //pNew->Internal.s.fDetaching     = false;

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

    r80333 r80334  
    8888     */
    8989    pQueue->pVMR3 = pVM;
    90 #ifdef VBOX_BUGREF_9217
    9190    pQueue->pVMR0 = fRZEnabled ? pVM->pVMR0ForCall : NIL_RTR0PTR;
    92 #else
    93     pQueue->pVMR0 = fRZEnabled ? pVM->pVMR0 : NIL_RTR0PTR;
    94 #endif
    9591    pQueue->pVMRC = fRZEnabled ? pVM->pVMRC : NIL_RTRCPTR;
    9692    pQueue->pszName = pszName;

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

    r80333 r80334  
    239239     */
    240240    pPool->pVMR3     = pVM;
    241 #ifdef VBOX_BUGREF_9217
    242241    pPool->pVMR0     = pVM->pVMR0ForCall;
    243 #else
    244     pPool->pVMR0     = pVM->pVMR0;
    245 #endif
    246242    pPool->cMaxPages = cMaxPages;
    247243    pPool->cCurPages = PGMPOOL_IDX_FIRST;

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

    r80333 r80334  
    11501150    {
    11511151        pTimer->pVMRC = pVM->pVMRC;
    1152 #ifdef VBOX_BUGREF_9217
    11531152        pTimer->pVMR0 = pVM->pVMR0ForCall; /** @todo fix properly */
    1154 #else
    1155         pTimer->pVMR0 = pVM->pVMR0;
    1156 #endif
    11571153    }
    11581154}
    … …  
    15321528    pTimer->enmClock        = enmClock;
    15331529    pTimer->pVMR3           = pVM;
    1534 #ifdef VBOX_BUGREF_9217
    15351530    pTimer->pVMR0           = pVM->pVMR0ForCall; /** @todo fix properly */
    1536 #else
    1537     pTimer->pVMR0           = pVM->pVMR0;
    1538 #endif
    15391531    pTimer->pVMRC           = pVM->pVMRC;
    15401532    pTimer->enmState        = TMTIMERSTATE_STOPPED;

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

    r80333 r80334  
    582582        PVM pVM = pUVM->pVM = CreateVMReq.pVMR3;
    583583        AssertRelease(VALID_PTR(pVM));
    584 #ifdef VBOX_BUGREF_9217
    585584        AssertRelease(pVM->pVMR0ForCall == CreateVMReq.pVMR0);
    586 #else
    587         AssertRelease(pVM->pVMR0 == CreateVMReq.pVMR0);
    588 #endif
    589585        AssertRelease(pVM->pSession == pUVM->vm.s.pSession);
    590586        AssertRelease(pVM->cCpus == cCpus);

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

    r80281 r80334  
    361361    /** Hypercall input/ouput page. */
    362362    NEMR0HYPERCALLDATA          HypercallData;
    363 #  ifdef VBOX_BUGREF_9217
    364363    /** Delta to add to convert a ring-0 pointer to a ring-3 one.   */
    365364    uintptr_t                   offRing3ConversionDelta;
    366 #  endif
    367365# else
    368366    uint32_t                    uDummy;
    … …  
    380378    /** I/O control context. */
    381379    PSUPR0IOCTLCTX              pIoCtlCtx;
    382 # ifndef VBOX_BUGREF_9217
    383     /** Delta to add to convert a ring-0 pointer to a ring-3 one.   */
    384     uintptr_t                   offRing3ConversionDelta;
    385 # endif
    386380    /** Info about the VidGetHvPartitionId I/O control interface. */
    387381    NEMWINIOCTL                 IoCtlGetHvPartitionId;

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

    r80284 r80334  
    5757    void       *pvVM = NULL;
    5858    RTR0PTR     pvR0 = NIL_RTR0PTR;
    59 #ifdef VBOX_BUGREF_9217
    6059    SUPPAGE     aPages[(sizeof(GVM) + NUM_CPUS * sizeof(GVMCPU)) >> PAGE_SHIFT];
    61 #else
    62     SUPPAGE     aPages[(sizeof(VM) + NUM_CPUS * sizeof(VMCPU)) >> PAGE_SHIFT];
    63 #endif
    6460    rc = SUPR3Init(NULL);
    6561    if (RT_FAILURE(rc))
    … …  
    7773    PVM  pVM = (PVM)pvVM;
    7874    pVM->paVMPagesR3 = aPages;
    79 #ifdef VBOX_BUGREF_9217
    8075    pVM->pVMR0ForCall = pvR0;
    81 #else
    82     pVM->pVMR0 = pvR0;
    83 #endif
    8476
    8577    PUVM pUVM = (PUVM)RTMemPageAllocZ(RT_ALIGN_Z(sizeof(*pUVM), PAGE_SIZE));
    … …  
    9486
    9587    pVM->cCpus = NUM_CPUS;
    96 #ifdef VBOX_BUGREF_9217
    9788    pVM->cbSelf = sizeof(VM);
    9889    pVM->cbVCpu = sizeof(VMCPU);
    … …  
    10394        pVCpu = (PVMCPU)((uintptr_t)pVCpu + sizeof(GVMCPU));
    10495    }
    105 #else
    106     pVM->cbSelf = RT_UOFFSETOF_DYN(VM, aCpus[pVM->cCpus]);
    107     for (VMCPUID idCpu = 0; idCpu < NUM_CPUS; idCpu++)
    108         pVM->apCpusR3[idCpu] = &pVM->aCpus[idCpu];
    109 #endif
    11096
    11197    rc = STAMR3InitUVM(pUVM);

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

    r80282 r80334  
    652652                 * Allocate and init the VM structure.
    653653                 */
    654 #ifdef VBOX_BUGREF_9217
    655654                PVM pVM = (PVM)RTMemPageAllocZ(sizeof(VM) + sizeof(VMCPU));
    656655                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
    662656                if (RT_SUCCESS(rc))
    663657                {
    … …  
    667661                    pVM->cCpus = 1;
    668662
    669 #ifdef VBOX_BUGREF_9217
    670663                    PVMCPU pVCpu = (PVMCPU)(pVM + 1);
    671 #else
    672                     PVMCPU pVCpu = &pVM->aCpus[0];
    673 #endif
    674664                    pVCpu->pVMR3 = pVM;
    675665                    pVCpu->hNativeThread = RTThreadNativeSelf();

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

    r80281 r80334  
    14191419    GEN_CHECK_OFF(VM, pUVM);
    14201420    GEN_CHECK_OFF(VM, pVMR3);
    1421 #ifdef VBOX_BUGREF_9217
    14221421    GEN_CHECK_OFF(VM, pVMR0ForCall);
    1423 #else
    1424     GEN_CHECK_OFF(VM, pVMR0);
    1425 #endif
    14261422    GEN_CHECK_OFF(VM, pVMRC);
    1427 #if defined(VBOX_BUGREF_9217) && defined(IN_RING0)
     1423#ifdef IN_RING0
    14281424    GEN_CHECK_OFF(VM, hSelfUnsafe);
    14291425    GEN_CHECK_OFF(VM, cCpusUnsafe);
    … …  
    14631459    GEN_CHECK_OFF(VM, cfgm);
    14641460    GEN_CHECK_OFF(VM, apic);
    1465 #ifndef VBOX_BUGREF_9217
    1466     GEN_CHECK_OFF(VM, aCpus);
    1467 #endif
    14681461
    14691462
    … …  
    14731466    GEN_CHECK_OFF(VMCPU, pUVCpu);
    14741467    GEN_CHECK_OFF(VMCPU, pVMR3);
    1475 #ifndef VBOX_BUGREF_9217
    1476     GEN_CHECK_OFF(VMCPU, pVMR0);
    1477 #endif
     1468    GEN_CHECK_OFF(VMCPU, pVCpuR0ForVtg);
    14781469    GEN_CHECK_OFF(VMCPU, pVMRC);
    14791470    GEN_CHECK_OFF(VMCPU, idCpu);

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

    r80281 r80334  
    254254
    255255    PVM pVM = NULL; NOREF(pVM);
    256 #ifndef VBOX_BUGREF_9217
    257     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0], PAGE_SIZE);
    258     CHECK_MEMBER_ALIGNMENT(VM, aCpus[1], PAGE_SIZE);
    259     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Host, 64);
    260     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Guest, 64);
    261     CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Host, 64);
    262     CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Guest, 64);
    263     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Hyper, 64);
    264     CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Hyper, 64);
    265 # ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI
    266     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.pvApicBase, 8);
    267 # endif
    268 
    269     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].iem.s.DataTlb, 64);
    270     CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].iem.s.CodeTlb, 64);
    271 #endif
    272256
    273257    CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.u64CallRing3Arg, 8);
    … …  
    284268
    285269    /* the VMCPUs are page aligned TLB hit reasons. */
    286 #ifndef VBOX_BUGREF_9217
    287     CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096);
    288 #endif
    289270    CHECK_SIZE_ALIGNMENT(VMCPU, 4096);
    290271
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