VirtualBox

Changeset 76240 in vbox for trunk


Ignore:
Timestamp:
Dec 14, 2018 8:34:20 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
127510
Message:

Main: bugref:6913: had to revert all changes for the defect because of crashing VBoxSVC on MacOS

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

Legend:

Unmodified
Added
Removed

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

    r76215 r76240  
    2372523725      The given medium was registered or unregistered
    2372623726      within this VirtualBox installation.
     23727      <note>This event is not yet implemented.</note>
    2372723728    </desc>
    2372823729
    … …  
    2375123752      The configuration of the given medium was changed (location, properties,
    2375223753      child/parent or anything else).
     23754      <note>This event is not yet implemented.</note>
    2375323755    </desc>
    2375423756
    … …  
    2414224144      <link to="IMachine::mediumAttachments">medium attachment</link>
    2414324145      changes.
     24146      <note>This event is not yet implemented.</note>
    2414424147    </desc>
    2414524148    <attribute name="mediumAttachment" type="IMediumAttachment" readonly="yes">

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

    r76215 r76240  
    169169                                MediumLockList *pMediumLockList,
    170170                                ComObjPtr<Progress> *aProgress,
    171                                 bool aWait,
    172                                 bool aNotify);
     171                                bool aWait);
    173172    Utf8Str i_getPreferredDiffFormat();
    174173    MediumVariant_T i_getPreferredDiffVariant();
    … …  
    177176    HRESULT i_unlockRead(MediumState_T *aState);
    178177    HRESULT i_unlockWrite(MediumState_T *aState);
    179     HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait, bool aNotify);
     178    HRESULT i_deleteStorage(ComObjPtr<Progress> *aProgress, bool aWait);
    180179    HRESULT i_markForDeletion();
    181180    HRESULT i_unmarkForDeletion();
    … …  
    200199                      MediumLockList *aMediumLockList,
    201200                      ComObjPtr<Progress> *aProgress,
    202                       bool aWait,
    203                       bool aNotify);
     201                      bool aWait);
    204202    void i_cancelMergeTo(MediumLockList *aChildrenToReparent,
    205203                       MediumLockList *aMediumLockList);
    … …  
    208206                     MediumLockList *aMediumLockList,
    209207                     ComObjPtr<Progress> *aProgress,
    210                      bool aWait,
    211                      bool aNotify);
     208                     bool aWait);
    212209
    213210    HRESULT i_fixParentUuidOfChildren(MediumLockList *pChildrenToReparent);
    … …  
    223220                         const ComObjPtr<Progress> &aProgress);
    224221    HRESULT i_importFile(const char *aFilename,
    225                          const ComObjPtr<MediumFormat> &aFormat,
    226                          MediumVariant_T aVariant,
    227                          RTVFSIOSTREAM hVfsIosSrc,
    228                          const ComObjPtr<Medium> &aParent,
    229                          const ComObjPtr<Progress> &aProgress,
    230                          bool aNotify);
     222                        const ComObjPtr<MediumFormat> &aFormat,
     223                        MediumVariant_T aVariant,
     224                        RTVFSIOSTREAM hVfsIosSrc,
     225                        const ComObjPtr<Medium> &aParent,
     226                        const ComObjPtr<Progress> &aProgress);
    231227
    232228    HRESULT i_cloneToEx(const ComObjPtr<Medium> &aTarget, MediumVariant_T aVariant,
    233229                        const ComObjPtr<Medium> &aParent, IProgress **aProgress,
    234                         uint32_t idxSrcImageSame, uint32_t idxDstImageSame, bool aNotify);
     230                        uint32_t idxSrcImageSame, uint32_t idxDstImageSame);
    235231
    236232    const Utf8Str& i_getKeyId();

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

    r76215 r76240  
    150150    int i_unloadVDPlugin(const char *pszPluginLibrary);
    151151
    152     void i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, const BOOL aRegistered);
    153     void i_onMediumConfigChanged(IMedium *aMedium);
    154     void i_onMediumChanged(IMediumAttachment* aMediumAttachment);
    155     void i_onStorageDeviceChanged(IMediumAttachment* aStorageDevice, const BOOL fRemoved, const BOOL fSilent);
    156152    void i_onMachineStateChange(const Guid &aId, MachineState_T aState);
    157153    void i_onMachineDataChange(const Guid &aId, BOOL aTemporary = FALSE);

  • trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

    r76215 r76240  
    26412641                                                     hVfsIosReadAhead,
    26422642                                                     nullParent,
    2643                                                      pProgressImportTmp,
    2644                                                      true /* aNotify */);
     2643                                                     pProgressImportTmp);
    26452644                    RTVfsIoStrmRelease(hVfsIosReadAhead);
    26462645                    hVfsIosSrc = NIL_RTVFSIOSTREAM;

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

    r76215 r76240  
    40374037                                                 pMediumLockList,
    40384038                                                 NULL /* aProgress */,
    4039                                                  true /* aWait */,
    4040                                                  false /* aNotify */);
     4039                                                 true /* aWait */);
    40414040
    40424041                alock.acquire();
    … …  
    41464145    mParent->i_saveModifiedRegistries();
    41474146
    4148     if (aM)
    4149         mParent->i_onMediumConfigChanged(aM);
    41504147    return rc;
    41514148}
    … …  
    1082210819                                              pMediumLockList,
    1082310820                                              NULL /* aProgress */,
    10824                                               true /* aWait */,
    10825                                               false /* aNotify */);
     10821                                              true /* aWait */);
    1082610822            alock.acquire();
    1082710823            if (FAILED(rc)) throw rc;
    … …  
    1105911055                Assert(pMedium);
    1106011056
    11061                 rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/, false /*aNotify*/);
     11057                rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/);
    1106211058                // continue on delete failure, just collect error messages
    1106311059                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(),
    … …  
    1122711223
    1122811224        HRESULT rc = oldmedium->i_deleteStorage(NULL /*aProgress*/,
    11229                                                 true /*aWait*/,
    11230                                                 false /*aNotify*/);
     11225                                                true /*aWait*/);
    1123111226
    1123211227        writeLock.acquire();
    … …  
    1402814023    }
    1402914024
    14030     mParent->i_onMediumChanged(aAttachment);
    14031 
    1403214025    /* ignore notifications sent after #OnSessionEnd() is called */
    1403314026    if (!directControl)
    … …  
    1426614259            directControl = mData->mSession.mDirectControl;
    1426714260    }
    14268 
    14269     mParent->i_onStorageDeviceChanged(aAttachment, aRemove, aSilent);
    1427014261
    1427114262    /* ignore notifications sent after #OnSessionEnd() is called */

  • trunk/src/VBox/Main/src-server/MachineImplCloneVM.cpp

    r76215 r76240  
    1616 */
    1717
    18 #include <set>
    19 #include <map>
    2018#include "MachineImplCloneVM.h"
    2119
    … …  
    732730                                          pMediumLockList,
    733731                                          NULL /* aProgress */,
    734                                           true /* aWait */,
    735                                           false /* aNotify */);
     732                                          true /* aWait */);
    736733        delete pMediumLockList;
    737734        if (FAILED(rc)) throw rc;
    … …  
    10191016    RTCList<ComObjPtr<Medium> > newMedia;   /* All created images */
    10201017    RTCList<Utf8Str> newFiles;              /* All extra created files (save states, ...) */
    1021     std::set<ComObjPtr<Medium> > pMediumsForNotify;
    1022     std::map<Guid, DeviceType_T> uIdsForNotify;
    10231018    try
    10241019    {
    … …  
    11581153                        /* diff image has to be used... */
    11591154                        pNewParent = pDiff;
    1160                         pMediumsForNotify.insert(pDiff->i_getParent());
    1161                         uIdsForNotify[pDiff->i_getId()] = pDiff->i_getDeviceType();
    11621155                    }
    11631156                    else
    … …  
    12911284                                                   progress2.asOutParam(),
    12921285                                                   uSrcParentIdx,
    1293                                                    uTrgParentIdx,
    1294                                                    false /* aNotify */);
     1286                                                   uTrgParentIdx);
    12951287                        srcLock.acquire();
    12961288                        if (FAILED(rc)) throw rc;
    … …  
    13261318                         * chain. */
    13271319                        pNewParent = pTarget;
    1328                         uIdsForNotify[pTarget->i_getId()] = pTarget->i_getDeviceType();
    13291320                    }
    13301321                }
    … …  
    13651356                    /* diff image has to be used... */
    13661357                    pNewParent = pDiff;
    1367                     pMediumsForNotify.insert(pDiff->i_getParent());
    1368                     uIdsForNotify[pDiff->i_getId()] = pDiff->i_getDeviceType();
    13691358                }
    13701359                else
    … …  
    15451534            const ComObjPtr<Medium> &pMedium = newMedia.at(i - 1);
    15461535            mrc = pMedium->i_deleteStorage(NULL /* aProgress */,
    1547                                            true /* aWait */,
    1548                                            false /* aNotify */);
     1536                                           true /* aWait */);
    15491537            pMedium->Close();
    15501538        }
    … …  
    15581546        p->mParent->i_saveModifiedRegistries();
    15591547    }
    1560     else
    1561     {
    1562         for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
    1563              it != uIdsForNotify.end();
    1564              ++it)
    1565         {
    1566             p->mParent->i_onMediumRegistered(it->first, it->second, TRUE);
    1567         }
    1568         for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
    1569              it != pMediumsForNotify.end();
    1570              ++it)
    1571         {
    1572             if (it->isNotNull())
    1573                 p->mParent->i_onMediumConfigChanged(*it);
    1574         }
    1575     }
    15761548
    15771549    return mrc;

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

    r76239 r76240  
    4646#include <algorithm>
    4747#include <list>
    48 #include <set>
    49 #include <map>
    5048
    5149
    … …  
    224222{
    225223public:
    226     Task(Medium *aMedium, Progress *aProgress, bool fNotifyAboutChanges = true)
     224    Task(Medium *aMedium, Progress *aProgress)
    227225        : ThreadTask("Medium::Task"),
    228226          mVDOperationIfaces(NULL),
    … …  
    230228          mMediumCaller(aMedium),
    231229          mProgress(aProgress),
    232           mVirtualBoxCaller(NULL),
    233           mNotifyAboutChanges(fNotifyAboutChanges)
     230          mVirtualBoxCaller(NULL)
    234231    {
    235232        AssertReturnVoidStmt(aMedium, mRC = E_FAIL);
    … …  
    274271    HRESULT rc() const { return mRC; }
    275272    bool isOk() const { return SUCCEEDED(rc()); }
    276     bool NotifyAboutChanges() const { return mNotifyAboutChanges; }
    277273
    278274    const ComPtr<Progress>& GetProgressObject() const {return mProgress;}
    … …  
    335331    ComObjPtr<VirtualBox> mVirtualBox;
    336332    AutoCaller mVirtualBoxCaller;
    337     bool mNotifyAboutChanges;
    338333};
    339334
    … …  
    349344                   Progress *aProgress,
    350345                   uint64_t aSize,
    351                    MediumVariant_T aVariant,
    352                    bool fNotifyAboutChanges = true)
    353         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     346                   MediumVariant_T aVariant)
     347        : Medium::Task(aMedium, aProgress),
    354348          mSize(aSize),
    355349          mVariant(aVariant)
    … …  
    373367                   MediumVariant_T aVariant,
    374368                   MediumLockList *aMediumLockList,
    375                    bool fKeepMediumLockList = false,
    376                    bool fNotifyAboutChanges = true)
    377         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     369                   bool fKeepMediumLockList = false)
     370        : Medium::Task(aMedium, aProgress),
    378371          mpMediumLockList(aMediumLockList),
    379372          mTarget(aTarget),
    … …  
    419412              MediumLockList *aTargetMediumLockList,
    420413              bool fKeepSourceMediumLockList = false,
    421               bool fKeepTargetMediumLockList = false,
    422               bool fNotifyAboutChanges = true)
    423         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     414              bool fKeepTargetMediumLockList = false)
     415        : Medium::Task(aMedium, aProgress),
    424416          mTarget(aTarget),
    425417          mParent(aParent),
    … …  
    478470              MediumVariant_T aVariant,
    479471              MediumLockList *aMediumLockList,
    480               bool fKeepMediumLockList = false,
    481               bool fNotifyAboutChanges = true)
    482         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     472              bool fKeepMediumLockList = false)
     473        : Medium::Task(aMedium, aProgress),
    483474          mpMediumLockList(aMediumLockList),
    484475          mVariant(aVariant),
    … …  
    509500                Progress *aProgress,
    510501                MediumLockList *aMediumLockList,
    511                 bool fKeepMediumLockList = false,
    512                 bool fNotifyAboutChanges = true)
    513         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     502                bool fKeepMediumLockList = false)
     503        : Medium::Task(aMedium, aProgress),
    514504          mpMediumLockList(aMediumLockList),
    515505          mfKeepMediumLockList(fKeepMediumLockList)
    … …  
    539529               Progress *aProgress,
    540530               MediumLockList *aMediumLockList,
    541                bool fKeepMediumLockList = false,
    542                bool fNotifyAboutChanges = true)
    543         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     531               bool fKeepMediumLockList = false)
     532        : Medium::Task(aMedium, aProgress),
    544533          mSize(aSize),
    545534          mpMediumLockList(aMediumLockList),
    … …  
    570559              Progress *aProgress,
    571560              MediumLockList *aMediumLockList,
    572               bool fKeepMediumLockList = false,
    573               bool fNotifyAboutChanges = true)
    574         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     561              bool fKeepMediumLockList = false)
     562        : Medium::Task(aMedium, aProgress),
    575563          mpMediumLockList(aMediumLockList),
    576564          mfKeepMediumLockList(fKeepMediumLockList)
    … …  
    598586               Progress *aProgress,
    599587               MediumLockList *aMediumLockList,
    600                bool fKeepMediumLockList = false,
    601                bool fNotifyAboutChanges = true)
    602         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     588               bool fKeepMediumLockList = false)
     589        : Medium::Task(aMedium, aProgress),
    603590          mpMediumLockList(aMediumLockList),
    604591          mfKeepMediumLockList(fKeepMediumLockList)
    … …  
    630617              Progress *aProgress,
    631618              MediumLockList *aMediumLockList,
    632               bool fKeepMediumLockList = false,
    633               bool fNotifyAboutChanges = true)
    634         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     619              bool fKeepMediumLockList = false)
     620        : Medium::Task(aMedium, aProgress),
    635621          mTarget(aTarget),
    636622          mfMergeForward(fMergeForward),
    … …  
    680666               Medium *aParent,
    681667               MediumLockList *aTargetMediumLockList,
    682                bool fKeepTargetMediumLockList = false,
    683                bool fNotifyAboutChanges = true)
    684         : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
     668               bool fKeepTargetMediumLockList = false)
     669        : Medium::Task(aMedium, aProgress),
    685670          mFilename(aFilename),
    686671          mFormat(aFormat),
    … …  
    745730                Progress *aProgress,
    746731                MediumLockList *aMediumLockList)
    747         : Medium::Task(aMedium, aProgress, false),
     732        : Medium::Task(aMedium, aProgress),
    748733          mstrNewPassword(strNewPassword),
    749734          mstrCurrentPassword(strCurrentPassword),
    … …  
    16591644        i_markRegistriesModified();
    16601645        m->pVirtualBox->i_saveModifiedRegistries();
    1661         m->pVirtualBox->i_onMediumConfigChanged(this);
    16621646    }
    16631647    catch (HRESULT aRC) { rc = aRC; }
    … …  
    18951879    i_markRegistriesModified();
    18961880    m->pVirtualBox->i_saveModifiedRegistries();
    1897     m->pVirtualBox->i_onMediumConfigChanged(this);
    18981881
    18991882    return S_OK;
    … …  
    20071990        i_markRegistriesModified();
    20081991        m->pVirtualBox->i_saveModifiedRegistries();
    2009         m->pVirtualBox->i_onMediumConfigChanged(this);
    20101992    }
    20111993
    … …  
    20742056    }
    20752057
    2076     const Guid uPrevImage = m->uuidImage;
    20772058    unconst(m->uuidImage) = imageId;
    2078     ComObjPtr<Medium> pPrevParent = i_getParent();
    20792059    unconst(m->uuidParentImage) = parentId;
    20802060
    … …  
    20852065                             !!aSetParentId /* fSetParentId */,
    20862066                             autoCaller);
    2087 
    2088     AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
    2089     const Guid uCurrImage = m->uuidImage;
    2090     ComObjPtr<Medium> pCurrParent = i_getParent();
    2091     arlock.release();
    2092 
    2093     if (SUCCEEDED(rc))
    2094     {
    2095         if (uCurrImage != uPrevImage)
    2096             m->pVirtualBox->i_onMediumConfigChanged(this);
    2097         if (pPrevParent != pCurrParent)
    2098         {
    2099             m->pVirtualBox->i_onMediumConfigChanged(pPrevParent);
    2100             m->pVirtualBox->i_onMediumConfigChanged(pCurrParent);
    2101         }
    2102     }
    21032067
    21042068    return rc;
    … …  
    23942358    ComObjPtr<VirtualBox> pVirtualBox(m->pVirtualBox);
    23952359
    2396     Guid uId = i_getId();
    2397     DeviceType_T devType = i_getDeviceType();
    2398     bool wasCreated = m->state != MediumState_NotCreated;
    23992360    MultiResult mrc = i_close(aAutoCaller);
    24002361
    24012362    pVirtualBox->i_saveModifiedRegistries();
    2402 
    2403     if (SUCCEEDED(mrc) && wasCreated)
    2404         pVirtualBox->i_onMediumRegistered(uId, devType, FALSE);
    24052363
    24062364    return mrc;
    … …  
    24722430    i_markRegistriesModified();
    24732431    m->pVirtualBox->i_saveModifiedRegistries();
    2474     m->pVirtualBox->i_onMediumConfigChanged(this);
    24752432
    24762433    return S_OK;
    … …  
    25522509    i_markRegistriesModified();
    25532510    m->pVirtualBox->i_saveModifiedRegistries();
    2554     m->pVirtualBox->i_onMediumConfigChanged(this);
    25552511
    25562512    return S_OK;
    25572513}
    2558 
    25592514HRESULT Medium::createBaseStorage(LONG64 aLogicalSize,
    25602515                                  const std::vector<MediumVariant_T> &aVariant,
    … …  
    26422597
    26432598    MultiResult mrc = i_deleteStorage(&pProgress,
    2644                                       false /* aWait */,
    2645                                       true /* aNotify */);
     2599                                      false /* aWait */);
    26462600    /* Must save the registries in any case, since an entry was removed. */
    26472601    m->pVirtualBox->i_saveModifiedRegistries();
    … …  
    27622716
    27632717    rc = i_createDiffStorage(diff, (MediumVariant_T)mediumVariantFlags, pMediumLockList,
    2764                              &pProgress, false /* aWait */, true /* aNotify */);
     2718                             &pProgress, false /* aWait */);
    27652719    if (FAILED(rc))
    27662720        delete pMediumLockList;
    … …  
    27942748
    27952749    rc = i_mergeTo(pTarget, fMergeForward, pParentForTarget, pChildrenToReparent,
    2796                    pMediumLockList, &pProgress, false /* aWait */, true /* aNotify */);
     2750                   pMediumLockList, &pProgress, false /* aWait */);
    27972751    if (FAILED(rc))
    27982752        i_cancelMergeTo(pChildrenToReparent, pMediumLockList);
    … …  
    33453299        MediumState_T mediumState;
    33463300        refreshState(autoCaller, &mediumState);
    3347         m->pVirtualBox->i_onMediumConfigChanged(this);
    33483301    }
    33493302    catch (HRESULT aRC) { rc = aRC; }
    … …  
    34733426
    34743427    if (SUCCEEDED(rc))
    3475         rc = i_resize(aLogicalSize, pMediumLockList, &pProgress, false /* aWait */, true /* aNotify */);
     3428        rc = i_resize(aLogicalSize, pMediumLockList, &pProgress, false /* aWait */);
    34763429
    34773430    if (SUCCEEDED(rc))
    … …  
    45264479        unconst(m->strLocationFull) = newPath;
    45274480
    4528         m->pVirtualBox->i_onMediumConfigChanged(this);
    4529 
    45304481        LogFlowThisFunc(("locationFull.after='%s'\n", m->strLocationFull.c_str()));
    45314482        // we changed something
    … …  
    46744625
    46754626/**
    4676  * Internal method to update the medium's id. Must have caller + locking!
     4627 * Internal method to return the medium's size. Must have caller + locking!
    46774628 * @return
    46784629 */
    … …  
    49204871 * @param aWait             @c true if this method should block instead of
    49214872 *                          creating an asynchronous thread.
    4922  * @param aNotify           Notify about mediums which metadatа are changed
    4923  *                          during execution of the function.
    49244873 *
    49254874 * @note Locks this object and @a aTarget for writing.
    … …  
    49294878                                    MediumLockList *aMediumLockList,
    49304879                                    ComObjPtr<Progress> *aProgress,
    4931                                     bool aWait,
    4932                                     bool aNotify)
     4880                                    bool aWait)
    49334881{
    49344882    AssertReturn(!aTarget.isNull(), E_FAIL);
    … …  
    50054953        pTask = new Medium::CreateDiffTask(this, pProgress, aTarget, aVariant,
    50064954                                           aMediumLockList,
    5007                                            aWait /* fKeepMediumLockList */,
    5008                                            aNotify);
     4955                                           aWait /* fKeepMediumLockList */);
    50094956        rc = pTask->rc();
    50104957        AssertComRC(rc);
    … …  
    51865133 * @param aWait         @c true if this method should block instead of creating
    51875134 *                      an asynchronous thread.
    5188  * @param aNotify       Notify about mediums which metadatа are changed
    5189  *                      during execution of the function.
    51905135 *
    51915136 * @note Locks mVirtualBox and this object for writing. Locks medium tree for
    … …  
    51935138 */
    51945139HRESULT Medium::i_deleteStorage(ComObjPtr<Progress> *aProgress,
    5195                               bool aWait, bool aNotify)
     5140                              bool aWait)
    51965141{
    51975142    AssertReturn(aProgress != NULL || aWait == true, E_FAIL);
    … …  
    53645309
    53655310        /* setup task object to carry out the operation sync/async */
    5366         pTask = new Medium::DeleteTask(this, pProgress, pMediumLockList, false, aNotify);
     5311        pTask = new Medium::DeleteTask(this, pProgress, pMediumLockList);
    53675312        rc = pTask->rc();
    53685313        AssertComRC(rc);
    … …  
    60095954 * @param aWait         @c true if this method should block instead of creating
    60105955 *                      an asynchronous thread.
    6011  * @param aNotify       Notify about mediums which metadatа are changed
    6012  *                      during execution of the function.
    60135956 *
    60145957 * @note Locks the tree lock for writing. Locks the media from the chain
    … …  
    60215964                          MediumLockList *aMediumLockList,
    60225965                          ComObjPtr<Progress> *aProgress,
    6023                           bool aWait, bool aNotify)
     5966                          bool aWait)
    60245967{
    60255968    AssertReturn(pTarget != NULL, E_FAIL);
    … …  
    60766019                                      pParentForTarget, aChildrenToReparent,
    60776020                                      pProgress, aMediumLockList,
    6078                                       aWait /* fKeepMediumLockList */,
    6079                                       aNotify);
     6021                                      aWait /* fKeepMediumLockList */);
    60806022        rc = pTask->rc();
    60816023        AssertComRC(rc);
    … …  
    61926134 * @param aWait         @c true if this method should block instead of creating
    61936135 *                      an asynchronous thread.
    6194  * @param aNotify       Notify about mediums which metadatа are changed
    6195  *                      during execution of the function.
    61966136 *
    61976137 * @note Locks the media from the chain for writing.
    … …  
    62016141                         MediumLockList *aMediumLockList,
    62026142                         ComObjPtr<Progress> *aProgress,
    6203                          bool aWait,
    6204                          bool aNotify)
     6143                         bool aWait)
    62056144{
    62066145    AssertReturn(aMediumLockList != NULL, E_FAIL);
    … …  
    62416180                                       pProgress,
    62426181                                       aMediumLockList,
    6243                                        aWait /* fKeepMediumLockList */,
    6244                                        aNotify);
     6182                                       aWait /* fKeepMediumLockList */);
    62456183        rc = pTask->rc();
    62466184        AssertComRC(rc);
    … …  
    65456483 * @param aParent               Parent medium. May be NULL.
    65466484 * @param aProgress             Progress object to use.
    6547  * @param aNotify               Notify about mediums which metadatа are changed
    6548  *                              during execution of the function.
    65496485 * @return
    65506486 * @note The destination format is defined by the Medium instance.
    … …  
    65606496                             RTVFSIOSTREAM aVfsIosSrc,
    65616497                             const ComObjPtr<Medium> &aParent,
    6562                              const ComObjPtr<Progress> &aProgress,
    6563                              bool aNotify)
     6498                             const ComObjPtr<Progress> &aProgress)
    65646499{
    65656500    /** @todo r=klaus The code below needs to be double checked with regard
    … …  
    66226557        /* setup task object to carry out the operation asynchronously */
    66236558        pTask = new Medium::ImportTask(this, aProgress, aFilename, aFormat, aVariant,
    6624                                        aVfsIosSrc, aParent, pTargetMediumLockList, false, aNotify);
     6559                                       aVfsIosSrc, aParent, pTargetMediumLockList);
    66256560        rc = pTask->rc();
    66266561        AssertComRC(rc);
    … …  
    66566591 *                           same content as the given image in the source chain.
    66576592 *                           Use UINT32_MAX to disable this optimization.
    6658  * @param aNotify            Notify about mediums which metadatа are changed
    6659  *                           during execution of the function.
    66606593 * @return
    66616594 */
    66626595HRESULT Medium::i_cloneToEx(const ComObjPtr<Medium> &aTarget, MediumVariant_T aVariant,
    66636596                            const ComObjPtr<Medium> &aParent, IProgress **aProgress,
    6664                             uint32_t idxSrcImageSame, uint32_t idxDstImageSame, bool aNotify)
     6597                            uint32_t idxSrcImageSame, uint32_t idxDstImageSame)
    66656598{
    66666599    /** @todo r=klaus The code below needs to be double checked with regard
    … …  
    67676700                                      aParent, idxSrcImageSame,
    67686701                                      idxDstImageSame, pSourceMediumLockList,
    6769                                       pTargetMediumLockList, false, false, aNotify);
     6702                                      pTargetMediumLockList);
    67706703        rc = pTask->rc();
    67716704        AssertComRC(rc);
    … …  
    73677300    pToken.setNull();
    73687301
    7369     if (FAILED(rc))
    7370         return rc;
     7302    if (FAILED(rc)) return rc;
    73717303
    73727304    /* If this is a base image which incorrectly has a parent UUID set,
    … …  
    73767308     * with a diff image before the base is registered this would destroy
    73777309     * the diff. Not acceptable. */
    7378     do
    7379     {
    7380         if (fRepairImageZeroParentUuid)
    7381         {
    7382             rc = LockWrite(pToken.asOutParam());
    7383             if (FAILED(rc))
    7384                 break;
    7385 
    7386             alock.release();
     7310    if (fRepairImageZeroParentUuid)
     7311    {
     7312        rc = LockWrite(pToken.asOutParam());
     7313        if (FAILED(rc)) return rc;
     7314
     7315        alock.release();
     7316
     7317        try
     7318        {
     7319            PVDISK hdd;
     7320            vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
     7321            ComAssertRCThrow(vrc, E_FAIL);
    73877322
    73887323            try
    73897324            {
    7390                 PVDISK hdd;
    7391                 vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
     7325                vrc = VDOpen(hdd,
     7326                             format.c_str(),
     7327                             location.c_str(),
     7328                             (uOpenFlags & ~VD_OPEN_FLAGS_READONLY) | m->uOpenFlagsDef,
     7329                             m->vdImageIfaces);
     7330                if (RT_FAILURE(vrc))
     7331                    throw S_OK;
     7332
     7333                RTUUID zeroParentUuid;
     7334                RTUuidClear(&zeroParentUuid);
     7335                vrc = VDSetParentUuid(hdd, 0, &zeroParentUuid);
    73927336                ComAssertRCThrow(vrc, E_FAIL);
    7393 
    7394                 try
    7395                 {
    7396                     vrc = VDOpen(hdd,
    7397                                  format.c_str(),
    7398                                  location.c_str(),
    7399                                  (uOpenFlags & ~VD_OPEN_FLAGS_READONLY) | m->uOpenFlagsDef,
    7400                                  m->vdImageIfaces);
    7401                     if (RT_FAILURE(vrc))
    7402                         throw S_OK;
    7403 
    7404                     RTUUID zeroParentUuid;
    7405                     RTUuidClear(&zeroParentUuid);
    7406                     vrc = VDSetParentUuid(hdd, 0, &zeroParentUuid);
    7407                     ComAssertRCThrow(vrc, E_FAIL);
    7408                 }
    7409                 catch (HRESULT aRC)
    7410                 {
    7411                     rc = aRC;
    7412                 }
    7413 
    7414                 VDDestroy(hdd);
    74157337            }
    74167338            catch (HRESULT aRC)
    … …  
    74197341            }
    74207342
    7421             pToken->Abandon();
    7422             pToken.setNull();
    7423             if (FAILED(rc))
    7424                 break;
    7425         }
    7426     } while(0);
     7343            VDDestroy(hdd);
     7344        }
     7345        catch (HRESULT aRC)
     7346        {
     7347            rc = aRC;
     7348        }
     7349
     7350        pToken->Abandon();
     7351        pToken.setNull();
     7352        if (FAILED(rc)) return rc;
     7353    }
    74277354
    74287355    return rc;
    … …  
    85668493            m->pVirtualBox->i_saveModifiedRegistries();
    85678494        }
    8568         if (task.NotifyAboutChanges())
    8569             m->pVirtualBox->i_onMediumRegistered(m->id, m->devType, TRUE);
    85708495    }
    85718496    else
    … …  
    88038728     * unlock the medium. */
    88048729
    8805     if (task.NotifyAboutChanges() && SUCCEEDED(mrc))
    8806     {
    8807         m->pVirtualBox->i_onMediumRegistered(pTarget->i_getId(), pTarget->i_getDeviceType(), TRUE);
    8808         m->pVirtualBox->i_onMediumConfigChanged(this);
    8809     }
    8810 
    88118730    return mrc;
    88128731}
    … …  
    89018820
    89028821                ComObjPtr<Progress> pProgress(task.GetProgressObject());
    8903                 rc = pTarget->i_resize(sourceSize, pMediumLockListForResize, &pProgress, true, false);
     8822                rc = pTarget->i_resize(sourceSize, pMediumLockListForResize, &pProgress, true);
    89048823                if (FAILED(rc))
    89058824                {
    … …  
    90678986    HRESULT rc2;
    90688987
    9069     std::set<ComObjPtr<Medium> > pMediumsForNotify;
    9070     std::map<Guid, DeviceType_T> uIdsForNotify;
    9071 
    90728988    if (SUCCEEDED(mrc))
    90738989    {
    … …  
    90899005            pTarget->i_setParent(task.mParentForTarget);
    90909006            if (task.mParentForTarget)
    9091             {
    90929007                i_deparent();
    9093                 if (task.NotifyAboutChanges())
    9094                     pMediumsForNotify.insert(task.mParentForTarget);
    9095             }
    90969008
    90979009            /* then, register again */
    … …  
    91289040                    // no depth check, reduces depth
    91299041                    pMedium->i_setParent(pTarget);
    9130 
    9131                     if (task.NotifyAboutChanges())
    9132                         pMediumsForNotify.insert(pMedium);
    91339042                }
    91349043            }
    9135             pMediumsForNotify.insert(pTarget);
    91369044        }
    91379045
    … …  
    91589066            }
    91599067
    9160             uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
    91619068            rc2 = pMedium->m->pVirtualBox->i_unregisterMedium(pMedium);
    91629069            AssertComRC(rc2);
    … …  
    92199126        if (task.isAsync())
    92209127            i_cancelMergeTo(task.mpChildrenToReparent, task.mpMediumLockList);
    9221     }
    9222     else if (task.NotifyAboutChanges())
    9223     {
    9224         for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
    9225              it != pMediumsForNotify.end();
    9226              ++it)
    9227         {
    9228             if (it->isNotNull())
    9229                 m->pVirtualBox->i_onMediumConfigChanged(*it);
    9230         }
    9231         for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
    9232              it != uIdsForNotify.end();
    9233              ++it)
    9234         {
    9235             m->pVirtualBox->i_onMediumRegistered(it->first, it->second, FALSE);
    9236         }
    92379128    }
    92389129
    … …  
    95559446                m->pVirtualBox->i_saveModifiedRegistries();
    95569447                eik.fetch();
    9557 
    9558                 if (task.NotifyAboutChanges())
    9559                 {
    9560                     if (!fCreatingTarget)
    9561                     {
    9562                         if (!aFilterPropNames.empty())
    9563                             m->pVirtualBox->i_onMediumConfigChanged(pTargetBase);
    9564                         m->pVirtualBox->i_onMediumConfigChanged(pParent);
    9565                     }
    9566                     else
    9567                     {
    9568                         m->pVirtualBox->i_onMediumRegistered(pTarget->i_getId(), pTarget->i_getDeviceType(), TRUE);
    9569                     }
    9570                 }
    95719448            }
    95729449        }
    … …  
    97449621    task.mpMediumLockList->Clear();
    97459622
    9746     if (task.NotifyAboutChanges() && SUCCEEDED(mrc))
    9747         m->pVirtualBox->i_onMediumConfigChanged(this);
    97489623    return mrc;
    97499624}
    … …  
    98139688    /* Reset UUID to prevent Create* from reusing it again */
    98149689    unconst(m->id).clear();
    9815 
    9816     if (task.NotifyAboutChanges() && SUCCEEDED(rc) && m->pParent.isNotNull())
    9817         m->pVirtualBox->i_onMediumConfigChanged(m->pParent);
    98189690
    98199691    return rc;
    … …  
    99599831    m->logicalSize = logicalSize;
    99609832    m->variant = variant;
    9961 
    9962     if (task.NotifyAboutChanges() && SUCCEEDED(rc))
    9963         m->pVirtualBox->i_onMediumConfigChanged(this);
    99649833
    99659834    /* Everything is explicitly unlocked when the task exits,
    … …  
    100599928    }
    100609929    catch (HRESULT aRC) { rc = aRC; }
    10061 
    10062     if (task.NotifyAboutChanges() && SUCCEEDED(rc))
    10063         m->pVirtualBox->i_onMediumConfigChanged(this);
    100649930
    100659931    /* Everything is explicitly unlocked when the task exits,
    … …  
    1017810044        m->size = size;
    1017910045        m->logicalSize = logicalSize;
    10180 
    10181         if (task.NotifyAboutChanges())
    10182             m->pVirtualBox->i_onMediumConfigChanged(this);
    1018310046    }
    1018410047
    … …  
    1044910312    task.mpTargetMediumLockList->Clear();
    1045010313
    10451     if (task.NotifyAboutChanges() && SUCCEEDED(mrc))
    10452     {
    10453         if (pParent)
    10454             m->pVirtualBox->i_onMediumConfigChanged(pParent);
    10455         if (fCreatingTarget)
    10456             m->pVirtualBox->i_onMediumConfigChanged(this);
    10457         else
    10458             m->pVirtualBox->i_onMediumRegistered(m->id, m->devType, TRUE);
    10459     }
    10460 
    1046110314    return mrc;
    1046210315}

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

    r76239 r76240  
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1616 */
    17 
    18 #include <set>
    19 #include <map>
    2017
    2118#include "Logging.h"
    … …  
    16401637    BOOL fSuspendedBySave     = FALSE;
    16411638
    1642     std::set<ComObjPtr<Medium> > pMediumsForNotify;
    1643     std::map<Guid, DeviceType_T> uIdsForNotify;
    1644 
    16451639    try
    16461640    {
    … …  
    17791773            if (FAILED(rc))
    17801774                throw rc;
    1781         }
    1782 
    1783         // store parent of newly created diffs before commit for notify
    1784         {
    1785             MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
    1786             for (MediumAttachmentList::const_iterator
    1787                  it = mMediumAttachments->begin();
    1788                  it != mMediumAttachments->end();
    1789                  ++it)
    1790             {
    1791                 MediumAttachment *pAttach = *it;
    1792                 Medium *pMedium = pAttach->i_getMedium();
    1793                 if (!pMedium)
    1794                     continue;
    1795 
    1796                 bool fFound = false;
    1797                 /* was this medium attached before? */
    1798                 for (MediumAttachmentList::iterator
    1799                      oldIt = oldAtts.begin();
    1800                      oldIt != oldAtts.end();
    1801                      ++oldIt)
    1802                 {
    1803                     MediumAttachment *pOldAttach = *oldIt;
    1804                     if (pOldAttach->i_getMedium() == pMedium)
    1805                     {
    1806                         fFound = true;
    1807                         break;
    1808                     }
    1809                 }
    1810                 if (!fFound)
    1811                 {
    1812                     pMediumsForNotify.insert(pMedium->i_getParent());
    1813                     uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
    1814                 }
    1815             }
    18161775        }
    18171776
    … …  
    19171876    if (SUCCEEDED(rc))
    19181877        mParent->i_onSnapshotTaken(mData->mUuid, task.m_uuidSnapshot);
    1919 
    1920     if (SUCCEEDED(rc))
    1921     {
    1922         for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
    1923              it != uIdsForNotify.end();
    1924              ++it)
    1925         {
    1926             mParent->i_onMediumRegistered(it->first, it->second, TRUE);
    1927         }
    1928 
    1929         for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
    1930              it != pMediumsForNotify.end();
    1931              ++it)
    1932         {
    1933             if (it->isNotNull())
    1934                 mParent->i_onMediumConfigChanged(*it);
    1935         }
    1936     }
    19371878    LogFlowThisFuncLeave();
    19381879}
    … …  
    21792120    HRESULT rc = S_OK;
    21802121    Guid snapshotId;
    2181     std::set<ComObjPtr<Medium> > pMediumsForNotify;
    2182     std::map<Guid, DeviceType_T> uIdsForNotify;
    21832122
    21842123    try
    … …  
    22752214            /* make the snapshot we restored from the current snapshot */
    22762215            mData->mCurrentSnapshot = task.m_pSnapshot;
    2277         }
    2278 
    2279         // store parent of newly created diffs for notify
    2280         {
    2281             MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
    2282             for (MediumAttachmentList::const_iterator
    2283                  it = mMediumAttachments->begin();
    2284                  it != mMediumAttachments->end();
    2285                  ++it)
    2286             {
    2287                 MediumAttachment *pAttach = *it;
    2288                 Medium *pMedium = pAttach->i_getMedium();
    2289                 if (!pMedium)
    2290                     continue;
    2291 
    2292                 bool fFound = false;
    2293                 /* was this medium attached before? */
    2294                 for (MediumAttachmentList::iterator
    2295                      oldIt = oldAtts.begin();
    2296                      oldIt != oldAtts.end();
    2297                      ++oldIt)
    2298                 {
    2299                     MediumAttachment *pOldAttach = *oldIt;
    2300                     if (pOldAttach->i_getMedium() == pMedium)
    2301                     {
    2302                         fFound = true;
    2303                         break;
    2304                     }
    2305                 }
    2306                 if (!fFound)
    2307                 {
    2308                     pMediumsForNotify.insert(pMedium->i_getParent());
    2309                     uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
    2310                 }
    2311             }
    23122216        }
    23132217
    … …  
    24102314            LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->i_getName().c_str()));
    24112315
    2412             ComObjPtr<Medium> pParent = pMedium->i_getParent();
    24132316            HRESULT rc2 = pMedium->i_deleteStorage(NULL /* aProgress */,
    2414                                                    true /* aWait */,
    2415                                                    false /* aNotify */);
     2317                                                   true /* aWait */);
    24162318            // ignore errors here because we cannot roll back after i_saveSettings() above
    24172319            if (SUCCEEDED(rc2))
    2418             {
    2419                 pMediumsForNotify.insert(pParent);
    24202320                pMedium->uninit();
    2421             }
    24222321        }
    24232322    }
    … …  
    24462345
    24472346    if (SUCCEEDED(rc))
    2448     {
    24492347        mParent->i_onSnapshotRestored(mData->mUuid, snapshotId);
    2450         for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
    2451              it != uIdsForNotify.end();
    2452              ++it)
    2453         {
    2454             mParent->i_onMediumRegistered(it->first, it->second, TRUE);
    2455         }
    2456         for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
    2457              it != pMediumsForNotify.end();
    2458              ++it)
    2459         {
    2460             if (it->isNotNull())
    2461                 mParent->i_onMediumConfigChanged(*it);
    2462         }
    2463     }
    24642348
    24652349    LogFlowThisFunc(("Done restoring snapshot (rc=%08X)\n", rc));
    … …  
    28122696    MediumDeleteRecList toDelete;
    28132697    Guid snapshotId;
    2814     std::set<ComObjPtr<Medium> > pMediumsForNotify;
    2815     std::map<Guid,DeviceType_T> uIdsForNotify;
    28162698
    28172699    try
    … …  
    31883070                    /* No need to hold the lock any longer. */
    31893071                    mLock.release();
    3190                     ComObjPtr<Medium> pParent = pMedium->i_getParent();
    3191                     Guid uMedium = pMedium->i_getId();
    3192                     DeviceType_T uMediumType = pMedium->i_getDeviceType();
    31933072                    rc = pMedium->i_deleteStorage(&task.m_pProgress,
    3194                                                   true /* aWait */,
    3195                                                   false /* aNotify */);
     3073                                                  true /* aWait */);
    31963074                    if (FAILED(rc))
    31973075                        throw rc;
    3198 
    3199                     pMediumsForNotify.insert(pParent);
    3200                     uIdsForNotify[uMedium] = uMediumType;
    32013076
    32023077                    // need to uninit the deleted medium
    … …  
    32063081            else
    32073082            {
    3208                 {
    3209                     //store ids before merging for notify
    3210                     pMediumsForNotify.insert(it->mpTarget);
    3211                     if (it->mfMergeForward)
    3212                         pMediumsForNotify.insert(it->mpSource->i_getParent());
    3213                     else
    3214                     {
    3215                         //children which will be reparented to target
    3216                         for (MediaList::const_iterator iit = it->mpSource->i_getChildren().begin();
    3217                              iit != it->mpSource->i_getChildren().end();
    3218                              ++iit)
    3219                         {
    3220                             pMediumsForNotify.insert(*iit);
    3221                         }
    3222                     }
    3223                     if (it->mfMergeForward)
    3224                     {
    3225                         for (ComObjPtr<Medium> pTmpMedium = it->mpTarget->i_getParent();
    3226                              pTmpMedium != it->mpSource;
    3227                              pTmpMedium = pTmpMedium->i_getParent())
    3228                         {
    3229                             uIdsForNotify[pTmpMedium->i_getId()] = pTmpMedium->i_getDeviceType();
    3230                         }
    3231                         uIdsForNotify[it->mpSource->i_getId()] = it->mpSource->i_getDeviceType();
    3232                     }
    3233                     else
    3234                     {
    3235                         for (ComObjPtr<Medium> pTmpMedium = it->mpSource->i_getParent();
    3236                              pTmpMedium != it->mpTarget;
    3237                              pTmpMedium = pTmpMedium->i_getParent())
    3238                         {
    3239                             uIdsForNotify[pTmpMedium->i_getId()] = pTmpMedium->i_getDeviceType();
    3240                         }
    3241                     }
    3242                 }
    3243 
    32443083                bool fNeedsSave = false;
    32453084                if (it->mfNeedsOnlineMerge)
    … …  
    32723111                                                 it->mpMediumLockList,
    32733112                                                 &task.m_pProgress,
    3274                                                  true /* aWait */,
    3275                                                  false /* aNotify */);
     3113                                                 true /* aWait */);
    32763114                }
    32773115
    … …  
    34403278
    34413279    if (SUCCEEDED(mrc))
    3442     {
    34433280        mParent->i_onSnapshotDeleted(mData->mUuid, snapshotId);
    3444         for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
    3445              it != uIdsForNotify.end();
    3446              ++it)
    3447         {
    3448             mParent->i_onMediumRegistered(it->first, it->second, FALSE);
    3449         }
    3450         for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
    3451              it != pMediumsForNotify.end();
    3452              ++it)
    3453         {
    3454             if (it->isNotNull())
    3455                 mParent->i_onMediumConfigChanged(*it);
    3456         }
    3457     }
    34583281
    34593282    LogFlowThisFunc(("Done deleting snapshot (rc=%08X)\n", (HRESULT)mrc));

  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r76215 r76240  
    19631963
    19641964    if (SUCCEEDED(rc))
    1965     {
    19661965        medium.queryInterfaceTo(aMedium.asOutParam());
    1967         i_onMediumRegistered(medium->i_getId(), medium->i_getDeviceType(), TRUE);
    1968     }
    19691966
    19701967    return rc;
    … …  
    20172014    }
    20182015
    2019     bool fMediumRegistered = false;
    20202016    if (pMedium.isNull())
    20212017    {
    … …  
    20442040                rc = VBOX_E_OBJECT_NOT_FOUND;
    20452041            }
    2046             else
    2047             {
    2048                 fMediumRegistered = true;
    2049             }
    20502042        }
    20512043        else
    … …  
    20572049
    20582050    if (SUCCEEDED(rc))
    2059     {
    20602051        pMedium.queryInterfaceTo(aMedium.asOutParam());
    2061         if (fMediumRegistered)
    2062             i_onMediumRegistered(pMedium->i_getId(), pMedium->i_getDeviceType() ,TRUE);
    2063     }
    20642052
    20652053    return rc;
    … …  
    22642252        if (RT_FAILURE(vrc))
    22652253            fFailure = true;
    2266     }
    2267     if (!fFailure)
    2268     {
    2269         for (MediaList::const_iterator mt = m->allHardDisks.begin();
    2270              mt != m->allHardDisks.end();
    2271              ++mt)
    2272         {
    2273             i_onMediumConfigChanged(*mt);
    2274         }
    22752254    }
    22762255    return fFailure ? VERR_INVALID_PARAMETER : VINF_SUCCESS;
    … …  
    29382917}
    29392918
    2940 
    2941 /** Event for onMediumRegistered() */
    2942 struct MediumRegisteredEvent : public VirtualBox::CallbackEvent
    2943 {
    2944     MediumRegisteredEvent(VirtualBox *aVB, const Guid &aMediumId,
    2945                           const DeviceType_T aDevType, const BOOL aRegistered)
    2946         : CallbackEvent(aVB, VBoxEventType_OnMediumRegistered)
    2947         , mMediumId(aMediumId.toUtf16()), mDevType(aDevType), mRegistered(aRegistered)
    2948     {}
    2949 
    2950     virtual HRESULT prepareEventDesc(IEventSource *aSource, VBoxEventDesc &aEvDesc)
    2951     {
    2952         return aEvDesc.init(aSource, VBoxEventType_OnMediumRegistered, mMediumId.raw(), mDevType, mRegistered);
    2953     }
    2954 
    2955     Bstr mMediumId;
    2956     DeviceType_T mDevType;
    2957     BOOL mRegistered;
    2958 };
    2959 
    2960 /**
    2961  *  @note Doesn't lock any object.
    2962  */
    2963 void VirtualBox::i_onMediumRegistered(const Guid &aMediumId, const DeviceType_T aDevType, const BOOL aRegistered)
    2964 {
    2965     i_postEvent(new MediumRegisteredEvent(this, aMediumId, aDevType, aRegistered));
    2966 }
    2967 
    2968 /** Event for onMediumConfigChanged() */
    2969 struct MediumConfigChangedEvent : public VirtualBox::CallbackEvent
    2970 {
    2971     MediumConfigChangedEvent(VirtualBox *aVB, IMedium *aMedium)
    2972         : CallbackEvent(aVB, VBoxEventType_OnMediumConfigChanged)
    2973         , mMedium(aMedium)
    2974     {}
    2975 
    2976     virtual HRESULT prepareEventDesc(IEventSource *aSource, VBoxEventDesc &aEvDesc)
    2977     {
    2978         return aEvDesc.init(aSource, VBoxEventType_OnMediumConfigChanged, mMedium);
    2979     }
    2980 
    2981     IMedium* mMedium;
    2982 };
    2983 
    2984 void VirtualBox::i_onMediumConfigChanged(IMedium *aMedium)
    2985 {
    2986     i_postEvent(new MediumConfigChangedEvent(this, aMedium));
    2987 }
    2988 
    2989 /** Event for onMediumChanged() */
    2990 struct MediumChangedEvent : public VirtualBox::CallbackEvent
    2991 {
    2992     MediumChangedEvent(VirtualBox *aVB, IMediumAttachment *aMediumAttachment)
    2993         : CallbackEvent(aVB, VBoxEventType_OnMediumChanged)
    2994         , mMediumAttachment(aMediumAttachment)
    2995     {}
    2996 
    2997     virtual HRESULT prepareEventDesc(IEventSource *aSource, VBoxEventDesc &aEvDesc)
    2998     {
    2999         return aEvDesc.init(aSource, VBoxEventType_OnMediumChanged, mMediumAttachment);
    3000     }
    3001 
    3002     IMediumAttachment* mMediumAttachment;
    3003 };
    3004 
    3005 void VirtualBox::i_onMediumChanged(IMediumAttachment *aMediumAttachment)
    3006 {
    3007     i_postEvent(new MediumChangedEvent(this, aMediumAttachment));
    3008 }
    3009 
    3010 /** Event for onStorageDeviceChanged() */
    3011 struct StorageDeviceChangedEvent : public VirtualBox::CallbackEvent
    3012 {
    3013     StorageDeviceChangedEvent(VirtualBox *aVB, IMediumAttachment *aStorageDevice, BOOL fRemoved, BOOL fSilent)
    3014         : CallbackEvent(aVB, VBoxEventType_OnStorageDeviceChanged)
    3015         , mStorageDevice(aStorageDevice)
    3016         , mRemoved(fRemoved)
    3017         , mSilent(fSilent)
    3018     {}
    3019 
    3020     virtual HRESULT prepareEventDesc(IEventSource *aSource, VBoxEventDesc &aEvDesc)
    3021     {
    3022         return aEvDesc.init(aSource, VBoxEventType_OnStorageDeviceChanged, mStorageDevice, mRemoved, mSilent);
    3023     }
    3024 
    3025     IMediumAttachment* mStorageDevice;
    3026     BOOL mRemoved;
    3027     BOOL mSilent;
    3028 };
    3029 
    3030 void VirtualBox::i_onStorageDeviceChanged(IMediumAttachment *aStorageDevice, const BOOL fRemoved, const BOOL fSilent)
    3031 {
    3032     i_postEvent(new StorageDeviceChangedEvent(this, aStorageDevice, fRemoved, fSilent));
    3033 }
    30342919
    30352920/**
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