Changeset 68938 in vbox

Timestamp:

Sep 29, 2017 4:13:26 PM (7 years ago)

Author:

vboxsync

Message:

Main,VBoxManage: Changed the CPUID override methods on IMachine to take sub-leaves into account. Currently we do not support non-zero sub-leaves due to VMM, but that can be fixed later.

Location:

trunk

Files:

• include/VBox/settings.h (modified) (1 diff)
• src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp (modified) (1 diff)
• src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp (modified) (3 diffs)
• src/VBox/Main/idl/VirtualBox.xidl (modified) (5 diffs)
• src/VBox/Main/include/MachineImpl.h (modified) (2 diffs)
• src/VBox/Main/src-client/ConsoleImpl2.cpp (modified) (1 diff)
• src/VBox/Main/src-server/MachineImpl.cpp (modified) (5 diffs)
• src/VBox/Main/xml/Settings.cpp (modified) (5 diffs)

trunk/include/VBox/settings.h

@@ -694 +694 @@
     bool operator==(const CpuIdLeaf &c) const;
 
-    uint32_t                ulId;
-    uint32_t                ulEax;
-    uint32_t                ulEbx;
-    uint32_t                ulEcx;
-    uint32_t                ulEdx;
+    uint32_t                idx;
+    uint32_t                idxSub;
+    uint32_t                uEax;
+    uint32_t                uEbx;
+    uint32_t                uEcx;
+    uint32_t                uEdx;
 };
 

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

@@ -630 +630 @@
     if (details != VMINFO_MACHINEREADABLE)
         RTPrintf("CPUID overrides: ");
-    ULONG cFound = 0;
-    static uint32_t const s_auCpuIdRanges[] =
-    {
-        UINT32_C(0x00000000), UINT32_C(0x0000000a),
-        UINT32_C(0x80000000), UINT32_C(0x8000000a)
-    };
-    for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
-        for (uint32_t uLeaf = s_auCpuIdRanges[i]; uLeaf < s_auCpuIdRanges[i + 1]; uLeaf++)
-        {
-            ULONG uEAX, uEBX, uECX, uEDX;
-            rc = machine->GetCPUIDLeaf(uLeaf, &uEAX, &uEBX, &uECX, &uEDX);
-            if (SUCCEEDED(rc))
-            {
-                if (details == VMINFO_MACHINEREADABLE)
-                    RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x", uLeaf, uEAX, uEBX, uECX, uEDX);
-                else
-                {
-                    if (!cFound)
-                        RTPrintf("Leaf no.  EAX      EBX      ECX      EDX\n");
-                    RTPrintf("                 %08x  %08x %08x %08x %08x\n", uLeaf, uEAX, uEBX, uECX, uEDX);
-                }
-                cFound++;
-            }
-        }
-    if (!cFound && details != VMINFO_MACHINEREADABLE)
+    ULONG uOrdinal = 0;
+    for (uOrdinal = 0; uOrdinal < _4K; uOrdinal++)
+    {
+        ULONG uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX;
+        rc = machine->GetCPUIDLeafByOrdinal(uOrdinal, &uLeaf, &uSubLeaf, &uEAX, &uEBX, &uECX, &uEDX);
+        if (SUCCEEDED(rc))
+        {
+            if (details == VMINFO_MACHINEREADABLE)
+                RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x,%08x", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
+            else
+            {
+                if (!uOrdinal)
+                    RTPrintf("Leaf no.       EAX      EBX      ECX      EDX\n");
+                RTPrintf("                 %08x/%03x  %08x %08x %08x %08x\n", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX);
+            }
+        }
+        else
+        {
+            if (rc != E_INVALIDARG)
+                com::GlueHandleComError(machine, "GetCPUIDLeaf", rc, __FILE__, __LINE__);
+            break;
+        }
+    }
+
+    if (!uOrdinal && details != VMINFO_MACHINEREADABLE)
         RTPrintf("None\n");
 

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

@@ -81 +81 @@
     MODIFYVM_UNPLUGCPU,
     MODIFYVM_SETCPUID,
+    MODIFYVM_SETCPUID_OLD,
     MODIFYVM_DELCPUID,
+    MODIFYVM_DELCPUID_OLD,
     MODIFYVM_DELALLCPUID,
     MODIFYVM_GRAPHICSCONTROLLER,
@@ -253 +255 @@
     { "--vtxvpid",                  MODIFYVM_VTXVPID,                   RTGETOPT_REQ_BOOL_ONOFF },
     { "--vtxux",                    MODIFYVM_VTXUX,                     RTGETOPT_REQ_BOOL_ONOFF },
-    { "--cpuidset",                 MODIFYVM_SETCPUID,                  RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
-    { "--cpuidremove",              MODIFYVM_DELCPUID,                  RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX},
+    { "--cpuid-set",                MODIFYVM_SETCPUID,                  RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX },
+    { "--cpuid-remove",             MODIFYVM_DELCPUID,                  RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX },
+    { "--cpuidset",                 MODIFYVM_SETCPUID_OLD,              RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX },
+    { "--cpuidremove",              MODIFYVM_DELCPUID_OLD,              RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX },
     { "--cpuidremoveall",           MODIFYVM_DELALLCPUID,               RTGETOPT_REQ_NOTHING},
     { "--cpus",                     MODIFYVM_CPUS,                      RTGETOPT_REQ_UINT32 },
@@ -735 +739 @@
 
             case MODIFYVM_SETCPUID:
-            {
-                uint32_t id = ValueUnion.u32;
+            case MODIFYVM_SETCPUID_OLD:
+            {
+                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(USAGE_MODIFYVM,
-                                           "Missing or Invalid argument to '%s'",
-                                           GetOptState.pDef->pszLong);
+                        return errorSyntax(USAGE_MODIFYVM, "Missing or Invalid argument to '%s'", GetOptState.pDef->pszLong);
                     aValue[i] = ValueUnion.u32;
                 }
-                CHECK_ERROR(sessionMachine, SetCPUIDLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
+                CHECK_ERROR(sessionMachine, SetCPUIDLeaf(idx, idxSub, aValue[0], aValue[1], aValue[2], aValue[3]));
                 break;
             }
 
             case MODIFYVM_DELCPUID:
-            {
-                CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.u32));
-                break;
-            }
+                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:

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

@@ -4776 +4776 @@
   <interface
     name="IMachine" extends="$unknown"
-    uuid="f50b24f0-0956-453c-d14c-8c27c683c295"
+    uuid="85cd948e-a71f-4289-281e-0ca7ad48cd89"
     wsmap="managed"
     wrap-hint-server-addinterfaces="IInternalMachineControl"
     wrap-hint-server="manualaddinterfaces"
-    reservedMethods="7" reservedAttributes="9"
+    reservedMethods="6" reservedAttributes="9"
     >
     <!-- Note! This interface is not compatible between 5.0 and 5.1 as it had too many
@@ -6932 +6932 @@
     </method>
 
+    <method name="getCPUIDLeafByOrdinal" const="yes">
+      <desc>
+        Used to enumerate CPUID information override values.
+
+        <result name="E_INVALIDARG">
+          Invalid ordinal number is out of range.
+        </result>
+      </desc>
+      <param name="ordinal" type="unsigned long" dir="in">
+        <desc>
+          The ordinal number of the leaf to get.
+        </desc>
+      </param>
+      <param name="idx" type="unsigned long" dir="out">
+        <desc>
+          CPUID leaf index.
+        </desc>
+      </param>
+      <param name="idxSub" type="unsigned long" dir="out">
+        <desc>
+          CPUID leaf sub-index.
+        </desc>
+      </param>
+      <param name="valEax" type="unsigned long" dir="out">
+        <desc>
+          CPUID leaf value for register eax.
+        </desc>
+      </param>
+      <param name="valEbx" type="unsigned long" dir="out">
+        <desc>
+          CPUID leaf value for register ebx.
+        </desc>
+      </param>
+      <param name="valEcx" type="unsigned long" dir="out">
+        <desc>
+          CPUID leaf value for register ecx.
+        </desc>
+      </param>
+      <param name="valEdx" type="unsigned long" dir="out">
+        <desc>
+          CPUID leaf value for register edx.
+        </desc>
+      </param>
+    </method>
+
     <method name="getCPUIDLeaf" const="yes">
       <desc>
@@ -6937 +6982 @@
 
         Currently supported index values for cpuid:
-        Standard CPUID leafs: 0 - 0xA
-        Extended CPUID leafs: 0x80000000 - 0x8000000A
-
-        See the Intel and AMD programmer's manuals for detailed information
-        about the cpuid instruction and its leafs.
+        Standard CPUID leaves: 0 - 0x1f
+        Extended CPUID leaves: 0x80000000 - 0x8000001f
+        VIA CPUID leaves:      0xc0000000 - 0xc000000f
+
+        See the Intel, AMD and VIA programmer's manuals for detailed information
+        about the CPUID instruction and its leaves.
         <result name="E_INVALIDARG">
-          Invalid id.
-        </result>
-
-      </desc>
-      <param name="id" type="unsigned long" dir="in">
+          Invalid index.
+        </result>
+
+      </desc>
+      <param name="idx" type="unsigned long" dir="in">
         <desc>
           CPUID leaf index.
+        </desc>
+      </param>
+      <param name="idxSub" type="unsigned long" dir="in">
+        <desc>
+          CPUID leaf sub-index (ECX).  Set to 0xffffffff (or 0) if not applicable.
         </desc>
       </param>
@@ -6980 +7031 @@
 
         Currently supported index values for cpuid:
-        Standard CPUID leafs: 0 - 0xA
-        Extended CPUID leafs: 0x80000000 - 0x8000000A
-
-        See the Intel and AMD programmer's manuals for detailed information
-        about the cpuid instruction and its leafs.
+        Standard CPUID leaves: 0 - 0x1f
+        Extended CPUID leaves: 0x80000000 - 0x8000001f
+        VIA CPUID leaves:      0xc0000000 - 0xc000000f
+
+        The subleaf index is only applicable to certain leaves (see manuals as this is
+        subject to change).
+
+        See the Intel, AMD and VIA programmer's manuals for detailed information
+        about the cpuid instruction and its leaves.
 
         Do not use this method unless you know exactly what you're doing. Misuse can lead to
         random crashes inside VMs.
         <result name="E_INVALIDARG">
-          Invalid id.
-        </result>
-
-      </desc>
-      <param name="id" type="unsigned long" dir="in">
+          Invalid index.
+        </result>
+
+      </desc>
+      <param name="idx" type="unsigned long" dir="in">
         <desc>
           CPUID leaf index.
         </desc>
       </param>
+      <param name="idxSub" type="unsigned long" dir="in">
+        <desc>
+          CPUID leaf sub-index (ECX).  Set to 0xffffffff (or 0) if not applicable.
+          The 0xffffffff causes it to remove all other subleaves before adding one
+          with sub-index 0.
+        </desc>
+      </param>
       <param name="valEax" type="unsigned long" dir="in">
         <desc>
@@ -7025 +7087 @@
 
         <result name="E_INVALIDARG">
-          Invalid id.
-        </result>
-
-      </desc>
-      <param name="id" type="unsigned long" dir="in">
+          Invalid index.
+        </result>
+
+      </desc>
+      <param name="idx" type="unsigned long" dir="in">
         <desc>
           CPUID leaf index.
+        </desc>
+      </param>
+      <param name="idxSub" type="unsigned long" dir="in">
+        <desc>
+          CPUID leaf sub-index (ECX).  Set to 0xffffffff (or 0) if not applicable.
+          The 0xffffffff value works like a wildcard.
         </desc>
       </param>

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

@@ -298 +298 @@
         BOOL                mCPUAttached[SchemaDefs::MaxCPUCount];
 
-        settings::CpuIdLeaf mCpuIdStdLeafs[11];
-        settings::CpuIdLeaf mCpuIdExtLeafs[11];
+        std::list<settings::CpuIdLeaf> mCpuIdLeafList;
 
         DeviceType_T        mBootOrder[SchemaDefs::MaxBootPosition];
@@ -1090 +1089 @@
     HRESULT setCPUProperty(CPUPropertyType_T aProperty,
                            BOOL aValue);
-    HRESULT getCPUIDLeaf(ULONG aId,
+    HRESULT getCPUIDLeafByOrdinal(ULONG aOrdinal,
+                                  ULONG *aIdx,
+                                  ULONG *aSubIdx,
+                                  ULONG *aValEax,
+                                  ULONG *aValEbx,
+                                  ULONG *aValEcx,
+                                  ULONG *aValEdx);
+    HRESULT getCPUIDLeaf(ULONG aIdx, ULONG aSubIdx,
                          ULONG *aValEax,
                          ULONG *aValEbx,
                          ULONG *aValEcx,
                          ULONG *aValEdx);
-    HRESULT setCPUIDLeaf(ULONG aId,
+    HRESULT setCPUIDLeaf(ULONG aIdx, ULONG aSubIdx,
                          ULONG aValEax,
                          ULONG aValEbx,
                          ULONG aValEcx,
                          ULONG aValEdx);
-    HRESULT removeCPUIDLeaf(ULONG aId);
+    HRESULT removeCPUIDLeaf(ULONG aIdx, ULONG aSubIdx);
     HRESULT removeAllCPUIDLeaves();
     HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,

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

@@ -922 +922 @@
         InsertConfigNode(pRoot, "CPUM", &pCPUM);
 
-        /* cpuid leaf overrides. */
-        static uint32_t const s_auCpuIdRanges[] =
-        {
-            UINT32_C(0x00000000), UINT32_C(0x0000000a),
-            UINT32_C(0x80000000), UINT32_C(0x8000000a)
-        };
-        for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
-            for (uint32_t uLeaf = s_auCpuIdRanges[i]; uLeaf < s_auCpuIdRanges[i + 1]; uLeaf++)
-            {
-                ULONG ulEax, ulEbx, ulEcx, ulEdx;
-                hrc = pMachine->GetCPUIDLeaf(uLeaf, &ulEax, &ulEbx, &ulEcx, &ulEdx);
-                if (SUCCEEDED(hrc))
-                {
-                    PCFGMNODE pLeaf;
-                    InsertConfigNode(pCPUM, Utf8StrFmt("HostCPUID/%RX32", uLeaf).c_str(), &pLeaf);
-
-                    InsertConfigInteger(pLeaf, "eax", ulEax);
-                    InsertConfigInteger(pLeaf, "ebx", ulEbx);
-                    InsertConfigInteger(pLeaf, "ecx", ulEcx);
-                    InsertConfigInteger(pLeaf, "edx", ulEdx);
-                }
-                else if (hrc != E_INVALIDARG)                                               H();
-            }
+        /* Host CPUID leaf overrides. */
+        for (uint32_t iOrdinal = 0; iOrdinal < _4K; iOrdinal++)
+        {
+            ULONG uLeaf, uSubLeaf, uEax, uEbx, uEcx, uEdx;
+            hrc = pMachine->GetCPUIDLeafByOrdinal(iOrdinal, &uLeaf, &uSubLeaf, &uEax, &uEbx, &uEcx, &uEdx);
+            if (hrc == E_INVALIDARG)
+                break;
+            H();
+            PCFGMNODE pLeaf;
+            InsertConfigNode(pCPUM, Utf8StrFmt("HostCPUID/%RX32", uLeaf).c_str(), &pLeaf);
+            /** @todo Figure out how to tell the VMM about uSubLeaf   */
+            InsertConfigInteger(pLeaf, "eax", uEax);
+            InsertConfigInteger(pLeaf, "ebx", uEbx);
+            InsertConfigInteger(pLeaf, "ecx", uEcx);
+            InsertConfigInteger(pLeaf, "edx", uEdx);
+        }
 
         /* We must limit CPUID count for Windows NT 4, as otherwise it stops

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

@@ -2310 +2310 @@
 }
 
-HRESULT Machine::getCPUIDLeaf(ULONG aId, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
+HRESULT Machine::getCPUIDLeafByOrdinal(ULONG aOrdinal, ULONG *aIdx, ULONG *aSubIdx, ULONG *aValEax, ULONG *aValEbx,
+                                       ULONG *aValEcx, ULONG *aValEdx)
 {
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    switch(aId)
-    {
-        case 0x0:
-        case 0x1:
-        case 0x2:
-        case 0x3:
-        case 0x4:
-        case 0x5:
-        case 0x6:
-        case 0x7:
-        case 0x8:
-        case 0x9:
-        case 0xA:
-            if (mHWData->mCpuIdStdLeafs[aId].ulId != aId)
-                return E_INVALIDARG;
-
-            *aValEax = mHWData->mCpuIdStdLeafs[aId].ulEax;
-            *aValEbx = mHWData->mCpuIdStdLeafs[aId].ulEbx;
-            *aValEcx = mHWData->mCpuIdStdLeafs[aId].ulEcx;
-            *aValEdx = mHWData->mCpuIdStdLeafs[aId].ulEdx;
-            break;
-
-        case 0x80000000:
-        case 0x80000001:
-        case 0x80000002:
-        case 0x80000003:
-        case 0x80000004:
-        case 0x80000005:
-        case 0x80000006:
-        case 0x80000007:
-        case 0x80000008:
-        case 0x80000009:
-        case 0x8000000A:
-            if (mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId != aId)
-                return E_INVALIDARG;
-
-            *aValEax = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax;
-            *aValEbx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx;
-            *aValEcx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx;
-            *aValEdx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx;
-            break;
-
-        default:
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
-    }
-    return S_OK;
-}
-
-
-HRESULT Machine::setCPUIDLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
-{
+    if (aOrdinal < mHWData->mCpuIdLeafList.size())
+    {
+        for (settings::CpuIdLeafsList::const_iterator it = mHWData->mCpuIdLeafList.begin();
+             it != mHWData->mCpuIdLeafList.end();
+             ++it)
+        {
+            if (aOrdinal == 0)
+            {
+                const settings::CpuIdLeaf &rLeaf= *it;
+                *aIdx    = rLeaf.idx;
+                *aSubIdx = rLeaf.idxSub;
+                *aValEax = rLeaf.uEax;
+                *aValEbx = rLeaf.uEbx;
+                *aValEcx = rLeaf.uEcx;
+                *aValEdx = rLeaf.uEdx;
+                return S_OK;
+            }
+            aOrdinal--;
+        }
+    }
+    return E_INVALIDARG;
+}
+
+HRESULT Machine::getCPUIDLeaf(ULONG aIdx, ULONG aSubIdx, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    /*
+     * Search the list.
+     */
+    for (settings::CpuIdLeafsList::const_iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); ++it)
+    {
+        const settings::CpuIdLeaf &rLeaf= *it;
+        if (   rLeaf.idx == aIdx
+            && (   aSubIdx == UINT32_MAX
+                || rLeaf.idxSub == aSubIdx) )
+        {
+            *aValEax = rLeaf.uEax;
+            *aValEbx = rLeaf.uEbx;
+            *aValEcx = rLeaf.uEcx;
+            *aValEdx = rLeaf.uEdx;
+            return S_OK;
+        }
+    }
+
+    return E_INVALIDARG;
+}
+
+
+HRESULT Machine::setCPUIDLeaf(ULONG aIdx, ULONG aSubIdx, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
+{
+    /*
+     * Validate input before taking locks and checking state.
+     */
+    if (aSubIdx != 0 && aSubIdx != UINT32_MAX)
+        return setError(E_INVALIDARG, tr("Currently only aSubIdx values 0 and 0xffffffff are supported: %#x"), aSubIdx);
+    if (   aIdx >= UINT32_C(0x20)
+        && aIdx - UINT32_C(0x80000000) >= UINT32_C(0x20)
+        && aIdx - UINT32_C(0xc0000000) >= UINT32_C(0x10) )
+        return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aIdx);
+
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
     HRESULT rc = i_checkStateDependency(MutableStateDep);
     if (FAILED(rc)) return rc;
 
-    switch(aId)
-    {
-        case 0x0:
-        case 0x1:
-        case 0x2:
-        case 0x3:
-        case 0x4:
-        case 0x5:
-        case 0x6:
-        case 0x7:
-        case 0x8:
-        case 0x9:
-        case 0xA:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xB);
-            AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
-            i_setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mCpuIdStdLeafs[aId].ulId  = aId;
-            mHWData->mCpuIdStdLeafs[aId].ulEax = aValEax;
-            mHWData->mCpuIdStdLeafs[aId].ulEbx = aValEbx;
-            mHWData->mCpuIdStdLeafs[aId].ulEcx = aValEcx;
-            mHWData->mCpuIdStdLeafs[aId].ulEdx = aValEdx;
-            break;
-
-        case 0x80000000:
-        case 0x80000001:
-        case 0x80000002:
-        case 0x80000003:
-        case 0x80000004:
-        case 0x80000005:
-        case 0x80000006:
-        case 0x80000007:
-        case 0x80000008:
-        case 0x80000009:
-        case 0x8000000A:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xB);
-            AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
-            i_setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId  = aId;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax = aValEax;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx = aValEbx;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx = aValEcx;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx = aValEdx;
-            break;
-
-        default:
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
-    }
-    return S_OK;
-}
-
-HRESULT Machine::removeCPUIDLeaf(ULONG aId)
+    /*
+     * Impose a maximum number of leaves.
+     */
+    if (mHWData->mCpuIdLeafList.size() > 256)
+        return setError(E_FAIL, tr("Max of 256 CPUID override leaves reached"));
+
+    /*
+     * Updating the list is a bit more complicated.  So, let's do a remove first followed by an insert.
+     */
+    i_setModified(IsModified_MachineData);
+    mHWData.backup();
+
+    for (settings::CpuIdLeafsList::iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); )
+    {
+        settings::CpuIdLeaf &rLeaf= *it;
+        if (   rLeaf.idx == aIdx
+            && (   aSubIdx == UINT32_MAX
+                || rLeaf.idxSub == aSubIdx) )
+            it = mHWData->mCpuIdLeafList.erase(it);
+        else
+            ++it;
+    }
+
+    settings::CpuIdLeaf NewLeaf;
+    NewLeaf.idx    = aIdx;
+    NewLeaf.idxSub = aSubIdx == UINT32_MAX ? 0 : aSubIdx;
+    NewLeaf.uEax   = aValEax;
+    NewLeaf.uEbx   = aValEbx;
+    NewLeaf.uEcx   = aValEcx;
+    NewLeaf.uEdx   = aValEdx;
+    mHWData->mCpuIdLeafList.push_back(NewLeaf);
+    return S_OK;
+}
+
+HRESULT Machine::removeCPUIDLeaf(ULONG aIdx, ULONG aSubIdx)
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2429 +2420 @@
     if (FAILED(rc)) return rc;
 
-    switch(aId)
-    {
-        case 0x0:
-        case 0x1:
-        case 0x2:
-        case 0x3:
-        case 0x4:
-        case 0x5:
-        case 0x6:
-        case 0x7:
-        case 0x8:
-        case 0x9:
-        case 0xA:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xB);
-            AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
-            i_setModified(IsModified_MachineData);
-            mHWData.backup();
-            /* Invalidate leaf. */
-            mHWData->mCpuIdStdLeafs[aId].ulId = UINT32_MAX;
-            break;
-
-        case 0x80000000:
-        case 0x80000001:
-        case 0x80000002:
-        case 0x80000003:
-        case 0x80000004:
-        case 0x80000005:
-        case 0x80000006:
-        case 0x80000007:
-        case 0x80000008:
-        case 0x80000009:
-        case 0x8000000A:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xB);
-            AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
-            i_setModified(IsModified_MachineData);
-            mHWData.backup();
-            /* Invalidate leaf. */
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = UINT32_MAX;
-            break;
-
-        default:
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
-    }
+    /*
+     * Do the removal.
+     */
+    bool fModified = false;
+    for (settings::CpuIdLeafsList::iterator it = mHWData->mCpuIdLeafList.begin(); it != mHWData->mCpuIdLeafList.end(); )
+    {
+        settings::CpuIdLeaf &rLeaf= *it;
+        if (   rLeaf.idx == aIdx
+            && (   aSubIdx == UINT32_MAX
+                || rLeaf.idxSub == aSubIdx) )
+        {
+            if (!fModified)
+            {
+                fModified = true;
+                i_setModified(IsModified_MachineData);
+                mHWData.backup();
+            }
+            it = mHWData->mCpuIdLeafList.erase(it);
+        }
+        else
+            ++it;
+    }
+
     return S_OK;
 }
@@ -2482 +2453 @@
     if (FAILED(rc)) return rc;
 
-    i_setModified(IsModified_MachineData);
-    mHWData.backup();
-
-    /* Invalidate all standard leafs. */
-    for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); ++i)
-        mHWData->mCpuIdStdLeafs[i].ulId = UINT32_MAX;
-
-    /* Invalidate all extended leafs. */
-    for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); ++i)
-        mHWData->mCpuIdExtLeafs[i].ulId = UINT32_MAX;
+    if (mHWData->mCpuIdLeafList.size() > 0)
+    {
+        i_setModified(IsModified_MachineData);
+        mHWData.backup();
+
+        mHWData->mCpuIdLeafList.clear();
+    }
 
     return S_OK;
@@ -8957 +8925 @@
              ++it)
         {
-            const settings::CpuIdLeaf &leaf = *it;
-
-            switch (leaf.ulId)
-            {
-            case 0x0:
-            case 0x1:
-            case 0x2:
-            case 0x3:
-            case 0x4:
-            case 0x5:
-            case 0x6:
-            case 0x7:
-            case 0x8:
-            case 0x9:
-            case 0xA:
-                mHWData->mCpuIdStdLeafs[leaf.ulId] = leaf;
-                break;
-
-            case 0x80000000:
-            case 0x80000001:
-            case 0x80000002:
-            case 0x80000003:
-            case 0x80000004:
-            case 0x80000005:
-            case 0x80000006:
-            case 0x80000007:
-            case 0x80000008:
-            case 0x80000009:
-            case 0x8000000A:
-                mHWData->mCpuIdExtLeafs[leaf.ulId - 0x80000000] = leaf;
-                break;
-
-            default:
-                /* just ignore */
-                break;
-            }
+            const settings::CpuIdLeaf &rLeaf= *it;
+            if (   rLeaf.idx < UINT32_C(0x20)
+                || rLeaf.idx - UINT32_C(0x80000000) < UINT32_C(0x20)
+                || rLeaf.idx - UINT32_C(0xc0000000) < UINT32_C(0x10) )
+                mHWData->mCpuIdLeafList.push_back(rLeaf);
+            /* else: just ignore */
         }
 
@@ -10305 +10243 @@
         /* Standard and Extended CPUID leafs. */
         data.llCpuIdLeafs.clear();
-        for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); ++idx)
-            if (mHWData->mCpuIdStdLeafs[idx].ulId != UINT32_MAX)
-                data.llCpuIdLeafs.push_back(mHWData->mCpuIdStdLeafs[idx]);
-        for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); ++idx)
-            if (mHWData->mCpuIdExtLeafs[idx].ulId != UINT32_MAX)
-                data.llCpuIdLeafs.push_back(mHWData->mCpuIdExtLeafs[idx]);
+        data.llCpuIdLeafs = mHWData->mCpuIdLeafList;
 
         // memory

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

@@ -2635 +2635 @@
  */
 CpuIdLeaf::CpuIdLeaf() :
-    ulId(UINT32_MAX),
-    ulEax(0),
-    ulEbx(0),
-    ulEcx(0),
-    ulEdx(0)
+    idx(UINT32_MAX),
+    idxSub(0),
+    uEax(0),
+    uEbx(0),
+    uEcx(0),
+    uEdx(0)
 {
 }
@@ -2651 +2652 @@
 {
     return (this == &c)
-        || (   ulId      == c.ulId
-            && ulEax     == c.ulEax
-            && ulEbx     == c.ulEbx
-            && ulEcx     == c.ulEcx
-            && ulEdx     == c.ulEdx);
+        || (   idx      == c.idx
+            && idxSub   == c.idxSub
+            && uEax     == c.uEax
+            && uEbx     == c.uEbx
+            && uEcx     == c.uEcx
+            && uEdx     == c.uEdx);
 }
 
@@ -3348 +3350 @@
         CpuIdLeaf leaf;
 
-        if (!pelmCpuIdLeaf->getAttributeValue("id", leaf.ulId))
+        if (!pelmCpuIdLeaf->getAttributeValue("id", leaf.idx))
             throw ConfigFileError(this, pelmCpuIdLeaf, N_("Required CpuId/@id attribute is missing"));
 
-        pelmCpuIdLeaf->getAttributeValue("eax", leaf.ulEax);
-        pelmCpuIdLeaf->getAttributeValue("ebx", leaf.ulEbx);
-        pelmCpuIdLeaf->getAttributeValue("ecx", leaf.ulEcx);
-        pelmCpuIdLeaf->getAttributeValue("edx", leaf.ulEdx);
+        if (!pelmCpuIdLeaf->getAttributeValue("subleaf", leaf.idxSub))
+            leaf.idxSub = 0;
+        pelmCpuIdLeaf->getAttributeValue("eax", leaf.uEax);
+        pelmCpuIdLeaf->getAttributeValue("ebx", leaf.uEbx);
+        pelmCpuIdLeaf->getAttributeValue("ecx", leaf.uEcx);
+        pelmCpuIdLeaf->getAttributeValue("edx", leaf.uEdx);
 
         ll.push_back(leaf);
@@ -5317 +5321 @@
 
         xml::ElementNode *pelmCpuIdLeaf = pelmCpuIdTree->createChild("CpuIdLeaf");
-        pelmCpuIdLeaf->setAttribute("id",  leaf.ulId);
-        pelmCpuIdLeaf->setAttribute("eax", leaf.ulEax);
-        pelmCpuIdLeaf->setAttribute("ebx", leaf.ulEbx);
-        pelmCpuIdLeaf->setAttribute("ecx", leaf.ulEcx);
-        pelmCpuIdLeaf->setAttribute("edx", leaf.ulEdx);
+        pelmCpuIdLeaf->setAttribute("id",  leaf.idx);
+        if (leaf.idxSub != 0)
+            pelmCpuIdLeaf->setAttribute("subleaf",  leaf.idxSub);
+        pelmCpuIdLeaf->setAttribute("eax", leaf.uEax);
+        pelmCpuIdLeaf->setAttribute("ebx", leaf.uEbx);
+        pelmCpuIdLeaf->setAttribute("ecx", leaf.uEcx);
+        pelmCpuIdLeaf->setAttribute("edx", leaf.uEdx);
     }
 
@@ -6937 +6943 @@
             }
         }
+
+        for (CpuIdLeafsList::const_iterator it = hardwareMachine.llCpuIdLeafs.begin();
+             it != hardwareMachine.llCpuIdLeafs.end();
+             ++it)
+            if (it->idxSub != 0)
+            {
+                m->sv = SettingsVersion_v1_16;
+                return;
+            }
     }