VirtualBox

Changeset 73389 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Jul 28, 2018 7:03:03 AM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
124007
Message:

VMM, SUPDrv: Nested VMX: bugref:9180 Implement some of the VMX MSRs.

Location:
trunk/src/VBox/VMM/VMMAll
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r73290 r73389  
    12921292{
    12931293    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1294     if (pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures.fVmx)
     1294    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1295    if (pGuestFeatures->fVmx)
    12951296    {
    1296         uint64_t const fVmcsRevisionId  = VMX_VMCS_REVISION_ID;
    1297         uint64_t const f32BitAddrLimit  = 0;
    1298         uint64_t const fDualMonSmiSmm   = 0;
    1299         uint64_t const fVmcsMemType     = VMX_VMCS_MEM_TYPE_WB;
    1300         uint64_t const fVmcsInsOutsInfo = pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures.fVmxInsOutInfo;
    1301         uint64_t const fTrueCapMsrs     = 0;
    1302         *puValue = fVmcsRevisionId
    1303                  | (f32BitAddrLimit  << MSR_IA32_VMX_BASIC_VMCS_PHYS_WIDTH_SHIFT)
    1304                  | (fDualMonSmiSmm   << MSR_IA32_VMX_BASIC_DUAL_MON_SHIFT)
    1305                  | (fVmcsMemType     << MSR_IA32_VMX_BASIC_VMCS_MEM_TYPE_SHIFT)
    1306                  | (fVmcsInsOutsInfo << MSR_IA32_VMX_BASIC_VMCS_INS_OUTS_SHIFT)
    1307                  | (fTrueCapMsrs     << MSR_IA32_VMX_BASIC_TRUE_CONTROLS_SHIFT);
     1297        *puValue = RT_BF_MAKE(VMX_BF_BASIC_VMCS_ID,       VMX_VMCS_REVISION_ID          )
     1298                 | RT_BF_MAKE(VMX_BF_BASIC_DUAL_MON,      0                             )
     1299                 | RT_BF_MAKE(VMX_BF_BASIC_VMCS_MEM_TYPE, VMX_BASIC_MEM_TYPE_WB         )
     1300                 | RT_BF_MAKE(VMX_BF_BASIC_VMCS_INS_OUTS, pGuestFeatures->fVmxInsOutInfo)
     1301                 | RT_BF_MAKE(VMX_BF_BASIC_TRUE_CTLS,     0                             );
    13081302    }
    13091303    else
    … …  
    13161310static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxPinbasedCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    13171311{
    1318     RT_NOREF_PV(pVCpu); RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1319     *puValue = 0;
     1312    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
     1313    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1314    if (pGuestFeatures->fVmx)
     1315    {
     1316        uint32_t const fFeatures = (pGuestFeatures->fVmxExtIntExit   << VMX_BF_PIN_CTLS_EXT_INT_EXIT_SHIFT )
     1317                                 | (pGuestFeatures->fVmxNmiExit      << VMX_BF_PIN_CTLS_NMI_EXIT_SHIFT     )
     1318                                 | (pGuestFeatures->fVmxVirtNmi      << VMX_BF_PIN_CTLS_VIRT_NMI_SHIFT     )
     1319                                 | (pGuestFeatures->fVmxPreemptTimer << VMX_BF_PIN_CTLS_PREEMPT_TIMER_SHIFT);
     1320        uint32_t const fVal      = VMX_PIN_CTLS_DEFAULT1;
     1321        uint32_t const fZap      = fFeatures | VMX_PIN_CTLS_DEFAULT1;
     1322        AssertMsgReturn((fVal & fZap) == fVal, ("fVal=%#RX32 fZap=%#RX32 fFeatures=%#RX32\n", fVal, fZap, fFeatures),
     1323                        VERR_CPUM_INVALID_HWVIRT_FEAT_COMBO);
     1324        *puValue = RT_MAKE_U64(fVal, fZap);
     1325    }
     1326    else
     1327        *puValue = 0;
    13201328    return VINF_SUCCESS;
    13211329}
    … …  
    13251333static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxProcbasedCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    13261334{
    1327     RT_NOREF_PV(pVCpu); RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1328     *puValue = 0;
     1335    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
     1336    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1337    if (pGuestFeatures->fVmx)
     1338    {
     1339        uint32_t const fFeatures = (pGuestFeatures->fVmxIntWindowExit     << VMX_BF_PROC_CTLS_INT_WINDOW_EXIT_SHIFT   )
     1340                                 | (pGuestFeatures->fVmxTscOffsetting     << VMX_BF_PROC_CTLS_USE_TSC_OFFSETTING_SHIFT)
     1341                                 | (pGuestFeatures->fVmxHltExit           << VMX_BF_PROC_CTLS_HLT_EXIT_SHIFT          )
     1342                                 | (pGuestFeatures->fVmxInvlpgExit        << VMX_BF_PROC_CTLS_INVLPG_EXIT_SHIFT       )
     1343                                 | (pGuestFeatures->fVmxMwaitExit         << VMX_BF_PROC_CTLS_MWAIT_EXIT_SHIFT        )
     1344                                 | (pGuestFeatures->fVmxRdpmcExit         << VMX_BF_PROC_CTLS_RDPMC_EXIT_SHIFT        )
     1345                                 | (pGuestFeatures->fVmxRdtscExit         << VMX_BF_PROC_CTLS_RDTSC_EXIT_SHIFT        )
     1346                                 | (pGuestFeatures->fVmxCr3LoadExit       << VMX_BF_PROC_CTLS_CR3_LOAD_EXIT_SHIFT     )
     1347                                 | (pGuestFeatures->fVmxCr3StoreExit      << VMX_BF_PROC_CTLS_CR3_STORE_EXIT_SHIFT    )
     1348                                 | (pGuestFeatures->fVmxCr8LoadExit       << VMX_BF_PROC_CTLS_CR8_LOAD_EXIT_SHIFT     )
     1349                                 | (pGuestFeatures->fVmxCr8StoreExit      << VMX_BF_PROC_CTLS_CR8_STORE_EXIT_SHIFT    )
     1350                                 | (pGuestFeatures->fVmxTprShadow         << VMX_BF_PROC_CTLS_USE_TPR_SHADOW_SHIFT    )
     1351                                 | (pGuestFeatures->fVmxNmiWindowExit     << VMX_BF_PROC_CTLS_NMI_WINDOW_EXIT_SHIFT   )
     1352                                 | (pGuestFeatures->fVmxMovDRxExit        << VMX_BF_PROC_CTLS_MOV_DR_EXIT_SHIFT       )
     1353                                 | (pGuestFeatures->fVmxUncondIoExit      << VMX_BF_PROC_CTLS_UNCOND_IO_EXIT_SHIFT    )
     1354                                 | (pGuestFeatures->fVmxUseIoBitmaps      << VMX_BF_PROC_CTLS_USE_IO_BITMAPS_SHIFT    )
     1355                                 | (pGuestFeatures->fVmxMonitorTrapFlag   << VMX_BF_PROC_CTLS_MONITOR_TRAP_FLAG_SHIFT )
     1356                                 | (pGuestFeatures->fVmxUseMsrBitmaps     << VMX_BF_PROC_CTLS_USE_MSR_BITMAPS_SHIFT   )
     1357                                 | (pGuestFeatures->fVmxMonitorExit       << VMX_BF_PROC_CTLS_MONITOR_EXIT_SHIFT      )
     1358                                 | (pGuestFeatures->fVmxPauseExit         << VMX_BF_PROC_CTLS_PAUSE_EXIT_SHIFT        )
     1359                                 | (pGuestFeatures->fVmxSecondaryExecCtls << VMX_BF_PROC_CTLS_USE_SECONDARY_CTLS_SHIFT);
     1360        uint32_t const fVal      = VMX_PROC_CTLS_DEFAULT1;
     1361        uint32_t const fZap      = fFeatures | VMX_PROC_CTLS_DEFAULT1;
     1362        AssertMsgReturn((fVal & fZap) == fVal, ("fVal=%#RX32 fZap=%#RX32 fFeatures=%#RX32\n", fVal, fZap, fFeatures),
     1363                        VERR_CPUM_INVALID_HWVIRT_FEAT_COMBO);
     1364        *puValue = RT_MAKE_U64(fVal, fZap);
     1365    }
     1366    else
     1367        *puValue = 0;
    13291368    return VINF_SUCCESS;
    13301369}
    … …  
    13341373static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxExitCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    13351374{
    1336     RT_NOREF_PV(pVCpu); RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1337     *puValue = 0;
     1375    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
     1376    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1377    if (pGuestFeatures->fVmx)
     1378    {
     1379        uint32_t const fFeatures = (pGuestFeatures->fVmxExitSaveDebugCtls << VMX_BF_EXIT_CTLS_SAVE_DEBUG_SHIFT          )
     1380                                 | (pGuestFeatures->fVmxHostAddrSpaceSize << VMX_BF_EXIT_CTLS_HOST_ADDR_SPACE_SIZE_SHIFT)
     1381                                 | (pGuestFeatures->fVmxExitAckExtInt     << VMX_BF_EXIT_CTLS_ACK_EXT_INT_SHIFT         )
     1382                                 | (pGuestFeatures->fVmxExitSaveEferMsr   << VMX_BF_EXIT_CTLS_SAVE_EFER_MSR_SHIFT       )
     1383                                 | (pGuestFeatures->fVmxExitLoadEferMsr   << VMX_BF_EXIT_CTLS_LOAD_EFER_MSR_SHIFT       )
     1384                                 | (pGuestFeatures->fVmxSavePreemptTimer  << VMX_BF_EXIT_CTLS_SAVE_PREEMPT_TIMER_SHIFT  );
     1385        uint32_t const fVal      = VMX_EXIT_CTLS_DEFAULT1;
     1386        uint32_t const fZap      = fFeatures | VMX_EXIT_CTLS_DEFAULT1;
     1387        AssertMsgReturn((fVal & fZap) == fVal, ("fVal=%#RX32 fZap=%#RX32 fFeatures=%#RX32\n", fVal, fZap, fFeatures),
     1388                        VERR_CPUM_INVALID_HWVIRT_FEAT_COMBO);
     1389        *puValue = RT_MAKE_U64(fVal, fZap);
     1390    }
     1391    else
     1392        *puValue = 0;
    13381393    return VINF_SUCCESS;
    13391394}
    … …  
    13431398static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxEntryCtls(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    13441399{
    1345     RT_NOREF_PV(pVCpu); RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1346     *puValue = 0;
     1400    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
     1401    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1402    if (pGuestFeatures->fVmx)
     1403    {
     1404        uint32_t const fFeatures = (pGuestFeatures->fVmxEntryLoadDebugCtls << VMX_BF_ENTRY_CTLS_LOAD_DEBUG_SHIFT      )
     1405                                 | (pGuestFeatures->fVmxIa32eModeGuest     << VMX_BF_ENTRY_CTLS_IA32E_MODE_GUEST_SHIFT)
     1406                                 | (pGuestFeatures->fVmxEntryLoadEferMsr   << VMX_BF_ENTRY_CTLS_LOAD_EFER_MSR_SHIFT   );
     1407        uint32_t const fDefault1 = VMX_ENTRY_CTLS_DEFAULT1;
     1408        uint32_t const fVal      = fDefault1;
     1409        uint32_t const fZap      = fFeatures | fDefault1;
     1410        AssertMsgReturn((fVal & fZap) == fVal, ("fVal=%#RX32 fZap=%#RX32 fFeatures=%#RX32\n", fVal, fZap, fFeatures),
     1411                        VERR_CPUM_INVALID_HWVIRT_FEAT_COMBO);
     1412        *puValue = RT_MAKE_U64(fVal, fZap);
     1413    }
     1414    else
     1415        *puValue = 0;
    13471416    return VINF_SUCCESS;
    13481417}
    … …  
    13521421static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxMisc(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    13531422{
    1354     RT_NOREF_PV(pVCpu); RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1355     *puValue = 0;
     1423    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
     1424    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1425    if (pGuestFeatures->fVmx)
     1426    {
     1427        /** @todo Think about this especially preemption timer TSC shifts.  */
     1428        *puValue = 0;
     1429    }
     1430    else
     1431        *puValue = 0;
    13561432    return VINF_SUCCESS;
    13571433}
    … …  
    14061482static DECLCALLBACK(VBOXSTRICTRC) cpumMsrRd_Ia32VmxProcBasedCtls2(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    14071483{
    1408     RT_NOREF_PV(pVCpu); RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
    1409     *puValue = 0;
     1484    RT_NOREF_PV(idMsr); RT_NOREF_PV(pRange);
     1485    PCCPUMFEATURES pGuestFeatures = &pVCpu->CTX_SUFF(pVM)->cpum.s.GuestFeatures;
     1486    if (pGuestFeatures->fVmx)
     1487    {
     1488        uint32_t const fFeatures = (pGuestFeatures->fVmxVirtApicAccess    << VMX_BF_PROC_CTLS2_VIRT_APIC_ACCESS_SHIFT  )
     1489                                 | (pGuestFeatures->fVmxEpt               << VMX_BF_PROC_CTLS2_EPT_SHIFT               )
     1490                                 | (pGuestFeatures->fVmxDescTableExit     << VMX_BF_PROC_CTLS2_DESC_TABLE_EXIT_SHIFT   )
     1491                                 | (pGuestFeatures->fVmxRdtscp            << VMX_BF_PROC_CTLS2_RDTSCP_SHIFT            )
     1492                                 | (pGuestFeatures->fVmxVirtX2ApicAccess  << VMX_BF_PROC_CTLS2_VIRT_X2APIC_ACCESS_SHIFT)
     1493                                 | (pGuestFeatures->fVmxVpid              << VMX_BF_PROC_CTLS2_VPID_SHIFT              )
     1494                                 | (pGuestFeatures->fVmxWbinvdExit        << VMX_BF_PROC_CTLS2_WBINVD_EXIT_SHIFT       )
     1495                                 | (pGuestFeatures->fVmxUnrestrictedGuest << VMX_BF_PROC_CTLS2_UNRESTRICTED_GUEST_SHIFT)
     1496                                 | (pGuestFeatures->fVmxPauseLoopExit     << VMX_BF_PROC_CTLS2_PAUSE_LOOP_EXIT_SHIFT   )
     1497                                 | (pGuestFeatures->fVmxInvpcid           << VMX_BF_PROC_CTLS2_INVPCID_SHIFT           );
     1498        uint32_t const fVal      = 0;
     1499        uint32_t const fZap      = fFeatures;
     1500        *puValue = RT_MAKE_U64(fVal, fZap);
     1501    }
     1502    else
     1503        *puValue = 0;
    14101504    return VINF_SUCCESS;
    14111505}

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

    r73293 r73389  
    349349
    350350/**
    351  * Checks if MSR bitmaps are available. It is assumed that when it's available
     351 * Checks if MSR bitmaps are active. It is assumed that when it's available
    352352 * it will be used as well.
    353353 *
    … …  
    355355 * @param   pVM         The cross context VM structure.
    356356 */
    357 VMM_INT_DECL(bool) HMAreMsrBitmapsAvailable(PVM pVM)
     357VMM_INT_DECL(bool) HMIsMsrBitmapActive(PVM pVM)
    358358{
    359359    if (HMIsEnabled(pVM))
    … …  
    363363
    364364        if (   pVM->hm.s.vmx.fSupported
    365             && (pVM->hm.s.vmx.Msrs.ProcCtls.n.allowed1 & VMX_VMCS_CTRL_PROC_EXEC_USE_MSR_BITMAPS))
    366         {
     365            && (pVM->hm.s.vmx.Msrs.ProcCtls.n.allowed1 & VMX_PROC_CTLS_USE_MSR_BITMAPS))
    367366            return true;
    368         }
    369367    }
    370368    return false;
    … …  
    389387 * Checks if VT-x is active.
    390388 *
    391  * @returns true if AMD-V is active.
     389 * @returns true if VT-x is active.
    392390 * @param   pVM         The cross context VM structure.
    393391 *
    … …  
    396394VMM_INT_DECL(bool) HMIsVmxActive(PVM pVM)
    397395{
    398     return pVM->hm.s.vmx.fSupported && HMIsEnabled(pVM);
     396    return HMIsVmxSupported(pVM) && HMIsEnabled(pVM);
     397}
     398
     399
     400/**
     401 * Checks if VT-x is supported by the host CPU.
     402 *
     403 * @returns true if VT-x is supported, false otherwise.
     404 * @param   pVM         The cross context VM structure.
     405 *
     406 * @remarks Works before hmR3InitFinalizeR0.
     407 */
     408VMM_INT_DECL(bool) HMIsVmxSupported(PVM pVM)
     409{
     410    return pVM->hm.s.vmx.fSupported;
    399411}
    400412
    … …  
    544556
    545557
     558/**
     559 * Gets a copy of the VMX host MSRs that were read by HM during ring-0
     560 * initialization.
     561 *
     562 * @return VBox status code.
     563 * @param   pVM        The cross context VM structure.
     564 * @param   pVmxMsrs   Where to store the VMXMSRS struct (only valid when
     565 *                     VINF_SUCCESS is returned).
     566 *
     567 * @remarks Caller needs to take care not to call this function too early. Call
     568 *          after HM initialization is fully complete.
     569 */
     570VMM_INT_DECL(int) HMVmxGetHostMsrs(PVM pVM, PVMXMSRS pVmxMsrs)
     571{
     572    AssertPtrReturn(pVM,      VERR_INVALID_PARAMETER);
     573    AssertPtrReturn(pVmxMsrs, VERR_INVALID_PARAMETER);
     574    if (pVM->hm.s.vmx.fSupported)
     575    {
     576        *pVmxMsrs = pVM->hm.s.vmx.Msrs;
     577        return VINF_SUCCESS;
     578    }
     579    return VERR_VMX_NOT_SUPPORTED;
     580}
     581
     582
     583#if 0 /** @todo Update comment hm_vmx.h VMXMSRS struct if this is removed. */
     584/**
     585 * Gets the specified VMX host MSR that was read by HM during ring-0
     586 * initialization.
     587 *
     588 * @return VBox status code.
     589 * @param   pVM        The cross context VM structure.
     590 * @param   idMsr      The MSR.
     591 * @param   puValue    Where to store the MSR value (only updated when VINF_SUCCESS
     592 *                     is returned).
     593 *
     594 * @remarks Caller needs to take care not to call this function too early. Call
     595 *          after HM initialization is fully complete.
     596 */
     597VMM_INT_DECL(int) HMVmxGetHostMsr(PVM pVM, uint32_t idMsr, uint64_t *puValue)
     598{
     599    AssertPtrReturn(pVM,     VERR_INVALID_PARAMETER);
     600    AssertPtrReturn(puValue, VERR_INVALID_PARAMETER);
     601
     602    if (!pVM->hm.s.vmx.fSupported)
     603        return VERR_VMX_NOT_SUPPORTED;
     604
     605    PCVMXMSRS pVmxMsrs = &pVM->hm.s.vmx.Msrs;
     606    switch (idMsr)
     607    {
     608        case MSR_IA32_FEATURE_CONTROL:         *puValue =  pVmxMsrs->u64FeatCtrl;      break;
     609        case MSR_IA32_VMX_BASIC:               *puValue =  pVmxMsrs->u64Basic;         break;
     610        case MSR_IA32_VMX_PINBASED_CTLS:       *puValue =  pVmxMsrs->PinCtls.u;        break;
     611        case MSR_IA32_VMX_PROCBASED_CTLS:      *puValue =  pVmxMsrs->ProcCtls.u;       break;
     612        case MSR_IA32_VMX_PROCBASED_CTLS2:     *puValue =  pVmxMsrs->ProcCtls2.u;      break;
     613        case MSR_IA32_VMX_EXIT_CTLS:           *puValue =  pVmxMsrs->ExitCtls.u;       break;
     614        case MSR_IA32_VMX_ENTRY_CTLS:          *puValue =  pVmxMsrs->EntryCtls.u;      break;
     615        case MSR_IA32_VMX_TRUE_PINBASED_CTLS:  *puValue =  pVmxMsrs->TruePinCtls.u;    break;
     616        case MSR_IA32_VMX_TRUE_PROCBASED_CTLS: *puValue =  pVmxMsrs->TrueProcCtls.u;   break;
     617        case MSR_IA32_VMX_TRUE_ENTRY_CTLS:     *puValue =  pVmxMsrs->TrueEntryCtls.u;  break;
     618        case MSR_IA32_VMX_TRUE_EXIT_CTLS:      *puValue =  pVmxMsrs->TrueExitCtls.u;   break;
     619        case MSR_IA32_VMX_MISC:                *puValue =  pVmxMsrs->u64Misc;          break;
     620        case MSR_IA32_VMX_CR0_FIXED0:          *puValue =  pVmxMsrs->u64Cr0Fixed0;     break;
     621        case MSR_IA32_VMX_CR0_FIXED1:          *puValue =  pVmxMsrs->u64Cr0Fixed1;     break;
     622        case MSR_IA32_VMX_CR4_FIXED0:          *puValue =  pVmxMsrs->u64Cr4Fixed0;     break;
     623        case MSR_IA32_VMX_CR4_FIXED1:          *puValue =  pVmxMsrs->u64Cr4Fixed1;     break;
     624        case MSR_IA32_VMX_VMCS_ENUM:           *puValue =  pVmxMsrs->u64VmcsEnum;      break;
     625        case MSR_IA32_VMX_VMFUNC:              *puValue =  pVmxMsrs->u64VmFunc;        break;
     626        case MSR_IA32_VMX_EPT_VPID_CAP:        *puValue =  pVmxMsrs->u64EptVpidCaps;   break;
     627        default:
     628        {
     629            AssertMsgFailed(("Invalid MSR %#x\n", idMsr));
     630            return VERR_NOT_FOUND;
     631        }
     632    }
     633    return VINF_SUCCESS;
     634}
     635#endif
     636
     637
    546638#ifndef IN_RC
    547639/**
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette