VirtualBox

Changeset 25930 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Jan 20, 2010 12:59:47 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
56765
Message:

Main: remove separate snapshots tree lock, have snapshots list use machine lock instead

Location:
trunk/src/VBox/Main
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/MachineImpl.cpp

    r25913 r25930  
    9797
    9898Machine::Data::Data()
    99     : mSnapshotsTreeLockHandle(LOCKCLASS_LISTOFSNAPSHOTS)
    10099{
    101100    mRegistered = FALSE;
    … …  
    604603
    605604        /* rollback all changes */
    606         rollback (false /* aNotify */);
     605        rollback(false /* aNotify */);
    607606
    608607        /* uninitialize the common part to make sure all data is reset to
    … …  
    740739        if (mData->m_pMachineConfigFile)
    741740        {
    742             // @todo why are we parsing this several times?
    743             // this is hugely inefficient
     741            // reset the XML file to force loadSettings() (called from registeredInit())
     742            // to parse it again; the file might have changed
    744743            delete mData->m_pMachineConfigFile;
    745744            mData->m_pMachineConfigFile = NULL;
    … …  
    57005699{
    57015700    AutoCaller autoCaller(this);
    5702     AssertComRCReturnVoid (autoCaller.rc());
    5703     AssertComRCReturnVoid (autoCaller.state() == InUninit ||
    5704                            autoCaller.state() == Limited);
     5701    AssertComRCReturnVoid(autoCaller.rc());
     5702    AssertComRCReturnVoid(    autoCaller.state() == InUninit
     5703                           || autoCaller.state() == Limited);
    57055704
    57065705    /* uninit all children using addDependentChild()/removeDependentChild()
    … …  
    57105709    /* tell all our other child objects we've been uninitialized */
    57115710
    5712     for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
     5711    for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
    57135712    {
    57145713        if (mNetworkAdapters[slot])
    … …  
    57315730    }
    57325731
    5733     for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
     5732    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
    57345733    {
    57355734        if (mParallelPorts[slot])
    … …  
    57405739    }
    57415740
    5742     for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
     5741    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
    57435742    {
    57445743        if (mSerialPorts[slot])
    … …  
    57715770     * disk attachments will already be uninitialized and deleted, so this
    57725771     * code will not affect them. */
    5773     if (!!mMediaData && (getClassID() == clsidMachine || getClassID() == clsidSnapshotMachine))
     5772    VBoxClsID clsid = getClassID();
     5773    if (    !!mMediaData
     5774         && (clsid == clsidMachine || clsid == clsidSnapshotMachine)
     5775       )
    57745776    {
    57755777        for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
    … …  
    60256027
    60266028        /* Snapshot node (optional) */
    6027         if (mData->m_pMachineConfigFile->llFirstSnapshot.size())
    6028         {
    6029             // there can only be one root snapshot
    6030             Assert(mData->m_pMachineConfigFile->llFirstSnapshot.size() == 1);
     6029        size_t cRootSnapshots;
     6030        if ((cRootSnapshots = mData->m_pMachineConfigFile->llFirstSnapshot.size()))
     6031        {
     6032            // there must be only one root snapshot
     6033            Assert(cRootSnapshots == 1);
    60316034
    60326035            settings::Snapshot &snap = mData->m_pMachineConfigFile->llFirstSnapshot.front();
    … …  
    60756078    catch (...)
    60766079    {
    6077         rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
     6080        rc = VirtualBox::handleUnexpectedExceptions(RT_SRC_POS);
    60786081    }
    60796082
    … …  
    65396542                if (FAILED(rc))
    65406543                {
    6541                     if (getClassID() == clsidSnapshotMachine)
     6544                    VBoxClsID clsid = getClassID();
     6545                    if (clsid == clsidSnapshotMachine)
    65426546                    {
    65436547                        // wrap another error message around the "cannot find hard disk" set by findHardDisk
    … …  
    66306634                rc = medium->attachTo(mData->mUuid);
    66316635        }
     6636
    66326637        if (FAILED(rc))
    66336638            break;
    66346639
    6635         /* backup mMediaData to let registeredInit() properly rollback on failure
     6640        /* back up mMediaData to let registeredInit() properly rollback on failure
    66366641         * (= limited accessibility) */
    6637 
    66386642        mMediaData.backup();
    66396643        mMediaData->mAttachments.push_back(pAttachment);
    … …  
    66546658                              bool aSetError /* = false */)
    66556659{
    6656     AutoReadLock chlock(snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     6660    AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
    66576661
    66586662    if (!mData->mFirstSnapshot)
    … …  
    66946698    AssertReturn(aName, E_INVALIDARG);
    66956699
    6696     AutoReadLock chlock(snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     6700    AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
    66976701
    66986702    if (!mData->mFirstSnapshot)
    … …  
    82808284 * @note Locks objects for writing!
    82818285 */
    8282 void Machine::rollback (bool aNotify)
     8286void Machine::rollback(bool aNotify)
    82838287{
    82848288    AutoCaller autoCaller(this);
    … …  
    82938297    if (aNotify && mHWData.isBackedUp())
    82948298    {
    8295         if (mHWData->mSharedFolders.size() !=
    8296             mHWData.backedUpData()->mSharedFolders.size())
     8299        if (mHWData->mSharedFolders.size() != mHWData.backedUpData()->mSharedFolders.size())
    82978300            sharedFoldersChanged = true;
    82988301        else
    82998302        {
    8300             for (HWData::SharedFolderList::iterator rit =
    8301                      mHWData->mSharedFolders.begin();
     8303            for (HWData::SharedFolderList::iterator rit = mHWData->mSharedFolders.begin();
    83028304                 rit != mHWData->mSharedFolders.end() && !sharedFoldersChanged;
    83038305                 ++rit)
    83048306            {
    8305                 for (HWData::SharedFolderList::iterator cit =
    8306                          mHWData.backedUpData()->mSharedFolders.begin();
     8307                for (HWData::SharedFolderList::iterator cit = mHWData.backedUpData()->mSharedFolders.begin();
    83078308                     cit != mHWData.backedUpData()->mSharedFolders.end();
    83088309                     ++cit)
    83098310                {
    8310                     if ((*cit)->getName() != (*rit)->getName() ||
    8311                         (*cit)->getHostPath() != (*rit)->getHostPath())
     8311                    if (    (*cit)->getName() != (*rit)->getName()
     8312                         || (*cit)->getHostPath() != (*rit)->getHostPath()
     8313                       )
    83128314                    {
    83138315                        sharedFoldersChanged = true;
    … …  
    83288330            while (it != mStorageControllers->end())
    83298331            {
    8330                 if (std::find (backedList->begin(), backedList->end(), *it ) ==
    8331                     backedList->end())
     8332                if (   std::find(backedList->begin(), backedList->end(), *it)
     8333                    == backedList->end()
     8334                   )
    83328335                {
    83338336                    (*it)->uninit();
    … …  
    83598362
    83608363    /* check for changes in child objects */
    8361 
    83628364    bool vrdpChanged = false, usbChanged = false;
    83638365
    8364     ComPtr<INetworkAdapter> networkAdapters [RT_ELEMENTS (mNetworkAdapters)];
    8365     ComPtr<ISerialPort> serialPorts [RT_ELEMENTS (mSerialPorts)];
    8366     ComPtr<IParallelPort> parallelPorts [RT_ELEMENTS (mParallelPorts)];
     8366    ComPtr<INetworkAdapter> networkAdapters[RT_ELEMENTS(mNetworkAdapters)];
     8367    ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
     8368    ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
    83678369
    83688370    if (mBIOSSettings)
    … …  
    83808382        usbChanged = mUSBController->rollback();
    83818383
    8382     for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
    8383         if (mNetworkAdapters [slot])
    8384             if (mNetworkAdapters [slot]->rollback())
    8385                 networkAdapters [slot] = mNetworkAdapters [slot];
    8386 
    8387     for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
    8388         if (mSerialPorts [slot])
    8389             if (mSerialPorts [slot]->rollback())
    8390                 serialPorts [slot] = mSerialPorts [slot];
    8391 
    8392     for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
    8393         if (mParallelPorts [slot])
    8394             if (mParallelPorts [slot]->rollback())
    8395                 parallelPorts [slot] = mParallelPorts [slot];
     8384    for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
     8385        if (mNetworkAdapters[slot])
     8386            if (mNetworkAdapters[slot]->rollback())
     8387                networkAdapters[slot] = mNetworkAdapters[slot];
     8388
     8389    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
     8390        if (mSerialPorts[slot])
     8391            if (mSerialPorts[slot]->rollback())
     8392                serialPorts[slot] = mSerialPorts[slot];
     8393
     8394    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
     8395        if (mParallelPorts[slot])
     8396            if (mParallelPorts[slot]->rollback())
     8397                parallelPorts[slot] = mParallelPorts[slot];
    83968398
    83978399    if (aNotify)
    … …  
    84108412            that->onUSBControllerChange();
    84118413
    8412         for (ULONG slot = 0; slot < RT_ELEMENTS (networkAdapters); slot ++)
    8413             if (networkAdapters [slot])
    8414                 that->onNetworkAdapterChange (networkAdapters [slot], FALSE);
    8415         for (ULONG slot = 0; slot < RT_ELEMENTS (serialPorts); slot ++)
    8416             if (serialPorts [slot])
    8417                 that->onSerialPortChange (serialPorts [slot]);
    8418         for (ULONG slot = 0; slot < RT_ELEMENTS (parallelPorts); slot ++)
    8419             if (parallelPorts [slot])
    8420                 that->onParallelPortChange (parallelPorts [slot]);
     8414        for (ULONG slot = 0; slot < RT_ELEMENTS(networkAdapters); slot ++)
     8415            if (networkAdapters[slot])
     8416                that->onNetworkAdapterChange(networkAdapters[slot], FALSE);
     8417        for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); slot ++)
     8418            if (serialPorts[slot])
     8419                that->onSerialPortChange(serialPorts[slot]);
     8420        for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); slot ++)
     8421            if (parallelPorts[slot])
     8422                that->onParallelPortChange(parallelPorts[slot]);
    84218423
    84228424        if (storageChanged)

  • trunk/src/VBox/Main/MediumImpl.cpp

    r25907 r25930  
    27322732                        m->numCreateDiffTasks);
    27332733
    2734     BackRefList::iterator it =
    2735         std::find_if(m->backRefs.begin(), m->backRefs.end(),
    2736                      BackRef::EqualsTo(aMachineId));
     2734    BackRefList::iterator it = std::find_if(m->backRefs.begin(),
     2735                                            m->backRefs.end(),
     2736                                            BackRef::EqualsTo(aMachineId));
    27372737    if (it == m->backRefs.end())
    27382738    {
    … …  
    27652765
    27662766        if (idOldSnapshot == aSnapshotId)
     2767        {
     2768#ifdef DEBUG
     2769            dumpBackRefs();
     2770#endif
    27672771            return setError(E_FAIL,
    2768                             tr("Cannot attach medium '%s' {%RTuuid} from snapshot '%RTuuid': medium is already in use by snapshot '%RTuuid'"),
     2772                            tr("Cannot attach medium '%s' {%RTuuid} from snapshot '%RTuuid': medium is already in use by this snapshot!"),
    27692773                            m->strLocationFull.raw(),
    27702774                            m->id.raw(),
    27712775                            aSnapshotId.raw(),
    27722776                            idOldSnapshot.raw());
     2777        }
    27732778    }
    27742779
    … …  
    31773182 *                      if no real merge is necessary).
    31783183 *
    3179  * @note Locks getTreeLock() for reading. Locks this object, aTarget and all
    3180  *       intermediate hard disks for writing.
     3184 * @note Caller must hold media tree lock for writing. This locks this object
     3185 *       and every medium object on the merge chain for writing.
    31813186 */
    31823187HRESULT Medium::prepareDiscard(MergeChain * &aChain)
    … …  
    31893194    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    31903195
    3191     /* we access mParent & children() */
    3192     AutoReadLock treeLock(m->pVirtualBox->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     3196    Assert(m->pVirtualBox->getMediaTreeLockHandle().isWriteLockOnCurrentThread());
    31933197
    31943198    AssertReturn(m->type == MediumType_Normal, E_FAIL);

  • trunk/src/VBox/Main/SnapshotImpl.cpp

    r25907 r25930  
    448448    if (FAILED(autoCaller.rc())) return autoCaller.rc();
    449449
    450     AutoReadLock alock(m->pMachine->snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    451     AutoReadLock block(this->lockHandle() COMMA_LOCKVAL_SRC_POS);
     450    // snapshots tree is protected by machine lock
     451    AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
    452452
    453453    SafeIfaceArray<ISnapshot> collection(m->llChildren);
    … …  
    491491    AssertComRC(autoCaller.rc());
    492492
    493     AutoReadLock treeLock(m->pMachine->snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     493    // snapshots tree is protected by machine lock
     494    AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     495
    494496    return (ULONG)m->llChildren.size();
    495497}
    … …  
    526528    AssertComRC(autoCaller.rc());
    527529
    528     AutoReadLock treeLock(m->pMachine->snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     530    // snapshots tree is protected by machine lock
     531    AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     532
    529533    return getAllChildrenCountImpl();
    530534}
    … …  
    686690    AssertComRC(autoCaller.rc());
    687691
    688     AutoWriteLock chLock(m->pMachine->snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     692    // snapshots tree is protected by machine lock
     693    AutoWriteLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
     694
    689695    // call the implementation under the tree lock
    690696    updateSavedStatePathsImpl(aOldPath, aNewPath);
    … …  
    692698
    693699/**
    694  * Internal implementation for Snapshot::saveSnapshot (below).
     700 * Internal implementation for Snapshot::saveSnapshot (below). Caller has
     701 * requested the snapshots tree (machine) lock.
     702 *
    695703 * @param aNode
    696704 * @param aAttrsOnly
    … …  
    753761HRESULT Snapshot::saveSnapshot(settings::Snapshot &data, bool aAttrsOnly)
    754762{
    755     AutoWriteLock listLock(m->pMachine->snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
     763    // snapshots tree is protected by machine lock
     764    AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
    756765
    757766    return saveSnapshotImpl(data, aAttrsOnly);
    … …  
    966975
    967976    unconst(mBIOSSettings).createObject();
    968     mBIOSSettings->init (this);
     977    mBIOSSettings->init(this);
    969978
    970979#ifdef VBOX_WITH_VRDP
    971980    unconst(mVRDPServer).createObject();
    972     mVRDPServer->init (this);
     981    mVRDPServer->init(this);
    973982#endif
    974983
    975984    unconst(mAudioAdapter).createObject();
    976     mAudioAdapter->init (this);
     985    mAudioAdapter->init(this);
    977986
    978987    unconst(mUSBController).createObject();
    979     mUSBController->init (this);
    980 
    981     for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
    982     {
    983         unconst(mNetworkAdapters [slot]).createObject();
    984         mNetworkAdapters [slot]->init (this, slot);
    985     }
    986 
    987     for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
    988     {
    989         unconst(mSerialPorts [slot]).createObject();
    990         mSerialPorts [slot]->init (this, slot);
    991     }
    992 
    993     for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
    994     {
    995         unconst(mParallelPorts [slot]).createObject();
    996         mParallelPorts [slot]->init (this, slot);
     988    mUSBController->init(this);
     989
     990    for (ULONG slot = 0; slot < RT_ELEMENTS(mNetworkAdapters); slot++)
     991    {
     992        unconst(mNetworkAdapters[slot]).createObject();
     993        mNetworkAdapters[slot]->init(this, slot);
     994    }
     995
     996    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
     997    {
     998        unconst(mSerialPorts[slot]).createObject();
     999        mSerialPorts[slot]->init(this, slot);
     1000    }
     1001
     1002    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
     1003    {
     1004        unconst(mParallelPorts[slot]).createObject();
     1005        mParallelPorts[slot]->init(this, slot);
    9971006    }
    9981007
    … …  
    19391948    ComAssertRet(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
    19401949
    1941     AutoWriteLock treeLock(snapshotsTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
    1942 
    19431950    ComObjPtr<Snapshot> pSnapshot;
    19441951    HRESULT rc = findSnapshot(id, pSnapshot, true /* aSetError */);
    … …  
    21132120    /* Locking order:  */
    21142121    AutoMultiWriteLock3 alock(this->lockHandle(),
    2115                               this->snapshotsTreeLockHandle(),
    2116                               aTask.pSnapshot->lockHandle()
     2122                              aTask.pSnapshot->lockHandle(),
     2123                              &mParent->getMediaTreeLockHandle()
    21172124                              COMMA_LOCKVAL_SRC_POS);
    21182125

  • trunk/src/VBox/Main/VirtualBoxBase.cpp

    r25860 r25930  
    10131013         * Do some checks to avoid endless loops when the user is forgetful */
    10141014        -- count;
    1015         Assert (count == mDependentChildren.size());
     1015        Assert(count == mDependentChildren.size());
    10161016        if (count != mDependentChildren.size())
    10171017            mDependentChildren.erase (it);

  • trunk/src/VBox/Main/glue/AutoLock.cpp

    r25906 r25930  
    7575        { LOCKCLASS_LISTOFMACHINES,     "4-LISTOFMACHINES" },
    7676        { LOCKCLASS_MACHINEOBJECT,      "5-MACHINEOBJECT" },
    77         { LOCKCLASS_LISTOFSNAPSHOTS,    "6-LISTOFSNAPSHOTS" },
    78         { LOCKCLASS_SNAPSHOTOBJECT,     "7-SNAPSHOTOBJECT" },
    79         { LOCKCLASS_LISTOFMEDIA,        "8-LISTOFMEDIA" },
    80         { LOCKCLASS_LISTOFOTHEROBJECTS, "9-LISTOFOTHEROBJECTS" },
    81         { LOCKCLASS_OTHEROBJECT,        "10-OTHEROBJECT" },
    82         { LOCKCLASS_USBLIST,            "11-USBLIST" },
    83         { LOCKCLASS_PROGRESSLIST,       "12-PROGRESSLIST" },
    84         { LOCKCLASS_OBJECTSTATE,        "13-OBJECTSTATE" }
     77        { LOCKCLASS_SNAPSHOTOBJECT,     "6-SNAPSHOTOBJECT" },
     78        { LOCKCLASS_LISTOFMEDIA,        "7-LISTOFMEDIA" },
     79        { LOCKCLASS_LISTOFOTHEROBJECTS, "8-LISTOFOTHEROBJECTS" },
     80        { LOCKCLASS_OTHEROBJECT,        "9-OTHEROBJECT" },
     81        { LOCKCLASS_USBLIST,            "10-USBLIST" },
     82        { LOCKCLASS_PROGRESSLIST,       "11-PROGRESSLIST" },
     83        { LOCKCLASS_OBJECTSTATE,        "12-OBJECTSTATE" }
    8584    };
    8685

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

    r25903 r25930  
    188188        ComObjPtr<Snapshot> mFirstSnapshot;
    189189        ComObjPtr<Snapshot> mCurrentSnapshot;
    190 
    191         // protectes the snapshots tree of this machine
    192         RWLockHandle mSnapshotsTreeLockHandle;
    193190    };
    194191
    … …  
    800797    static const wchar_t *getComponentName() { return L"Machine"; }
    801798
    802     /**
    803      * Returns the handle of the snapshots tree lock. This lock is
    804      * machine-specific because there is one snapshots tree per
    805      * IMachine; the lock protects the "first snapshot" member in
    806      * IMachine and all the children and parent links in snapshot
    807      * objects pointed to therefrom.
    808      *
    809      * Locking order:
    810      * a) object lock of the machine;
    811      * b) snapshots tree lock of the machine;
    812      * c) individual snapshot object locks in parent->child order,
    813      *    if needed; they are _not_ needed for the tree itself
    814      *    (as defined above).
    815      */
    816     RWLockHandle* snapshotsTreeLockHandle() const
    817     {
    818         return &mData->mSnapshotsTreeLockHandle;
    819     }
    820 
    821799protected:
    822800
    … …  
    932910    // so they cannot be a part of HWData
    933911
    934     const ComObjPtr<VRDPServer> mVRDPServer;
    935     const ComObjPtr<SerialPort>
    936         mSerialPorts [SchemaDefs::SerialPortCount];
    937     const ComObjPtr<ParallelPort>
    938         mParallelPorts [SchemaDefs::ParallelPortCount];
    939     const ComObjPtr<AudioAdapter> mAudioAdapter;
    940     const ComObjPtr<USBController> mUSBController;
    941     const ComObjPtr<BIOSSettings> mBIOSSettings;
    942     const ComObjPtr<NetworkAdapter>
    943         mNetworkAdapters [SchemaDefs::NetworkAdapterCount];
     912    const ComObjPtr<VRDPServer>     mVRDPServer;
     913    const ComObjPtr<SerialPort>     mSerialPorts[SchemaDefs::SerialPortCount];
     914    const ComObjPtr<ParallelPort>   mParallelPorts[SchemaDefs::ParallelPortCount];
     915    const ComObjPtr<AudioAdapter>   mAudioAdapter;
     916    const ComObjPtr<USBController>  mUSBController;
     917    const ComObjPtr<BIOSSettings>   mBIOSSettings;
     918    const ComObjPtr<NetworkAdapter> mNetworkAdapters[SchemaDefs::NetworkAdapterCount];
    944919
    945920    typedef std::list< ComObjPtr<StorageController> > StorageControllerList;
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette