Changeset 953 in vbox

Timestamp:

Feb 16, 2007 3:45:20 PM (18 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

18705

Message:

Main: Prototyped IVMDKImage.

Location:

trunk/src/VBox

Files:

• Frontends/VBoxSDL/VBoxSDL.cpp (modified) (1 diff)
• Frontends/VirtualBox/include/VBoxGlobal.h (modified) (3 diffs)
• Frontends/VirtualBox/src/VBoxGlobal.cpp (modified) (6 diffs)
• Main/HardDiskImpl.cpp (modified) (4 diffs)
• Main/VirtualBoxImpl.cpp (modified) (1 diff)
• Main/idl/VirtualBox.xidl (modified) (11 diffs)
• Main/include/HardDiskImpl.h (modified) (2 diffs)
• Main/include/VirtualBoxImpl.h (modified) (1 diff)
• Main/linux/server.cpp (modified) (1 diff)

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

@@ -301 +301 @@
         }
 #endif /* VBOX_SECURELABEL */
+        return S_OK;
+    }
+
+    STDMETHOD(OnMediaRegistered) (INPTR GUIDPARAM mediaId, DeviceType_T mediaType,
+                                  BOOL registered)
+    {
+        NOREF (mediaId);
+        NOREF (mediaType);
+        NOREF (registered);
         return S_OK;
     }

trunk/src/VBox/Frontends/VirtualBox/include/VBoxGlobal.h

@@ -323 +323 @@
     /* details generators */
 
-    QString details (const CHardDisk &aHD, bool aPredict = false) const;
+    QString details (const CHardDisk &aHD, bool aPredict = false);
 
     QString details (const CUSBDevice &aDevice) const;
@@ -330 +330 @@
     QString prepareFileNameForHTML (const QString &fn) const;
 
-    QString detailsReport (const CMachine &m, bool isNewVM, bool withLinks) const;
+    QString detailsReport (const CMachine &m, bool isNewVM, bool withLinks);
 
     /* VirtualBox helpers */
@@ -354 +354 @@
     void updateMedia (const VBoxMedia &);
     void removeMedia (VBoxDefs::DiskType, const QUuid &);
+
+    bool findMedia (const CUnknown &, VBoxMedia &) const;
 
     /* various helpers */

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

@@ -188 +188 @@
             }
         }
+        return S_OK;
+    }
+
+    STDMETHOD(OnMediaRegistered) (IN_GUIDPARAM id, DeviceType_T type,
+                                  BOOL registered)
+    {
+        /** @todo */
+        Q_UNUSED (id);
+        Q_UNUSED (type);
+        Q_UNUSED (registered);
         return S_OK;
     }
@@ -575 +585 @@
  *                  (with the exception mentioned above).
  */
-QString VBoxGlobal::details (const CHardDisk &aHD, bool aPredict /* = false */) const
+QString VBoxGlobal::details (const CHardDisk &aHD, bool aPredict /* = false */)
 {
     Assert (!aPredict || aHD.GetParent().isNull());
+
+/// @todo (r=dmik) later: we need to keep *all* media (including all hard disk
+//  children) in the current media list in order for the following to work.
+//    VBoxMedia media;
+//    if (!findMedia (CUnknown (aHD), media))
+//    {
+//        /* media may be new and not alredy in the media list, request refresh */
+//        startEnumeratingMedia();
+//        if (!findMedia (CUnknown (aHD), media))
+//            AssertFailed();
+//    }
 
     CHardDisk root = aHD.GetRoot();
@@ -590 +611 @@
         details = hardDiskTypeString (root);
 
-    details += ", " + formatSize (root.GetSize() * _1M);
+    details += ", ";
+
+    /// @todo (r=dmik) prepend the details with the warning/error
+    //  icon when not accessible
+
+/// @todo (r=dmik) later: we need to keep *all* media (including all hard disk
+//  children) in the current media list in order for the following to work.
+//    switch (media.status)
+//    {
+//        case VBoxMedia::Unknown:
+//            details += tr ("<i>Checking...</i>", "hard disk");
+//            break;
+//        case VBoxMedia::Ok:
+            details += formatSize (root.GetSize() * _1M);
+//            break;
+//        case VBoxMedia::Error:
+//        case VBoxMedia::Inaccessible:
+//            details += tr ("Inaccessible", "hard disk");
+//            break;
+//    }
 
     return details;
@@ -674 +714 @@
  *  @param withLinks    true if section titles should be hypertext links
  */
-QString VBoxGlobal::detailsReport (
-    const CMachine &m, bool isNewVM, bool withLinks) const
+QString VBoxGlobal::detailsReport (const CMachine &m, bool isNewVM,
+                                   bool withLinks)
 {
     static const char *sTableTpl =
@@ -1267 +1307 @@
 
 /**
+ *  Searches for a VBoxMedia object representing the given COM media object.
+ *
+ *  @return true if found and false otherwise.
+ */
+bool VBoxGlobal::findMedia (const CUnknown &aObj, VBoxMedia &aMedia) const
+{
+    for (VBoxMediaList::ConstIterator it = media_list.begin();
+         it != media_list.end(); ++ it)
+    {
+        if ((*it).disk == aObj)
+        {            
+            aMedia = (*it);
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+/**
  *  Changes the language of all global string constants according to the
  *  currently installed translations tables.
@@ -1286 +1346 @@
     sessionStates [CEnums::SessionOpen] =       tr ("Open", "SessionState");
     sessionStates [CEnums::SessionSpawning] =   tr ("Spawning", "SessionState");
-    sessionStates [CEnums::SessionClosing] =   tr ("Closing", "SessionState");
+    sessionStates [CEnums::SessionClosing] =    tr ("Closing", "SessionState");
 
     deviceTypes [CEnums::NoDevice] =        tr ("None", "DeviceType");

trunk/src/VBox/Main/HardDiskImpl.cpp

@@ -1005 +1005 @@
         (*it)->updatePaths (aOldPath, aNewPath);
     }
+}
+
+/** 
+ *  Helper method that deduces a hard disk object type to create from
+ *  the location string format and from the contents of the resource
+ *  pointed to by the location string.
+ *
+ *  Currently, the location string must be a file path which is
+ *  passed to the HVirtualDiskImage or HVMDKImage initializer in
+ *  attempt to create a hard disk object.
+ * 
+ *  @param  aVirtualBox 
+ *  @param  aLocation 
+ *  @param  hardDisk 
+ * 
+ *  @return 
+ */
+/* static */
+HRESULT HardDisk::openHardDisk (VirtualBox *aVirtualBox, INPTR BSTR aLocation,
+                                ComObjPtr <HardDisk> &hardDisk)
+{
+    AssertReturn (aVirtualBox, E_POINTER);
+
+    /* null and empty strings are not allowed locations */
+    AssertReturn (aLocation, E_INVALIDARG);
+    AssertReturn (*aLocation, E_INVALIDARG);
+
+    HRESULT rc = S_OK;
+
+    /* try to guess the probe order by extension */
+    Utf8Str loc = aLocation;
+    char *ext = RTPathExt (loc);
+
+    HardDiskStorageType_T order [2];
+
+    if (RTPathCompare (ext, "vmdk") == 0)
+    {
+        order [0] = HardDiskStorageType_VMDKImage;
+        order [1] = HardDiskStorageType_VirtualDiskImage;
+    }
+    else
+    {
+        order [0] = HardDiskStorageType_VirtualDiskImage;
+        order [1] = HardDiskStorageType_VMDKImage;
+    }
+
+    for (size_t i = 0; i < ELEMENTS (order) && SUCCEEDED (rc); ++ i)
+    {
+        switch (order [i])
+        {
+            case HardDiskStorageType_VirtualDiskImage:
+            {
+                ComObjPtr <HVirtualDiskImage> obj;
+                obj.createObject();
+                rc = obj->init (aVirtualBox, NULL, aLocation,
+                                FALSE /* aRegistered */);
+                if (SUCCEEDED (rc))
+                {
+                    hardDisk = obj;
+                    return rc;
+                }
+                break;
+            }
+            case HardDiskStorageType_VMDKImage:
+            {
+                ComObjPtr <HVMDKImage> obj;
+                obj.createObject();
+                rc = obj->init (aVirtualBox, NULL, aLocation,
+                                FALSE /* aRegistered */);
+                if (SUCCEEDED (rc))
+                {
+                    hardDisk = obj;
+                    return rc;
+                }
+                break;
+            }
+            default:
+            {
+                rc = E_FAIL;
+                ComAssertComRCBreak (E_FAIL, rc = rc);
+            }
+        }
+    }
+
+    return rc;
 }
 
@@ -1198 +1283 @@
  *
  *  @param aHDNode      <HardDisk> node
- *  @param aVDINod      <VirtualDiskImage> node
+ *  @param aVDINode     <VirtualDiskImage> node
  */
 HRESULT HVirtualDiskImage::init (VirtualBox *aVirtualBox, HardDisk *aParent,
@@ -1425 +1510 @@
     if (mState != NotCreated)
         return setError (E_ACCESSDENIED,
-            tr ("Cannot change the file path of the existing VDI hard disk '%ls'"),
+            tr ("Cannot change the file path of the existing hard disk '%ls'"),
             toString().raw());
 
@@ -3170 +3255 @@
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// HVMDKImage class
+////////////////////////////////////////////////////////////////////////////////
+
+// constructor / destructor
+////////////////////////////////////////////////////////////////////////////////
+
+HRESULT HVMDKImage::FinalConstruct()
+{
+    HRESULT rc = HardDisk::FinalConstruct();
+    if (FAILED (rc))
+        return rc;
+
+    mState = NotCreated;
+
+    mStateCheckSem = NIL_RTSEMEVENTMULTI;
+    mStateCheckWaiters = 0;
+
+    mSize = 0;
+    mActualSize = 0;
+
+    return S_OK;
+}
+
+void HVMDKImage::FinalRelease()
+{
+    HardDisk::FinalRelease();
+}
+
+// public initializer/uninitializer for internal purposes only
+////////////////////////////////////////////////////////////////////////////////
+
+// public methods for internal purposes only
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Initializes the VMDK hard disk object by reading its properties from
+ *  the given configuration node. The created hard disk will be marked as
+ *  registered on success.
+ *
+ *  @param aHDNode      <HardDisk> node
+ *  @param aVMDKNode    <VirtualDiskImage> node
+ */
+HRESULT HVMDKImage::init (VirtualBox *aVirtualBox, HardDisk *aParent,
+                          CFGNODE aHDNode, CFGNODE aVMDKNode)
+{
+    LogFlowMember (("HVMDKImage::init (load)\n"));
+
+    AssertReturn (aHDNode && aVMDKNode, E_FAIL);
+
+    AutoLock alock (this);
+    ComAssertRet (!isReady(), E_UNEXPECTED);
+
+    mStorageType = HardDiskStorageType_VMDKImage;
+
+    HRESULT rc = S_OK;
+
+    do
+    {
+        rc = protectedInit (aVirtualBox, aParent);
+        CheckComRCBreakRC (rc);
+
+        /* set ready to let protectedUninit() be called on failure */
+        setReady (true);
+
+        /* filePath (required) */
+        Bstr filePath;
+        CFGLDRQueryBSTR (aVMDKNode, "filePath", filePath.asOutParam());
+
+        rc = setFilePath (filePath);
+        CheckComRCBreakRC (rc);
+
+        LogFlowMember ((" '%ls'\n", mFilePathFull.raw()));
+
+        /* load basic settings and children */
+        rc = loadSettings (aHDNode);
+        CheckComRCBreakRC (rc);
+
+        mState = Created;
+        mRegistered = TRUE;
+
+        /* Don't call queryInformation() for registered hard disks to
+         * prevent the calling thread (i.e. the VirtualBox server startup
+         * thread) from an unexpected freeze. The vital mId property (UUID)
+         * is read from the registry file in loadSettings(). To get the rest,
+         * the user will have to call COMGETTER(Accessible) manually. */
+    }
+    while (0);
+
+    if (FAILED (rc))
+        uninit();
+
+    return rc;
+}
+
+/**
+ *  Initializes the VMDK hard disk object using the given image file name.
+ *
+ *  @param aVirtualBox  VirtualBox parent.
+ *  @param aParent      Currently, must always be NULL.
+ *  @param aFilePath    path to the image file (can be NULL to create an
+ *                      imageless object)
+ *  @param aRegistered  whether to mark this disk as registered or not
+ *                      (ignored when \a aFilePath is NULL, assuming FALSE)
+ */
+HRESULT HVMDKImage::init (VirtualBox *aVirtualBox, HardDisk *aParent,
+                          const BSTR aFilePath, BOOL aRegistered /* = FALSE */)
+{
+    LogFlowMember (("HVirtualDiskImage::init (aFilePath='%ls', aRegistered=%d)\n",
+                    aFilePath, aRegistered));
+
+    AssertReturn (aParent == NULL, E_FAIL);
+
+    AutoLock alock (this);
+    ComAssertRet (!isReady(), E_UNEXPECTED);
+
+    mStorageType = HardDiskStorageType_VirtualDiskImage;
+
+    HRESULT rc = S_OK;
+
+    do
+    {
+        rc = protectedInit (aVirtualBox, aParent);
+        CheckComRCBreakRC (rc);
+
+        /* set ready to let protectedUninit() be called on failure */
+        setReady (true);
+
+        rc = setFilePath (aFilePath);
+        CheckComRCBreakRC (rc);
+
+        Assert (mId.isEmpty());
+        
+        if (aFilePath && *aFilePath)
+        {
+            mRegistered = aRegistered;
+            mState = Created;
+
+            /* Call queryInformation() anyway (even if it will block), because
+             * it is the only way to get the UUID of the existing VDI and
+             * initialize the vital mId property. */
+            Bstr errMsg;
+            rc = queryInformation (&errMsg);
+            if (SUCCEEDED (rc))
+            {
+                /* We are constructing a new HVirtualDiskImage object. If there
+                 * is a fatal accessibility error (we cannot read image UUID),
+                 * we have to fail. We do so even on non-fatal errors as well,
+                 * because it's not worth to keep going with the inaccessible
+                 * image from the very beginning (when nothing else depends on
+                 * it yet). */
+                if (!errMsg.isNull())
+                    rc = setErrorBstr (E_FAIL, errMsg);
+            }
+        }
+        else
+        {
+            mRegistered = FALSE;
+            mState = NotCreated;
+            mId.create();
+        }
+    }
+    while (0);
+
+    if (FAILED (rc))
+        uninit();
+
+    return rc;
+}
+
+/**
+ *  Uninitializes the instance and sets the ready flag to FALSE.
+ *  Called either from FinalRelease(), by the parent when it gets destroyed,
+ *  or by a third party when it decides this object is no more valid.
+ */
+void HVMDKImage::uninit()
+{
+    LogFlowMember (("HVMDKImage::uninit()\n"));
+
+    AutoLock alock (this);
+    if (!isReady())
+        return;
+
+    HardDisk::protectedUninit (alock);
+}
+
+// IHardDisk properties
+////////////////////////////////////////////////////////////////////////////////
+
+STDMETHODIMP HVMDKImage::COMGETTER(Description) (BSTR *aDescription)
+{
+    if (!aDescription)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    mDescription.cloneTo (aDescription);
+    return S_OK;
+}
+
+STDMETHODIMP HVMDKImage::COMSETTER(Description) (INPTR BSTR aDescription)
+{
+    AutoLock alock (this);
+    CHECK_READY();
+
+    CHECK_BUSY_AND_READERS();
+
+    return E_NOTIMPL;
+
+/// @todo (r=dmik) implement
+
+//     if (mState >= Created)
+//     {
+//         int vrc = VDISetImageComment (Utf8Str (mFilePathFull), Utf8Str (aDescription));
+//         if (VBOX_FAILURE (vrc))
+//             return setError (E_FAIL,
+//                 tr ("Could not change the description of the VDI hard disk '%ls' "
+//                     "(%Vrc)"),
+//                 toString().raw(), vrc);
+//     }
+
+//     mDescription = aDescription;
+//     return S_OK;
+}
+
+STDMETHODIMP HVMDKImage::COMGETTER(Size) (ULONG64 *aSize)
+{
+    if (!aSize)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+/// @todo (r=dmik) later
+
+//     /* only a non-differencing image knows the logical size */
+//     if (isDifferencing())
+//         return root()->COMGETTER(Size) (aSize);
+
+    *aSize = mSize;
+    return S_OK;
+}
+
+STDMETHODIMP HVMDKImage::COMGETTER(ActualSize) (ULONG64 *aActualSize)
+{
+    if (!aActualSize)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    *aActualSize = mActualSize;
+    return S_OK;
+}
+
+// IVirtualDiskImage properties
+////////////////////////////////////////////////////////////////////////////////
+
+STDMETHODIMP HVMDKImage::COMGETTER(FilePath) (BSTR *aFilePath)
+{
+    if (!aFilePath)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    mFilePathFull.cloneTo (aFilePath);
+    return S_OK;
+}
+
+STDMETHODIMP HVMDKImage::COMSETTER(FilePath) (INPTR BSTR aFilePath)
+{
+    AutoLock alock (this);
+    CHECK_READY();
+
+    if (mState != NotCreated)
+        return setError (E_ACCESSDENIED,
+            tr ("Cannot change the file path of the existing hard disk '%ls'"),
+            toString().raw());
+
+    CHECK_BUSY_AND_READERS();
+
+    /* append the default path if only a name is given */
+    Bstr path = aFilePath;
+    if (aFilePath && *aFilePath)
+    {
+        Utf8Str fp = aFilePath;
+        if (!RTPathHavePath (fp))
+        {
+            AutoReaderLock propsLock (mVirtualBox->systemProperties());
+            path = Utf8StrFmt ("%ls%c%s",
+                               mVirtualBox->systemProperties()->defaultVDIFolder().raw(),
+                               RTPATH_DELIMITER,
+                               fp.raw());
+        }
+    }
+
+    return setFilePath (path);
+}
+
+STDMETHODIMP HVMDKImage::COMGETTER(Created) (BOOL *aCreated)
+{
+    if (!aCreated)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    *aCreated = mState >= Created;
+    return S_OK;
+}
+
+// IVMDKImage methods
+/////////////////////////////////////////////////////////////////////////////
+
+STDMETHODIMP HVMDKImage::CreateDynamicImage (ULONG64 aSize, IProgress **aProgress)
+{
+    if (!aProgress)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    return createImage (aSize, TRUE /* aDynamic */, aProgress);
+}
+
+STDMETHODIMP HVMDKImage::CreateFixedImage (ULONG64 aSize, IProgress **aProgress)
+{
+    if (!aProgress)
+        return E_POINTER;
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    return createImage (aSize, FALSE /* aDynamic */, aProgress);
+}
+
+STDMETHODIMP HVMDKImage::DeleteImage()
+{
+    AutoLock alock (this);
+    CHECK_READY();
+    CHECK_BUSY_AND_READERS();
+
+    if (mRegistered)
+        return setError (E_ACCESSDENIED,
+             tr ("Cannot delete an image of the registered hard disk image '%ls"),
+             mFilePathFull.raw());
+    if (mState == NotCreated)
+        return setError (E_FAIL,
+             tr ("Hard disk image has been already deleted or never created"));
+
+    int vrc = RTFileDelete (Utf8Str (mFilePathFull));
+    if (VBOX_FAILURE (vrc))
+        return setError (E_FAIL, tr ("Could not delete the image file '%ls' (%Vrc)"),
+                         mFilePathFull.raw(), vrc);
+
+    mState = NotCreated;
+
+    /* reset the fields */
+    mSize = 0;
+    mActualSize = 0;
+
+    return S_OK;
+}
+
+// public/protected methods for internal purposes only
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Attempts to mark the hard disk as registered.
+ *  Only VirtualBox can call this method.
+ */
+HRESULT HVMDKImage::trySetRegistered (BOOL aRegistered)
+{
+    AutoLock alock (this);
+    CHECK_READY();
+
+    if (aRegistered)
+    {
+        if (mState == NotCreated)
+            return setError (E_FAIL,
+                tr ("Image file '%ls' is not yet created for this hard disk"),
+                mFilePathFull.raw());
+/// @todo (r=dmik) later?
+//         if (isDifferencing())
+//             return setError (E_FAIL,
+//                 tr ("Hard disk '%ls' is differencing and cannot be unregistered "
+//                     "explicitly"),
+//                 mFilePathFull.raw());
+    }
+    else
+    {
+        ComAssertRet (mState >= Created, E_FAIL);
+    }
+
+    return HardDisk::trySetRegistered (aRegistered);
+}
+
+/**
+ *  Checks accessibility of this hard disk image only (w/o parents).
+ *
+ *  @param aAccessError on output, a null string indicates the hard disk is
+ *                      accessible, otherwise contains a message describing
+ *                      the reason of inaccessibility.
+ */
+HRESULT HVMDKImage::getAccessible (Bstr &aAccessError)
+{
+    AutoLock alock (this);
+    CHECK_READY();
+
+    if (mStateCheckSem != NIL_RTSEMEVENTMULTI)
+    {
+        /* An accessibility check in progress on some other thread,
+         * wait for it to finish. */
+
+        ComAssertRet (mStateCheckWaiters != (ULONG) ~0, E_FAIL);
+        ++ mStateCheckWaiters;
+        alock.leave();
+        
+        int vrc = RTSemEventMultiWait (mStateCheckSem, RT_INDEFINITE_WAIT);
+
+        alock.enter();
+        AssertReturn (mStateCheckWaiters != 0, E_FAIL);
+        -- mStateCheckWaiters;
+        if (mStateCheckWaiters == 0)
+        {
+            RTSemEventMultiDestroy (mStateCheckSem);
+            mStateCheckSem = NIL_RTSEMEVENTMULTI;
+        }
+        
+        AssertRCReturn (vrc, E_FAIL);
+
+        /* don't touch aAccessError, it has been already set */
+        return S_OK;
+    }
+
+    /* check the basic accessibility */
+    HRESULT rc = getBaseAccessible (aAccessError, true /* aCheckBusy */);
+    if (FAILED (rc) || !aAccessError.isNull())
+        return rc;
+
+    if (mState >= Created)
+    {
+        return queryInformation (&aAccessError);
+    }
+
+    aAccessError = Utf8StrFmt ("Hard disk image '%ls' is not yet created",
+                               mFilePathFull.raw());
+    return S_OK;
+}
+
+/**
+ *  Saves hard disk settings to the specified storage node and saves
+ *  all children to the specified hard disk node
+ *
+ *  @param aHDNode      <HardDisk> or <DiffHardDisk> node
+ *  @param aStorageNode <VirtualDiskImage> node
+ */
+HRESULT HVMDKImage::saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode)
+{
+    AssertReturn (aHDNode && aStorageNode, E_FAIL);
+
+    AutoLock alock (this);
+    CHECK_READY();
+
+    /* filePath (required) */
+    CFGLDRSetBSTR (aStorageNode, "filePath", mFilePath);
+
+    /* save basic settings and children */
+    return HardDisk::saveSettings (aHDNode);
+}
+
+/**
+ *  Checks if the given change of \a aOldPath to \a aNewPath affects the path
+ *  of this hard disk and updates it if necessary to reflect the new location.
+ *  Intended to be from HardDisk::updatePaths().
+ *
+ *  @param aOldPath old path (full)
+ *  @param aNewPath new path (full)
+ *
+ *  @note Locks this object for writing.
+ */
+void HVMDKImage::updatePath (const char *aOldPath, const char *aNewPath)
+{
+    AssertReturnVoid (aOldPath);
+    AssertReturnVoid (aNewPath);
+
+    AutoLock alock (this);
+    AssertReturnVoid (isReady());
+
+    size_t oldPathLen = strlen (aOldPath);
+
+    Utf8Str path = mFilePathFull;
+    LogFlowThisFunc (("VMDK.fullPath={%s}\n", path.raw()));
+
+    if (RTPathStartsWith (path, aOldPath))
+    {
+        Utf8Str newPath = Utf8StrFmt ("%s%s", aNewPath,
+                                              path.raw() + oldPathLen);
+        path = newPath;
+
+        mVirtualBox->calculateRelativePath (path, path);
+
+        unconst (mFilePathFull) = newPath;
+        unconst (mFilePath) = path;
+
+        LogFlowThisFunc (("-> updated: full={%s} short={%s}\n",
+                          newPath.raw(), path.raw()));
+    }
+}
+
+/**
+ *  Returns the string representation of this hard disk.
+ *  When \a aShort is false, returns the full image file path.
+ *  Otherwise, returns the image file name only.
+ *
+ *  @param aShort       if true, a short representation is returned
+ */
+Bstr HVMDKImage::toString (bool aShort /* = false */)
+{
+    AutoLock alock (this);
+
+    if (!aShort)
+        return mFilePathFull;
+    else
+    {
+        Utf8Str fname = mFilePathFull;
+        return RTPathFilename (fname.mutableRaw());
+    }
+}
+
+/**
+ *  Creates a clone of this hard disk by storing hard disk data in the given
+ *  VDI file name.
+ *
+ *  @param aId          UUID to assign to the created image
+ *  @param aTargetPath  VDI file where the cloned image is to be to stored
+ *  @param aProgress    progress object to run during operation
+ */
+HRESULT
+HVMDKImage::cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
+                          Progress *aProgress)
+{
+    ComAssertMsgFailed (("Not implemented"));
+    return E_NOTIMPL;
+
+/// @todo (r=dmik) later?
+//  Use code from HVirtualDiskImage::cloneToImage as an example.
+}
+
+/**
+ *  Creates a new differencing image for this hard disk with the given
+ *  VDI file name.
+ *
+ *  @param aId          UUID to assign to the created image
+ *  @param aTargetPath  VDI file where to store the created differencing image
+ *  @param aProgress    progress object to run during operation
+ *                      (can be NULL)
+ */
+HRESULT
+HVMDKImage::createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
+                             Progress *aProgress)
+{
+    ComAssertMsgFailed (("Not implemented"));
+    return E_NOTIMPL;
+
+/// @todo (r=dmik) later?
+//  Use code from HVirtualDiskImage::createDiffImage as an example.
+}
+
+// private methods
+/////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Helper to set a new file path.
+ *  Resolves a path relatively to the Virtual Box home directory.
+ *
+ *  @note
+ *      Must be called from under the object's lock!
+ */
+HRESULT HVMDKImage::setFilePath (const BSTR aFilePath)
+{
+    if (aFilePath && *aFilePath)
+    {
+        /* get the full file name */
+        char filePathFull [RTPATH_MAX];
+        int vrc = RTPathAbsEx (mVirtualBox->homeDir(), Utf8Str (aFilePath),
+                               filePathFull, sizeof (filePathFull));
+        if (VBOX_FAILURE (vrc))
+            return setError (E_FAIL,
+                tr ("Invalid image file path '%ls' (%Vrc)"), aFilePath, vrc);
+
+        mFilePath = aFilePath;
+        mFilePathFull = filePathFull;
+    }
+    else
+    {
+        mFilePath.setNull();
+        mFilePathFull.setNull();
+    }
+
+    return S_OK;
+}
+
+/**
+ *  Helper to query information about the VDI hard disk.
+ *
+ *  @param aAccessError not used when NULL, otherwise see #getAccessible()
+ *
+ *  @note Must be called from under the object's lock, only after
+ *        CHECK_BUSY_AND_READERS() succeeds.
+ */
+HRESULT HVMDKImage::queryInformation (Bstr *aAccessError)
+{
+    AssertReturn (isLockedOnCurrentThread(), E_FAIL);
+
+    /* create a lock object to completely release it later */
+    AutoLock alock (this);
+
+    AssertReturn (mStateCheckWaiters == 0, E_FAIL);
+
+    ComAssertRet (mState >= Created, E_FAIL);
+
+    HRESULT rc = S_OK;
+    int vrc = VINF_SUCCESS;
+
+    /* lazily create a semaphore */
+    vrc = RTSemEventMultiCreate (&mStateCheckSem);
+    ComAssertRCRet (vrc, E_FAIL);
+
+    /* go to Busy state to prevent any concurrent modifications
+     * after releasing the lock below (to unblock getters before 
+     * a lengthy operation) */
+    setBusy();
+
+    alock.leave();
+    
+    /* VBoxVHDD management interface needs to be optimized: we're opening a
+     * file three times in a raw to get three bits of information. */
+
+    Utf8Str filePath = mFilePathFull;
+    Bstr errMsg;
+
+    do
+    {
+/// @todo (r=dmik) implement
+//
+//         /* check the image file */
+//         Guid id, parentId;
+//         vrc = VDICheckImage (filePath, NULL, NULL, NULL,
+//                              id.ptr(), parentId.ptr(), NULL, 0);
+//
+//         if (VBOX_FAILURE (vrc))
+//             break;
+//
+//         if (!mId.isEmpty())
+//         {
+//             /* check that the actual UUID of the image matches the stored UUID */
+//             if (mId != id)
+//             {
+//                 errMsg = Utf8StrFmt (
+//                     tr ("Actual UUID {%Vuuid} of the hard disk image '%s' doesn't "
+//                         "match UUID {%Vuuid} stored in the registry"),
+//                     id.ptr(), filePath.raw(), mId.ptr());
+//                 break;
+//             }
+//         }
+//         else
+//         {
+//             /* assgn an UUID read from the image file */
+//             mId = id;
+//         }
+//
+//         if (mParent)
+//         {
+//             /* check parent UUID */
+//             AutoLock parentLock (mParent);
+//             if (mParent->id() != parentId)
+//             {
+//                 errMsg = Utf8StrFmt (
+//                     tr ("UUID {%Vuuid} of the parent image '%ls' stored in "
+//                         "the hard disk image file '%s' doesn't match "
+//                         "UUID {%Vuuid} stored in the registry"),
+//                     parentId.raw(), mParent->toString().raw(),
+//                     filePath.raw(), mParent->id().raw());
+//                 break;
+//             }
+//         }
+//         else if (!parentId.isEmpty())
+//         {
+//             errMsg = Utf8StrFmt (
+//                 tr ("Hard disk image '%s' is a differencing image that is linked "
+//                     "to a hard disk with UUID {%Vuuid} and cannot be used "
+//                     "directly as a base hard disk"),
+//                 filePath.raw(), parentId.raw());
+//             break;
+//         }
+//
+//         {
+//             RTFILE file = NIL_RTFILE;
+//             vrc = RTFileOpen (&file, filePath, RTFILE_O_READ);
+//             if (VBOX_SUCCESS (vrc))
+//             {
+//                 uint64_t size = 0;
+//                 vrc = RTFileGetSize (file, &size);
+//                 if (VBOX_SUCCESS (vrc))
+//                     mActualSize = size;
+//                 RTFileClose (file);
+//             }
+//             if (VBOX_FAILURE (vrc))
+//                 break;
+//         }
+//
+//         if (!mParent)
+//         {
+//             /* query logical size only for non-differencing images */
+//
+//             PVDIDISK disk = VDIDiskCreate();
+//             vrc = VDIDiskOpenImage (disk, Utf8Str (mFilePathFull),
+//                                     VDI_OPEN_FLAGS_READONLY);
+//             if (VBOX_SUCCESS (vrc))
+//             {
+//                 uint64_t size = VDIDiskGetSize (disk);
+//                 /* convert to MBytes */
+//                 mSize = size / 1024 / 1024;
+//             }
+//
+//             VDIDiskDestroy (disk);
+//             if (VBOX_FAILURE (vrc))
+//                 break;
+//         }
+    }
+    while (0);
+
+    /* enter the lock again */
+    alock.enter();
+    
+    /* remove the busy flag */
+    clearBusy();
+    
+    if (FAILED (rc) || VBOX_FAILURE (vrc) || !errMsg.isNull())
+    {
+        LogWarningFunc (("'%ls' is not accessible "
+                         "(rc=%08X, vrc=%Vrc, errMsg='%ls')\n",
+                         mFilePathFull.raw(), rc, vrc, errMsg.raw()));
+
+        if (aAccessError)
+        {
+            if (!errMsg.isNull())
+                *aAccessError = errMsg;
+            else if (VBOX_FAILURE (vrc))
+                *aAccessError = Utf8StrFmt (
+                    tr ("Could not access hard disk image '%ls' (%Vrc)"),
+                        mFilePathFull.raw(), vrc);
+        }
+        
+        /* downgrade to not accessible */
+        mState = Created;
+    }
+    else
+    {
+        if (aAccessError)
+            aAccessError->setNull();
+
+        mState = Accessible;
+    }
+    
+    /* inform waiters if there are any */
+    if (mStateCheckWaiters > 0)
+    {
+        RTSemEventMultiSignal (mStateCheckSem);
+    }
+    else
+    {
+        /* delete the semaphore ourselves */
+        RTSemEventMultiDestroy (mStateCheckSem);
+        mStateCheckSem = NIL_RTSEMEVENTMULTI;
+    }
+
+    return rc;
+}
+
+/**
+ *  Helper to create hard disk images.
+ *
+ *  @param aSize        size in MB
+ *  @param aDynamic     dynamic or fixed image
+ *  @param aProgress    address of IProgress pointer to return
+ */
+HRESULT HVMDKImage::createImage (ULONG64 aSize, BOOL aDynamic,
+                                 IProgress **aProgress)
+{
+    ComAssertMsgFailed (("Not implemented"));
+    return E_NOTIMPL;
+
+/// @todo (r=dmik) later?
+//  Use code from HVirtualDiskImage::createImage as an example.
+}
+
+/* static */
+DECLCALLBACK(int) HVMDKImage::vdiTaskThread (RTTHREAD thread, void *pvUser)
+{
+    AssertMsgFailed (("Not implemented"));
+    return VERR_GENERAL_FAILURE;
+
+/// @todo (r=dmik) later?
+//  Use code from HVirtualDiskImage::vdiTaskThread as an example.
+}

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -959 +959 @@
         }
 
-        /// @todo (dmik) later
-//        case HardDiskStorageType_PhysicalVolume:
-//        {
-//            break;
-//        }
+       case HardDiskStorageType_VMDKImage:
+       {
+            ComObjPtr <HVMDKImage> vmdk;
+            vmdk.createObject();
+            rc = vmdk->init (this, NULL, NULL);
+            hardDisk = vmdk;
+            break;
+       }
+       default:
+           AssertFailed();
     };
 
+    if (SUCCEEDED (rc))
+        hardDisk.queryInterfaceTo (aHardDisk);
+
+    return rc;
+}
+
+/** @note Locks mSystemProperties object for reading. */
+STDMETHODIMP VirtualBox::OpenHardDisk (INPTR BSTR aLocation, IHardDisk **aHardDisk)
+{
+    /* null and empty strings are not allowed locations */
+    if (!aLocation || !(*aLocation))
+        return E_INVALIDARG;
+
+    if (!aHardDisk)
+        return E_POINTER;
+
+    AutoCaller autoCaller (this);
+    CheckComRCReturnRC (autoCaller.rc());
+
+    /* Currently, the location is always a path. So, append the
+     * default path if only a name is given. */
+    Bstr location = aLocation;
+    {
+        Utf8Str loc = aLocation;
+        if (!RTPathHavePath (loc))
+        {
+            AutoLock propsLock (mData.mSystemProperties);
+            location = Utf8StrFmt ("%ls%c%s",
+                                   mData.mSystemProperties->defaultVDIFolder().raw(),
+                                   RTPATH_DELIMITER,
+                                   loc.raw());
+        }
+    }
+
+    ComObjPtr <HardDisk> hardDisk;
+    HRESULT rc = HardDisk::openHardDisk (this, location, hardDisk);
     if (SUCCEEDED (rc))
         hardDisk.queryInterfaceTo (aHardDisk);

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

@@ -406 +406 @@
     <interface
         name="IVirtualBoxCallback" extends="$unknown"
-        uuid="FD443EC1-2007-4F5B-9282-D72760A66916"
+        uuid="1293842f-0380-47cf-80b5-e4f821861b26"
     >
         <method name="onMachineStateChange">
@@ -483 +483 @@
         </method>
 
+        <method name="onMediaRegistered">
+            <desc>
+                The given media was registered or unregistered
+                within this VirtualBox installation.
+
+                The @a mediaType parameter describes what type of
+                media the specified @a mediaId refers to. Possible
+                values are:
+
+                - <link to="HardDiskDevice"/>: the media is a hard disk
+                  that, if registered, can be obtained using the
+                  <link to="IVirtualBox::getHardDisk"/> call.
+                - <link to="DVDDevice"/>: the media is a CD/DVD image
+                  that, if registered, can be obtained using the
+                  <link to="IVirtualBox::getDVDImage"/> call.
+                - <link to="FloppyDevice"/>: the media is a Floppy image
+                  that, if registered, can be obtained using the
+                  <link to="IVirtualBox::getFloppyImage"/> call.
+
+                Note that if this is a deregistration notification,
+                there is no way to access the object representing the
+                unregistered media. It is supposed that the
+                application will do required cleanup based on the @a
+                mediaId value.
+            </desc>
+            <param name="mediaId" type="uuid" dir="in">
+                <desc>ID of the media this event relates to.</desc>
+            </param>
+            <param name="mediaType" type="DeviceType" dir="in">
+                <desc>Type of the media this event relates to.</desc>
+            </param>
+            <param name="registered" type="boolean" dir="in">
+                <desc>
+                    If true, the media was registered, otherwise it was
+                    unregistered.
+                </desc>
+            </param>
+        </method>
+
         <method name="onMachineRegistered">
             <desc>
-                The given machine was registered within this VirtualBox
-                installation or unregistered, as described by the
-                boolean argument.
+                The given machine was registered or unregistered
+                within this VirtualBox installation.
             </desc>
             <param name="machineId" type="uuid" dir="in">
@@ -495 +533 @@
                 <desc>
                     If true, the machine was registered, otherwise it was
-                    deregistered.
+                    unregistered.
                 </desc>
             </param>
@@ -567 +605 @@
     <interface
         name="IVirtualBox" extends="$dispatched"
-        uuid="E1D95593-F579-4F47-B489-0B67181014E1"
+        uuid="00f4e8eb-d737-4c88-9ccb-b434edf8b912"
     >
         <desc>
@@ -860 +898 @@
             </param>
 
+        </method>
+
+        <method name="openHardDisk">
+            <desc>
+
+                Opens a hard disk from an existing location.
+
+                This method tries to guess the
+                <link to="HardDiskStorageType">hard disk storage
+                type</link>
+                from the format of the location string and from the
+                contens of the resource the location points
+                to. Currently, a <i>file path</i> is the only supported
+                format for the location string which must point to
+                either a VDI file or to a VMDK file. On success,
+                an IHardDisk object will be returned that also
+                implements the corresponding interface (IVirtualDiskImage
+                or IVMDKImage, respectively). The <link
+                to="IHardDisk::storageType"/> property may also be
+                used to determine the storage type of the returned
+                object (instead of trying to query one of these interfaces).
+
+                <note>The specified file path can be absolute (full path) or
+                relative to the <link to="IVirtualBox::homeFolder"> VirtualBox
+                home directory</link>. If only a file name without any path is
+                given, the <link to="ISystemProperties::defaultVDIFolder">
+                default VDI folder</link> will be used as a path to the image
+                file.</note>
+
+                The opened hard disk remains unregistered
+                until <link to="#registerHardDisk()"/> is called.
+
+            </desc>
+
+            <param name="location" type="wstring" dir="in">
+                <desc>
+                    Location of the resource that contains a valid hard disk.
+                </desc>
+            </param>
+            <param name="hardDisk" type="IHardDisk" dir="return">
+                <desc>Opened hard disk object.</desc>
+            </param>
         </method>
 
@@ -4058 +4138 @@
     <enum
         name="HardDiskStorageType"
-        uuid="e45e2303-38fd-4f75-a791-5cb321759f53"
+        uuid="48138584-ad99-479d-a36f-eb82a7663685"
     >
         <desc>
@@ -4075 +4155 @@
                 SCSI protocol over a TCP/IP network, see
                 <link to="IISCSIHardDisk"/>)
+            </desc>
+        </const>
+        <const name="VMDKImage" value="2">
+            <desc>
+                WMware Virtual Machine Disk image (a regular file in the file
+                system of the host OS, see <link to="IVMDKImage"/>)
             </desc>
         </const>
@@ -4178 +4264 @@
                 SCSI protocol over a TCP/IP network link (represented by the
                 <link to="IISCSIHardDisk"/> interface).</li>
+
+                <li><i>WMware VMDK Image</i>, a regular file in the file
+                system of the host OS (represented by the <link
+                to="IVMDKImage"/> interface).</li>
 
             </ul>
@@ -4285 +4375 @@
             type of the hard disk attached to the virtual machine. This is
             explained below.
+
+            Note that in the current implementation, only the
+            <link to="VirtualDiskImage"/> storage type is used to
+            represent differencing hard disks. In other words, all
+            differencing hard disks are <link to="IVirtualDiskImage"/>
+            objects.
 
             <b>Normal Hard Disks</b>
@@ -4834 +4930 @@
             to="IHardDisk"/> interface.
 
-            The <link to="IHardDisk::description">description</link> the iSCSI
-            hard disk is stored in the VirtualBox configuration file, so it can
-            be changed (at appropriate times) even when <link
-            to="IHardDisk::accessible">accessible</link> returns <tt>false</tt>.
-            However, the hard disk may not be attached to a running virtual
-            machine.
+            The <link to="IHardDisk::description">description</link>
+            of the iSCSI hard disk is stored in the VirtualBox
+            configuration file, so it can be changed (at appropriate
+            times) even when
+            <link to="IHardDisk::accessible">accessible</link> returns
+            <tt>false</tt>.  However, the hard disk must not be
+            attached to a running virtual machine.
 
             <note>In the current imlementation, the type of all iSCSI hard disks
@@ -4900 +4997 @@
             </desc>
         </attribute>
+
+    </interface>
+
+    <!--
+    // IVMDKImage
+    /////////////////////////////////////////////////////////////////////////
+    -->
+
+    <interface
+        name="IVMDKImage" extends="$unknown"
+        uuid="178398f5-8559-4fee-979e-420af5b53eef"
+    >
+        <desc>
+
+            The IVMDKImage interface represents <link
+            to="IHardDisk">virtual hard disks</link> that use 
+            WMware Virtual Machine Disk image files to store hard disk data.
+
+            Hard disks using VMDK images can be either opened using
+            <link to="IVirtualBox::openHardDisk()"/> or created from
+            scratch using <link to="IVirtualBox::createHardDisk()"/>.
+
+            Objects that support this interface also support the <link
+            to="IHardDisk"/> interface.
+
+            When a new hard disk object is created from scatch, an image file
+            for it is not automatically created. To do it, you need to specify a
+            valid <link to="#filePath">file path</link>, and call <link
+            to="#createFixedImage()"/> or <link to="#createDynamicImage()"/>.
+            When it is done, the hard disk object can be registered by calling
+            <link to="IVirtualBox::registerHardDisk()"/> and then
+            <link to="IMachine::attachHardDisk()">attached</link> to
+            virtual machines.
+
+            The <link to="IHardDisk::description">description</link>
+            of the VMDK hard disk is stored in the VirtualBox
+            configuration file, so it can be changed (at appropriate
+            times) even when
+            <link to="IHardDisk::accessible">accessible</link> returns
+            <tt>false</tt>.  However, the hard disk must not be
+            attached to a running virtual machine.
+
+            <note>In the current imlementation, the type of all VMDK hard disks
+            is <link to="HardDiskType::WritethroughHardDisk">Writethrough</link>
+            and cannot be changed.</note>
+
+        </desc>
+
+        <attribute name="filePath" type="wstring">
+            <desc>
+
+                Full file name of the VMDK image of this hard disk. For
+                newly created hard disk objects, this value is <tt>null</tt>.
+
+                When assigning a new path, it can be absolute (full path) or
+                relative to the <link to="IVirtualBox::homeFolder"> VirtualBox
+                home directory</link>. If only a file name without any path is
+                given, the <link to="ISystemProperties::defaultVDIFolder">
+                default VDI folder</link> will be used as a path to the image
+                file.
+
+                When reading this propery, a full path is always returned.
+
+                <note>This property cannot be changed when <link to="#created"/>
+                returns <tt>true</tt>. In this case, the specified file name can
+                be absolute (full path) or relative to the <link
+                to="IVirtualBox::homeFolder"> VirtualBox home directory</link>.
+                If only a file name without any path is given, the <link
+                to="ISystemProperties::defaultVDIFolder"> default VDI
+                folder</link> will be used as a path to the image file.</note>
+
+            </desc>
+        </attribute>
+
+        <attribute name="created" type="boolean" readonly="yes">
+            <desc>
+
+                Whether the virual disk image is created or not. For newly
+                created hard disk objects or after a successful invocation of
+                <link to="#deleteImage()"/>, this value is <tt>false</tt> until
+                <link to="#createFixedImage()"/> or <link
+                to="#createDynamicImage()"/> is called.
+
+            </desc>
+        </attribute>
+
+        <method name="createDynamicImage">
+
+            <desc>
+
+                Starts creating a dymically expanding hard disk image in the
+                background. The previous image associated with this object, if
+                any, must be deleted using <link to="#deleteImage"/>, otherwise
+                the operation will fail.
+
+                <note>After the returned progress object reports that the
+                operation is complete, this hard disk object can be
+                <link to="IVirtualBox::registerHardDisk()">registered</link>
+                within this VirtualBox installation.</note>
+
+            </desc>
+
+            <param name="size" type="unsigned long long" dir="in">
+                <desc>Maximum logical size of the hard disk in megabytes.</desc>
+            </param>
+            <param name="progress" type="IProgress" dir="return">
+                <desc>Progress object to track the operation completion.</desc>
+            </param>
+
+        </method>
+
+        <method name="createFixedImage">
+            <desc>
+
+                Starts creating a fixed-size hard disk image in the background.
+                The previous image, if any, must be deleted using <link
+                to="#deleteImage"/>, otherwise the operation will fail.
+
+                <note>After the returned progress object reports that the
+                operation is complete, this hard disk object can be
+                <link to="IVirtualBox::registerHardDisk()">registered</link>
+                within this VirtualBox installation.</note>
+
+            </desc>
+
+            <param name="size" type="unsigned long long" dir="in">
+                <desc>Logical size of the hard disk in megabytes.</desc>
+            </param>
+            <param name="progress" type="IProgress" dir="return">
+                <desc>Progress object to track the operation completion.</desc>
+            </param>
+
+        </method>
+
+        <method name="deleteImage">
+            <desc>
+
+                Deletes the existing hard disk image. The hard disk must not be
+                registered within this VirtualBox installation, otherwise the
+                operation will fail.
+
+                <note>After this operation succeeds, it will be impossible to
+                register the hard disk until the image file is created
+                again.</note>
+
+                <note>This operation is valid only for non-differencing hard
+                disks, after they are unregistered using <link
+                to="IVirtualBox::unregisterHardDisk()"/>.</note>
+
+            </desc>
+        </method>
 
     </interface>

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

@@ -174 +174 @@
     const Bstr &lastAccessError() const { return mLastAccessError; }
 
+    static HRESULT openHardDisk (VirtualBox *aVirtualBox, INPTR BSTR aLocation,
+                                 ComObjPtr <HardDisk> &hardDisk);
+
     // for VirtualBoxSupportErrorInfoImpl
     static const wchar_t *getComponentName() { return L"HardDisk"; }
@@ -424 +427 @@
 };
 
+////////////////////////////////////////////////////////////////////////////////
+
+class ATL_NO_VTABLE HVMDKImage :
+    public HardDisk,
+    public VirtualBoxSupportTranslation <HVMDKImage>,
+    public IVMDKImage
+{
+
+public:
+
+    VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(HVMDKImage)
+
+    DECLARE_NOT_AGGREGATABLE(HVMDKImage)
+
+    DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+    BEGIN_COM_MAP(HVMDKImage)
+        COM_INTERFACE_ENTRY(ISupportErrorInfo)
+        COM_INTERFACE_ENTRY(IHardDisk)
+        COM_INTERFACE_ENTRY(IVMDKImage)
+    END_COM_MAP()
+
+    NS_DECL_ISUPPORTS
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    // public initializer/uninitializer for internal purposes only
+
+    HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
+                  CFGNODE aHDNode, CFGNODE aVMDKNode);
+    HRESULT init (VirtualBox *aVirtualBox, HardDisk *aParent,
+                  INPTR BSTR aFilePath, BOOL aRegistered = FALSE);
+    void uninit();
+
+    // IHardDisk properties
+    STDMETHOD(COMGETTER(Description)) (BSTR *aDescription);
+    STDMETHOD(COMSETTER(Description)) (INPTR BSTR aDescription);
+    STDMETHOD(COMGETTER(Size)) (ULONG64 *aSize);
+    STDMETHOD(COMGETTER(ActualSize)) (ULONG64 *aActualSize);
+
+    // IVirtualDiskImage properties
+    STDMETHOD(COMGETTER(FilePath)) (BSTR *aFilePath);
+    STDMETHOD(COMSETTER(FilePath)) (INPTR BSTR aFilePath);
+    STDMETHOD(COMGETTER(Created)) (BOOL *aCreated);
+
+    // IVirtualDiskImage methods
+    STDMETHOD(CreateDynamicImage) (ULONG64 aSize, IProgress **aProgress);
+    STDMETHOD(CreateFixedImage) (ULONG64 aSize, IProgress **aProgress);
+    STDMETHOD(DeleteImage)();
+
+    // public methods for internal purposes only
+
+    const Bstr &filePath() const { return mFilePath; }
+    const Bstr &filePathFull() const { return mFilePathFull; }
+
+    HRESULT trySetRegistered (BOOL aRegistered);
+    HRESULT getAccessible (Bstr &aAccessError);
+
+    HRESULT saveSettings (CFGNODE aHDNode, CFGNODE aStorageNode);
+
+    void updatePath (const char *aOldPath, const char *aNewPath);
+
+    Bstr toString (bool aShort = false);
+
+    HRESULT cloneToImage (const Guid &aId, const Utf8Str &aTargetPath,
+                          Progress *aProgress);
+    HRESULT createDiffImage (const Guid &aId, const Utf8Str &aTargetPath,
+                             Progress *aProgress);
+
+    // for VirtualBoxSupportErrorInfoImpl
+    static const wchar_t *getComponentName() { return L"VMDKImage"; }
+
+private:
+
+    HRESULT setFilePath (const BSTR aFilePath);
+    HRESULT queryInformation (Bstr *aAccessError);
+    HRESULT createImage (ULONG64 aSize, BOOL aDynamic, IProgress **aProgress);
+
+    /** VDI asynchronous operation thread function */
+    static DECLCALLBACK(int) vdiTaskThread (RTTHREAD thread, void *pvUser);
+
+    enum State
+    {
+        NotCreated,
+        Created,
+        /* the following must be greater than Created */
+        Accessible,
+    };
+
+    State mState;
+    
+    RTSEMEVENTMULTI mStateCheckSem;
+    ULONG mStateCheckWaiters;
+
+    Bstr mDescription;
+
+    ULONG64 mSize;
+    ULONG64 mActualSize;
+
+    Bstr mFilePath;
+    Bstr mFilePathFull;
+
+    friend class HardDisk;
+};
+
 
 COM_DECL_READONLY_ENUM_AND_COLLECTION (HardDisk)

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

@@ -138 +138 @@
 
     STDMETHOD(CreateHardDisk) (HardDiskStorageType_T aStorageType, IHardDisk **aHardDisk);
+    STDMETHOD(OpenHardDisk) (INPTR BSTR aLocation, IHardDisk **aHardDisk);
     STDMETHOD(OpenVirtualDiskImage) (INPTR BSTR aFilePath, IVirtualDiskImage **aImage);
     STDMETHOD(RegisterHardDisk) (IHardDisk *aHardDisk);

trunk/src/VBox/Main/linux/server.cpp

@@ -120 +120 @@
 NS_DECL_CLASSINFO(HISCSIHardDisk)
 NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HISCSIHardDisk, IHardDisk, IISCSIHardDisk)
+NS_DECL_CLASSINFO(HVMDKImage)
+NS_IMPL_THREADSAFE_ISUPPORTS2_CI(HVMDKImage, IHardDisk, IVMDKImage)
 NS_DECL_CLASSINFO(HardDiskAttachment)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(HardDiskAttachment, IHardDiskAttachment)