ConsoleImpl.cpp revision c7a378ed2fbad681c0b674351d698ef20a368935
/* $Id$ */
/** @file
* VBox Console COM Class implementation
*/
/*
* Copyright (C) 2006-2011 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
/** @todo Move the TAP mess back into the driver! */
#if defined(RT_OS_WINDOWS)
#elif defined(RT_OS_LINUX)
# include <errno.h>
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
#elif defined(RT_OS_FREEBSD)
# include <errno.h>
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
#elif defined(RT_OS_SOLARIS)
# include <iprt/coredumper.h>
#endif
#include "ConsoleImpl.h"
#include "Global.h"
#include "VirtualBoxErrorInfoImpl.h"
#include "GuestImpl.h"
#include "KeyboardImpl.h"
#include "MouseImpl.h"
#include "DisplayImpl.h"
#include "MachineDebuggerImpl.h"
#include "USBDeviceImpl.h"
#include "RemoteUSBDeviceImpl.h"
#include "SharedFolderImpl.h"
#include "AudioSnifferInterface.h"
#include "ProgressCombinedImpl.h"
#include "ConsoleVRDPServer.h"
#include "VMMDev.h"
#include "package-generated.h"
#ifdef VBOX_WITH_EXTPACK
# include "ExtPackManagerImpl.h"
#endif
#include "BusAssignmentManager.h"
// generated header
#include "SchemaDefs.h"
#include "VBoxEvents.h"
#include "AutoCaller.h"
#include "Logging.h"
#include "VBox/com/ErrorInfo.h"
#include <iprt/buildconfig.h>
#ifdef VBOX_WITH_USB
#endif
#ifdef VBOX_WITH_GUEST_PROPS
#endif
#include <set>
#include <algorithm>
#include <memory> // for auto_ptr
#include <vector>
#include <typeinfo>
// VMTask and friends
////////////////////////////////////////////////////////////////////////////////
/**
* Task structure for asynchronous VM operations.
*
* Once created, the task structure adds itself as a Console caller. This means:
*
* 1. The user must check for #rc() before using the created structure
* (e.g. passing it as a thread function argument). If #rc() returns a
* failure, the Console object may not be used by the task (see
* Console::addCaller() for more details).
* 2. On successful initialization, the structure keeps the Console caller
* until destruction (to ensure Console remains in the Ready state and won't
* be accidentally uninitialized). Forgetting to delete the created task
* will lead to Console::uninit() stuck waiting for releasing all added
* callers.
*
* If \a aUsesVMPtr parameter is true, the task structure will also add itself
* as a Console::mpVM caller with the same meaning as above. See
* Console::addVMCaller() for more info.
*/
struct VMTask
{
bool aUsesVMPtr)
mVMCallerAdded(false)
{
return;
if (aUsesVMPtr)
{
mVMCallerAdded = true;
}
}
~VMTask()
{
if (mVMCallerAdded)
}
/** Releases the VM caller before destruction. Not normally necessary. */
void releaseVMCaller()
{
mVMCallerAdded = false;
}
private:
bool mVMCallerAdded : 1;
};
struct VMTakeSnapshotTask : public VMTask
{
false /* aUsesVMPtr */),
{}
bool fTakingSnapshotOnline;
};
struct VMPowerUpTask : public VMTask
{
false /* aUsesVMPtr */),
mStartPaused(false),
{}
bool mStartPaused;
/* array of progress objects for hard disk reset operations */
};
struct VMPowerDownTask : public VMTask
{
true /* aUsesVMPtr */)
{}
};
struct VMSaveTask : public VMTask
{
const Utf8Str &aSavedStateFile)
true /* aUsesVMPtr */),
{}
};
// Handler for global events
////////////////////////////////////////////////////////////////////////////////
class VmEventListener {
public:
{
}
virtual ~VmEventListener()
{
}
{
switch(aType)
{
{
if (id != interestedId)
break;
/* now we can operate with redirects */
break;
mConsole->onNATRedirectRuleChange(ulSlot, fRemove, proto, hostIp.raw(), hostPort, guestIp.raw(), guestPort);
}
break;
default:
AssertFailed();
}
return S_OK;
}
private:
};
// constructor / destructor
/////////////////////////////////////////////////////////////////////////////
: mSavedStateDataLoaded(false)
, mVMCallers(0)
, mVMDestroying(false)
, mVMPoweredOff(false)
, mVMIsAlreadyPoweringOff(false)
, mfSnapshotFolderSizeWarningShown(false)
, mfSnapshotFolderExt4WarningShown(false)
, mfSnapshotFolderDiskTypeShown(false)
, mVMStateChangeCallbackDisabled(false)
{
}
{}
{
LogFlowThisFunc(("\n"));
for (unsigned i = 0; i < RT_ELEMENTS(maStorageDevType); ++ i)
VMM2USERMETHODS *pVmm2UserMethods = (VMM2USERMETHODS *)RTMemAlloc(sizeof(*mpVmm2UserMethods) + sizeof(Console *));
if (!pVmm2UserMethods)
return E_OUTOFMEMORY;
return BaseFinalConstruct();
}
void Console::FinalRelease()
{
LogFlowThisFunc(("\n"));
uninit();
}
// public initializer/uninitializer for internal purposes only
/////////////////////////////////////////////////////////////////////////////
{
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
/* Cache essential properties and objects */
/* Create associated child COM objects */
// Event source may be needed by other children
#ifdef VBOX_WITH_EXTPACK
#endif
/* Grab global and machine shared folder lists */
/* Create other child objects */
mcAudioRefs = 0;
mcVRDPClients = 0;
mcGuestCredentialsProvided = false;
// VirtualBox 4.0: We no longer initialize the VMMDev instance here,
// which starts the HGCM thread. Instead, this is now done in the
// power-up thread when a VM is actually being powered up to avoid
// having HGCM threads all over the place every time a session is
// opened, even if that session will not run a VM.
// unconst(m_pVMMDev) = new VMMDev(this);
// AssertReturn(mVMMDev, E_FAIL);
/* VirtualBox events registration. */
{
mVmListener = new VmEventListenerImpl(this);
}
/* Confirm a successful initialization when it's the case */
#ifdef VBOX_WITH_EXTPACK
/* Let the extension packs have a go at things (hold no locks). */
#endif
return S_OK;
}
/**
* Uninitializes the Console object.
*/
{
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
{
LogFlowThisFunc(("Already uninitialized.\n"));
return;
}
if (mVmListener)
{
{
{
// XXX: for some reasons we're getting VBOX_E_OBJECT_NOT_FOUND
// here - investigate
//AssertComRC(rc);
}
}
mVmListener->Release();
mVmListener = 0;
}
/* power down the VM if necessary */
if (mpVM)
{
powerDown();
}
if (mVMZeroCallersSem != NIL_RTSEMEVENT)
{
}
if (mpVmm2UserMethods)
{
RTMemFree((void *)mpVmm2UserMethods);
}
if (mAudioSniffer)
{
delete mAudioSniffer;
}
// if the VM had a VMMDev with an HGCM thread, then remove that here
if (m_pVMMDev)
{
delete m_pVMMDev;
}
if (mBusMgr)
{
}
mUSBDevices.clear();
if (mVRDEServerInfo)
{
}
if (mDebugger)
{
}
if (mDisplay)
{
}
if (mMouse)
{
}
if (mKeyboard)
{
}
if (mGuest)
{
}
if (mConsoleVRDPServer)
{
delete mConsoleVRDPServer;
}
// we don't perform uninit() as it's possible that some pending event refers to this source
}
#ifdef VBOX_WITH_GUEST_PROPS
bool Console::enabledGuestPropertiesVRDP(void)
{
value.asOutParam());
{
if (value == "1")
{
return true;
}
}
return false;
}
void Console::updateGuestPropertiesVRDPLogon(uint32_t u32ClientId, const char *pszUser, const char *pszDomain)
{
if (!enabledGuestPropertiesVRDP())
{
return;
}
char szPropNm[256];
clientName.raw(),
bstrReadOnlyGuest.raw());
bstrReadOnlyGuest.raw());
bstrReadOnlyGuest.raw());
char szClientId[64];
bstrReadOnlyGuest.raw());
return;
}
{
if (!enabledGuestPropertiesVRDP())
return;
char szPropNm[256];
bstrReadOnlyGuest.raw());
bstrReadOnlyGuest.raw());
bstrReadOnlyGuest.raw());
char szClientId[64];
bstrReadOnlyGuest.raw());
return;
}
#endif /* VBOX_WITH_GUEST_PROPS */
#ifdef VBOX_WITH_EXTPACK
/**
* Used by VRDEServer and others to talke to the extension pack manager.
*
* @returns The extension pack manager.
*/
{
return mptrExtPackManager;
}
#endif
int Console::VRDPClientLogon(uint32_t u32ClientId, const char *pszUser, const char *pszPassword, const char *pszDomain)
{
AutoCaller autoCaller(this);
if (!autoCaller.isOk())
{
/* Console has been already uninitialized, deny request */
LogRel(("AUTH: Access denied (Console uninitialized).\n"));
return VERR_ACCESS_DENIED;
}
ULONG authTimeout = 0;
LogRel(("AUTH: User: [%s]. Domain: [%s]. Authentication type: [%s]\n",
"Null":
"External":
(authType == AuthType_Guest?
"Guest":
"INVALID"
)
)
));
switch (authType)
{
case AuthType_Null:
{
break;
}
case AuthType_External:
{
/* Call the external library. */
result = mConsoleVRDPServer->Authenticate(uuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId);
if (result != AuthResultDelegateToGuest)
{
break;
}
LogRel(("AUTH: Delegated to guest.\n"));
LogFlowFunc(("External auth asked for guest judgement\n"));
} /* pass through */
case AuthType_Guest:
{
// @todo r=dj locking required here for m_pVMMDev?
if ( (m_pVMMDev)
)
{
/* Issue the request to guest. Assume that the call does not require EMT. It should not. */
/* Ask the guest to judge these credentials. */
if (RT_SUCCESS(rc))
{
/* Wait for guest. */
if (RT_SUCCESS(rc))
{
switch (u32GuestFlags & (VMMDEV_CREDENTIALS_JUDGE_OK | VMMDEV_CREDENTIALS_JUDGE_DENY | VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT))
{
default:
}
}
else
{
}
}
else
{
}
}
if (authType == AuthType_External)
{
result = mConsoleVRDPServer->Authenticate(uuid, guestJudgement, pszUser, pszPassword, pszDomain, u32ClientId);
}
else
{
switch (guestJudgement)
{
case AuthGuestAccessGranted:
break;
default:
break;
}
}
} break;
default:
AssertFailed();
}
if (result != AuthResultAccessGranted)
{
/* Reject. */
LogRel(("AUTH: Access denied.\n"));
return VERR_ACCESS_DENIED;
}
LogRel(("AUTH: Access granted.\n"));
/* Multiconnection check must be made after authentication, so bad clients would not interfere with a good one. */
LogFlowFunc(("allowMultiConnection %d, reuseSingleConnection = %d, mcVRDPClients = %d, mu32SingleRDPClientId = %d\n", allowMultiConnection, reuseSingleConnection, mcVRDPClients, mu32SingleRDPClientId));
if (allowMultiConnection == FALSE)
{
/* Note: the 'mcVRDPClients' variable is incremented in ClientConnect callback, which is called when the client
* is successfully connected, that is after the ClientLogon callback. Therefore the mcVRDPClients
* value is 0 for first client.
*/
if (mcVRDPClients != 0)
{
/* There is a client already.
* If required drop the existing client connection and let the connecting one in.
*/
{
LogRel(("AUTH: Multiple connections are not enabled. Disconnecting existing client.\n"));
}
else
{
/* Reject. */
LogRel(("AUTH: Multiple connections are not enabled. Access denied.\n"));
return VERR_ACCESS_DENIED;
}
}
/* Save the connected client id. From now on it will be necessary to disconnect this one. */
}
#ifdef VBOX_WITH_GUEST_PROPS
#endif /* VBOX_WITH_GUEST_PROPS */
/* Check if the successfully verified credentials are to be sent to the guest. */
value.asOutParam());
{
/* Provide credentials only if there are no logged in users. */
LONG64 ul64Timestamp = 0;
{
/* And only if there are no connected clients. */
if (ASMAtomicCmpXchgBool(&mcGuestCredentialsProvided, true, false))
{
}
}
}
// @todo r=dj locking required here for m_pVMMDev?
&& m_pVMMDev)
{
}
return VINF_SUCCESS;
}
{
AutoCaller autoCaller(this);
if ( (u32Clients == 1)
)
{
true,
VRDP_EXPERIENCE_LEVEL_FULL); // @todo configurable
}
mDisplay->VideoAccelVRDP(true);
return;
}
{
AutoCaller autoCaller(this);
if ( (u32Clients == 0)
)
{
false,
0);
}
mDisplay->VideoAccelVRDP(false);
{
}
{
}
{
mcAudioRefs--;
if (mcAudioRefs <= 0)
{
if (mAudioSniffer)
{
if (port)
{
}
}
}
}
if (authType == AuthType_External)
#ifdef VBOX_WITH_GUEST_PROPS
#endif /* VBOX_WITH_GUEST_PROPS */
if (u32Clients == 0)
mcGuestCredentialsProvided = false;
return;
}
{
AutoCaller autoCaller(this);
LogFlowFunc(("mAudioSniffer %p, u32ClientId %d.\n",
++mcAudioRefs;
if (mcAudioRefs == 1)
{
if (mAudioSniffer)
{
if (port)
{
}
}
}
return;
}
{
AutoCaller autoCaller(this);
return;
}
{
AutoCaller autoCaller(this);
return;
}
//static
//static
{
switch (adapterType)
{
return "pcnet";
#ifdef VBOX_WITH_E1000
return "e1000";
#endif
#ifdef VBOX_WITH_VIRTIO
return "virtio-net";
#endif
default:
AssertFailed();
return "unknown";
}
return NULL;
}
/**
* Loads various console data stored in the saved state file.
* This method does validation of the state file and returns an error info
* when appropriate.
*
* The method does nothing if the machine is not in the Saved file or if
* console data from it has already been loaded.
*
* @note The caller must lock this object for writing.
*/
{
return S_OK;
return rc;
if (RT_SUCCESS(vrc))
{
{
if (RT_SUCCESS(vrc))
else if (vrc == VERR_SSM_UNIT_NOT_FOUND)
vrc = VINF_SUCCESS;
}
else
}
if (RT_FAILURE(vrc))
tr("The saved state file '%ls' is invalid (%Rrc). Delete the saved state and try again"),
mSavedStateDataLoaded = true;
return rc;
}
/**
* Callback handler to save various console data to the state file,
* called when the user saves the VM state.
*
* @param pvUser pointer to Console
*
* @note Locks the Console object for reading.
*/
//static
DECLCALLBACK(void)
{
LogFlowFunc(("\n"));
++ it)
{
// don't lock the folder because methods we access are const
}
return;
}
/**
* Callback handler to load various console data from the state file.
* Called when the VM is being restored from the saved state.
*
* @param pvUser pointer to Console
* @param uVersion Console unit version.
* Should match sSSMConsoleVer.
* @param uPass The data pass.
*
* @note Should locks the Console object for writing, if necessary.
*/
//static
DECLCALLBACK(int)
{
LogFlowFunc(("\n"));
return VERR_VERSION_MISMATCH;
/* Currently, nothing to do when we've been called from VMR3Load*. */
return SSMR3SkipToEndOfUnit(pSSM);
}
/**
* Method to load various console data from the state file.
* Called from #loadDataFromSavedState.
*
* @param pvUser pointer to Console
* @param u32Version Console unit version.
* Should match sSSMConsoleVer.
*
* @note Locks the Console object for writing.
*/
int
{
AutoCaller autoCaller(this);
{
bool writable = true;
bool autoMount = false;
delete[] buf;
delete[] buf;
if (u32Version > 0x00010000)
}
return VINF_SUCCESS;
}
#ifdef VBOX_WITH_GUEST_PROPS
// static
void *pvParms,
{
using namespace guestProp;
/*
* No locking, as this is purely a notification which does not make any
* changes to the object state.
*/
Log5(("Console::doGuestPropNotification: pCBData={.pcszName=%s, .pcszValue=%s, .pcszFlags=%s}\n",
int rc;
rc = VINF_SUCCESS;
else
{
LogFunc(("Console::doGuestPropNotification: hrc=%Rhrc pCBData={.pcszName=%s, .pcszValue=%s, .pcszFlags=%s}\n",
}
return rc;
}
{
using namespace guestProp;
/*
* Now things get slightly complicated. Due to a race with the guest adding
* properties, there is no good way to know how much to enlarge a buffer for
* the service to enumerate into. We choose a decent starting size and loop a
* few times, each time retrying with the size suggested by the service plus
* one Kb.
*/
int vrc = VERR_BUFFER_OVERFLOW;
{
try
{
}
catch(...)
{
return E_OUTOFMEMORY;
}
&parm[0]);
}
if (VERR_BUFFER_OVERFLOW == vrc)
return setError(E_UNEXPECTED,
tr("Temporary failure due to guest activity, please retry"));
/*
* Finally we have to unpack the data returned by the service into the safe
* arrays supplied by the caller. We start by counting the number of entries.
*/
const char *pszBuf
unsigned cEntries = 0;
/* The list is terminated by a zero-length string at the end of a set
* of four strings. */
{
/* We are counting sets of four strings. */
for (unsigned j = 0; j < 4; ++j)
++cEntries;
}
/*
* And now we create the COM safe arrays and fill them in.
*/
/* Rely on the service to have formated the data correctly. */
for (unsigned i = 0; i < cEntries; ++i)
{
}
return S_OK;
}
#endif /* VBOX_WITH_GUEST_PROPS */
// IConsole properties
/////////////////////////////////////////////////////////////////////////////
{
AutoCaller autoCaller(this);
/* mMachine is constant during life time, no need to lock */
/* callers expect to get a valid reference, better fail than crash them */
return E_FAIL;
return S_OK;
}
{
AutoCaller autoCaller(this);
/* we return our local state (since it's always the same as on the server) */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mGuest is constant during life time, no need to lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mKeyboard is constant during life time, no need to lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mMouse is constant during life time, no need to lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mDisplay is constant during life time, no need to lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* we need a write lock because of the lazy mDebugger initialization*/
/* check if we have to create the debugger object */
if (!mDebugger)
{
}
return S_OK;
}
{
AutoCaller autoCaller(this);
return S_OK;
}
STDMETHODIMP Console::COMGETTER(RemoteUSBDevices)(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices))
{
AutoCaller autoCaller(this);
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mDisplay is constant during life time, no need to lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* loadDataFromSavedState() needs a write lock */
/* Read console data stored in the saved state file (if not yet done) */
return S_OK;
}
{
AutoCaller autoCaller(this);
// no need to lock - lifetime constant
return S_OK;
}
STDMETHODIMP Console::COMGETTER(AttachedPciDevices)(ComSafeArrayOut(IPciDeviceAttachment *, aAttachments))
{
AutoCaller autoCaller(this);
return S_OK;
}
// IConsole methods
/////////////////////////////////////////////////////////////////////////////
{
}
{
}
{
AutoCaller autoCaller(this);
switch (mMachineState)
{
case MachineState_Running:
case MachineState_Paused:
case MachineState_Stuck:
break;
/* Try cancel the teleportation. */
case MachineState_Teleporting:
if (!mptrCancelableProgress.isNull())
{
break;
}
/* Try cancel the live snapshot. */
if (!mptrCancelableProgress.isNull())
{
break;
}
/* Try cancel the FT sync. */
if (!mptrCancelableProgress.isNull())
{
break;
}
return setError(VBOX_E_INVALID_VM_STATE, tr("Cannot power down at this point in a fault tolerant sync"));
/* extra nice error message for a common case */
case MachineState_Saved:
case MachineState_Stopping:
default:
return setError(VBOX_E_INVALID_VM_STATE,
tr("Invalid machine state: %s (must be Running, Paused or Stuck)"),
}
LogFlowThisFunc(("Initiating SHUTDOWN request...\n"));
/* memorize the current machine state */
bool fBeganPowerDown = false;
do
{
/*
* request a progress object from the server
* (this will set the machine state to Stopping on the server to block
* others from accessing this machine)
*/
break;
fBeganPowerDown = true;
/* sync the state with the server */
/* setup task object and thread to carry out the operation asynchronously */
"VMPowerDown");
if (RT_FAILURE(vrc))
{
break;
}
/* task is now owned by powerDownThread(), so release it */
/* pass the progress to the caller */
}
while (0);
{
/* preserve existing error info */
if (fBeganPowerDown)
{
/*
* cancel the requested power down procedure.
* This will reset the machine state to the state it had right
* before calling mControl->BeginPoweringDown().
*/
}
return rc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
/** @todo r=bird: This should be allowed on paused VMs as well. Later. */
)
return setInvalidMachineStateError();
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* leave the lock before a VMR3* call (EMT will call us back)! */
tr("Could not reset the machine (%Rrc)"),
vrc);
return rc;
}
{
return vrc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
)
return setInvalidMachineStateError();
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* Check if the CPU is present */
if (!fCpuAttached)
/* Check if the CPU is unlocked */
bool fLocked = true;
if (RT_SUCCESS(vrc))
{
/* Notify the guest if possible. */
if (RT_SUCCESS(vrc))
{
unsigned cTries = 100;
do
{
/* It will take some time until the event is processed in the guest. Wait */
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. */
}
}
/* If the CPU was unlocked we can detach it now. */
{
/*
* Call worker in EMT, that's faster and safer than doing everything
* using VMR3ReqCall.
*/
this, aCpu);
{
if (RT_SUCCESS(vrc))
}
if (RT_SUCCESS(vrc))
{
/* Detach it from the VM */
}
else
}
else
return rc;
}
{
/* nuke anything which might have been left behind. */
/*
* Attach the driver.
*/
return VINF_SUCCESS;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
/** @todo r=bird: This should be allowed on paused VMs as well. Later. */
)
return setInvalidMachineStateError();
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* Check if the CPU is present */
if (fCpuAttached)
/*
* 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.
*/
this, aCpu);
/* leave the lock before a VMR3* call (EMT will call us back)! */
{
if (RT_SUCCESS(vrc))
}
tr("Could not add CPU to the machine (%Rrc)"),
vrc);
if (RT_SUCCESS(vrc))
{
/* Notify the guest if possible. */
/** @todo warning if the guest doesn't support it */
}
return rc;
}
{
AutoCaller autoCaller(this);
switch (mMachineState)
{
case MachineState_Running:
case MachineState_Teleporting:
break;
case MachineState_Paused:
case MachineState_Saving:
default:
return setInvalidMachineStateError();
}
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
LogFlowThisFunc(("Sending PAUSE request...\n"));
/* leave the lock before a VMR3* call (EMT will call us back)! */
if (RT_FAILURE(vrc))
return hrc;
}
{
AutoCaller autoCaller(this);
if (mMachineState != MachineState_Paused)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot resume the machine as it is not paused (machine state: %s)"),
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
LogFlowThisFunc(("Sending RESUME request...\n"));
/* leave the lock before a VMR3* call (EMT will call us back)! */
#ifdef VBOX_WITH_EXTPACK
int vrc = mptrExtPackManager->callAllVmPowerOnHooks(this, mpVM); /** @todo called a few times too many... */
#else
int vrc = VINF_SUCCESS;
#endif
if (RT_SUCCESS(vrc))
{
else
}
tr("Could not resume the machine execution (%Rrc)"),
vrc);
return rc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
)
return setInvalidMachineStateError();
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
if (RT_SUCCESS(vrc))
{
}
tr("Controlled power off failed (%Rrc)"),
vrc);
return rc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
)
return setInvalidMachineStateError();
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
bool handled = false;
if (RT_SUCCESS(vrc))
{
}
tr("Checking if the ACPI Power Button event was handled by the guest OS failed (%Rrc)"),
vrc);
return rc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Invalid machine state %s when checking if the guest entered the ACPI mode)"),
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
bool entered = false;
if (RT_SUCCESS(vrc))
{
}
return S_OK;
}
{
AutoCaller autoCaller(this);
return setInvalidMachineStateError();
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
if (RT_SUCCESS(vrc))
{
}
tr("Sending sleep button event failed (%Rrc)"),
vrc);
return rc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
&& mMachineState != MachineState_Paused)
{
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot save the execution state as the machine is not running or paused (machine state: %s)"),
}
/* memorize the current machine state */
if (mMachineState == MachineState_Running)
{
}
bool fBeganSavingState = false;
bool fTaskCreationFailed = false;
do
{
/*
* request a saved state file path from the server
* (this will set the machine state to Saving on the server to block
* others from accessing this machine)
*/
fBeganSavingState = true;
/* sync the state with the server */
/* ensure the directory for the saved state file exists */
{
dir.stripFilename();
{
if (RT_FAILURE(vrc))
{
tr("Could not create a directory '%s' to save the state to (%Rrc)"),
break;
}
}
}
/* create a task object early to ensure mpVM protection is successful */
/*
* If we fail here it means a PowerDown() call happened on another
* thread while we were doing Pause() (which leaves the Console lock).
* We assign PowerDown() a higher precedence than SaveState(),
* therefore just return the error to the caller.
*/
{
fTaskCreationFailed = true;
break;
}
/* create a thread to wait until the VM state is saved */
0, RTTHREADTYPE_MAIN_WORKER, 0, "VMSave");
if (RT_FAILURE(vrc))
{
break;
}
/* task is now owned by saveStateThread(), so release it */
/* return the progress to the caller */
}
while (0);
{
/* preserve existing error info */
if (fBeganSavingState)
{
/*
* cancel the requested save state procedure.
* This will reset the machine state to the state it had right
* before calling mControl->BeginSavingState().
*/
}
if (lastMachineState == MachineState_Running)
{
/* restore the paused state if appropriate */
/* restore the running state if appropriate */
Resume();
}
else
}
return rc;
}
{
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_PoweredOff
)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot adopt the saved machine state as the machine is not in Powered Off, Teleported or Aborted state (machine state: %s)"),
}
{
AutoCaller autoCaller(this);
if (mMachineState != MachineState_Saved)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot delete the machine state as the machine is not in the saved state (machine state: %s)"),
/*
* Saved -> PoweredOff transition will be detected in the SessionMachine
* and properly handled.
*/
return rc;
}
/** read the value of a LEd. */
{
if (!pLed)
return 0;
return u32;
}
{
AutoCaller autoCaller(this);
/*
* Note: we don't lock the console object here because
* readAndClearLed() should be thread safe.
*/
/* Get LED array to read */
PDMLEDCORE SumLed = {0};
switch (aDeviceType)
{
case DeviceType_Floppy:
case DeviceType_DVD:
case DeviceType_HardDisk:
{
for (unsigned i = 0; i < RT_ELEMENTS(mapStorageLeds); ++i)
if (maStorageDevType[i] == aDeviceType)
break;
}
case DeviceType_Network:
{
for (unsigned i = 0; i < RT_ELEMENTS(mapNetworkLeds); ++i)
break;
}
case DeviceType_USB:
{
for (unsigned i = 0; i < RT_ELEMENTS(mapUSBLed); ++i)
break;
}
case DeviceType_SharedFolder:
{
break;
}
default:
return setError(E_INVALIDARG,
tr("Invalid device type: %d"),
}
/* Compose the result */
{
case 0:
break;
case PDMLED_READING:
break;
case PDMLED_WRITING:
case PDMLED_READING | PDMLED_WRITING:
break;
}
return S_OK;
}
{
#ifdef VBOX_WITH_USB
AutoCaller autoCaller(this);
if ( mMachineState != MachineState_Running
&& mMachineState != MachineState_Paused)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot attach a USB device to the machine which is not running or paused (machine state: %s)"),
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* Don't proceed unless we've found the usb controller. */
if (RT_FAILURE(vrc))
return setError(VBOX_E_PDM_ERROR,
tr("The virtual machine does not have a USB controller"));
/* leave the lock because the USB Proxy service may call us back
* (via onUSBDeviceAttach()) */
/* Request the device capture */
return rc;
#else /* !VBOX_WITH_USB */
return setError(VBOX_E_PDM_ERROR,
tr("The virtual machine does not have a USB controller"));
#endif /* !VBOX_WITH_USB */
}
{
#ifdef VBOX_WITH_USB
AutoCaller autoCaller(this);
/* Find it. */
{
{
pUSBDevice = *it;
break;
}
++ it;
}
if (!pUSBDevice)
return setError(E_INVALIDARG,
tr("USB device with UUID {%RTuuid} is not attached to this machine"),
/*
* Inform the USB device and USB proxy about what's cooking.
*/
return rc2;
/* Request the PDM to detach the USB device. */
{
/* leave the lock since we don't need it any more (note though that
* the USB Proxy service must not call us back here) */
/* Request the device release. Even if it fails, the device will
* remain as held by proxy, which is OK for us (the VM process). */
}
return rc;
#else /* !VBOX_WITH_USB */
return setError(VBOX_E_PDM_ERROR,
tr("The virtual machine does not have a USB controller"));
#endif /* !VBOX_WITH_USB */
}
{
#ifdef VBOX_WITH_USB
{
{
}
}
return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
tr("Could not find a USB device with address '%ls'"),
aAddress);
#else /* !VBOX_WITH_USB */
return E_NOTIMPL;
#endif /* !VBOX_WITH_USB */
}
{
#ifdef VBOX_WITH_USB
{
{
}
}
return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
tr("Could not find a USB device with uuid {%RTuuid}"),
#else /* !VBOX_WITH_USB */
return E_NOTIMPL;
#endif /* !VBOX_WITH_USB */
}
{
AutoCaller autoCaller(this);
/// @todo see @todo in AttachUSBDevice() about the Paused state
if (mMachineState == MachineState_Saved)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot create a transient shared folder on the machine in the saved state"));
if ( mMachineState != MachineState_PoweredOff
)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot create a transient shared folder on the machine while it is changing the state (machine state: %s)"),
return setError(VBOX_E_FILE_ERROR,
tr("Shared folder named '%ls' already exists"),
aName);
/* protect mpVM (if not NULL) */
if ( mpVM
&& autoVMCaller.isOk()
&& m_pVMMDev
&& m_pVMMDev->isShFlActive()
)
{
/* If the VM is online and supports shared folders, share this folder
* under the specified name. */
/* first, remove the machine or the global folder if there is any */
{
}
/* second, create the given folder */
}
/* notify console callbacks after the folder is added to the list */
return rc;
}
{
AutoCaller autoCaller(this);
/// @todo see @todo in AttachUSBDevice() about the Paused state
if (mMachineState == MachineState_Saved)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot remove a transient shared folder from the machine in the saved state"));
if ( mMachineState != MachineState_PoweredOff
)
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot remove a transient shared folder from the machine while it is changing the state (machine state: %s)"),
/* protect mpVM (if not NULL) */
if ( mpVM
&& autoVMCaller.isOk()
&& m_pVMMDev
&& m_pVMMDev->isShFlActive()
)
{
/* if the VM is online and supports shared folders, UNshare this
* folder. */
/* first, remove the given folder */
/* first, remove the machine or the global folder if there is any */
{
/* don't check rc here because we need to remove the console
* folder from the collection even on failure */
}
}
/* notify console callbacks after the folder is removed to the list */
return rc;
}
{
AutoCaller autoCaller(this);
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot take a snapshot of the machine while it is changing the state (machine state: %s)"),
/* prepare the progress object:
a) count the no. of hard disk attachments to get a matching no. of progress sub-operations */
return rc;
for (size_t i = 0;
i < aMediumAttachments.size();
++i)
{
return rc;
if (type == DeviceType_HardDisk)
{
++cOperations;
// assume that creating a diff image takes as long as saving a 1MB state
// (note, the same value must be used in SessionMachine::BeginTakingSnapshot() on the server!)
ulTotalOperationsWeight += 1;
}
}
// b) one extra sub-operations for online snapshots OR offline snapshots that have a saved state (needs to be copied)
bool fTakingSnapshotOnline = ((mMachineState == MachineState_Running) || (mMachineState == MachineState_Paused));
LogFlowFunc(("fTakingSnapshotOnline = %d, mMachineState = %d\n", fTakingSnapshotOnline, mMachineState));
)
{
++cOperations;
}
// finally, create the progress object
1); // ulFirstOperationWeight
return rc;
return E_OUTOFMEMORY;
try
{
/*
* If we fail here it means a PowerDown() call happened on another
* thread while we were doing Pause() (which leaves the Console lock).
* We assign PowerDown() a higher precedence than TakeSnapshot(),
* therefore just return the error to the caller.
*/
/* memorize the current machine state */
(void*)pTask,
0,
0,
"ConsoleTakeSnap");
tr("Could not create VMTakeSnap thread (%Rrc)"),
vrc);
}
{
delete pTask;
}
return rc;
}
{
AutoCaller autoCaller(this);
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot delete a snapshot of the machine while it is changing the state (machine state: %s)"),
return S_OK;
}
{
AutoCaller autoCaller(this);
return setError(VBOX_E_INVALID_VM_STATE,
tr("Cannot delete the current state of the running machine (machine state: %s)"),
return S_OK;
}
// Non-interface public methods
/////////////////////////////////////////////////////////////////////////////
/*static*/
{
false /* aWarning */,
true /* aLogIt */);
return rc;
}
{
return setError(VBOX_E_INVALID_VM_STATE,
tr("Invalid machine state: %s"),
}
/**
* @copydoc VirtualBox::handleUnexpectedExceptions
*/
/* static */
{
try
{
/* re-throw the current exception */
throw;
}
{
return setErrorStatic(E_FAIL,
tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
}
catch (...)
{
return setErrorStatic(E_FAIL,
tr("Unknown exception\n%s[%d] (%s)"),
}
/* should not get here */
AssertFailed();
return E_FAIL;
}
/* static */
{
switch (enmCtrlType)
{
return "lsilogicscsi";
return "buslogic";
return "lsilogicsas";
return "ahci";
return "piix3ide";
return "i82078";
default:
return NULL;
}
}
HRESULT Console::convertBusPortDeviceToLun(StorageBus_T enmBus, LONG port, LONG device, unsigned &uLun)
{
switch (enmBus)
{
case StorageBus_IDE:
case StorageBus_Floppy:
{
return S_OK;
}
case StorageBus_SATA:
case StorageBus_SCSI:
case StorageBus_SAS:
{
return S_OK;
}
default:
uLun = 0;
}
}
// private methods
/////////////////////////////////////////////////////////////////////////////
/**
* Process a medium change.
*
* @param aMediumAttachment The medium attachment with the new medium state.
* @param fForce Force medium chance, if it is locked or not.
*
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
/* We will need to release the write lock before calling EMT */
if (pMedium)
{
}
{
if (attCtrlName == ctrlName)
{
pStorageController = ctrls[i];
break;
}
}
if (pStorageController.isNull())
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/*
* 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.
*/
&pReq,
0 /* no wait! */,
7,
this,
fForce);
/* leave the lock before waiting for a result (EMT will call us back!) */
{
if (RT_SUCCESS(vrc))
}
if (RT_SUCCESS(vrc))
{
LogFlowThisFunc(("Returns S_OK\n"));
return S_OK;
}
if (!pMedium)
vrc);
}
/**
* Performs the medium change in EMT.
*
* @returns VBox status code.
*
* @param pThis Pointer to the Console object.
* @param pcszDevice The PDM device name.
* @param uInstance The PDM device instance.
* @param uLun The PDM LUN number of the drive.
* @param fHostDrive True if this is a host drive attachment.
* @param pszPath The path to the media / drive which is now being mounted / captured.
* If NULL no media or drive is attached and the LUN will be configured with
* the default block driver with no media. This will also be the state if
* mounting / capturing the specified media / drive fails.
* @param pszFormat Medium format string, usually "RAW".
* @param fPassthrough Enables using passthrough mode of the host DVD drive if applicable.
*
* @thread EMT
*/
const char *pcszDevice,
unsigned uInstance,
bool fUseHostIOCache,
bool fForce)
{
LogFlowFunc(("pConsole=%p uInstance=%u pszDevice=%p:{%s} enmBus=%u, aMediumAtt=%p, fForce=%d\n",
/*
* Suspend the VM first.
*
* The VM must not be running since it might have pending I/O to
* the drive which is being changed.
*/
bool fResume;
switch (enmVMState)
{
case VMSTATE_RESETTING:
case VMSTATE_RUNNING:
{
LogFlowFunc(("Suspending the VM...\n"));
/* disable the callback to prevent Console-level state change */
pConsole->mVMStateChangeCallbackDisabled = true;
pConsole->mVMStateChangeCallbackDisabled = false;
fResume = true;
break;
}
case VMSTATE_SUSPENDED:
case VMSTATE_CREATED:
case VMSTATE_OFF:
fResume = false;
break;
case VMSTATE_RUNNING_LS:
case VMSTATE_RUNNING_FT:
(enmVMState == VMSTATE_RUNNING_LS) ? Utf8Str(tr("Cannot change drive during live migration")) : Utf8Str(tr("Cannot change drive during fault tolerant syncing")),
false /*aWarning*/,
true /*aLogIt*/);
default:
}
/* Determine the base path for the device instance. */
int rc = VINF_SUCCESS;
int rcRet = VINF_SUCCESS;
false /* fSetupMerge */,
false /* fBuiltinIoCache */,
0 /* uMergeSource */,
0 /* uMergeTarget */,
NULL /* phrc */,
true /* fAttachDetach */,
fForce /* fForceUnmount */,
pVM,
NULL /* paLedDevType */);
/** @todo this dumps everything attached to this device instance, which
* is more than necessary. Dumping the changed LUN would be enough. */
/*
* Resume the VM if necessary.
*/
if (fResume)
{
LogFlowFunc(("Resuming the VM...\n"));
/* disable the callback to prevent Console-level state change */
pConsole->mVMStateChangeCallbackDisabled = true;
pConsole->mVMStateChangeCallbackDisabled = false;
if (RT_FAILURE(rc))
{
/* too bad, we failed. try to sync the console state with the VMM state */
}
/// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
// error (if any) will be hidden from the caller. For proper reporting
// of such multiple errors to the caller we need to enhance the
// IVirtualBoxError interface. For now, give the first error the higher
// priority.
if (RT_SUCCESS(rcRet))
}
return rcRet;
}
/**
* Called by IInternalSessionControl::OnNetworkAdapterChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger network change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* Get the properties we need from the adapter */
{
}
{
{
/*
* Find the adapter instance, get the config interface and update
* the link state.
*/
if (RT_SUCCESS(vrc))
{
if (pINetCfg)
{
Log(("Console::onNetworkAdapterChange: setting link state to %d\n",
}
{
if ( enmVMState == VMSTATE_RUNNING /** @todo LiveMigration: Forbid or deal correctly with the _LS variants */
|| enmVMState == VMSTATE_SUSPENDED)
{
{
}
{
}
}
}
}
else if (vrc == VERR_PDM_DEVICE_INSTANCE_NOT_FOUND)
{
}
else
if (RT_FAILURE(vrc))
}
}
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnNATEngineChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
int vrc = VINF_SUCCESS;
/* don't trigger nat engine change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
|| pNetworkAdapter.isNull())
goto done;
/*
* Find the adapter instance, get the config interface and update
* the link state.
*/
{
goto done;
}
if (RT_FAILURE(vrc))
{
goto done;
}
if ( RT_FAILURE(vrc)
{
goto done;
}
/* look down for PDMINETWORKNATCONFIG interface */
while (pBase)
{
if ((pNetNatCfg = (PPDMINETWORKNATCONFIG)pBase->pfnQueryInterface(pBase, PDMINETWORKNATCONFIG_IID)))
break;
}
if (!pNetNatCfg)
goto done;
if (RT_FAILURE(vrc))
}
done:
return rc;
}
/**
* Process a network adaptor change.
*
* @returns COM status code.
*
* @param pszDevice The PDM device name.
* @param uInstance The PDM device instance.
* @param uLun The PDM LUN number of the drive.
* @param aNetworkAdapter The network adapter whose attachment needs to be changed
*
* @note Locks this object for writing.
*/
unsigned uInstance,
unsigned uLun,
{
LogFlowThisFunc(("pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
AutoCaller autoCaller(this);
/* We will need to release the write lock before calling EMT */
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/*
* Call worker in EMT, that's faster and safer than doing everything
* using VM3ReqCall. Note that we separate VMR3ReqCall from VMR3ReqWait
* here to make requests from under the lock in order to serialize them.
*/
/* leave the lock before waiting for a result (EMT will call us back!) */
{
if (RT_SUCCESS(vrc))
}
if (RT_SUCCESS(vrc))
{
LogFlowThisFunc(("Returns S_OK\n"));
return S_OK;
}
tr("Could not change the network adaptor attachement type (%Rrc)"),
vrc);
}
/**
* Performs the Network Adaptor change in EMT.
*
* @returns VBox status code.
*
* @param pThis Pointer to the Console object.
* @param pszDevice The PDM device name.
* @param uInstance The PDM device instance.
* @param uLun The PDM LUN number of the drive.
* @param aNetworkAdapter The network adapter whose attachment needs to be changed
*
* @thread EMT
* @note Locks the Console object for writing.
*/
const char *pszDevice,
unsigned uInstance,
unsigned uLun,
{
LogFlowFunc(("pThis=%p pszDevice=%p:{%s} uInstance=%u uLun=%u aNetworkAdapter=%p\n",
&& (uLun == 0)
/* protect mpVM */
/*
* Suspend the VM first.
*
* The VM must not be running since it might have pending I/O to
* the drive which is being changed.
*/
bool fResume;
switch (enmVMState)
{
case VMSTATE_RESETTING:
case VMSTATE_RUNNING:
{
LogFlowFunc(("Suspending the VM...\n"));
/* disable the callback to prevent Console-level state change */
pThis->mVMStateChangeCallbackDisabled = true;
pThis->mVMStateChangeCallbackDisabled = false;
fResume = true;
break;
}
case VMSTATE_SUSPENDED:
case VMSTATE_CREATED:
case VMSTATE_OFF:
fResume = false;
break;
default:
}
int rc = VINF_SUCCESS;
int rcRet = VINF_SUCCESS;
true /*fAttachDetach*/, false /*fIgnoreConnectFailure*/);
/*
* Resume the VM if necessary.
*/
if (fResume)
{
LogFlowFunc(("Resuming the VM...\n"));
/* disable the callback to prevent Console-level state change */
pThis->mVMStateChangeCallbackDisabled = true;
pThis->mVMStateChangeCallbackDisabled = false;
if (RT_FAILURE(rc))
{
/* too bad, we failed. try to sync the console state with the VMM state */
}
/// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
// error (if any) will be hidden from the caller. For proper reporting
// of such multiple errors to the caller we need to enhance the
// IVirtualBoxError interface. For now, give the first error the higher
// priority.
if (RT_SUCCESS(rcRet))
}
return rcRet;
}
/**
* Called by IInternalSessionControl::OnSerialPortChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger serial port change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* nothing to do so far */
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnParallelPortChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger parallel port change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* nothing to do so far */
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnStorageControllerChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger storage controller change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* nothing to do so far */
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnMediumChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger medium change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnCPUChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger CPU change if the VM isn't running */
if (mpVM)
{
if (aRemove)
else
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnCpuExecutionCapChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger the CPU priority change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
if ( mMachineState == MachineState_Running
)
{
/* No need to call in the EMT thread. */
}
else
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnVRDEServerChange().
*
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
if ( mVRDEServer
&& ( mMachineState == MachineState_Running
)
)
{
if (aRestart)
{
/* VRDP server may call this Console object back from other threads (VRDP INPUT or OUTPUT). */
if (vrdpEnabled)
{
// If there was no VRDP server started the 'stop' will do nothing.
// However if a server was started and this notification was called,
// we have to restart the server.
else
}
else
{
}
}
}
/* notify console callbacks on success */
return rc;
}
/**
* @note Locks this object for reading.
*/
void Console::onVRDEServerInfoChange()
{
AutoCaller autoCaller(this);
}
/**
* Called by IInternalSessionControl::OnUSBControllerChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger USB controller change if the VM isn't running */
if (mpVM)
{
/// @todo implement one day.
// Anyway, if we want to query the machine's USB Controller we need
// to cache it to mUSBController in #init() (similar to mDVDDrive).
//
// bird: While the VM supports hot-plugging, I doubt any guest can
// handle it at this time... :-)
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* nothing to do so far */
}
/* notify console callbacks on success */
return rc;
}
/**
* Called by IInternalSessionControl::OnSharedFolderChange().
*
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
/* notify console callbacks on success */
{
fireSharedFolderChangedEvent(mEventSource, aGlobal ? (Scope_T)Scope_Global : (Scope_T)Scope_Machine);
}
return rc;
}
/**
* Called by IInternalSessionControl::OnUSBDeviceAttach() or locally by
* processRemoteUSBDevices() after IInternalMachineControl::RunUSBDeviceFilters()
* returns TRUE for a given remote USB device.
*
* @return S_OK if the device was attached to the VM.
* @return failure if not attached.
*
* @param aDevice
* The device in question.
* @param aMaskedIfs
* The interfaces to hide from the guest.
*
* @note Locks this object for writing.
*/
HRESULT Console::onUSBDeviceAttach(IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError, ULONG aMaskedIfs)
{
#ifdef VBOX_WITH_USB
AutoCaller autoCaller(this);
/* protect mpVM (we don't need error info, since it's a callback) */
AutoVMCallerQuiet autoVMCaller(this);
{
/* The VM may be no more operational when this message arrives
* (e.g. it may be Saving or Stopping or just PoweredOff) --
* autoVMCaller.rc() will return a failure in this case. */
LogFlowThisFunc(("Attach request ignored (mMachineState=%d).\n",
return autoVMCaller.rc();
}
{
/* notify callbacks about the error */
return S_OK;
}
/* Don't proceed unless there's at least one USB hub. */
if (!PDMR3USBHasHub(mpVM))
{
LogFlowThisFunc(("Attach request ignored (no USB controller).\n"));
return E_FAIL;
}
{
/* take the current error info */
/* the error must be a VirtualBoxErrorInfo instance */
{
/* notify callbacks about the error */
}
}
return rc;
#else /* !VBOX_WITH_USB */
return E_FAIL;
#endif /* !VBOX_WITH_USB */
}
/**
* Called by IInternalSessionControl::OnUSBDeviceDetach() and locally by
* processRemoteUSBDevices().
*
* @note Locks this object for writing.
*/
{
#ifdef VBOX_WITH_USB
AutoCaller autoCaller(this);
/* Find the device. */
{
{
pUSBDevice = *it;
break;
}
++ it;
}
if (pUSBDevice.isNull())
{
LogFlowThisFunc(("USB device not found.\n"));
/* The VM may be no more operational when this message arrives
* (e.g. it may be Saving or Stopping or just PoweredOff). Use
* AutoVMCaller to detect it -- AutoVMCaller::rc() will return a
* failure in this case. */
AutoVMCallerQuiet autoVMCaller(this);
{
LogFlowThisFunc(("Detach request ignored (mMachineState=%d).\n",
return autoVMCaller.rc();
}
/* the device must be in the list otherwise */
}
{
/* notify callback about an error */
return S_OK;
}
{
/* take the current error info */
/* the error must be a VirtualBoxErrorInfo instance */
{
/* notify callbacks about the error */
}
}
return rc;
#else /* !VBOX_WITH_USB */
return E_FAIL;
#endif /* !VBOX_WITH_USB */
}
/**
* Called by IInternalSessionControl::OnBandwidthGroupChange().
*
* @note Locks this object for writing.
*/
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
/* don't trigger the CPU priority change if the VM isn't running */
if (mpVM)
{
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
if ( mMachineState == MachineState_Running
)
{
/* No need to call in the EMT thread. */
{
int vrc;
}
}
else
}
/* notify console callbacks on success */
return rc;
}
/**
* @note Temporarily locks this object for writing.
*/
{
#ifndef VBOX_WITH_GUEST_PROPS
#else /* VBOX_WITH_GUEST_PROPS */
return E_INVALIDARG;
return E_POINTER;
return E_POINTER;
return E_POINTER;
AutoCaller autoCaller(this);
/* protect mpVM (if not NULL) */
AutoVMCallerWeak autoVMCaller(this);
/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
* autoVMCaller, so there is no need to hold a lock of this */
using namespace guestProp;
try
{
/* The + 1 is the null terminator */
4, &parm[0]);
/* The returned string should never be able to be greater than our buffer */
{
if (vrc != VERR_NOT_FOUND)
{
if (aTimestamp)
if (aFlags)
{
}
}
else
}
else
tr("The service call failed with the error %Rrc"),
vrc);
}
{
rc = E_OUTOFMEMORY;
}
return rc;
#endif /* VBOX_WITH_GUEST_PROPS */
}
/**
* @note Temporarily locks this object for writing.
*/
{
#ifndef VBOX_WITH_GUEST_PROPS
#else /* VBOX_WITH_GUEST_PROPS */
return E_INVALIDARG;
return E_INVALIDARG;
return E_INVALIDARG;
AutoCaller autoCaller(this);
/* protect mpVM (if not NULL) */
AutoVMCallerWeak autoVMCaller(this);
/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
* autoVMCaller, so there is no need to hold a lock of this */
using namespace guestProp;
int vrc = VINF_SUCCESS;
/* The + 1 is the null terminator */
{
/* The + 1 is the null terminator */
}
{
/* The + 1 is the null terminator */
}
3, &parm[0]);
2, &parm[0]);
else
1, &parm[0]);
if (RT_SUCCESS(vrc))
else
tr("The service call failed with the error %Rrc"),
vrc);
return rc;
#endif /* VBOX_WITH_GUEST_PROPS */
}
/**
* @note Temporarily locks this object for writing.
*/
{
#ifndef VBOX_WITH_GUEST_PROPS
#else /* VBOX_WITH_GUEST_PROPS */
return E_POINTER;
if (ComSafeArrayOutIsNull(aNames))
return E_POINTER;
if (ComSafeArrayOutIsNull(aValues))
return E_POINTER;
return E_POINTER;
if (ComSafeArrayOutIsNull(aFlags))
return E_POINTER;
AutoCaller autoCaller(this);
/* protect mpVM (if not NULL) */
AutoVMCallerWeak autoVMCaller(this);
/* Note: validity of mVMMDev which is bound to uninit() is guaranteed by
* autoVMCaller, so there is no need to hold a lock of this */
#endif /* VBOX_WITH_GUEST_PROPS */
}
/*
* Internal: helper function for connecting progress reporting
*/
{
if (pProgress)
}
/**
* @note Temporarily locks this object for writing.
*/
{
AutoCaller autoCaller(this);
int vrc = VINF_SUCCESS;
/* We will need to release the lock before doing the actual merge */
/* paranoia - we don't want merges to happen while teleporting etc. */
switch (mMachineState)
{
break;
default:
return setInvalidMachineStateError();
}
if (pMedium)
{
}
{
if (attCtrlName == ctrlName)
{
pStorageController = ctrls[i];
break;
}
}
if (pStorageController.isNull())
tr("Could not find storage controller '%ls'"),
attCtrlName.raw());
unsigned uLUN;
/* Pause the VM, as it might have pending IO on this drive */
{
LogFlowFunc(("Suspending the VM...\n"));
/* disable the callback to prevent Console-level state change */
mVMStateChangeCallbackDisabled = true;
mVMStateChangeCallbackDisabled = false;
}
13,
this,
pVM,
true /* fSetupMerge */,
&rc);
/* error handling is after resuming the VM */
{
LogFlowFunc(("Resuming the VM...\n"));
/* disable the callback to prevent Console-level state change */
mVMStateChangeCallbackDisabled = true;
mVMStateChangeCallbackDisabled = false;
if (RT_FAILURE(vrc2))
{
/* too bad, we failed. try to sync the console state with the VMM state */
}
}
if (RT_FAILURE(vrc))
return rc;
if (RT_SUCCESS(vrc))
{
if (pIBase)
{
if (!pIMedium)
}
else
}
/* Finally trigger the merge. */
if (RT_FAILURE(vrc))
/* Pause the VM, as it might have pending IO on this drive */
{
LogFlowFunc(("Suspending the VM...\n"));
/* disable the callback to prevent Console-level state change */
mVMStateChangeCallbackDisabled = true;
mVMStateChangeCallbackDisabled = false;
}
/* Update medium chain and state now, so that the VM can continue. */
13,
this,
pVM,
false /* fSetupMerge */,
0 /* uMergeSource */,
0 /* uMergeTarget */,
&rc);
/* error handling is after resuming the VM */
{
LogFlowFunc(("Resuming the VM...\n"));
/* disable the callback to prevent Console-level state change */
mVMStateChangeCallbackDisabled = true;
mVMStateChangeCallbackDisabled = false;
if (RT_FAILURE(vrc2))
{
/* too bad, we failed. try to sync the console state with the VMM state */
}
}
if (RT_FAILURE(vrc))
return rc;
return rc;
}
/**
* Gets called by Session::UpdateMachineState()
* (IInternalSessionControl::updateMachineState()).
*
* Must be called only in certain cases (see the implementation).
*
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
, E_FAIL);
return setMachineStateLocally(aMachineState);
}
/**
* @note Locks this object for writing.
*/
{
#if 0
LogFlowThisFunc(("fVisible=%d, fAlpha=%d, xHot = %d, yHot = %d, width=%d, height=%d, shape=%p\n",
#endif
AutoCaller autoCaller(this);
/* We need a write lock because we alter the cached callback data */
/* Save the callback arguments */
/* start with not valid */
else
fireMousePointerShapeChangedEvent(mEventSource, fVisible, fAlpha, xHot, yHot, width, height, ComSafeArrayInArg(pShape));
#if 0
#endif
}
/**
* @note Locks this object for writing.
*/
void Console::onMouseCapabilityChange(BOOL supportsAbsolute, BOOL supportsRelative, BOOL needsHostCursor)
{
LogFlowThisFunc(("supportsAbsolute=%d supportsRelative=%d needsHostCursor=%d\n",
AutoCaller autoCaller(this);
/* We need a write lock because we alter the cached callback data */
/* save the callback arguments */
}
/**
* @note Locks this object for reading.
*/
{
AutoCaller autoCaller(this);
}
/**
* @note Locks this object for reading.
*/
void Console::onAdditionsStateChange()
{
AutoCaller autoCaller(this);
}
/**
* @note Locks this object for reading.
* This notification only is for reporting an incompatible
* Guest Additions interface, *not* the Guest Additions version!
*
* The user will be notified inside the guest if new Guest
* Additions are available (via VBoxTray/VBoxClient).
*/
void Console::onAdditionsOutdated()
{
AutoCaller autoCaller(this);
}
/**
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
/* We need a write lock because we alter the cached callback data */
/* save the callback arguments */
}
/**
* @note Locks this object for reading.
*/
{
AutoCaller autoCaller(this);
}
/**
* @note Locks this object for reading.
*/
{
AutoCaller autoCaller(this);
}
/**
* @note Locks this object for reading.
*/
{
*aWinId = 0;
AutoCaller autoCaller(this);
if (aCheck)
{
//Assert(fDelivered);
if (fDelivered)
{
// bit clumsy
if (pCanShowEvent)
{
}
else
{
}
}
else
}
else
{
//Assert(fDelivered);
if (fDelivered)
{
if (pShowEvent)
{
}
else
}
}
return S_OK;
}
// private methods
////////////////////////////////////////////////////////////////////////////////
/**
* Increases the usage counter of the mpVM pointer. Guarantees that
* VMR3Destroy() will not be called on it at least until releaseVMCaller()
* is called.
*
* If this method returns a failure, the caller is not allowed to use mpVM
* and may return the failed result code to the upper level. This method sets
* the extended error info on failure if \a aQuiet is false.
*
* Setting \a aQuiet to true is useful for methods that don't want to return
* the failed result code to the caller when this method fails (e.g. need to
* silently check for the mpVM availability).
*
* When mpVM is NULL but \a aAllowNullVM is true, a corresponding error will be
* returned instead of asserting. Having it false is intended as a sanity check
* for methods that have checked mMachineState and expect mpVM *NOT* to be NULL.
*
* @param aQuiet true to suppress setting error info
* @param aAllowNullVM true to accept mpVM being NULL and return a failure
* (otherwise this method will assert if mpVM is NULL)
*
* @note Locks this object for writing.
*/
bool aAllowNullVM /* = false */)
{
AutoCaller autoCaller(this);
if (mVMDestroying)
{
/* powerDown() is waiting for all callers to finish */
tr("The virtual machine is being powered down"));
}
{
Assert(aAllowNullVM == true);
/* The machine is not powered up */
tr("The virtual machine is not powered up"));
}
++mVMCallers;
return S_OK;
}
/**
* Decreases the usage counter of the mpVM pointer. Must always complete
* the addVMCaller() call after the mpVM pointer is no more necessary.
*
* @note Locks this object for writing.
*/
void Console::releaseVMCaller()
{
AutoCaller autoCaller(this);
Assert(mVMCallers > 0);
--mVMCallers;
if (mVMCallers == 0 && mVMDestroying)
{
/* inform powerDown() there are no more callers */
}
}
/**
* Initialize the release logging facility. In case something
* goes wrong, there will be no release logging. Maybe in the future
* we can add some logic to use different file names in this case.
* Note that the logic must be in sync with Machine::DeleteSettings().
*/
{
/* make sure the Logs folder exists */
/*
* Age the old log files
* Rename .(n-1) to .(n), .(n-2) to .(n-1), ..., and the last log file to .1
* Overwrite target files in case they exist.
*/
if (cHistoryFiles)
{
for (int i = cHistoryFiles-1; i >= 0; i--)
{
for (unsigned int j = 0; j < RT_ELEMENTS(files); ++ j)
{
if (i > 0)
else
/* If the old file doesn't exist, delete the new file (if it
* exists) to provide correct rotation even if the sequence is
* broken */
}
}
}
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
#endif
if (RT_SUCCESS(vrc))
{
/* some introductory information */
char szTmp[256];
RTLogRelLogger(loggerRelease, 0, ~0U,
"VirtualBox %s r%u %s (%s %s) release log\n"
#ifdef VBOX_BLEEDING_EDGE
#endif
"Log opened %s\n",
ULONG cMbHostRam = 0;
ULONG cMbHostRamAvail = 0;
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
RTLogRelLogger(loggerRelease, 0, ~0U,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
RTProcSelf(),
/* register this logger as the release logger */
/* Explicitly flush the log in case of VBOX_RELEASE_LOG=buffered. */
}
else
tr("Failed to open release log (%s, %Rrc)"),
/* If we've made any directory changes, flush the directory to increase
the likelihood that the log file will be usable after a system panic.
Tip: Try 'export VBOX_RELEASE_LOG_FLAGS=flush' if the last bits of the log
is missing. Just don't have too high hopes for this to help. */
return hrc;
}
/**
* Common worker for PowerUp and PowerUpPaused.
*
* @returns COM status code.
*
* @param aProgress Where to return the progress object.
* @param aPaused true if PowerUpPaused called.
*/
{
AutoCaller autoCaller(this);
bool fBeganPoweringUp = false;
try
{
throw setError(VBOX_E_INVALID_VM_STATE,
tr("The virtual machine is already running or busy (machine state: %s)"),
/* test and clear the TeleporterEnabled property */
throw rc;
#if 0 /** @todo we should save it afterwards, but that isn't necessarily a good idea. Find a better place for this (VBoxSVC). */
if (fTeleporterEnabled)
{
throw rc;
}
#endif
/* test the FaultToleranceState property */
throw rc;
/* Create a progress object to track progress of this operation. Must
* be done as early as possible (together with BeginPowerUp()) as this
* is vital for communicating as much as possible early powerup
* failure information to the API caller */
if (mMachineState == MachineState_Saved)
else if (fTeleporterEnabled)
else if (fFaultToleranceSyncEnabled)
else
if ( mMachineState == MachineState_Saved
|| (!fTeleporterEnabled && !fFaultToleranceSyncEnabled))
progressDesc.raw(),
FALSE /* aCancelable */);
else
if (fTeleporterEnabled)
progressDesc.raw(),
TRUE /* aCancelable */,
3 /* cOperations */,
10 /* ulTotalOperationsWeight */,
1 /* ulFirstOperationWeight */,
NULL);
else
progressDesc.raw(),
TRUE /* aCancelable */,
3 /* cOperations */,
10 /* ulTotalOperationsWeight */,
1 /* ulFirstOperationWeight */,
NULL);
throw rc;
/* Tell VBoxSVC and Machine about the progress object so they can
LogFlowThisFunc(("Calling BeginPowerUp...\n"));
{
LogFlowThisFunc(("BeginPowerUp failed\n"));
throw rc;
}
fBeganPoweringUp = true;
/** @todo this code prevents starting a VM with unavailable bridged
* networking interface. The only benefit is a slightly better error
* message, which should be moved to the driver code. This is the
* only reason why I left the code in for now. The driver allows
* unavailable bridged networking interfaces in certain circumstances,
* and this is sabotaged by this check. The VM will initially have no
* network connectivity, but the user can fix this at runtime. */
#if 0
/* the network cards will undergo a quick consistency check */
++slot)
{
if (!enabled)
continue;
switch (netattach)
{
{
/* a valid host interface must have been set */
{
throw setError(VBOX_E_HOST_ERROR,
tr("VM cannot start because host interface networking requires a host interface name to be set"));
}
pHostInterface.asOutParam())))
{
throw setError(VBOX_E_HOST_ERROR,
tr("VM cannot start because the host interface '%ls' does not exist"),
}
break;
}
default:
break;
}
}
#endif // 0
/* Read console data stored in the saved state file (if not yet done) */
rc = loadDataFromSavedState();
throw rc;
/* Check all types of shared folders and compose a single list */
{
/* first, insert global folders */
/* second, insert machine folders */
/* third, insert console folders */
}
/*
* Saved VMs will have to prove that their saved states seem kosher.
*/
if (mMachineState == MachineState_Saved)
{
throw rc;
if (RT_FAILURE(vrc))
throw setError(VBOX_E_FILE_ERROR,
tr("VM cannot start because the saved state file '%ls' is invalid (%Rrc). Delete the saved state prior to starting the VM"),
}
LogFlowThisFunc(("Checking if canceled...\n"));
throw rc;
if (fCanceled)
{
LogFlowThisFunc(("Canceled in BeginPowerUp\n"));
}
LogFlowThisFunc(("Not canceled yet.\n"));
/* setup task object and thread to carry out the operation
* asynchronously */
if (mMachineState == MachineState_Saved)
/* Reset differencing hard disks for which autoReset is true,
* but only if the machine has no snapshots OR the current snapshot
* is an OFFLINE snapshot; otherwise we would reset the current
* differencing image of an ONLINE snapshot which contains the disk
* state of the machine while it was previously running, but without
* the corresponding machine state, which is equivalent to powering
* off a running machine and not good idea
*/
throw rc;
BOOL fCurrentSnapshotIsOnline = false;
if (pCurrentSnapshot)
{
throw rc;
}
if (!fCurrentSnapshotIsOnline)
{
LogFlowThisFunc(("Looking for immutable images to reset\n"));
throw rc;
for (size_t i = 0;
++i)
{
/** @todo later applies to floppies as well */
if (devType == DeviceType_HardDisk)
{
throw rc;
/* needs autoreset? */
throw rc;
if (autoReset)
{
throw rc;
/* save for later use on the powerup thread */
}
}
}
}
else
LogFlowThisFunc(("Machine has a current snapshot which is online, skipping immutable images reset\n"));
throw rc;
#ifdef RT_OS_SOLARIS
/* setup host core dumper for the VM */
HRESULT hrc = mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpEnabled").raw(), value.asOutParam());
{
mMachine->GetExtraData(Bstr("VBoxInternal2/CoreDumpReplaceSystemDump").raw(), coreDumpReplaceSys.asOutParam());
uint32_t fCoreFlags = 0;
if ( coreDumpReplaceSys.isEmpty() == false
{
}
if ( coreDumpLive.isEmpty() == false
{
}
if ( pszDumpDir
&& *pszDumpDir == '\0')
pszDumpDir = NULL;
int vrc;
if ( pszDumpDir
&& !RTDirExists(pszDumpDir))
{
/*
* Try create the directory.
*/
if (RT_FAILURE(vrc))
throw setError(E_FAIL, "Failed to setup CoreDumper. Couldn't create dump directory '%s' (%Rrc)\n", pszDumpDir, vrc);
}
if (RT_FAILURE(vrc))
else
LogRel(("CoreDumper setup successful. pszDumpDir=%s fFlags=%#x\n", pszDumpDir ? pszDumpDir : ".", fCoreFlags));
}
#endif
/* pass the progress object to the caller if requested */
if (aProgress)
{
{
/* there are no other operations to track, return the powerup
* progress only */
}
else
{
/* create a combined progress object */
progresses.end());
}
}
RTTHREADTYPE_MAIN_WORKER, 0, "VMPowerUp");
if (RT_FAILURE(vrc))
/* task is now owned by powerUpThread(), so release it */
/* finally, set the state: no right to fail in this method afterwards
* since we've already started the thread and it is now responsible for
* any error reporting and appropriate state change! */
if (mMachineState == MachineState_Saved)
else if (fTeleporterEnabled)
else if (enmFaultToleranceState == FaultToleranceState_Standby)
else
}
{
/* The progress object will fetch the current error info */
if (!pPowerupProgress.isNull())
/* Save the error info across the IPC below. Can't be done before the
* progress notification above, as saving the error info deletes it
* from the current context, and thus the progress object wouldn't be
* updated correctly. */
/* signal end of operation */
}
return rc;
}
/**
* Internal power off worker routine.
*
* This method may be called only at certain places with the following meaning
* as shown below:
*
* - if the machine state is either Running or Paused, a normal
* Console-initiated powerdown takes place (e.g. PowerDown());
* - if the machine state is Saving, saveStateThread() has successfully done its
* job;
* - if the machine state is Starting or Restoring, powerUpThread() has failed
* - if the machine state is Stopping, the VM has powered itself off (i.e. not
* as a result of the powerDown() call).
*
* Calling it in situations other than the above will cause unexpected behavior.
*
* Note that this method should be the only one that destroys mpVM and sets it
* to NULL.
*
* @param aProgress Progress object to run (may be NULL).
*
* @note Locks this object for writing.
*
* @note Never call this method from a thread that called addVMCaller() or
* instantiated an AutoVMCaller object; first call releaseVMCaller() or
* release(). Otherwise it will deadlock.
*/
{
AutoCaller autoCaller(this);
/* Total # of steps for the progress object. Must correspond to the
* number of "advance percent count" comments in this method! */
enum { StepCount = 7 };
/* current step */
int vrc = VINF_SUCCESS;
/* sanity */
Assert(mVMDestroying == false);
LogRel(("Console::powerDown(): A request to power off the VM has been issued (mMachineState=%s, InUninit=%d)\n",
/* Check if we need to power off the VM. In case of mVMPoweredOff=true, the
* VM has already powered itself off in vmstateChangeCallback() and is just
* notifying Console about that. In case of Starting or Restoring,
* powerUpThread() is calling us on failure, so the VM is already off at
* that point. */
if ( !mVMPoweredOff
&& ( mMachineState == MachineState_Starting
)
mVMPoweredOff = true;
/*
* Go to Stopping state if not already there.
*
* vmstateChangeCallback() needs it to set the state to Saved on
* VMSTATE_TERMINATED. In terms of protecting from inappropriate operations
* while leaving the lock below, Saving or Restoring should be fine too.
* Ditto for TeleportingPausedVM -> Teleported.
*/
if ( mMachineState != MachineState_Saving
)
/* ----------------------------------------------------------------------
* DONE with necessary state changes, perform the power down actions (it's
* safe to leave the object lock now if needed)
* ---------------------------------------------------------------------- */
/* Stop the VRDP server to prevent new clients connection while VM is being
* powered off. */
if (mConsoleVRDPServer)
{
LogFlowThisFunc(("Stopping VRDP server...\n"));
/* Leave the lock since EMT will call us back as addVMCaller()
* in updateDisplayData(). */
}
/* advance percent count */
if (aProgress)
/* ----------------------------------------------------------------------
* Now, wait for all mpVM callers to finish their work if there are still
* some on other threads. NO methods that need mpVM (or initiate other calls
* that need it) may be called after this point
* ---------------------------------------------------------------------- */
/* go to the destroying state to prevent from adding new callers */
mVMDestroying = true;
if (mVMCallers > 0)
{
/* lazy creation */
if (mVMZeroCallersSem == NIL_RTSEMEVENT)
LogFlowThisFunc(("Waiting for mpVM callers (%d) to drop to zero...\n",
mVMCallers));
}
/* advance percent count */
if (aProgress)
vrc = VINF_SUCCESS;
/*
* Power off the VM if not already done that.
* Leave the lock since EMT will call vmstateChangeCallback.
*
* Note that VMR3PowerOff() may fail here (invalid VMSTATE) if the
* VM-(guest-)initiated power off happened in parallel a ms before this
* call. So far, we let this error pop up on the user's side.
*/
if (!mVMPoweredOff)
{
LogFlowThisFunc(("Powering off the VM...\n"));
#ifdef VBOX_WITH_EXTPACK
#endif
}
/* advance percent count */
if (aProgress)
#ifdef VBOX_WITH_HGCM
/* Shutdown HGCM services before destroying the VM. */
if (m_pVMMDev)
{
LogFlowThisFunc(("Shutdown HGCM...\n"));
/* Leave the lock since EMT will call us back as addVMCaller() */
}
/* advance percent count */
if (aProgress)
#endif /* VBOX_WITH_HGCM */
LogFlowThisFunc(("Ready for VM destruction.\n"));
/* If we are called from Console::uninit(), then try to destroy the VM even
* on failure (this will most likely fail too, but what to do?..) */
{
/* If the machine has an USB controller, release all USB devices
* (symmetric to the code in captureUSBDevices()) */
bool fHasUSBController = false;
{
if (RT_SUCCESS(vrc))
{
fHasUSBController = true;
detachAllUSBDevices(false /* aDone */);
}
}
/* Now we've got to destroy the VM as well. (mpVM is not valid beyond
* this point). We leave the lock before calling VMR3Destroy() because
* it will result into calling destructors of drivers associated with
* Console children which may in turn try to lock Console (e.g. by
* instantiating SafeVMPtr to access mpVM). It's safe here because
* mVMDestroying is set which should prevent any activity. */
/* Set mpVM to NULL early just in case if some old code is not using
* addVMCaller()/releaseVMCaller(). */
LogFlowThisFunc(("Destroying the VM...\n"));
/* take the lock again */
/* advance percent count */
if (aProgress)
if (RT_SUCCESS(vrc))
{
LogFlowThisFunc(("Machine has been destroyed (mMachineState=%d)\n",
/* Note: the Console-level machine state change happens on the
* VMSTATE_TERMINATE state change in vmstateChangeCallback(). If
* powerDown() is called from EMT (i.e. from vmstateChangeCallback()
* on receiving VM-initiated VMSTATE_OFF), VMSTATE_TERMINATE hasn't
* occurred yet. This is okay, because mMachineState is already
* Stopping in this case, so any other attempt to call PowerDown()
* will be rejected. */
}
else
{
/* bad bad bad, but what to do? */
tr("Could not destroy the machine. (Error: %Rrc)"),
vrc);
}
/* Complete the detaching of the USB devices. */
if (fHasUSBController)
detachAllUSBDevices(true /* aDone */);
/* advance percent count */
if (aProgress)
}
else
{
tr("Could not power off the machine. (Error: %Rrc)"),
vrc);
}
/* Finished with destruction. Note that if something impossible happened and
* we've failed to destroy the VM, mVMDestroying will remain true and
* mMachineState will be something like Stopping, so most Console methods
* will return an error to the caller. */
mVMDestroying = false;
return rc;
}
/**
* @note Locks this object for writing.
*/
bool aUpdateServer /* = true */)
{
AutoCaller autoCaller(this);
if (mMachineState != aMachineState)
{
LogThisFunc(("machineState=%s -> %s aUpdateServer=%RTbool\n",
Global::stringifyMachineState(mMachineState), Global::stringifyMachineState(aMachineState), aUpdateServer));
/// @todo (dmik)
// possibly, we need to redo onStateChange() using the dedicated
// Event thread, like it is done in VirtualBox. This will make it
// much safer (no deadlocks possible if someone tries to use the
// console from the callback), however, listeners will lose the
// ability to synchronously react to state changes (is it really
// necessary??)
LogFlowThisFunc(("Doing onStateChange()...\n"));
LogFlowThisFunc(("Done onStateChange()\n"));
if (aUpdateServer)
{
/* Server notification MUST be done from under the lock; otherwise
* the machine state here and on the server might go out of sync
* which can lead to various unexpected results (like the machine
* state being >= MachineState_Running on the server, while the
* session state is already SessionState_Unlocked at the same time
* there).
*
* Cross-lock conditions should be carefully watched out: calling
* UpdateState we will require Machine and SessionMachine locks
* (remember that here we're holding the Console lock here, and also
* all locks that have been entered by the thread before calling
* this method).
*/
LogFlowThisFunc(("Doing mControl->UpdateState()...\n"));
}
}
return rc;
}
/**
* Searches for a shared folder with the given logical name
* in the collection of shared folders.
*
* @param aName logical name of the shared folder
* @param aSharedFolder where to return the found object
* @param aSetError whether to set the error info if the folder is
* not found
* @return
* S_OK when found or E_INVALIDARG when not found
*
* @note The caller must lock this object for writing.
*/
bool aSetError /* = false */)
{
/* sanity check */
{
return S_OK;
}
if (aSetError)
tr("Could not find a shared folder named '%ls'."),
aName);
return VBOX_E_FILE_ERROR;
}
/**
* Fetches the list of global or machine shared folders from the server.
*
* @param aGlobal true to fetch global folders.
*
* @note The caller must lock this object for writing.
*/
{
/* sanity check */
/* protect mpVM (if not NULL) */
&& autoVMCaller.isOk()
&& m_pVMMDev
&& m_pVMMDev->isShFlActive();
if (aGlobal)
{
/// @todo grab & process global folders when they are done
}
else
{
if (online)
{
mMachineSharedFolders.insert(std::make_pair(name, SharedFolderData(hostPath, writable, autoMount)));
/* send changes to HGCM if the VM is running */
/// @todo report errors as runtime warnings through VMSetError
if (online)
{
{
/* a new machine folder is added or
* the existing machine folder is changed */
; /* the console folder exists, nothing to do */
else
{
/* remove the old machine folder (when changed)
* or the global folder if any (when new) */
/* create the new machine folder */
autoMount));
}
}
/* forget the processed (or identical) folder */
}
}
/* process outdated (removed) folders */
/// @todo report errors as runtime warnings through VMSetError
if (online)
{
{
; /* the console folder exists, nothing to do */
else
{
/* remove the outdated machine folder */
/* create the global folder if there is any */
}
}
}
}
return rc;
}
/**
* Searches for a shared folder with the given name in the list of machine
* shared folders and then in the list of the global shared folders.
*
* @param aName Name of the folder to search for.
* @param aIt Where to store the pointer to the found folder.
* @return @c true if the folder was found and @c false otherwise.
*
* @note The caller must lock this object for reading.
*/
{
/* sanity check */
AssertReturn(isWriteLockOnCurrentThread(), false);
/* first, search machine folders */
return true;
/* second, search machine folders */
return true;
return false;
}
/**
* Calls the HGCM service to add a shared folder definition.
*
* @param aName Shared folder name.
* @param aHostPath Shared folder path.
*
* @note Must be called from under AutoVMCaller and when mpVM != NULL!
* @note Doesn't lock anything.
*/
{
/* sanity checks */
if (cbString >= UINT16_MAX)
if (cbString >= UINT16_MAX)
{
}
/*
* Auto-mount flag; is indicated by using the SHFL_CPARMS_ADD_MAPPING2
* define below. This shows the host service that we have supplied
* an additional parameter (auto-mount) and keeps the actual command
* backwards compatible.
*/
SHFL_CPARMS_ADD_MAPPING2, &parms[0]);
if (RT_FAILURE(vrc))
tr("Could not create a shared folder '%ls' mapped to '%ls' (%Rrc)"),
return S_OK;
}
/**
* Calls the HGCM service to remove the shared folder definition.
*
* @param aName Shared folder name.
*
* @note Must be called from under AutoVMCaller and when mpVM != NULL!
* @note Doesn't lock anything.
*/
{
/* sanity checks */
if (cbString >= UINT16_MAX)
1, &parms);
if (RT_FAILURE(vrc))
tr("Could not remove the shared folder '%ls' (%Rrc)"),
return S_OK;
}
/**
* VM state callback function. Called by the VMM
* using its state machine states.
*
* Primarily used to handle VM initiated power off, suspend and state saving,
* but also for doing termination completed work (VMSTATE_TERMINATE).
*
* In general this function is called in the context of the EMT.
*
* @param aVM The VM handle.
* @param aState The new state.
* @param aOldState The old state.
* @param aUser The user argument (pointer to the Console object).
*
* @note Locks the Console object for writing.
*/
void *aUser)
{
LogFlowFunc(("Changing state from %s to %s (aVM=%p)\n",
/* Note that we must let this method proceed even if Console::uninit() has
* been already called. In such case this VMSTATE change is a result of:
* 1) powerDown() called from uninit() itself, or
* 2) VM-(guest-)initiated power off. */
switch (aState)
{
/*
* The VM has terminated
*/
case VMSTATE_OFF:
{
break;
/* Do we still think that it is running? It may happen if this is a
*/
)
{
LogFlowFunc(("VM has powered itself off but Console still thinks it is running. Notifying.\n"));
/* prevent powerDown() from calling VMR3PowerOff() again */
that->mVMPoweredOff = true;
/*
* request a progress object from the server
* (this will set the machine state to Stopping on the server
* to block others from accessing this machine)
*/
/* sync the state with the server */
/* Setup task object and thread to carry out the operation
* asynchronously (if we call powerDown() right here but there
* is one or more mpVM callers (added with addVMCaller()) we'll
* deadlock).
*/
pProgress));
/* If creating a task failed, this can currently mean one of
* two: either Console::uninit() has been called just a ms
* before (so a powerDown() call is already on the way), or
* powerDown() itself is being already executed. Just do
* nothing.
*/
{
LogFlowFunc(("Console is already being uninitialized.\n"));
break;
}
"VMPowerDown");
/* task is now owned by powerDownThread(), so release it */
}
break;
}
/* The VM has been completely destroyed.
*
* Note: This state change can happen at two points:
* 1) At the end of VMR3Destroy() if it was not called from EMT.
* 2) At the end of vmR3EmulationThread if VMR3Destroy() was
* called by EMT.
*/
case VMSTATE_TERMINATED:
{
break;
/* Terminate host interface networking. If aVM is NULL, we've been
* manually called from powerUpThread() either before calling
* VMR3Create() or after VMR3Create() failed, so no need to touch
* networking.
*/
if (aVM)
/* From now on the machine is officially powered down or remains in
* the Saved state.
*/
switch (that->mMachineState)
{
default:
AssertFailed();
/* fall through */
case MachineState_Stopping:
/* successfully powered down */
break;
case MachineState_Saving:
/* successfully saved */
break;
case MachineState_Starting:
/* failed to start, but be patient: set back to PoweredOff
* (for similarity with the below) */
break;
case MachineState_Restoring:
/* failed to load the saved state file, but be patient: set
* back to Saved (to preserve the saved state file) */
break;
/* Teleportation failed or was canceled. Back to powered off. */
break;
/* Successfully teleported the VM. */
break;
/* Fault tolerant sync failed or was canceled. Back to powered off. */
break;
}
break;
}
case VMSTATE_SUSPENDED:
{
break;
switch (that->mMachineState)
{
case MachineState_Teleporting:
break;
break;
case MachineState_Saving:
case MachineState_Restoring:
case MachineState_Stopping:
/* The worker thread handles the transition. */
break;
default:
case MachineState_Running:
break;
case MachineState_Paused:
/* Nothing to do. */
break;
}
break;
}
case VMSTATE_SUSPENDED_LS:
case VMSTATE_SUSPENDED_EXT_LS:
{
break;
switch (that->mMachineState)
{
case MachineState_Teleporting:
break;
break;
case MachineState_Saving:
/* ignore */
break;
default:
AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(aOldState), VMR3GetStateName(aState) ));
break;
}
break;
}
case VMSTATE_RUNNING:
{
if ( aOldState == VMSTATE_POWERING_ON
|| aOldState == VMSTATE_RESUMING
|| aOldState == VMSTATE_RUNNING_FT)
{
break;
&& aOldState == VMSTATE_POWERING_ON)
)
&& aOldState == VMSTATE_RESUMING)
&& aOldState == VMSTATE_RUNNING_FT));
}
break;
}
case VMSTATE_RUNNING_LS:
("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(aOldState), VMR3GetStateName(aState) ));
break;
case VMSTATE_RUNNING_FT:
("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(aOldState), VMR3GetStateName(aState) ));
break;
case VMSTATE_FATAL_ERROR:
{
break;
/* Fatal errors are only for running VMs. */
/* Note! 'Pause' is used here in want of something better. There
* are currently only two places where fatal errors might be
* raised, so it is not worth adding a new externally
* visible state for this yet. */
break;
}
case VMSTATE_GURU_MEDITATION:
{
break;
/* Guru are only for running VMs */
break;
}
default: /* shut up gcc */
break;
}
}
#ifdef VBOX_WITH_USB
/**
* Sends a request to VMM to attach the given host device.
* After this method succeeds, the attached device will appear in the
* mUSBDevices collection.
*
* @param aHostDevice device to attach
*
* @note Synchronously calls EMT.
* @note Must be called from under this object's lock.
*/
{
/* still want a lock object because we need to leave it */
/*
* Get the address and the Uuid, and call the pfnCreateProxyDevice roothub
* method in EMT (using usbAttachCallback()).
*/
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
LogFlowThisFunc(("Proxying USB device '%s' {%RTuuid}...\n",
/* leave the lock before a VMR3* call (EMT will call us back)! */
/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */
/* restore the lock */
/* hrc is S_OK here */
if (RT_FAILURE(vrc))
{
LogWarningThisFunc(("Failed to create proxy device for '%s' {%RTuuid} (%Rrc)\n",
switch (vrc)
{
case VERR_VUSB_NO_PORTS:
tr("Failed to attach the USB device. (No available ports on the USB controller)."));
break;
tr("Not permitted to open the USB device, check usbfs options"));
break;
default:
tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"),
vrc);
break;
}
}
return hrc;
}
/**
* USB device attach callback used by AttachUSBDevice().
* Note that AttachUSBDevice() doesn't return until this callback is executed,
* so we don't use AutoCaller and don't care about reference counters of
* interface pointers passed in.
*
* @thread EMT
* @note Locks the console object for writing.
*/
//static
DECLCALLBACK(int)
Console::usbAttachCallback(Console *that, IUSBDevice *aHostDevice, PCRTUUID aUuid, bool aRemote, const char *aAddress, ULONG aMaskedIfs)
{
void *pvRemoteBackend = NULL;
if (aRemote)
{
pvRemoteBackend = that->consoleVRDPServer()->USBBackendRequestPointer(pRemoteUSBDevice->clientId(), &guid);
if (!pvRemoteBackend)
return VERR_INVALID_PARAMETER; /* The clientId is invalid then. */
}
if (RT_SUCCESS(vrc))
{
/* Create a OUSBDevice and add it to the device list */
/* notify callbacks */
}
return vrc;
}
/**
* Sends a request to VMM to detach the given host device. After this method
* succeeds, the detached device will disappear from the mUSBDevices
* collection.
*
* @param aIt Iterator pointing to the device to detach.
*
* @note Synchronously calls EMT.
* @note Must be called from under this object's lock.
*/
{
/* still want a lock object because we need to leave it */
/* protect mpVM */
AutoVMCaller autoVMCaller(this);
/* if the device is attached, then there must at least one USB hub. */
LogFlowThisFunc(("Detaching USB proxy device {%RTuuid}...\n",
/* leave the lock before a VMR3* call (EMT will call us back)! */
/** @todo just do everything here and only wrap the PDMR3Usb call. That'll offload some notification stuff from the EMT thread. */
return S_OK;
}
/**
* USB device detach callback used by DetachUSBDevice().
* Note that DetachUSBDevice() doesn't return until this callback is executed,
* so we don't use AutoCaller and don't care about reference counters of
* interface pointers passed in.
*
* @thread EMT
* @note Locks the console object for writing.
*/
//static
DECLCALLBACK(int)
{
/*
* If that was a remote device, release the backend pointer.
* The pointer was requested in usbAttachCallback.
*/
if (fRemote)
{
}
if (RT_SUCCESS(vrc))
{
/* Remove the device from the collection */
/* notify callbacks */
}
return vrc;
}
#endif /* VBOX_WITH_USB */
/**
* Helper function to handle host interface device creation and attachment.
*
* @param networkAdapter the network adapter which attachment should be reset
* @return COM status code
*
* @note The caller must lock this object for writing.
*
* @todo Move this back into the driver!
*/
{
LogFlowThisFunc(("\n"));
/* sanity check */
# ifdef VBOX_STRICT
/* paranoia */
# endif /* VBOX_STRICT */
# ifdef RT_OS_LINUX
/*
* Allocate a host interface device
*/
if (RT_SUCCESS(rcVBox))
{
/*
*/
/* The name of the TAP interface we are using */
if (tapDeviceName.isEmpty())
{
LogRel(("No TAP device name was supplied.\n"));
}
{
/* If we are using a static TAP device then try to open it. */
else
memcpy(IfReq.ifr_name, str.c_str(), sizeof(IfReq.ifr_name) - 1); /** @todo bitch about names which are too long... */
if (rcVBox != 0)
{
tr("Failed to open the host network interface %ls"),
tapDeviceName.raw());
}
}
{
/*
* Make it pollable.
*/
{
/*
* Here is the right place to communicate the TAP file descriptor and
* necessary.
*/
}
else
{
LogRel(("Configuration error: Failed to configure /dev/net/tun non blocking. Error: %s\n", strerror(iErr)));
tr("could not set up the host networking device for non blocking access: %s"),
}
}
}
else
{
switch (rcVBox)
{
case VERR_ACCESS_DENIED:
/* will be handled by our caller */
break;
default:
tr("Could not set up the host networking device: %Rrc"),
rcVBox);
break;
}
}
# elif defined(RT_OS_FREEBSD)
/*
*/
/* The name of the TAP interface we are using */
if (tapDeviceName.isEmpty())
{
LogRel(("No TAP device name was supplied.\n"));
}
/* If we are using a static TAP device then try to open it. */
else
if (RT_SUCCESS(rcVBox))
else
{
switch (rcVBox)
{
case VERR_ACCESS_DENIED:
/* will be handled by our caller */
break;
default:
tr("Failed to open the host network interface %ls"),
tapDeviceName.raw());
break;
}
}
# else
# error "huh?"
# endif
/* in case of failure, cleanup. */
{
LogRel(("General failure attaching to host interface\n"));
tr("General failure attaching to host interface"));
}
return rc;
}
/**
* Helper function to handle detachment from a host interface
*
* @param networkAdapter the network adapter which attachment should be reset
* @return COM status code
*
* @note The caller must lock this object for writing.
*
* @todo Move this back into the driver!
*/
{
/* sanity check */
LogFlowThisFunc(("\n"));
# ifdef VBOX_STRICT
/* paranoia */
# endif /* VBOX_STRICT */
/* is there an open TAP device? */
{
/*
* Close the file handle.
*/
bool isStatic = true;
{
/* If the name is empty, this is a dynamic TAP device, so close it now,
so that the termination script can remove the interface. Otherwise we still
need the FD to pass to the termination script. */
isStatic = false;
}
if (isStatic)
{
/* If we are using a static TAP device, we close it now, after having called the
termination script. */
}
/* the TAP device name and handle are no longer valid */
}
return rc;
}
#endif /* (RT_OS_LINUX || RT_OS_FREEBSD) && !VBOX_WITH_NETFLT */
/**
* Called at power down to terminate host interface networking.
*
* @note The caller must lock this object for writing.
*/
{
LogFlowThisFunc(("\n"));
/* sanity check */
/*
* host interface termination handling
*/
{
if (!enabled)
continue;
{
#endif /* (RT_OS_LINUX || RT_OS_FREEBSD) && !VBOX_WITH_NETFLT */
}
}
return rc;
}
/**
* Process callback handler for VMR3LoadFromFile, VMR3LoadFromStream, VMR3Save
* and VMR3Teleport.
*
* @param pVM The VM handle.
* @param uPercent Completion percentage (0-100).
* @param pvUser Pointer to an IProgress instance.
* @return VINF_SUCCESS.
*/
/*static*/
{
/* update the progress object */
if (pProgress)
return VINF_SUCCESS;
}
/**
* @copydoc FNVMATERROR
*
* @remarks Might be some tiny serialization concerns with access to the string
* object here...
*/
/*static*/ DECLCALLBACK(void)
{
/* We ignore RT_SRC_POS_DECL arguments to avoid confusion of end-users. */
/* Append to any the existing error message. */
if (pErrorText->length())
else
}
/**
* VM runtime error callback function.
* See VMSetRuntimeError for the detailed description of parameters.
*
* @param pVM The VM handle.
* @param pvUser The user argument.
* @param fFlags The action flags. See VMSETRTERR_FLAGS_*.
* @param pszErrorId Error ID string.
* @param pszFormat Error message format string.
* @param va Error message arguments.
* @thread EMT.
*/
/* static */ DECLCALLBACK(void)
const char *pszErrorId,
{
LogRel(("Console: VM runtime error: fatal=%RTbool, errorID=%s message=\"%s\"\n",
}
/**
* Captures USB devices that match filters of the VM.
* Called at VM startup.
*
* @param pVM The VM handle.
*
* @note The caller must lock this object for writing.
*/
{
LogFlowThisFunc(("\n"));
/* sanity check */
/* If the machine has an USB controller, ask the USB proxy service to
* capture devices */
if (RT_SUCCESS(vrc))
{
/* leave the lock before calling Host in VBoxSVC since Host may call
* us back from under its lock (e.g. onUSBDeviceAttach()) which would
* produce an inter-process dead-lock otherwise. */
}
else if ( vrc == VERR_PDM_DEVICE_NOT_FOUND
vrc = VINF_SUCCESS;
else
}
/**
* Detach all USB device which are attached to the VM for the
* purpose of clean up and such like.
*
* @note The caller must lock this object for writing.
*/
{
/* sanity check */
mUSBDevices.clear();
/* leave the lock before calling Host in VBoxSVC since Host may call
* us back from under its lock (e.g. onUSBDeviceAttach()) which would
* produce an inter-process dead-lock otherwise. */
}
/**
* @note Locks this object for writing.
*/
void Console::processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList)
{
LogFlowThisFunc(("u32ClientId = %d, pDevList=%p, cbDevList = %d\n", u32ClientId, pDevList, cbDevList));
AutoCaller autoCaller(this);
if (!autoCaller.isOk())
{
/* Console has been already uninitialized, deny request */
AssertMsgFailed(("Console is already uninitialized\n"));
LogFlowThisFunc(("Console is already uninitialized\n"));
return;
}
/*
* Mark all existing remote USB devices as dirty.
*/
++it)
{
}
/*
* Process the pDevList and add devices those are not already in the mRemoteUSBDevices list.
*/
/** @todo (sunlover) REMOTE_USB Strict validation of the pDevList. */
VRDEUSBDEVICEDESC *e = pDevList;
/* The cbDevList condition must be checked first, because the function can
* receive pDevList = NULL and cbDevList = 0 on client disconnect.
*/
{
LogFlowThisFunc(("vendor %04X, product %04X, name = %s\n",
bool fNewDevice = true;
++it)
{
{
/* The device is already in the list. */
fNewDevice = false;
break;
}
}
if (fNewDevice)
{
LogRel(("Remote USB: ++++ Vendor %04X. Product %04X. Name = [%s].\n",
/* Create the device object and add the new device to list. */
/* Check if the device is ok for current USB filters. */
ULONG fMaskedIfs = 0;
if (fMatched)
{
/// @todo (r=dmik) warning reporting subsystem
{
LogFlowThisFunc(("Device attached\n"));
pUSBDevice->captured(true);
}
}
}
{
LogWarningThisFunc(("cbDevList %d > oNext %d\n",
break;
}
}
/*
* Remove dirty devices, that is those which are not reported by the server anymore.
*/
for (;;)
{
{
{
pUSBDevice = *it;
break;
}
++ it;
}
if (!pUSBDevice)
{
break;
}
LogRel(("Remote USB: ---- Vendor %04X. Product %04X. Name = [%ls].\n",
/* Detach the device from VM. */
if (pUSBDevice->captured())
{
}
/* And remove it from the list. */
}
}
/**
* Progress cancelation callback for fault tolerance VM poweron
*/
static void faultToleranceProgressCancelCallback(void *pvUser)
{
if (pVM)
}
/**
* Thread function which starts the VM (also from saved state) and
* track progress.
*
* @param Thread The thread id.
* @param pvUser Pointer to a VMPowerUpTask structure.
* @return VINF_SUCCESS (ignored).
*
* @note Locks the Console object for writing.
*/
/*static*/
{
#if defined(RT_OS_WINDOWS)
{
/* initialize COM */
}
#endif
int vrc = VINF_SUCCESS;
/* Set up a build identifier so that it can be seen from core dumps what
* exact build was used to produce the core. */
static char saBuildID[40];
/* Note: no need to use addCaller() because VMPowerUpTask does that */
/* The lock is also used as a signal from the task initiator (which
* releases it only after RTThreadCreate()) that we can start the job */
/* sanity */
try
{
// Create the VMM device object, which starts the HGCM thread; do this only
// once for the console, for the pathological case that the same console
// object is used to power up a VM twice. VirtualBox 4.0: we now do that
// here instead of the Console constructor (see Console::init())
{
}
/* wait for auto reset ops to complete so that we can successfully lock
* the attached hard disks by calling LockMedia() below */
{
}
/*
* Lock attached media. This method will also check their accessibility.
* If we're a teleporter, we'll have to postpone this action so we can
* migrate between local processes.
*
* Note! The media will be unlocked automatically by
* SessionMachine::setMachineState() when the VM is powered down.
*/
if ( !task->mTeleporterEnabled
{
}
/* Create the VRDP server. In case of headless operation, this will
* also create the framebuffer, required at VM creation.
*/
/* Does VRDP server call Console from the other thread?
* Not sure (and can change), so leave the lock just in case.
*/
if (vrc == VERR_NET_ADDRESS_IN_USE)
{
LogRel(("VRDE: Warning: failed to launch VRDE server (%Rrc): '%s'\n",
}
else if (vrc == VINF_NOT_SUPPORTED)
{
/* This means that the VRDE is not installed. */
LogRel(("VRDE: VirtualBox Remote Desktop Extension is not available.\n"));
}
else if (RT_FAILURE(vrc))
{
/* Fail, if the server is installed but can't start. */
switch (vrc)
{
case VERR_FILE_NOT_FOUND:
{
/* VRDE library file is missing. */
break;
}
default:
vrc);
}
LogRel(("VRDE: Failed: (%Rrc), error message: '%s'\n",
}
/*
* Create the VM
*/
/*
* leave the lock since EMT will call Console. It's safe because
* mMachineState is either Starting or Restoring state here.
*/
&pVM);
/* Enable client connections to the server. */
if (RT_SUCCESS(vrc))
{
do
{
/*
*/
if (RT_FAILURE(vrc))
break;
/*
* Synchronize debugger settings
*/
if (machineDebugger)
/*
* Shared Folders
*/
{
/* Does the code below call Console from the other thread?
* Not sure, so leave the lock just in case. */
++it)
{
}
/* enter the lock again */
}
/*
* Capture USB devices.
*/
/* leave the lock before a lengthy operation */
/* Load saved state? */
{
LogFlowFunc(("Restoring saved state from '%s'...\n",
if (RT_SUCCESS(vrc))
{
if (task->mStartPaused)
/* done */
else
{
#ifdef VBOX_WITH_EXTPACK
#endif
if (RT_SUCCESS(vrc))
}
}
/* Power off in case we failed loading or resuming the VM */
if (RT_FAILURE(vrc))
{
#ifdef VBOX_WITH_EXTPACK
#endif
}
}
else if (task->mTeleporterEnabled)
{
/* -> ConsoleImplTeleporter.cpp */
bool fPowerOffOnFailure;
{
#ifdef VBOX_WITH_EXTPACK
#endif
}
}
{
/*
* Get the config.
*/
{
}
{
{
/* Power on the FT enabled VM. */
#ifdef VBOX_WITH_EXTPACK
#endif
if (RT_SUCCESS(vrc))
}
}
else
}
else if (task->mStartPaused)
/* done */
else
{
/* Power on the VM (i.e. start executing) */
#ifdef VBOX_WITH_EXTPACK
#endif
if (RT_SUCCESS(vrc))
}
/* enter the lock again */
}
while (0);
/* On failure, destroy the VM */
{
/* preserve existing error info */
/* powerDown() will call VMR3Destroy() and do all necessary
* cleanup (VRDP, USB devices) */
}
else
{
/*
* Deregister the VMSetError callback. This is necessary as the
* pfnVMAtError() function passed to VMR3Create() is supposed to
* be sticky but our error callback isn't.
*/
/** @todo register another VMSetError callback? */
}
}
else
{
/*
* If VMR3Create() failed it has released the VM memory.
*/
}
{
/* If VMR3Create() or one of the other calls in this function fail,
* an appropriate error message has been set in task->mErrorMsg.
* However since that happens via a callback, the rc status code in
* this function is not updated.
*/
{
/* If the error message is not set but we've got a failure,
* convert the VBox status code into a meaningful error message.
* This becomes unused once all the sources of errors set the
* appropriate error message themselves.
*/
vrc);
}
/* Set the error message as the COM error.
* Progress::notifyComplete() will pick it up later. */
}
}
)
{
*
* 1) we failed before VMR3Create() was called;
* 2) VMR3Create() failed.
*
* In both cases, there is no need to call powerDown(), but we still
* need to go back to the PoweredOff/Saved state. Reuse
* vmstateChangeCallback() for that purpose.
*/
/* preserve existing error info */
pConsole);
}
/*
* Evaluate the final result. Note that the appropriate mMachineState value
* is already set by vmstateChangeCallback() in all cases.
*/
/* leave the lock, don't need it any more */
{
/* Notify the progress object of the success */
}
else
{
/* The progress object will fetch the current error info */
}
/* Notify VBoxSVC and any waiting openRemoteSession progress object. */
#if defined(RT_OS_WINDOWS)
/* uninitialize COM */
#endif
return VINF_SUCCESS;
}
/**
* Reconfigures a medium attachment (part of taking or deleting an online snapshot).
*
* @param pConsole Reference to the console object.
* @param pVM The VM handle.
* @param lInstance The instance of the controller.
* @param pcszDevice The name of the controller type.
* @param enmBus The storage bus type of the controller.
* @param fSetupMerge Whether to set up a medium merge
* @param uMergeSource Merge source image index
* @param uMergeTarget Merge target image index
* @param aMediumAtt The medium attachment.
* @param aMachineState The current machine state.
* @param phrc Where to store com error - only valid if we return VERR_GENERAL_FAILURE.
* @return VBox status code.
*/
/* static */
const char *pcszDevice,
unsigned uInstance,
bool fUseHostIOCache,
bool fBuiltinIoCache,
bool fSetupMerge,
unsigned uMergeSource,
unsigned uMergeTarget,
{
int rc;
#define RC_CHECK() do { if (RT_FAILURE(rc)) { AssertMsgFailed(("rc=%Rrc\n", rc)); return rc; } } while (0)
#define H() do { if (FAILED(hrc)) { AssertMsgFailed(("hrc=%Rhrc (%#x)\n", hrc, hrc)); *phrc = hrc; return VERR_GENERAL_FAILURE; } } while (0)
/* Ignore attachments other than hard disks, since at the moment they are
* not subject to snapshotting in general. */
if (lType != DeviceType_HardDisk)
return VINF_SUCCESS;
/* Determine the base path for the device instance. */
/* Update the device instance configuration. */
phrc,
true /* fAttachDetach */,
false /* fForceUnmount */,
pVM,
NULL /* paLedDevType */);
/** @todo this dumps everything attached to this device instance, which
* is more than necessary. Dumping the changed LUN would be enough. */
RC_CHECK();
#undef H
LogFlowFunc(("Returns success\n"));
return VINF_SUCCESS;
}
/**
* Progress cancelation callback employed by Console::fntTakeSnapshotWorker.
*/
static void takesnapshotProgressCancelCallback(void *pvUser)
{
}
/**
* Worker thread created by Console::TakeSnapshot.
* @param Thread The current thread (ignored).
* @param pvUser The task.
* @return VINF_SUCCESS (ignored).
*/
/*static*/
{
// taking a snapshot consists of the following:
// 1) creating a diff image for each virtual hard disk, into which write operations go after
// the snapshot has been created (done in VBoxSVC, in SessionMachine::BeginTakingSnapshot)
// 2) creating a Snapshot object with the state of the machine (hardware + storage,
// done in VBoxSVC, also in SessionMachine::BeginTakingSnapshot)
// 3) saving the state of the virtual machine (here, in the VM process, if the machine is online)
bool fBeganTakingSnapshot = false;
bool fSuspenededBySave = false;
{
return autoCaller.rc();
}
try
{
/* STEP 1 + 2:
* request creating the diff images on the server and create the snapshot object
* (this will set the machine state to Saving on the server to block
* others from accessing this machine)
*/
throw rc;
fBeganTakingSnapshot = true;
/*
* state file is non-null only when the VM is paused
* (i.e. creating a snapshot online)
*/
if (!f)
/* sync the state with the server */
else
// STEP 3: save the VM state (if online)
if (pTask->fTakingSnapshotOnline)
{
LogFlowFunc(("VMR3Save...\n"));
true /*fContinueAfterwards*/,
if (RT_FAILURE(vrc))
throw setErrorStatic(E_FAIL,
tr("Failed to save the machine state to '%s' (%Rrc)"),
// STEP 4: reattach hard disks
LogFlowFunc(("Reattaching new differencing hard disks...\n"));
1); // operation weight, same as computed when setting up progress object
throw rc;
for (size_t i = 0;
++i)
{
/*
* We can't pass a storage controller object directly
* (g++ complains about not being able to pass non POD types through '...')
* so we have to query needed values here and pass them.
*/
throw rc;
throw rc;
throw rc;
throw rc;
throw rc;
throw rc;
throw rc;
/*
* don't leave the lock since reconfigureMediumAttachment
* isn't going to need the Console lock.
*/
13,
that,
false /* fSetupMerge */,
0 /* uMergeSource */,
0 /* uMergeTarget */,
atts[i],
&rc);
if (RT_FAILURE(vrc))
throw rc;
}
}
/*
* finalize the requested snapshot object.
* This will reset the machine state to the state it had right
* before calling mControl->BeginTakingSnapshot().
*/
// do not throw rc here because we can't call EndTakingSnapshot() twice
LogFlowFunc(("EndTakingSnapshot -> %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
}
{
/* preserve existing error info */
if (fBeganTakingSnapshot)
LogFunc(("Caught %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
}
/*
* Fix up the machine state.
*
* For live snapshots we do all the work, for the two other variations we
* just update the local copy.
*/
{
if (!pTask->fTakingSnapshotOnline)
{
{
LogFlowFunc(("VMR3Resume...\n"));
if (RT_FAILURE(vrc))
{
}
}
else
}
else
{
/** @todo this could probably be made more generic and reused elsewhere. */
/* paranoid cleanup on for a failed online snapshot. */
switch (enmVMState)
{
case VMSTATE_RUNNING:
case VMSTATE_RUNNING_LS:
case VMSTATE_DEBUGGING:
case VMSTATE_DEBUGGING_LS:
case VMSTATE_POWERING_OFF:
case VMSTATE_POWERING_OFF_LS:
case VMSTATE_RESETTING:
case VMSTATE_RESETTING_LS:
break;
case VMSTATE_GURU_MEDITATION:
break;
case VMSTATE_FATAL_ERROR:
case VMSTATE_FATAL_ERROR_LS:
else
break;
default:
case VMSTATE_SUSPENDED:
case VMSTATE_SUSPENDED_LS:
case VMSTATE_SUSPENDING:
case VMSTATE_SUSPENDING_LS:
if (fSuspenededBySave)
{
LogFlowFunc(("VMR3Resume (on failure)...\n"));
if (RT_FAILURE(vrc))
}
else
break;
}
}
}
/*else: somebody else has change the state... Leave it. */
/* check the remote state to see that we got it right. */
delete pTask;
return VINF_SUCCESS;
}
/**
* Thread for executing the saved state operation.
*
* @param Thread The thread handle.
* @param pvUser Pointer to a VMSaveTask structure.
* @return VINF_SUCCESS (ignored).
*
* @note Locks the Console object for writing.
*/
/*static*/
{
bool fSuspenededBySave;
false, /*fContinueAfterwards*/
if (RT_FAILURE(vrc))
{
}
/* lock the console once we're going to access it */
/* synchronize the state with the server */
{
/*
* The machine has been successfully saved, so power it down
* (vmstateChangeCallback() will set state to Saved on success).
* Note: we release the task's VM caller, otherwise it will
* deadlock.
*/
task->releaseVMCaller();
}
/*
* Finalize the requested save state procedure. In case of failure it will
* reset the machine state to the state it had right before calling
* mControl->BeginSavingState(). This must be the last thing because it
* will set the progress to completed, and that means that the frontend
* can immediately uninit the associated console object.
*/
return VINF_SUCCESS;
}
/**
* Thread for powering down the Console.
*
* @param Thread The thread handle.
* @param pvUser Pointer to the VMTask structure.
* @return VINF_SUCCESS (ignored).
*
* @note Locks the Console object for writing.
*/
/*static*/
{
/* Note: no need to use addCaller() to protect Console because VMTask does
* that */
/* wait until the method tat started us returns */
/* release VM caller to avoid the powerDown() deadlock */
task->releaseVMCaller();
/* complete the operation */
return VINF_SUCCESS;
}
/**
* @interface_method_impl{VMM2USERMETHODS,pfnSaveState}
*/
/*static*/
{
/*
* For now, just call SaveState. We should probably try notify the GUI so
* it can pop up a progress object and stuff.
*/
}
/**
* The Main status driver instance data.
*/
typedef struct DRVMAINSTATUS
{
/** The LED connectors. */
/** Pointer to the LED ports interface above us. */
/** Pointer to the array of LED pointers. */
/** The unit number corresponding to the first entry in the LED array. */
/** The unit number corresponding to the last entry in the LED array.
* (The size of the LED array is iLastLUN - iFirstLUN + 1.) */
/**
* Notification about a unit which have been changed.
*
* The driver must discard any pointers to data owned by
* the unit and requery it.
*
* @param pInterface Pointer to the interface structure containing the called function pointer.
* @param iLUN The unit number.
*/
{
{
if (RT_FAILURE(rc))
}
}
/**
* @interface_method_impl{PDMIBASE,pfnQueryInterface}
*/
{
return NULL;
}
/**
* Destruct a status driver instance.
*
* @returns VBox status.
* @param pDrvIns The driver instance data.
*/
{
{
while (iLed-- > 0)
}
}
/**
* Construct a status driver instance.
*
* @copydoc FNPDMDRVCONSTRUCT
*/
{
/*
* Validate configuration.
*/
("Configuration error: Not possible to attach anything to this driver!\n"),
/*
* Data.
*/
/*
* Read config.
*/
if (RT_FAILURE(rc))
{
return rc;
}
if (rc == VERR_CFGM_VALUE_NOT_FOUND)
else if (RT_FAILURE(rc))
{
return rc;
}
if (rc == VERR_CFGM_VALUE_NOT_FOUND)
else if (RT_FAILURE(rc))
{
return rc;
}
{
AssertMsgFailed(("Configuration error: Invalid unit range %u-%u\n", pData->iFirstLUN, pData->iLastLUN));
return VERR_GENERAL_FAILURE;
}
/*
* query the LEDs we want.
*/
return VINF_SUCCESS;
}
/**
* Keyboard driver registration record.
*/
{
/* u32Version */
/* szName */
"MainStatus",
/* szRCMod */
"",
/* szR0Mod */
"",
/* pszDescription */
"Main status driver (Main as in the API).",
/* fFlags */
/* fClass. */
/* cMaxInstances */
~0,
/* cbInstance */
sizeof(DRVMAINSTATUS),
/* pfnConstruct */
/* pfnDestruct */
/* pfnRelocate */
NULL,
/* pfnIOCtl */
NULL,
/* pfnPowerOn */
NULL,
/* pfnReset */
NULL,
/* pfnSuspend */
NULL,
/* pfnResume */
NULL,
/* pfnAttach */
NULL,
/* pfnDetach */
NULL,
/* pfnPowerOff */
NULL,
/* pfnSoftReset */
NULL,
/* u32EndVersion */
};
/* vi: set tabstop=4 shiftwidth=4 expandtab: */