Changeset 25182 in vbox for trunk/src

Timestamp:

Dec 4, 2009 10:50:15 AM (15 years ago)

Author:

vboxsync

Message:

Backed out 55600; unable to create new VMs

Location:

trunk/src/VBox/Main

Files:

• DHCPServerImpl.cpp (modified) (3 diffs)
• MachineImpl.cpp (modified) (6 diffs)
• MediumImpl.cpp (modified) (17 diffs)
• PerformanceImpl.cpp (modified) (3 diffs)
• ProgressImpl.cpp (modified) (2 diffs)
• SharedFolderImpl.cpp (modified) (4 diffs)
• VirtualBoxBase.cpp (modified) (6 diffs)
• VirtualBoxImpl.cpp (modified) (80 diffs)
• include/SharedFolderImpl.h (modified) (2 diffs)
• include/StorageControllerImpl.h (modified) (1 diff)
• include/VirtualBoxImpl.h (modified) (3 diffs)
• include/objectslist.h (deleted)
• xml/VirtualBox-settings-common.xsd (modified) (1 diff)

trunk/src/VBox/Main/DHCPServerImpl.cpp

@@ -52 +52 @@
         return;
 
+//    /* we uninit children and reset mParent
+//     * and VirtualBox::removeDependentChild() needs a write lock */
+//    AutoMultiWriteLock2 alock (mVirtualBox->lockHandle(), this->treeLock());
+
+    mVirtualBox->removeDependentChild (this);
+
     unconst(mVirtualBox).setNull();
 }
@@ -72 +78 @@
     m.upperIP = "0.0.0.0";
 
+    /* register with VirtualBox early, since uninit() will
+     * unconditionally unregister on failure */
+    aVirtualBox->addDependentChild (this);
+
     /* Confirm a successful initialization */
     autoInitSpan.setSucceeded();
@@ -87 +97 @@
     /* share VirtualBox weakly (parent remains NULL so far) */
     unconst(mVirtualBox) = aVirtualBox;
+
+    aVirtualBox->addDependentChild (this);
 
     unconst(mName) = data.strNetworkName;

trunk/src/VBox/Main/MachineImpl.cpp

@@ -395 +395 @@
     unconst(mParent) = aParent;
 
+    /* register with parent early, since uninit() will unconditionally
+     * unregister on failure */
+    mParent->addDependentChild (this);
+
     /* allocate the essential machine data structure (the rest will be
      * allocated later by initDataAndChildObjects() */
@@ -687 +691 @@
     /* free the essential data structure last */
     mData.free();
+
+    mParent->removeDependentChild (this);
 
     LogFlowThisFuncLeave();
@@ -5458 +5464 @@
     for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
     {
-        if (mNetworkAdapters[slot])
-        {
-            mNetworkAdapters[slot]->uninit();
-            unconst(mNetworkAdapters[slot]).setNull();
+        if (mNetworkAdapters [slot])
+        {
+            mNetworkAdapters [slot]->uninit();
+            unconst(mNetworkAdapters [slot]).setNull();
         }
     }
@@ -5479 +5485 @@
     for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
     {
-        if (mParallelPorts[slot])
-        {
-            mParallelPorts[slot]->uninit();
-            unconst(mParallelPorts[slot]).setNull();
+        if (mParallelPorts [slot])
+        {
+            mParallelPorts [slot]->uninit();
+            unconst(mParallelPorts [slot]).setNull();
         }
     }
@@ -5488 +5494 @@
     for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
     {
-        if (mSerialPorts[slot])
-        {
-            mSerialPorts[slot]->uninit();
-            unconst(mSerialPorts[slot]).setNull();
+        if (mSerialPorts [slot])
+        {
+            mSerialPorts [slot]->uninit();
+            unconst(mSerialPorts [slot]).setNull();
         }
     }
@@ -9018 +9024 @@
     ComAssertRet (!control.isNull(), E_INVALIDARG);
 
-    /* Creating a Progress object requires the VirtualBox lock, and
+    /* Creating a Progress object requires the VirtualBox children lock, and
      * thus locking it here is required by the lock order rules. */
-    AutoMultiWriteLock2 alock(mParent->lockHandle(), this->lockHandle());
-
-    if (control.equalsTo(mData->mSession.mDirectControl))
+    AutoMultiWriteLock2 alock(mParent->childrenLock(), this->lockHandle());
+
+    if (control.equalsTo (mData->mSession.mDirectControl))
     {
         ComAssertRet (aProgress, E_POINTER);

trunk/src/VBox/Main/MediumImpl.cpp

@@ -896 +896 @@
     unconst(m->pVirtualBox) = aVirtualBox;
 
+    /* register with VirtualBox early, since uninit() will
+     * unconditionally unregister on failure */
+    aVirtualBox->addDependentChild(this);
+
     /* no storage yet */
     m->state = MediumState_NotCreated;
@@ -991 +995 @@
     unconst(m->pVirtualBox) = aVirtualBox;
 
+    /* register with VirtualBox early, since uninit() will
+     * unconditionally unregister on failure */
+    aVirtualBox->addDependentChild(this);
+
     /* there must be a storage unit */
     m->state = MediumState_Created;
@@ -1074 +1082 @@
     /* register with VirtualBox/parent early, since uninit() will
      * unconditionally unregister on failure */
-    if (aParent)
+    if (aParent == NULL)
+        // base disk: add to global list
+        aVirtualBox->addDependentChild(this);
+    else
     {
         // differencing image: add to parent
@@ -1215 +1226 @@
     /* share VirtualBox weakly (parent remains NULL so far) */
     unconst(m->pVirtualBox) = aVirtualBox;
+    aVirtualBox->addDependentChild(this);
 
     /* fake up a UUID which is unique, but also reproducible */
@@ -1302 +1314 @@
             deparent();
         }
+        else
+            // base image: remove it from the global list
+            m->pVirtualBox->removeDependentChild(this);
     }
 
@@ -2318 +2333 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ComObjPtr<Medium> diff = static_cast<Medium*>(aTarget);
+    ComObjPtr<Medium> diff;
+    HRESULT rc = m->pVirtualBox->cast(aTarget, diff);
+    if (FAILED(rc)) return rc;
 
     AutoWriteLock alock(this);
@@ -2329 +2346 @@
     /* We want to be locked for reading as long as our diff child is being
      * created */
-    HRESULT rc = LockRead(NULL);
+    rc = LockRead(NULL);
     if (FAILED(rc)) return rc;
 
@@ -2369 +2386 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    ComObjPtr<Medium> target = static_cast<Medium*>(aTarget);
-    ComObjPtr<Medium> parent;
+    ComObjPtr <Medium> target;
+    HRESULT rc = m->pVirtualBox->cast(aTarget, target);
+    if (FAILED(rc)) return rc;
+    ComObjPtr <Medium> parent;
     if (aParent)
-        parent = static_cast<Medium*>(aParent);
+    {
+        rc = m->pVirtualBox->cast(aParent, parent);
+        if (FAILED(rc)) return rc;
+    }
 
     AutoMultiWriteLock3 alock(this, target, parent);
 
-    ComObjPtr<Progress> progress;
-    HRESULT rc = S_OK;
+    ComObjPtr <Progress> progress;
 
     try
@@ -3855 +3876 @@
                     }
 
+                    /* deassociate from VirtualBox, associate with parent */
+
+                    m->pVirtualBox->removeDependentChild(this);
+
                     /* we set mParent & children() */
                     AutoWriteLock treeLock(m->pVirtualBox->hardDiskTreeLockHandle());
@@ -4678 +4703 @@
 
     if (m->pParent)
+    {
+        /* deassociate from the parent, associate with VirtualBox */
+        m->pVirtualBox->addDependentChild(this);
         deparent();
+    }
 
     HRESULT rc = E_FAIL;
@@ -4684 +4713 @@
     {
         case DeviceType_DVD:
-            rc = m->pVirtualBox->unregisterImage(this, DeviceType_DVD);
+            rc = m->pVirtualBox->unregisterDVDImage(this);
             break;
         case DeviceType_Floppy:
-            rc = m->pVirtualBox->unregisterImage(this, DeviceType_Floppy);
+            rc = m->pVirtualBox->unregisterFloppyImage(this);
             break;
         case DeviceType_HardDisk:
@@ -4704 +4733 @@
             m->pParent = pParentBackup;
             m->pParent->m->llChildren.push_back(this);
+            m->pVirtualBox->removeDependentChild(this);
         }
     }
@@ -5109 +5139 @@
                 Assert(target->m->pParent.isNull());
 
-                /* associate the child with the parent */
+                /* associate the child with the parent and deassociate from
+                 * VirtualBox */
                 target->m->pParent = that;
                 that->m->llChildren.push_back(target);
+                target->m->pVirtualBox->removeDependentChild(target);
 
                 /** @todo r=klaus neither target nor that->base() are locked,
@@ -5126 +5158 @@
 
                 if (FAILED(rc))
+                {
                     /* break the parent association on failure to register */
+                    target->m->pVirtualBox->addDependentChild(target);
                     that->deparent();
+                }
             }
 
@@ -5337 +5372 @@
                         source->deparent();
                     }
+                    else
+                    {
+                        target->m->pVirtualBox->addDependentChild(target);
+                        target->m->pVirtualBox->removeDependentChild(source);
+                    }
 
                     /* then, register again */
@@ -5610 +5650 @@
                         target->m->pParent = parent;
                         parent->m->llChildren.push_back(target);
+                        target->m->pVirtualBox->removeDependentChild(target);
 
                         /* register with mVirtualBox as the last step and move to
@@ -5617 +5658 @@
 
                         if (FAILED(rc))
+                        {
                             /* break parent association on failure to register */
+                            target->m->pVirtualBox->addDependentChild(target);
                             target->deparent();     // removes target from parent
+                        }
                     }
                     else

trunk/src/VBox/Main/PerformanceImpl.cpp

@@ -528 +528 @@
     if (!SUCCEEDED(autoCaller.rc())) return;
 
+    Log(("PerformanceCollector::suspendSampling\n"));
     int rc = RTTimerLRStop(m.sampler);
     AssertRC(rc);
@@ -537 +538 @@
     if (!SUCCEEDED(autoCaller.rc())) return;
 
+    Log(("PerformanceCollector::resumeSampling\n"));
     int rc = RTTimerLRStart(m.sampler, 0);
     AssertRC(rc);
@@ -554 +556 @@
     if (collector->mMagic == MAGIC)
     {
+Log(("staticSamplerCallback %RX64\n", RTTimeNanoTS()));
         collector->samplerCallback();
     }

trunk/src/VBox/Main/ProgressImpl.cpp

@@ -121 +121 @@
     /* share parent weakly */
     unconst(mParent) = aParent;
+
+    /* register with parent early, since uninit() will unconditionally
+     * unregister on failure */
+    mParent->addDependentChild (this);
 #endif
 
@@ -190 +194 @@
         if (aAutoUninitSpan.initFailed() && !mId.isEmpty())
             mParent->removeProgress (mId);
+
+        mParent->removeDependentChild (this);
 
         unconst(mParent).setNull();

trunk/src/VBox/Main/SharedFolderImpl.cpp

@@ -161 +161 @@
     unconst(mVirtualBox) = aVirtualBox;
 
-    HRESULT rc = protectedInit(aVirtualBox, aName, aHostPath, aWritable);
+    HRESULT rc = protectedInit (aVirtualBox, aName, aHostPath, aWritable);
 
     /* Confirm a successful initialization when it's the case */
@@ -176 +176 @@
  *      Must be called from under the object's lock!
  */
-HRESULT SharedFolder::protectedInit(VirtualBoxBase *aParent,
-                                    CBSTR aName,
-                                    CBSTR aHostPath,
-                                    BOOL aWritable)
+HRESULT SharedFolder::protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
+                                     CBSTR aName, CBSTR aHostPath, BOOL aWritable)
 {
     LogFlowThisFunc(("aName={%ls}, aHostPath={%ls}, aWritable={%d}\n",
@@ -223 +221 @@
     unconst(mParent) = aParent;
 
+    /* register with parent */
+    mParent->addDependentChild (this);
+
     unconst(m.name) = aName;
     unconst(m.hostPath) = hostPath;
@@ -242 +243 @@
     if (autoUninitSpan.uninitDone())
         return;
+
+    if (mParent)
+        mParent->removeDependentChild (this);
 
     unconst(mParent) = NULL;

trunk/src/VBox/Main/VirtualBoxBase.cpp

@@ -38 +38 @@
 #include "Logging.h"
 
-#include "objectslist.h"
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxBaseProto
-//
+// VirtualBoxBaseProto methods
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -291 +286 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
 // VirtualBoxBaseProto::AutoInitSpan methods
-//
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -645 +637 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxBase
-//
+// VirtualBoxBase methods
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -686 +675 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxSupportTranslationBase
-//
+// VirtualBoxSupportTranslationBase methods
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -752 +738 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBoxSupportErrorInfoImplBase
-//
+// VirtualBoxSupportErrorInfoImplBase methods
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -929 +912 @@
 }
 
+// VirtualBoxBaseWithChildrenNEXT methods
+////////////////////////////////////////////////////////////////////////////////
 
 /**

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -70 +70 @@
 
 #include "Logging.h"
-#include "objectslist.h"
 
 #ifdef RT_OS_WINDOWS
@@ -83 +82 @@
 
 #define VBOX_GLOBAL_SETTINGS_FILE "VirtualBox.xml"
+
+typedef std::vector< ComObjPtr<Machine> > MachineVector;
+
+typedef std::list< ComObjPtr<Machine> > MachineList;
+typedef std::vector< ComObjPtr<SessionMachine> > SessionMachineVector;
+typedef std::list< ComObjPtr<GuestOSType> > GuestOSTypeList;
+
+typedef std::map<Guid, ComPtr<IProgress> > ProgressMap;
+
+typedef std::list <ComObjPtr<SharedFolder> > SharedFolderList;
+typedef std::list <ComObjPtr<DHCPServer> > DHCPServerList;
+
+typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
+
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -156 +169 @@
 #endif
 
-typedef ObjectsList<Machine> MachinesOList;
-typedef ObjectsList<Medium> MediaOList;
-typedef ObjectsList<GuestOSType> GuestOSTypesOList;
-typedef ObjectsList<SharedFolder> SharedFoldersOList;
-typedef ObjectsList<DHCPServer> DHCPServersOList;
-
-typedef std::map<Guid, ComPtr<IProgress> > ProgressMap;
-typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
-
 /**
  *  Main VirtualBox data structure.
@@ -194 +198 @@
 #endif /* VBOX_WITH_RESOURCE_USAGE_API */
 
-    // the following lists all have an RWLockHandle as a member and are locked
-    // individually; getting the VirtualBox object lock is NOT necessary, but
-    // see the remarks which ObjectsList method lock themselves and which require
-    // external locking
-    MachinesOList                       ollMachines;
-    GuestOSTypesOList                   ollGuestOSTypes;
-
-    MediaOList                          ollHardDisks,           // only base hard disks; the RWLockHandle in here is also used
-                                                                // for hardDiskTreeLockHandle()
-                                        ollDVDImages,
-                                        ollFloppyImages;
-    SharedFoldersOList                  ollSharedFolders;
-    DHCPServersOList                    ollDHCPServers;
-
-    // the hard disks map is an additional map sorted by UUID for quick lookup
-    // and contains ALL hard disks (base and differencing);
-    // the map must also be protected by ollHardDisks.getLockHandle()!
+    MachineList                         llMachines;
+    GuestOSTypeList                     llGuestOSTypes;
+
+    ProgressMap                         mapProgressOperations;
+
+    MediaList                           llHardDisks,
+                                        llDVDImages,
+                                        llFloppyImages;
+    SharedFolderList                    llSharedFolders;
+    DHCPServerList                      llDHCPServers;
+
+    /// @todo NEWMEDIA do we really need this map? Used only in
+    /// find() it seems
     HardDiskMap                         mapHardDisks;
 
-    ProgressMap                         mapProgressOperations;
     CallbackList                        llCallbacks;
 
     RWLockHandle                        mtxProgressOperations;
             // protects mutex operations; "leaf" lock, no other lock may be requested after this
+    RWLockHandle                        mtxHardDiskTree;
+            // protects the hard disk tree; this is implemented here, but only requested through
+            // Medium::treeLock, which returns exactly this
+    RWLockHandle                        mtxChildrenMap;
+            // used for VirtualBoxWithChildrenNEXT management
 
     // the following are data for the client watcher thread
@@ -369 +373 @@
                                           Global::sOSTypes [i].numSerialEnabled);
                 if (SUCCEEDED(rc))
-                    m->ollGuestOSTypes.addChild(guestOSTypeObj);
+                    m->llGuestOSTypes.push_back (guestOSTypeObj);
             }
             ComAssertComRCThrowRC (rc);
@@ -529 +533 @@
         if (FAILED(rc)) return rc;
 
-        rc = registerImage(pImage, DeviceType_DVD, false /* aSaveRegistry */);
+        rc = registerDVDImage(pImage, false /* aSaveRegistry */);
         if (FAILED(rc)) return rc;
     }
@@ -544 +548 @@
         if (FAILED(rc)) return rc;
 
-        rc = registerImage(pImage, DeviceType_Floppy, false /* aSaveRegistry */);
+        rc = registerFloppyImage(pImage, false /* aSaveRegistry */);
         if (FAILED(rc)) return rc;
     }
@@ -564 +568 @@
     /* tell all our child objects we've been uninitialized */
 
-    LogFlowThisFunc(("Uninitializing machines (%d)...\n", m->ollMachines.size()));
-    m->ollMachines.uninitAll();
-    m->ollFloppyImages.uninitAll();
-    m->ollDVDImages.uninitAll();
-    m->ollHardDisks.uninitAll();
-    m->ollDHCPServers.uninitAll();
+    LogFlowThisFunc(("Uninitializing machines (%d)...\n", m->llMachines.size()));
+    if (m->llMachines.size())
+    {
+        MachineList::iterator it = m->llMachines.begin();
+        while (it != m->llMachines.end())
+            (*it++)->uninit();
+        m->llMachines.clear();
+    }
+
+    /* Uninit all other children still referenced by clients (unregistered
+     * machines, hard disks, DVD/floppy images, server-side progress
+     * operations). */
+    uninitDependentChildren();
+
+    m->mapHardDisks.clear();
+
+    m->llFloppyImages.clear();
+    m->llDVDImages.clear();
+    m->llHardDisks.clear();
+    m->llDHCPServers.clear();
 
     m->mapProgressOperations.clear();
 
-    m->ollGuestOSTypes.uninitAll();
+    m->llGuestOSTypes.clear();
 
     /* Note that we release singleton children after we've all other children.
@@ -770 +788 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock al(m->ollMachines.getLockHandle());
-    SafeIfaceArray<IMachine> machines(m->ollMachines.getList());
+    AutoReadLock alock(this);
+
+    SafeIfaceArray<IMachine> machines(m->llMachines);
     machines.detachTo(ComSafeArrayOutArg(aMachines));
 
@@ -785 +804 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock al(m->ollHardDisks.getLockHandle());
-    SafeIfaceArray<IMedium> hardDisks(m->ollHardDisks.getList());
+    AutoReadLock alock(this);
+
+    SafeIfaceArray<IMedium> hardDisks(m->llHardDisks);
     hardDisks.detachTo(ComSafeArrayOutArg(aHardDisks));
 
@@ -792 +812 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(DVDImages) (ComSafeArrayOut(IMedium *, aDVDImages))
+STDMETHODIMP
+VirtualBox::COMGETTER(DVDImages) (ComSafeArrayOut(IMedium *, aDVDImages))
 {
     if (ComSafeArrayOutIsNull(aDVDImages))
@@ -800 +821 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock al(m->ollDVDImages.getLockHandle());
-    SafeIfaceArray<IMedium> images(m->ollDVDImages.getList());
+    AutoReadLock alock(this);
+
+    SafeIfaceArray<IMedium> images(m->llDVDImages);
     images.detachTo(ComSafeArrayOutArg(aDVDImages));
 
@@ -807 +829 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(FloppyImages) (ComSafeArrayOut(IMedium *, aFloppyImages))
+STDMETHODIMP
+VirtualBox::COMGETTER(FloppyImages) (ComSafeArrayOut(IMedium *, aFloppyImages))
 {
     if (ComSafeArrayOutIsNull(aFloppyImages))
@@ -815 +838 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock al(m->ollFloppyImages.getLockHandle());
-    SafeIfaceArray<IMedium> images(m->ollFloppyImages.getList());
+    AutoReadLock alock(this);
+
+    SafeIfaceArray<IMedium> images(m->llFloppyImages);
     images.detachTo(ComSafeArrayOutArg(aFloppyImages));
 
@@ -831 +855 @@
     /* protect mProgressOperations */
     AutoReadLock safeLock(m->mtxProgressOperations);
+
     SafeIfaceArray<IProgress> progress(m->mapProgressOperations);
     progress.detachTo(ComSafeArrayOutArg(aOperations));
@@ -844 +869 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock al(m->ollGuestOSTypes.getLockHandle());
-    SafeIfaceArray<IGuestOSType> ostypes(m->ollGuestOSTypes.getList());
+    AutoReadLock alock(this);
+
+    SafeIfaceArray<IGuestOSType> ostypes(m->llGuestOSTypes);
     ostypes.detachTo(ComSafeArrayOutArg(aGuestOSTypes));
 
@@ -851 +877 @@
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(SharedFolders) (ComSafeArrayOut(ISharedFolder *, aSharedFolders))
+STDMETHODIMP
+VirtualBox::COMGETTER(SharedFolders) (ComSafeArrayOut(ISharedFolder *, aSharedFolders))
 {
 #ifndef RT_OS_WINDOWS
@@ -892 +919 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    AutoReadLock al(m->ollDHCPServers.getLockHandle());
-    SafeIfaceArray<IDHCPServer> svrs (m->ollDHCPServers.getList());
+    AutoReadLock alock(this);
+
+    SafeIfaceArray<IDHCPServer> svrs (m->llDHCPServers);
     svrs.detachTo(ComSafeArrayOutArg(aDHCPServers));
 
@@ -1149 +1177 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::RegisterMachine(IMachine *aMachine)
+STDMETHODIMP VirtualBox::RegisterMachine (IMachine *aMachine)
 {
     CheckComArgNotNull(aMachine);
@@ -1162 +1190 @@
     if (FAILED(rc)) return rc;
 
+    /* We need the children map lock here to keep the getDependentChild() result
+     * valid until we finish */
+    AutoReadLock chLock (childrenLock());
+
     /* We can safely cast child to Machine * here because only Machine
      * implementations of IMachine can be among our children. */
-    Machine *pMachine = static_cast<Machine*>(aMachine);
-
-    AutoCaller machCaller(pMachine);
-    ComAssertComRCRetRC(machCaller.rc());
-
-    rc = registerMachine(pMachine);
+    Machine *machine = static_cast <Machine *> (getDependentChild (aMachine));
+    if (machine == NULL)
+    {
+        /* this machine was not created by CreateMachine() or opened by
+         * OpenMachine() or loaded during startup */
+        return setError (VBOX_E_INVALID_OBJECT_STATE,
+            tr ("The machine named '%ls' is not created within this "
+                "VirtualBox instance"), name.raw());
+    }
+
+    AutoCaller machCaller (machine);
+    ComAssertComRCRetRC (machCaller.rc());
+
+    rc = registerMachine (machine);
+
     /* fire an event */
     if (SUCCEEDED(rc))
-        onMachineRegistered(pMachine->getId(), TRUE);
+        onMachineRegistered(machine->getId(), TRUE);
 
     return rc;
@@ -1178 +1219 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::GetMachine(IN_BSTR aId, IMachine **aMachine)
+STDMETHODIMP VirtualBox::GetMachine (IN_BSTR aId, IMachine **aMachine)
 {
     CheckComArgOutSafeArrayPointerValid(aMachine);
@@ -1195 +1236 @@
 
 /** @note Locks this object for reading, then some machine objects for reading. */
-STDMETHODIMP VirtualBox::FindMachine(IN_BSTR aName, IMachine **aMachine)
+STDMETHODIMP VirtualBox::FindMachine (IN_BSTR aName, IMachine **aMachine)
 {
     LogFlowThisFuncEnter();
@@ -1207 +1248 @@
 
     /* start with not found */
-    ComObjPtr<Machine> pMachineFound;
-
-    AutoReadLock al(m->ollMachines.getLockHandle());
-    for (MachinesOList::iterator it = m->ollMachines.begin();
-         it != m->ollMachines.end();
-         ++it)
+    ComObjPtr<Machine> machine;
+    MachineList machines;
+    {
+        /* take a copy for safe iteration outside the lock */
+        AutoReadLock alock(this);
+        machines = m->llMachines;
+    }
+
+    for (MachineList::iterator it = machines.begin();
+         !machine && it != machines.end();
+         ++ it)
     {
         ComObjPtr<Machine> &pMachine2 = *it;
@@ -1223 +1269 @@
             AutoReadLock machLock(pMachine2);
             if (pMachine2->getName() == aName)
-            {
-                pMachineFound = pMachine2;
-                break;
-            }
+                machine = pMachine2;
         }
     }
 
     /* this will set (*machine) to NULL if machineObj is null */
-    pMachineFound.queryInterfaceTo(aMachine);
-
-    HRESULT rc = pMachineFound
+    machine.queryInterfaceTo(aMachine);
+
+    HRESULT rc = machine
         ? S_OK
-        : setError(VBOX_E_OBJECT_NOT_FOUND,
-                   tr("Could not find a registered machine named '%ls'"), aName);
+        : setError (VBOX_E_OBJECT_NOT_FOUND,
+            tr ("Could not find a registered machine named '%ls'"), aName);
 
     LogFlowThisFunc(("aName=\"%ls\", aMachine=%p, rc=%08X\n", aName, *aMachine, rc));
@@ -1245 +1288 @@
 
 /** @note Locks objects! */
-STDMETHODIMP VirtualBox::UnregisterMachine(IN_BSTR  aId,
-                                           IMachine **aMachine)
+STDMETHODIMP VirtualBox::UnregisterMachine (IN_BSTR  aId,
+                                            IMachine **aMachine)
 {
     Guid id(aId);
@@ -1255 +1298 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
-    // find machine from the given ID
-    ComObjPtr<Machine> pMachine;
-    HRESULT rc = findMachine(id, true /* setError */, &pMachine);
+    AutoWriteLock alock(this);
+
+    ComObjPtr<Machine> machine;
+
+    HRESULT rc = findMachine (id, true /* setError */, &machine);
     if (FAILED(rc)) return rc;
 
-    rc = pMachine->trySetRegistered(FALSE);
+    rc = machine->trySetRegistered (FALSE);
     if (FAILED(rc)) return rc;
 
     /* remove from the collection of registered machines */
-    m->ollMachines.removeChild(pMachine);
+    m->llMachines.remove (machine);
 
     /* save the global registry */
-    AutoWriteLock alock(this);
     rc = saveSettings();
 
     /* return the unregistered machine to the caller */
-    pMachine.queryInterfaceTo(aMachine);
+    machine.queryInterfaceTo(aMachine);
 
     /* fire an event */
-    onMachineRegistered(id, FALSE);
+    onMachineRegistered (id, FALSE);
 
     return rc;
@@ -1417 +1461 @@
     if (SUCCEEDED(rc))
     {
-        rc = registerImage(image, DeviceType_DVD);
+        rc = registerDVDImage (image);
 
         if (SUCCEEDED(rc))
@@ -1484 +1528 @@
     if (SUCCEEDED(rc))
     {
-        rc = registerImage(image, DeviceType_Floppy);
+        rc = registerFloppyImage (image);
 
         if (SUCCEEDED(rc))
@@ -1572 +1616 @@
     *aType = NULL;
 
-    AutoReadLock alock(m->ollGuestOSTypes.getLockHandle());
-    for (GuestOSTypesOList::iterator it = m->ollGuestOSTypes.begin();
-         it != m->ollGuestOSTypes.end();
-         ++it)
+    AutoReadLock alock(this);
+
+    for (GuestOSTypeList::iterator it = m->llGuestOSTypes.begin();
+         it != m->llGuestOSTypes.end();
+         ++ it)
     {
         const Bstr &typeId = (*it)->id();
@@ -1592 +1637 @@
 }
 
-STDMETHODIMP VirtualBox::CreateSharedFolder(IN_BSTR aName, IN_BSTR aHostPath, BOOL /* aWritable */)
+STDMETHODIMP
+VirtualBox::CreateSharedFolder (IN_BSTR aName, IN_BSTR aHostPath, BOOL /* aWritable */)
 {
     CheckComArgNotNull(aName);
@@ -1603 +1649 @@
 }
 
-STDMETHODIMP VirtualBox::RemoveSharedFolder(IN_BSTR aName)
+STDMETHODIMP VirtualBox::RemoveSharedFolder (IN_BSTR aName)
 {
     CheckComArgNotNull(aName);
@@ -1960 +2006 @@
 void VirtualBox::dumpAllBackRefs()
 {
-    {
-        AutoReadLock al(m->ollHardDisks.getLockHandle());
-        for (MediaList::const_iterator mt = m->ollHardDisks.begin();
-             mt != m->ollHardDisks.end();
-             ++mt)
-        {
-            ComObjPtr<Medium> pMedium = *mt;
-            pMedium->dumpBackRefs();
-        }
-    }
-    {
-        AutoReadLock al(m->ollDVDImages.getLockHandle());
-        for (MediaList::const_iterator mt = m->ollDVDImages.begin();
-             mt != m->ollDVDImages.end();
-             ++mt)
-        {
-            ComObjPtr<Medium> pMedium = *mt;
-            pMedium->dumpBackRefs();
-        }
+    for (MediaList::const_iterator mt = m->llHardDisks.begin();
+         mt != m->llHardDisks.end();
+         ++mt)
+    {
+        ComObjPtr<Medium> pMedium = *mt;
+        pMedium->dumpBackRefs();
+    }
+    for (MediaList::const_iterator mt = m->llDVDImages.begin();
+         mt != m->llDVDImages.end();
+         ++mt)
+    {
+        ComObjPtr<Medium> pMedium = *mt;
+        pMedium->dumpBackRefs();
     }
 }
@@ -2622 +2662 @@
 {
     ComObjPtr<GuestOSType> type;
+
     AutoCaller autoCaller(this);
     AssertComRCReturn(autoCaller.rc(), type);
 
+    AutoReadLock alock(this);
+
     /* unknown type must always be the first */
-    ComAssertRet(m->ollGuestOSTypes.size() > 0, type);
-
-    return m->ollGuestOSTypes.front();
+    ComAssertRet (m->llGuestOSTypes.size() > 0, type);
+
+    type = m->llGuestOSTypes.front();
+    return type;
 }
 
@@ -2659 +2703 @@
     AutoReadLock alock(this);
 
-    for (MachinesOList::iterator it = m->ollMachines.begin();
-         it != m->ollMachines.end();
+    for (MachineList::iterator it = m->llMachines.begin();
+         it != m->llMachines.end();
          ++it)
     {
@@ -2695 +2739 @@
                                 ComObjPtr<Machine> *aMachine /* = NULL */)
 {
-    HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
-
     AutoCaller autoCaller(this);
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    {
-        AutoReadLock al(m->ollMachines.getLockHandle());
-
-        for (MachinesOList::iterator it = m->ollMachines.begin();
-             it != m->ollMachines.end();
-             ++it)
+    bool found = false;
+
+    {
+        AutoReadLock alock(this);
+
+        for (MachineList::iterator it = m->llMachines.begin();
+             !found && it != m->llMachines.end();
+             ++ it)
         {
             ComObjPtr<Machine> pMachine2 = *it;
@@ -2712 +2756 @@
             AssertComRC(machCaller.rc());
 
-            if (pMachine2->getId() == aId)
-            {
-                rc = S_OK;
-                if (aMachine)
-                    *aMachine = pMachine2;
-                break;
-            }
-        }
-    }
-
-    if (aSetError && FAILED(rc))
-        setError(VBOX_E_OBJECT_NOT_FOUND,
-                 tr("Could not find a registered machine with UUID {%RTuuid}"),
-                 aId.raw());
+            found = pMachine2->getId() == aId;
+            if (found && aMachine)
+                *aMachine = pMachine2;
+        }
+    }
+
+    HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
+
+    if (aSetError && !found)
+    {
+        setError (VBOX_E_OBJECT_NOT_FOUND,
+            tr ("Could not find a registered machine with UUID {%RTuuid}"),
+            aId.raw());
+    }
 
     return rc;
@@ -2752 +2796 @@
     AssertReturn(aId || aLocation, E_INVALIDARG);
 
-    // we use the hard disks map, but it is protected by the
-    // hard disk _list_ lock handle
-    AutoReadLock alock(m->ollHardDisks.getLockHandle());
+    AutoReadLock alock(this);
 
     /* first, look up by UUID in the map if UUID is provided */
     if (aId)
     {
-        HardDiskMap::const_iterator it = m->mapHardDisks.find(*aId);
+        HardDiskMap::const_iterator it = m->mapHardDisks.find (*aId);
         if (it != m->mapHardDisks.end())
         {
@@ -2845 +2887 @@
     }
 
-    AutoReadLock alock(m->ollDVDImages.getLockHandle());
+    AutoReadLock alock(this);
 
     bool found = false;
 
-    for (MediaList::const_iterator it = m->ollDVDImages.begin();
-         it != m->ollDVDImages.end();
+    for (MediaList::const_iterator it = m->llDVDImages.begin();
+         it != m->llDVDImages.end();
          ++ it)
     {
@@ -2921 +2963 @@
     }
 
-    AutoReadLock alock(m->ollFloppyImages.getLockHandle());
+    AutoReadLock alock(this);
 
     bool found = false;
 
-    for (MediaList::const_iterator it = m->ollFloppyImages.begin();
-         it != m->ollFloppyImages.end();
+    for (MediaList::const_iterator it = m->llFloppyImages.begin();
+         it != m->llFloppyImages.end();
          ++ it)
     {
@@ -2967 +3009 @@
                                     GuestOSType*& pGuestOSType)
 {
+    AutoReadLock alock(this);
+
     /* Look for a GuestOSType object */
-    AssertMsg(m->ollGuestOSTypes.size() != 0,
+    AssertMsg(m->llGuestOSTypes.size() != 0,
               ("Guest OS types array must be filled"));
 
@@ -2977 +3021 @@
     }
 
-    AutoReadLock alock(m->ollGuestOSTypes.getLockHandle());
-    for (GuestOSTypesOList::const_iterator it = m->ollGuestOSTypes.begin();
-         it != m->ollGuestOSTypes.end();
+    for (GuestOSTypeList::const_iterator it = m->llGuestOSTypes.begin();
+         it != m->llGuestOSTypes.end();
          ++it)
     {
@@ -3123 +3166 @@
  * @note Locks this object and media objects for reading.
  */
-HRESULT VirtualBox::checkMediaForConflicts2(const Guid &aId,
-                                            const Utf8Str &aLocation,
-                                            Utf8Str &aConflict)
+HRESULT VirtualBox::checkMediaForConflicts2 (const Guid &aId,
+                                             const Utf8Str &aLocation,
+                                             Utf8Str &aConflict)
 {
     aConflict.setNull();
@@ -3196 +3239 @@
     HRESULT rc = S_OK;
 
+    /* serialize file access (prevents concurrent reads and writes) */
+    AutoWriteLock alock(this);
+
     try
     {
         // machines
-        settings::MachinesRegistry machinesTemp;
-        {
-            AutoReadLock al(m->ollMachines.getLockHandle());
-            for (MachinesOList::iterator it = m->ollMachines.begin();
-                 it != m->ollMachines.end();
-                 ++it)
-            {
-                settings::MachineRegistryEntry mre;
-                rc = (*it)->saveRegistryEntry(mre);
-                machinesTemp.push_back(mre);
-            }
+        m->pMainConfigFile->llMachines.clear();
+        for (MachineList::iterator it = m->llMachines.begin();
+             it != m->llMachines.end();
+             ++it)
+        {
+            settings::MachineRegistryEntry mre;
+            rc = (*it)->saveRegistryEntry(mre);
+            m->pMainConfigFile->llMachines.push_back(mre);
         }
 
         // hard disks
-        settings::MediaList hardDisksTemp;
-        {
-            AutoReadLock al(m->ollHardDisks.getLockHandle());
-            for (MediaList::const_iterator it = m->ollHardDisks.begin();
-                 it != m->ollHardDisks.end();
-                 ++it)
-            {
-                settings::Medium med;
-                rc = (*it)->saveSettings(med);
-                if (FAILED(rc)) throw rc;
-                hardDisksTemp.push_back(med);
-            }
+        m->pMainConfigFile->llHardDisks.clear();
+        for (MediaList::const_iterator it = m->llHardDisks.begin();
+             it != m->llHardDisks.end();
+             ++it)
+        {
+            settings::Medium med;
+            rc = (*it)->saveSettings(med);
+            m->pMainConfigFile->llHardDisks.push_back(med);
+            if (FAILED(rc)) throw rc;
         }
 
         /* CD/DVD images */
-        settings::MediaList dvdsTemp;
-        {
-            AutoReadLock al(m->ollDVDImages.getLockHandle());
-            for (MediaList::const_iterator it = m->ollDVDImages.begin();
-                 it != m->ollDVDImages.end();
-                 ++it)
-            {
-                settings::Medium med;
-                rc = (*it)->saveSettings(med);
-                if (FAILED(rc)) throw rc;
-                dvdsTemp.push_back(med);
-            }
+        m->pMainConfigFile->llDvdImages.clear();
+        for (MediaList::const_iterator it = m->llDVDImages.begin();
+             it != m->llDVDImages.end();
+             ++it)
+        {
+            settings::Medium med;
+            rc = (*it)->saveSettings(med);
+            if (FAILED(rc)) throw rc;
+            m->pMainConfigFile->llDvdImages.push_back(med);
         }
 
         /* floppy images */
-        settings::MediaList floppiesTemp;
-        {
-            AutoReadLock al(m->ollFloppyImages.getLockHandle());
-            for (MediaList::const_iterator it = m->ollFloppyImages.begin();
-                 it != m->ollFloppyImages.end();
-                 ++it)
-            {
-                settings::Medium med;
-                rc = (*it)->saveSettings(med);
-                if (FAILED(rc)) throw rc;
-                floppiesTemp.push_back(med);
-            }
-        }
-
-        settings::DHCPServersList dhcpServersTemp;
-        {
-            AutoReadLock al(m->ollDHCPServers.getLockHandle());
-            for (DHCPServersOList::const_iterator it = m->ollDHCPServers.begin();
-                 it != m->ollDHCPServers.end();
-                 ++it)
-            {
-                settings::DHCPServer d;
-                rc = (*it)->saveSettings(d);
-                if (FAILED(rc)) throw rc;
-                dhcpServersTemp.push_back(d);
-            }
-        }
-
-        /* finally, lock VirtualBox object for writing */
-        AutoWriteLock alock(this);
-
-        /* now copy the temp data to the config file under the VirtualBox lock */
-        m->pMainConfigFile->llMachines = machinesTemp;
-        m->pMainConfigFile->llHardDisks = hardDisksTemp;
-        m->pMainConfigFile->llDvdImages = dvdsTemp;
-        m->pMainConfigFile->llFloppyImages = floppiesTemp;
-        m->pMainConfigFile->llDhcpServers = dhcpServersTemp;
-
-        // leave extra data alone, it's still in the config file
+        m->pMainConfigFile->llFloppyImages.clear();
+        for (MediaList::const_iterator it = m->llFloppyImages.begin();
+             it != m->llFloppyImages.end();
+             ++it)
+        {
+            settings::Medium med;
+            rc = (*it)->saveSettings(med);
+            if (FAILED(rc)) throw rc;
+            m->pMainConfigFile->llFloppyImages.push_back(med);
+        }
+
+        m->pMainConfigFile->llDhcpServers.clear();
+        for (DHCPServerList::const_iterator it =
+                m->llDHCPServers.begin();
+                it != m->llDHCPServers.end();
+                ++ it)
+        {
+            settings::DHCPServer d;
+            rc = (*it)->saveSettings(d);
+            if (FAILED(rc)) throw rc;
+            m->pMainConfigFile->llDhcpServers.push_back(d);
+        }
 
         /* host data (USB filters) */
@@ -3290 +3310 @@
         if (FAILED(rc)) throw rc;
 
-        // and write out the XML, still under the lock
+        // now write out the XML
         m->pMainConfigFile->write(m->strSettingsFilePath);
     }
@@ -3328 +3348 @@
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
+    AutoWriteLock alock(this);
+
     HRESULT rc = S_OK;
 
@@ -3357 +3379 @@
 
     /* add to the collection of registered machines */
-    m->ollMachines.addChild(aMachine);
+    m->llMachines.push_back(aMachine);
 
     if (autoCaller.state() != InInit)
@@ -3388 +3410 @@
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    AutoCaller hardDiskCaller(aHardDisk);
+    AutoWriteLock alock(this);
+
+    AutoCaller hardDiskCaller (aHardDisk);
     AssertComRCReturn(hardDiskCaller.rc(), hardDiskCaller.rc());
 
-    Guid id;
-    Utf8Str strLocationFull;
-    ComObjPtr<Medium> pParent;
-    {
-        AutoReadLock hardDiskLock(aHardDisk);
-        id = aHardDisk->getId();
-        strLocationFull = aHardDisk->getLocationFull();
-        pParent = aHardDisk->getParent();
-    }
-
-    HRESULT rc;
-    {
-        // lock the hard disk lists (list + map) while checking for conflicts
-        AutoWriteLock al(m->ollHardDisks.getLockHandle());
-
-        Utf8Str strConflict;
-        rc = checkMediaForConflicts2(id,
-                                     strLocationFull,
-                                     strConflict);
-        if (FAILED(rc)) return rc;
-        if (strConflict.length())
-            return setError(E_INVALIDARG,
-                            tr("Cannot register the hard disk '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
-                            strLocationFull.raw(),
-                            id.raw(),
-                            strConflict.raw(),
-                            m->strSettingsFilePath.raw());
-
-        // store base (root) hard disks in the list
-        if (pParent.isNull())
-            m->ollHardDisks.getList().push_back(aHardDisk);
-                    // access the list directly because we already locked the list above
-
-        // store all hard disks (even differencing images) in the map
-        m->mapHardDisks[id] = aHardDisk;
-    }
+    AutoReadLock hardDiskLock (aHardDisk);
+
+    Utf8Str strConflict;
+    HRESULT rc = checkMediaForConflicts2(aHardDisk->getId(),
+                                         aHardDisk->getLocationFull(),
+                                         strConflict);
+    if (FAILED(rc)) return rc;
+
+    if (strConflict.length())
+    {
+        return setError(E_INVALIDARG,
+                        tr("Cannot register the hard disk '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
+                        aHardDisk->getLocationFull().raw(),
+                        aHardDisk->getId().raw(),
+                        strConflict.raw(),
+                        m->strSettingsFilePath.raw());
+    }
+
+    if (aHardDisk->getParent().isNull())
+    {
+        /* base (root) hard disk */
+        m->llHardDisks.push_back (aHardDisk);
+    }
+
+    m->mapHardDisks.insert(HardDiskMap::value_type(aHardDisk->getId(),
+                                                   HardDiskMap::mapped_type(aHardDisk)));
 
     if (aSaveRegistry)
     {
         rc = saveSettings();
-        if (FAILED(rc))
+        if (FAILED (rc))
             unregisterHardDisk(aHardDisk, false /* aSaveRegistry */);
     }
@@ -3461 +3475 @@
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
+    AutoWriteLock alock(this);
+
     AutoCaller hardDiskCaller (aHardDisk);
     AssertComRCReturn(hardDiskCaller.rc(), hardDiskCaller.rc());
 
-    Guid id;
-    ComObjPtr<Medium> pParent;
-    {
-        AutoReadLock hardDiskLock(aHardDisk);
-        id = aHardDisk->getId();
-        pParent = aHardDisk->getParent();
-    }
-
-    {
-        // lock the hard disk lists (list + map)
-        AutoWriteLock al(m->ollHardDisks.getLockHandle());
-
-        // remove base (root) hard disks from the list
-        if (pParent.isNull())
-            m->ollHardDisks.getList().remove(aHardDisk);
-                    // access the list directly because we already locked the list above
-
-        // remove all hard disks (even differencing images) from map
-        size_t cnt = m->mapHardDisks.erase(id);
-        Assert(cnt == 1);
-        NOREF(cnt);
+    AutoReadLock hardDiskLock (aHardDisk);
+
+    size_t cnt = m->mapHardDisks.erase(aHardDisk->getId());
+    Assert(cnt == 1);
+    NOREF(cnt);
+
+    if (aHardDisk->getParent().isNull())
+    {
+        /* base (root) hard disk */
+        m->llHardDisks.remove(aHardDisk);
     }
 
@@ -3492 +3497 @@
     {
         rc = saveSettings();
-        if (FAILED(rc))
+        if (FAILED (rc))
             registerHardDisk(aHardDisk, false /* aSaveRegistry */);
     }
@@ -3500 +3505 @@
 
 /**
- * Remembers the given image by storing it in the CD/DVD or floppy image registry.
- *
- * @param argImage      Image object to remember.
- * @param argType       Either DeviceType_DVD or DeviceType_Floppy.
+ * Remembers the given image by storing it in the CD/DVD image registry.
+ *
+ * @param aImage        Image object to remember.
  * @param aSaveRegistry @c true to save the image registry to disk (default).
  *
@@ -3515 +3519 @@
  * @note Locks this object for writing and @a aImage for reading.
  */
-HRESULT VirtualBox::registerImage(Medium *argImage,
-                                  DeviceType_T argType,
-                                  bool argSaveRegistry /*= true*/)
-{
-    AssertReturn(argImage != NULL, E_INVALIDARG);
+HRESULT VirtualBox::registerDVDImage (Medium *aImage,
+                                      bool aSaveRegistry /*= true*/)
+{
+    AssertReturn(aImage != NULL, E_INVALIDARG);
 
     AutoCaller autoCaller(this);
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    AutoCaller imageCaller(argImage);
+    AutoWriteLock alock(this);
+
+    AutoCaller imageCaller (aImage);
     AssertComRCReturn(imageCaller.rc(), imageCaller.rc());
 
-    Guid id;
-    Utf8Str strLocationFull;
-    ComObjPtr<Medium> pParent;
-    {
-        AutoReadLock al(argImage);
-        id = argImage->getId();
-        strLocationFull = argImage->getLocationFull();
-        pParent = argImage->getParent();
-    }
-
-    // work on DVDs or floppies list?
-    ObjectsList<Medium> &oll = (argType == DeviceType_DVD) ? m->ollDVDImages : m->ollFloppyImages;
-
-    HRESULT rc;
-    {
-        // lock the images lists (list + map) while checking for conflicts
-        AutoWriteLock al(oll.getLockHandle());
-
-        Utf8Str strConflict;
-        rc = checkMediaForConflicts2(id,
-                                     strLocationFull,
-                                     strConflict);
-        if (FAILED(rc)) return rc;
-
-        if (strConflict.length())
-            return setError(VBOX_E_INVALID_OBJECT_STATE,
-                            tr("Cannot register the image '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
-                            strLocationFull.raw(),
-                            id.raw(),
-                            strConflict.raw(),
-                            m->strSettingsFilePath.raw());
-
-        // add to the collection
-        oll.getList().push_back(argImage);
-                // access the list directly because we already locked the list above
-    }
-
-    if (argSaveRegistry)
+    AutoReadLock imageLock (aImage);
+
+    Utf8Str strConflict;
+    HRESULT rc = checkMediaForConflicts2(aImage->getId(),
+                                         aImage->getLocationFull(),
+                                         strConflict);
+    if (FAILED(rc)) return rc;
+
+    if (strConflict.length())
+    {
+        return setError(VBOX_E_INVALID_OBJECT_STATE,
+                        tr("Cannot register the CD/DVD image '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
+                        aImage->getLocationFull().raw(),
+                        aImage->getId().raw(),
+                        strConflict.raw(),
+                        m->strSettingsFilePath.raw());
+    }
+
+    /* add to the collection */
+    m->llDVDImages.push_back (aImage);
+
+    if (aSaveRegistry)
     {
         rc = saveSettings();
-        if (FAILED(rc))
-            unregisterImage(argImage, argType, false /* aSaveRegistry */);
+        if (FAILED (rc))
+            unregisterDVDImage (aImage, false /* aSaveRegistry */);
     }
 
@@ -3575 +3564 @@
 
 /**
- * Removes the given image from the CD/DVD or floppy image registry.
- *
- * @param argImage        Image object to remove.
- * @param argType         Either DeviceType_DVD or DeviceType_Floppy.
- * @param argSaveRegistry @c true to save hard disk registry to disk (default).
+ * Removes the given image from the CD/DVD image registry registry.
+ *
+ * @param aImage        Image object to remove.
+ * @param aSaveRegistry @c true to save hard disk registry to disk (default).
  *
  * When @a aSaveRegistry is @c true, this operation may fail because of the
@@ -3590 +3578 @@
  * @note Locks this object for writing and @a aImage for reading.
  */
-HRESULT VirtualBox::unregisterImage(Medium *argImage,
-                                    DeviceType_T argType,
-                                    bool argSaveRegistry /*= true*/)
-{
-    AssertReturn(argImage != NULL, E_INVALIDARG);
+HRESULT VirtualBox::unregisterDVDImage (Medium *aImage,
+                                        bool aSaveRegistry /*= true*/)
+{
+    AssertReturn(aImage != NULL, E_INVALIDARG);
 
     AutoCaller autoCaller(this);
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    AutoCaller imageCaller(argImage);
+    AutoWriteLock alock(this);
+
+    AutoCaller imageCaller (aImage);
     AssertComRCReturn(imageCaller.rc(), imageCaller.rc());
 
-    Guid id;
-    ComObjPtr<Medium> pParent;
-    {
-        AutoReadLock al(argImage);
-        id = argImage->getId();
-        pParent = argImage->getParent();
-    }
-
-    // work on DVDs or floppies list?
-    ObjectsList<Medium> &oll = (argType == DeviceType_DVD) ? m->ollDVDImages : m->ollFloppyImages;
-
-    oll.removeChild(argImage);
+    AutoReadLock imageLock (aImage);
+
+    m->llDVDImages.remove (aImage);
 
     HRESULT rc = S_OK;
 
-    if (argSaveRegistry)
+    if (aSaveRegistry)
     {
         rc = saveSettings();
-        if (FAILED(rc))
-            registerImage(argImage, argType, false /* aSaveRegistry */);
+        if (FAILED (rc))
+            registerDVDImage (aImage, false /* aSaveRegistry */);
     }
 
     return rc;
+}
+
+/**
+ * Remembers the given image by storing it in the floppy image registry.
+ *
+ * @param aImage        Image object to remember.
+ * @param aSaveRegistry @c true to save the image registry to disk (default).
+ *
+ * When @a aSaveRegistry is @c true, this operation may fail because of the
+ * failed #saveSettings() method it calls. In this case, the image object
+ * will not be remembered. It is therefore the responsibility of the caller to
+ * call this method as the last step of some action that requires registration
+ * in order to make sure that only fully functional image objects get
+ * registered.
+ *
+ * @note Locks this object for writing and @a aImage for reading.
+ */
+HRESULT VirtualBox::registerFloppyImage(Medium *aImage,
+                                        bool aSaveRegistry /*= true*/)
+{
+    AssertReturn(aImage != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
+
+    AutoWriteLock alock(this);
+
+    AutoCaller imageCaller (aImage);
+    AssertComRCReturn(imageCaller.rc(), imageCaller.rc());
+
+    AutoReadLock imageLock (aImage);
+
+    Utf8Str strConflict;
+    HRESULT rc = checkMediaForConflicts2(aImage->getId(),
+                                         aImage->getLocationFull(),
+                                         strConflict);
+    if (FAILED(rc)) return rc;
+
+    if (strConflict.length())
+    {
+        return setError(VBOX_E_INVALID_OBJECT_STATE,
+                        tr("Cannot register the floppy image '%s' with UUID {%RTuuid} because a %s already exists in the media registry ('%s')"),
+                        aImage->getLocationFull().raw(),
+                        aImage->getId().raw(),
+                        strConflict.raw(),
+                        m->strSettingsFilePath.raw());
+    }
+
+    /* add to the collection */
+    m->llFloppyImages.push_back (aImage);
+
+    if (aSaveRegistry)
+    {
+        rc = saveSettings();
+        if (FAILED (rc))
+            unregisterFloppyImage(aImage, false /* aSaveRegistry */);
+    }
+
+    return rc;
+}
+
+/**
+ * Removes the given image from the floppy image registry registry.
+ *
+ * @param aImage        Image object to remove.
+ * @param aSaveRegistry @c true to save hard disk registry to disk (default).
+ *
+ * When @a aSaveRegistry is @c true, this operation may fail because of the
+ * failed #saveSettings() method it calls. In this case, the image object
+ * will NOT be removed from the registry when this method returns. It is
+ * therefore the responsibility of the caller to call this method as the first
+ * step of some action that requires unregistration, before calling uninit() on
+ * @a aImage.
+ *
+ * @note Locks this object for writing and @a aImage for reading.
+ */
+HRESULT VirtualBox::unregisterFloppyImage(Medium *aImage,
+                                          bool aSaveRegistry /*= true*/)
+{
+    AssertReturn(aImage != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
+
+    AutoWriteLock alock(this);
+
+    AutoCaller imageCaller (aImage);
+    AssertComRCReturn(imageCaller.rc(), imageCaller.rc());
+
+    AutoReadLock imageLock (aImage);
+
+    m->llFloppyImages.remove (aImage);
+
+    HRESULT rc = S_OK;
+
+    if (aSaveRegistry)
+    {
+        rc = saveSettings();
+        if (FAILED (rc))
+            registerFloppyImage (aImage, false /* aSaveRegistry */);
+    }
+
+    return rc;
+}
+
+/**
+ * Attempts to cast from a raw interface pointer to an underlying object.
+ * On success, @a aTo will contain the object reference. On failure, @a aTo will
+ * be set to @c null and an extended error info will be returned.
+ *
+ * @param aFrom     Interface pointer to cast from.
+ * @param aTo       Where to store a reference to the underlying object.
+ *
+ * @note Locks #childrenLock() for reading.
+ */
+HRESULT VirtualBox::cast (IMedium *aFrom, ComObjPtr<Medium> &aTo)
+{
+    AssertReturn(aFrom != NULL, E_INVALIDARG);
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
+
+    /* We need the children map lock here to keep the getDependentChild() result
+     * valid until we finish */
+    AutoReadLock chLock (childrenLock());
+
+    VirtualBoxBase *child = getDependentChild (aFrom);
+    if (!child)
+        return setError (E_FAIL, tr ("The given hard disk object is not created "
+                                     "within this VirtualBox instance"));
+
+    /* we can safely cast child to Medium * here because only Medium
+     * implementations of IMedium can be among our children */
+
+    aTo = static_cast<Medium*>(child);
+
+    return S_OK;
 }
 
@@ -3637 +3754 @@
  * @note Locks this object + DVD, Floppy and HardDisk children for writing.
  */
-HRESULT VirtualBox::updateSettings(const char *aOldPath, const char *aNewPath)
+HRESULT VirtualBox::updateSettings (const char *aOldPath, const char *aNewPath)
 {
     LogFlowThisFunc(("aOldPath={%s} aNewPath={%s}\n", aOldPath, aNewPath));
@@ -3647 +3764 @@
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    ObjectsList<Medium> ollAll;
-    ollAll.appendOtherList(m->ollDVDImages);
-    ollAll.appendOtherList(m->ollFloppyImages);
-    ollAll.appendOtherList(m->ollHardDisks);
-
-    for (MediaList::iterator it = ollAll.begin();
-         it != ollAll.end();
+    AutoWriteLock alock(this);
+
+    /* check DVD paths */
+    for (MediaList::iterator it = m->llDVDImages.begin();
+         it != m->llDVDImages.end();
          ++ it)
     {
         (*it)->updatePath(aOldPath, aNewPath);
+    }
+
+    /* check Floppy paths */
+    for (MediaList::iterator it = m->llFloppyImages.begin();
+         it != m->llFloppyImages  .end();
+         ++ it)
+    {
+        (*it)->updatePath(aOldPath, aNewPath);
+    }
+
+    /* check HardDisk paths */
+    for (MediaList::const_iterator it = m->llHardDisks.begin();
+         it != m->llHardDisks.end();
+         ++ it)
+    {
+        (*it)->updatePaths(aOldPath, aNewPath);
     }
 
@@ -3768 +3899 @@
 RWLockHandle& VirtualBox::hardDiskTreeLockHandle()
 {
-    return m->ollHardDisks.getLockHandle();
+    return m->mtxHardDiskTree;
+}
+
+/**
+ * Reimplements VirtualBoxWithTypedChildren::childrenLock() to return a
+ * dedicated lock instead of the main object lock. The dedicated lock for
+ * child map operations frees callers of init() methods of these children
+ * from acquiring a write parent (VirtualBox) lock (which would be mandatory
+ * otherwise). Since VirtualBox has a lot of heterogenous children which
+ * init() methods are called here and there, it definitely makes sense.
+ */
+RWLockHandle* VirtualBox::childrenLock()
+{
+    return &m->mtxChildrenMap;
 }
 
@@ -3780 +3924 @@
     LogFlowFuncEnter();
 
-    VirtualBox *that = (VirtualBox*)pvUser;
-    Assert(that);
-
-    typedef std::vector< ComObjPtr<Machine> > MachineVector;
-    typedef std::vector< ComObjPtr<SessionMachine> > SessionMachineVector;
+    VirtualBox *that = (VirtualBox *) pvUser;
+    Assert (that);
 
     SessionMachineVector machines;
@@ -3837 +3978 @@
             {
                 /* machine mutex is released */
-                (machines[rc - WAIT_OBJECT_0 - 1])->checkForDeath();
+                (machines [rc - WAIT_OBJECT_0 - 1])->checkForDeath();
                 update = true;
             }
@@ -3843 +3984 @@
             {
                 /* machine mutex is abandoned due to client process termination */
-                (machines[rc - WAIT_ABANDONED_0 - 1])->checkForDeath();
+                (machines [rc - WAIT_ABANDONED_0 - 1])->checkForDeath();
                 update = true;
             }
@@ -3857 +3998 @@
             {
                 /* close old process handles */
-                for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++i)
-                    CloseHandle(handles[i]);
-
-                // lock the machines list for reading
-                AutoReadLock thatLock(that->m->ollMachines.getLockHandle());
+                for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++ i)
+                    CloseHandle (handles [i]);
+
+                AutoReadLock thatLock (that);
 
                 /* obtain a new set of opened machines */
@@ -3867 +4007 @@
                 machines.clear();
 
-                for (MachinesOList::iterator it = that->m->ollMachines.begin();
-                     it != that->m->ollMachines.end();
-                     ++it)
+                for (MachineList::iterator it = that->m->llMachines.begin();
+                     it != that->m->llMachines.end(); ++ it)
                 {
                     /// @todo handle situations with more than 64 objects
@@ -3877 +4016 @@
                     ComObjPtr<SessionMachine> sm;
                     HANDLE ipcSem;
-                    if ((*it)->isSessionOpenOrClosing(sm, NULL, &ipcSem))
+                    if ((*it)->isSessionOpenOrClosing (sm, NULL, &ipcSem))
                     {
-                        machines.push_back(sm);
-                        handles[1 + cnt] = ipcSem;
-                        ++cnt;
+                        machines.push_back (sm);
+                        handles [1 + cnt] = ipcSem;
+                        ++ cnt;
                     }
                 }
@@ -3891 +4030 @@
                 spawnedMachines.clear();
 
-                for (MachinesOList::iterator it = that->m->ollMachines.begin();
-                     it != that->m->ollMachines.end();
-                     ++it)
+                for (MachineList::iterator it = that->m->llMachines.begin();
+                     it != that->m->llMachines.end(); ++ it)
                 {
                     /// @todo handle situations with more than 64 objects
@@ -3900 +4038 @@
 
                     RTPROCESS pid;
-                    if ((*it)->isSessionSpawning(&pid))
+                    if ((*it)->isSessionSpawning (&pid))
                     {
-                        HANDLE ph = OpenProcess(SYNCHRONIZE, FALSE, pid);
+                        HANDLE ph = OpenProcess (SYNCHRONIZE, FALSE, pid);
                         AssertMsg (ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
                                                 pid, GetLastError()));
                         if (rc == 0)
                         {
-                            spawnedMachines.push_back(*it);
-                            handles[1 + cnt + cntSpawned] = ph;
-                            ++cntSpawned;
+                            spawnedMachines.push_back (*it);
+                            handles [1 + cnt + cntSpawned] = ph;
+                            ++ cntSpawned;
                         }
                     }
@@ -3915 +4053 @@
 
                 LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
-
-                // machines lock unwinds here
             }
         }
@@ -3954 +4090 @@
             autoCaller.release();
 
-            int vrc = RTSemEventWait(that->m->updateReq, 500);
+            int vrc = RTSemEventWait (that->m->updateReq, 500);
 
             /* Restore the caller before using VirtualBox. If it fails, this
@@ -3993 +4129 @@
 #ifdef DEBUG
                             {
-                                AutoReadLock machineLock(machines[semId]);
+                                AutoReadLock machineLock (machines [semId]);
                                 LogFlowFunc (("released mutex: machine='%ls'\n",
-                                              machines[semId]->name().raw()));
+                                              machines [semId]->name().raw()));
                             }
 #endif
-                            machines[semId]->checkForDeath();
+                            machines [semId]->checkForDeath();
                         }
                         update = true;
@@ -4023 +4159 @@
 #ifdef DEBUG
                                     {
-                                        AutoReadLock machineLock(machines[semId]);
-                                        LogFlowFunc(("mutex owner dead: machine='%ls'\n",
-                                                     machines[i]->name().raw()));
+                                        AutoReadLock machineLock (machines [semId]);
+                                        LogFlowFunc (("mutex owner dead: machine='%ls'\n",
+                                                      machines [i]->name().raw()));
                                     }
 #endif
-                                    machines[i]->checkForDeath();
+                                    machines [i]->checkForDeath();
                                 }
                             }
@@ -4062 +4198 @@
                     machines.clear();
 
-                    for (MachinesOList::iterator it = that->m->llMachines.begin();
+                    for (MachineList::iterator it = that->m->llMachines.begin();
                          it != that->m->llMachines.end(); ++ it)
                     {
@@ -4075 +4211 @@
                         {
                             machines.push_back (sm);
-                            handles[cnt].hsemCur = (HSEM) ipcSem;
-                            handles[cnt].ulUser = cnt;
+                            handles [cnt].hsemCur = (HSEM) ipcSem;
+                            handles [cnt].ulUser = cnt;
                             ++ cnt;
                         }
@@ -4100 +4236 @@
                     spawnedMachines.clear();
 
-                    for (MachinesOList::iterator it = that->m->llMachines.begin();
+                    for (MachineList::iterator it = that->m->llMachines.begin();
                          it != that->m->llMachines.end(); ++ it)
                     {
@@ -4154 +4290 @@
                 /* RT_SUCCESS(rc) means an update event is signaled */
 
-                // lock the machines list for reading
-                AutoReadLock thatLock(that->m->ollMachines.getLockHandle());
+                AutoReadLock thatLock (that);
 
                 if (RT_SUCCESS(rc) || update)
@@ -4162 +4297 @@
                     machines.clear();
 
-                    for (MachinesOList::iterator it = that->m->ollMachines.begin();
-                         it != that->m->ollMachines.end();
-                         ++it)
+                    for (MachineList::iterator it = that->m->llMachines.begin();
+                         it != that->m->llMachines.end(); ++ it)
                     {
                         ComObjPtr<SessionMachine> sm;
-                        if ((*it)->isSessionOpenOrClosing(sm))
-                            machines.push_back(sm);
+                        if ((*it)->isSessionOpenOrClosing (sm))
+                            machines.push_back (sm);
                     }
 
                     cnt = machines.size();
-                    LogFlowFunc(("UPDATE: direct session count = %d\n", cnt));
+                    LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
                 }
 
@@ -4180 +4314 @@
                     spawnedMachines.clear();
 
-                    for (MachinesOList::iterator it = that->m->ollMachines.begin();
-                         it != that->m->ollMachines.end();
-                         ++it)
+                    for (MachineList::iterator it = that->m->llMachines.begin();
+                         it != that->m->llMachines.end(); ++ it)
                     {
                         if ((*it)->isSessionSpawning())
-                            spawnedMachines.push_back(*it);
+                            spawnedMachines.push_back (*it);
                     }
 
                     cntSpawned = spawnedMachines.size();
-                    LogFlowFunc(("UPDATE: spawned session count = %d\n", cntSpawned));
+                    LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
                 }
-
-                // machines lock unwinds here
             }
 
@@ -4359 +4490 @@
 }
 
-STDMETHODIMP VirtualBox::FindDHCPServerByNetworkName(IN_BSTR aName, IDHCPServer ** aServer)
+//STDMETHODIMP VirtualBox::FindDHCPServerForInterface (IHostNetworkInterface * aIinterface, IDHCPServer ** aServer)
+//{
+//    return E_NOTIMPL;
+//}
+
+STDMETHODIMP VirtualBox::FindDHCPServerByNetworkName (IN_BSTR aName, IDHCPServer ** aServer)
 {
     CheckComArgNotNull(aName);
@@ -4366 +4502 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    AutoWriteLock alock(this);
 
     HRESULT rc;
@@ -4371 +4509 @@
     ComPtr<DHCPServer> found;
 
-    AutoReadLock alock(m->ollDHCPServers.getLockHandle());
-
-    for (DHCPServersOList::const_iterator it = m->ollDHCPServers.begin();
-         it != m->ollDHCPServers.end();
-         ++it)
-    {
-        rc = (*it)->COMGETTER(NetworkName)(bstr.asOutParam());
+    for (DHCPServerList::const_iterator it =
+            m->llDHCPServers.begin();
+         it != m->llDHCPServers.end();
+         ++ it)
+    {
+        rc = (*it)->COMGETTER(NetworkName) (bstr.asOutParam());
         if (FAILED(rc)) throw rc;
 
-        if (bstr == aName)
+        if(bstr == aName)
         {
             found = *it;
@@ -4421 +4558 @@
  */
 HRESULT VirtualBox::registerDHCPServer(DHCPServer *aDHCPServer,
-                                       bool aSaveRegistry /*= true*/)
+                                     bool aSaveRegistry /*= true*/)
 {
     AssertReturn(aDHCPServer != NULL, E_INVALIDARG);
@@ -4428 +4565 @@
     AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
 
-    AutoCaller dhcpServerCaller(aDHCPServer);
+    AutoWriteLock alock(this);
+
+    AutoCaller dhcpServerCaller (aDHCPServer);
     AssertComRCReturn(dhcpServerCaller.rc(), dhcpServerCaller.rc());
+
+    AutoReadLock dhcpServerLock (aDHCPServer);
 
     Bstr name;
     HRESULT rc;
-    rc = aDHCPServer->COMGETTER(NetworkName)(name.asOutParam());
+    rc = aDHCPServer->COMGETTER(NetworkName) (name.asOutParam());
     if (FAILED(rc)) return rc;
 
     ComPtr<IDHCPServer> existing;
     rc = FindDHCPServerByNetworkName(name.mutableRaw(), existing.asOutParam());
-    if (SUCCEEDED(rc))
+    if(SUCCEEDED(rc))
     {
         return E_INVALIDARG;
     }
-
     rc = S_OK;
 
-    m->ollDHCPServers.addChild(aDHCPServer);
+    m->llDHCPServers.push_back (aDHCPServer);
 
     if (aSaveRegistry)
@@ -4485 +4625 @@
     AssertComRCReturn(dhcpServerCaller.rc(), dhcpServerCaller.rc());
 
-    m->ollDHCPServers.removeChild(aDHCPServer);
+    AutoReadLock dhcpServerLock (aDHCPServer);
+
+    m->llDHCPServers.remove (aDHCPServer);
 
     HRESULT rc = S_OK;

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

@@ -31 +31 @@
 
 class ATL_NO_VTABLE SharedFolder :
-    public VirtualBoxBaseWithChildrenNEXT,
+    public VirtualBoxBase,
     public VirtualBoxSupportErrorInfoImpl<SharedFolder, ISharedFolder>,
     public VirtualBoxSupportTranslation<SharedFolder>,
@@ -94 +94 @@
 protected:
 
-    HRESULT protectedInit(VirtualBoxBase *aParent,
-                          CBSTR aName, CBSTR aHostPath, BOOL aWritable);
+    HRESULT protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
+                           CBSTR aName, CBSTR aHostPath, BOOL aWritable);
 
 private:
 
-    VirtualBoxBase *const mParent;
+    VirtualBoxBaseWithChildrenNEXT *const mParent;
 
     /* weak parents (only one of them is not null) */

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

@@ -32 +32 @@
 
 class ATL_NO_VTABLE StorageController :
-    public VirtualBoxBase,
+    public VirtualBoxBaseWithChildrenNEXT,
     public VirtualBoxSupportErrorInfoImpl<StorageController, IStorageController>,
     public VirtualBoxSupportTranslation<StorageController>,

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

@@ -60 +60 @@
 
 class ATL_NO_VTABLE VirtualBox :
-    public VirtualBoxBase,
+    public VirtualBoxBaseWithChildrenNEXT,
     public VirtualBoxSupportErrorInfoImpl<VirtualBox, IVirtualBox>,
     public VirtualBoxSupportTranslation<VirtualBox>,
@@ -257 +257 @@
     HRESULT unregisterHardDisk(Medium *aHardDisk, bool aSaveRegistry = true);
 
-    HRESULT registerImage(Medium *aImage, DeviceType_T argType, bool aSaveRegistry = true);
-    HRESULT unregisterImage(Medium *aImage, DeviceType_T argType, bool aSaveRegistry = true);
+    HRESULT registerDVDImage(Medium *aImage, bool aSaveRegistry = true);
+    HRESULT unregisterDVDImage(Medium *aImage, bool aSaveRegistry = true);
+
+    HRESULT registerFloppyImage (Medium *aImage, bool aSaveRegistry = true);
+    HRESULT unregisterFloppyImage (Medium *aImage, bool aSaveRegistry = true);
+
+    HRESULT cast (IMedium *aFrom, ComObjPtr<Medium> &aTo);
 
     HRESULT saveSettings();
@@ -270 +275 @@
 
     RWLockHandle& hardDiskTreeLockHandle();
+    RWLockHandle* childrenLock();
 
     /* for VirtualBoxSupportErrorInfoImpl */

trunk/src/VBox/Main/xml/VirtualBox-settings-common.xsd

@@ -489 +489 @@
     <xsd:element name="PAE" type="TPAEType" minOccurs="0"/>
     <xsd:element name="SyntheticCpu" type="TSyntheticCpuType" minOccurs="0"/>
-    <xsd:element name="CpuIdTree" type="TCpuIdTree" minOccurs="0">
+    <xsd:element name="CpuIdTree" type="TCpuIdTree">
       <xsd:unique name="TCPU-CpuIdTree-CpuIdLeaf">
         <xsd:selector xpath="vb:CpuIdLeaf"/>