VirtualBoxImpl.cpp revision e64031e20c39650a7bc902a3e1aba613b9415dee
/* $Id$ */
/** @file
* Implementation of IVirtualBox in VBoxSVC.
*/
/*
* Copyright (C) 2006-2010 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.
*/
#include <iprt/buildconfig.h>
#include "VBox/com/EventQueue.h"
#include <VBox/settings.h>
#include <package-generated.h>
#include <algorithm>
#include <set>
#include <vector>
#include <memory> // for auto_ptr
#include <typeinfo>
#include "VirtualBoxImpl.h"
#include "Global.h"
#include "MachineImpl.h"
#include "MediumImpl.h"
#include "SharedFolderImpl.h"
#include "ProgressImpl.h"
#include "HostImpl.h"
#include "USBControllerImpl.h"
#include "SystemPropertiesImpl.h"
#include "GuestOSTypeImpl.h"
#include "DHCPServerRunner.h"
#include "DHCPServerImpl.h"
#ifdef VBOX_WITH_RESOURCE_USAGE_API
#include "PerformanceImpl.h"
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
#include "AutoCaller.h"
#include "Logging.h"
#include "objectslist.h"
#ifdef RT_OS_WINDOWS
#endif
////////////////////////////////////////////////////////////////////////////////
//
// Definitions
//
////////////////////////////////////////////////////////////////////////////////
#define VBOX_GLOBAL_SETTINGS_FILE "VirtualBox.xml"
////////////////////////////////////////////////////////////////////////////////
//
// Global variables
//
////////////////////////////////////////////////////////////////////////////////
// static
// static
// static
////////////////////////////////////////////////////////////////////////////////
//
// CallbackEvent class
//
////////////////////////////////////////////////////////////////////////////////
/**
* Abstract callback event class to asynchronously call VirtualBox callbacks
* on a dedicated event thread. Subclasses reimplement #handleCallback()
* to call appropriate IVirtualBoxCallback methods depending on the event
* to be dispatched.
*
* @note The VirtualBox instance passed to the constructor is strongly
* referenced, so that the VirtualBox singleton won't be released until the
* event gets handled by the event thread.
*/
{
public:
{
}
void *handler();
private:
/*
* Note that this is a weak ref -- the CallbackEvent handler thread
* is bound to the lifetime of the VirtualBox instance, so it's safe.
*/
};
////////////////////////////////////////////////////////////////////////////////
//
// VirtualBox private member data definition
//
////////////////////////////////////////////////////////////////////////////////
#if defined(RT_OS_WINDOWS)
#define UPDATEREQARG NULL
#define UPDATEREQTYPE HANDLE
#define UPDATEREQARG NIL_RTSEMEVENT
#define UPDATEREQTYPE RTSEMEVENT
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
#define UPDATEREQARG
#define UPDATEREQTYPE RTSEMEVENT
#else
# error "Port me!"
#endif
/**
* Main VirtualBox data structure.
* @note |const| members are persistent during lifetime so can be accessed
* without locking.
*/
struct VirtualBox::Data
{
Data()
: pMainConfigFile(NULL),
{}
~Data()
{
if (pMainConfigFile)
{
delete pMainConfigFile;
}
};
// const data members not requiring locking
const Utf8Str strHomeDir;
// VirtualBox main settings file
const Utf8Str strSettingsFilePath;
// const objects not requiring locking
#ifdef VBOX_WITH_RESOURCE_USAGE_API
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
// Each of the following lists use a particular lock handle that protects the
// list as a whole. As opposed to version 3.1 and earlier, these lists no
// longer need the main VirtualBox object lock, but only the respective list
// lock. In each case, the locking order is defined that the list must be
// requested before object locks of members of the lists (see the order definitions
// in AutoLock.h; e.g. LOCKCLASS_LISTOFMACHINES before LOCKCLASS_MACHINEOBJECT).
// All the media lists are protected by the following locking handle:
// the hard disks map is an additional map sorted by UUID for quick lookup
// and contains ALL hard disks (base and differencing); it is protected by
// the same lock as the other media lists above
// list of pending machine renames (also protected by media tree lock;
// see VirtualBox::rememberMachineNameChangeForMedia())
struct PendingMachineRename
{
};
// the following are data for the client watcher thread
const UPDATEREQTYPE updateReq;
const RTTHREAD threadClientWatcher;
// the following are data for the async event thread
const RTTHREAD threadAsyncEvent;
EventQueue * const pAsyncEventQ;
};
// constructor / destructor
/////////////////////////////////////////////////////////////////////////////
{}
VirtualBox::~VirtualBox()
{}
{
LogFlowThisFunc(("\n"));
return init();
}
void VirtualBox::FinalRelease()
{
LogFlowThisFunc(("\n"));
uninit();
}
// public initializer/uninitializer for internal purposes only
/////////////////////////////////////////////////////////////////////////////
/**
* Initializes the VirtualBox object.
*
* @return COM result code
*/
{
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
/* Locking this object for writing during init sounds a bit paradoxical,
* but in the current locking mess this avoids that some code gets a
* read lock and later calls code which wants the same write lock. */
// allocate our instance data
m = new Data;
LogFlow(("===========================================================\n"));
if (sPackageType.isEmpty())
/* Get the VirtualBox home directory. */
{
char szHomeDir[RTPATH_MAX];
if (RT_FAILURE(vrc))
tr("Could not create the VirtualBox home directory '%s' (%Rrc)"),
}
/* compose the VirtualBox.xml file name */
m->strHomeDir.raw(),
bool fCreate = false;
try
{
// load and parse VirtualBox.xml; this will throw on XML or logic errors
try
{
}
catch (xml::EIPRTFailure &e)
{
// this is thrown by the XML backend if the RTOpen() call fails;
// only if the main settings file does not exist, create it,
// if there's something more serious, then do fail!
if (e.rc() == VERR_FILE_NOT_FOUND)
fCreate = true;
else
throw;
}
if (fCreate)
#ifdef VBOX_WITH_RESOURCE_USAGE_API
/* create the performance collector object BEFORE host */
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
/* create the host object early, machines will need it */
/* create the system properties object, someone may need it too */
/* guest OS type objects, needed by machines */
{
{
}
}
/* all registered media, needed by machines */
throw rc;
/* machines */
throw rc;
#ifdef DEBUG
LogFlowThisFunc(("Dumping media backreferences\n"));
#endif
/* net services */
++it)
{
}
}
{
/* we assume that error info is set by the thrower */
}
catch (...)
{
}
{
/* start the client watcher thread */
#if defined(RT_OS_WINDOWS)
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
#else
# error "Port me!"
#endif
(void *)this,
0,
"Watcher");
if (RT_FAILURE(vrc))
}
{
try
{
/* start the async event handler thread */
&unconst(m->pAsyncEventQ),
0,
"EventHandler");
/* wait until the thread sets m->pAsyncEventQ */
}
{
}
}
/* Confirm a successful initialization when it's the case */
LogFlow(("===========================================================\n"));
return rc;
}
{
++it)
{
{
&uuid);
return rc;
}
}
return S_OK;
}
{
++it)
{
NULL, // parent
xmlHD); // XML data; this recurses to processes the children
}
++it)
{
}
++it)
{
}
return S_OK;
}
void VirtualBox::uninit()
{
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
LogFlow(("===========================================================\n"));
/* tell all our child objects we've been uninitialized */
m->ollMachines.uninitAll();
m->ollFloppyImages.uninitAll();
m->ollDVDImages.uninitAll();
m->ollHardDisks.uninitAll();
m->ollDHCPServers.uninitAll();
m->mapProgressOperations.clear();
m->ollGuestOSTypes.uninitAll();
/* Note that we release singleton children after we've all other children.
* In some cases this is important because these other children may use
* some resources of the singletons which would prevent them from
* uninitializing (as for example, mSystemProperties which owns
* MediumFormat objects which Medium objects refer to) */
if (m->pSystemProperties)
{
m->pSystemProperties->uninit();
}
if (m->pHost)
{
}
#ifdef VBOX_WITH_RESOURCE_USAGE_API
if (m->pPerformanceCollector)
{
m->pPerformanceCollector->uninit();
}
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
LogFlowThisFunc(("Releasing callbacks...\n"));
if (m->llCallbacks.size())
{
/* release all callbacks */
LogWarningFunc(("%d unregistered callbacks!\n",
m->llCallbacks.size()));
m->llCallbacks.clear();
}
LogFlowThisFunc(("Terminating the async event handler...\n"));
if (m->threadAsyncEvent != NIL_RTTHREAD)
{
/* signal to exit the event loop */
{
/*
* Wait for thread termination (only if we've successfully posted
* a NULL event!)
*/
if (RT_FAILURE(vrc))
LogWarningFunc(("RTThreadWait(%RTthrd) -> %Rrc\n",
m->threadAsyncEvent, vrc));
}
else
{
AssertMsgFailed(("postEvent(NULL) failed\n"));
}
}
LogFlowThisFunc(("Terminating the client watcher...\n"));
if (m->threadClientWatcher != NIL_RTTHREAD)
{
/* signal the client watcher thread */
/* wait for the termination */
}
m->llProcesses.clear();
#if defined(RT_OS_WINDOWS)
{
::CloseHandle(m->updateReq);
}
if (m->updateReq != NIL_RTSEMEVENT)
{
}
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
if (m->updateReq != NIL_RTSEMEVENT)
{
}
#else
# error "Port me!"
#endif
// clean up our instance data
delete m;
/* Unload hard disk plugin backends. */
VDShutdown();
LogFlow(("===========================================================\n"));
}
// IVirtualBox properties
/////////////////////////////////////////////////////////////////////////////
{
AutoCaller autoCaller(this);
return S_OK;
}
{
AutoCaller autoCaller(this);
return S_OK;
}
{
AutoCaller autoCaller(this);
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mHomeDir is const and doesn't need a lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mCfgFile.mName is const and doesn't need a lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mHost is const, no need to lock */
return S_OK;
}
{
AutoCaller autoCaller(this);
/* mSystemProperties is const, no need to lock */
return S_OK;
}
{
return E_POINTER;
AutoCaller autoCaller(this);
return S_OK;
}
{
return E_POINTER;
AutoCaller autoCaller(this);
return S_OK;
}
{
return E_POINTER;
AutoCaller autoCaller(this);
return S_OK;
}
{
return E_POINTER;
AutoCaller autoCaller(this);
return S_OK;
}
{
AutoCaller autoCaller(this);
/* protect mProgressOperations */
return S_OK;
}
{
AutoCaller autoCaller(this);
return S_OK;
}
{
#ifndef RT_OS_WINDOWS
#endif /* RT_OS_WINDOWS */
AutoCaller autoCaller(this);
}
{
#ifdef VBOX_WITH_RESOURCE_USAGE_API
AutoCaller autoCaller(this);
/* mPerformanceCollector is const, no need to lock */
return S_OK;
#else /* !VBOX_WITH_RESOURCE_USAGE_API */
#endif /* !VBOX_WITH_RESOURCE_USAGE_API */
}
{
return E_POINTER;
AutoCaller autoCaller(this);
return S_OK;
}
{
AutoCaller autoCaller(this);
static const struct {
const char* fileName;
const char* url;
} firmwareDesc[] = {
{
/* compiled-in firmware */
},
{
},
{
},
{
}
};
{
continue;
/* compiled-in firmware */
{
break;
}
int rc;
firmwareDesc[i].fileName);
{
if (aFile)
break;
}
char pszVBoxPath[RTPATH_MAX];
firmwareDesc[i].fileName);
{
if (aFile)
break;
}
/** @todo: account for version in the URL */
/* Assume single record per firmware type */
break;
}
return S_OK;
}
// IVirtualBox methods
/////////////////////////////////////////////////////////////////////////////
/** @note Locks mSystemProperties object for reading. */
{
LogFlowThisFunc(("aName=\"%ls\",aOsTypeId =\"%ls\",aBaseFolder=\"%ls\"\n", aName, aOsTypeId, aBaseFolder));
/** @todo tighten checks on aId? */
AutoCaller autoCaller(this);
/* Compose the settings file name using the following scheme:
*
* <base_folder>/<machine_name>/<machine_name>.xml
*
* If a non-null and non-empty base folder is specified, the default
* machine folder will be used as a base folder.
*/
if (strSettingsFile.isEmpty())
/* we use the non-full folder value below to keep the path relative */
aName);
/* create a new object */
/* Create UUID if an empty one was specified. */
/* initialize the machine object */
id,
TRUE /* aNameSync */);
{
/* set the return value */
}
return rc;
}
{
/** @todo tighten checks on aId? */
AutoCaller autoCaller(this);
/* append the default extension if none */
/* create a new object */
/* Create UUID if an empty one was specified. */
/* initialize the machine object */
id,
FALSE /* aOverride */,
FALSE /* aNameSync */);
{
/* set the return value */
}
return rc;
}
{
AutoCaller autoCaller(this);
/* create a new object */
{
/* initialize the machine object */
NULL); /* const Guid *aId */
{
/* set the return value */
}
}
return rc;
}
/** @note Locks objects! */
{
AutoCaller autoCaller(this);
/* We can safely cast child to Machine * here because only Machine
* implementations of IMachine can be among our children. */
/* fire an event */
return rc;
}
/** @note Locks objects! */
{
AutoCaller autoCaller(this);
/* the below will set *aMachine to NULL if machine is null */
return rc;
}
/** @note Locks this object for reading, then some machine objects for reading. */
{
AutoCaller autoCaller(this);
/* start with not found */
++it)
{
/* skip inaccessible machines */
{
{
break;
}
}
}
/* this will set (*machine) to NULL if machineObj is null */
? S_OK
return rc;
}
/** @note Locks objects! */
{
return E_INVALIDARG;
AutoCaller autoCaller(this);
// find machine from the given ID
// trySetRegistered needs VirtualBox object write lock
/* remove from the collection of registered machines */
/* save the global registry */
rc = saveSettings();
/* return the unregistered machine to the caller */
/* fire an event */
return rc;
}
{
AutoCaller autoCaller(this);
/* we don't access non-const data members so no need to lock */
bool fNeedsSaveSettings = false;
if (fNeedsSaveSettings)
{
saveSettings();
}
return rc;
}
{
AutoCaller autoCaller(this);
/* we don't access non-const data members so no need to lock */
if (aSetImageId)
{
}
if (aSetParentId)
parentId);
{
bool fNeedsSaveSettings = false;
{
}
/* Note that it's important to call uninit() on failure to register
* because the differencing hard disk would have been already associated
* with the parent and this association needs to be broken. */
else
if (fNeedsSaveSettings)
{
saveSettings();
}
}
return rc;
}
{
AutoCaller autoCaller(this);
/* the below will set *aHardDisk to NULL if hardDisk is null */
return rc;
}
{
AutoCaller autoCaller(this);
/* the below will set *aHardDisk to NULL if hardDisk is null */
return rc;
}
/** @note Doesn't lock anything. */
{
AutoCaller autoCaller(this);
/* generate an UUID if not specified */
{
bool fNeedsSaveSettings = false;
if (fNeedsSaveSettings)
{
saveSettings();
}
}
return rc;
}
/** @note Locks objects! */
{
AutoCaller autoCaller(this);
/* the below will set *aDVDImage to NULL if image is null */
return rc;
}
/** @note Locks objects! */
{
AutoCaller autoCaller(this);
/* the below will set *aDVDImage to NULL if dvd is null */
return rc;
}
/** @note Doesn't lock anything. */
{
AutoCaller autoCaller(this);
/* generate an UUID if not specified */
rc = image->init(this, aLocation, Medium::OpenReadWrite, DeviceType_Floppy, true, id, false, Guid());
{
bool fNeedsSaveSettings = false;
if (fNeedsSaveSettings)
{
saveSettings();
}
}
return rc;
}
/** @note Locks objects! */
{
AutoCaller autoCaller(this);
/* the below will set *aFloppyImage to NULL if image is null */
return rc;
}
/** @note Locks objects! */
{
AutoCaller autoCaller(this);
/* the below will set *aFloppyImage to NULL if img is null */
return rc;
}
/** @note Locks this object for reading. */
{
/* Old ID to new ID conversion table. See r39691 for a source */
static const wchar_t *kOldNewIDs[] =
{
L"unknown", L"Other",
L"win31", L"Windows31",
L"win95", L"Windows95",
L"win98", L"Windows98",
L"winme", L"WindowsMe",
L"winnt4", L"WindowsNT4",
L"win2k", L"Windows2000",
L"winxp", L"WindowsXP",
L"win2k3", L"Windows2003",
L"winvista", L"WindowsVista",
L"win2k8", L"Windows2008",
L"ecs", L"OS2eCS",
L"fedoracore", L"Fedora",
/* the rest is covered by the case-insensitive comparison */
};
AutoCaller autoCaller(this);
/* first, look for a substitution */
{
if (id == kOldNewIDs[i])
{
break;
}
}
++it)
{
{
break;
}
}
tr("'%ls' is not a valid Guest OS type"),
aId);
}
{
AutoCaller autoCaller(this);
}
{
AutoCaller autoCaller(this);
}
/**
* @note Locks this object for reading.
*/
{
using namespace settings;
if (ComSafeArrayOutIsNull(aKeys))
return E_POINTER;
AutoCaller autoCaller(this);
int i = 0;
++it, ++i)
{
}
return S_OK;
}
/**
* @note Locks this object for reading.
*/
{
AutoCaller autoCaller(this);
/* start with nothing found */
settings::ExtraDataItemsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.find(strKey);
// found:
/* return the result to caller (may be empty) */
return S_OK;
}
/**
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
// locking note: we only hold the read lock briefly to look up the old value,
// then release it and call the onExtraCanChange callbacks. There is a small
// chance of a race insofar as the callback might be called twice if two callers
// change the same key at the same time, but that's a much better solution
// than the deadlock we had here before. The actual changing of the extradata
// is then performed under the write lock and race-free.
// look up the old value first; if nothing's changed then we need not do anything
{
settings::ExtraDataItemsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.find(strKey);
}
bool fChanged;
{
// ask for permission from all listeners outside the locks;
// onExtraDataCanChange() only briefly requests the VirtualBox
// lock to copy the list of callbacks to invoke
{
LogWarningFunc(("Someone vetoed! Change refused%s%ls\n",
return setError(E_ACCESSDENIED,
tr("Could not set extra data because someone refused the requested change of '%ls' to '%ls'%s%ls"),
aKey,
sep,
err);
}
// data is changing and change not vetoed: then write it out under the lock
else
// creates a new key if needed
/* save settings on success */
}
// fire notification outside the lock
if (fChanged)
return S_OK;
}
/**
* @note Locks objects!
*/
{
AutoCaller autoCaller(this);
/* check the session state */
if (state != SessionState_Closed)
return setError(VBOX_E_INVALID_OBJECT_STATE,
tr("The given session is already open or being opened"));
/* get the IInternalSessionControl interface */
{
/*
* tell the client watcher thread to update the set of
* machines that have open sessions
*/
/* fire an event */
}
return rc;
}
/**
* @note Locks objects!
*/
{
AutoCaller autoCaller(this);
/* check the session state */
if (state != SessionState_Closed)
return setError(VBOX_E_INVALID_OBJECT_STATE,
tr("The given session is already open or being opened"));
/* get the IInternalSessionControl interface */
/* create a progress object */
FALSE /* aCancelable */);
{
/* signal the client watcher thread */
/* fire an event */
}
return rc;
}
/**
* @note Locks objects!
*/
{
AutoCaller autoCaller(this);
/* check the session state */
if (state != SessionState_Closed)
return setError(VBOX_E_INVALID_OBJECT_STATE,
tr("The given session is already open or being opened"));
/* get the IInternalSessionControl interface */
return rc;
}
/**
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
#if 0 /** @todo r=bird,r=pritesh: must check that the interface id match correct or we might screw up with old code! */
void *dummy;
return hrc;
#endif
return S_OK;
}
/**
* @note Locks this object for writing.
*/
{
AutoCaller autoCaller(this);
m->llCallbacks.end(),
rc = E_INVALIDARG;
else
return rc;
}
ULONG /* aTimeout */,
BSTR * /* aChanged */,
BSTR * /* aValues */)
{
}
// public methods only for internal purposes
/////////////////////////////////////////////////////////////////////////////
#ifdef DEBUG
void VirtualBox::dumpAllBackRefs()
{
{
++mt)
{
pMedium->dumpBackRefs();
}
}
{
++mt)
{
pMedium->dumpBackRefs();
}
}
}
#endif
/**
* Posts an event to the event queue that is processed asynchronously
* on a dedicated thread.
*
* Posting events to the dedicated event queue is useful to perform secondary
* actions outside any object locks -- for example, to iterate over a list
* of callbacks and inform them about some change caused by some object's
* method call.
*
* @param event event to post
* (must be allocated using |new|, will be deleted automatically
* by the event thread after processing)
*
* @note Doesn't lock any object.
*/
{
AutoCaller autoCaller(this);
{
LogWarningFunc(("VirtualBox has been uninitialized (state=%d), the event is discarded!\n",
autoCaller.state()));
return S_OK;
}
return S_OK;
return E_FAIL;
}
/**
* Adds a progress to the global collection of pending operations.
* Usually gets called upon progress object initialization.
*
* @param aProgress Operation to add to the collection.
*
* @note Doesn't lock objects.
*/
{
AutoCaller autoCaller(this);
/* protect mProgressOperations */
return S_OK;
}
/**
* Removes the progress from the global collection of pending operations.
* Usually gets called upon progress completion.
*
* @param aId UUID of the progress operation to remove
*
* @note Doesn't lock objects.
*/
{
AutoCaller autoCaller(this);
/* protect mProgressOperations */
return S_OK;
}
#ifdef RT_OS_WINDOWS
struct StartSVCHelperClientData
{
bool privileged;
void *user;
};
/**
* Helper method that starts a worker thread that:
* - creates a pipe communication channel using SVCHlpClient;
* - starts an SVC Helper process that will inherit this channel;
* - executes the supplied function by passing it the created SVCHlpClient
* and opened instance to communicate to the Helper process and the given
* Progress object.
*
* The user function is supposed to communicate to the helper process
* using the \a aClient argument to do the requested job and optionally expose
* the progress through the \a aProgress object. The user function should never
* call notifyComplete() on it: this will be done automatically using the
* result code returned by the function.
*
* Before the user function is started, the communication channel passed to
* the \a aClient argument is fully set up, the function should start using
* its write() and read() methods directly.
*
* The \a aVrc parameter of the user function may be used to return an error
* code if it is related to communication errors (for example, returned by
* the SVCHlpClient members when they fail). In this case, the correct error
* message using this value will be reported to the caller. Note that the
* value of \a aVrc is inspected only if the user function itself returns
* success.
*
* If a failure happens anywhere before the user function would be normally
* called, it will be called anyway in special "cleanup only" mode indicated
* by \a aClient, \a aProgress and \aVrc arguments set to NULL. In this mode,
* all the function is supposed to do is to cleanup its aUser argument if
* necessary (it's assumed that the ownership of this argument is passed to
* the user function once #startSVCHelperClient() returns a success, thus
* making it responsible for the cleanup).
*
* After the user function returns, the thread will send the SVCHlpMsg::Null
* message to indicate a process termination.
*
* @param aPrivileged |true| to start the SVC Helper process as a privileged
* user that can perform administrative tasks
* @param aFunc user function to run
* @param aUser argument to the user function
* @param aProgress progress object that will track operation completion
*
* @note aPrivileged is currently ignored (due to some unsolved problems in
* Vista) and the process will be started as a normal (unprivileged)
* process.
*
* @note Doesn't lock anything.
*/
{
AutoCaller autoCaller(this);
/* create the SVCHelperClientThread() argument */
d(new StartSVCHelperClientData());
d->that = this;
d->privileged = aPrivileged;
static_cast <void *>(d.get()),
RTTHREADFLAGS_WAITABLE, "SVCHelper");
E_FAIL);
/* d is now owned by SVCHelperClientThread(), so release it */
d.release();
return S_OK;
}
/**
* Worker thread for startSVCHelperClient().
*/
/* static */
DECLCALLBACK(int)
{
d(static_cast <StartSVCHelperClientData *>(aUser));
bool userFuncCalled = false;
do
{
/* protect VirtualBox from uninitialization */
if (!autoCaller.isOk())
{
/* it's too late */
break;
}
int vrc = VINF_SUCCESS;
if (RT_FAILURE(vrc))
{
break;
}
/* get the path to the executable */
char exePathBuf[RTPATH_MAX];
if (d->privileged)
{
/* Attempt to start a privileged process using the Run As dialog */
if (!ShellExecuteEx(&shExecInfo))
{
/* hide excessive details in case of a frequent error
* (pressing the Cancel button to close the Run As dialog) */
if (vrc2 == VERR_CANCELLED)
tr("Operation cancelled by the user"));
else
tr("Could not launch a privileged process '%s' (%Rrc)"),
break;
}
}
else
{
if (RT_FAILURE(vrc))
{
break;
}
}
/* wait for the client to connect */
if (RT_SUCCESS(vrc))
{
/* start the user supplied function */
userFuncCalled = true;
}
/* send the termination signal to the process anyway */
{
if (RT_SUCCESS(vrc))
}
{
break;
}
}
while (0);
{
/* call the user function in the "cleanup only" mode
* to let it free resources passed to in aUser */
}
return 0;
}
#endif /* RT_OS_WINDOWS */
/**
* Sends a signal to the client watcher thread to rescan the set of machines
* that have open sessions.
*
* @note Doesn't lock anything.
*/
void VirtualBox::updateClientWatcher()
{
AutoCaller autoCaller(this);
/* sent an update request */
#if defined(RT_OS_WINDOWS)
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
#else
# error "Port me!"
#endif
}
/**
* Adds the given child process ID to the list of processes to be reaped.
* This call should be followed by #updateClientWatcher() to take the effect.
*/
{
AutoCaller autoCaller(this);
/// @todo (dmik) Win32?
#ifndef RT_OS_WINDOWS
#endif
}
/** Event for onMachineStateChange(), onMachineDataChange(), onMachineRegistered() */
{
{}
{}
{}
{
switch (what)
{
case DataChanged:
break;
case StateChanged:
LogFlow(("OnMachineStateChange: id={%RTuuid}, state=%d\n",
break;
case Registered:
LogFlow(("OnMachineRegistered: id={%RTuuid}, registered=%d\n",
break;
}
}
};
/**
* @note Doesn't lock any object.
*/
{
}
/**
* @note Doesn't lock any object.
*/
{
}
/**
* @note Locks this object for reading.
*/
{
LogFlowThisFunc(("machine={%s} aKey={%ls} aValue={%ls}\n",
AutoCaller autoCaller(this);
{
list = m->llCallbacks;
}
{
aError.asOutParam(),
&allowChange);
{
/* if a call to this method fails for some reason (for ex., because
* the other side is dead), we ensure allowChange stays true
* (MS COM RPC implementation seems to zero all output vars before
* issuing an IPC call or after a failure, so it's essential
* there) */
allowChange = TRUE;
}
}
return allowChange;
}
/** Event for onExtraDataChange() */
{
{}
{
LogFlow(("OnExtraDataChange: machineId={%RTuuid}, key='%ls', val='%ls'\n",
}
};
/**
* @note Doesn't lock any object.
*/
{
}
/**
* @note Doesn't lock any object.
*/
{
}
/** Event for onSessionStateChange() */
{
{}
{
LogFlow(("OnSessionStateChange: machineId={%RTuuid}, sessionState=%d\n",
}
};
/**
* @note Doesn't lock any object.
*/
{
}
/** Event for onSnapshotTaken(), onSnapshotDeleted() and onSnapshotChange() */
{
: CallbackEvent(aVB)
{}
{
switch (what)
{
case Taken:
LogFlow(("OnSnapshotTaken: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
break;
case Deleted:
LogFlow(("OnSnapshotDeleted: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
break;
case Changed:
LogFlow(("OnSnapshotChange: machineId={%RTuuid}, snapshotId={%RTuuid}\n",
break;
}
}
};
/**
* @note Doesn't lock any object.
*/
{
}
/**
* @note Doesn't lock any object.
*/
{
}
/**
* @note Doesn't lock any object.
*/
{
}
/** Event for onGuestPropertyChange() */
{
: CallbackEvent(aVBox),
{}
{
LogFlow(("OnGuestPropertyChange: machineId={%RTuuid}, name='%ls', value='%ls', flags='%ls'\n",
}
};
/**
* @note Doesn't lock any object.
*/
{
}
/**
* @note Locks this object for reading.
*/
{
AutoCaller autoCaller(this);
/* unknown type must always be the first */
return m->ollGuestOSTypes.front();
}
/**
* Returns the list of opened machines (machines having direct sessions opened
* by client processes) and optionally the list of direct session controls.
*
* @param aMachines Where to put opened machines (will be empty if none).
* @param aControls Where to put direct session controls (optional).
*
* @note The returned lists contain smart pointers. So, clear it as soon as
* it becomes no more necessary to release instances.
*
* @note It can be possible that a session machine from the list has been
* already uninitialized, so do a usual AutoCaller/AutoReadLock sequence
* when accessing unprotected data directly.
*
* @note Locks objects for reading.
*/
{
AutoCaller autoCaller(this);
if (aControls)
++it)
{
{
if (aControls)
}
}
}
/**
* Searches for a Machine object with the given ID in the collection
* of registered machines.
*
* @param id
* ID of the machine
* @param doSetError
* if TRUE, the appropriate error info is set in case when the machine
* is not found
* @param machine
* where to store the found machine object (can be NULL)
*
* @return
* S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
*
* @note Locks this object for reading.
*/
bool aSetError,
{
AutoCaller autoCaller(this);
{
++it)
{
/* sanity */
{
if (aMachine)
break;
}
}
}
tr("Could not find a registered machine with UUID {%RTuuid}"),
return rc;
}
/**
* Searches for a Medium object with the given ID or location in the list of
* registered hard disks. If both ID and location are specified, the first
* object that matches either of them (not necessarily both) is returned.
*
* @param aId ID of the hard disk (unused when NULL).
* @param aLocation Full location specification (unused NULL).
* @param aSetError If @c true , the appropriate error info is set in case
* when the hard disk is not found.
* @param aHardDisk Where to store the found hard disk object (can be NULL).
*
* @return S_OK when found or E_INVALIDARG when not found.
*
* @note Locks the media tree for reading.
*/
bool aSetError,
{
// we use the hard disks map, but it is protected by the
// hard disk _list_ lock handle
/* first, look up by UUID in the map if UUID is provided */
if (aId)
{
{
if (aHardDisk)
return S_OK;
}
}
/* then iterate and search by location */
int result = -1;
if (aLocation)
{
++ it)
{
if (result == 0)
{
if (aHardDisk)
break;
}
}
}
{
if (aId)
tr("Could not find a hard disk with UUID {%RTuuid} in the media registry ('%s')"),
m->strSettingsFilePath.raw());
else
tr("Could not find a hard disk with location '%ls' in the media registry ('%s')"),
m->strSettingsFilePath.raw());
}
return rc;
}
/**
* Searches for a Medium object with the given ID or location in the list of
* registered DVD images. If both ID and file path are specified, the first
* object that matches either of them (not necessarily both) is returned.
*
* @param aId ID of the DVD image (unused when NULL).
* @param aLocation Full path to the image file (unused when NULL).
* @param aSetError If @c true, the appropriate error info is set in case when
* the image is not found.
* @param aImage Where to store the found image object (can be NULL).
*
* @return S_OK when found or E_INVALIDARG when not found.
*
* @note Locks the media tree for reading.
*/
bool aSetError,
{
{
if (RT_FAILURE(vrc))
return setError(VBOX_E_FILE_ERROR,
tr("Invalid image file location '%ls' (%Rrc)"),
vrc);
}
bool found = false;
++ it)
{
/* no AutoCaller, registered image life time is bound to this */
) == 0);
if (found)
{
if (aImage)
break;
}
}
{
if (aId)
m->strSettingsFilePath.raw());
else
m->strSettingsFilePath.raw());
}
return rc;
}
/**
* Searches for a Medium object with the given ID or location in the
* collection of registered DVD images. If both ID and file path are specified,
* the first object that matches either of them (not necessarily both) is
* returned.
*
* @param aId ID of the DVD image (unused when NULL).
* @param aLocation Full path to the image file (unused when NULL).
* @param aSetError If @c true, the appropriate error info is set in case when
* the image is not found.
* @param aImage Where to store the found image object (can be NULL).
*
* @return S_OK when found or E_INVALIDARG when not found.
*
* @note Locks the media tree for reading.
*/
bool aSetError,
{
{
if (RT_FAILURE(vrc))
return setError(VBOX_E_FILE_ERROR,
tr("Invalid image file location '%ls' (%Rrc)"),
}
bool found = false;
++ it)
{
/* no AutoCaller, registered image life time is bound to this */
) == 0);
if (found)
{
if (aImage)
break;
}
}
{
if (aId)
tr("Could not find a floppy image with UUID {%RTuuid} in the media registry ('%s')"),
m->strSettingsFilePath.raw());
else
tr("Could not find a floppy image with location '%ls' in the media registry ('%s')"),
m->strSettingsFilePath.raw());
}
return rc;
}
{
/* Look for a GuestOSType object */
("Guest OS types array must be filled"));
if (bstrOSType.isEmpty())
{
pGuestOSType = NULL;
return S_OK;
}
++it)
{
{
pGuestOSType = *it;
return S_OK;
}
}
return setError(VBOX_E_OBJECT_NOT_FOUND,
tr("Guest OS type '%ls' is invalid"),
bstrOSType.raw());
}
{
return m->pHost;
}
{
return m->pSystemProperties;
}
#ifdef VBOX_WITH_RESOURCE_USAGE_API
{
return m->pPerformanceCollector;
}
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
/**
* Returns the default machine folder from the system properties
* with proper locking.
* @return
*/
{
return m->pSystemProperties->m_strDefaultMachineFolder;
}
/**
* Returns the default hard disk folder from the system properties
* with proper locking.
* @return
*/
{
return m->pSystemProperties->m_strDefaultHardDiskFolder;
}
/**
* Returns the default hard disk format from the system properties
* with proper locking.
* @return
*/
{
return m->pSystemProperties->m_strDefaultHardDiskFormat;
}
{
return m->strHomeDir;
}
/**
* Calculates the absolute path of the given path taking the VirtualBox home
* directory as the current directory.
*
* @param aPath Path to calculate the absolute path for.
* @param aResult Where to put the result (used only on success, can be the
* same Utf8Str instance as passed in @a aPath).
* @return IPRT result.
*
* @note Doesn't lock any object.
*/
{
AutoCaller autoCaller(this);
/* no need to lock since mHomeDir is const */
char folder[RTPATH_MAX];
if (RT_SUCCESS(vrc))
return vrc;
}
/**
* Tries to calculate the relative path of the given absolute path using the
* directory of the VirtualBox settings file as the base directory.
*
* @param aPath Absolute path to calculate the relative path for.
* @param aResult Where to put the result (used only when it's possible to
* make a relative path from the given absolute path; otherwise
* left untouched).
*
* @note Doesn't lock any object.
*/
{
AutoCaller autoCaller(this);
/* no need to lock since mHomeDir is const */
{
/* when assigning, we create a separate Utf8Str instance because both
* aPath and aResult can point to the same memory location when this
* func is called (if we just do aResult = aPath, aResult will be freed
* first, and since its the same as aPath, an attempt to copy garbage
* will be made. */
}
}
// private methods
/////////////////////////////////////////////////////////////////////////////
/**
* Checks if there is a hard disk, DVD or floppy image with the given ID or
* location already registered.
*
* On return, sets @a aConflict to the string describing the conflicting medium,
* or sets it to @c Null if no conflicting media is found. Returns S_OK in
* either case. A failure is unexpected.
*
* @param aId UUID to check.
* @param aLocation Location to check.
* @param aConflict Where to return parameters of the conflicting medium.
*
* @note Locks the media tree and media objects for reading.
*/
{
{
{
/* Note: no AutoCaller since bound to this */
return S_OK;
}
}
{
{
/* Note: no AutoCaller since bound to this */
return S_OK;
}
}
{
{
/* Note: no AutoCaller since bound to this */
return S_OK;
}
}
return S_OK;
}
/**
* Called from Machine::prepareSaveSettings() when it has detected
* that a machine has been renamed. Such renames will require
* updating the global media registry during the
* VirtualBox::saveSettings() that follows later.
*
* When a machine is renamed, there may well be media (in particular,
* diff images for snapshots) in the global registry that will need
* to have their paths updated. Before 3.2, Machine::saveSettings
* used to call VirtualBox::saveSettings implicitly, which was both
* unintuitive and caused locking order problems. Now, we remeber
* such pending name changes with this method so that
* VirtualBox::saveSettings() can process them properly.
*/
const Utf8Str &strNewConfigDir)
{
}
/**
* Helper function to write out the configuration tree.
*
* @note Caller must have locked the VirtualBox object for writing!
*/
{
AutoCaller autoCaller(this);
try
{
// lock the lists while we're here
// machines
{
++it)
{
// save actual machine registry entry
}
}
// lock all media for the following; use a write lock because we're
// modifying the PendingMachineRenamesList, which is protected by this
// if a machine was renamed, then we'll need to refresh media paths
if (m->llPendingMachineRenames.size())
{
// make a single list from the three media lists so we don't need three loops
// with hard disks, we must use the map, not the list, because the list only has base images
++it)
{
++it2)
{
}
}
// done, don't do it again until we have more machine renames
m->llPendingMachineRenames.clear();
}
// hard disks
++it)
{
}
++it)
{
}
/* floppy images */
++it)
{
}
{
++it)
{
settings::DHCPServer d;
}
}
/* now copy the temp data to the config file under the VirtualBox lock */
// leave extra data alone, it's still in the config file
/* host data (USB filters) */
// and write out the XML, still under the lock
}
{
/* we assume that error info is set by the thrower */
}
catch (...)
{
}
return rc;
}
/**
* Helper to register the machine.
*
* When called during VirtualBox startup, adds the given machine to the
* collection of registered machines. Otherwise tries to mark the machine
* as registered, and, if succeeded, adds it to the collection and
* saves global settings.
*
* @note The caller must have added itself as a caller of the @a aMachine
* object if calls this method not on VirtualBox startup.
*
* @param aMachine machine to register
*
* @note Locks objects!
*/
{
AutoCaller autoCaller(this);
{
{
/* sanity */
return setError(E_INVALIDARG,
tr("Registered machine with UUID {%RTuuid} ('%ls') already exists"),
}
}
{
}
/* add to the collection of registered machines */
rc = saveSettings();
return rc;
}
/**
* Remembers the given hard disk by storing it in the hard disk registry.
*
* @param aHardDisk Hard disk object to remember.
* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
*
* @note Caller must hold the media tree lock for writing; in addition, this locks @a aHardDisk for reading
*/
bool *pfNeedsSaveSettings)
{
AutoCaller autoCaller(this);
// caller must hold the media tree write lock
{
}
if (strConflict.length())
return setError(E_INVALIDARG,
tr("Cannot register the hard disk '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
strConflict.raw(),
m->strSettingsFilePath.raw());
// store base (root) hard disks in the list
// access the list directly because we already locked the list above
// store all hard disks (even differencing images) in the map
if (pfNeedsSaveSettings)
*pfNeedsSaveSettings = true;
return rc;
}
/**
* Removes the given hard disk from the hard disk registry.
*
* @param aHardDisk Hard disk object to remove.
* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
*
* @note Caller must hold the media tree lock for writing; in addition, this locks @a aHardDisk for reading
*/
bool *pfNeedsSaveSettings)
{
AutoCaller autoCaller(this);
// caller must hold the media tree write lock
{
}
// remove base (root) hard disks from the list
// access the list directly because caller must have locked the list
// remove all hard disks (even differencing images) from map
if (pfNeedsSaveSettings)
*pfNeedsSaveSettings = true;
return S_OK;
}
/**
*
* @param argImage Image object to remember.
* @param argType Either DeviceType_DVD or DeviceType_Floppy.
* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
*
* @note Caller must hold the media tree lock for writing; in addition, this locks @a argImage for reading
*/
bool *pfNeedsSaveSettings)
{
AutoCaller autoCaller(this);
// caller must hold the media tree write lock
{
}
// work on DVDs or floppies list?
// lock the images lists (list + map) while checking for conflicts
if (strConflict.length())
return setError(VBOX_E_INVALID_OBJECT_STATE,
tr("Cannot register the image '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
strConflict.raw(),
m->strSettingsFilePath.raw());
// add to the collection
// access the list directly because we already locked the list above
if (pfNeedsSaveSettings)
*pfNeedsSaveSettings = true;
return rc;
}
/**
*
* @param argImage Image object to remove.
* @param argType Either DeviceType_DVD or DeviceType_Floppy.
* @param pfNeedsSaveSettings Optional pointer to a bool that must have been initialized to false and that will be set to true
* by this function if the caller should invoke VirtualBox::saveSettings() because the global settings have changed.
*
* @note Caller must hold the media tree lock for writing; in addition, this locks @a argImage for reading
*/
bool *pfNeedsSaveSettings)
{
AutoCaller autoCaller(this);
// caller must hold the media tree write lock
{
}
// work on DVDs or floppies list?
// access the list directly because the caller must have requested the lock
if (pfNeedsSaveSettings)
*pfNeedsSaveSettings = true;
return rc;
}
/**
* Creates the path to the specified file according to the path information
* present in the file name.
*
* Note that the given file name must contain the full path otherwise the
* extracted relative path will be created based on the current working
* directory which is normally unknown.
*
* @param aFileName Full file name which path needs to be created.
*
* @return Extended error information on failure to create the path.
*/
/* static */
{
{
if (RT_FAILURE(vrc))
tr("Could not create the directory '%s' (%Rrc)"),
vrc);
}
return S_OK;
}
/**
* Handles unexpected exceptions by turning them into COM errors in release
* builds or by hitting a breakpoint in the release builds.
*
* Usage pattern:
* @code
try
{
// ...
}
catch (LaLalA)
{
// ...
}
catch (...)
{
rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
}
* @endcode
*
* @param RT_SRC_POS_DECL "RT_SRC_POS" macro instantiation.
*/
/* static */
{
try
{
/* re-throw the current exception */
throw;
}
{
}
{
}
catch (...)
{
}
/* should not get here */
AssertFailed();
return E_FAIL;
}
{
return m->strSettingsFilePath;
}
/**
* Returns the lock handle which protects the media trees (hard disks,
* DVDs, floppies). As opposed to version 3.1 and earlier, these lists
* are no longer protected by the VirtualBox lock, but by this more
* specialized lock. Mind the locking order: always request this lock
* after the VirtualBox object lock but before the locks of the media
* objects contained in these lists. See AutoLock.h.
*/
{
return m->lockMedia;
}
/**
* Thread function that watches the termination of all client processes
* that have opened sessions using IVirtualBox::OpenSession()
*/
// static
{
size_t cntSpawned = 0;
#if defined(RT_OS_WINDOWS)
/// @todo (dmik) processes reaping!
do
{
/* VirtualBox has been early uninitialized, terminate */
if (!autoCaller.isOk())
break;
do
{
/* release the caller to let uninit() ever proceed */
INFINITE);
/* Restore the caller before using VirtualBox. If it fails, this
* means VirtualBox is being uninitialized and we must terminate. */
autoCaller.add();
if (!autoCaller.isOk())
break;
bool update = false;
if (rc == WAIT_OBJECT_0)
{
/* update event is signaled */
update = true;
}
{
/* machine mutex is released */
update = true;
}
{
/* machine mutex is abandoned due to client process termination */
update = true;
}
{
/* spawned VM process has terminated (normally or abnormally) */
update = true;
}
if (update)
{
/* close old process handles */
CloseHandle(handles[i]);
// lock the machines list for reading
/* obtain a new set of opened machines */
cnt = 0;
++it)
{
/// @todo handle situations with more than 64 objects
("MAXIMUM_WAIT_OBJECTS reached"));
{
++cnt;
}
}
/* obtain a new set of spawned machines */
cntSpawned = 0;
++it)
{
/// @todo handle situations with more than 64 objects
("MAXIMUM_WAIT_OBJECTS reached"));
{
pid, GetLastError()));
if (rc == 0)
{
++cntSpawned;
}
}
}
// machines lock unwinds here
}
}
while (true);
}
while (0);
/* close old process handles */
CloseHandle(handles[i]);
/* release sets of machines if any */
::CoUninitialize();
/// @todo (dmik) processes reaping!
/* according to PMREF, 64 is the maximum for the muxwait list */
do
{
/* VirtualBox has been early uninitialized, terminate */
if (!autoCaller.isOk())
break;
do
{
/* release the caller to let uninit() ever proceed */
/* Restore the caller before using VirtualBox. If it fails, this
* means VirtualBox is being uninitialized and we must terminate. */
autoCaller.add();
if (!autoCaller.isOk())
break;
bool update = false;
bool updateSpawned = false;
if (RT_SUCCESS(vrc))
{
/* update event is signaled */
update = true;
updateSpawned = true;
}
else
{
("RTSemEventWait returned %Rrc\n", vrc));
/* are there any mutexes? */
if (cnt > 0)
{
/* figure out what's going on with machines */
unsigned long semId = 0;
{
/* machine mutex is normally released */
{
#ifdef DEBUG
{
LogFlowFunc(("released mutex: machine='%ls'\n",
}
#endif
}
update = true;
}
else if (arc == ERROR_SEM_OWNER_DIED)
{
/* machine mutex is abandoned due to client process
* termination; find which mutex is in the Owner Died
* state */
{
unsigned long reqCnt;
if (arc == ERROR_SEM_OWNER_DIED)
{
/* close the dead mutex as asked by PMREF */
if (i >= 0 && i < cnt)
{
#ifdef DEBUG
{
LogFlowFunc(("mutex owner dead: machine='%ls'\n",
}
#endif
machines[i]->checkForDeath();
}
}
}
update = true;
}
else
("DosWaitMuxWaitSem returned %d\n", arc));
}
/* are there any spawning sessions? */
if (cntSpawned > 0)
{
for (size_t i = 0; i < cntSpawned; ++ i)
updateSpawned |= (spawnedMachines[i])->
}
}
if (update || updateSpawned)
{
if (update)
{
/* close the old muxsem */
if (muxSem != NULLHANDLE)
/* obtain a new set of opened machines */
cnt = 0;
{
/// @todo handle situations with more than 64 objects
("maximum of 64 mutex semaphores reached (%d)",
cnt));
{
++ cnt;
}
}
if (cnt > 0)
{
/* create a new muxsem */
("DosCreateMuxWaitSem returned %d\n", arc));
}
}
if (updateSpawned)
{
/* obtain a new set of spawned machines */
{
if ((*it)->isSessionSpawning())
}
}
}
}
while (true);
}
while (0);
/* close the muxsem */
if (muxSem != NULLHANDLE)
/* release sets of machines if any */
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
bool update = false;
bool updateSpawned = false;
do
{
if (!autoCaller.isOk())
break;
do
{
/* release the caller to let uninit() ever proceed */
/*
* Restore the caller before using VirtualBox. If it fails, this
* means VirtualBox is being uninitialized and we must terminate.
*/
autoCaller.add();
if (!autoCaller.isOk())
break;
{
/* RT_SUCCESS(rc) means an update event is signaled */
// lock the machines list for reading
{
/* obtain a new set of opened machines */
++it)
{
}
}
{
/* obtain a new set of spawned machines */
++it)
{
if ((*it)->isSessionSpawning())
}
}
// machines lock unwinds here
}
update = false;
updateSpawned = false;
for (size_t i = 0; i < cntSpawned; ++ i)
/* reap child processes */
{
{
LogFlowFunc(("UPDATE: child process count = %d\n",
{
if (vrc == VINF_SUCCESS)
{
LogFlowFunc(("pid %d (%x) was reaped, status=%d, reason=%d\n",
}
else
{
LogFlowFunc(("pid %d (%x) was NOT reaped, vrc=%Rrc\n",
if (vrc != VERR_PROCESS_RUNNING)
{
/* remove the process if it is not already running */
}
else
++ it;
}
}
}
}
}
while (true);
}
while (0);
/* release sets of machines if any */
#else
# error "Port me!"
#endif
return 0;
}
/**
* Thread function that handles custom events posted using #postEvent().
*/
// static
{
// create an event queue for the current thread
// return the queue to the one who created this thread
// signal that we're ready
delete eventQ;
return 0;
}
////////////////////////////////////////////////////////////////////////////////
/**
* Takes the current list of registered callbacks of the managed VirtualBox
* instance, and calls #handleCallback() for every callback item from the
* list, passing the item as an argument.
*
* @note Locks the managed VirtualBox object for reading but leaves the lock
* before iterating over callbacks and calling their methods.
*/
{
if (!mVirtualBox)
return NULL;
if (!autoCaller.isOk())
{
LogWarningFunc(("VirtualBox has been uninitialized (state=%d), the callback event is discarded!\n",
autoCaller.state()));
/* We don't need mVirtualBox any more, so release it */
mVirtualBox = NULL;
return NULL;
}
{
/* Make a copy to release the lock before iterating */
/* We don't need mVirtualBox any more, so release it */
mVirtualBox = NULL;
}
++it)
handleCallback(*it);
return NULL;
}
//STDMETHODIMP VirtualBox::CreateDHCPServerForInterface(/*IHostNetworkInterface * aIinterface,*/ IDHCPServer ** aServer)
//{
// return E_NOTIMPL;
//}
{
AutoCaller autoCaller(this);
return rc;
}
{
AutoCaller autoCaller(this);
++it)
{
{
break;
}
}
if (!found)
return E_INVALIDARG;
}
{
AutoCaller autoCaller(this);
return rc;
}
/**
* Remembers the given dhcp server by storing it in the hard disk registry.
*
* @param aDHCPServer Dhcp Server object to remember.
* @param aSaveRegistry @c true to save hard disk registry to disk (default).
*
* When @a aSaveRegistry is @c true, this operation may fail because of the
* failed #saveSettings() method it calls. In this case, the dhcp server object
* will not be remembered. It is therefore the responsibility of the caller to
* call this method as the last step of some action that requires registration
* in order to make sure that only fully functional dhcp server objects get
* registered.
*
* @note Locks this object for writing and @a aDHCPServer for reading.
*/
bool aSaveRegistry /*= true*/)
{
AutoCaller autoCaller(this);
{
return E_INVALIDARG;
}
if (aSaveRegistry)
{
rc = saveSettings();
}
return rc;
}
/**
* Removes the given hard disk from the hard disk registry.
*
* @param aHardDisk Hard disk object to remove.
* @param aSaveRegistry @c true to save hard disk registry to disk (default).
*
* When @a aSaveRegistry is @c true, this operation may fail because of the
* failed #saveSettings() method it calls. In this case, the hard disk object
* will NOT be removed from the registry when this method returns. It is
* therefore the responsibility of the caller to call this method as the first
* step of some action that requires unregistration, before calling uninit() on
* @a aHardDisk.
*
* @note Locks this object for writing and @a aHardDisk for reading.
*/
bool aSaveRegistry /*= true*/)
{
AutoCaller autoCaller(this);
if (aSaveRegistry)
{
rc = saveSettings();
}
return rc;
}
/* vi: set tabstop=4 shiftwidth=4 expandtab: */