Changeset 45622 in vbox for trunk/src

Timestamp:

Apr 18, 2013 9:49:05 PM (12 years ago)

Author:

vboxsync

Message:

Main: Introducing CPUPropertyType_LongMode + legacy band aid.

Location:

trunk/src/VBox/Main

Files:

• idl/VirtualBox.xidl (modified) (1 diff)
• include/ApplianceImplPrivate.h (modified) (1 diff)
• include/MachineImpl.h (modified) (1 diff)
• src-client/ConsoleImpl2.cpp (modified) (1 diff)
• src-server/ApplianceImpl.cpp (modified) (1 diff)
• src-server/ApplianceImplExport.cpp (modified) (1 diff)
• src-server/MachineImpl.cpp (modified) (7 diffs)
• xml/Settings.cpp (modified) (5 diffs)

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -937 +937 @@
         This setting determines whether VirtualBox will expose a synthetic CPU to the guest to allow
         teleporting between host systems that differ significantly.
+      </desc>
+    </const>
+    <const name="LongMode"             value="3">
+      <desc>
+        This setting determines whether VirtualBox will advertice long mode
+        (i.e. 64-bit guest support) and let the guest enter it.
       </desc>
     </const>

trunk/src/VBox/Main/include/ApplianceImplPrivate.h

@@ -224 +224 @@
 void convertCIMOSType2VBoxOSType(Utf8Str &strType, ovf::CIMOSType_T c, const Utf8Str &cStr);
 
-ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox);
+ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox, BOOL fLongMode);
 
 Utf8Str convertNetworkAttachmentTypeToString(NetworkAttachmentType_T type);

trunk/src/VBox/Main/include/MachineImpl.h

@@ -269 +269 @@
         BOOL                mAccelerate2DVideoEnabled;
         BOOL                mPAEEnabled;
+        settings::Hardware::LongModeType mLongMode;
         BOOL                mSyntheticCpu;
         ULONG               mCPUCount;

trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

@@ -890 +890 @@
          */
         BOOL fIsGuest64Bit;
-        hrc = guestOSType->COMGETTER(Is64Bit)(&fIsGuest64Bit);                              H();
+        hrc = pMachine->GetCPUProperty(CPUPropertyType_LongMode, &fIsGuest64Bit);           H();
         BOOL fSupportsLongMode;
         hrc = host->GetProcessorFeature(ProcessorFeature_LongMode, &fSupportsLongMode);     H();

trunk/src/VBox/Main/src-server/ApplianceImpl.cpp

@@ -245 +245 @@
  * Private helper func that suggests a VirtualBox guest OS type
  * for the given OVF operating system type.
+ * @returns CIM OS type.
  * @param pcszVBox  Our guest OS type identifier string.
- */
-ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox)
+ * @param fLongMode Whether long mode is enabled and a 64-bit CIM type is
+ *                  preferred even if the VBox guest type isn't 64-bit.
+ */
+ovf::CIMOSType_T convertVBoxOSType2CIMOSType(const char *pcszVBox, BOOL fLongMode)
 {
     for (size_t i = 0; i < RT_ELEMENTS(g_osTypes); ++i)
     {
         if (!RTStrICmp(pcszVBox, Global::OSTypeId(g_osTypes[i].osType)))
+        {
+            if (fLongMode && !(g_osTypes[i].osType & VBOXOSTYPE_x64))
+            {
+                VBOXOSTYPE enmDesiredOsType = (VBOXOSTYPE)((int)g_osTypes[i].osType | (int)VBOXOSTYPE_x64);
+                size_t     j = i;
+                while (++j < RT_ELEMENTS(g_osTypes))
+                    if (g_osTypes[j].osType == enmDesiredOsType)
+                        return g_osTypes[j].cim;
+                j = i;
+                while (--j > 0)
+                    if (g_osTypes[j].osType == enmDesiredOsType)
+                        return g_osTypes[j].cim;
+                /* Not all OSes have 64-bit versions, so just return the 32-bit variant. */
+            }
             return g_osTypes[i].cim;
+        }
     }
 

trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

@@ -127 +127 @@
         // HWVirtExVPIDEnabled?
         // PAEEnabled?
+        // Long mode enabled?
+        BOOL fLongMode;
+        rc = GetCPUProperty(CPUPropertyType_LongMode, &fLongMode);
+        if (FAILED(rc)) throw rc;
+
         // snapshotFolder?
         // VRDPServer?
 
         /* Guest OS type */
-        ovf::CIMOSType_T cim = convertVBoxOSType2CIMOSType(strOsTypeVBox.c_str());
+        ovf::CIMOSType_T cim = convertVBoxOSType2CIMOSType(strOsTypeVBox.c_str(), fLongMode);
         pNewDesc->addEntry(VirtualSystemDescriptionType_OS,
                            "",

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -65 +65 @@
 
 #include <iprt/asm.h>
+#if HC_ARCH_BITS == 32
+# include <iprt/asm-amd64-x86.h>
+#endif
 #include <iprt/path.h>
 #include <iprt/dir.h>
@@ -191 +194 @@
     mPAEEnabled = false;
 #endif
+    mLongMode =  HC_ARCH_BITS == 64 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
     mSyntheticCpu = false;
     mHPETEnabled = false;
@@ -351 +355 @@
             for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
                 mSerialPorts[slot]->applyDefaults(aOsType);
+
+            /* Let the OS type select 64-bit ness. */
+            mHWData->mLongMode = aOsType->is64Bit()
+                               ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
         }
 
@@ -2028 +2036 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    switch(property)
-    {
-    case CPUPropertyType_PAE:
-        *aVal = mHWData->mPAEEnabled;
-        break;
-
-    case CPUPropertyType_Synthetic:
-        *aVal = mHWData->mSyntheticCpu;
-        break;
-
-    default:
-        return E_INVALIDARG;
+    switch (property)
+    {
+        case CPUPropertyType_PAE:
+            *aVal = mHWData->mPAEEnabled;
+            break;
+
+        case CPUPropertyType_Synthetic:
+            *aVal = mHWData->mSyntheticCpu;
+            break;
+
+        case CPUPropertyType_LongMode:
+            if (mHWData->mLongMode == settings::Hardware::LongMode_Enabled)
+                *aVal = TRUE;
+            else if (mHWData->mLongMode == settings::Hardware::LongMode_Disabled)
+                *aVal = FALSE;
+#if HC_ARCH_BITS == 64
+            else
+                *aVal = TRUE;
+#else
+            else
+            {
+                *aVal = FALSE;
+
+                ComPtr<IGuestOSType> guestOSType;
+                HRESULT hrc2 = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(), guestOSType.asOutParam());
+                if (SUCCEEDED(hrc2))
+                {
+                    BOOL fIs64Bit = FALSE;
+                    hrc2 = pGuestOSType->COMGETTER(Is64Bit)(&fIs64Bit); AssertComRC(hrc);
+                    if (SUCCEEDED(hrc2) && fIs64Bit)
+                    {
+                        ComObjPtr<Host> ptrHost = mParent->host();
+                        alock.release();
+                        hrc2 = ptrHost->GetProcessorFeature(ProcessorFeature_LongMode, aVal)
+                        AssertComRC(hrc);
+                        if (FAILURE(hrc2))
+                            *aVal = FALSE;
+                    }
+            }
+#endif
+            break;
+
+        default:
+            return E_INVALIDARG;
     }
     return S_OK;
@@ -2054 +2094 @@
     if (FAILED(rc)) return rc;
 
-    switch(property)
-    {
-    case CPUPropertyType_PAE:
-        setModified(IsModified_MachineData);
-        mHWData.backup();
-        mHWData->mPAEEnabled = !!aVal;
-        break;
-
-    case CPUPropertyType_Synthetic:
-        setModified(IsModified_MachineData);
-        mHWData.backup();
-        mHWData->mSyntheticCpu = !!aVal;
-        break;
-
-    default:
-        return E_INVALIDARG;
+    switch (property)
+    {
+        case CPUPropertyType_PAE:
+            setModified(IsModified_MachineData);
+            mHWData.backup();
+            mHWData->mPAEEnabled = !!aVal;
+            break;
+
+        case CPUPropertyType_Synthetic:
+            setModified(IsModified_MachineData);
+            mHWData.backup();
+            mHWData->mSyntheticCpu = !!aVal;
+            break;
+
+        case CPUPropertyType_LongMode:
+            setModified(IsModified_MachineData);
+            mHWData.backup();
+            mHWData->mLongMode = !aVal ? settings::Hardware::LongMode_Disabled : settings::Hardware::LongMode_Enabled;
+            break;
+
+        default:
+            return E_INVALIDARG;
     }
     return S_OK;
@@ -8597 +8643 @@
         mHWData->mPAEEnabled                  = data.fPAE;
         mHWData->mSyntheticCpu                = data.fSyntheticCpu;
-
+        mHWData->mLongMode                    = data.enmLongMode;
         mHWData->mCPUCount                    = data.cCPUs;
         mHWData->mCPUHotPlugEnabled           = data.fCpuHotPlug;
@@ -9827 +9873 @@
         data.fHardwareVirtForce     = !!mHWData->mHWVirtExForceEnabled;
         data.fPAE                   = !!mHWData->mPAEEnabled;
+        data.enmLongMode            = mHWData->mLongMode;
         data.fSyntheticCpu          = !!mHWData->mSyntheticCpu;
 

trunk/src/VBox/Main/xml/Settings.cpp

@@ -1734 +1734 @@
           fSyntheticCpu(false),
           fPAE(false),
+          enmLongMode(HC_ARCH_BITS == 64 ? Hardware::LongMode_Enabled : Hardware::LongMode_Disabled),
           cCPUs(1),
           fCpuHotPlug(false),
@@ -1800 +1801 @@
                   && (fSyntheticCpu             == h.fSyntheticCpu)
                   && (fPAE                      == h.fPAE)
+                  && (enmLongMode               == h.enmLongMode)
                   && (cCPUs                     == h.cCPUs)
                   && (fCpuHotPlug               == h.fCpuHotPlug)
@@ -2537 +2539 @@
                 pelmCPUChild->getAttributeValue("enabled", hw.fPAE);
 
+            bool fLongMode;
+            if (   (pelmCPUChild = pelmHwChild->findChildElement("LongMode"))
+                && pelmCPUChild->getAttributeValue("enabled", fLongMode) )
+                hw.enmLongMode = fLongMode ? Hardware::LongMode_Enabled : Hardware::LongMode_Disabled;
+            else
+                hw.enmLongMode = Hardware::LongMode_Legacy;
+
             if ((pelmCPUChild = pelmHwChild->findChildElement("SyntheticCpu")))
                 pelmCPUChild->getAttributeValue("enabled", hw.fSyntheticCpu);
@@ -3701 +3710 @@
     pelmCPU->createChild("HardwareVirtExVPID")->setAttribute("enabled", hw.fVPID);
     pelmCPU->createChild("PAE")->setAttribute("enabled", hw.fPAE);
+    if (m->sv >= SettingsVersion_v1_14 && hw.enmLongMode != Hardware::LongMode_Legacy)
+        pelmCPU->createChild("LongMode")->setAttribute("enabled", hw.enmLongMode == Hardware::LongMode_Enabled);
 
     if (hw.fSyntheticCpu)
@@ -4990 +5001 @@
     {
         // VirtualBox 4.3 adds default frontend setting.
-        if (!hardwareMachine.strDefaultFrontend.isEmpty())
+        if (   !hardwareMachine.strDefaultFrontend.isEmpty()
+            || hardwareMachine.enmLongMode != Hardware::LongMode_Legacy)
             m->sv = SettingsVersion_v1_14;
     }