Changeset 25901 in vbox for trunk/src/VBox

Timestamp:

Jan 18, 2010 4:52:21 PM (15 years ago)

Author:

vboxsync

Message:

CPU hotplug: Merge 4th patch. Implements the Main API and a VBoxManage interface to turn CPU hotplug on/off and to add/remove CPUs while the VM is running

Location:

trunk/src/VBox

Files:

• Frontends/VBoxHeadless/VBoxHeadless.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageControlVM.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageModifyVM.cpp (modified) (3 diffs)
• Frontends/VBoxSDL/VBoxSDL.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxConsoleView.cpp (modified) (1 diff)
• Main/ConsoleImpl.cpp (modified) (2 diffs)
• Main/ConsoleImpl2.cpp (modified) (4 diffs)
• Main/ConsoleVRDPServer.cpp (modified) (1 diff)
• Main/MachineImpl.cpp (modified) (11 diffs)
• Main/SessionImpl.cpp (modified) (1 diff)
• Main/VirtualBoxCallbackImpl.cpp (modified) (1 diff)
• Main/idl/VirtualBox.xidl (modified) (5 diffs)
• Main/include/ConsoleImpl.h (modified) (2 diffs)
• Main/include/DisplayImpl.h (modified) (1 diff)
• Main/include/MachineImpl.h (modified) (5 diffs)
• Main/include/SessionImpl.h (modified) (1 diff)
• Main/include/VirtualBoxCallbackImpl.h (modified) (1 diff)
• Main/xml/Settings.cpp (modified) (10 diffs)

trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp

@@ -403 +403 @@
 
     STDMETHOD(OnMediumChange)(IMediumAttachment * /* aMediumAttachment */)
+    {
+        return S_OK;
+    }
+
+    STDMETHOD(OnCPUChange)(ULONG /*aCPU*/, BOOL /* aRemove */)
     {
         return S_OK;

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

@@ -116 +116 @@
             CHECK_ERROR_BREAK(console, Reset());
         }
+        else if (!strcmp(a->argv[1], "unplugcpu"))
+        {
+            if (a->argc <= 1 + 1)
+            {
+                errorArgument("Missing argument to '%s'. Expected CPU number.", a->argv[1]);
+                rc = E_FAIL;
+                break;
+            }
+
+            unsigned n = parseNum(a->argv[2], 32, "CPU");
+
+            CHECK_ERROR_BREAK(sessionMachine, HotUnplugCPU(n));
+        }
+        else if (!strcmp(a->argv[1], "plugcpu"))
+        {
+            if (a->argc <= 1 + 1)
+            {
+                errorArgument("Missing argument to '%s'. Expected CPU number.", a->argv[1]);
+                rc = E_FAIL;
+                break;
+            }
+
+            unsigned n = parseNum(a->argv[2], 32, "CPU");
+
+            CHECK_ERROR_BREAK(sessionMachine, HotPlugCPU(n));
+        }
         else if (!strcmp(a->argv[1], "poweroff"))
         {

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

@@ -71 +71 @@
     MODIFYVM_VTXVPID,
     MODIFYVM_CPUS,
+    MODIFYVM_CPUHOTPLUG,
+    MODIFYVM_PLUGCPU,
+    MODIFYVM_UNPLUGCPU,
     MODIFYVM_SETCPUID,
     MODIFYVM_DELCPUID,
@@ -153 +156 @@
     { "--cpuidremoveall",           MODIFYVM_DELALLCPUID,               RTGETOPT_REQ_NOTHING},
     { "--cpus",                     MODIFYVM_CPUS,                      RTGETOPT_REQ_UINT32 },
+    { "--cpuhotplug",               MODIFYVM_CPUHOTPLUG,                RTGETOPT_REQ_BOOL_ONOFF },
+    { "--plugcpu",                  MODIFYVM_PLUGCPU,                   RTGETOPT_REQ_UINT32 },
+    { "--unplugcpu",                MODIFYVM_UNPLUGCPU,                 RTGETOPT_REQ_UINT32 },
     { "--rtcuseutc",                MODIFYVM_RTCUSEUTC,                 RTGETOPT_REQ_BOOL_ONOFF },
     { "--monitorcount",             MODIFYVM_MONITORCOUNT,              RTGETOPT_REQ_UINT32 },
@@ -423 +429 @@
             }
 
+            case MODIFYVM_CPUHOTPLUG:
+            {
+                CHECK_ERROR(machine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
+                break;
+            }
+
+            case MODIFYVM_PLUGCPU:
+            {
+                CHECK_ERROR(machine, HotPlugCPU(ValueUnion.u32));
+                break;
+            }
+
+            case MODIFYVM_UNPLUGCPU:
+            {
+                CHECK_ERROR(machine, HotUnplugCPU(ValueUnion.u32));
+                break;
+            }
+
             case MODIFYVM_MONITORCOUNT:
             {

trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

@@ -542 +542 @@
 
     STDMETHOD(OnMediumChange)(IMediumAttachment * /*aMediumAttachment*/)
+    {
+        return S_OK;
+    }
+
+    STDMETHOD(OnCPUChange)(ULONG /*aCPU*/, BOOL /* aRemove */)
     {
         return S_OK;

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp

@@ -536 +536 @@
                 break;
         }
+        return S_OK;
+    }
+
+    STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove)
+    {
+        NOREF(aCPU);
+        NOREF(aRemove);
         return S_OK;
     }

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1730 +1730 @@
 }
 
+DECLCALLBACK(int) Console::unplugCpu(Console *pThis, unsigned uCpu)
+{
+    LogFlowFunc(("pThis=%p uCpu=%u\n", pThis, uCpu));
+
+    AssertReturn(pThis, VERR_INVALID_PARAMETER);
+
+    int vrc = PDMR3DeviceDetach(pThis->mpVM, "acpi", 0, uCpu, 0);
+    Log(("UnplugCpu: rc=%Rrc\n", vrc));
+
+    return vrc;
+}
+
+STDMETHODIMP Console::doCPURemove(ULONG aCpu)
+{
+    HRESULT rc = S_OK;
+
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this);
+
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+
+    /* protect mpVM */
+    AutoVMCaller autoVMCaller(this);
+    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
+
+    /* Check if the CPU is present */
+    BOOL fCpuAttached;
+    rc = mMachine->GetCPUStatus(aCpu, &fCpuAttached);
+    if (FAILED(rc)) return rc;
+
+    if (!fCpuAttached)
+        return setError(E_FAIL,
+                        tr("CPU %d is not attached"), aCpu);
+
+    /* Check if the CPU is unlocked */
+    PPDMIBASE pBase;
+    int vrc = PDMR3QueryDeviceLun(mpVM, "acpi", 0, aCpu, &pBase);
+    bool fLocked = true;
+    if (RT_SUCCESS(vrc))
+    {
+        uint32_t idCpuCore, idCpuPackage;
+
+        /* Notify the guest if possible. */
+        vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(mpVM, aCpu, &idCpuCore, &idCpuPackage);
+        AssertRC(vrc);
+
+        Assert(pBase);
+
+        PPDMIACPIPORT pPort =
+            (PPDMIACPIPORT) pBase->pfnQueryInterface(pBase, PDMINTERFACE_ACPI_PORT);
+
+        vrc = getVMMDev()->getVMMDevPort()->pfnCpuHotUnplug(getVMMDev()->getVMMDevPort(), idCpuCore, idCpuPackage);
+        if (RT_SUCCESS(vrc))
+        {
+            unsigned cTries = 10;
+
+            do
+            {
+                /* It will take some time until the event is processed in the guest. Wait  */
+                vrc = pPort ? pPort->pfnGetCpuStatus(pPort, aCpu, &fLocked) : VERR_INVALID_POINTER;
+
+                if (RT_SUCCESS(vrc) && !fLocked)
+                    break;
+
+                /* Sleep a bit */
+                RTThreadSleep(100);
+            } while (cTries-- > 0);
+        }
+        else if (vrc == VERR_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST)
+        {
+            /* Query one time. It is possible that the user ejected the CPU. */
+            vrc = pPort ? pPort->pfnGetCpuStatus(pPort, aCpu, &fLocked) : VERR_INVALID_POINTER;
+        }
+    }
+
+    /* If the CPU was unlocked we can detach it now. */
+    if (RT_SUCCESS(vrc) && !fLocked)
+    {
+        /*
+         * Call worker in EMT, that's faster and safer than doing everything
+         * using VMR3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
+         * here to make requests from under the lock in order to serialize them.
+         */
+        PVMREQ pReq;
+        vrc = VMR3ReqCall(mpVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
+                          (PFNRT)Console::unplugCpu, 2,
+                          this, aCpu);
+
+        /* leave the lock before a VMR3* call (EMT will call us back)! */
+        alock.leave();
+
+        if (vrc == VERR_TIMEOUT || RT_SUCCESS(vrc))
+        {
+            vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
+            AssertRC(vrc);
+            if (RT_SUCCESS(vrc))
+                vrc = pReq->iStatus;
+        }
+        VMR3ReqFree(pReq);
+
+        if (RT_SUCCESS(vrc))
+        {
+            /* Detach it from the VM  */
+            vrc = VMR3HotUnplugCpu(mpVM, aCpu);
+            AssertRC(vrc);
+        }
+        else
+           rc = setError(VBOX_E_VM_ERROR,
+                         tr("Hot-Remove failed (rc=%Rrc)"), vrc);
+    }
+    else
+        rc = setError(VBOX_E_VM_ERROR,
+                      tr("Hot-Remove was aborted because the CPU may still be used by the guest"), VERR_RESOURCE_BUSY);
+
+    LogFlowThisFunc(("mMachineState=%d, rc=%08X\n", mMachineState, rc));
+    LogFlowThisFuncLeave();
+    return rc;
+}
+
+DECLCALLBACK(int) Console::plugCpu(Console *pThis, unsigned uCpu)
+{
+    LogFlowFunc(("pThis=%p uCpu=%u\n", pThis, uCpu));
+
+    AssertReturn(pThis, VERR_INVALID_PARAMETER);
+
+    int rc = VMR3HotPlugCpu(pThis->mpVM, uCpu);
+    AssertRC(rc);
+
+    PCFGMNODE pInst = CFGMR3GetChild(CFGMR3GetRoot(pThis->mpVM), "Devices/acpi/0/");
+    AssertRelease(pInst);
+    /* nuke anything which might have been left behind. */
+    CFGMR3RemoveNode(CFGMR3GetChildF(pInst, "LUN#%d", uCpu));
+
+#define RC_CHECK() do { if (RT_FAILURE(rc)) { AssertReleaseRC(rc); break; } } while (0)
+
+    PCFGMNODE pLunL0;
+    PCFGMNODE pCfg;
+    rc = CFGMR3InsertNodeF(pInst, &pLunL0, "LUN#%d", uCpu);     RC_CHECK();
+    rc = CFGMR3InsertString(pLunL0, "Driver",       "ACPICpu"); RC_CHECK();
+    rc = CFGMR3InsertNode(pLunL0,   "Config",       &pCfg);     RC_CHECK();
+
+    /*
+     * Attach the driver.
+     */
+    PPDMIBASE pBase;
+    rc = PDMR3DeviceAttach(pThis->mpVM, "acpi", 0, uCpu, 0, &pBase); RC_CHECK();
+
+    Log(("PlugCpu: rc=%Rrc\n", rc));
+
+    CFGMR3Dump(pInst);
+
+    return VINF_SUCCESS;
+}
+
+STDMETHODIMP Console::doCPUAdd(ULONG aCpu)
+{
+    HRESULT rc = S_OK;
+
+    LogFlowThisFuncEnter();
+    LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this);
+
+    if (   mMachineState != MachineState_Running
+        && mMachineState != MachineState_Teleporting
+        && mMachineState != MachineState_LiveSnapshotting
+        /** @todo r=bird: This should be allowed on paused VMs as well. Later.  */
+       )
+        return setError(VBOX_E_INVALID_VM_STATE,
+            tr("Invalid machine state: %s"),
+            Global::stringifyMachineState(mMachineState));
+
+    /* protect mpVM */
+    AutoVMCaller autoVMCaller(this);
+    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
+
+    /* Check if the CPU is present */
+    BOOL fCpuAttached;
+    rc = mMachine->GetCPUStatus(aCpu, &fCpuAttached);
+    if (FAILED(rc)) return rc;
+
+    if (fCpuAttached)
+        return setError(E_FAIL,
+                        tr("CPU %d is already attached"), aCpu);
+
+    /*
+     * Call worker in EMT, that's faster and safer than doing everything
+     * using VMR3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
+     * here to make requests from under the lock in order to serialize them.
+     */
+    PVMREQ pReq;
+    int vrc = VMR3ReqCall(mpVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
+                          (PFNRT)Console::plugCpu, 2,
+                          this, aCpu);
+
+    /* leave the lock before a VMR3* call (EMT will call us back)! */
+    alock.leave();
+
+    if (vrc == VERR_TIMEOUT || RT_SUCCESS(vrc))
+    {
+        vrc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
+        AssertRC(vrc);
+        if (RT_SUCCESS(vrc))
+            vrc = pReq->iStatus;
+    }
+    VMR3ReqFree(pReq);
+
+    rc = RT_SUCCESS(vrc) ? S_OK :
+        setError(VBOX_E_VM_ERROR,
+            tr("Could not add CPU to the machine (%Rrc)"),
+            vrc);
+
+    if (RT_SUCCESS(vrc))
+    {
+        uint32_t idCpuCore, idCpuPackage;
+
+        /* Notify the guest if possible. */
+        vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(mpVM, aCpu, &idCpuCore, &idCpuPackage);
+        AssertRC(vrc);
+
+        vrc = getVMMDev()->getVMMDevPort()->pfnCpuHotPlug(getVMMDev()->getVMMDevPort(), idCpuCore, idCpuPackage);
+        /** @todo warning if the guest doesn't support it */
+    }
+
+    LogFlowThisFunc(("mMachineState=%d, rc=%08X\n", mMachineState, rc));
+    LogFlowThisFuncLeave();
+    return rc;
+}
+
 STDMETHODIMP Console::Pause()
 {
@@ -3730 +3973 @@
         while (it != mCallbacks.end())
             (*it++)->OnMediumChange(aMediumAttachment);
+    }
+
+    LogFlowThisFunc(("Leaving rc=%#x\n", rc));
+    return rc;
+}
+
+/**
+ * Called by IInternalSessionControl::OnCPUChange().
+ *
+ * @note Locks this object for writing.
+ */
+HRESULT Console::onCPUChange(ULONG aCPU, BOOL aRemove)
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnRC(autoCaller.rc());
+
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    /* Don't do anything if the VM isn't running */
+    if (!mpVM)
+        return S_OK;
+
+    HRESULT rc = S_OK;
+
+    /* protect mpVM */
+    AutoVMCaller autoVMCaller(this);
+    if (FAILED(autoVMCaller.rc())) return autoVMCaller.rc();
+
+    if (aRemove)
+        rc = doCPURemove(aCPU);
+    else
+        rc = doCPUAdd(aCPU);
+
+    /* notify console callbacks on success */
+    if (SUCCEEDED(rc))
+    {
+        CallbackList::iterator it = mCallbacks.begin();
+        while (it != mCallbacks.end())
+            (*it++)->OnCPUChange(aCPU, aRemove);
     }
 

trunk/src/VBox/Main/ConsoleImpl2.cpp

@@ -1851 +1851 @@
     if (fACPI)
     {
+        BOOL fCpuHotPlug = false;
         BOOL fShowCpu = fExtProfile;
         /* Always show the CPU leafs when we have multiple VCPUs or when the IO-APIC is enabled.
@@ -1856 +1857 @@
          * intelppm driver refuses to register an idle state handler.
          */
-        if ((cCpus > 1) ||  fIOAPIC)
+        if ((cCpus > 1) || fIOAPIC)
             fShowCpu = true;
+
+        hrc = pMachine->COMGETTER(CPUHotPlugEnabled)(&fCpuHotPlug);                 H();
 
         rc = CFGMR3InsertNode(pDevices, "acpi", &pDev);                             RC_CHECK();
@@ -1878 +1881 @@
 
         rc = CFGMR3InsertInteger(pCfg,  "ShowCpu", fShowCpu);                       RC_CHECK();
+        rc = CFGMR3InsertInteger(pCfg,  "CpuHotPlug", fCpuHotPlug);                 RC_CHECK();
         rc = CFGMR3InsertInteger(pInst, "PCIDeviceNo",          7);                 RC_CHECK();
         Assert(!afPciDeviceNo[7]);
@@ -1886 +1890 @@
         rc = CFGMR3InsertString(pLunL0, "Driver",               "ACPIHost");        RC_CHECK();
         rc = CFGMR3InsertNode(pLunL0,   "Config", &pCfg);                           RC_CHECK();
+
+        /* Attach the dummy CPU drivers */
+        for (ULONG iCpuCurr = 1; iCpuCurr < cCpus; iCpuCurr++)
+        {
+            BOOL fCpuAttached = true;
+
+            if (fCpuHotPlug)
+            {
+                hrc = pMachine->GetCPUStatus(iCpuCurr, &fCpuAttached);              H();
+            }
+
+            if (fCpuAttached)
+            {
+                rc = CFGMR3InsertNodeF(pInst, &pLunL0, "LUN#%u", iCpuCurr);             RC_CHECK();
+                rc = CFGMR3InsertString(pLunL0, "Driver",           "ACPICpu");         RC_CHECK();
+                rc = CFGMR3InsertNode(pLunL0,   "Config", &pCfg);                       RC_CHECK();
+            }
+        }
     }
 

trunk/src/VBox/Main/ConsoleVRDPServer.cpp

@@ -119 +119 @@
 
     STDMETHOD(OnMediumChange)(IMediumAttachment *aAttachment)
+    {
+        return S_OK;
+    }
+
+    STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove)
     {
         return S_OK;

trunk/src/VBox/Main/MachineImpl.cpp

@@ -156 +156 @@
     mMemorySize = 128;
     mCPUCount = 1;
+    mCPUHotPlugEnabled = false;
     mMemoryBalloonSize = 0;
     mStatisticsUpdateInterval = 0;
@@ -189 +190 @@
 
     mFirmwareType = FirmwareType_BIOS;
+
+    for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); i++)
+        mCPUAttached[i] = false;
 }
 
@@ -217 +221 @@
         mSyntheticCpu != that.mSyntheticCpu ||
         mCPUCount != that.mCPUCount ||
+        mCPUHotPlugEnabled != that.mCPUHotPlugEnabled ||
         mClipboardMode != that.mClipboardMode)
         return false;
@@ -223 +228 @@
         if (mBootOrder [i] != that.mBootOrder [i])
             return false;
+
+
+    for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); i++)
+    {
+        if (mCPUAttached[i] != that.mCPUAttached[i])
+            return false;
+    }
 
     if (mSharedFolders.size() != that.mSharedFolders.size())
@@ -1075 +1087 @@
 STDMETHODIMP Machine::COMSETTER(CPUCount) (ULONG CPUCount)
 {
-    /* check RAM limits */
+    /* check CPU limits */
     if (    CPUCount < SchemaDefs::MinCPUCount
          || CPUCount > SchemaDefs::MaxCPUCount
@@ -1088 +1100 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
+    /* We cant go below the current number of CPUs if hotplug is enabled*/
+    if (mHWData->mCPUHotPlugEnabled)
+    {
+        for (unsigned idx = CPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
+        {
+            if (mHWData->mCPUAttached[idx])
+                return setError(E_INVALIDARG,
+                                tr(": %lu (must be higher than or equal to %lu)"),
+                                CPUCount, idx+1);
+        }
+    }
+
     HRESULT rc = checkStateDependency(MutableStateDep);
     if (FAILED(rc)) return rc;
@@ -1095 +1119 @@
 
     return S_OK;
+}
+
+STDMETHODIMP Machine::COMGETTER(CPUHotPlugEnabled) (BOOL *enabled)
+{
+    if (!enabled)
+        return E_POINTER;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this);
+
+    *enabled = mHWData->mCPUHotPlugEnabled;
+
+    return S_OK;
+}
+
+STDMETHODIMP Machine::COMSETTER(CPUHotPlugEnabled) (BOOL enabled)
+{
+    HRESULT rc = S_OK;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this);
+
+    rc = checkStateDependency(MutableStateDep);
+    if (FAILED(rc)) return rc;
+
+    if (mHWData->mCPUHotPlugEnabled != enabled)
+    {
+        if (enabled)
+        {
+            mHWData.backup();
+
+            /* Add the amount of CPUs currently attached */
+            for (unsigned i = 0; i < mHWData->mCPUCount; i++)
+            {
+                mHWData->mCPUAttached[i] = true;
+            }
+        }
+        else
+        {
+            /*
+             * We can disable hotplug only if the amount of maximum CPUs is equal
+             * to the amount of attached CPUs
+             */
+            unsigned cCpusAttached = 0;
+            unsigned iHighestId = 0;
+
+            for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; i++)
+            {
+                if (mHWData->mCPUAttached[i])
+                {
+                    cCpusAttached++;
+                    iHighestId = i;
+                }
+            }
+
+            if (   (cCpusAttached != mHWData->mCPUCount)
+                || (iHighestId >= mHWData->mCPUCount))
+                return setError(E_INVALIDARG,
+                                tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached\n"));
+
+            mHWData.backup();
+        }
+    }
+
+    mHWData->mCPUHotPlugEnabled = enabled;
+
+    return rc;
 }
 
@@ -4257 +4352 @@
 }
 
+STDMETHODIMP Machine::HotPlugCPU(ULONG aCpu)
+{
+    HRESULT rc = S_OK;
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this);
+
+    if (!mHWData->mCPUHotPlugEnabled)
+        return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
+
+    if (aCpu >= mHWData->mCPUCount)
+        return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
+
+    if (mHWData->mCPUAttached[aCpu])
+        return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
+
+    alock.leave();
+    rc = onCPUChange(aCpu, false);
+    alock.enter();
+    if (FAILED(rc)) return rc;
+
+    mHWData.backup();
+    mHWData->mCPUAttached[aCpu] = true;
+
+    /* Save settings if online */
+    if (Global::IsOnline(mData->mMachineState))
+        SaveSettings();
+
+    return S_OK;
+}
+
+STDMETHODIMP Machine::HotUnplugCPU(ULONG aCpu)
+{
+    HRESULT rc = S_OK;
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this);
+
+    if (!mHWData->mCPUHotPlugEnabled)
+        return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
+
+    if (aCpu >= SchemaDefs::MaxCPUCount)
+        return setError(E_INVALIDARG,
+                        tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
+                        SchemaDefs::MaxCPUCount);
+
+    if (!mHWData->mCPUAttached[aCpu])
+        return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
+
+    /* CPU 0 can't be detached */
+    if (aCpu == 0)
+        return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
+
+    alock.leave();
+    rc = onCPUChange(aCpu, true);
+    alock.enter();
+    if (FAILED(rc)) return rc;
+
+    mHWData.backup();
+    mHWData->mCPUAttached[aCpu] = false;
+
+    /* Save settings if online */
+    if (Global::IsOnline(mData->mMachineState))
+        SaveSettings();
+
+    return S_OK;
+}
+
+STDMETHODIMP Machine::GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached)
+{
+    LogFlowThisFunc(("\n"));
+
+    CheckComArgNotNull(aCpuAttached);
+
+    *aCpuAttached = false;
+
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoReadLock alock(this);
+
+    /* If hotplug is enabled the CPU is always enabled. */
+    if (!mHWData->mCPUHotPlugEnabled)
+    {
+        if (aCpu < mHWData->mCPUCount)
+            *aCpuAttached = true;
+    }
+    else
+    {
+        if (aCpu < SchemaDefs::MaxCPUCount)
+            *aCpuAttached = mHWData->mCPUAttached[aCpu];
+    }
+
+    return S_OK;
+}
+
 // public methods for internal purposes
 /////////////////////////////////////////////////////////////////////////////
@@ -5960 +6157 @@
         mHWData->mSyntheticCpu                = data.fSyntheticCpu;
 
-        mHWData->mCPUCount = data.cCPUs;
+        mHWData->mCPUCount          = data.cCPUs;
+        mHWData->mCPUHotPlugEnabled = data.fCpuHotPlug;
+
+        // cpu
+        if (mHWData->mCPUHotPlugEnabled)
+        {
+            for (settings::CpuList::const_iterator it = data.llCpus.begin();
+                it != data.llCpus.end();
+                ++it)
+            {
+                const settings::Cpu &cpu = *it;
+
+                mHWData->mCPUAttached[cpu.ulId] = true;
+            }
+        }
 
         // cpuid leafs
@@ -6983 +7194 @@
         }
 
-        data.cCPUs = mHWData->mCPUCount;
+        data.cCPUs       = mHWData->mCPUCount;
+        data.fCpuHotPlug = mHWData->mCPUHotPlugEnabled;
+
+        data.llCpus.clear();
+        if (data.fCpuHotPlug)
+        {
+            for (unsigned idx = 0; idx < data.cCPUs; idx++)
+            {
+                if (mHWData->mCPUAttached[idx])
+                {
+                    settings::Cpu cpu;
+                    cpu.ulId = idx;
+                    data.llCpus.push_back(cpu);
+                }
+            }
+        }
 
         // memory
@@ -9659 +9885 @@
  *  @note Locks this object for reading.
  */
+HRESULT SessionMachine::onCPUChange(ULONG aCPU, BOOL aRemove)
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
+
+    ComPtr<IInternalSessionControl> directControl;
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+        directControl = mData->mSession.mDirectControl;
+    }
+
+    /* ignore notifications sent after #OnSessionEnd() is called */
+    if (!directControl)
+        return S_OK;
+
+    return directControl->OnCPUChange(aCPU, aRemove);
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
 HRESULT SessionMachine::onVRDPServerChange()
 {

trunk/src/VBox/Main/SessionImpl.cpp

@@ -571 +571 @@
 
     return mConsole->onMediumChange(aMediumAttachment, aForce);
+}
+
+STDMETHODIMP Session::OnCPUChange(ULONG aCPU, BOOL aRemove)
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    AssertReturn(mState == SessionState_Open, VBOX_E_INVALID_VM_STATE);
+    AssertReturn(mType == SessionType_Direct, VBOX_E_INVALID_OBJECT_STATE);
+
+    return mConsole->onCPUChange(aCPU, aRemove);
 }
 

trunk/src/VBox/Main/VirtualBoxCallbackImpl.cpp

@@ -289 +289 @@
 }
 
+STDMETHODIMP CallbackWrapper::OnCPUChange(ULONG aCPU, BOOL aRemove)
+{
+    if (mConsoleCallback.isNull())
+        return S_OK;
+
+    return mConsoleCallback->OnCPUChange(aCPU, aRemove);
+}
+
 STDMETHODIMP CallbackWrapper::OnRuntimeError(BOOL fFatal, IN_BSTR id, IN_BSTR message)
 {

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

@@ -459 +459 @@
            -->
     </const>
-    <const name="Future"     value="13">
-      <desc>Settings version greater than "1.10", written by a future VirtualBox version.</desc>
+    <const name="v1_11"     value="13">
+      <desc>Settings version "1.10", written by VirtualBox 3.2.x.</desc>
+      <!-- CPU hot-plug support
+           -->
+    </const>
+    <const name="Future"     value="14">
+      <desc>Settings version greater than "1.11", written by a future VirtualBox version.</desc>
     </const>
   </enum>
@@ -4356 +4361 @@
     </attribute>
 
+    <attribute name="CPUHotPlugEnabled" type="boolean">
+      <desc>
+        This setting determines whether VirtualBox allows CPU
+        hotplugging for this machine.</desc>
+    </attribute>
+
     <attribute name="memorySize" type="unsigned long">
       <desc>System memory size in megabytes.</desc>
@@ -5932 +5943 @@
       </param>
     </method>
+
+    <method name="HotPlugCPU">
+      <desc>
+        Plugs a CPU into the machine.
+      </desc>
+      <param name="cpu" type="unsigned long" dir="in">
+        <desc>
+          The CPU id to insert.
+        </desc>
+      </param>
+    </method>
+
+    <method name="HotUnplugCPU">
+      <desc>
+        Removes a CPU from the machine.
+      </desc>
+      <param name="cpu" type="unsigned long" dir="in">
+        <desc>
+          The CPU id to remove.
+        </desc>
+      </param>
+    </method>
+
+    <method name="GetCPUStatus">
+      <desc>
+        Plugs a CPU into the machine.
+      </desc>
+      <param name="cpu" type="unsigned long" dir="in">
+        <desc>
+          The CPU id to check for.
+        </desc>
+      </param>
+      <param name="attached" type="boolean" dir="return">
+        <desc>
+          Status of the CPU.
+        </desc>
+      </param>
+    </method>
 </interface>
 
@@ -6116 +6165 @@
       <param name="mediumAttachment" type="IMediumAttachment" dir="in">
         <desc>Medium attachment that is subject to change.</desc>
+      </param>
+    </method>
+
+    <method name="onCPUChange">
+      <desc>
+        Notification when a CPU changes.
+      </desc>
+      <param name="cpu" type="unsigned long" dir="in">
+        <desc>The CPU which changed</desc>
+      </param>
+      <param name="add" type="boolean" dir="in">
+        <desc>Flag whether the CPU was added or removed</desc>
       </param>
     </method>
@@ -12706 +12767 @@
       <param name="mediumAttachment" type="IMediumAttachment" dir="in"/>
       <param name="force" type="boolean" dir="in"/>
+    </method>
+
+    <method name="onCPUChange">
+      <desc>
+        Notification when a CPU changes.
+      </desc>
+      <param name="cpu" type="unsigned long" dir="in">
+        <desc>The CPU which changed</desc>
+      </param>
+      <param name="add" type="boolean" dir="in">
+        <desc>Flag whether the CPU was added or removed</desc>
+      </param>
     </method>
 

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

@@ -179 +179 @@
     HRESULT onStorageControllerChange ();
     HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
+    HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
     HRESULT onVRDPServerChange();
     HRESULT onUSBControllerChange();
@@ -448 +449 @@
                                           const char *pszFormat, bool fPassthrough,
                                           bool fForce);
+    static DECLCALLBACK(int) unplugCpu (Console *pThis, unsigned uCpu);
+    static DECLCALLBACK(int) plugCpu (Console *pThis, unsigned uCpu);
     HRESULT doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce);
+    HRESULT doCPURemove(ULONG aCpu);
+    HRESULT doCPUAdd(ULONG aCpu);
 
 #ifdef VBOX_DYNAMIC_NET_ATTACH

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

@@ -194 +194 @@
     }
 
+    STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove)
+    {
+        return S_OK;
+    }
+
     STDMETHOD(OnVRDPServerChange)()
     {

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

@@ -296 +296 @@
         BOOL           mSyntheticCpu;
         ULONG          mCPUCount;
+        BOOL           mCPUHotPlugEnabled;
         BOOL           mAccelerate3DEnabled;
+
+        BOOL           mCPUAttached[SchemaDefs::MaxCPUCount];
 
         settings::CpuIdLeaf mCpuIdStdLeafs[10];
@@ -531 +534 @@
     STDMETHOD(COMGETTER(CPUCount))(ULONG *cpuCount);
     STDMETHOD(COMSETTER(CPUCount))(ULONG cpuCount);
+    STDMETHOD(COMGETTER(CPUHotPlugEnabled))(BOOL *enabled);
+    STDMETHOD(COMSETTER(CPUHotPlugEnabled))(BOOL enabled);
     STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
     STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
@@ -634 +639 @@
     STDMETHOD(QuerySavedScreenshotPNGSize)(ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
     STDMETHOD(ReadSavedScreenshotPNGToArray)(ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
+    STDMETHOD(HotPlugCPU(ULONG aCpu));
+    STDMETHOD(HotUnplugCPU(ULONG aCpu));
+    STDMETHOD(GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached));
 
     // public methods only for internal purposes
@@ -717 +725 @@
     virtual HRESULT onUSBControllerChange() { return S_OK; }
     virtual HRESULT onStorageControllerChange() { return S_OK; }
+    virtual HRESULT onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
     virtual HRESULT onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
     virtual HRESULT onSharedFolderChange() { return S_OK; }
@@ -1036 +1045 @@
     HRESULT onSerialPortChange(ISerialPort *serialPort);
     HRESULT onParallelPortChange(IParallelPort *parallelPort);
+    HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
     HRESULT onVRDPServerChange();
     HRESULT onUSBControllerChange();

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

@@ -96 +96 @@
     STDMETHOD(OnStorageControllerChange)();
     STDMETHOD(OnMediumChange)(IMediumAttachment *aMediumAttachment, BOOL aForce);
+    STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove);
     STDMETHOD(OnVRDPServerChange)();
     STDMETHOD(OnUSBControllerChange)();

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

@@ -94 +94 @@
     STDMETHOD(OnStorageControllerChange) ();
     STDMETHOD(OnMediumChange)(IMediumAttachment *iMediumAttachment);
+    STDMETHOD(OnCPUChange)(ULONG aCPU, BOOL aRemove);
     STDMETHOD(OnRuntimeError)(BOOL fFatal, IN_BSTR id, IN_BSTR message);
     STDMETHOD(OnCanShowWindow)(BOOL *canShow);

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

@@ -30 +30 @@
  *   3) In the settings writer method, write the setting _only_ if the current settings
  *      version (stored in m->sv) is high enough. That is, for VirtualBox 3.2, write it
- *      only if (m->sv >= SettingsVersion_v1_10).
+ *      only if (m->sv >= SettingsVersion_v1_11).
  *
  *   4) In MachineConfigFile::bumpSettingsVersionIfNeeded(), check if the new setting has
@@ -82 +82 @@
 
 /** VirtualBox XML settings version number substring ("x.y")  */
-#define VBOX_XML_VERSION        "1.9"
+#define VBOX_XML_VERSION        "1.11"
 
 /** VirtualBox XML settings version platform substring */
@@ -282 +282 @@
                 else if (ulMinor == 10)
                     m->sv = SettingsVersion_v1_10;
-                else if (ulMinor > 10)
+                else if (ulMinor == 11)
+                    m->sv = SettingsVersion_v1_11;
+                else if (ulMinor > 11)
                     m->sv = SettingsVersion_Future;
             }
@@ -302 +304 @@
         // creating new settings file:
         m->strSettingsVersionFull = VBOX_XML_VERSION_FULL;
-        m->sv = SettingsVersion_v1_10;
+        m->sv = SettingsVersion_v1_11;
     }
 }
@@ -556 +558 @@
 
         case SettingsVersion_v1_10:
+            pcszVersion = "1.10";
+            m->sv = SettingsVersion_v1_10;
+            break;
+
+        case SettingsVersion_v1_11:
         case SettingsVersion_Future:                // can be set if this code runs on XML files that were created by a future version of VBox;
                                                     // in that case, downgrade to current version when writing since we can't write future versions...
-            pcszVersion = "1.10";
-            m->sv = SettingsVersion_v1_10;
+            pcszVersion = "1.11";
+            m->sv = SettingsVersion_v1_11;
             break;
 
@@ -1263 +1270 @@
           fPAE(false),
           cCPUs(1),
+          fCpuHotPlug(false),
           ulMemorySizeMB((uint32_t)-1),
           ulVRAMSizeMB(8),
@@ -1284 +1292 @@
     fPAE = true;
 #endif
+}
+
+/**
+ * Called from MachineConfigFile::readHardware() to read cpu information.
+ * @param elmCpuid
+ * @param ll
+ */
+void MachineConfigFile::readCpuTree(const xml::ElementNode &elmCpu,
+                                    CpuList &ll)
+{
+    xml::NodesLoop nl1(elmCpu, "Cpu");
+    const xml::ElementNode *pelmCpu;
+    while ((pelmCpu = nl1.forAllNodes()))
+    {
+        Cpu cpu;
+
+        if (!pelmCpu->getAttributeValue("id", cpu.ulId))
+            throw ConfigFileError(this, pelmCpu, N_("Required Cpu/@id attribute is missing"));
+
+        ll.push_back(cpu);
+    }
 }
 
@@ -1560 +1589 @@
             }
 
+            pelmHwChild->getAttributeValue("hotplug", hw.fCpuHotPlug);
+
             const xml::ElementNode *pelmCPUChild;
+            if (hw.fCpuHotPlug)
+            {
+                if ((pelmCPUChild = pelmHwChild->findChildElement("CpuTree")))
+                    readCpuTree(*pelmCPUChild, hw.llCpus);
+            }
+
             if ((pelmCPUChild = pelmHwChild->findChildElement("HardwareVirtEx")))
             {
@@ -2468 +2505 @@
         pelmCPU->createChild("SyntheticCpu")->setAttribute("enabled", hw.fSyntheticCpu);
     pelmCPU->setAttribute("count", hw.cCPUs);
+
+    if (m->sv >= SettingsVersion_v1_11)
+    {
+        pelmCPU->setAttribute("hotplug", hw.fCpuHotPlug);
+
+        xml::ElementNode *pelmCpuTree = NULL;
+        for (CpuList::const_iterator it = hw.llCpus.begin();
+             it != hw.llCpus.end();
+             ++it)
+        {
+            const Cpu &cpu = *it;
+
+            if (pelmCpuTree == NULL)
+                 pelmCpuTree = pelmCPU->createChild("CpuTree");
+
+            xml::ElementNode *pelmCpu = pelmCpuTree->createChild("Cpu");
+            pelmCpu->setAttribute("id", cpu.ulId);
+        }
+    }
+
     xml::ElementNode *pelmCpuIdTree = NULL;
     for (CpuIdLeafsList::const_iterator it = hw.llCpuIdLeafs.begin();
@@ -3081 +3138 @@
        )
         m->sv = SettingsVersion_v1_10;
+
+    // Version 1.11 is required for CPU hotplugging
+    if (   (m->sv < SettingsVersion_v1_11)
+        && (hardwareMachine.fCpuHotPlug)
+       )
+        m->sv = SettingsVersion_v1_11;
 }