Changeset 5218 in vbox

Timestamp:

Oct 10, 2007 1:33:06 PM (17 years ago)

Author:

vboxsync

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

25152

Message:

Main: Fixed getDVDImageUsage()/getFloppyImageUsage() to a) prevent from unregistering images referred to by snapshots and b) avoid accessing Limited VMs (#2410).

Location:

trunk/src/VBox/Main

Files:

• MachineImpl.cpp (modified) (1 diff)
• SnapshotImpl.cpp (modified) (1 diff)
• VirtualBoxImpl.cpp (modified) (7 diffs)
• include/MachineImpl.h (modified) (1 diff)
• include/SnapshotImpl.h (modified) (1 diff)
• include/VirtualBoxImpl.h (modified) (1 diff)

trunk/src/VBox/Main/MachineImpl.cpp

@@ -2616 +2616 @@
 
 /**
+ *  Returns @c true if the given DVD image is attached to this machine either
+ *  in the current state or in any of the snapshots.
+ * 
+ *  @param aId          Image ID to check.
+ *  @param aUsage       Type of the check.
+ *
+ *  @note Locks this object + DVD object for reading.
+ */
+bool Machine::isDVDImageUsed (const Guid &aId, ResourceUsage_T aUsage)
+{
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc() || autoCaller.state() == Limited, false);
+
+    /* answer 'not attached' if the VM is limited */
+    if (autoCaller.state() == Limited)
+        return false;
+
+    AutoReaderLock alock (this);
+
+    Machine *m = this;
+
+    /* take the session machine when appropriate */
+    if (!mData->mSession.mMachine.isNull())
+        m = mData->mSession.mMachine;
+
+    /* first, check the current state */
+    {
+        const ComObjPtr <DVDDrive> &dvd = m->dvdDrive();
+        AssertReturn (!dvd.isNull(), false);
+
+        AutoReaderLock dvdLock (dvd);
+
+        /* loop over the backed up (permanent) and current (temporary) DVD data */
+        DVDDrive::Data *d [2];
+        if (dvd->data().isBackedUp())
+        {
+            d [0] = dvd->data().backedUpData();
+            d [1] = dvd->data().data();
+        }
+        else
+        {
+            d [0] = dvd->data().data();
+            d [1] = NULL;
+        }
+
+        if (!(aUsage & ResourceUsage_PermanentUsage))
+            d [0] = NULL;
+        if (!(aUsage & ResourceUsage_TemporaryUsage))
+            d [1] = NULL;
+
+        for (unsigned i = 0; i < ELEMENTS (d); ++ i)
+        {
+            if (d [i] &&
+                d [i]->mDriveState == DriveState_ImageMounted)
+            {
+                Guid id;
+                HRESULT rc = d [i]->mDVDImage->COMGETTER(Id) (id.asOutParam());
+                AssertComRC (rc);
+                if (id == aId)
+                    return true;
+            }
+        }
+    }
+
+    /* then, check snapshots if any */
+    if (aUsage & ResourceUsage_PermanentUsage)
+    {
+        if (!mData->mFirstSnapshot.isNull() &&
+            mData->mFirstSnapshot->isDVDImageUsed (aId))
+            return true;
+    }
+
+    return false;
+}
+
+/** 
+ *  Returns @c true if the given Floppy image is attached to this machine either
+ *  in the current state or in any of the snapshots.
+ * 
+ *  @param aId          Image ID to check.
+ *  @param aUsage       Type of the check.
+ *
+ *  @note Locks this object + Floppy object for reading.
+ */
+bool Machine::isFloppyImageUsed (const Guid &aId, ResourceUsage_T aUsage)
+{
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc() || autoCaller.state() == Limited, false);
+
+    /* answer 'not attached' if the VM is limited */
+    if (autoCaller.state() == Limited)
+        return false;
+
+    AutoReaderLock alock (this);
+
+    Machine *m = this;
+
+    /* take the session machine when appropriate */
+    if (!mData->mSession.mMachine.isNull())
+        m = mData->mSession.mMachine;
+
+    /* first, check the current state */
+    {
+        const ComObjPtr <FloppyDrive> &floppy = m->floppyDrive();
+        AssertReturn (!floppy.isNull(), false);
+
+        AutoReaderLock floppyLock (floppy);
+
+        /* loop over the backed up (permanent) and current (temporary) Floppy data */
+        FloppyDrive::Data *d [2];
+        if (floppy->data().isBackedUp())
+        {
+            d [0] = floppy->data().backedUpData();
+            d [1] = floppy->data().data();
+        }
+        else
+        {
+            d [0] = floppy->data().data();
+            d [1] = NULL;
+        }
+
+        if (!(aUsage & ResourceUsage_PermanentUsage))
+            d [0] = NULL;
+        if (!(aUsage & ResourceUsage_TemporaryUsage))
+            d [1] = NULL;
+
+        for (unsigned i = 0; i < ELEMENTS (d); ++ i)
+        {
+            if (d [i] &&
+                d [i]->mDriveState == DriveState_ImageMounted)
+            {
+                Guid id;
+                HRESULT rc = d [i]->mFloppyImage->COMGETTER(Id) (id.asOutParam());
+                AssertComRC (rc);
+                if (id == aId)
+                    return true;
+            }
+        }
+    }
+
+    /* then, check snapshots if any */
+    if (aUsage & ResourceUsage_PermanentUsage)
+    {
+        if (!mData->mFirstSnapshot.isNull() &&
+            mData->mFirstSnapshot->isFloppyImageUsed (aId))
+            return true;
+    }
+
+    return false;
+}
+
+/**
  *  @note Locks mParent and this object for writing,
  *        calls the client process (outside the lock).

trunk/src/VBox/Main/SnapshotImpl.cpp

@@ -396 +396 @@
 
 /**
+ *  Returns @c true if the given DVD image is attached to this snapshot or any
+ *  of its children, recursively.
+ * 
+ *  @param aId          Image ID to check.
+ * 
+ *  @note Locks this object for reading.
+ */
+bool Snapshot::isDVDImageUsed (const Guid &aId)
+{
+    AutoReaderLock alock (this);
+    AssertReturn (isReady(), false);
+
+    AssertReturn (!mData.mMachine.isNull(), false);
+    AssertReturn (!mData.mMachine->dvdDrive().isNull(), false);
+
+    DVDDrive::Data *d = mData.mMachine->dvdDrive()->data().data();
+
+    if (d &&
+        d->mDriveState == DriveState_ImageMounted)
+    {
+        Guid id;
+        HRESULT rc = d->mDVDImage->COMGETTER(Id) (id.asOutParam());
+        AssertComRC (rc);
+        if (id == aId)
+            return true;
+    }
+
+    AutoReaderLock chLock (childrenLock());
+    for (SnapshotList::const_iterator it = children().begin();
+         it != children().end(); ++ it)
+    {
+        if ((*it)->isDVDImageUsed (aId))
+            return true;
+    }
+
+    return false;
+}
+
+/** 
+ *  Returns @c true if the given Floppy image is attached to this snapshot or any
+ *  of its children, recursively.
+ * 
+ *  @param aId          Image ID to check.
+ * 
+ *  @note Locks this object for reading.
+ */
+bool Snapshot::isFloppyImageUsed (const Guid &aId)
+{
+    AutoReaderLock alock (this);
+    AssertReturn (isReady(), false);
+
+    AssertReturn (!mData.mMachine.isNull(), false);
+    AssertReturn (!mData.mMachine->dvdDrive().isNull(), false);
+
+    FloppyDrive::Data *d = mData.mMachine->floppyDrive()->data().data();
+
+    if (d &&
+        d->mDriveState == DriveState_ImageMounted)
+    {
+        Guid id;
+        HRESULT rc = d->mFloppyImage->COMGETTER(Id) (id.asOutParam());
+        AssertComRC (rc);
+        if (id == aId)
+            return true;
+    }
+
+    AutoReaderLock chLock (childrenLock());
+    for (SnapshotList::const_iterator it = children().begin();
+         it != children().end(); ++ it)
+    {
+        if ((*it)->isFloppyImageUsed (aId))
+            return true;
+    }
+
+    return false;
+}
+
+/**
  *  Checks if the specified path change affects the saved state file path of
  *  this snapshot or any of its (grand-)children and updates it accordingly.

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -2729 +2729 @@
  *  Helper to find machines that use the given DVD image.
  *
- *  @param machineIDs   string where to store the list (can be NULL)
- *  @return TRUE if at least one machine found and false otherwise
+ *  This method also checks whether an existing snapshot refers to the given
+ *  image. However, only the machine ID is returned in this case, not IDs of
+ *  individual snapshots.
+ *
+ *  @param aId          Image ID to get usage for.
+ *  @param aUsage       Type of the check.
+ *  @param aMachineIDs  Where to store the list of machine IDs (can be NULL)
+ *
+ *  @return @c true if at least one machine or its snapshot found and @c false
+ *  otherwise.
  *
  *  @note For now, we just scan all the machines. We can optimize this later
@@ -2738 +2746 @@
  *  @note Locks objects for reading.
  */
-BOOL VirtualBox::getDVDImageUsage (const Guid &id,
-                                   ResourceUsage_T usage,
-                                   Bstr *machineIDs)
+bool VirtualBox::getDVDImageUsage (const Guid &aId,
+                                   ResourceUsage_T aUsage,
+                                   Bstr *aMachineIDs)
 {
     AutoCaller autoCaller (this);
@@ -2755 +2763 @@
              ++ mit)
         {
-            /// @todo (dmik) move this part to Machine for better incapsulation
-
             ComObjPtr <Machine> m = *mit;
-            AutoReaderLock malock (m);
-
-            /* take the session machine when appropriate */
-            if (!m->data()->mSession.mMachine.isNull())
-                m = m->data()->mSession.mMachine;
-
-            const ComObjPtr <DVDDrive> &dvd = m->dvdDrive();
-            AutoReaderLock dalock (dvd);
-
-            /* loop over the backed up (permanent) and current (temporary) dvd data */
-            DVDDrive::Data *dvdData [2];
-            if (dvd->data().isBackedUp())
+            if (m->isDVDImageUsed (aId, aUsage))
             {
-                dvdData [0] = dvd->data().backedUpData();
-                dvdData [1] = dvd->data().data();
+                /* if not interested in the list, return shortly */
+                if (aMachineIDs == NULL)
+                    return true;
+
+                idSet.insert (m->data()->mUuid);
             }
-            else
-            {
-                dvdData [0] = dvd->data().data();
-                dvdData [1] = NULL;
-            }
-
-            if (!(usage & ResourceUsage_PermanentUsage))
-                dvdData [0] = NULL;
-            if (!(usage & ResourceUsage_TemporaryUsage))
-                dvdData [1] = NULL;
-
-            for (unsigned i = 0; i < ELEMENTS (dvdData); i++)
-            {
-                if (dvdData [i])
-                {
-                    if (dvdData [i]->mDriveState == DriveState_ImageMounted)
-                    {
-                        Guid iid;
-                        dvdData [i]->mDVDImage->COMGETTER(Id) (iid.asOutParam());
-                        if (iid == id)
-                            idSet.insert (m->data()->mUuid);
-                    }
-                }
-            }
-        }
-    }
-
-    if (machineIDs)
+        }
+    }
+
+    if (aMachineIDs)
     {
         if (!idSet.empty())
@@ -2819 +2793 @@
             *(-- idListPtr) = 0;
             /* copy the string */
-            *machineIDs = idList;
+            *aMachineIDs = idList;
             RTMemTmpFree (idList);
         }
         else
         {
-            (*machineIDs).setNull();
+            (*aMachineIDs).setNull();
         }
     }
@@ -2832 +2806 @@
 
 /**
- *  Helper to find machines that use the given floppy image.
- *
- *  @param machineIDs   string where to store the list (can be NULL)
- *  @return TRUE if at least one machine found and false otherwise
+ *  Helper to find machines that use the given Floppy image.
+ *
+ *  This method also checks whether an existing snapshot refers to the given
+ *  image. However, only the machine ID is returned in this case, not IDs of
+ *  individual snapshots.
+ *
+ *  @param aId          Image ID to get usage for.
+ *  @param aUsage       Type of the check.
+ *  @param aMachineIDs  Where to store the list of machine IDs (can be NULL)
+ *
+ *  @return @c true if at least one machine or its snapshot found and @c false
+ *  otherwise.
  *
  *  @note For now, we just scan all the machines. We can optimize this later
  *  if required by adding the corresponding field to FloppyImage and requiring all
- *  IFloppyImage instances to be FloppyImage objects.
+ *  FloppyImage instances to be FloppyImage objects.
  *
  *  @note Locks objects for reading.
  */
-BOOL VirtualBox::getFloppyImageUsage (const Guid &id,
-                                      ResourceUsage_T usage,
-                                      Bstr *machineIDs)
+bool VirtualBox::getFloppyImageUsage (const Guid &aId,
+                                      ResourceUsage_T aUsage,
+                                      Bstr *aMachineIDs)
 {
     AutoCaller autoCaller (this);
@@ -2860 +2842 @@
              ++ mit)
         {
-            /// @todo (dmik) move this part to Machine for better incapsulation
-
             ComObjPtr <Machine> m = *mit;
-            AutoReaderLock malock (m);
-
-            /* take the session machine when appropriate */
-            if (!m->data()->mSession.mMachine.isNull())
-                m = m->data()->mSession.mMachine;
-
-            const ComObjPtr <FloppyDrive> &drv = m->floppyDrive();
-            AutoReaderLock dalock (drv);
-
-            /* loop over the backed up (permanent) and current (temporary) floppy data */
-            FloppyDrive::Data *data [2];
-            if (drv->data().isBackedUp())
+            if (m->isFloppyImageUsed (aId, aUsage))
             {
-                data [0] = drv->data().backedUpData();
-                data [1] = drv->data().data();
+                /* if not interested in the list, return shortly */
+                if (aMachineIDs == NULL)
+                    return true;
+
+                idSet.insert (m->data()->mUuid);
             }
-            else
-            {
-                data [0] = drv->data().data();
-                data [1] = NULL;
-            }
-
-            if (!(usage & ResourceUsage_PermanentUsage))
-                data [0] = NULL;
-            if (!(usage & ResourceUsage_TemporaryUsage))
-                data [1] = NULL;
-
-            for (unsigned i = 0; i < ELEMENTS (data); i++)
-            {
-                if (data [i])
-                {
-                    if (data [i]->mDriveState == DriveState_ImageMounted)
-                    {
-                        Guid iid;
-                        data [i]->mFloppyImage->COMGETTER(Id) (iid.asOutParam());
-                        if (iid == id)
-                            idSet.insert (m->data()->mUuid);
-                    }
-                }
-            }
-        }
-    }
-
-    if (machineIDs)
+        }
+    }
+
+    if (aMachineIDs)
     {
         if (!idSet.empty())
@@ -2924 +2872 @@
             *(-- idListPtr) = 0;
             /* copy the string */
-            *machineIDs = idList;
+            *aMachineIDs = idList;
             RTMemTmpFree (idList);
         }
         else
         {
-            (*machineIDs).setNull();
+            (*aMachineIDs).setNull();
         }
     }

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

@@ -543 +543 @@
     void getLogFolder (Utf8Str &aLogFolder);
 
+    bool isDVDImageUsed (const Guid &aId, ResourceUsage_T aUsage);
+    bool isFloppyImageUsed (const Guid &aId, ResourceUsage_T aUsage);
+
     HRESULT openSession (IInternalSessionControl *aControl);
     HRESULT openRemoteSession (IInternalSessionControl *aControl,

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

@@ -107 +107 @@
     ComObjPtr <Snapshot> findChildOrSelf (INPTR BSTR aName);
 
+    bool isDVDImageUsed (const Guid &aId);
+    bool isFloppyImageUsed (const Guid &aId);
+
     void updateSavedStatePaths (const char *aOldPath, const char *aNewPath);
 

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

@@ -231 +231 @@
     }
 
-    BOOL getDVDImageUsage (const Guid &id, ResourceUsage_T usage,
-                           Bstr *machineIDs = NULL);
-    BOOL getFloppyImageUsage (const Guid &id, ResourceUsage_T usage,
-                              Bstr *machineIDs = NULL);
+    bool getDVDImageUsage (const Guid &aId, ResourceUsage_T aUsage,
+                           Bstr *aMachineIDs = NULL);
+    bool getFloppyImageUsage (const Guid &aId, ResourceUsage_T aUsage,
+                              Bstr *aMachineIDs = NULL);
 
     const ComObjPtr <Host> &host() { return mData.mHost; }