Changeset 33232 in vbox for trunk/src

Timestamp:

Oct 19, 2010 2:24:46 PM (14 years ago)

Author:

vboxsync

Message:

Main: use paths relative to machine folder in machine registries

Location:

trunk/src/VBox/Main

Files:

• ApplianceImplExport.cpp (modified) (2 diffs)
• HostImpl.cpp (modified) (4 diffs)
• MachineImpl.cpp (modified) (4 diffs)
• MediumImpl.cpp (modified) (19 diffs)
• VirtualBoxImpl.cpp (modified) (17 diffs)
• include/MachineImpl.h (modified) (1 diff)
• include/MediumImpl.h (modified) (3 diffs)
• include/VirtualBoxImpl.h (modified) (3 diffs)

trunk/src/VBox/Main/ApplianceImplExport.cpp

@@ -1776 +1776 @@
             // source path: where the VBox image is
             const Utf8Str &strSrcFilePath = pDiskEntry->strVboxCurrent;
-            Bstr bstrSrcFilePath(strSrcFilePath);
 
             // Do NOT check here whether the file exists. findHardDisk will
@@ -1785 +1784 @@
             ComObjPtr<Medium> pSourceDisk;
 
-            Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
-            rc = mVirtualBox->findHardDisk(NULL, bstrSrcFilePath.raw(), true, &pSourceDisk);
+            Log(("Finding source disk \"%s\"\n", strSrcFilePath.c_str()));
+            rc = mVirtualBox->findHardDiskByLocation(strSrcFilePath, true, &pSourceDisk);
             if (FAILED(rc)) throw rc;
 

trunk/src/VBox/Main/HostImpl.cpp

@@ -1612 +1612 @@
             {
                 Medium *pCached = *itCached;
-                const Utf8Str strLocationCached = pCached->getLocation();
+                const Utf8Str strLocationCached = pCached->getLocationFull();
                 bool fFound = false;
                 for (MediaList::iterator itNew = llNew.begin();
@@ -1619 +1619 @@
                 {
                     Medium *pNew = *itNew;
-                    const Utf8Str strLocationNew = pNew->getLocation();
+                    const Utf8Str strLocationNew = pNew->getLocationFull();
                     if (strLocationNew == strLocationCached)
                     {
@@ -1636 +1636 @@
             {
                 Medium *pNew = *itNew;
-                const Utf8Str strLocationNew = pNew->getLocation();
+                const Utf8Str strLocationNew = pNew->getLocationFull();
                 bool fFound = false;
                 for (MediaList::iterator itCached = pllCached->begin();
@@ -1643 +1643 @@
                 {
                     Medium *pCached = *itCached;
-                    const Utf8Str strLocationCached = pCached->getLocation();
+                    const Utf8Str strLocationCached = pCached->getLocationFull();
                     if (strLocationNew == strLocationCached)
                     {

trunk/src/VBox/Main/MachineImpl.cpp

@@ -6928 +6928 @@
     if (config.canHaveOwnMediaRegistry())
     {
+        // determine machine folder
+        Utf8Str strMachineFolder = getSettingsFileFull();
+        strMachineFolder.stripFilename();
         rc = mParent->initMedia(getId(),         // media registry ID == machine UUID
-                                config.mediaRegistry);
+                                config.mediaRegistry,
+                                strMachineFolder);
         if (FAILED(rc)) return rc;
     }
@@ -7408 +7412 @@
             {
                 /* find a hard disk by UUID */
-                rc = mParent->findHardDisk(&dev.uuid, Utf8Str::Empty, true /* aDoSetError */, &medium);
+                rc = mParent->findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
                 if (FAILED(rc))
                 {
@@ -8053 +8057 @@
     // save machine's media registry if this is VirtualBox 4.0 or later
     if (config.canHaveOwnMediaRegistry())
+    {
+        // determine machine folder
+        Utf8Str strMachineFolder = getSettingsFileFull();
+        strMachineFolder.stripFilename();
         mParent->saveMediaRegistry(config.mediaRegistry,
-                                   getId());            // only media with registry ID == machine UUID
+                                   getId(),             // only media with registry ID == machine UUID
+                                   strMachineFolder);
             // this throws HRESULT
+    }
 
     // save snapshots
@@ -8410 +8420 @@
         {
             if (pMedium->isHostDrive())
-                dev.strHostDriveSrc = pMedium->getLocation();
+                dev.strHostDriveSrc = pMedium->getLocationFull();
             else
                 dev.uuid = pMedium->getId();

trunk/src/VBox/Main/MediumImpl.cpp

@@ -117 +117 @@
     MediumState_T state;
     MediumVariant_T variant;
-    Utf8Str strLocation;
     Utf8Str strLocationFull;
     uint64_t size;
@@ -948 +947 @@
     if (FAILED(rc)) return rc;
 
-    if (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
-    {
-        rc = setLocation(aLocation);
-        if (FAILED(rc)) return rc;
-    }
-    else
-    {
-        rc = setLocation(aLocation);
-        if (FAILED(rc)) return rc;
-    }
+    rc = setLocation(aLocation);
+    if (FAILED(rc)) return rc;
 
     if (!(m->formatObj->getCapabilities() & (   MediumFormatCapabilities_CreateFixed
@@ -1085 +1076 @@
  * @param uuidMachineRegistry The registry to which this medium should be added (global registry UUI or medium UUID).
  * @param aNode         Configuration settings.
- *
- * @note Locks VirtualBox for writing, the medium tree for writing.
+ * @param strMachineFolder The machine folder with which to resolve relative paths; if empty, then we use the VirtualBox home directory
+ *
+ * @note Locks the medium tree for writing.
  */
 HRESULT Medium::init(VirtualBox *aVirtualBox,
@@ -1092 +1084 @@
                      DeviceType_T aDeviceType,
                      const Guid &uuidMachineRegistry,
-                     const settings::Medium &data)
+                     const settings::Medium &data,
+                     const Utf8Str &strMachineFolder)
 {
     using namespace settings;
@@ -1171 +1164 @@
     }
 
-    /* required */
-    rc = setLocation(data.strLocation);
+    // compose full path of the medium, if it's not fully qualified...
+    // slightly convoluted logic here. If the caller has given us a
+    // machine folder, then a relative path will be relative to that:
+    Utf8Str strFull;
+    if (    !strMachineFolder.isEmpty()
+         && !RTPathHavePath(data.strLocation.c_str()))
+    {
+        strFull = strMachineFolder;
+        strFull += RTPATH_DELIMITER;
+        strFull += data.strLocation;
+    }
+    else
+    {
+        // Otherwise use the old VirtualBox "make absolute path" logic:
+        rc = m->pVirtualBox->calculateFullPath(data.strLocation, strFull);
+        if (FAILED(rc)) return rc;
+    }
+
+    rc = setLocation(strFull);
     if (FAILED(rc)) return rc;
 
@@ -1212 +1222 @@
                        aDeviceType,
                        uuidMachineRegistry,
-                       med);              // child data
+                       med,               // child data
+                       strMachineFolder);
         if (FAILED(rc)) break;
 
@@ -2888 +2899 @@
 
 /**
- * Internal method to return the medium's location. Must have caller + locking!
- * @return
- */
-const Utf8Str& Medium::getLocation() const
-{
-    return m->strLocation;
-}
-
-/**
  * Internal method to return the medium's full location. Must have caller + locking!
  * @return
@@ -3153 +3155 @@
         unconst(m->strLocationFull) = newPath;
 
-        Utf8Str path;
-        m->pVirtualBox->copyPathRelativeToConfig(newPath, path);
-        unconst(m->strLocation) = path;
-
         LogFlowThisFunc(("locationFull.after='%s'\n", m->strLocationFull.c_str()));
     }
@@ -3258 +3256 @@
  *
  * @param data      Settings struct to be updated.
+ * @param strHardDiskFolder Folder for which paths should be relative.
  *
  * @note Locks this object, medium tree and children for reading.
  */
-HRESULT Medium::saveSettings(settings::Medium &data)
+HRESULT Medium::saveSettings(settings::Medium &data,
+                             const Utf8Str &strHardDiskFolder)
 {
     AutoCaller autoCaller(this);
@@ -3272 +3272 @@
 
     data.uuid = m->id;
-    data.strLocation = m->strLocation;
+
+    // make path relative if needed
+    if (    !strHardDiskFolder.isEmpty()
+         && RTPathStartsWith(m->strLocationFull.c_str(), strHardDiskFolder.c_str())
+       )
+        data.strLocation = m->strLocationFull.substr(strHardDiskFolder.length() + 1);
+    else
+        data.strLocation = m->strLocationFull;
     data.strFormat = m->strFormat;
 
@@ -3309 +3316 @@
     {
         settings::Medium med;
-        HRESULT rc = (*it)->saveSettings(med);
+        HRESULT rc = (*it)->saveSettings(med, strHardDiskFolder);
         AssertComRCReturnRC(rc);
         data.llChildren.push_back(med);
     }
-
-    return S_OK;
-}
-
-/**
- * Compares the location of this medium 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.
- */
-HRESULT Medium::compareLocationTo(const Utf8Str &strLocation, int &aResult)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    Utf8Str locationFull(m->strLocationFull);
-
-    /// @todo NEWMEDIA delegate the comparison to the backend?
-
-    if (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
-    {
-        Utf8Str location;
-
-        /* For locations represented by files, append the default path if
-         * only the name is given, and then get the full path. */
-        if (!RTPathHavePath(strLocation.c_str()))
-        {
-            m->pVirtualBox->getDefaultHardDiskFolder(location);
-            location.append(RTPATH_DELIMITER);
-            location.append(strLocation);
-        }
-        else
-            location = strLocation;
-
-        int vrc = m->pVirtualBox->calculateFullPath(location, location);
-        if (RT_FAILURE(vrc))
-            return setError(VBOX_E_FILE_ERROR,
-                            tr("Invalid medium storage file location '%s' (%Rrc)"),
-                            location.c_str(),
-                            vrc);
-
-        aResult = RTPathCompare(locationFull.c_str(), location.c_str());
-    }
-    else
-        aResult = locationFull.compare(strLocation);
 
     return S_OK;
@@ -3604 +3558 @@
 
 /**
- * Sets the value of m->strLocation and calculates the value of m->strLocationFull.
- *
- * Treats non-FS-path locations specially, and prepends the default medium
- * 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
+ * Sets the value of m->strLocationFull. The given location must be a fully
+ * qualified path; relative paths are not supported here.
+ *
+ * As a special exception, 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
@@ -3652 +3603 @@
         Guid id;
 
-        Utf8Str location(aLocation);
+        Utf8Str locationFull(aLocation);
 
         if (m->state == MediumState_NotCreated)
@@ -3659 +3610 @@
             Assert(m->formatObj->getCapabilities() & MediumFormatCapabilities_File);
 
-            if (RTPathFilename(location.c_str()) == NULL)
+            if (RTPathFilename(aLocation.c_str()) == NULL)
             {
                 /* no file name is given (either an empty string or ends with a
@@ -3676 +3627 @@
                 id.create();
 
-                location = Utf8StrFmt("%s{%RTuuid}.%s",
-                                      location.c_str(), id.raw(), strExt.c_str());
+                locationFull = Utf8StrFmt("%s{%RTuuid}.%s",
+                                          aLocation.c_str(), id.raw(), strExt.c_str());
             }
         }
 
-        /* append the default folder if no path is given */
-        if (!RTPathHavePath(location.c_str()))
-        {
-            Utf8Str tmp;
-            m->pVirtualBox->getDefaultHardDiskFolder(tmp);
-            tmp.append(RTPATH_DELIMITER);
-            tmp.append(location);
-            location = tmp;
-        }
-
-        /* get the full file name */
-        Utf8Str locationFull;
-        int vrc = m->pVirtualBox->calculateFullPath(location, locationFull);
-        if (RT_FAILURE(vrc))
-            return setError(VBOX_E_FILE_ERROR,
-                            tr("Invalid medium storage file location '%s' (%Rrc)"),
-                            location.c_str(), vrc);
+        // we must always have full paths now
+        Assert(RTPathHavePath(locationFull.c_str()));
 
         /* detect the backend from the storage unit if importing */
@@ -3703 +3639 @@
         {
             char *backendName = NULL;
+
+            int vrc = VINF_SUCCESS;
 
             /* is it a file? */
@@ -3719 +3657 @@
             {
                 /* assume it's not a file, restore the original location */
-                location = locationFull = aLocation;
+                locationFull = aLocation;
                 vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */,
                                   locationFull.c_str(), &backendName);
@@ -3755 +3693 @@
         }
 
+        m->strLocationFull = locationFull;
+
         /* is it still a file? */
-        if (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
-        {
-            m->strLocation = location;
-            m->strLocationFull = locationFull;
-
-            if (m->state == MediumState_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 */
-                unconst(m->id) = id;
-            }
-        }
-        else
-        {
-            m->strLocation = locationFull;
-            m->strLocationFull = locationFull;
-        }
+        if (    (m->formatObj->getCapabilities() & MediumFormatCapabilities_File)
+             && (m->state == MediumState_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 */
+            unconst(m->id) = id;
     }
     else
-    {
-        m->strLocation = aLocation;
         m->strLocationFull = aLocation;
-    }
 
     return S_OK;
@@ -4006 +3932 @@
                     Guid id = parentId;
                     ComObjPtr<Medium> pParent;
-                    rc = m->pVirtualBox->findHardDisk(&id, Utf8Str::Empty, false /* aSetError */, &pParent);
+                    rc = m->pVirtualBox->findHardDiskById(id, false /* aSetError */, &pParent);
                     if (FAILED(rc))
                     {

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -457 +457 @@
         /* all registered media, needed by machines */
         if (FAILED(rc = initMedia(m->uuidMediaRegistry,
-                                  m->pMainConfigFile->mediaRegistry)))
+                                  m->pMainConfigFile->mediaRegistry,
+                                  Utf8Str::Empty)))     // const Utf8Str &machineFolder
             throw rc;
 
@@ -608 +609 @@
  */
 HRESULT VirtualBox::initMedia(const Guid &uuidRegistry,
-                              const settings::MediaRegistry mediaRegistry)
+                              const settings::MediaRegistry mediaRegistry,
+                              const Utf8Str &strMachineFolder)
 {
     LogFlow(("VirtualBox::initMedia ENTERING, uuidRegistry=%s\n", uuidRegistry.toString().c_str()));
@@ -628 +630 @@
                                  DeviceType_HardDisk,
                                  uuidRegistry,
-                                 xmlHD);        // XML data; this recurses to processes the children
+                                 xmlHD,         // XML data; this recurses to processes the children
+                                 strMachineFolder);
         if (FAILED(rc)) return rc;
 
@@ -648 +651 @@
                               DeviceType_DVD,
                               uuidRegistry,
-                              xmlDvd);
+                              xmlDvd,
+                              strMachineFolder);
         if (FAILED(rc)) return rc;
 
@@ -669 +673 @@
                               DeviceType_Floppy,
                               uuidRegistry,
-                              xmlFloppy);
+                              xmlFloppy,
+                              strMachineFolder);
         if (FAILED(rc)) return rc;
 
@@ -1479 +1484 @@
         case DeviceType_HardDisk:
             if (!id.isEmpty())
-                rc = findHardDisk(&id, Utf8Str::Empty, true /* setError */, &pMedium);
+                rc = findHardDiskById(id, true /* setError */, &pMedium);
             else
-                rc = findHardDisk(NULL, strLocation, true /* setError */, &pMedium);
+                rc = findHardDiskByLocation(strLocation, true /* setError */, &pMedium);
         break;
 
@@ -2525 +2530 @@
 
 /**
+ * Searches for a Medium object with the given ID in the list of registered
+ * hard disks.
+ *
+ * @param aId           ID of the hard disk. Must not be empty.
+ * @param aSetError     If @c true , the appropriate error info is set in case
+ *                      when the hard disk is not found.
+ * @param aHardDisk     Where to store the found hard disk object (can be NULL).
+ *
+ * @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
+ *
+ * @note Locks the media tree for reading.
+ */
+HRESULT VirtualBox::findHardDiskById(const Guid &id,
+                                     bool aSetError,
+                                     ComObjPtr<Medium> *aHardDisk /*= NULL*/)
+{
+    AssertReturn(!id.isEmpty(), E_INVALIDARG);
+
+    // we use the hard disks map, but it is protected by the
+    // hard disk _list_ lock handle
+    AutoReadLock alock(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    HardDiskMap::const_iterator it = m->mapHardDisks.find(id);
+    if (it != m->mapHardDisks.end())
+    {
+        if (aHardDisk)
+            *aHardDisk = (*it).second;
+        return S_OK;
+    }
+
+    if (aSetError)
+        return setError(VBOX_E_OBJECT_NOT_FOUND,
+                        tr("Could not find an open hard disk with UUID {%RTuuid}"),
+                        id.raw());
+
+    return VBOX_E_OBJECT_NOT_FOUND;
+}
+
+/**
  * Searches for a Medium object with the given ID or location in the list of
  * registered hard disks. If both ID and location are specified, the first
  * object that matches either of them (not necessarily both) is returned.
  *
- * @param aId           ID of the hard disk (unused when NULL).
- * @param aLocation     Full location specification (unused NULL).
+ * @param aLocation     Full location specification. Must not be empty.
  * @param aSetError     If @c true , the appropriate error info is set in case
  *                      when the hard disk is not found.
  * @param aHardDisk     Where to store the found hard disk object (can be NULL).
  *
- * @return S_OK when found or E_INVALIDARG when not found.
+ * @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
  *
  * @note Locks the media tree for reading.
  */
-HRESULT VirtualBox::findHardDisk(const Guid *aId,
-                                 const Utf8Str &strLocation,
-                                 bool aSetError,
-                                 ComObjPtr<Medium> *aHardDisk /*= NULL*/)
-{
-    AssertReturn(aId || !strLocation.isEmpty(), E_INVALIDARG);
+HRESULT VirtualBox::findHardDiskByLocation(const Utf8Str &strLocation,
+                                           bool aSetError,
+                                           ComObjPtr<Medium> *aHardDisk /*= NULL*/)
+{
+    AssertReturn(!strLocation.isEmpty(), E_INVALIDARG);
 
     // we use the hard disks map, but it is protected by the
@@ -2550 +2592 @@
     AutoReadLock alock(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
 
-    /* first, look up by UUID in the map if UUID is provided */
-    if (aId)
-    {
-        HardDiskMap::const_iterator it = m->mapHardDisks.find(*aId);
-        if (it != m->mapHardDisks.end())
+    for (HardDiskMap::const_iterator it = m->mapHardDisks.begin();
+         it != m->mapHardDisks.end();
+         ++it)
+    {
+        const ComObjPtr<Medium> &pHD = (*it).second;
+
+        AutoCaller autoCaller(pHD);
+        if (FAILED(autoCaller.rc())) return autoCaller.rc();
+        AutoWriteLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
+
+        Utf8Str strLocationFull = pHD->getLocationFull();
+
+        if (0 == RTPathCompare(strLocationFull.c_str(), strLocation.c_str()))
         {
             if (aHardDisk)
-                *aHardDisk = (*it).second;
+                *aHardDisk = pHD;
             return S_OK;
         }
     }
 
-    /* then iterate and search by location */
-    int result = -1;
-    if (!strLocation.isEmpty())
-    {
-        for (HardDiskMap::const_iterator it = m->mapHardDisks.begin();
-             it != m->mapHardDisks.end();
-             ++ it)
-        {
-            const ComObjPtr<Medium> &hd = (*it).second;
-
-            HRESULT rc = hd->compareLocationTo(strLocation, result);
-            if (FAILED(rc)) return rc;
-
-            if (result == 0)
-            {
-                if (aHardDisk)
-                    *aHardDisk = hd;
-                break;
-            }
-        }
-    }
-
-    HRESULT rc = result == 0 ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
-
-    if (aSetError && result != 0)
-    {
-        if (aId)
-            setError(rc,
-                     tr("Could not find a hard disk with UUID {%RTuuid} in the media registry ('%s')"),
-                     aId->raw(),
-                     m->strSettingsFilePath.c_str());
-        else
-            setError(rc,
-                     tr("Could not find a hard disk with location '%s' in the media registry ('%s')"),
-                     strLocation.c_str(),
-                     m->strSettingsFilePath.c_str());
-    }
-
-    return rc;
+    if (aSetError)
+        return setError(VBOX_E_OBJECT_NOT_FOUND,
+                        tr("Could not find an open hard disk with location '%s'"),
+                        strLocation.c_str());
+
+    return VBOX_E_OBJECT_NOT_FOUND;
 }
 
@@ -2877 +2894 @@
 
     char folder[RTPATH_MAX];
-    int vrc = RTPathAbsEx(m->strHomeDir.c_str(), strPath.c_str(), folder, sizeof(folder));
+    int vrc = RTPathAbsEx(m->strHomeDir.c_str(),
+                          strPath.c_str(),
+                          folder,
+                          sizeof(folder));
     if (RT_SUCCESS(vrc))
         aResult = folder;
@@ -2939 +2959 @@
     HRESULT rc = S_OK;
 
-    Bstr bstrLocation(aLocation);
     aConflict.setNull();
     fIdentical = false;
@@ -2946 +2965 @@
     const char *pcszType = NULL;
 
-    {
-        rc = findHardDisk(&aId, bstrLocation, false /* aSetError */, &pMediumFound);
-        if (SUCCEEDED(rc))
-            pcszType = tr("hard disk");
-    }
+    if (!aId.isEmpty())
+        rc = findHardDiskById(aId, false /* aSetError */, &pMediumFound);
+    if (FAILED(rc) && !aLocation.isEmpty())
+        rc = findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound);
+    if (SUCCEEDED(rc))
+        pcszType = tr("hard disk");
 
     if (!pcszType)
     {
-        rc = findDVDOrFloppyImage(DeviceType_DVD, &aId, bstrLocation, false /* aSetError */, &pMediumFound);
+        rc = findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound);
         if (SUCCEEDED(rc))
             pcszType = tr("CD/DVD image");
@@ -2961 +2981 @@
     if (!pcszType)
     {
-        rc = findDVDOrFloppyImage(DeviceType_Floppy, &aId, bstrLocation, false /* aSetError */, &pMediumFound);
+        rc = findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound);
         if (SUCCEEDED(rc))
             pcszType = tr("floppy image");
@@ -3034 +3054 @@
  * This throws HRESULT on errors!
  *
- * @param mediaRegistry
- * @param uuidRegistry
- * @return
+ * @param mediaRegistry Settings structure to fill.
+ * @param uuidRegistry The UUID of the media registry; either a machine UUID (if machine registry) or the UUID of the global registry.
+ * @param hardDiskFolder The machine folder for relative paths, if machine registry, or an empty string otherwise.
  */
 void VirtualBox::saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
-                                   const Guid &uuidRegistry)
+                                   const Guid &uuidRegistry,
+                                   const Utf8Str &strMachineFolder)
 {
     HRESULT rc;
@@ -3052 +3073 @@
         {
             settings::Medium med;
-            rc = pMedium->saveSettings(med);     // this recurses into its children
+            rc = pMedium->saveSettings(med, strMachineFolder);     // this recurses into its children
             if (FAILED(rc)) throw rc;
             mediaRegistry.llHardDisks.push_back(med);
@@ -3068 +3089 @@
         {
             settings::Medium med;
-            rc = pMedium->saveSettings(med);
+            rc = pMedium->saveSettings(med, strMachineFolder);
             if (FAILED(rc)) throw rc;
             mediaRegistry.llDvdImages.push_back(med);
@@ -3084 +3105 @@
         {
             settings::Medium med;
-            rc = pMedium->saveSettings(med);
+            rc = pMedium->saveSettings(med, strMachineFolder);
             if (FAILED(rc)) throw rc;
             mediaRegistry.llFloppyImages.push_back(med);
@@ -3168 +3189 @@
 
         saveMediaRegistry(m->pMainConfigFile->mediaRegistry,
-                          m->uuidMediaRegistry);
+                          m->uuidMediaRegistry,         // global media registry ID
+                          Utf8Str::Empty);              // strMachineFolder
 
         mediaLock.release();

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

@@ -152 +152 @@
         BOOL                mRegistered;
 
-        /** Flag indicating that the config file is read-only. */
         Utf8Str             m_strConfigFile;
         Utf8Str             m_strConfigFileFull;

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

@@ -87 +87 @@
                  DeviceType_T aDeviceType,
                  const Guid &uuidMachineRegistry,
-                 const settings::Medium &data);
+                 const settings::Medium &data,
+                 const Utf8Str &strMachineFolder);
 
     // initializer for host floppy/DVD
@@ -167 +168 @@
     MediumVariant_T getVariant() const;
     bool isHostDrive() const;
-    const Utf8Str& getLocation() const;
     const Utf8Str& getLocationFull() const;
     const Utf8Str& getFormat() const;
@@ -199 +199 @@
     bool isReadOnly();
 
-    HRESULT saveSettings(settings::Medium &data);
-
-    HRESULT compareLocationTo(const Utf8Str &strLocation, int &aResult);
+    HRESULT saveSettings(settings::Medium &data,
+                         const Utf8Str &strHardDiskFolder);
 
     HRESULT createMediumLockList(bool fFailIfInaccessible,

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

@@ -98 +98 @@
     HRESULT initMachines();
     HRESULT initMedia(const Guid &uuidMachineRegistry,
-                      const settings::MediaRegistry mediaRegistry);
+                      const settings::MediaRegistry mediaRegistry,
+                      const Utf8Str &strMachineFolder);
     void uninit();
 
@@ -212 +213 @@
                         ComObjPtr<Machine> *machine = NULL);
 
-    HRESULT findHardDisk(const Guid *aId,
-                         const Utf8Str &strLocation,
-                         bool aSetError,
-                         ComObjPtr<Medium> *aHardDisk = NULL);
+    HRESULT findHardDiskById(const Guid &id,
+                             bool aSetError,
+                             ComObjPtr<Medium> *aHardDisk = NULL);
+    HRESULT findHardDiskByLocation(const Utf8Str &strLocation,
+                                   bool aSetError,
+                                   ComObjPtr<Medium> *aHardDisk = NULL);
     HRESULT findDVDOrFloppyImage(DeviceType_T mediumType,
                                  const Guid *aId,
@@ -262 +265 @@
 
     void saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
-                           const Guid &uuidRegistry);
+                           const Guid &uuidRegistry,
+                           const Utf8Str &strMachineFolder);
     HRESULT saveSettings();