Changeset 101035 in vbox for trunk/src/VBox/Frontends

Timestamp:

Sep 7, 2023 8:59:15 AM (15 months ago)

Author:

vboxsync

Message:

Initial commit (based draft v2 / on patch v5) for implementing platform architecture support for x86 and ARM. bugref:10384

Location:

trunk/src/VBox/Frontends

Files:

• VBoxManage/VBoxManageAppliance.cpp (modified) (1 diff)
• VBoxManage/VBoxManageControlVM.cpp (modified) (7 diffs)
• VBoxManage/VBoxManageInfo.cpp (modified) (15 diffs)
• VBoxManage/VBoxManageList.cpp (modified) (5 diffs)
• VBoxManage/VBoxManageMisc.cpp (modified) (10 diffs)
• VBoxManage/VBoxManageModifyVM.cpp (modified) (29 diffs)
• VBoxManage/VBoxManageStorageController.cpp (modified) (6 diffs)
• VBoxManage/VBoxManageUtils.cpp (modified) (1 diff)
• VBoxManage/VBoxManageUtils.h (modified) (1 diff)
• VirtualBox/src/converter/UIConverterBackendGlobal.cpp (modified) (11 diffs)
• VirtualBox/src/globals/UICommon.cpp (modified) (1 diff)
• VirtualBox/src/globals/UIDetailsGenerator.cpp (modified) (10 diffs)
• VirtualBox/src/notificationcenter/UINotificationObjects.cpp (modified) (2 diffs)
• VirtualBox/src/notificationcenter/UINotificationObjects.h (modified) (2 diffs)
• VirtualBox/src/runtime/UIMachineLogic.cpp (modified) (2 diffs)
• VirtualBox/src/runtime/UISession.cpp (modified) (5 diffs)
• VirtualBox/src/settings/editors/UIAudioControllerEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UIBootOrderEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UIChipsetEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UIGraphicsControllerEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UINetworkFeaturesEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UIParavirtProviderEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UIStorageSettingsEditor.cpp (modified) (12 diffs)
• VirtualBox/src/settings/editors/UITpmEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/editors/UIUSBControllerEditor.cpp (modified) (2 diffs)
• VirtualBox/src/settings/machine/UIMachineSettingsGeneral.cpp (modified) (2 diffs)
• VirtualBox/src/settings/machine/UIMachineSettingsNetwork.cpp (modified) (2 diffs)
• VirtualBox/src/settings/machine/UIMachineSettingsSerial.cpp (modified) (4 diffs)
• VirtualBox/src/settings/machine/UIMachineSettingsSystem.cpp (modified) (8 diffs)
• VirtualBox/src/snapshots/UISnapshotDetailsWidget.cpp (modified) (10 diffs)
• VirtualBox/src/widgets/UIApplianceEditorWidget.cpp (modified) (2 diffs)
• VirtualBox/src/wizards/clonevm/UIWizardCloneVM.cpp (modified) (1 diff)
• VirtualBox/src/wizards/newvm/UIWizardNewVM.cpp (modified) (9 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp

@@ -1016 +1016 @@
                                             break;
                                     }
-                                    CHECK_ERROR_RET(systemProperties, GetMaxPortCountForStorageBus(enmStorageBus, &maxPorts),
-                                        RTEXITCODE_FAILURE);
+
+                                    PlatformArchitecture_T platformArch = PlatformArchitecture_x86; /** @todo BUGBUG Appliances only handle x86 so far! */
+
+                                    ComPtr<IPlatformProperties> pPlatformProperties;
+                                    CHECK_ERROR_RET(pVirtualBox, GetPlatformProperties(platformArch, pPlatformProperties.asOutParam()),
+                                                                                       RTEXITCODE_FAILURE);
+
+                                    CHECK_ERROR_RET(pPlatformProperties, GetMaxPortCountForStorageBus(enmStorageBus, &maxPorts),
+                                                    RTEXITCODE_FAILURE);
                                     if (uTargetControllerPort >= maxPorts)
                                         return errorSyntax(Appliance::tr("Illegal port value: %u. For %ls controllers the only valid values are 0 to %lu (inclusive)"),

trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

@@ -805 +805 @@
             setCurrentSubcommand(HELP_SCOPE_CONTROLVM_SETLINKSTATE);
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][12], NetworkAdapterCount, "NIC");
             if (!n)
@@ -843 +843 @@
             setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICTRACEFILE);
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][12], NetworkAdapterCount, "NIC");
             if (!n)
@@ -887 +887 @@
             setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICTRACE);
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][8], NetworkAdapterCount, "NIC");
             if (!n)
@@ -928 +928 @@
         {
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][5], NetworkAdapterCount, "NIC");
             if (!n)
@@ -1022 +1022 @@
             setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICPROPERTY);
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][11], NetworkAdapterCount, "NIC");
             if (!n)
@@ -1084 +1084 @@
             setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NICPROMISC);
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][10], NetworkAdapterCount, "NIC");
             if (!n)
@@ -1134 +1134 @@
             setCurrentSubcommand(HELP_SCOPE_CONTROLVM_NIC);
             /* Get the number of network adapters */
-            ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine);
+            ULONG NetworkAdapterCount = getMaxNics(sessionMachine);
             unsigned n = parseNum(&a->argv[1][3], NetworkAdapterCount, "NIC");
             if (!n)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -1092 +1092 @@
         pSession->COMGETTER(Console)(pConsole.asOutParam());
 
+    ComPtr<IPlatform> platform;
+    CHECK_ERROR_RET(machine, COMGETTER(Platform)(platform.asOutParam()), hrc);
+    ComPtr<IPlatformProperties> platformProperties;
+    CHECK_ERROR_RET(platform, COMGETTER(Properties)(platformProperties.asOutParam()), hrc);
+
+    PlatformArchitecture_T platformArch;
+    CHECK_ERROR_RET(platform, COMGETTER(Architecture)(&platformArch), hrc);
+
+    ComPtr<IFirmwareSettings> firmwareSettings;
+    CHECK_ERROR_RET(machine, COMGETTER(FirmwareSettings)(firmwareSettings.asOutParam()), hrc);
+
     char szNm[80];
     char szValue[256];
@@ -1170 +1181 @@
         Bstr strPasswordId;
         HRESULT hrc2 = machine->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
+
+        SHOW_UTF8_STRING(      "encryption",              Info::tr("Encryption:"),
+                                                          SUCCEEDED(hrc2) ? "enabled" : "disabled");
         if (SUCCEEDED(hrc2))
         {
-            RTPrintf("Encryption:     enabled\n");
-            RTPrintf("Cipher:         %ls\n", strCipher.raw());
-            RTPrintf("Password ID:    %ls\n", strPasswordId.raw());
-        }
-        else
-            RTPrintf("Encryption:     disabled\n");
+            SHOW_BSTR_STRING(      "enc_cipher",          Info::tr("Cipher:"), strCipher);
+            SHOW_BSTR_STRING(      "enc_password_id",     Info::tr("Password ID:"), strPasswordId);
+        }
     }
     SHOW_STRINGARRAY_PROP( machine, Groups,                     "groups",               Info::tr("Groups:"));
+    SHOW_UTF8_STRING(      "platformArchitecture",              Info::tr("Platform Architecture:"),
+                                                                                        platformArch == PlatformArchitecture_x86 ? "x86" : "ARM");
     Bstr osTypeId;
     CHECK_ERROR2I_RET(machine, COMGETTER(OSTypeId)(osTypeId.asOutParam()), hrcCheck);
@@ -1199 +1212 @@
     SHOW_ULONG_PROP(pGraphicsAdapter, VRAMSize,                 "vram",                 Info::tr("VRAM size:"),       "MB");
     SHOW_ULONG_PROP(       machine, CPUExecutionCap,            "cpuexecutioncap",      Info::tr("CPU exec cap:"),    "%");
-    SHOW_BOOLEAN_PROP(     machine, HPETEnabled,                "hpet",                 Info::tr("HPET:"));
     SHOW_STRING_PROP_MAJ(  machine, CPUProfile,                 "cpu-profile",          Info::tr("CPUProfile:"),      "host", 6);
 
     ChipsetType_T chipsetType;
-    CHECK_ERROR2I_RET(machine, COMGETTER(ChipsetType)(&chipsetType), hrcCheck);
+    CHECK_ERROR2I_RET(platform, COMGETTER(ChipsetType)(&chipsetType), hrcCheck);
     const char *pszChipsetType;
     switch (chipsetType)
@@ -1226 +1238 @@
 
     FirmwareType_T firmwareType;
-    CHECK_ERROR2I_RET(machine, COMGETTER(FirmwareType)(&firmwareType), hrcCheck);
+    CHECK_ERROR2I_RET(firmwareSettings, COMGETTER(FirmwareType)(&firmwareType), hrcCheck);
     const char *pszFirmwareType;
     switch (firmwareType)
@@ -1246 +1258 @@
 
     SHOW_ULONG_PROP(       machine, CPUCount, "cpus", Info::tr("Number of CPUs:"), "");
-    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_PAE, &f), "pae", "PAE:");
-    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_LongMode, &f), "longmode", Info::tr("Long Mode:"));
-    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_TripleFaultReset, &f), "triplefaultreset", Info::tr("Triple Fault Reset:"));
-    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_APIC, &f), "apic", "APIC:");
-    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_X2APIC, &f), "x2apic", "X2APIC:");
-    SHOW_BOOLEAN_METHOD(   machine, GetCPUProperty(CPUPropertyType_HWVirt, &f), "nested-hw-virt", Info::tr("Nested VT-x/AMD-V:"));
+
+    switch (platformArch)
+    {
+        case PlatformArchitecture_x86:
+        {
+            ComPtr<IPlatformX86> platformX86;
+            CHECK_ERROR_RET(platform, COMGETTER(X86)(platformX86.asOutParam()), hrc);
+
+            SHOW_BOOLEAN_PROP(     platformX86, HPETEnabled, "hpet", Info::tr("HPET:"));
+            SHOW_BOOLEAN_METHOD(   platformX86, GetCPUProperty(CPUPropertyTypeX86_PAE, &f), "pae", "PAE:");
+            SHOW_BOOLEAN_METHOD(   platformX86, GetCPUProperty(CPUPropertyTypeX86_LongMode, &f), "longmode", Info::tr("Long Mode:"));
+            SHOW_BOOLEAN_METHOD(   platformX86, GetCPUProperty(CPUPropertyTypeX86_TripleFaultReset, &f), "triplefaultreset", Info::tr("Triple Fault Reset:"));
+            SHOW_BOOLEAN_METHOD(   platformX86, GetCPUProperty(CPUPropertyTypeX86_APIC, &f), "apic", "APIC:");
+            SHOW_BOOLEAN_METHOD(   platformX86, GetCPUProperty(CPUPropertyTypeX86_X2APIC, &f), "x2apic", "X2APIC:");
+            SHOW_BOOLEAN_METHOD(   platformX86, GetCPUProperty(CPUPropertyTypeX86_HWVirt, &f), "nested-hw-virt", Info::tr("Nested VT-x/AMD-V:"));
+
+            if (details != VMINFO_MACHINEREADABLE)
+                RTPrintf("%-28s ", Info::tr("CPUID overrides:"));
+            ULONG uOrdinal = 0;
+            for (uOrdinal = 0; uOrdinal < _4K; uOrdinal++)
+            {
+                ULONG uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX;
+                hrc = platformX86->GetCPUIDLeafByOrdinal(uOrdinal, &uLeaf, &uSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
+                if (SUCCEEDED(hrc))
+                {
+                    if (details == VMINFO_MACHINEREADABLE)
+                        RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x,%08x", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
+                    else
+                    {
+                        if (!uOrdinal)
+                            RTPrintf(Info::tr("Leaf no.      EAX      EBX      ECX      EDX\n"));
+                        RTPrintf("%-28s %08x/%03x  %08x %08x %08x %08x\n", "", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
+                    }
+                }
+                else
+                {
+                    if (hrc != E_INVALIDARG)
+                        com::GlueHandleComError(machine, "GetCPUIDLeaf", hrc, __FILE__, __LINE__);
+                    break;
+                }
+            }
+            if (!uOrdinal && details != VMINFO_MACHINEREADABLE)
+                RTPrintf(Info::tr("None\n"));
+
+            SHOW_BOOLEAN_METHOD(platformX86, GetHWVirtExProperty(HWVirtExPropertyType_Enabled,   &f),   "hwvirtex",     Info::tr("Hardware Virtualization:"));
+            SHOW_BOOLEAN_METHOD(platformX86, GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &f),"nestedpaging", Info::tr("Nested Paging:"));
+            SHOW_BOOLEAN_METHOD(platformX86, GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &f),  "largepages",   Info::tr("Large Pages:"));
+            SHOW_BOOLEAN_METHOD(platformX86, GetHWVirtExProperty(HWVirtExPropertyType_VPID, &f),        "vtxvpid",      "VT-x VPID:");
+            SHOW_BOOLEAN_METHOD(platformX86, GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &f), "vtxux", Info::tr("VT-x Unrestricted Exec.:"));
+            SHOW_BOOLEAN_METHOD(platformX86, GetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, &f),      "virtvmsavevmload", Info::tr("AMD-V Virt. Vmsave/Vmload:"));
+            break;
+        }
+
+        case PlatformArchitecture_ARM:
+        {
+            /** @todo BUGBUG ARM stuff here */
+            break;
+        }
+
+        default:
+            AssertFailed();
+            break;
+    }
+
     SHOW_ULONG_PROP(       machine, CPUIDPortabilityLevel, "cpuid-portability-level", Info::tr("CPUID Portability Level:"), "");
-
-    if (details != VMINFO_MACHINEREADABLE)
-        RTPrintf("%-28s ", Info::tr("CPUID overrides:"));
-    ULONG uOrdinal = 0;
-    for (uOrdinal = 0; uOrdinal < _4K; uOrdinal++)
-    {
-        ULONG uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX;
-        hrc = machine->GetCPUIDLeafByOrdinal(uOrdinal, &uLeaf, &uSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
-        if (SUCCEEDED(hrc))
-        {
-            if (details == VMINFO_MACHINEREADABLE)
-                RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x,%08x", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
-            else
-            {
-                if (!uOrdinal)
-                    RTPrintf(Info::tr("Leaf no.      EAX      EBX      ECX      EDX\n"));
-                RTPrintf("%-28s %08x/%03x  %08x %08x %08x %08x\n", "", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
-            }
-        }
-        else
-        {
-            if (hrc != E_INVALIDARG)
-                com::GlueHandleComError(machine, "GetCPUIDLeaf", hrc, __FILE__, __LINE__);
-            break;
-        }
-    }
-    if (!uOrdinal && details != VMINFO_MACHINEREADABLE)
-        RTPrintf(Info::tr("None\n"));
-
-    ComPtr<IBIOSSettings> biosSettings;
-    CHECK_ERROR2I_RET(machine, COMGETTER(BIOSSettings)(biosSettings.asOutParam()), hrcCheck);
 
     ComPtr<INvramStore> nvramStore;
     CHECK_ERROR2I_RET(machine, COMGETTER(NonVolatileStore)(nvramStore.asOutParam()), hrcCheck);
 
-    BIOSBootMenuMode_T bootMenuMode;
-    CHECK_ERROR2I_RET(biosSettings, COMGETTER(BootMenuMode)(&bootMenuMode), hrcCheck);
+    FirmwareBootMenuMode_T enmBootMenuMode;
+    CHECK_ERROR2I_RET(firmwareSettings, COMGETTER(BootMenuMode)(&enmBootMenuMode), hrcCheck);
     const char *pszBootMenu;
-    switch (bootMenuMode)
-    {
-        case BIOSBootMenuMode_Disabled:
+    switch (enmBootMenuMode)
+    {
+        case FirmwareBootMenuMode_Disabled:
             if (details == VMINFO_MACHINEREADABLE)
                 pszBootMenu = "disabled";
@@ -1299 +1338 @@
                 pszBootMenu = Info::tr("disabled");
             break;
-        case BIOSBootMenuMode_MenuOnly:
+        case FirmwareBootMenuMode_MenuOnly:
             if (details == VMINFO_MACHINEREADABLE)
                 pszBootMenu = "menuonly";
@@ -1316 +1355 @@
     CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
     ULONG maxBootPosition = 0;
-    CHECK_ERROR2I_RET(systemProperties, COMGETTER(MaxBootPosition)(&maxBootPosition), hrcCheck);
+    CHECK_ERROR2I_RET(platformProperties, COMGETTER(MaxBootPosition)(&maxBootPosition), hrcCheck);
     for (ULONG i = 1; i <= maxBootPosition; i++)
     {
@@ -1339 +1378 @@
     }
 
-    SHOW_BOOLEAN_PROP(biosSettings, ACPIEnabled,                "acpi",                 "ACPI:");
-    SHOW_BOOLEAN_PROP(biosSettings, IOAPICEnabled,              "ioapic",               "IOAPIC:");
+    SHOW_BOOLEAN_PROP(firmwareSettings, ACPIEnabled,                "acpi",                 "ACPI:");
+    SHOW_BOOLEAN_PROP(firmwareSettings, IOAPICEnabled,              "ioapic",               "IOAPIC:");
 
     APICMode_T apicMode;
-    CHECK_ERROR2I_RET(biosSettings, COMGETTER(APICMode)(&apicMode), hrcCheck);
+    CHECK_ERROR2I_RET(firmwareSettings, COMGETTER(APICMode)(&apicMode), hrcCheck);
     const char *pszAPIC;
     switch (apicMode)
@@ -1369 +1408 @@
     SHOW_UTF8_STRING("biosapic", Info::tr("BIOS APIC mode:"), pszAPIC);
 
-    SHOW_LONG64_PROP(biosSettings,  TimeOffset, "biossystemtimeoffset", Info::tr("Time offset:"),  Info::tr("ms"));
+    SHOW_LONG64_PROP(firmwareSettings,  TimeOffset, "biossystemtimeoffset", Info::tr("Time offset:"),  Info::tr("ms"));
     Bstr bstrNVRAMFile;
     CHECK_ERROR2I_RET(nvramStore, COMGETTER(NonVolatileStorageFile)(bstrNVRAMFile.asOutParam()), hrcCheck);
     if (bstrNVRAMFile.isNotEmpty())
         SHOW_BSTR_STRING("BIOS NVRAM File", Info::tr("BIOS NVRAM File:"), bstrNVRAMFile);
-    SHOW_BOOLEAN_PROP_EX(machine,   RTCUseUTC, "rtcuseutc", Info::tr("RTC:"), "UTC", Info::tr("local time"));
-    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_Enabled,   &f),   "hwvirtex",     Info::tr("Hardware Virtualization:"));
-    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &f),"nestedpaging", Info::tr("Nested Paging:"));
-    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &f),  "largepages",   Info::tr("Large Pages:"));
-    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VPID, &f),        "vtxvpid",      "VT-x VPID:");
-    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &f), "vtxux", Info::tr("VT-x Unrestricted Exec.:"));
-    SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, &f),      "virtvmsavevmload", Info::tr("AMD-V Virt. Vmsave/Vmload:"));
-
-#ifdef VBOX_WITH_IOMMU_AMD
+    SHOW_BOOLEAN_PROP_EX(platform,   RTCUseUTC, "rtcuseutc", Info::tr("RTC:"), "UTC", Info::tr("local time"));
+
+#ifdef VBOX_WITH_IOMMU_AMD /** @todo BUGBUG Do we set / needs this for ARM as well? */
     IommuType_T iommuType;
-    CHECK_ERROR2I_RET(machine, COMGETTER(IommuType)(&iommuType), hrcCheck);
+    CHECK_ERROR2I_RET(platform, COMGETTER(IommuType)(&iommuType), hrcCheck);
     const char *pszIommuType = iommuTypeToString(iommuType, details);
     SHOW_UTF8_STRING("iommu", "IOMMU:", pszIommuType);
@@ -1587 +1620 @@
 
     /* get the maximum amount of NICS */
-    ULONG maxNICs = getMaxNics(pVirtualBox, machine);
+    ULONG maxNICs = getMaxNics(machine);
 
     for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++)
@@ -2009 +2042 @@
     /* get the maximum amount of UARTs */
     ULONG maxUARTs = 0;
-    sysProps->COMGETTER(SerialPortCount)(&maxUARTs);
+    platformProperties->COMGETTER(SerialPortCount)(&maxUARTs);
     for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++)
     {
@@ -2030 +2063 @@
             else
             {
-                ULONG ulIRQ, ulIOBase;
+                ULONG ulIRQ, ulIOAddress;
                 PortMode_T HostMode;
                 Bstr path;
@@ -2036 +2069 @@
                 UartType_T UartType;
                 uart->COMGETTER(IRQ)(&ulIRQ);
-                uart->COMGETTER(IOBase)(&ulIOBase);
+                uart->COMGETTER(IOAddress)(&ulIOAddress);
                 uart->COMGETTER(Path)(path.asOutParam());
                 uart->COMGETTER(Server)(&fServer);
@@ -2043 +2076 @@
 
                 if (details == VMINFO_MACHINEREADABLE)
-                    RTPrintf("%s=\"%#06x,%d\"\n", szNm, ulIOBase, ulIRQ);
+                    RTPrintf("%s=\"%#06x,%d\"\n", szNm, ulIOAddress, ulIRQ);
                 else
-                    RTPrintf(Info::tr("%-28s I/O base: %#06x, IRQ: %d"), szNm, ulIOBase, ulIRQ);
+                    RTPrintf(Info::tr("%-28s I/O address: %#06x, IRQ: %d"), szNm, ulIOAddress, ulIRQ);
                 switch (HostMode)
                 {
@@ -2115 +2148 @@
     /* get the maximum amount of LPTs */
     ULONG maxLPTs = 0;
-    sysProps->COMGETTER(ParallelPortCount)(&maxLPTs);
+    platformProperties->COMGETTER(ParallelPortCount)(&maxLPTs);
     for (ULONG currentLPT = 0; currentLPT < maxLPTs; currentLPT++)
     {

trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

@@ -732 +732 @@
     CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
 
+    ComPtr<IPlatformProperties> platformProperties;
+    CHECK_ERROR2I_RET(systemProperties, COMGETTER(Platform)(platformProperties.asOutParam()), hrcCheck);
+
     Bstr str;
     ULONG ulValue;
@@ -757 +760 @@
     systemProperties->COMGETTER(InfoVDSize)(&i64Value);
     RTPrintf(List::tr("Virtual disk limit (info):       %lld Bytes\n", "" , i64Value), i64Value);
-    systemProperties->COMGETTER(SerialPortCount)(&ulValue);
+    platformProperties->COMGETTER(SerialPortCount)(&ulValue);
     RTPrintf(List::tr("Maximum Serial Port count:       %u\n"), ulValue);
-    systemProperties->COMGETTER(ParallelPortCount)(&ulValue);
+    platformProperties->COMGETTER(ParallelPortCount)(&ulValue);
     RTPrintf(List::tr("Maximum Parallel Port count:     %u\n"), ulValue);
-    systemProperties->COMGETTER(MaxBootPosition)(&ulValue);
+    platformProperties->COMGETTER(MaxBootPosition)(&ulValue);
     RTPrintf(List::tr("Maximum Boot Position:           %u\n"), ulValue);
-    systemProperties->GetMaxNetworkAdapters(ChipsetType_PIIX3, &ulValue);
+    platformProperties->GetMaxNetworkAdapters(ChipsetType_PIIX3, &ulValue);
     RTPrintf(List::tr("Maximum PIIX3 Network Adapter count:   %u\n"), ulValue);
-    systemProperties->GetMaxNetworkAdapters(ChipsetType_ICH9,  &ulValue);
+    platformProperties->GetMaxNetworkAdapters(ChipsetType_ICH9,  &ulValue);
     RTPrintf(List::tr("Maximum ICH9 Network Adapter count:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue);
     RTPrintf(List::tr("Maximum PIIX3 IDE Controllers:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue);
     RTPrintf(List::tr("Maximum ICH9 IDE Controllers:    %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
     RTPrintf(List::tr("Maximum IDE Port count:          %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
     RTPrintf(List::tr("Maximum Devices per IDE Port:    %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue);
     RTPrintf(List::tr("Maximum PIIX3 SATA Controllers:  %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue);
     RTPrintf(List::tr("Maximum ICH9 SATA Controllers:   %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
     RTPrintf(List::tr("Maximum SATA Port count:         %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
     RTPrintf(List::tr("Maximum Devices per SATA Port:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue);
     RTPrintf(List::tr("Maximum PIIX3 SCSI Controllers:  %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue);
     RTPrintf(List::tr("Maximum ICH9 SCSI Controllers:   %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
     RTPrintf(List::tr("Maximum SCSI Port count:         %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
     RTPrintf(List::tr("Maximum Devices per SCSI Port:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue);
     RTPrintf(List::tr("Maximum SAS PIIX3 Controllers:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue);
     RTPrintf(List::tr("Maximum SAS ICH9 Controllers:    %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
     RTPrintf(List::tr("Maximum SAS Port count:          %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
     RTPrintf(List::tr("Maximum Devices per SAS Port:    %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_PCIe, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_PCIe, &ulValue);
     RTPrintf(List::tr("Maximum NVMe PIIX3 Controllers:  %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_PCIe, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_PCIe, &ulValue);
     RTPrintf(List::tr("Maximum NVMe ICH9 Controllers:   %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
     RTPrintf(List::tr("Maximum NVMe Port count:         %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
     RTPrintf(List::tr("Maximum Devices per NVMe Port:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_VirtioSCSI, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_VirtioSCSI, &ulValue);
     RTPrintf(List::tr("Maximum virtio-scsi PIIX3 Controllers:  %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_VirtioSCSI, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_VirtioSCSI, &ulValue);
     RTPrintf(List::tr("Maximum virtio-scsi ICH9 Controllers:   %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
     RTPrintf(List::tr("Maximum virtio-scsi Port count:         %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
     RTPrintf(List::tr("Maximum Devices per virtio-scsi Port:   %u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
     RTPrintf(List::tr("Maximum PIIX3 Floppy Controllers:%u\n"), ulValue);
-    systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
+    platformProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
     RTPrintf(List::tr("Maximum ICH9 Floppy Controllers: %u\n"), ulValue);
-    systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
+    platformProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
     RTPrintf(List::tr("Maximum Floppy Port count:       %u\n"), ulValue);
-    systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
+    platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
     RTPrintf(List::tr("Maximum Devices per Floppy Port: %u\n"), ulValue);
 #if 0
@@ -835 +838 @@
     systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
     RTPrintf(List::tr("Default machine folder:          %ls\n"), str.raw());
-    systemProperties->COMGETTER(RawModeSupported)(&fValue);
+    platformProperties->COMGETTER(RawModeSupported)(&fValue);
     RTPrintf(List::tr("Raw-mode Supported:              %s\n"), fValue ? List::tr("yes") : List::tr("no"));
-    systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
+    platformProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
     RTPrintf(List::tr("Exclusive HW virtualization use: %s\n"), fValue ? List::tr("on") : List::tr("off"));
     systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
@@ -1442 +1445 @@
     switch (enmArchitecture)
     {
-        case CPUArchitecture_x86:       pszArchitecture = "x86"; break;
-        case CPUArchitecture_AMD64:     pszArchitecture = "AMD64"; break;
-
+        case CPUArchitecture_x86:      pszArchitecture = "x86"; break;
+        case CPUArchitecture_AMD64:    pszArchitecture = "AMD64"; break;
+        case CPUArchitecture_ARMv8_32: pszArchitecture = "ARMv8 (32-bit only)"; break;
+        case CPUArchitecture_ARMv8_64: pszArchitecture = "ARMv8 (64-bit)"; break;
 #ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
         case CPUArchitecture_32BitHack:
@@ -2154 +2158 @@
         {
             ComPtr<IHost> Host;
-            CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
-
-            RTPrintf(List::tr("Host CPUIDs:\n\nLeaf no.  EAX      EBX      ECX      EDX\n"));
-            ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
-            static uint32_t const s_auCpuIdRanges[] =
+            CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
+            PlatformArchitecture_T platformArch;
+            CHECK_ERROR_BREAK(Host, COMGETTER(Architecture)(&platformArch));
+
+            switch (platformArch)
             {
-                UINT32_C(0x00000000), UINT32_C(0x0000007f),
-                UINT32_C(0x80000000), UINT32_C(0x8000007f),
-                UINT32_C(0xc0000000), UINT32_C(0xc000007f)
-            };
-            for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
-            {
-                ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
-                CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
-                if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
-                    continue;
-                cLeafs++;
-                for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
+                case PlatformArchitecture_x86:
                 {
-                    CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
-                    RTPrintf("%08x  %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
+                    ComPtr<IHostX86> HostX86;
+                    CHECK_ERROR_BREAK(Host, COMGETTER(X86)(HostX86.asOutParam()));
+
+                    RTPrintf(List::tr("Host CPUIDs:\n\nLeaf no.  EAX      EBX      ECX      EDX\n"));
+                    ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
+                    static uint32_t const s_auCpuIdRanges[] =
+                    {
+                        UINT32_C(0x00000000), UINT32_C(0x0000007f),
+                        UINT32_C(0x80000000), UINT32_C(0x8000007f),
+                        UINT32_C(0xc0000000), UINT32_C(0xc000007f)
+                    };
+                    for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
+                    {
+                        ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
+                        CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
+                        if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
+                            continue;
+                        cLeafs++;
+                        for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
+                        {
+                            CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
+                            RTPrintf("%08x  %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
+                        }
+                    }
+
+                    break;
                 }
+
+                case PlatformArchitecture_ARM:
+                {
+                    /** @todo BUGBUG Implement this for ARM! */
+                    break;
+                }
+
+                default:
+                    AssertFailed();
+                    break;
             }
             break;

trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

@@ -263 +263 @@
 static const RTGETOPTDEF g_aCreateVMOptions[] =
 {
-    { "--name",           'n', RTGETOPT_REQ_STRING },
-    { "-name",            'n', RTGETOPT_REQ_STRING },
-    { "--groups",         'g', RTGETOPT_REQ_STRING },
-    { "--basefolder",     'p', RTGETOPT_REQ_STRING },
-    { "-basefolder",      'p', RTGETOPT_REQ_STRING },
-    { "--ostype",         'o', RTGETOPT_REQ_STRING },
-    { "-ostype",          'o', RTGETOPT_REQ_STRING },
-    { "--uuid",           'u', RTGETOPT_REQ_UUID },
-    { "-uuid",            'u', RTGETOPT_REQ_UUID },
-    { "--register",       'r', RTGETOPT_REQ_NOTHING },
-    { "-register",        'r', RTGETOPT_REQ_NOTHING },
-    { "--default",        'd', RTGETOPT_REQ_NOTHING },
-    { "-default",         'd', RTGETOPT_REQ_NOTHING },
-    { "--cipher",         'c', RTGETOPT_REQ_STRING },
-    { "-cipher",          'c', RTGETOPT_REQ_STRING },
-    { "--password-id",    'i', RTGETOPT_REQ_STRING },
-    { "-password-id",     'i', RTGETOPT_REQ_STRING },
-    { "--password",       'w', RTGETOPT_REQ_STRING },
-    { "-password",        'w', RTGETOPT_REQ_STRING },
+    { "--name",                  'n', RTGETOPT_REQ_STRING },
+    { "-name",                   'n', RTGETOPT_REQ_STRING },
+    { "--groups",                'g', RTGETOPT_REQ_STRING },
+    { "--basefolder",            'p', RTGETOPT_REQ_STRING },
+    { "-basefolder",             'p', RTGETOPT_REQ_STRING },
+    { "--ostype",                'o', RTGETOPT_REQ_STRING },
+    { "-ostype",                 'o', RTGETOPT_REQ_STRING },
+    { "--uuid",                  'u', RTGETOPT_REQ_UUID },
+    { "-uuid",                   'u', RTGETOPT_REQ_UUID },
+    { "--register",              'r', RTGETOPT_REQ_NOTHING },
+    { "-register",               'r', RTGETOPT_REQ_NOTHING },
+    { "--default",               'd', RTGETOPT_REQ_NOTHING },
+    { "-default",                'd', RTGETOPT_REQ_NOTHING },
+    { "--cipher",                'c', RTGETOPT_REQ_STRING },
+    { "-cipher",                 'c', RTGETOPT_REQ_STRING },
+    { "--password-id",           'i', RTGETOPT_REQ_STRING },
+    { "-password-id",            'i', RTGETOPT_REQ_STRING },
+    { "--password",              'w', RTGETOPT_REQ_STRING },
+    { "-password",               'w', RTGETOPT_REQ_STRING },
+    { "--platform-architecture", 'a', RTGETOPT_REQ_STRING },
+    { "--platform-arch",         'a', RTGETOPT_REQ_STRING }, /* Shorter. */
 };
 
@@ -287 +289 @@
 {
     HRESULT hrc;
+    PlatformArchitecture_T platformArch = PlatformArchitecture_None;
     Bstr bstrBaseFolder;
     Bstr bstrName;
@@ -350 +353 @@
                 break;
 
+            case 'a':   // --platform-architecture
+                if (!RTStrICmp(ValueUnion.psz, "x86"))
+                    platformArch = PlatformArchitecture_x86;
+                else if (!RTStrICmp(ValueUnion.psz, "arm"))
+                    platformArch = PlatformArchitecture_ARM;
+                else
+                    return errorArgument(Misc::tr("Invalid --platform-architecture argument '%s'"), ValueUnion.psz);
+                break;
+
             default:
                 return errorGetOpt(c, &ValueUnion);
@@ -356 +368 @@
 
     /* check for required options */
+    if (platformArch == PlatformArchitecture_None)
+        return errorSyntax(Misc::tr("Parameter --platform-architecture is required"));
     if (bstrName.isEmpty())
         return errorSyntax(Misc::tr("Parameter --name is required"));
@@ -398 +412 @@
                           CreateMachine(bstrSettingsFile.raw(),
                                         bstrName.raw(),
+                                        platformArch,
                                         ComSafeArrayAsInParam(groups),
                                         bstrOsTypeId.raw(),
@@ -670 +685 @@
                     RTEXITCODE_FAILURE);
 
+    /* Get the platform architecture, to clone a VM which has the same architecture. */
+    ComPtr<IPlatform>      platform;
+    CHECK_ERROR_RET(srcMachine, COMGETTER(Platform)(platform.asOutParam()), RTEXITCODE_FAILURE);
+    PlatformArchitecture_T platformArch;
+    CHECK_ERROR_RET(platform, COMGETTER(Architecture)(&platformArch), RTEXITCODE_FAILURE);
+
     /* If a snapshot name/uuid was given, get the particular machine of this
      * snapshot. */
@@ -704 +725 @@
     CHECK_ERROR_RET(a->virtualBox, CreateMachine(bstrSettingsFile.raw(),
                                                  Bstr(pszTrgName).raw(),
+                                                 platformArch,
                                                  ComSafeArrayAsInParam(groups),
                                                  NULL,
@@ -1419 +1441 @@
 }
 
-RTEXITCODE handleSetProperty(HandlerArg *a)
+RTEXITCODE handleSetProperty(HandlerArg *a) /** @todo r=andy Rename this to handle[Get|Set]SystemProperty? */
 {
     HRESULT hrc;
@@ -1429 +1451 @@
     ComPtr<ISystemProperties> systemProperties;
     a->virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
+
+    ComPtr<IPlatformProperties> platformProperties;
+    systemProperties->COMGETTER(Platform)(platformProperties.asOutParam());
 
     if (!strcmp(a->argv[0], "machinefolder"))
@@ -1448 +1473 @@
         else
             return errorArgument(Misc::tr("Invalid hwvirtexclusive argument '%s'"), a->argv[1]);
-        CHECK_ERROR(systemProperties, COMSETTER(ExclusiveHwVirt)(fHwVirtExclusive));
+        CHECK_ERROR(platformProperties, COMSETTER(ExclusiveHwVirt)(fHwVirtExclusive));
     }
     else if (   !strcmp(a->argv[0], "vrdeauthlibrary")

trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

@@ -72 +72 @@
     MODIFYVM_ACPI,
     MODIFYVM_IOAPIC,
-    MODIFYVM_PAE,
-    MODIFYVM_LONGMODE,
     MODIFYVM_CPUID_PORTABILITY,
-    MODIFYVM_TFRESET,
-    MODIFYVM_APIC,
-    MODIFYVM_X2APIC,
     MODIFYVM_PARAVIRTPROVIDER,
     MODIFYVM_PARAVIRTDEBUG,
-    MODIFYVM_HWVIRTEX,
-    MODIFYVM_NESTEDPAGING,
-    MODIFYVM_LARGEPAGES,
-    MODIFYVM_VTXVPID,
-    MODIFYVM_VTXUX,
-    MODIFYVM_VIRT_VMSAVE_VMLOAD,
-    MODIFYVM_IBPB_ON_VM_EXIT,
-    MODIFYVM_IBPB_ON_VM_ENTRY,
-    MODIFYVM_SPEC_CTRL,
-    MODIFYVM_L1D_FLUSH_ON_SCHED,
-    MODIFYVM_L1D_FLUSH_ON_VM_ENTRY,
-    MODIFYVM_MDS_CLEAR_ON_SCHED,
-    MODIFYVM_MDS_CLEAR_ON_VM_ENTRY,
-    MODIFYVM_NESTED_HW_VIRT,
     MODIFYVM_CPUS,
     MODIFYVM_CPUHOTPLUG,
@@ -99 +80 @@
     MODIFYVM_PLUGCPU,
     MODIFYVM_UNPLUGCPU,
-    MODIFYVM_SETCPUID,
-    MODIFYVM_DELCPUID,
-    MODIFYVM_DELCPUID_OLD,      // legacy, different syntax from MODIFYVM_DELCPUID
-    MODIFYVM_DELALLCPUID,
     MODIFYVM_GRAPHICSCONTROLLER,
     MODIFYVM_MONITORCOUNT,
@@ -109 +86 @@
     MODIFYVM_ACCELERATE2DVIDEO,
 #endif
-    MODIFYVM_BIOSLOGOFADEIN,
-    MODIFYVM_BIOSLOGOFADEOUT,
-    MODIFYVM_BIOSLOGODISPLAYTIME,
-    MODIFYVM_BIOSLOGOIMAGEPATH,
-    MODIFYVM_BIOSBOOTMENU,
-    MODIFYVM_BIOSAPIC,
-    MODIFYVM_BIOSSYSTEMTIMEOFFSET,
-    MODIFYVM_BIOSPXEDEBUG,
+    /*
+     * Firmware-specific stuff.
+     */
+    MODIFYVM_FWLOGOFADEIN,
+    MODIFYVM_FWLOGOFADEOUT,
+    MODIFYVM_FWLOGODISPLAYTIME,
+    MODIFYVM_FWLOGOIMAGEPATH,
+    MODIFYVM_FWBOOTMENU,
+    MODIFYVM_FWAPIC,
+    MODIFYVM_FWSYSTEMTIMEOFFSET,
+    MODIFYVM_FWPXEDEBUG,
     MODIFYVM_SYSTEMUUIDLE,
     MODIFYVM_BOOT,
@@ -224 +204 @@
     MODIFYVM_TRACING_ALLOW_VM_ACCESS,
     MODIFYVM_HARDWARE_UUID,
-    MODIFYVM_HPET,
     MODIFYVM_IOCACHE,
     MODIFYVM_IOCACHESIZE,
@@ -269 +248 @@
     MODIFYVM_GUEST_DEBUG_ADDRESS,
     MODIFYVM_GUEST_DEBUG_PORT,
+    /*
+     * x86-specific stuff.
+     */
+    MODIFYVM_X86_APIC,
+    MODIFYVM_X86_DELCPUID,
+    MODIFYVM_X86_DELCPUID_OLD,      // legacy, different syntax from MODIFYVM_DELCPUID
+    MODIFYVM_X86_DELALLCPUID,
+    MODIFYVM_X86_HPET,
+    MODIFYVM_X86_HWVIRTEX,
+    MODIFYVM_X86_IBPB_ON_VM_ENTRY,
+    MODIFYVM_X86_IBPB_ON_VM_EXIT,
+    MODIFYVM_X86_L1D_FLUSH_ON_SCHED,
+    MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY,
+    MODIFYVM_X86_LARGEPAGES,
+    MODIFYVM_X86_LONGMODE,
+    MODIFYVM_X86_MDS_CLEAR_ON_SCHED,
+    MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY,
+    MODIFYVM_X86_NESTED_HW_VIRT,
+    MODIFYVM_X86_NESTEDPAGING,
+    MODIFYVM_X86_PAE,
+    MODIFYVM_X86_SETCPUID,
+    MODIFYVM_X86_SPEC_CTRL,
+    MODIFYVM_X86_TFRESET,
+    MODIFYVM_X86_VIRT_VMSAVE_VMLOAD,
+    MODIFYVM_X86_VTXUX,
+    MODIFYVM_X86_VTXVPID,
+    MODIFYVM_X86_X2APIC
 };
 
@@ -284 +290 @@
     OPT1("--acpi",                                                      MODIFYVM_ACPI,                      RTGETOPT_REQ_BOOL_ONOFF),
     OPT1("--ioapic",                                                    MODIFYVM_IOAPIC,                    RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--pae",                                                       MODIFYVM_PAE,                       RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--long-mode",                     "--longmode",               MODIFYVM_LONGMODE,                  RTGETOPT_REQ_BOOL_ONOFF),
     OPT1("--cpuid-portability-level",                                   MODIFYVM_CPUID_PORTABILITY,         RTGETOPT_REQ_UINT32),
-    OPT2("--triple-fault-reset",            "--triplefaultreset",       MODIFYVM_TFRESET,                   RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--apic",                                                      MODIFYVM_APIC,                      RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--x2apic",                                                    MODIFYVM_X2APIC,                    RTGETOPT_REQ_BOOL_ONOFF),
     OPT2("--paravirt-provider",             "--paravirtprovider",       MODIFYVM_PARAVIRTPROVIDER,          RTGETOPT_REQ_STRING),
     OPT2("--paravirt-debug",                "--paravirtdebug",          MODIFYVM_PARAVIRTDEBUG,             RTGETOPT_REQ_STRING),
-    OPT1("--hwvirtex",                                                  MODIFYVM_HWVIRTEX,                  RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--nested-paging",                 "--nestedpaging",           MODIFYVM_NESTEDPAGING,              RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--large-pages",                   "--largepages",             MODIFYVM_LARGEPAGES,                RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--vtx-vpid",                      "--vtxvpid",                MODIFYVM_VTXVPID,                   RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--vtx-ux",                        "--vtxux",                  MODIFYVM_VTXUX,                     RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--virt-vmsave-vmload",                                        MODIFYVM_VIRT_VMSAVE_VMLOAD,        RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--ibpb-on-vm-exit",                                           MODIFYVM_IBPB_ON_VM_EXIT,           RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--ibpb-on-vm-entry",                                          MODIFYVM_IBPB_ON_VM_ENTRY,          RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--spec-ctrl",                                                 MODIFYVM_SPEC_CTRL,                 RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--l1d-flush-on-sched",                                        MODIFYVM_L1D_FLUSH_ON_SCHED,        RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--l1d-flush-on-vm-entry",                                     MODIFYVM_L1D_FLUSH_ON_VM_ENTRY,     RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--mds-clear-on-sched",                                        MODIFYVM_MDS_CLEAR_ON_SCHED,        RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--mds-clear-on-vm-entry",                                     MODIFYVM_MDS_CLEAR_ON_VM_ENTRY,     RTGETOPT_REQ_BOOL_ONOFF),
-    OPT1("--nested-hw-virt",                                            MODIFYVM_NESTED_HW_VIRT,            RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--cpuid-set",                     "--cpuidset",               MODIFYVM_SETCPUID,                  RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
-    OPT1("--cpuid-remove",                                              MODIFYVM_DELCPUID,                  RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
-    OPT1("--cpuidremove",                                               MODIFYVM_DELCPUID_OLD,              RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX), /* legacy - syntax differs */
-    OPT2("--cpuid-remove-all",              "--cpuidremoveall",         MODIFYVM_DELALLCPUID,               RTGETOPT_REQ_NOTHING),
     OPT1("--cpus",                                                      MODIFYVM_CPUS,                      RTGETOPT_REQ_UINT32),
     OPT2("--cpu-hotplug",                   "--cpuhotplug",             MODIFYVM_CPUHOTPLUG,                RTGETOPT_REQ_BOOL_ONOFF),
@@ -323 +306 @@
     OPT2("--accelerate-2d-video",           "--accelerate2dvideo",      MODIFYVM_ACCELERATE2DVIDEO,         RTGETOPT_REQ_BOOL_ONOFF),
 #endif
-    OPT2("--bios-logo-fade-in",             "--bioslogofadein",         MODIFYVM_BIOSLOGOFADEIN,            RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--bios-logo-fade-out",            "--bioslogofadeout",        MODIFYVM_BIOSLOGOFADEOUT,           RTGETOPT_REQ_BOOL_ONOFF),
-    OPT2("--bios-logo-display-time",        "--bioslogodisplaytime",    MODIFYVM_BIOSLOGODISPLAYTIME,       RTGETOPT_REQ_UINT32),
-    OPT2("--bios-logo-image-path",          "--bioslogoimagepath",      MODIFYVM_BIOSLOGOIMAGEPATH,         RTGETOPT_REQ_STRING),
-    OPT2("--bios-boot-menu",                "--biosbootmenu",           MODIFYVM_BIOSBOOTMENU,              RTGETOPT_REQ_STRING),
-    OPT2("--bios-system-time-offset",       "--biossystemtimeoffset",   MODIFYVM_BIOSSYSTEMTIMEOFFSET,      RTGETOPT_REQ_INT64),
-    OPT2("--bios-apic",                     "--biosapic",               MODIFYVM_BIOSAPIC,                  RTGETOPT_REQ_STRING),
-    OPT2("--bios-pxe-debug",                "--biospxedebug",           MODIFYVM_BIOSPXEDEBUG,              RTGETOPT_REQ_BOOL_ONOFF),
+    /** Kept for backwards-compatibility. */
+    OPT1("--firmware-logo-fade-in",                                     MODIFYVM_FWLOGOFADEIN,              RTGETOPT_REQ_BOOL_ONOFF),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-logo-fade-in",             "--bioslogofadein",         MODIFYVM_FWLOGOFADEIN,              RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--firmware-fade-out",                                         MODIFYVM_FWLOGOFADEOUT,             RTGETOPT_REQ_BOOL_ONOFF),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-logo-fade-out",            "--bioslogofadeout",        MODIFYVM_FWLOGOFADEOUT,             RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--firmware-logo-display-time",                                MODIFYVM_FWLOGODISPLAYTIME,         RTGETOPT_REQ_UINT32),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-logo-display-time",        "--bioslogodisplaytime",    MODIFYVM_FWLOGODISPLAYTIME,         RTGETOPT_REQ_UINT32),
+    OPT1("--firmware-logo-image-path",                                  MODIFYVM_FWLOGOIMAGEPATH,           RTGETOPT_REQ_STRING),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-logo-image-path",          "--bioslogoimagepath",      MODIFYVM_FWLOGOIMAGEPATH,           RTGETOPT_REQ_STRING),
+    OPT1("--firmware-boot-menu",                                        MODIFYVM_FWBOOTMENU,                RTGETOPT_REQ_STRING),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-boot-menu",                "--biosbootmenu",           MODIFYVM_FWBOOTMENU,                RTGETOPT_REQ_STRING),
+    OPT1("--firmware-system-time-offset",                               MODIFYVM_FWSYSTEMTIMEOFFSET,        RTGETOPT_REQ_INT64),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-system-time-offset",       "--biossystemtimeoffset",   MODIFYVM_FWSYSTEMTIMEOFFSET,        RTGETOPT_REQ_INT64),
+    OPT1("--firmware-apic",                                             MODIFYVM_FWAPIC,                    RTGETOPT_REQ_STRING),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-apic",                     "--biosapic",               MODIFYVM_FWAPIC,                    RTGETOPT_REQ_STRING),
+    OPT1("--firmware-pxe-debug",                                        MODIFYVM_FWPXEDEBUG,                RTGETOPT_REQ_BOOL_ONOFF),
+    /** Kept for backwards-compatibility. */
+    OPT2("--bios-pxe-debug",                "--biospxedebug",           MODIFYVM_FWPXEDEBUG,                RTGETOPT_REQ_BOOL_ONOFF),
     OPT2("--system-uuid-le",                "--system-uuid-le",         MODIFYVM_SYSTEMUUIDLE,              RTGETOPT_REQ_BOOL_ONOFF),
     OPT1("--boot",                                                      MODIFYVM_BOOT,                      RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
@@ -440 +440 @@
     OPT1("--tracing-allow-vm-access",                                   MODIFYVM_TRACING_ALLOW_VM_ACCESS,   RTGETOPT_REQ_BOOL_ONOFF),
     OPT2("--hardware-uuid",                 "--hardwareuuid",                            MODIFYVM_HARDWARE_UUID,             RTGETOPT_REQ_STRING),
-    OPT1("--hpet",                                                      MODIFYVM_HPET,                      RTGETOPT_REQ_BOOL_ONOFF),
     OPT1("--iocache",                                                   MODIFYVM_IOCACHE,                   RTGETOPT_REQ_BOOL_ONOFF),
     OPT2("--iocache-size",                  "--iocachesize",            MODIFYVM_IOCACHESIZE,               RTGETOPT_REQ_UINT32),
@@ -483 +482 @@
     OPT1("--guest-debug-address",                                       MODIFYVM_GUEST_DEBUG_ADDRESS,       RTGETOPT_REQ_STRING),
     OPT1("--guest-debug-port",                                          MODIFYVM_GUEST_DEBUG_PORT,          RTGETOPT_REQ_UINT32),
+
+    /*
+     * x86-only stuff.
+     *
+     * Note: The non-prefixed options (e.g. "hpet" vs. "x86-hpet") are being kept
+     *       to maintain backwards compatibility, at least for a while. Remove them before going on pension.
+     *
+     * Sorted after their MODIFYVM_X86_XXX values.
+     */
+    OPT1("--x86-apic",                                                  MODIFYVM_X86_APIC,                  RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--apic",                                                      MODIFYVM_X86_APIC,                  RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-cpuid-remove",                                          MODIFYVM_X86_DELCPUID,              RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
+    OPT1("--cpuid-remove",                                              MODIFYVM_X86_DELCPUID,              RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
+    OPT1("--cpuidremove",                                               MODIFYVM_X86_DELCPUID_OLD,          RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX), /* legacy - syntax differs */
+    OPT1("--x86-cpuid-remove-all",                                      MODIFYVM_X86_DELALLCPUID,           RTGETOPT_REQ_NOTHING),
+    OPT2("--cpuid-remove-all",              "--cpuidremoveall",         MODIFYVM_X86_DELALLCPUID,           RTGETOPT_REQ_NOTHING),
+    OPT1("--x86-hpet",                                                  MODIFYVM_X86_HPET,                  RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--hpet",                                                      MODIFYVM_X86_HPET,                  RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-hwvirtex",                                              MODIFYVM_X86_HWVIRTEX,              RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--hwvirtex",                                                  MODIFYVM_X86_HWVIRTEX,              RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-ibpb-on-vm-entry",                                      MODIFYVM_X86_IBPB_ON_VM_ENTRY,      RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--ibpb-on-vm-entry",                                          MODIFYVM_X86_IBPB_ON_VM_ENTRY,      RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-ibpb-on-vm-exit",                                       MODIFYVM_X86_IBPB_ON_VM_EXIT,       RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--ibpb-on-vm-exit",                                           MODIFYVM_X86_IBPB_ON_VM_EXIT,       RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-l1d-flush-on-sched",                                    MODIFYVM_X86_L1D_FLUSH_ON_SCHED,    RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--l1d-flush-on-sched",                                        MODIFYVM_X86_L1D_FLUSH_ON_SCHED,    RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-l1d-flush-on-vm-entry",                                 MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--l1d-flush-on-vm-entry",                                     MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-large-pages",                                           MODIFYVM_X86_LARGEPAGES,            RTGETOPT_REQ_BOOL_ONOFF),
+    OPT2("--large-pages",                   "--largepages",             MODIFYVM_X86_LARGEPAGES,            RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-long-mode",                                             MODIFYVM_X86_LONGMODE,              RTGETOPT_REQ_BOOL_ONOFF),
+    OPT2("--long-mode",                     "--longmode",               MODIFYVM_X86_LONGMODE,              RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-mds-clear-on-sched",                                    MODIFYVM_X86_MDS_CLEAR_ON_SCHED,    RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--mds-clear-on-sched",                                        MODIFYVM_X86_MDS_CLEAR_ON_SCHED,    RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-mds-clear-on-vm-entry",                                 MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--mds-clear-on-vm-entry",                                     MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-nested-hw-virt",                                        MODIFYVM_X86_NESTED_HW_VIRT,        RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--nested-hw-virt",                                            MODIFYVM_X86_NESTED_HW_VIRT,        RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-nested-paging",                                         MODIFYVM_X86_NESTEDPAGING,          RTGETOPT_REQ_BOOL_ONOFF),
+    OPT2("--nested-paging",                 "--nestedpaging",           MODIFYVM_X86_NESTEDPAGING,          RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-pae",                                                   MODIFYVM_X86_PAE,                   RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--pae",                                                       MODIFYVM_X86_PAE,                   RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-cpuid-set",                                             MODIFYVM_X86_SETCPUID,              RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
+    OPT2("--cpuid-set",                     "--cpuidset",               MODIFYVM_X86_SETCPUID,              RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
+    OPT1("--x86-spec-ctrl",                                             MODIFYVM_X86_SPEC_CTRL,             RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--spec-ctrl",                                                 MODIFYVM_X86_SPEC_CTRL,             RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-triple-fault-reset",                                    MODIFYVM_X86_TFRESET,               RTGETOPT_REQ_BOOL_ONOFF),
+    OPT2("--triple-fault-reset",            "--triplefaultreset",       MODIFYVM_X86_TFRESET,               RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--virt-vmsave-vmload",                                        MODIFYVM_X86_VIRT_VMSAVE_VMLOAD,    RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-virt-vmsave-vmload",                                    MODIFYVM_X86_VIRT_VMSAVE_VMLOAD,    RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-vtx-ux",                                                MODIFYVM_X86_VTXUX,                 RTGETOPT_REQ_BOOL_ONOFF),
+    OPT2("--vtx-ux",                        "--vtxux",                  MODIFYVM_X86_VTXUX,                 RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-vtx-vpid",                                              MODIFYVM_X86_VTXVPID,               RTGETOPT_REQ_BOOL_ONOFF),
+    OPT2("--vtx-vpid",                      "--vtxvpid",                MODIFYVM_X86_VTXVPID,               RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x86-x2apic",                                                MODIFYVM_X86_X2APIC,                RTGETOPT_REQ_BOOL_ONOFF),
+    OPT1("--x2apic",                                                    MODIFYVM_X86_X2APIC,                RTGETOPT_REQ_BOOL_ONOFF),
 };
 
@@ -617 +672 @@
 }
 
+/**
+ * Handles the x86-specific modifyvm options.
+ *
+ * @returns HRESULT
+ * @retval  E_INVALIDARG if handed-in option was not being handled.
+ * @param   pGetOptState        Pointer to GetOpt state to use.
+ * @param   c                   Current GetOpt value (short form).
+ * @param   pValueUnion         Pointer to current value union.
+ * @param   sessionMachine      Session machine to use.
+ * @param   platformX86         x86-specific platform object to use.
+ */
+HRESULT handleModifyVM_x86(PRTGETOPTSTATE pGetOptState, int c, PRTGETOPTUNION pValueUnion,
+                           ComPtr<IMachine> &sessionMachine, ComPtr<IPlatformX86> &platformX86)
+{
+    RT_NOREF(sessionMachine);
+
+    HRESULT hrc = S_OK;
+
+    switch (c)
+    {
+        case MODIFYVM_X86_APIC:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_APIC, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_DELCPUID:
+            CHECK_ERROR(platformX86, RemoveCPUIDLeaf(pValueUnion->PairU32.uFirst, pValueUnion->PairU32.uSecond));
+            break;
+
+        case MODIFYVM_X86_DELCPUID_OLD:
+            CHECK_ERROR(platformX86, RemoveCPUIDLeaf(pValueUnion->u32, UINT32_MAX));
+            break;
+
+        case MODIFYVM_X86_DELALLCPUID:
+            CHECK_ERROR(platformX86, RemoveAllCPUIDLeaves());
+            break;
+
+        case MODIFYVM_X86_HPET:
+            CHECK_ERROR(platformX86, COMSETTER(HPETEnabled)(pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_TFRESET:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_TripleFaultReset, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_PAE:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_PAE, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_LONGMODE:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_LongMode, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_X2APIC:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_X2APIC, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_NESTEDPAGING:
+            CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_LARGEPAGES:
+            CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_VTXVPID:
+            CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_VPID, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_VTXUX:
+            CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_VIRT_VMSAVE_VMLOAD:
+            CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_IBPB_ON_VM_EXIT:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_IBPBOnVMExit, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_IBPB_ON_VM_ENTRY:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_IBPBOnVMEntry, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_SPEC_CTRL:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_SpecCtrl, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_L1D_FLUSH_ON_SCHED:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_L1DFlushOnEMTScheduling, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_L1DFlushOnVMEntry, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_MDS_CLEAR_ON_SCHED:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_MDSClearOnEMTScheduling, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_MDSClearOnVMEntry, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_NESTED_HW_VIRT:
+            CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_HWVirt, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_HWVIRTEX:
+            CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, pValueUnion->f));
+            break;
+
+        case MODIFYVM_X86_SETCPUID:
+        {
+            uint32_t const idx    = c == MODIFYVM_X86_SETCPUID ?  pValueUnion->PairU32.uFirst  : pValueUnion->u32;
+            uint32_t const idxSub = c == MODIFYVM_X86_SETCPUID ?  pValueUnion->PairU32.uSecond : UINT32_MAX;
+            uint32_t aValue[4];
+            for (unsigned i = 0; i < 4; i++)
+            {
+                int vrc = RTGetOptFetchValue(pGetOptState, pValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
+                if (RT_FAILURE(vrc))
+                    return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
+                                       pGetOptState->pDef->pszLong);
+                aValue[i] = pValueUnion->u32;
+            }
+            CHECK_ERROR(platformX86, SetCPUIDLeaf(idx, idxSub, aValue[0], aValue[1], aValue[2], aValue[3]));
+            break;
+        }
+
+        default:
+            hrc = E_INVALIDARG;
+            break;
+    }
+
+    return hrc;
+}
+
 RTEXITCODE handleModifyVM(HandlerArg *a)
 {
@@ -635 +827 @@
 
     /* Get the number of network adapters */
-    ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, machine);
+    ULONG NetworkAdapterCount = getMaxNics(machine);
 
     /* open a session for the VM */
@@ -644 +836 @@
     CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE);
 
-    ComPtr<IBIOSSettings> biosSettings;
-    sessionMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
+    ComPtr<IFirmwareSettings> firmwareSettings;
+    CHECK_ERROR_RET(sessionMachine, COMGETTER(FirmwareSettings)(firmwareSettings.asOutParam()), RTEXITCODE_FAILURE);
+
+    ComPtr<IPlatform> platform;
+    CHECK_ERROR_RET(sessionMachine, COMGETTER(Platform)(platform.asOutParam()), RTEXITCODE_FAILURE);
+
+    /* For the x86-based options we need the x86-specific platform object. */
+    ComPtr<IPlatformX86> platformX86;
+    platform->COMGETTER(X86)(platformX86.asOutParam());
 
     ComPtr<IGraphicsAdapter> pGraphicsAdapter;
@@ -742 +941 @@
                 if (!RTStrICmp(ValueUnion.psz, "efi"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFI));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "efi32"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFI32));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "efi64"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFI64));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "efidual"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "bios"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_BIOS));
                 }
                 else
@@ -770 +969 @@
             case MODIFYVM_ACPI:
             {
-                CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
+                CHECK_ERROR(firmwareSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
                 break;
             }
@@ -776 +975 @@
             case MODIFYVM_IOAPIC:
             {
-                CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_PAE:
-            {
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_LONGMODE:
-            {
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_LongMode, ValueUnion.f));
+                CHECK_ERROR(firmwareSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
                 break;
             }
@@ -795 +982 @@
             {
                 CHECK_ERROR(sessionMachine, COMSETTER(CPUIDPortabilityLevel)(ValueUnion.u32));
-                break;
-            }
-
-            case MODIFYVM_TFRESET:
-            {
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_TripleFaultReset, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_APIC:
-            {
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_APIC, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_X2APIC:
-            {
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_X2APIC, ValueUnion.f));
                 break;
             }
@@ -845 +1014 @@
             }
 
-            case MODIFYVM_HWVIRTEX:
-            {
-                CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_SETCPUID:
-            {
-                uint32_t const idx    = c == MODIFYVM_SETCPUID ?  ValueUnion.PairU32.uFirst  : ValueUnion.u32;
-                uint32_t const idxSub = c == MODIFYVM_SETCPUID ?  ValueUnion.PairU32.uSecond : UINT32_MAX;
-                uint32_t aValue[4];
-                for (unsigned i = 0; i < 4; i++)
-                {
-                    int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
-                    if (RT_FAILURE(vrc))
-                        return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
-                                           GetOptState.pDef->pszLong);
-                    aValue[i] = ValueUnion.u32;
-                }
-                CHECK_ERROR(sessionMachine, SetCPUIDLeaf(idx, idxSub, aValue[0], aValue[1], aValue[2], aValue[3]));
-                break;
-            }
-
-            case MODIFYVM_DELCPUID:
-                CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.PairU32.uFirst, ValueUnion.PairU32.uSecond));
-                break;
-
-            case MODIFYVM_DELCPUID_OLD:
-                CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.u32, UINT32_MAX));
-                break;
-
-            case MODIFYVM_DELALLCPUID:
-            {
-                CHECK_ERROR(sessionMachine, RemoveAllCPUIDLeaves());
-                break;
-            }
-
-            case MODIFYVM_NESTEDPAGING:
-            {
-                CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_LARGEPAGES:
-            {
-                CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_VTXVPID:
-            {
-                CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_VTXUX:
-            {
-                CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_VIRT_VMSAVE_VMLOAD:
-                CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, ValueUnion.f));
-                break;
-
-            case MODIFYVM_IBPB_ON_VM_EXIT:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_IBPBOnVMExit, ValueUnion.f));
-                break;
-
-            case MODIFYVM_IBPB_ON_VM_ENTRY:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_IBPBOnVMEntry, ValueUnion.f));
-                break;
-
-            case MODIFYVM_SPEC_CTRL:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_SpecCtrl, ValueUnion.f));
-                break;
-
-            case MODIFYVM_L1D_FLUSH_ON_SCHED:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_L1DFlushOnEMTScheduling, ValueUnion.f));
-                break;
-
-            case MODIFYVM_L1D_FLUSH_ON_VM_ENTRY:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_L1DFlushOnVMEntry, ValueUnion.f));
-                break;
-
-            case MODIFYVM_MDS_CLEAR_ON_SCHED:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_MDSClearOnEMTScheduling, ValueUnion.f));
-                break;
-
-            case MODIFYVM_MDS_CLEAR_ON_VM_ENTRY:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_MDSClearOnVMEntry, ValueUnion.f));
-                break;
-
-            case MODIFYVM_NESTED_HW_VIRT:
-                CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_HWVirt, ValueUnion.f));
-                break;
-
             case MODIFYVM_CPUS:
             {
@@ -950 +1022 @@
             case MODIFYVM_RTCUSEUTC:
             {
-                CHECK_ERROR(sessionMachine, COMSETTER(RTCUseUTC)(ValueUnion.f));
+                CHECK_ERROR(platform, COMSETTER(RTCUseUTC)(ValueUnion.f));
                 break;
             }
@@ -1029 +1101 @@
             }
 #endif
-
-            case MODIFYVM_BIOSLOGOFADEIN:
-            {
-                CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_BIOSLOGOFADEOUT:
-            {
-                CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
-                break;
-            }
-
-            case MODIFYVM_BIOSLOGODISPLAYTIME:
-            {
-                CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
-                break;
-            }
-
-            case MODIFYVM_BIOSLOGOIMAGEPATH:
-            {
-                CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
-                break;
-            }
-
-            case MODIFYVM_BIOSBOOTMENU:
+            case MODIFYVM_FWLOGOFADEIN:
+            {
+                CHECK_ERROR(firmwareSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
+                break;
+            }
+
+            case MODIFYVM_FWLOGOFADEOUT:
+            {
+                CHECK_ERROR(firmwareSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
+                break;
+            }
+
+            case MODIFYVM_FWLOGODISPLAYTIME:
+            {
+                CHECK_ERROR(firmwareSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
+                break;
+            }
+
+            case MODIFYVM_FWLOGOIMAGEPATH:
+            {
+                CHECK_ERROR(firmwareSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
+                break;
+            }
+
+            case MODIFYVM_FWBOOTMENU:
             {
                 if (!RTStrICmp(ValueUnion.psz, "disabled"))
                 {
-                    CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_Disabled));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "menuonly"))
                 {
-                    CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_MenuOnly));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "messageandmenu"))
                 {
-                    CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_MessageAndMenu));
                 }
                 else
@@ -1076 +1147 @@
             }
 
-            case MODIFYVM_BIOSAPIC:
+            case MODIFYVM_FWAPIC:
             {
                 if (!RTStrICmp(ValueUnion.psz, "disabled"))
                 {
-                    CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_Disabled));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_Disabled));
                 }
                 else if (   !RTStrICmp(ValueUnion.psz, "apic")
@@ -1086 +1157 @@
                          || !RTStrICmp(ValueUnion.psz, "xapic"))
                 {
-                    CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_APIC));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_APIC));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "x2apic"))
                 {
-                    CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_X2APIC));
+                    CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_X2APIC));
                 }
                 else
@@ -1100 +1171 @@
             }
 
-            case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
-            {
-                CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
-                break;
-            }
-
-            case MODIFYVM_BIOSPXEDEBUG:
-            {
-                CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
+            case MODIFYVM_FWSYSTEMTIMEOFFSET:
+            {
+                CHECK_ERROR(firmwareSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
+                break;
+            }
+
+            case MODIFYVM_FWPXEDEBUG:
+            {
+                CHECK_ERROR(firmwareSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
                 break;
             }
@@ -1114 +1185 @@
             case MODIFYVM_SYSTEMUUIDLE:
             {
-                CHECK_ERROR(biosSettings, COMSETTER(SMBIOSUuidLittleEndian)(ValueUnion.f));
+                CHECK_ERROR(firmwareSettings, COMSETTER(SMBIOSUuidLittleEndian)(ValueUnion.f));
                 break;
             }
@@ -2493 +2564 @@
                     if (vrc != VINF_SUCCESS || uVal == 0)
                         return errorArgument(ModifyVM::tr("Error parsing UART I/O base '%s'"), pszIOBase);
-                    CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
+                    CHECK_ERROR(uart, COMSETTER(IOAddress)(uVal));
 
                     CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
@@ -3165 +3236 @@
             }
 
-            case MODIFYVM_HPET:
-            {
-                CHECK_ERROR(sessionMachine, COMSETTER(HPETEnabled)(ValueUnion.f));
-                break;
-            }
-
             case MODIFYVM_IOCACHE:
             {
@@ -3187 +3252 @@
                 if (!RTStrICmp(ValueUnion.psz, "piix3"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
+                    CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
                 }
                 else if (!RTStrICmp(ValueUnion.psz, "ich9"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_ICH9));
+                    CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_ICH9));
                     BOOL fIoApic = FALSE;
-                    CHECK_ERROR(biosSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
+                    CHECK_ERROR(firmwareSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
                     if (!fIoApic)
                     {
                         RTStrmPrintf(g_pStdErr, ModifyVM::tr("*** I/O APIC must be enabled for ICH9, enabling. ***\n"));
-                        CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(TRUE));
+                        CHECK_ERROR(firmwareSettings, COMSETTER(IOAPICEnabled)(TRUE));
                     }
                 }
@@ -3212 +3277 @@
                 if (   !RTStrICmp(ValueUnion.psz, "none")
                     || !RTStrICmp(ValueUnion.psz, "disabled"))
-                    CHECK_ERROR(sessionMachine, COMSETTER(IommuType)(IommuType_None));
+                    CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_None));
                 else if (!RTStrICmp(ValueUnion.psz, "amd"))
-                    CHECK_ERROR(sessionMachine, COMSETTER(IommuType)(IommuType_AMD));
+                    CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_AMD));
                 else if (!RTStrICmp(ValueUnion.psz, "intel"))
                 {
 #ifdef VBOX_WITH_IOMMU_INTEL
-                    CHECK_ERROR(sessionMachine, COMSETTER(IommuType)(IommuType_Intel));
+                    CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_Intel));
 #else
                     errorArgument(ModifyVM::tr("Invalid --iommu argument '%s' (valid: none,amd,automatic)"), ValueUnion.psz);
@@ -3226 +3291 @@
                 else if (!RTStrICmp(ValueUnion.psz, "automatic"))
                 {
-                    CHECK_ERROR(sessionMachine, COMSETTER(IommuType)(IommuType_Automatic));
+                    CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_Automatic));
 #ifndef VBOX_WITH_IOMMU_INTEL
                     RTStrmPrintf(g_pStdErr,
@@ -3630 +3695 @@
 
             default:
-                errorGetOpt(c, &ValueUnion);
+            {
+                hrc = handleModifyVM_x86(&GetOptState, c, &ValueUnion, machine, platformX86);
+                if (FAILED(hrc))
+                    errorGetOpt(c, &ValueUnion);
                 hrc = E_FAIL;
                 break;
+            }
         }
     }

trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp

@@ -123 +123 @@
     ComPtr<IMachine> machine;
     ComPtr<IStorageController> storageCtl;
-    ComPtr<ISystemProperties> systemProperties;
 
     RTGetOptInit(&GetState, a->argc, a->argv, g_aStorageAttachOptions,
@@ -337 +336 @@
         return errorSyntax(Storage::tr("Storage controller name not specified"));
 
-    /* get the virtualbox system properties */
-    CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), RTEXITCODE_FAILURE);
-
     // find the machine, lock it, get the mutable session machine
     CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
@@ -348 +344 @@
     a->session->COMGETTER(Machine)(machine.asOutParam());
 
+    ComPtr<IPlatform> platform;
+    CHECK_ERROR_RET(machine, COMGETTER(Platform)(platform.asOutParam()), RTEXITCODE_FAILURE);
+    ComPtr<IPlatformProperties> platformProperties;
+    CHECK_ERROR_RET(platform, COMGETTER(Properties)(platformProperties.asOutParam()), RTEXITCODE_FAILURE);
+
     try
     {
@@ -369 +370 @@
         CHECK_ERROR_RET(storageCtl, COMGETTER(Bus)(&storageBus), RTEXITCODE_FAILURE);
         ULONG maxPorts = 0;
-        CHECK_ERROR_RET(systemProperties, GetMaxPortCountForStorageBus(storageBus, &maxPorts), RTEXITCODE_FAILURE);
+        CHECK_ERROR_RET(platformProperties, GetMaxPortCountForStorageBus(storageBus, &maxPorts), RTEXITCODE_FAILURE);
         ULONG maxDevices = 0;
-        CHECK_ERROR_RET(systemProperties, GetMaxDevicesPerPortForStorageBus(storageBus, &maxDevices), RTEXITCODE_FAILURE);
+        CHECK_ERROR_RET(platformProperties, GetMaxDevicesPerPortForStorageBus(storageBus, &maxDevices), RTEXITCODE_FAILURE);
 
         if (port == ~0U)
@@ -460 +461 @@
 
                 /* check if the device type is supported by the controller */
-                CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
+                CHECK_ERROR(platformProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
                 for (size_t i = 0; i < saDeviceTypes.size(); ++ i)
                 {
@@ -556 +557 @@
                 com::SafeArray <DeviceType_T> saDeviceTypes;
 
-                CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
+                CHECK_ERROR(platformProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes)));
                 if (SUCCEEDED(hrc))
                 {

trunk/src/VBox/Frontends/VBoxManage/VBoxManageUtils.cpp

@@ -40 +40 @@
 DECLARE_TRANSLATION_CONTEXT(Utils);
 
-unsigned int getMaxNics(const ComPtr<IVirtualBox> &pVirtualBox,
-                        const ComPtr<IMachine> &pMachine)
+ULONG getMaxNics(const ComPtr<IMachine> &pMachine)
 {
-    ULONG NetworkAdapterCount = 0;
+    HRESULT hrc;
+
+    ULONG maxNetworkAdapters = 0;
     do {
-        HRESULT hrc;
+        ComPtr<IPlatform> pPlatform;
+        CHECK_ERROR_BREAK(pMachine, COMGETTER(Platform)(pPlatform.asOutParam()));
 
-        ComPtr<ISystemProperties> info;
-        CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(SystemProperties)(info.asOutParam()));
+        ChipsetType_T chipsetType;
+        CHECK_ERROR_BREAK(pPlatform, COMGETTER(ChipsetType)(&chipsetType));
 
-        ChipsetType_T aChipset;
-        CHECK_ERROR_BREAK(pMachine, COMGETTER(ChipsetType)(&aChipset));
+        ComPtr<IPlatformProperties> pPlatformProperties;
+        CHECK_ERROR_BREAK(pPlatform, COMGETTER(Properties)(pPlatformProperties.asOutParam()));
 
-        CHECK_ERROR_BREAK(info, GetMaxNetworkAdapters(aChipset, &NetworkAdapterCount));
+        CHECK_ERROR_BREAK(pPlatformProperties, GetMaxNetworkAdapters(chipsetType, &maxNetworkAdapters));
     } while (0);
 
-    return (unsigned int)NetworkAdapterCount;
+    return maxNetworkAdapters;
 }
 

trunk/src/VBox/Frontends/VBoxManage/VBoxManageUtils.h

@@ -36 +36 @@
 #include <VBox/com/VirtualBox.h>
 
-unsigned int getMaxNics(const ComPtr<IVirtualBox> &pVirtualBox,
-                        const ComPtr<IMachine> &pMachine);
+ULONG getMaxNics(const ComPtr<IMachine> &pMachine);
 
 void verifyHostNetworkInterfaceName(const ComPtr<IVirtualBox> &pVirtualBox,

trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp

@@ -38 +38 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -200 +200 @@
         case KStorageBus_IDE:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
-            int iMaxDevice = uiCommon().virtualBox().GetSystemProperties().GetMaxDevicesPerPortForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxDevice = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxDevicesPerPortForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -224 +224 @@
         case KStorageBus_SATA:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -240 +240 @@
         case KStorageBus_SCSI:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -256 +256 @@
         case KStorageBus_SAS:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -272 +272 @@
         case KStorageBus_Floppy:
         {
-            int iMaxDevice = uiCommon().virtualBox().GetSystemProperties().GetMaxDevicesPerPortForStorageBus(storageSlot.bus);
+            int iMaxDevice = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxDevicesPerPortForStorageBus(storageSlot.bus);
             if (storageSlot.port != 0)
             {
@@ -288 +288 @@
         case KStorageBus_USB:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -304 +304 @@
         case KStorageBus_PCIe:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -320 +320 @@
         case KStorageBus_VirtioSCSI:
         {
-            int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(storageSlot.bus);
+            int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(storageSlot.bus);
             if (storageSlot.port < 0 || storageSlot.port > iMaxPort)
             {
@@ -403 +403 @@
             if (result.bus == KStorageBus_Null)
                 break;
-            const int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(result.bus);
-            const int iMaxDevice = uiCommon().virtualBox().GetSystemProperties().GetMaxDevicesPerPortForStorageBus(result.bus);
+            const int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(result.bus);
+            const int iMaxDevice = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxDevicesPerPortForStorageBus(result.bus);
             const LONG iPort = iIndex / iMaxPort;
             const LONG iDevice = iIndex % iMaxPort;
@@ -431 +431 @@
             if (result.bus == KStorageBus_Null)
                 break;
-            const int iMaxPort = uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(result.bus);
+            const int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(result.bus);
             const LONG iPort = regExp.cap(1).toInt();
             const LONG iDevice = 0;

trunk/src/VBox/Frontends/VirtualBox/src/globals/UICommon.cpp

@@ -98 +98 @@
 /* COM includes: */
 #include "CAudioAdapter.h"
-#include "CBIOSSettings.h"
 #include "CCloudMachine.h"
 #include "CConsole.h"

trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDetailsGenerator.cpp

@@ -48 +48 @@
 #include "CCloudMachine.h"
 #include "CConsole.h"
+#include "CFirmwareSettings.h"
 #include "CForm.h"
 #include "CFormValue.h"
@@ -56 +57 @@
 #include "CNetworkAdapter.h"
 #include "CNvramStore.h"
+#include "CPlatform.h"
+#include "CPlatformX86.h"
+#include "CPlatformProperties.h"
 #include "CProgress.h"
 #include "CRangedIntegerFormValue.h"
@@ -64 +68 @@
 #include "CStorageController.h"
 #include "CStringFormValue.h"
-#include "CSystemProperties.h"
 #include "CTrustedPlatformModule.h"
 #include "CUefiVariableStore.h"
@@ -310 +313 @@
     if (fOptions & UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_ChipsetType)
     {
-        const KChipsetType enmChipsetType = comMachine.GetChipsetType();
+        CPlatform comPlatform = comMachine.GetPlatform();
+        const KChipsetType enmChipsetType = comPlatform.GetChipsetType();
         if (enmChipsetType == KChipsetType_ICH9)
             table << UITextTableLine(QApplication::translate("UIDetails", "Chipset Type", "details (system)"),
@@ -329 +333 @@
     if (fOptions & UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Firmware)
     {
-        switch (comMachine.GetFirmwareType())
+        CFirmwareSettings comFirmwareSettings = comMachine.GetFirmwareSettings();
+        switch (comFirmwareSettings.GetFirmwareType())
         {
             case KFirmwareType_EFI:
@@ -370 +375 @@
     if (fOptions & UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Acceleration)
     {
+        CPlatform comPlatform = comMachine.GetPlatform();
+        CPlatformX86 comPlatformX86 = comPlatform.GetX86();
         QStringList acceleration;
         if (uiCommon().virtualBox().GetHost().GetProcessorFeature(KProcessorFeature_HWVirtEx))
         {
             /* Nested Paging: */
-            if (comMachine.GetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging))
+            if (comPlatformX86.GetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging))
                 acceleration << QApplication::translate("UIDetails", "Nested Paging", "details (system)");
         }
         /* Nested VT-x/AMD-V: */
-        if (comMachine.GetCPUProperty(KCPUPropertyType_HWVirt))
+        if (comPlatformX86.GetCPUProperty(KCPUPropertyTypeX86_HWVirt))
             acceleration << QApplication::translate("UIDetails", "Nested VT-x/AMD-V", "details (system)");
         /* PAE/NX: */
-        if (comMachine.GetCPUProperty(KCPUPropertyType_PAE))
+        if (comPlatformX86.GetCPUProperty(KCPUPropertyTypeX86_PAE))
             acceleration << QApplication::translate("UIDetails", "PAE/NX", "details (system)");
         /* Paravirtualization provider: */
@@ -711 +718 @@
 
     /* Iterate over all the adapters: */
-    const ulong uCount = uiCommon().virtualBox().GetSystemProperties().GetMaxNetworkAdapters(comMachine.GetChipsetType());
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    CPlatform comPlatform = comMachine.GetPlatform();
+    const ulong uCount = comProperties.GetMaxNetworkAdapters(comPlatform.GetChipsetType());
     for (ulong uSlot = 0; uSlot < uCount; ++uSlot)
     {
@@ -876 +885 @@
 
     /* Iterate over all the ports: */
-    const ulong uCount = uiCommon().virtualBox().GetSystemProperties().GetSerialPortCount();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    const ulong uCount = comProperties.GetSerialPortCount();
     for (ulong uSlot = 0; uSlot < uCount; ++uSlot)
     {
@@ -887 +897 @@
         /* Gather port information: */
         const KPortMode enmMode = comPort.GetHostMode();
-        const QString strModeTemplate = UITranslator::toCOMPortName(comPort.GetIRQ(), comPort.GetIOBase()) + ", ";
+        const QString strModeTemplate = UITranslator::toCOMPortName(comPort.GetIRQ(), comPort.GetIOAddress()) + ", ";
         QString strModeType;
         switch (enmMode)
@@ -1287 +1297 @@
 {
     /* Determine max amount of network adapters: */
-    const CVirtualBox comVBox = uiCommon().virtualBox();
-    const KChipsetType enmChipsetType = comMachine.GetChipsetType();
-    CSystemProperties comSystemProperties = comVBox.GetSystemProperties();
-    const ulong cMaxNetworkAdapters = comSystemProperties.GetMaxNetworkAdapters(enmChipsetType);
+    CVirtualBox comVBox = uiCommon().virtualBox();
+    CPlatform comPlatform = comMachine.GetPlatform();
+    const KChipsetType enmChipsetType = comPlatform.GetChipsetType();
+    CPlatformProperties comPlatformProperties = comVBox.GetPlatformProperties(KPlatformArchitecture_x86);
+    const ulong cMaxNetworkAdapters = comPlatformProperties.GetMaxNetworkAdapters(enmChipsetType);
 
     /* Gather adapter properties: */

trunk/src/VBox/Frontends/VirtualBox/src/notificationcenter/UINotificationObjects.cpp

@@ -69 +69 @@
 #include "CNATNetwork.h"
 #include "CNetworkAdapter.h"
+#include "CPlatformProperties.h"
 #include "CRangedIntegerFormValue.h"
 #include "CRangedInteger64FormValue.h"
@@ -627 +628 @@
         UIErrorString::formatErrorInfo(comAppliance),
         QString(), QString(), pParent);
+}
+
+/* static */
+void UINotificationMessage::cannotAcquirePlatformPropertiesParameter(const CPlatformProperties &comProperties)
+{
+    createMessage(
+        QApplication::translate("UIMessageCenter", "Platform properties failure ..."),
+        QApplication::translate("UIMessageCenter", "Failed to acquire platform properties parameter.") +
+        UIErrorString::formatErrorInfo(comProperties));
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/notificationcenter/UINotificationObjects.h

@@ -78 +78 @@
 class CMouse;
 class CNetworkAdapter;
+class CPlatformProperties;
 class CStorageController;
 class CSystemProperties;
@@ -285 +286 @@
         static void cannotAcquireApplianceParameter(const CAppliance &comAppliance,
                                                     UINotificationCenter *pParent = 0);
+        /** Notifies about inability to acquire IPlatformProperties parameter.
+          * @param  comProperties  Brings the object parameter get acquired from. */
+        static void cannotAcquirePlatformPropertiesParameter(const CPlatformProperties &comProperties);
         /** Notifies about inability to acquire ISystemProperties parameter.
           * @param  comProperties  Brings the object parameter get acquired from. */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

@@ -96 +96 @@
 #include "CMediumAttachment.h"
 #include "CNetworkAdapter.h"
+#include "CPlatformProperties.h"
 #include "CRecordingSettings.h"
 #include "CSnapshot.h"
@@ -2697 +2698 @@
     KChipsetType enmChipsetType = KChipsetType_Null;
     uimachine()->acquireChipsetType(enmChipsetType);
-    const ulong uCount = qMin((ulong)4, (ulong)uiCommon().virtualBox().GetSystemProperties().GetMaxNetworkAdapters(enmChipsetType));
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    const ulong uCount = qMin((ulong)4, (ulong)comProperties.GetMaxNetworkAdapters(enmChipsetType));
 
     /* Enumerate existing network adapters: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

@@ -67 +67 @@
 #include "CMedium.h"
 #include "CMediumAttachment.h"
+#include "CPlatform.h"
+#include "CPlatformProperties.h"
 #include "CRecordingSettings.h"
 #include "CSnapshot.h"
@@ -301 +303 @@
     if (comMachine.isNull())
         return false;
-    const KChipsetType enmChipsetType = comMachine.GetChipsetType();
+    CPlatform comPlatform = comMachine.GetPlatform();
+    const KChipsetType enmChipsetType = comPlatform.GetChipsetType();
     const bool fSuccess = comMachine.isOk();
     if (!fSuccess)
@@ -1229 +1232 @@
     CVirtualBox comVBox = uiCommon().virtualBox();
     AssertReturn(comVBox.isNotNull(), false);
-    CSystemProperties comProperties = comVBox.GetSystemProperties();
+    CPlatformProperties comProperties = comVBox.GetPlatformProperties(KPlatformArchitecture_x86);
     if (!comVBox.isOk())
     {
@@ -1245 +1248 @@
         fSuccess = comProperties.isOk();
         if (!fSuccess)
-            UINotificationMessage::cannotAcquireSystemPropertiesParameter(comProperties);
+            UINotificationMessage::cannotAcquirePlatformPropertiesParameter(comProperties);
         else
         {
@@ -2693 +2696 @@
 
         /* Enumerate all the virtual network adapters: */
-        const ulong cCount = uiCommon().virtualBox().GetSystemProperties().GetMaxNetworkAdapters(machine().GetChipsetType());
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+        CPlatform comPlatform = machine().GetPlatform();
+        const ulong cCount = comProperties.GetMaxNetworkAdapters(comPlatform.GetChipsetType());
         for (ulong uAdapterIndex = 0; uAdapterIndex < cCount; ++uAdapterIndex)
         {

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIAudioControllerEditor.cpp

@@ -38 +38 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -147 +147 @@
 
         /* Load currently supported audio driver types: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
         m_supportedValues = comProperties.GetSupportedAudioControllerTypes();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIBootOrderEditor.cpp

@@ -44 +44 @@
 #include "COMEnums.h"
 #include "CMachine.h"
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -333 +333 @@
                                                                     << KDeviceType_HardDisk
                                                                     << KDeviceType_Network;
-    const CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+    const CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     const int iPossibleBootListSize = qMin((ULONG)4, comProperties.GetMaxBootPosition());
     possibleBootItems.resize(iPossibleBootListSize);

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIChipsetEditor.cpp

@@ -38 +38 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -150 +150 @@
 
         /* Load currently supported values: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
         m_supportedValues = comProperties.GetSupportedChipsetTypes();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIGraphicsControllerEditor.cpp

@@ -38 +38 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -156 +156 @@
 
         /* Load currently supported graphics controller types: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
         m_supportedValues = comProperties.GetSupportedGraphicsControllerTypes();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UINetworkFeaturesEditor.cpp

@@ -45 +45 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -465 +465 @@
 
         /* Load currently supported types: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
         QVector<KNetworkAdapterType> supportedTypes = comProperties.GetSupportedNetworkAdapterTypes();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIParavirtProviderEditor.cpp

@@ -38 +38 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -147 +147 @@
 
         /* Load currently supported paravirt provider types: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
         m_supportedValues = comProperties.GetSupportedParavirtProviders();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIStorageSettingsEditor.cpp

@@ -63 +63 @@
 
 /* COM includes: */
+#include "CPlatformProperties.h"
 #include "CSystemProperties.h"
 
@@ -1214 +1215 @@
 {
     /* Limit maximum port count: */
-    m_uPortCount = qMin(uPortCount, (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(bus()));
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    m_uPortCount = qMin(uPortCount, (uint)comProperties.GetMaxPortCountForStorageBus(bus()));
 }
 
@@ -1231 +1233 @@
 uint ControllerItem::maxPortCount()
 {
-    return (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(bus());
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    return (uint)comProperties.GetMaxPortCountForStorageBus(bus());
 }
 
@@ -1247 +1250 @@
 {
     SlotsList allSlots;
-    CSystemProperties comProps = uiCommon().virtualBox().GetSystemProperties();
+    CPlatformProperties comProps = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     for (ULONG i = 0; i < comProps.GetMaxPortCountForStorageBus(bus()); ++ i)
         for (ULONG j = 0; j < comProps.GetMaxDevicesPerPortForStorageBus(bus()); ++ j)
@@ -1264 +1267 @@
 DeviceTypeList ControllerItem::deviceTypeList() const
 {
-    return uiCommon().virtualBox().GetSystemProperties().GetDeviceTypesForStorageBus(m_enmBus).toList();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    return comProperties.GetDeviceTypesForStorageBus(m_enmBus).toList();
 }
 
@@ -1344 +1348 @@
 
     /* Load currently supported storage buses: */
-    CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     const QVector<KStorageBus> supportedBuses = comProperties.GetSupportedStorageBuses();
 
@@ -1366 +1370 @@
 
     /* Load currently supported storage buses & types: */
-    CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     const QVector<KStorageBus> supportedBuses = comProperties.GetSupportedStorageBuses();
     const QVector<KStorageControllerType> supportedTypes = comProperties.GetSupportedStorageControllerTypes();
@@ -1859 +1863 @@
         case R_IsMoreIDEControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_IDE) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_IDE));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_IDE));
         }
         case R_IsMoreSATAControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_SATA) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_SATA));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_SATA));
         }
         case R_IsMoreSCSIControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_SCSI) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_SCSI));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_SCSI));
         }
         case R_IsMoreFloppyControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_Floppy) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_Floppy));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_Floppy));
         }
         case R_IsMoreSASControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_SAS) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_SAS));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_SAS));
         }
         case R_IsMoreUSBControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_USB) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_USB));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_USB));
         }
         case R_IsMoreNVMeControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_PCIe) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_PCIe));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_PCIe));
         }
         case R_IsMoreVirtioSCSIControllersPossible:
         {
+            CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
             return (m_enmConfigurationAccessLevel == ConfigurationAccessLevel_Full) &&
                    (qobject_cast<RootItem*>(m_pRootItem)->childCount(KStorageBus_VirtioSCSI) <
-                    uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_VirtioSCSI));
+                    comProperties.GetMaxInstancesOfStorageBus(chipsetType(), KStorageBus_VirtioSCSI));
         }
         case R_IsMoreAttachmentsPossible:
@@ -1912 +1924 @@
                 {
                     ControllerItem *pItemController = qobject_cast<ControllerItem*>(pItem);
-                    CSystemProperties comProps = uiCommon().virtualBox().GetSystemProperties();
+                    CPlatformProperties comProps = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
                     const bool fIsMoreAttachmentsPossible = (ULONG)rowCount(specifiedIndex) <
                                                             (comProps.GetMaxPortCountForStorageBus(pItemController->bus()) *
@@ -2258 +2270 @@
 
                     /* Lets make sure there is enough of place for all the remaining attachments: */
+                    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
                     const uint uMaxPortCount =
-                        (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(enmNewCtrBusType);
+                        (uint)comProperties.GetMaxPortCountForStorageBus(enmNewCtrBusType);
                     const uint uMaxDevicePerPortCount =
-                        (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxDevicesPerPortForStorageBus(enmNewCtrBusType);
+                        (uint)comProperties.GetMaxDevicesPerPortForStorageBus(enmNewCtrBusType);
                     const QList<QUuid> ids = pItemController->attachmentIDs();
                     if (uMaxPortCount * uMaxDevicePerPortCount < (uint)ids.size())
@@ -2656 +2669 @@
 {
     QMap<KStorageBus, int> maximumMap;
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     for (int iStorageBusType = KStorageBus_IDE; iStorageBusType < KStorageBus_Max; ++iStorageBusType)
-    {
         maximumMap.insert((KStorageBus)iStorageBusType,
-                          uiCommon().virtualBox().GetSystemProperties().GetMaxInstancesOfStorageBus(chipsetType(), (KStorageBus)iStorageBusType));
-    }
+                          comProperties.GetMaxInstancesOfStorageBus(chipsetType(), (KStorageBus)iStorageBusType));
     return maximumMap;
 }
@@ -3264 +3276 @@
 {
     /* Load currently supported storage buses and types: */
-    CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     const QVector<KStorageBus> supportedBuses = comProperties.GetSupportedStorageBuses();
     const QVector<KStorageControllerType> supportedTypes = comProperties.GetSupportedStorageControllerTypes();

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UITpmEditor.cpp

@@ -38 +38 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -148 +148 @@
 
         /* Load currently supported values: */
-        CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+        CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
         m_supportedValues = comProperties.GetSupportedTpmTypes();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIUSBControllerEditor.cpp

@@ -36 +36 @@
 
 /* COM includes: */
-#include "CSystemProperties.h"
+#include "CPlatformProperties.h"
 
 
@@ -145 +145 @@
 {
     /* Load currently supported types: */
-    CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
     m_supportedValues = comProperties.GetSupportedUSBControllerTypes();
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsGeneral.cpp

@@ -52 +52 @@
 #include "CMedium.h"
 #include "CMediumAttachment.h"
+#include "CPlatform.h"
+#include "CPlatformX86.h"
 #include "CProgress.h"
 
@@ -729 +731 @@
                 // Should we check global object getters?
                 const CGuestOSType &comNewType = vbox.GetGuestOSType(newGeneralData.m_strGuestOsTypeId);
-                m_machine.SetCPUProperty(KCPUPropertyType_LongMode, comNewType.GetIs64Bit());
-                fSuccess = m_machine.isOk();
+                CPlatform comPlatform = m_machine.GetPlatform();
+                CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+                comPlatformX86.SetCPUProperty(KCPUPropertyTypeX86_LongMode, comNewType.GetIs64Bit());
+                fSuccess = comPlatformX86.isOk();
+                /// @todo convey error info ..
             }
         }

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsNetwork.cpp

@@ -42 +42 @@
 #include "CNATEngine.h"
 #include "CNetworkAdapter.h"
+#include "CPlatformProperties.h"
 
 
@@ -907 +908 @@
               * is that the limitation to 4 isn't necessary any more, but this needs to be checked
               * on all platforms to be certain that it's usable everywhere. */
-            const ulong uCount = qMin((ULONG)4, uiCommon().virtualBox().GetSystemProperties().GetMaxNetworkAdapters(KChipsetType_PIIX3));
+            const ulong uCount = qMin((ULONG)4, uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxNetworkAdapters(KChipsetType_PIIX3));
 
             /* Create corresponding adapter tabs: */

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSerial.cpp

@@ -45 +45 @@
 
 /* COM includes: */
+#include "CPlatformProperties.h"
 #include "CSerialPort.h"
 
@@ -800 +801 @@
             oldPortData.m_fPortEnabled = comPort.GetEnabled();
             oldPortData.m_uIRQ = comPort.GetIRQ();
-            oldPortData.m_uIOBase = comPort.GetIOBase();
+            oldPortData.m_uIOBase = comPort.GetIOAddress();
             oldPortData.m_hostMode = comPort.GetHostMode();
             oldPortData.m_fServer = comPort.GetServer();
@@ -973 +974 @@
         {
             /* How many ports to display: */
-            const ulong uCount = uiCommon().virtualBox().GetSystemProperties().GetSerialPortCount();
+            const ulong uCount = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetSerialPortCount();
 
             /* Create corresponding port tabs: */
@@ -1115 +1116 @@
             if (fSuccess && isMachineOffline() && newPortData.m_uIOBase != oldPortData.m_uIOBase)
             {
-                comPort.SetIOBase(newPortData.m_uIOBase);
+                comPort.SetIOAddress(newPortData.m_uIOBase);
                 fSuccess = comPort.isOk();
             }

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSystem.cpp

@@ -48 +48 @@
 
 /* COM includes: */
-#include "CBIOSSettings.h"
+#include "CFirmwareSettings.h"
+#include "CPlatform.h"
+#include "CPlatformX86.h"
 #include "CNvramStore.h"
 #include "CTrustedPlatformModule.h"
@@ -269 +271 @@
     UIDataSettingsMachineSystem oldSystemData;
 
+    CPlatform comPlatform = m_machine.GetPlatform();
+    CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+    CFirmwareSettings comFirmwareSettings = m_machine.GetFirmwareSettings();
+    CNvramStore comStoreLvl1 = m_machine.GetNonVolatileStore();
+    CUefiVariableStore comStoreLvl2 = comStoreLvl1.GetUefiVariableStore();
+
     /* Gather support flags: */
     oldSystemData.m_fSupportedPAE = uiCommon().host().GetProcessorFeature(KProcessorFeature_PAE);
@@ -278 +286 @@
     oldSystemData.m_iMemorySize = m_machine.GetMemorySize();
     oldSystemData.m_bootItems = loadBootItems(m_machine);
-    oldSystemData.m_chipsetType = m_machine.GetChipsetType();
+    oldSystemData.m_chipsetType = comPlatform.GetChipsetType();
     oldSystemData.m_tpmType = m_machine.GetTrustedPlatformModule().GetType();
     oldSystemData.m_pointingHIDType = m_machine.GetPointingHIDType();
-    oldSystemData.m_fEnabledIoApic = m_machine.GetBIOSSettings().GetIOAPICEnabled();
-    oldSystemData.m_fEnabledEFI = m_machine.GetFirmwareType() >= KFirmwareType_EFI && m_machine.GetFirmwareType() <= KFirmwareType_EFIDUAL;
-    oldSystemData.m_fEnabledUTC = m_machine.GetRTCUseUTC();
-    CNvramStore comStoreLvl1 = m_machine.GetNonVolatileStore();
-    CUefiVariableStore comStoreLvl2 = comStoreLvl1.GetUefiVariableStore();
+    oldSystemData.m_fEnabledIoApic = comFirmwareSettings.GetIOAPICEnabled();
+    oldSystemData.m_fEnabledEFI = comFirmwareSettings.GetFirmwareType() >= KFirmwareType_EFI && comFirmwareSettings.GetFirmwareType() <= KFirmwareType_EFIDUAL;
+    oldSystemData.m_fEnabledUTC = comPlatform.GetRTCUseUTC();
     oldSystemData.m_fAvailableSecureBoot = comStoreLvl2.isNotNull();
     oldSystemData.m_fEnabledSecureBoot = oldSystemData.m_fAvailableSecureBoot
@@ -295 +301 @@
     oldSystemData.m_cCPUCount = oldSystemData.m_fSupportedHwVirtEx ? m_machine.GetCPUCount() : 1;
     oldSystemData.m_iCPUExecCap = m_machine.GetCPUExecutionCap();
-    oldSystemData.m_fEnabledPAE = m_machine.GetCPUProperty(KCPUPropertyType_PAE);
-    oldSystemData.m_fEnabledNestedHwVirtEx = m_machine.GetCPUProperty(KCPUPropertyType_HWVirt);
+    oldSystemData.m_fEnabledPAE = comPlatformX86.GetCPUProperty(KCPUPropertyTypeX86_PAE);
+    oldSystemData.m_fEnabledNestedHwVirtEx = comPlatformX86.GetCPUProperty(KCPUPropertyTypeX86_HWVirt);
 
     /* Gather old 'Acceleration' data: */
     oldSystemData.m_paravirtProvider = m_machine.GetParavirtProvider();
-    oldSystemData.m_fEnabledNestedPaging = m_machine.GetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging);
+    oldSystemData.m_fEnabledNestedPaging = comPlatformX86.GetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging);
 
     /* Cache old data: */
@@ -883 +889 @@
         if (fSuccess && isMachineOffline() && newSystemData.m_chipsetType != oldSystemData.m_chipsetType)
         {
-            m_machine.SetChipsetType(newSystemData.m_chipsetType);
-            fSuccess = m_machine.isOk();
+            CPlatform comPlatform = m_machine.GetPlatform();
+            comPlatform.SetChipsetType(newSystemData.m_chipsetType);
+            fSuccess = comPlatform.isOk();
+            /// @todo convey error info ..
         }
         /* Save TPM type: */
@@ -903 +911 @@
         if (fSuccess && isMachineOffline() && newSystemData.m_fEnabledIoApic != oldSystemData.m_fEnabledIoApic)
         {
-            m_machine.GetBIOSSettings().SetIOAPICEnabled(newSystemData.m_fEnabledIoApic);
-            fSuccess = m_machine.isOk();
+            CFirmwareSettings comFirmwareSettings = m_machine.GetFirmwareSettings();
+            comFirmwareSettings.SetIOAPICEnabled(newSystemData.m_fEnabledIoApic);
+            fSuccess = comFirmwareSettings.isOk();
+            /// @todo convey error info ..
         }
         /* Save firware type (whether EFI is enabled): */
         if (fSuccess && isMachineOffline() && newSystemData.m_fEnabledEFI != oldSystemData.m_fEnabledEFI)
         {
-            m_machine.SetFirmwareType(newSystemData.m_fEnabledEFI ? KFirmwareType_EFI : KFirmwareType_BIOS);
-            fSuccess = m_machine.isOk();
+            CFirmwareSettings comFirmwareSettings = m_machine.GetFirmwareSettings();
+            comFirmwareSettings.SetFirmwareType(newSystemData.m_fEnabledEFI ? KFirmwareType_EFI : KFirmwareType_BIOS);
+            fSuccess = comFirmwareSettings.isOk();
+            /// @todo convey error info ..
         }
         /* Save whether UTC is enabled: */
         if (fSuccess && isMachineOffline() && newSystemData.m_fEnabledUTC != oldSystemData.m_fEnabledUTC)
         {
-            m_machine.SetRTCUseUTC(newSystemData.m_fEnabledUTC);
-            fSuccess = m_machine.isOk();
+            CPlatform comPlatform = m_machine.GetPlatform();
+            comPlatform.SetRTCUseUTC(newSystemData.m_fEnabledUTC);
+            fSuccess = comPlatform.isOk();
+            /// @todo convey error info ..
         }
         /* Save whether secure boot is enabled: */
@@ -989 +1003 @@
         if (fSuccess && isMachineOffline() && newSystemData.m_fEnabledPAE != oldSystemData.m_fEnabledPAE)
         {
-            m_machine.SetCPUProperty(KCPUPropertyType_PAE, newSystemData.m_fEnabledPAE);
-            fSuccess = m_machine.isOk();
+            CPlatform comPlatform = m_machine.GetPlatform();
+            CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+            comPlatformX86.SetCPUProperty(KCPUPropertyTypeX86_PAE, newSystemData.m_fEnabledNestedPaging);
+            fSuccess = comPlatformX86.isOk();
+            /// @todo convey error info ..
         }
         /* Save whether Nested HW Virt Ex is enabled: */
         if (fSuccess && isMachineOffline() && newSystemData.m_fEnabledNestedHwVirtEx != oldSystemData.m_fEnabledNestedHwVirtEx)
         {
-            m_machine.SetCPUProperty(KCPUPropertyType_HWVirt, newSystemData.m_fEnabledNestedHwVirtEx);
-            fSuccess = m_machine.isOk();
+            CPlatform comPlatform = m_machine.GetPlatform();
+            CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+            comPlatformX86.SetCPUProperty(KCPUPropertyTypeX86_HWVirt, newSystemData.m_fEnabledNestedPaging);
+            fSuccess = comPlatformX86.isOk();
+            /// @todo convey error info ..
         }
         /* Save CPU execution cap: */
@@ -1038 +1058 @@
         if (fSuccess && isMachineOffline() && newSystemData.m_fEnabledNestedPaging != oldSystemData.m_fEnabledNestedPaging)
         {
-            m_machine.SetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging, newSystemData.m_fEnabledNestedPaging);
-            fSuccess = m_machine.isOk();
+            CPlatform comPlatform = m_machine.GetPlatform();
+            CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+            comPlatformX86.SetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging, newSystemData.m_fEnabledNestedPaging);
+            fSuccess = comPlatformX86.isOk();
+            /// @todo convey error info ..
         }
 

trunk/src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotDetailsWidget.cpp

@@ -62 +62 @@
 #include "CAudioAdapter.h"
 #include "CAudioSettings.h"
+#include "CFirmwareSettings.h"
 #include "CRecordingSettings.h"
 #include "CRecordingScreenSettings.h"
@@ -68 +69 @@
 #include "CMediumAttachment.h"
 #include "CNetworkAdapter.h"
+#include "CPlatform.h"
+#include "CPlatformX86.h"
+#include "CPlatformProperties.h"
 #include "CSerialPort.h"
 #include "CSharedFolder.h"
 #include "CStorageController.h"
-#include "CSystemProperties.h"
 #include "CUSBController.h"
 #include "CUSBDeviceFilter.h"
@@ -1359 +1362 @@
 
             /* Chipset Type? */
-            const KChipsetType enmChipsetType = comMachine.GetChipsetType();
-            const KChipsetType enmChipsetTypeOld = comMachineOld.GetChipsetType();
+            CPlatform comPlatform = comMachine.GetPlatform();
+            const KChipsetType enmChipsetType = comPlatform.GetChipsetType();
+            CPlatform comPlatformOld = comMachineOld.GetPlatform();
+            const KChipsetType enmChipsetTypeOld = comPlatformOld.GetChipsetType();
             if (enmChipsetType == KChipsetType_ICH9)
             {
@@ -1715 +1720 @@
     QStringList aReport;
     /* Iterate through boot device types: */
-    for (ulong i = 1; i <= uiCommon().virtualBox().GetSystemProperties().GetMaxBootPosition(); ++i)
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    for (ulong i = 1; i <= comProperties.GetMaxBootPosition(); ++i)
     {
         const KDeviceType enmDevice = comMachine.GetBootOrder(i);
@@ -1733 +1739 @@
     /* Prepare report: */
     QString strReport;
-    switch (comMachine.GetFirmwareType())
+    CFirmwareSettings comFirmwareSettings = comMachine.GetFirmwareSettings();
+    switch (comFirmwareSettings.GetFirmwareType())
     {
         case KFirmwareType_EFI:
@@ -1756 +1763 @@
 QString UISnapshotDetailsWidget::accelerationReport(const CMachine &comMachine)
 {
+    /* Acquire platform stuff: */
+    CPlatform comPlatform = comMachine.GetPlatform();
+    CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+
     /* Prepare report: */
     QStringList aReport;
@@ -1762 +1773 @@
     {
         /* VT-x/AMD-V? */
-        if (comMachine.GetHWVirtExProperty(KHWVirtExPropertyType_Enabled))
+        if (comPlatformX86.GetHWVirtExProperty(KHWVirtExPropertyType_Enabled))
         {
             aReport << QApplication::translate("UIDetails", "VT-x/AMD-V", "details (system)");
             /* Nested Paging? */
-            if (comMachine.GetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging))
+            if (comPlatformX86.GetHWVirtExProperty(KHWVirtExPropertyType_NestedPaging))
                 aReport << QApplication::translate("UIDetails", "Nested Paging", "details (system)");
         }
     }
     /* PAE/NX? */
-    if (comMachine.GetCPUProperty(KCPUPropertyType_PAE))
+    if (comPlatformX86.GetCPUProperty(KCPUPropertyTypeX86_PAE))
         aReport << QApplication::translate("UIDetails", "PAE/NX", "details (system)");
     /* Paravirtualization Interface? */
@@ -1935 +1946 @@
     QStringList aReport;
     /* Iterate through machine network adapters: */
-    const ulong iCount = uiCommon().virtualBox().GetSystemProperties().GetMaxNetworkAdapters(comMachine.GetChipsetType());
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    CPlatform comPlatform = comMachine.GetPlatform();
+    const ulong iCount = comProperties.GetMaxNetworkAdapters(comPlatform.GetChipsetType());
     for (ulong iSlot = 0; iSlot < iCount; ++iSlot)
     {
@@ -1993 +2006 @@
     QStringList aReport;
     /* Iterate through machine serial ports: */
-    const ulong iCount = uiCommon().virtualBox().GetSystemProperties().GetSerialPortCount();
+    CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
+    const ulong iCount = comProperties.GetSerialPortCount();
     for (ulong iSlot = 0; iSlot < iCount; ++iSlot)
     {
@@ -2004 +2018 @@
             /* Compose the data: */
             QStringList aInfo;
-            aInfo << UITranslator::toCOMPortName(comPort.GetIRQ(), comPort.GetIOBase());
+            aInfo << UITranslator::toCOMPortName(comPort.GetIRQ(), comPort.GetIOAddress());
             if (   enmMode == KPortMode_HostPipe
                 || enmMode == KPortMode_HostDevice

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIApplianceEditorWidget.cpp

@@ -51 +51 @@
 
 /* COM includes: */
+#include "CPlatformProperties.h"
 #include "CSystemProperties.h"
 
@@ -840 +841 @@
                 QComboBox *pComboBox = new QComboBox(pParent);
                 /* Load currently supported network adapter types: */
-                CSystemProperties comProperties = uiCommon().virtualBox().GetSystemProperties();
+                CPlatformProperties comProperties = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86);
                 QVector<KNetworkAdapterType> supportedTypes = comProperties.GetSupportedNetworkAdapterTypes();
                 /* Take currently requested type into account if it's sane: */

trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevm/UIWizardCloneVM.cpp

@@ -190 +190 @@
     CVirtualBox comVBox = uiCommon().virtualBox();
     /* Create a new machine object: */
-    CMachine cloneMachine = comVBox.CreateMachine(m_strCloneFilePath, m_strCloneName, QVector<QString>(), QString(), QString(),
+    CMachine cloneMachine = comVBox.CreateMachine(m_strCloneFilePath, m_strCloneName, KPlatformArchitecture_x86,
+                                                  QVector<QString>(), QString(), QString(),
                                                   QString(), QString(), QString());
     if (!comVBox.isOk())

trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvm/UIWizardNewVM.cpp

@@ -45 +45 @@
 #include "CAudioAdapter.h"
 #include "CAudioSettings.h"
-#include "CBIOSSettings.h"
+#include "CFirmwareSettings.h"
 #include "CGraphicsAdapter.h"
 #include "CExtPackManager.h"
 #include "CMediumFormat.h"
+#include "CPlatform.h"
+#include "CPlatformX86.h"
 #include "CStorageController.h"
 #include "CUSBController.h"
@@ -157 +159 @@
         m_machine = vbox.CreateMachine(m_strMachineFilePath,
                                        m_strMachineBaseName,
+                                       KPlatformArchitecture_x86,
                                        groups, strTypeId, QString(),
                                        QString(), QString(), QString());
@@ -166 +169 @@
         }
     }
+
+    CFirmwareSettings comFirmwareSettings = m_machine.GetFirmwareSettings();
 
 #if 0
@@ -182 +187 @@
     /* Enabled I/O APIC explicitly in we have more than 1 VCPU: */
     if (iVPUCount > 1)
-        m_machine.GetBIOSSettings().SetIOAPICEnabled(true);
+        comFirmwareSettings.SetIOAPICEnabled(true);
 
     /* Set recommended firmware type: */
-    m_machine.SetFirmwareType(m_fEFIEnabled ? KFirmwareType_EFI : KFirmwareType_BIOS);
+    comFirmwareSettings.SetFirmwareType(m_fEFIEnabled ? KFirmwareType_EFI : KFirmwareType_BIOS);
 #endif
 
@@ -276 +281 @@
 void UIWizardNewVM::configureVM(const QString &strGuestTypeId, const CGuestOSType &comGuestType)
 {
+    /* Acquire platform stuff: */
+    CPlatform comPlatform = m_machine.GetPlatform();
+    CPlatformX86 comPlatformX86 = comPlatform.GetX86();
+    CFirmwareSettings comFirmwareSettings = m_machine.GetFirmwareSettings();
+
     /* Get graphics adapter: */
     CGraphicsAdapter comGraphics = m_machine.GetGraphicsAdapter();
@@ -288 +298 @@
     /* Enabled I/O APIC explicitly in we have more than 1 VCPU: */
     if (iVPUCount > 1)
-        m_machine.GetBIOSSettings().SetIOAPICEnabled(true);
+        comFirmwareSettings.SetIOAPICEnabled(true);
 
     /* Graphics Controller type: */
@@ -297 +307 @@
 
     /* Selecting recommended chipset type: */
-    m_machine.SetChipsetType(comGuestType.GetRecommendedChipset());
+    comPlatform.SetChipsetType(comGuestType.GetRecommendedChipset());
 
     /* Selecting recommended Audio Controller: */
@@ -373 +383 @@
 
     /* Turn on PAE, if recommended: */
-    m_machine.SetCPUProperty(KCPUPropertyType_PAE, comGuestType.GetRecommendedPAE());
+    comPlatformX86.SetCPUProperty(KCPUPropertyTypeX86_PAE, comGuestType.GetRecommendedPAE());
 
     /* Set the recommended triple fault behavior: */
-    m_machine.SetCPUProperty(KCPUPropertyType_TripleFaultReset, comGuestType.GetRecommendedTFReset());
+    comPlatformX86.SetCPUProperty(KCPUPropertyTypeX86_TripleFaultReset, comGuestType.GetRecommendedTFReset());
 
     /* Set recommended firmware type: */
-    m_machine.SetFirmwareType(m_fEFIEnabled ? KFirmwareType_EFI : KFirmwareType_BIOS);
+    comFirmwareSettings.SetFirmwareType(m_fEFIEnabled ? KFirmwareType_EFI : KFirmwareType_BIOS);
 
     /* Set recommended human interface device types: */
@@ -398 +408 @@
 
     /* Set HPET flag: */
-    m_machine.SetHPETEnabled(comGuestType.GetRecommendedHPET());
+    comPlatformX86.SetHPETEnabled(comGuestType.GetRecommendedHPET());
 
     /* Set UTC flags: */
-    m_machine.SetRTCUseUTC(comGuestType.GetRecommendedRTCUseUTC());
+    comPlatform.SetRTCUseUTC(comGuestType.GetRecommendedRTCUseUTC());
 
     /* Set graphic bits: */