HardDisk2Impl.cpp revision 62ce496afaf36bcde8d08da57a9444739d67f426
/* $Id$ */
/** @file
*
* VirtualBox COM class implementation
*/
/*
* Copyright (C) 2008 Sun Microsystems, Inc.
*
* 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.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
#include "HardDisk2Impl.h"
#include "ProgressImpl.h"
#include "SystemPropertiesImpl.h"
#include "Logging.h"
#include <list>
#include <memory>
////////////////////////////////////////////////////////////////////////////////
// Globals
////////////////////////////////////////////////////////////////////////////////
/**
* Asynchronous task thread parameter bucket.
*
* Note that instances of this class must be created using new() because the
* task thread function will delete them when the task is complete!
*
* @note The constructor of this class adds a caller on the managed HardDisk2
* object which is automatically released upon destruction.
*/
{
/** Where to save the result when executed using #runNow(). */
, operation (aOperation)
~Task();
{
AssertComRC (rc);
}
{
}
struct Data
{
/* CreateDynamic, CreateStatic */
/* CreateDiff */
/* Merge */
/** Hard disks to merge, in {parent,child} order */
}
d;
protected:
// SupportErrorInfoBase interface
};
{
/* remove callers added by setData() */
d.target->releaseCaller();
}
/**
* Starts a new thread driven by the HardDisk2::taskThread() function and passes
* this Task instance as an argument.
*
* Note that if this method returns success, this Task object becomes an ownee
* of the started thread and will be automatically deleted when the thread
* terminates.
*
* @note When the task is executed by this method, IProgress::notifyComplete()
* is automatically called for the progress object associated with this
* task when the task is finished to signal the operation completion for
* other threads asynchronously waiting for it.
*/
{
"HardDisk::Task");
return S_OK;
}
/**
* Runs HardDisk2::taskThread() by passing it this Task instance as an argument
* on the current thread instead of creating a new one.
*
* This call implies that it is made on another temporary thread created for
* some asynchronous task. Avoid calling it from a normal thread since the task
* operatinos are potentially lengthy and will block the calling thread in this
* case.
*
* Note that this Task object will be deleted by taskThread() when this method
* returns!
*
* @note When the task is executed by this method, IProgress::notifyComplete()
* is not called for the progress object associated with this task when
* the task is finished. Instead, the result of the operation is returned
* by this method directly and it's the caller's responsibility to
* complete the progress object in this case.
*/
{
return rc;
}
////////////////////////////////////////////////////////////////////////////////
/**
* Helper class for merge operations.
*
* @note It is assumed that when modifying methods of this class are called,
* HardDisk2::treeLock() is held in read mode.
*/
public com::SupportErrorInfoBase
{
public:
~MergeChain()
{
{
AssertComRC (rc);
(*it)->releaseCaller();
}
{
else
(*it)->releaseCaller();
}
mParent->releaseCaller();
}
{
if (mForward)
{
{
return rc;
}
}
/* go to Deleting */
{
case MediaState_Created:
break;
default:
return aHardDisk->setStateError();
}
if (mForward)
{
/* we will need parent to reparent target */
{
}
}
else
{
/* we will need to reparent children */
{
{
(*it)->releaseCaller();
return rc;
}
}
}
return S_OK;
}
{
if (!mForward)
{
{
return rc;
}
}
/* go to LockedWrite */
{
return rc;
}
return S_OK;
}
{
{
return rc;
}
/* go to Deleting */
{
case MediaState_Created:
break;
default:
return aHardDisk->setStateError();
}
return S_OK;
}
protected:
// SupportErrorInfoBase interface
private:
bool aImmutable)
{
if (aChildren)
{
/* not going to multi-merge as it's too expensive */
{
tr ("Hard disk '%ls' involved in the merge operation "
"has more than one child hard disk (%d)"),
}
}
if (aAttachments && !mIgnoreAttachments)
{
tr ("Hard disk '%ls' is attached to %d virtual machines"),
}
if (aImmutable)
{
tr ("Hard disk '%ls' is immutable"),
}
return S_OK;
}
/** true if forward merge, false if backward */
bool mForward : 1;
/** true to not perform attachment checks */
bool mIgnoreAttachments : 1;
/** Parent of the source when forward merge (if any) */
/** Children of the source when backward merge (if any) */
};
////////////////////////////////////////////////////////////////////////////////
// HardDisk2 class
////////////////////////////////////////////////////////////////////////////////
// constructor / destructor
////////////////////////////////////////////////////////////////////////////////
{
/* Initialize the callbacks of the VD error interface */
/* Initialize the callbacks of the VD progress interface */
/* Initialize the callbacks of the VD config interface */
/* Initialize the callbacks of the VD TCP interface (we always use the host
* IP stack for now) */
/* Initialize the per-disk interface chain */
int vrc;
"HardDisk2::vdInterfaceError",
"HardDisk2::vdInterfaceProgress",
"HardDisk2::vdInterfaceConfig",
"HardDisk2::vdInterfaceTcpNet",
return S_OK;
}
void HardDisk2::FinalRelease()
{
uninit();
}
// public initializer/uninitializer for internal purposes only
////////////////////////////////////////////////////////////////////////////////
/**
* Initializes the hard disk object without creating or opening an associated
* storage unit.
*
* For hard disks that don't have the VD_CAP_CREATE_FIXED or
* VD_CAP_CREATE_DYNAMIC capability (and therefore cannot be created or deleted
* with the means of VirtualBox) the associated storage unit is assumed to be
* ready for use so the state of the hard disk object will be set to Created.
*
* @param aVirtualBox VirtualBox object.
* @param aLocaiton Storage unit location.
*/
{
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan (this);
/* share VirtualBox weakly (parent remains NULL so far) */
/* register with VirtualBox early, since uninit() will
* unconditionally unregister on failure */
aVirtualBox->addDependentChild (this);
/* no storage yet */
/* No storage unit is created yet, no need to queryInfo() */
{
}
else
{
/// @todo later we may want to use a pfnComposeLocation backend info
/// callback to generate a well-formed location value (based on the hard
/// disk properties we have) rather than allowing each caller to invent
/// its own (pseudo-)location.
}
{
/* storage for hard disks of this format can neither be explicitly
* created by VirtualBox nor deleted, so we place the hard disk to
* Created state here and also add it to the registry */
m.state = MediaState_Created;
/// @todo later we may want to use a pfnIsConfigSufficient backend info
/// callback that would tell us when we have enough properties to work
/// with the hard disk and this information could be used to actually
/// move such hard disks from NotCreated to Created state. Instead of
/// pfnIsConfigSufficient we can use HardDiskFormat property
/// descriptions to see which properties are mandatory
}
/* Confirm a successful initialization when it's the case */
return rc;
}
/**
* Initializes the hard disk object by opening the storage unit at the specified
* location.
*
* Note that the UUID, format and the parent of this hard disk will be
* determined when reading the hard disk storage unit. If the detected parent is
* not known to VirtualBox, then this method will fail.
*
* @param aVirtualBox VirtualBox object.
* @param aLocaiton Storage unit location.
*/
{
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan (this);
/* share VirtualBox weakly (parent remains NULL so far) */
/* register with VirtualBox early, since uninit() will
* unconditionally unregister on failure */
aVirtualBox->addDependentChild (this);
/* there must be a storage unit */
m.state = MediaState_Created;
/* get all the information about the medium from the storage unit */
{
/* if the storage unit is not accessible, it's not acceptable for the
* newly opened media so convert this into an error */
if (m.state == MediaState_Inaccessible)
{
}
/* storage format must be detected by queryInfo() if the medium is
* accessible */
}
/* Confirm a successful initialization when it's the case */
return rc;
}
/**
* Initializes the hard disk object by loading its data from the given settings
* node.
*
* @param aVirtualBox VirtualBox object.
* @param aParent Parent hard disk or NULL for a root hard disk.
* @param aNode <HardDisk> settings node.
*
* @note Locks VirtualBox lock for writing, treeLock() for writing.
*/
{
using namespace settings;
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan (this);
/* share VirtualBox and parent weakly */
/* register with VirtualBox/parent early, since uninit() will
* unconditionally unregister on failure */
aVirtualBox->addDependentChild (this);
else
{
/* we set mParent */
aParent->addDependentChild (this);
}
/* see below why we don't call queryInfo() (and therefore treat the medium
* as inaccessible for now */
/* required */
/* optional */
{
}
/* required */
/* properties (after setting the format as it populates the map). Note that
* if some properties are not supported but preseint in the settings file,
* they will still be read and accessible (for possible backward
* compatibility; we can also clean them up from the XML upon next
* XML format versino change if we wish) */
{
}
/* required */
/* type is only for base hard disks */
{
else
AssertFailed();
}
LogFlowThisFunc (("m.locationFull='%ls', mm.format=%ls, m.id={%RTuuid}\n",
/* Don't call queryInfo() for registered media to prevent the calling
* thread (i.e. the VirtualBox server startup thread) from an unexpected
* freeze but mark it as initially inaccessible instead. The vital UUID,
* location and format properties are read from the registry file above; to
* get the actual state and the rest of the data, the user will have to call
* COMGETTER(State). */
/* load all children */
{
}
/* Confirm a successful initialization when it's the case */
return rc;
}
/**
* Uninitializes the instance.
*
* Called either from FinalRelease() or by the parent when it gets destroyed.
*
* @note All children of this hard disk get uninitialized by calling their
* uninit() methods.
*
* @note Locks treeLock() for writing, VirtualBox for writing.
*/
{
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan (this);
if (autoUninitSpan.uninitDone())
return;
{
/* remove the caller reference we added in setFormat() */
}
if (m.state == MediaState_Deleting)
{
/* we are being uninitialized after've been deleted by merge.
* Reparenting has already been done so don't touch it here (we are
* now orphans and remoeDependentChild() will assert) */
}
else
{
/* we uninit children and reset mParent
* and VirtualBox::removeDependentChild() needs a write lock */
{
mParent->removeDependentChild (this);
}
else
mVirtualBox->removeDependentChild (this);
}
}
// IHardDisk2 properties
////////////////////////////////////////////////////////////////////////////////
{
return E_POINTER;
AutoCaller autoCaller (this);
/* no need to lock, mm.format is const */
return S_OK;
}
{
return E_POINTER;
AutoCaller autoCaller (this);
AutoReadLock alock (this);
return S_OK;
}
{
AutoCaller autoCaller (this);
/* VirtualBox::saveSettings() needs a write lock */
switch (m.state)
{
case MediaState_Created:
case MediaState_Inaccessible:
break;
default:
return setStateError();
}
{
/* Nothing to do */
return S_OK;
}
/* we access mParent & children() */
/* cannot change the type of a differencing hard disk */
tr ("Hard disk '%ls' is a differencing hard disk"),
m.locationFull.raw());
/* cannot change the type of a hard disk being in use */
tr ("Hard disk '%ls' is attached to %d virtual machines"),
switch (aType)
{
case HardDiskType_Normal:
case HardDiskType_Immutable:
{
/* normal can be easily converted to imutable and vice versa even
* if they have children as long as they are not attached to any
* machine themselves */
break;
}
{
/* cannot change to writethrough if there are children */
tr ("Hard disk '%ls' has %d child hard disks"),
break;
}
default:
}
return rc;
}
{
return E_POINTER;
AutoCaller autoCaller (this);
/* we access mParent */
return S_OK;
}
{
if (ComSafeArrayOutIsNull (aChildren))
return E_POINTER;
AutoCaller autoCaller (this);
/* we access children */
return S_OK;
}
{
return E_POINTER;
return S_OK;
}
{
return E_POINTER;
AutoCaller autoCaller (this);
/* isRadOnly() will do locking */
*aReadOnly = isReadOnly();
return S_OK;
}
{
if (aLogicalSize == NULL)
return E_POINTER;
{
AutoCaller autoCaller (this);
AutoReadLock alock (this);
/* we access mParent */
{
return S_OK;
}
}
/* We assume that some backend may decide to return a meaningless value in
* response to VDGetSize() for differencing hard disks and therefore
* always ask the base hard disk ourselves. */
}
// IHardDisk2 methods
////////////////////////////////////////////////////////////////////////////////
{
AutoCaller autoCaller (this);
AutoReadLock alock (this);
return setError (VBOX_E_OBJECT_NOT_FOUND,
return S_OK;
}
{
AutoCaller autoCaller (this);
/* VirtualBox::saveSettings() needs a write lock */
switch (m.state)
{
case MediaState_Created:
case MediaState_Inaccessible:
break;
default:
return setStateError();
}
return setError (VBOX_E_OBJECT_NOT_FOUND,
return rc;
}
{
AutoCaller autoCaller (this);
AutoReadLock alock (this);
/// @todo make use of aNames according to the documentation
size_t i = 0;
{
++ i;
}
return S_OK;
}
{
AutoCaller autoCaller (this);
/* VirtualBox::saveSettings() needs a write lock */
/* first pass: validate names */
{
return setError (VBOX_E_OBJECT_NOT_FOUND,
}
/* second pass: assign */
{
}
return rc;
}
{
AutoCaller autoCaller (this);
AutoWriteLock alock (this);
return setError (VBOX_E_NOT_SUPPORTED,
tr ("Hard disk format '%ls' does not support dynamic storage "
switch (m.state)
{
case MediaState_NotCreated:
break;
default:
return setStateError();
}
m.locationFull.raw()),
FALSE /* aCancelable */);
/* setup task object and thread to carry out the operation
* asynchronously */
/* go to Creating state on success */
m.state = MediaState_Creating;
/* task is now owned by taskThread() so release it */
/* return progress to the caller */
return S_OK;
}
{
AutoCaller autoCaller (this);
AutoWriteLock alock (this);
return setError (VBOX_E_NOT_SUPPORTED,
tr ("Hard disk format '%ls' does not support fixed storage "
switch (m.state)
{
case MediaState_NotCreated:
break;
default:
return setStateError();
}
m.locationFull.raw()),
FALSE /* aCancelable */);
/* setup task object and thread to carry out the operation
* asynchronously */
/* go to Creating state on success */
m.state = MediaState_Creating;
/* task is now owned by taskThread() so release it */
/* return progress to the caller */
return S_OK;
}
{
AutoCaller autoCaller (this);
{
/* return progress to the caller */
}
return rc;
}
{
AutoCaller autoCaller (this);
AutoWriteLock alock (this);
tr ("Hard disk '%ls' is Writethrough"),
m.locationFull.raw());
/* We want to be locked for reading as long as our diff child is being
* created */
{
AssertComRC (rc2);
/* Note: on success, taskThread() will unlock this */
}
else
{
/* return progress to the caller */
}
return rc;
}
{
AutoCaller autoCaller (this);
}
{
AutoCaller autoCaller (this);
/* We want to be locked for reading as long as the clone hard disk is being
* created*/
try
{
throw target->setStateError();
FALSE /* aCancelable */);
/* setup task object and thread to carry out the operation
* asynchronously */
/* go to Creating state before leaving the lock */
/* task is now owned (or already deleted) by taskThread() so release it */
}
{
}
{
AssertComRC (rc2);
/* Note: on success, taskThread() will unlock this */
}
else
{
/* return progress to the caller */
}
return rc;
}
{
AutoCaller autoCaller (this);
}
{
AutoCaller autoCaller (this);
}
// public methods for internal purposes only
////////////////////////////////////////////////////////////////////////////////
/**
* Checks if the given change of \a aOldPath to \a aNewPath affects the location
* of this hard disk or any its child and updates the paths if necessary to
* reflect the new location.
*
* @param aOldPath Old path (full).
* @param aNewPath New path (full).
*
* @note Locks treeLock() for reading, this object and all children for writing.
*/
{
AutoCaller autoCaller (this);
AutoWriteLock alock (this);
/* we access children() */
/* update paths of all children */
++ it)
{
}
}
/**
* Returns the base hard disk of the hard disk chain this hard disk is part of.
*
* The root hard disk is found by walking up the parent-child relationship axis.
* If the hard disk doesn't have a parent (i.e. it's a base hard disk), it
* returns itself in response to this method.
*
* @param aLevel Where to store the number of ancestors of this hard disk
* (zero for the root), may be @c NULL.
*
* @note Locks treeLock() for reading.
*/
{
AutoCaller autoCaller (this);
/* we access mParent */
root = this;
level = 0;
{
for (;;)
{
break;
++ level;
}
}
return root;
}
/**
* Returns @c true if this hard disk cannot be modified because it has
* dependants (children) or is part of the snapshot. Related to the hard disk
* type and posterity, not to the current media state.
*
* @note Locks this object and treeLock() for reading.
*/
bool HardDisk2::isReadOnly()
{
AutoCaller autoCaller (this);
AutoReadLock alock (this);
/* we access children */
{
case HardDiskType_Normal:
{
return true;
return true;
return false;
}
case HardDiskType_Immutable:
{
return true;
}
{
return false;
}
default:
break;
}
AssertFailedReturn (false);
}
/**
* Saves hard disk data by appending a new <HardDisk> child node to the given
* parent node which can be either <HardDisks> or <HardDisk>.
*
* @param aaParentNode Parent <HardDisks> or <HardDisk> node.
*
* @note Locks this object, treeLock() and children for reading.
*/
{
using namespace settings;
AutoCaller autoCaller (this);
AutoReadLock alock (this);
/* we access mParent */
/* required */
/* required (note: the original locaiton, not full) */
/* required */
/* optional */
if (!m.description.isNull())
{
}
/* optional properties */
{
/* only save properties that have non-default values */
{
}
}
/* only for base hard disks */
{
const char *type =
}
/* save all children */
++ it)
{
}
return S_OK;
}
/**
* Compares the location of this hard disk to the given location.
*
* The comparison takes the location details into account. For example, if the
* location is a file in the host's filesystem, a case insensitive comparison
* will be performed for case insensitive filesystems.
*
* @param aLocation Location to compare to (as is).
* @param aResult Where to store the result of comparison: 0 if locations
* are equal, 1 if this object's location is greater than
* the specified location, and -1 otherwise.
*/
{
AutoCaller autoCaller (this);
AutoReadLock alock (this);
/// @todo NEWMEDIA delegate the comparison to the backend?
{
/* For locations represented by files, append the default path if
* only the name is given, and then get the full path. */
if (!RTPathHavePath (aLocation))
{
}
if (RT_FAILURE (vrc))
tr ("Invalid hard disk storage file location '%s' (%Rrc)"),
}
else
return S_OK;
}
/**
* Returns a short version of the location attribute.
*
* Reimplements MediumBase::name() to specially treat non-FS-path locations.
*
* @note Must be called from under this object's read or write lock.
*/
{
/// @todo NEWMEDIA treat non-FS-paths specially! (may require to requiest
/// this information from the VD backend)
return name;
}
/**
* Checks that this hard disk may be discarded and performs necessary state
* changes.
*
* This method is to be called prior to calling the #discrad() to perform
* necessary consistency checks and place involved hard disks to appropriate
* states. If #discard() is not called or fails, the state modifications
* performed by this method must be undone by #cancelDiscard().
*
* See #discard() for more info about discarding hard disks.
*
* @param aChain Where to store the created merge chain (may return NULL
* if no real merge is necessary).
*
* @note Locks treeLock() for reading. Locks this object, aTarget and all
* intermediate hard disks for writing.
*/
{
AutoCaller autoCaller (this);
AutoWriteLock alock (this);
/* we access mParent & children() */
{
/* special treatment of the last hard disk in the chain: */
{
/* lock only, to prevent any usage; discard() will unlock */
}
/* the differencing hard disk w/o children will be deleted, protect it
* from attaching to other VMs (this is why Deleting) */
switch (m.state)
{
case MediaState_Created:
m.state = MediaState_Deleting;
break;
default:
return setStateError();
}
/* aChain is intentionally NULL here */
return S_OK;
}
/* not going multi-merge as it's too expensive */
tr ("Hard disk '%ls' has more than one child hard disk (%d)"),
/* this is a read-only hard disk with children; it must be associated with
* exactly one snapshot (when the snapshot is being taken, none of the
* current VM's hard disks may be attached to other VMs). Note that by the
* time when discard() is called, there must be no any attachments at all
* (the code calling prepareDiscard() should detach). */
/* we keep this locked, so lock the affected child to make sure the lock
* order is correct when calling prepareMergeTo() */
/* delegate the rest to the profi */
{
/* base hard disk, backward merge */
{
/* backward merge is too tricky, we'll just detach on discard, so
* lock only, to prevent any usage; discard() will only unlock
* (since we return NULL in aChain) */
}
true /* aIgnoreAttachments */);
}
else
{
/* forward merge */
true /* aIgnoreAttachments */);
}
}
/**
* Discards this hard disk.
*
* Discarding the hard disk is merging its contents to its differencing child
* hard disk (forward merge) or contents of its child hard disk to itself
* (backward merge) if this hard disk is a base hard disk. If this hard disk is
* a differencing hard disk w/o children, then it will be simply deleted.
* Calling this method on a base hard disk w/o children will do nothing and
* silently succeed. If this hard disk has more than one child, the method will
* currently return an error (since merging in this case would be too expensive
* and result in data duplication).
*
* When the backward merge takes place (i.e. this hard disk is a target) then,
* on success, this hard disk will automatically replace the differencing child
* hard disk used as a source (which will then be deleted) in the attachment
* this child hard disk is associated with. This will happen only if both hard
* disks belong to the same machine because otherwise such a replace would be
* too tricky and could be not expected by the other machine. Same relates to a
* case when the child hard disk is not associated with any machine at all. When
* the backward merge is not applied, the method behaves as if the base hard
* disk were not attached at all -- i.e. simply detaches it from the machine but
* leaves the hard disk chain intact.
*
* This method is basically a wrapper around #mergeTo() that selects the correct
* merge direction and performs additional actions as described above and.
*
* Note that this method will not return until the merge operation is complete
* (which may be quite time consuming depending on the size of the merged hard
* disks).
*
* Note that #prepareDiscard() must be called before calling this method. If
* this method returns a failure, the caller must call #cancelDiscard(). On
* success, #cancelDiscard() must not be called (this method will perform all
* necessary steps such as resetting states of all involved hard disks and
* deleting @a aChain).
*
* @param aChain Merge chain created by #prepareDiscard() (may be NULL if
* no real merge takes place).
*
* @note Locks the hard disks from the chain for writing. Locks the machine
* object when the backward merge takes place. Locks treeLock() lock for
* reading or writing.
*/
{
{
AutoCaller autoCaller (this);
{
AutoWriteLock alock (this);
/* we access mParent & children() */
/* special treatment of the last hard disk in the chain: */
{
AssertComRC (rc);
return rc;
}
/* delete the differencing hard disk w/o children */
/* go back to Created since deleteStorage() expects this state */
m.state = MediaState_Created;
hdFrom = this;
}
else
{
}
}
{
/* mergeToAndWait() cannot uninitialize the initiator because of
* possible AutoCallers on the current thread, deleteStorageAndWait()
* doesn't do it either; do it ourselves */
}
return rc;
}
/**
* Undoes what #prepareDiscard() did. Must be called if #discard() is not called
* or fails. Frees memory occupied by @a aChain.
*
* @param aChain Merge chain created by #prepareDiscard() (may be NULL if
* no real merge takes place).
*
* @note Locks the hard disks from the chain for writing. Locks treeLock() for
* reading.
*/
{
AutoCaller autoCaller (this);
{
AutoWriteLock alock (this);
/* we access mParent & children() */
/* special treatment of the last hard disk in the chain: */
{
AssertComRC (rc);
return;
}
/* the differencing hard disk w/o children will be deleted, protect it
* from attaching to other VMs (this is why Deleting) */
m.state = MediaState_Created;
return;
}
/* delegate the rest to the profi */
}
/**
* Returns a preferred format for differencing hard disks.
*/
{
AutoCaller autoCaller (this);
/* mm.format is const, no need to lock */
/* check that our own format supports diffs */
{
/* use the default format if not */
}
return format;
}
// protected methods
////////////////////////////////////////////////////////////////////////////////
/**
* Deletes the hard disk storage unit.
*
* If @a aProgress is not NULL but the object it points to is @c null then a new
* progress object will be created and assigned to @a *aProgress on success,
* otherwise the existing progress object is used. If Progress is NULL, then no
*
* When @a aWait is @c false, this method will create a thread to perform the
* delete operation asynchronously and will return immediately. Otherwise, it
* will perform the operation on the calling thread and will not return to the
* caller until the operation is completed. Note that @a aProgress cannot be
* NULL when @a aWait is @c false (this method will assert in this case).
*
* completion.
* @param aWait @c true if this method should block instead of creating
* an asynchronous thread.
*
* @note Locks mVirtualBox and this object for writing. Locks treeLock() for
* writing.
*/
{
/* unregisterWithVirtualBox() needs a write lock. We want to unregister
* ourselves atomically after detecting that deletion is possible to make
* sure that we don't do that after another thread has done
* VirtualBox::findHardDisk2() but before it starts using us (provided that
* it holds a mVirtualBox lock too of course). */
AutoWriteLock alock (this);
return setError (VBOX_E_NOT_SUPPORTED,
tr ("Hard disk format '%ls' does not support storage deletion"),
/* Note that we are fine with Inaccessible state too: a) for symmetry with
* create calls and b) because it doesn't really harm to try, if it is
* really inaccessibke, the delete operation will fail anyway. Accepting
* Inaccessible state is especially important because all registered hard
* disks are initially Inaccessible upon VBoxSVC startup until
* COMGETTER(State) is called. */
switch (m.state)
{
case MediaState_Created:
case MediaState_Inaccessible:
break;
default:
return setStateError();
}
return setError (VBOX_E_OBJECT_IN_USE,
tr ("Hard disk '%ls' is attached to %d virtual machines"),
/* go to Deleting state before leaving the lock */
m.state = MediaState_Deleting;
/* we need to leave this object's write lock now because of
* unregisterWithVirtualBox() that locks treeLock() for writing */
/* try to remove from the list of known hard disks before performing actual
* deletion (we favor the consistency of the media registry in the first
* place which would have been broken if unregisterWithVirtualBox() failed
* after we successfully deleted the storage) */
/* restore the state because we may fail below; we will set it later again*/
m.state = MediaState_Created;
{
/* use the existing progress object... */
/* ...but create a new one if it is null */
{
m.locationFull.raw()),
FALSE /* aCancelable */);
}
}
if (aWait)
{
/* go to Deleting state before starting the task */
m.state = MediaState_Deleting;
}
else
{
/* go to Deleting state before leaving the lock */
m.state = MediaState_Deleting;
}
/* task is now owned (or already deleted) by taskThread() so release it */
{
/* return progress to the caller */
}
return rc;
}
/**
* Creates a new differencing storage unit using the given target hard disk's
* format and the location. Note that @c aTarget must be NotCreated.
*
* As opposed to the CreateDiffStorage() method, this method doesn't try to lock
* this hard disk for reading assuming that the caller has already done so. This
* is used when taking an online snaopshot (where all original hard disks are
* locked for writing and must remain such). Note however that if @a aWait is
* @c false and this method returns a success then the thread started by
* this method will unlock the hard disk (unless it is in
* MediaState_LockedWrite state) so make sure the hard disk is either in
* MediaState_LockedWrite or call #LockRead() before calling this method! If @a
* aWait is @c true then this method neither locks nor unlocks the hard disk, so
* make sure you do it yourself as needed.
*
* If @a aProgress is not NULL but the object it points to is @c null then a new
* progress object will be created and assigned to @a *aProgress on success,
* otherwise the existing progress object is used. If @a aProgress is NULL, then no
*
* When @a aWait is @c false, this method will create a thread to perform the
* create operation asynchronously and will return immediately. Otherwise, it
* will perform the operation on the calling thread and will not return to the
* caller until the operation is completed. Note that @a aProgress cannot be
* NULL when @a aWait is @c false (this method will assert in this case).
*
* @param aTarget Target hard disk.
* completion.
* @param aWait @c true if this method should block instead of creating
* an asynchronous thread.
*
* @note Locks this object and @a aTarget for writing.
*/
bool aWait)
{
AutoCaller autoCaller (this);
/* Note: MediaState_LockedWrite is ok when taking an online snapshot */
return aTarget->setStateError();
/* check that the hard disk is not attached to any VM in the current state*/
{
if (it->inCurState)
{
/* Note: when a VM snapshot is being taken, all normal hard disks
* attached to the VM in the current state will be, as an exception,
* also associated with the snapshot which is about to create (see
* SnapshotMachine::init()) before deassociating them from the
* current state (which takes place only on success in
* Machine::fixupHardDisks2()), so that the size of snapshotIds
* will be 1 in this case. The given condition is used to filter out
* this legal situatinon and do not report an error. */
{
return setError (VBOX_E_INVALID_OBJECT_STATE,
tr ("Hard disk '%ls' is attached to a virtual machine "
"with UUID {%RTuuid}. No differencing hard disks "
"based on it may be created until it is detached"),
}
}
}
{
/* use the existing progress object... */
/* ...but create a new one if it is null */
{
FALSE /* aCancelable */);
}
}
/* setup task object and thread to carry out the operation
* asynchronously */
/* register a task (it will deregister itself when done) */
++ mm.numCreateDiffTasks;
if (aWait)
{
/* go to Creating state before starting the task */
}
else
{
/* go to Creating state before leaving the lock */
}
/* task is now owned (or already deleted) by taskThread() so release it */
{
/* return progress to the caller */
}
return rc;
}
/**
* Prepares this (source) hard disk, target hard disk and all intermediate hard
* disks for the merge operation.
*
* This method is to be called prior to calling the #mergeTo() to perform
* necessary consistency checks and place involved hard disks to appropriate
* states. If #mergeTo() is not called or fails, the state modifications
* performed by this method must be undone by #cancelMergeTo().
*
* Note that when @a aIgnoreAttachments is @c true then it's the caller's
* responsibility to detach the source and all intermediate hard disks before
* calling #mergeTo() (which will fail otherwise).
*
* See #mergeTo() for more information about merging.
*
* @param aTarget Target hard disk.
* @param aChain Where to store the created merge chain.
* @param aIgnoreAttachments Don't check if the source or any intermediate
* hard disk is attached to any VM.
*
* @note Locks treeLock() for reading. Locks this object, aTarget and all
* intermediate hard disks for writing.
*/
MergeChain * &aChain,
bool aIgnoreAttachments /*= false*/)
{
AutoCaller autoCaller (this);
/* we walk the tree */
/* detect the merge direction */
bool forward;
{
forward = false;
else
{
if (parent == this)
forward = true;
else
{
{
AutoReadLock alock (this);
}
AutoReadLock alock (this);
tr ("Hard disks '%ls' and '%ls' are unrelated"),
}
}
}
/* build the chain (will do necessary checks and state changes) */
{
for (;;)
{
else if (last == this)
else
break;
}
}
return S_OK;
}
/**
* Merges this hard disk to the specified hard disk which must be either its
* direct ancestor or descendant.
*
* Given this hard disk is SOURCE and the specified hard disk is TARGET, we will
* get two varians of the merge operation:
*
* forward merge
* ------------------------->
* [Extra] <- SOURCE <- Intermediate <- TARGET
* Any Del Del LockWr
*
*
* backward merge
* <-------------------------
* TARGET <- Intermediate <- SOURCE <- [Extra]
* LockWr Del Del LockWr
*
* Each scheme shows the involved hard disks on the hard disk chain where
* SOURCE and TARGET belong. Under each hard disk there is a state value which
* the hard disk must have at a time of the mergeTo() call.
*
* The hard disks in the square braces may be absent (e.g. when the forward
* operation takes place and SOURCE is the base hard disk, or when the backward
* merge operation takes place and TARGET is the last child in the chain) but if
* they present they are involved too as shown.
*
* Nor the source hard disk neither intermediate hard disks may be attached to
* any VM directly or in the snapshot, otherwise this method will assert.
*
* The #prepareMergeTo() method must be called prior to this method to place all
* involved to necessary states and perform other consistency checks.
*
* If @a aWait is @c true then this method will perform the operation on the
* calling thread and will not return to the caller until the operation is
* completed. When this method succeeds, all intermediate hard disk objects in
* the chain will be uninitialized, the state of the target hard disk (and all
* involved extra hard disks) will be restored and @a aChain will be deleted.
* Note that this (source) hard disk is not uninitialized because of possible
* AutoCaller instances held by the caller of this method on the current thread.
* It's therefore the responsibility of the caller to call HardDisk2::uninit()
* after releasing all callers in this case!
*
* If @a aWait is @c false then this method will crea,te a thread to perform the
* create operation asynchronously and will return immediately. If the operation
* succeeds, the thread will uninitialize the source hard disk object and all
* intermediate hard disk objects in the chain, reset the state of the target
* hard disk (and all involved extra hard disks) and delete @a aChain. If the
* operation fails, the thread will only reset the states of all involved hard
* disks and delete @a aChain.
*
* When this method fails (regardless of the @a aWait mode), it is a caller's
* responsiblity to undo state changes and delete @a aChain using
* #cancelMergeTo().
*
* If @a aProgress is not NULL but the object it points to is @c null then a new
* progress object will be created and assigned to @a *aProgress on success,
* otherwise the existing progress object is used. If Progress is NULL, then no
* NULL when @a aWait is @c false (this method will assert in this case).
*
* @param aChain Merge chain created by #prepareMergeTo().
* completion.
* @param aWait @c true if this method should block instead of creating
* an asynchronous thread.
*
* @note Locks the branch lock for writing. Locks the hard disks from the chain
* for writing.
*/
bool aWait)
{
AutoCaller autoCaller (this);
{
/* use the existing progress object... */
/* ...but create a new one if it is null */
{
AutoReadLock alock (this);
FALSE /* aCancelable */);
}
}
/* setup task object and thread to carry out the operation
* asynchronously */
/* Note: task owns aChain (will delete it when not needed) in all cases
* except when @a aWait is @c true and runNow() fails -- in this case
* aChain will be left away because cancelMergeTo() will be applied by the
* caller on it as it is required in the documentation above */
if (aWait)
{
}
else
{
}
/* task is now owned (or already deleted) by taskThread() so release it */
{
/* return progress to the caller */
}
return rc;
}
/**
* Undoes what #prepareMergeTo() did. Must be called if #mergeTo() is not called
* or fails. Frees memory occupied by @a aChain.
*
* @param aChain Merge chain created by #prepareMergeTo().
*
* @note Locks the hard disks from the chain for writing.
*/
{
AutoCaller autoCaller (this);
/* the destructor will do the thing */
delete aChain;
}
// private methods
////////////////////////////////////////////////////////////////////////////////
/**
* Sets the value of m.location and calculates the value of m.locationFull.
*
* Reimplements MediumBase::setLocation() to specially treat non-FS-path
* locations and to prepend the default hard disk folder if the given location
* string does not contain any path information at all.
*
* Also, if the specified location is a file path that ends with '/' then the
* file name part will be generated by this method automatically in the format
* '{<uuid>}.<ext>' where <uuid> is a fresh UUID that this method will generate
* and assign to this medium, and <ext> is the default extension for this
* medium's storage format. Note that this procedure requires the media state to
* be NotCreated and will return a faiulre otherwise.
*
* @param aLocation Location of the storage unit. If the locaiton is a FS-path,
* then it can be relative to the VirtualBox home directory.
*
* @note Must be called from under this object's write lock.
*/
{
/// @todo so far, we assert but later it makes sense to support null
/// locations for hard disks that are not yet created fail to create a
/// storage unit instead
AutoCaller autoCaller (this);
/* formatObj may be null only when initializing from an existing path and
* no format is known yet */
E_FAIL);
/* are we dealing with a new hard disk constructed using the existing
* location? */
if (isImport ||
{
if (m.state == MediaState_NotCreated)
{
/* must be a file (formatObj must be already known) */
{
/* no file name is given (either an empty string or ends with a
* slash), generate a new UUID + file name if the state allows
* this */
("Must be at least one extension if it is "
"HardDiskFormatCapabilities_File\n"),
E_FAIL);
("Default extension must not be empty\n"),
E_FAIL);
}
}
/* append the default folder if no path is given */
if (!RTPathHavePath (location))
{
}
/* get the full file name */
if (RT_FAILURE (vrc))
return setError (VBOX_E_FILE_ERROR,
tr ("Invalid hard disk storage file location '%s' (%Rrc)"),
/* detect the backend from the storage unit if importing */
if (isImport)
{
char *backendName = NULL;
/* is it a file? */
{
if (RT_SUCCESS (vrc))
RTFileClose (file);
}
if (RT_SUCCESS (vrc))
{
}
{
/* assume it's not a file, restore the original location */
}
if (RT_FAILURE (vrc))
return setError (VBOX_E_IPRT_ERROR,
tr ("Could not get the storage format of the hard disk "
/* setFormat() must not fail since we've just used the backend so
* the format object must be there */
}
/* is it still a file? */
{
m.locationFull = locationFull;
if (m.state == MediaState_NotCreated)
{
/* assign a new UUID (this UUID will be used when calling
* VDCreateBase/VDCreateDiff as a wanted UUID). Note that we
* also do that if we didn't generate it to make sure it is
* either generated by us or reset to null */
}
}
else
{
m.location = locationFull;
m.locationFull = locationFull;
}
}
else
{
m.locationFull = aLocation;
}
return S_OK;
}
/**
* Checks that the format ID is valid and sets it on success.
*
* Note that this method will caller-reference the format object on success!
* This reference must be released somewhere to let the HardDiskFormat object be
* uninitialized.
*
* @note Must be called from under this object's write lock.
*/
{
/* get the format object first */
{
return setError (E_INVALIDARG,
/* reference the format permanently to prevent its unexpected
* uninitialization */
/* get properties (preinsert them as keys in the map). Note that the
* map doesn't grow over the object life time since the set of
* properties is meant to be constant. */
++ it)
{
}
}
return S_OK;
}
/**
* Queries information from the image file.
*
* As a result of this call, the accessibility state and data members such as
* size and description will be updated with the current information.
*
* Reimplements MediumBase::queryInfo() to query hard disk information using the
* VD backend interface.
*
* @note This method may block during a system I/O call that checks storage
* accessibility.
*
* @note Locks treeLock() for reading and writing (for new diff media checked
* for the first time). Locks mParent for reading. Locks this object for
* writing.
*/
{
AutoWriteLock alock (this);
m.state == MediaState_Inaccessible ||
m.state == MediaState_LockedRead ||
m.state == MediaState_LockedWrite,
E_FAIL);
int vrc = VINF_SUCCESS;
/* check if a blocking queryInfo() call is in progress on some other thread,
* and wait for it to finish if so instead of querying data ourselves */
if (m.queryInfoSem != NIL_RTSEMEVENTMULTI)
{
++ m.queryInfoCallers;
-- m.queryInfoCallers;
if (m.queryInfoCallers == 0)
{
/* last waiting caller deletes the semaphore */
}
return S_OK;
}
/* lazily create a semaphore for possible callers */
bool tempStateSet = false;
if (m.state != MediaState_LockedRead &&
m.state != MediaState_LockedWrite)
{
/* Cause other methods to prevent any modifications before leaving the
* lock. Note that clients will never see this temporary state change
* since any COMGETTER(State) is (or will be) blocked until we finish
* and restore the actual state. */
tempStateSet = true;
}
/* leave the lock before a blocking operation */
bool success = false;
try
{
/* are we dealing with a new hard disk constructed using the existing
* location? */
try
{
unsigned flags = VD_OPEN_FLAGS_INFO;
/* Note that we don't use VD_OPEN_FLAGS_READONLY when opening new
* hard disks because that would prevent necessary modifications
* when opening hard disks of some third-party formats for the first
* time in VirtualBox (such as VMDK for which VDOpen() needs to
* generate an UUID if it is missing) */
if (!isImport)
if (RT_FAILURE (vrc))
{
tr ("Could not open the hard disk '%ls'%s"),
throw S_OK;
}
{
/* check the UUID */
if (isImport)
{
}
else
{
{
tr ("UUID {%RTuuid} of the hard disk '%ls' does "
"not match the value {%RTuuid} stored in the "
"media registry ('%ls')"),
throw S_OK;
}
}
}
else
{
/* the backend does not support storing UUIDs within the
* underlying storage so use what we store in XML */
/* generate an UUID for an imported UUID-less hard disk */
if (isImport)
}
/* check the type */
if (type == VD_IMAGE_TYPE_DIFF)
{
if (isImport)
{
/* the parent must be known to us. Note that we freely
* call locking methods of mVirtualBox and parent from the
* write lock (breaking the {parent,child} lock order)
* because there may be no concurrent access to the just
* opened hard disk on ther threads yet (and init() will
* fail if this method reporst MediaState_Inaccessible) */
false /* aSetError */,
&parent);
{
tr ("Parent hard disk with UUID {%RTuuid} of the "
"hard disk '%ls' is not found in the media "
"registry ('%ls')"),
throw S_OK;
}
/* deassociate from VirtualBox, associate with parent */
mVirtualBox->removeDependentChild (this);
/* we set mParent & children() */
mParent->addDependentChild (this);
}
else
{
/* we access mParent */
/* check that parent UUIDs match. Note that there's no need
* for the parent's AutoCaller (our lifetime is bound to
* it) */
{
tr ("Hard disk '%ls' is differencing but it is not "
"associated with any parent hard disk in the "
"media registry ('%ls')"),
m.locationFull.raw(),
throw S_OK;
}
{
tr ("Parent UUID {%RTuuid} of the hard disk '%ls' "
"does not match UUID {%RTuuid} of its parent "
"hard disk stored in the media registry ('%ls')"),
throw S_OK;
}
/// @todo NEWMEDIA what to do if the parent is not
/// accessible while the diff is? Probably, nothing. The
/// real code will detect the mismatch anyway.
}
}
success = true;
}
{
}
}
{
}
if (success)
m.lastAccessError.setNull();
else
{
LogWarningFunc (("'%ls' is not accessible (error='%ls', "
"rc=%Rhrc, vrc=%Rrc)\n",
}
/* inform other callers if there are any */
if (m.queryInfoCallers > 0)
{
}
else
{
/* delete the semaphore ourselves */
}
if (tempStateSet)
{
/* Set the proper state according to the result of the check */
if (success)
m.state = MediaState_Created;
else
}
else
{
/* we're locked, use a special field to store the result */
m.accessibleInLock = success;
}
return rc;
}
/**
* @note Called from this object's AutoMayUninitSpan and from under mVirtualBox
* write lock.
*
* @note Locks treeLock() for reading.
*/
{
/* we access children */
tr ("Hard disk '%ls' has %d child hard disks"),
return S_OK;
}
/**
* @note Called from within this object's AutoWriteLock.
*/
const Guid &aSnapshotId)
{
if (mm.numCreateDiffTasks > 0)
tr ("One or more differencing child hard disks are "
"being created for the hard disk '%ls' (%u)"),
return S_OK;
}
/**
* @note Called from within this object's AutoMayUninitSpan (or AutoCaller) and
* from under mVirtualBox write lock.
*
* @note Locks treeLock() for writing.
*/
{
/* Note that we need to de-associate ourselves from the parent to let
* unregisterHardDisk2() properly save the registry */
/* we modify mParent and access children */
{
/* deassociate from the parent, associate with VirtualBox */
mVirtualBox->addDependentChild (this);
mParent->removeDependentChild (this);
}
{
{
/* re-associate with the parent as we are still relatives in the
* registry */
mParent->addDependentChild (this);
mVirtualBox->removeDependentChild (this);
}
}
return rc;
}
/**
* Returns the last error message collected by the vdErrorCall callback and
* resets it.
*
* The error message is returned prepended with a dot and a space, like this:
* <code>
* ". <error_text> (%Rrc)"
* </code>
* to make it easily appendable to a more general error message. The @c %Rrc
* format string is given @a aVRC as an argument.
*
* If there is no last error message collected by vdErrorCall or if it is a
* null or empty string, then this function returns the following text:
* <code>
* " (%Rrc)"
* </code>
*
* @note Doesn't do any object locking; it is assumed that the caller makes sure
* the callback isn't called by more than one thread at a time.
*
* @param aVRC VBox error code to use when no error message is provided.
*/
{
else
return error;
}
/**
* Error message callback.
*
* Puts the reported error message to the mm.vdError field.
*
* @note Doesn't do any object locking; it is assumed that the caller makes sure
* the callback isn't called by more than one thread at a time.
*
* @param pvUser The opaque data passed on container creation.
* @param rc The VBox error code.
* @param RT_SRC_POS_DECL Use RT_SRC_POS.
* @param pszFormat Error message format string.
* @param va Error message arguments.
*/
/*static*/
{
else
}
/**
* PFNVMPROGRESS callback handler for Task operations.
*
* @param uPercent Completetion precentage (0-100).
* @param pvUser Pointer to the Progress instance.
*/
/*static*/
void *pvUser)
{
{
/* update the progress object, capping it at 99% as the final percent
* is used for additional operations like setting the UUIDs and similar. */
}
return VINF_SUCCESS;
}
/* static */
const char *pszzValid)
{
/* we always return true since the only keys we have are those found in
* VDBACKENDINFO */
return true;
}
/* static */
{
return VERR_CFGM_VALUE_NOT_FOUND;
/* we interpret null values as "no value" in HardDisk2 */
return VERR_CFGM_VALUE_NOT_FOUND;
return VINF_SUCCESS;
}
/* static */
{
return VERR_CFGM_VALUE_NOT_FOUND;
return VERR_CFGM_NOT_ENOUGH_SPACE;
/* we interpret null values as "no value" in HardDisk2 */
return VERR_CFGM_VALUE_NOT_FOUND;
return VINF_SUCCESS;
}
/**
* Thread function for time-consuming tasks.
*
* The Task structure passed to @a pvUser must be allocated using new and will
* be freed by this method before it returns.
*
* @param pvUser Pointer to the Task instance.
*/
/* static */
{
/// @todo ugly hack, fix ComAssert... later
/* Note: no need in AutoCaller because Task does that */
{
////////////////////////////////////////////////////////////////////////
case Task::CreateDynamic:
case Task::CreateFixed:
{
/* The lock is also used as a signal from the task initiator (which
* releases it only after RTThreadCreate()) that we can start the job */
/* these parameters we need after creation */
/* The object may request a specific UUID (through a special form of
* the setLocation() argumet). Otherwise we have to generate it */
if (generateUuid)
{
/* VirtualBox::registerHardDisk2() will need UUID */
}
try
{
/* unlock before the potentially lengthy operation */
try
{
/* ensure the directory exists */
/* needed for vdProgressCallback */
if (RT_FAILURE (vrc))
{
tr ("Could not create the hard disk storage "
"unit '%s'%s"),
}
}
}
{
/* register with mVirtualBox as the last step and move to
* Created state only on success (leaving an orphan file is
* better than breaking media registry consistency) */
}
{
}
else
{
/* back to NotCreated on failiure */
/* reset UUID to prevent it from being reused next time */
if (generateUuid)
}
break;
}
////////////////////////////////////////////////////////////////////////
case Task::CreateDiff:
{
/* Lock both in {parent,child} order. The lock is also used as a
* signal from the task initiator (which releases it only after
* RTThreadCreate()) that we can start the job*/
/* The object may request a specific UUID (through a special form of
* the setLocation() argument). Otherwise we have to generate it */
if (generateUuid)
{
/* VirtualBox::registerHardDisk2() will need UUID */
}
try
{
/* Note: MediaState_LockedWrite is ok when taking an online
* snapshot */
/* unlock before the potentially lengthy operation */
try
{
if (RT_FAILURE (vrc))
{
tr ("Could not open the hard disk storage "
"unit '%s'%s"),
}
/* ensure the target directory exists */
/* needed for vdProgressCallback */
if (RT_FAILURE (vrc))
{
tr ("Could not create the differencing hard disk "
"storage unit '%s'%s"),
}
}
}
{
/* we set mParent & children() (note that thatLock is released
* here), but lock VirtualBox first to follow the rule */
/* associate the child with the parent and deassociate from
* VirtualBox */
/* register with mVirtualBox as the last step and move to
* Created state only on success (leaving an orphan file is
* better than breaking media registry consistency) */
{
/* break the parent association on failure to register */
}
}
{
}
else
{
/* back to NotCreated on failiure */
/* reset UUID to prevent it from being reused next time */
if (generateUuid)
}
if (isAsync)
{
/* unlock ourselves when done (unless in MediaState_LockedWrite
* state because of taking the online snapshot*/
{
AssertComRC (rc2);
}
}
/* deregister the task registered in createDiffStorage() */
/* Note that in sync mode, it's the caller's responsibility to
* unlock the hard disk */
break;
}
////////////////////////////////////////////////////////////////////////
{
/* The lock is also used as a signal from the task initiator (which
* releases it only after RTThreadCreate()) that we can start the
* job. We don't actually need the lock for anything else since the
* object is protected by MediaState_Deleting and we don't modify
* its sensitive fields below */
{
}
#if 0
#endif
try
{
try
{
/* open all hard disks in the chain (they are in the
* {parent,child} order in there. Note that we don't lock
* objects in this chain since they must be in states
* (Deleting and LockedWrite) that prevent from chaning
* their format and location fields from outside. */
{
/* complex sanity (sane complexity) */
/* open the first image with VDOPEN_FLAGS_INFO because
* it's not necessarily the base one */
VD_OPEN_FLAGS_INFO : 0,
if (RT_FAILURE (vrc))
throw vrc;
#if 0
LogFlow (("*** MERGE disk = %ls\n",
#endif
}
/* needed for vdProgressCallback */
#if 0
#endif
if (RT_FAILURE (vrc))
throw vrc;
/* update parent UUIDs */
/// @todo VDMerge should be taught to do so, including the
/// multiple children case
{
/* target's UUID needs to be updated (note that target
* is the only image in the container on success) */
if (RT_FAILURE (vrc))
throw vrc;
}
else
{
/* we need to update UUIDs of all source's children
* which cannot be part of the container at once so
* add each one in there individually */
{
{
/* VD_OPEN_FLAGS_INFO since UUID is wrong yet */
if (RT_FAILURE (vrc))
throw vrc;
if (RT_FAILURE (vrc))
throw vrc;
if (RT_FAILURE (vrc))
throw vrc;
}
}
}
}
catch (int aVRC)
{
tr ("Could not merge the hard disk '%ls' to '%ls'%s"),
}
}
bool saveSettingsFailed = false;
{
/* all hard disks but the target were successfully deleted by
* VDMerge; reparent the last one and uninitialize deleted */
/* we set mParent & children() (note that thatLock is released
* here), but lock VirtualBox first to follow the rule */
{
/* first, unregister the target since it may become a base
* hard disk which needs re-registration */
AssertComRC (rc2);
/* then, reparent it and disconnect the deleted branch at
* both ends (chain->parent() is source's parent) */
{
}
else
{
}
/* then, register again */
AssertComRC (rc2);
}
else
{
/* disconnect the deleted branch at the elder end */
/* reparent source's chidren and disconnect the deleted
* branch at the younger end m*/
{
/* obey {parent,child} lock order */
{
}
}
}
/* try to save the hard disk registry */
{
/* unregister and uninitialize all hard disks in the chain
* but the target */
{
{
++ it;
continue;
}
AssertComRC (rc2);
/* now, uninitialize the deleted hard disk (note that
* due to the Deleting state, uninit() will not touch
* the parent-child relationship so we need to
* uninitialize each disk individually) */
/* note that the operation initiator hard disk (which is
* normally also the source hard disk) is a special case
* -- there is one more caller added by Task to it which
* we must release. Also, if we are in sync mode, the
* caller may still hold an AutoCaller instance for it
* and therefore we cannot uninit() it (it's therefore
* the caller's responsibility) */
/* release the caller added by MergeChain before
* uninit() */
(*it)->releaseCaller();
/* delete (to prevent uninitialization in MergeChain
* dtor) and advance to the next item */
}
/* Note that states of all other hard disks (target, parent,
* children) will be restored by the MergeChain dtor */
}
else
{
/* too bad if we fail, but we'll need to rollback everything
* we did above to at least keep the HD tree in sync with
* the current registry on disk */
saveSettingsFailed = true;
/// @todo NEWMEDIA implement a proper undo
AssertFailed();
}
}
{
/* Here we come if either VDMerge() failed (in which case we
* assume that it tried to do everything to make a further
* retry possible -- e.g. not deleted intermediate hard disks
* and so on) or VirtualBox::saveSettings() failed (where we
* should have the original tree but with intermediate storage
* units deleted by VDMerge()). We have to only restore states
* (through the MergeChain dtor) unless we are run synchronously
* in which case it's the responsibility of the caller as stated
* in the mergeTo() docs. The latter also implies that we
* don't own the merge chain, so release it in this case. */
if (!isAsync)
}
break;
}
////////////////////////////////////////////////////////////////////////
{
/* Lock both in {parent,child} order. The lock is also used as a
* signal from the task initiator (which releases it only after
* RTThreadCreate()) that we can start the job*/
/* The object may request a specific UUID (through a special form of
* the setLocation() argumet). Otherwise we have to generate it */
if (generateUuid)
{
/* VirtualBox::registerHardDisk2() will need UUID */
}
try
{
/* unlock before the potentially lengthy operation */
try
{
if (RT_FAILURE (vrc))
{
tr ("Could not open the hard disk storage "
"unit '%s'%s"),
}
/* ensure the target directory exists */
/* needed for vdProgressCallback */
if (RT_FAILURE (vrc))
{
tr ("Could not create the clone hard disk "
"'%s'%s"),
}
}
}
{
/* we set mParent & children() (note that thatLock is released
* here), but lock VirtualBox first to follow the rule */
{
/* associate the clone with the original's parent and
* deassociate from VirtualBox */
/* register with mVirtualBox as the last step and move to
* Created state only on success (leaving an orphan file is
* better than breaking media registry consistency) */
{
/* break the parent association on failure to register */
}
}
else
{
/* just register */
}
}
{
}
else
{
/* back to NotCreated on failiure */
/* reset UUID to prevent it from being reused next time */
if (generateUuid)
}
if (isAsync)
{
/* unlock ourselves when done (unless in MediaState_LockedWrite
* state because of taking the online snapshot*/
{
AssertComRC (rc2);
}
}
/* Note that in sync mode, it's the caller's responsibility to
* unlock the hard disk */
break;
}
////////////////////////////////////////////////////////////////////////
{
/* The lock is also used as a signal from the task initiator (which
* releases it only after RTThreadCreate()) that we can start the job */
try
{
/* unlock before the potentially lengthy operation */
try
{
if (RT_SUCCESS (vrc))
if (RT_FAILURE (vrc))
{
tr ("Could not delete the hard disk storage "
"unit '%s'%s"),
}
}
}
/* go to the NotCreated state even on failure since the storage
* may have been already partially deleted and cannot be used any
* more. One will be able to manually re-open the storage if really
* needed to re-register it. */
/* Reset UUID to prevent Create* from reusing it again */
break;
}
default:
}
/* complete the progress if run asynchronously */
if (isAsync)
{
}
else
{
}
return VINF_SUCCESS;
/// @todo ugly hack, fix ComAssert... later
}
/* vi: set tabstop=4 shiftwidth=4 expandtab: */