VirtualBox

Changeset 76215 in vbox for trunk/src/VBox/Main/src-server


Ignore:
Timestamp:
Dec 13, 2018 6:58:16 PM (6 years ago)
Author:
vboxsync
Message:

Main: bugref:6913: Added generation of medium events

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

Legend:

Unmodified
Added
Removed

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

    r74804 r76215  
    26412641                                                     hVfsIosReadAhead,
    26422642                                                     nullParent,
    2643                                                      pProgressImportTmp);
     2643                                                     pProgressImportTmp,
     2644                                                     true /* aNotify */);
    26442645                    RTVfsIoStrmRelease(hVfsIosReadAhead);
    26452646                    hVfsIosSrc = NIL_RTVFSIOSTREAM;

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

    r75817 r76215  
    40374037                                                 pMediumLockList,
    40384038                                                 NULL /* aProgress */,
    4039                                                  true /* aWait */);
     4039                                                 true /* aWait */,
     4040                                                 false /* aNotify */);
    40404041
    40414042                alock.acquire();
    … …  
    41454146    mParent->i_saveModifiedRegistries();
    41464147
     4148    if (aM)
     4149        mParent->i_onMediumConfigChanged(aM);
    41474150    return rc;
    41484151}
    … …  
    1081910822                                              pMediumLockList,
    1082010823                                              NULL /* aProgress */,
    10821                                               true /* aWait */);
     10824                                              true /* aWait */,
     10825                                              false /* aNotify */);
    1082210826            alock.acquire();
    1082310827            if (FAILED(rc)) throw rc;
    … …  
    1105511059                Assert(pMedium);
    1105611060
    11057                 rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/);
     11061                rc = pMedium->i_deleteStorage(NULL /*aProgress*/, true /*aWait*/, false /*aNotify*/);
    1105811062                // continue on delete failure, just collect error messages
    1105911063                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->i_getLogName(),
    … …  
    1122311227
    1122411228        HRESULT rc = oldmedium->i_deleteStorage(NULL /*aProgress*/,
    11225                                                 true /*aWait*/);
     11229                                                true /*aWait*/,
     11230                                                false /*aNotify*/);
    1122611231
    1122711232        writeLock.acquire();
    … …  
    1402314028    }
    1402414029
     14030    mParent->i_onMediumChanged(aAttachment);
     14031
    1402514032    /* ignore notifications sent after #OnSessionEnd() is called */
    1402614033    if (!directControl)
    … …  
    1425914266            directControl = mData->mSession.mDirectControl;
    1426014267    }
     14268
     14269    mParent->i_onStorageDeviceChanged(aAttachment, aRemove, aSilent);
    1426114270
    1426214271    /* ignore notifications sent after #OnSessionEnd() is called */

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

    r74804 r76215  
    1616 */
    1717
     18#include <set>
     19#include <map>
    1820#include "MachineImplCloneVM.h"
    1921
    … …  
    730732                                          pMediumLockList,
    731733                                          NULL /* aProgress */,
    732                                           true /* aWait */);
     734                                          true /* aWait */,
     735                                          false /* aNotify */);
    733736        delete pMediumLockList;
    734737        if (FAILED(rc)) throw rc;
    … …  
    10161019    RTCList<ComObjPtr<Medium> > newMedia;   /* All created images */
    10171020    RTCList<Utf8Str> newFiles;              /* All extra created files (save states, ...) */
     1021    std::set<ComObjPtr<Medium> > pMediumsForNotify;
     1022    std::map<Guid, DeviceType_T> uIdsForNotify;
    10181023    try
    10191024    {
    … …  
    11531158                        /* diff image has to be used... */
    11541159                        pNewParent = pDiff;
     1160                        pMediumsForNotify.insert(pDiff->i_getParent());
     1161                        uIdsForNotify[pDiff->i_getId()] = pDiff->i_getDeviceType();
    11551162                    }
    11561163                    else
    … …  
    12841291                                                   progress2.asOutParam(),
    12851292                                                   uSrcParentIdx,
    1286                                                    uTrgParentIdx);
     1293                                                   uTrgParentIdx,
     1294                                                   false /* aNotify */);
    12871295                        srcLock.acquire();
    12881296                        if (FAILED(rc)) throw rc;
    … …  
    13181326                         * chain. */
    13191327                        pNewParent = pTarget;
     1328                        uIdsForNotify[pTarget->i_getId()] = pTarget->i_getDeviceType();
    13201329                    }
    13211330                }
    … …  
    13561365                    /* diff image has to be used... */
    13571366                    pNewParent = pDiff;
     1367                    pMediumsForNotify.insert(pDiff->i_getParent());
     1368                    uIdsForNotify[pDiff->i_getId()] = pDiff->i_getDeviceType();
    13581369                }
    13591370                else
    … …  
    15341545            const ComObjPtr<Medium> &pMedium = newMedia.at(i - 1);
    15351546            mrc = pMedium->i_deleteStorage(NULL /* aProgress */,
    1536                                            true /* aWait */);
     1547                                           true /* aWait */,
     1548                                           false /* aNotify */);
    15371549            pMedium->Close();
    15381550        }
    … …  
    15461558        p->mParent->i_saveModifiedRegistries();
    15471559    }
     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    }
    15481576
    15491577    return mrc;

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

    r76154 r76215  
    4646#include <algorithm>
    4747#include <list>
     48#include <set>
     49#include <map>
    4850
    4951
    … …  
    222224{
    223225public:
    224     Task(Medium *aMedium, Progress *aProgress)
     226    Task(Medium *aMedium, Progress *aProgress, bool fNotifyAboutChanges = true)
    225227        : ThreadTask("Medium::Task"),
    226228          mVDOperationIfaces(NULL),
    … …  
    228230          mMediumCaller(aMedium),
    229231          mProgress(aProgress),
    230           mVirtualBoxCaller(NULL)
     232          mVirtualBoxCaller(NULL),
     233          mNotifyAboutChanges(fNotifyAboutChanges)
    231234    {
    232235        AssertReturnVoidStmt(aMedium, mRC = E_FAIL);
    … …  
    271274    HRESULT rc() const { return mRC; }
    272275    bool isOk() const { return SUCCEEDED(rc()); }
     276    bool NotifyAboutChanges() const { return mNotifyAboutChanges; }
    273277
    274278    const ComPtr<Progress>& GetProgressObject() const {return mProgress;}
    … …  
    331335    ComObjPtr<VirtualBox> mVirtualBox;
    332336    AutoCaller mVirtualBoxCaller;
     337    bool mNotifyAboutChanges;
    333338};
    334339
    … …  
    344349                   Progress *aProgress,
    345350                   uint64_t aSize,
    346                    MediumVariant_T aVariant)
    347         : Medium::Task(aMedium, aProgress),
     351                   MediumVariant_T aVariant,
     352                   bool fNotifyAboutChanges = true)
     353        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    348354          mSize(aSize),
    349355          mVariant(aVariant)
    … …  
    367373                   MediumVariant_T aVariant,
    368374                   MediumLockList *aMediumLockList,
    369                    bool fKeepMediumLockList = false)
    370         : Medium::Task(aMedium, aProgress),
     375                   bool fKeepMediumLockList = false,
     376                   bool fNotifyAboutChanges = true)
     377        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    371378          mpMediumLockList(aMediumLockList),
    372379          mTarget(aTarget),
    … …  
    412419              MediumLockList *aTargetMediumLockList,
    413420              bool fKeepSourceMediumLockList = false,
    414               bool fKeepTargetMediumLockList = false)
    415         : Medium::Task(aMedium, aProgress),
     421              bool fKeepTargetMediumLockList = false,
     422              bool fNotifyAboutChanges = true)
     423        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    416424          mTarget(aTarget),
    417425          mParent(aParent),
    … …  
    470478              MediumVariant_T aVariant,
    471479              MediumLockList *aMediumLockList,
    472               bool fKeepMediumLockList = false)
    473         : Medium::Task(aMedium, aProgress),
     480              bool fKeepMediumLockList = false,
     481              bool fNotifyAboutChanges = true)
     482        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    474483          mpMediumLockList(aMediumLockList),
    475484          mVariant(aVariant),
    … …  
    500509                Progress *aProgress,
    501510                MediumLockList *aMediumLockList,
    502                 bool fKeepMediumLockList = false)
    503         : Medium::Task(aMedium, aProgress),
     511                bool fKeepMediumLockList = false,
     512                bool fNotifyAboutChanges = true)
     513        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    504514          mpMediumLockList(aMediumLockList),
    505515          mfKeepMediumLockList(fKeepMediumLockList)
    … …  
    529539               Progress *aProgress,
    530540               MediumLockList *aMediumLockList,
    531                bool fKeepMediumLockList = false)
    532         : Medium::Task(aMedium, aProgress),
     541               bool fKeepMediumLockList = false,
     542               bool fNotifyAboutChanges = true)
     543        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    533544          mSize(aSize),
    534545          mpMediumLockList(aMediumLockList),
    … …  
    559570              Progress *aProgress,
    560571              MediumLockList *aMediumLockList,
    561               bool fKeepMediumLockList = false)
    562         : Medium::Task(aMedium, aProgress),
     572              bool fKeepMediumLockList = false,
     573              bool fNotifyAboutChanges = true)
     574        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    563575          mpMediumLockList(aMediumLockList),
    564576          mfKeepMediumLockList(fKeepMediumLockList)
    … …  
    586598               Progress *aProgress,
    587599               MediumLockList *aMediumLockList,
    588                bool fKeepMediumLockList = false)
    589         : Medium::Task(aMedium, aProgress),
     600               bool fKeepMediumLockList = false,
     601               bool fNotifyAboutChanges = true)
     602        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    590603          mpMediumLockList(aMediumLockList),
    591604          mfKeepMediumLockList(fKeepMediumLockList)
    … …  
    617630              Progress *aProgress,
    618631              MediumLockList *aMediumLockList,
    619               bool fKeepMediumLockList = false)
    620         : Medium::Task(aMedium, aProgress),
     632              bool fKeepMediumLockList = false,
     633              bool fNotifyAboutChanges = true)
     634        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    621635          mTarget(aTarget),
    622636          mfMergeForward(fMergeForward),
    … …  
    666680               Medium *aParent,
    667681               MediumLockList *aTargetMediumLockList,
    668                bool fKeepTargetMediumLockList = false)
    669         : Medium::Task(aMedium, aProgress),
     682               bool fKeepTargetMediumLockList = false,
     683               bool fNotifyAboutChanges = true)
     684        : Medium::Task(aMedium, aProgress, fNotifyAboutChanges),
    670685          mFilename(aFilename),
    671686          mFormat(aFormat),
    … …  
    730745                Progress *aProgress,
    731746                MediumLockList *aMediumLockList)
    732         : Medium::Task(aMedium, aProgress),
     747        : Medium::Task(aMedium, aProgress, false),
    733748          mstrNewPassword(strNewPassword),
    734749          mstrCurrentPassword(strCurrentPassword),
    … …  
    16441659        i_markRegistriesModified();
    16451660        m->pVirtualBox->i_saveModifiedRegistries();
     1661        m->pVirtualBox->i_onMediumConfigChanged(this);
    16461662    }
    16471663    catch (HRESULT aRC) { rc = aRC; }
    … …  
    18791895    i_markRegistriesModified();
    18801896    m->pVirtualBox->i_saveModifiedRegistries();
     1897    m->pVirtualBox->i_onMediumConfigChanged(this);
    18811898
    18821899    return S_OK;
    … …  
    19902007        i_markRegistriesModified();
    19912008        m->pVirtualBox->i_saveModifiedRegistries();
     2009        m->pVirtualBox->i_onMediumConfigChanged(this);
    19922010    }
    19932011
    … …  
    20562074    }
    20572075
     2076    const Guid uPrevImage = m->uuidImage;
    20582077    unconst(m->uuidImage) = imageId;
     2078    ComObjPtr<Medium> pPrevParent = i_getParent();
    20592079    unconst(m->uuidParentImage) = parentId;
    20602080
    … …  
    20652085                             !!aSetParentId /* fSetParentId */,
    20662086                             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    }
    20672103
    20682104    return rc;
    … …  
    23582394    ComObjPtr<VirtualBox> pVirtualBox(m->pVirtualBox);
    23592395
     2396    Guid uId = i_getId();
     2397    DeviceType_T devType = i_getDeviceType();
     2398    bool wasCreated = m->state != MediumState_NotCreated;
    23602399    MultiResult mrc = i_close(aAutoCaller);
    23612400
    23622401    pVirtualBox->i_saveModifiedRegistries();
     2402
     2403    if (SUCCEEDED(mrc) && wasCreated)
     2404        m->pVirtualBox->i_onMediumRegistered(uId, devType, FALSE);
    23632405
    23642406    return mrc;
    … …  
    24302472    i_markRegistriesModified();
    24312473    m->pVirtualBox->i_saveModifiedRegistries();
     2474    m->pVirtualBox->i_onMediumConfigChanged(this);
    24322475
    24332476    return S_OK;
    … …  
    25092552    i_markRegistriesModified();
    25102553    m->pVirtualBox->i_saveModifiedRegistries();
     2554    m->pVirtualBox->i_onMediumConfigChanged(this);
    25112555
    25122556    return S_OK;
    25132557}
     2558
    25142559HRESULT Medium::createBaseStorage(LONG64 aLogicalSize,
    25152560                                  const std::vector<MediumVariant_T> &aVariant,
    … …  
    25972642
    25982643    MultiResult mrc = i_deleteStorage(&pProgress,
    2599                                       false /* aWait */);
     2644                                      false /* aWait */,
     2645                                      true /* aNotify */);
    26002646    /* Must save the registries in any case, since an entry was removed. */
    26012647    m->pVirtualBox->i_saveModifiedRegistries();
    … …  
    27162762
    27172763    rc = i_createDiffStorage(diff, (MediumVariant_T)mediumVariantFlags, pMediumLockList,
    2718                              &pProgress, false /* aWait */);
     2764                             &pProgress, false /* aWait */, true /* aNotify */);
    27192765    if (FAILED(rc))
    27202766        delete pMediumLockList;
    … …  
    27482794
    27492795    rc = i_mergeTo(pTarget, fMergeForward, pParentForTarget, pChildrenToReparent,
    2750                    pMediumLockList, &pProgress, false /* aWait */);
     2796                   pMediumLockList, &pProgress, false /* aWait */, true /* aNotify */);
    27512797    if (FAILED(rc))
    27522798        i_cancelMergeTo(pChildrenToReparent, pMediumLockList);
    … …  
    32993345        MediumState_T mediumState;
    33003346        refreshState(autoCaller, &mediumState);
     3347        m->pVirtualBox->i_onMediumConfigChanged(this);
    33013348    }
    33023349    catch (HRESULT aRC) { rc = aRC; }
    … …  
    34263473
    34273474    if (SUCCEEDED(rc))
    3428         rc = i_resize(aLogicalSize, pMediumLockList, &pProgress, false /* aWait */);
     3475        rc = i_resize(aLogicalSize, pMediumLockList, &pProgress, false /* aWait */, true /* aNotify */);
    34293476
    34303477    if (SUCCEEDED(rc))
    … …  
    44794526        unconst(m->strLocationFull) = newPath;
    44804527
     4528        m->pVirtualBox->i_onMediumConfigChanged(this);
     4529
    44814530        LogFlowThisFunc(("locationFull.after='%s'\n", m->strLocationFull.c_str()));
    44824531        // we changed something
    … …  
    46254674
    46264675/**
    4627  * Internal method to return the medium's size. Must have caller + locking!
     4676 * Internal method to update the medium's id. Must have caller + locking!
    46284677 * @return
    46294678 */
    … …  
    48784927                                    MediumLockList *aMediumLockList,
    48794928                                    ComObjPtr<Progress> *aProgress,
    4880                                     bool aWait)
     4929                                    bool aWait,
     4930                                    bool aNotify)
    48814931{
    48824932    AssertReturn(!aTarget.isNull(), E_FAIL);
    … …  
    49535003        pTask = new Medium::CreateDiffTask(this, pProgress, aTarget, aVariant,
    49545004                                           aMediumLockList,
    4955                                            aWait /* fKeepMediumLockList */);
     5005                                           aWait /* fKeepMediumLockList */,
     5006                                           aNotify);
    49565007        rc = pTask->rc();
    49575008        AssertComRC(rc);
    … …  
    51385189 */
    51395190HRESULT Medium::i_deleteStorage(ComObjPtr<Progress> *aProgress,
    5140                               bool aWait)
     5191                              bool aWait, bool aNotify)
    51415192{
    51425193    AssertReturn(aProgress != NULL || aWait == true, E_FAIL);
    … …  
    53095360
    53105361        /* setup task object to carry out the operation sync/async */
    5311         pTask = new Medium::DeleteTask(this, pProgress, pMediumLockList);
     5362        pTask = new Medium::DeleteTask(this, pProgress, pMediumLockList, false, aNotify);
    53125363        rc = pTask->rc();
    53135364        AssertComRC(rc);
    … …  
    59646015                          MediumLockList *aMediumLockList,
    59656016                          ComObjPtr<Progress> *aProgress,
    5966                           bool aWait)
     6017                          bool aWait, bool aNotify)
    59676018{
    59686019    AssertReturn(pTarget != NULL, E_FAIL);
    … …  
    60196070                                      pParentForTarget, aChildrenToReparent,
    60206071                                      pProgress, aMediumLockList,
    6021                                       aWait /* fKeepMediumLockList */);
     6072                                      aWait /* fKeepMediumLockList */,
     6073                                      aNotify);
    60226074        rc = pTask->rc();
    60236075        AssertComRC(rc);
    … …  
    61416193                         MediumLockList *aMediumLockList,
    61426194                         ComObjPtr<Progress> *aProgress,
    6143                          bool aWait)
     6195                         bool aWait,
     6196                         bool aNotify)
    61446197{
    61456198    AssertReturn(aMediumLockList != NULL, E_FAIL);
    … …  
    61806233                                       pProgress,
    61816234                                       aMediumLockList,
    6182                                        aWait /* fKeepMediumLockList */);
     6235                                       aWait /* fKeepMediumLockList */,
     6236                                       aNotify);
    61836237        rc = pTask->rc();
    61846238        AssertComRC(rc);
    … …  
    64966550                             RTVFSIOSTREAM aVfsIosSrc,
    64976551                             const ComObjPtr<Medium> &aParent,
    6498                              const ComObjPtr<Progress> &aProgress)
     6552                             const ComObjPtr<Progress> &aProgress,
     6553                             bool aNotify)
    64996554{
    65006555    /** @todo r=klaus The code below needs to be double checked with regard
    … …  
    65576612        /* setup task object to carry out the operation asynchronously */
    65586613        pTask = new Medium::ImportTask(this, aProgress, aFilename, aFormat, aVariant,
    6559                                        aVfsIosSrc, aParent, pTargetMediumLockList);
     6614                                       aVfsIosSrc, aParent, pTargetMediumLockList, false, aNotify);
    65606615        rc = pTask->rc();
    65616616        AssertComRC(rc);
    … …  
    65956650HRESULT Medium::i_cloneToEx(const ComObjPtr<Medium> &aTarget, MediumVariant_T aVariant,
    65966651                            const ComObjPtr<Medium> &aParent, IProgress **aProgress,
    6597                             uint32_t idxSrcImageSame, uint32_t idxDstImageSame)
     6652                            uint32_t idxSrcImageSame, uint32_t idxDstImageSame, bool aNotify)
    65986653{
    65996654    /** @todo r=klaus The code below needs to be double checked with regard
    … …  
    67006755                                      aParent, idxSrcImageSame,
    67016756                                      idxDstImageSame, pSourceMediumLockList,
    6702                                       pTargetMediumLockList);
     6757                                      pTargetMediumLockList, false, false, aNotify);
    67036758        rc = pTask->rc();
    67046759        AssertComRC(rc);
    … …  
    73007355    pToken.setNull();
    73017356
    7302     if (FAILED(rc)) return rc;
     7357    if (FAILED(rc))
     7358        return rc;
    73037359
    73047360    /* If this is a base image which incorrectly has a parent UUID set,
    … …  
    73087364     * with a diff image before the base is registered this would destroy
    73097365     * the diff. Not acceptable. */
    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);
     7366    do
     7367    {
     7368        if (fRepairImageZeroParentUuid)
     7369        {
     7370            rc = LockWrite(pToken.asOutParam());
     7371            if (FAILED(rc))
     7372                break;
     7373
     7374            alock.release();
    73227375
    73237376            try
    73247377            {
    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);
     7378                PVDISK hdd;
     7379                vrc = VDCreate(m->vdDiskIfaces, i_convertDeviceType(), &hdd);
    73367380                ComAssertRCThrow(vrc, E_FAIL);
     7381
     7382                try
     7383                {
     7384                    vrc = VDOpen(hdd,
     7385                                 format.c_str(),
     7386                                 location.c_str(),
     7387                                 (uOpenFlags & ~VD_OPEN_FLAGS_READONLY) | m->uOpenFlagsDef,
     7388                                 m->vdImageIfaces);
     7389                    if (RT_FAILURE(vrc))
     7390                        throw S_OK;
     7391
     7392                    RTUUID zeroParentUuid;
     7393                    RTUuidClear(&zeroParentUuid);
     7394                    vrc = VDSetParentUuid(hdd, 0, &zeroParentUuid);
     7395                    ComAssertRCThrow(vrc, E_FAIL);
     7396                }
     7397                catch (HRESULT aRC)
     7398                {
     7399                    rc = aRC;
     7400                }
     7401
     7402                VDDestroy(hdd);
    73377403            }
    73387404            catch (HRESULT aRC)
    … …  
    73417407            }
    73427408
    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     }
     7409            pToken->Abandon();
     7410            pToken.setNull();
     7411            if (FAILED(rc))
     7412                break;
     7413        }
     7414    } while(0);
    73547415
    73557416    return rc;
    … …  
    84938554            m->pVirtualBox->i_saveModifiedRegistries();
    84948555        }
     8556        if (task.NotifyAboutChanges())
     8557            m->pVirtualBox->i_onMediumRegistered(m->id, m->devType, TRUE);
    84958558    }
    84968559    else
    … …  
    87288791     * unlock the medium. */
    87298792
     8793    if (task.NotifyAboutChanges() && SUCCEEDED(mrc))
     8794    {
     8795        m->pVirtualBox->i_onMediumRegistered(pTarget->i_getId(), pTarget->i_getDeviceType(), TRUE);
     8796        m->pVirtualBox->i_onMediumConfigChanged(this);
     8797    }
     8798
    87308799    return mrc;
    87318800}
    … …  
    88208889
    88218890                ComObjPtr<Progress> pProgress(task.GetProgressObject());
    8822                 rc = pTarget->i_resize(sourceSize, pMediumLockListForResize, &pProgress, true);
     8891                rc = pTarget->i_resize(sourceSize, pMediumLockListForResize, &pProgress, true, false);
    88238892                if (FAILED(rc))
    88248893                {
    … …  
    89869055    HRESULT rc2;
    89879056
     9057    std::set<ComObjPtr<Medium> > pMediumsForNotify;
     9058    std::map<Guid, DeviceType_T> uIdsForNotify;
     9059
    89889060    if (SUCCEEDED(mrc))
    89899061    {
    … …  
    90039075             * (chain->parent() is source's parent). Depth check above. */
    90049076            pTarget->i_deparent();
     9077            if (task.NotifyAboutChanges())
     9078                pMediumsForNotify.insert(task.mParentForTarget);
    90059079            pTarget->i_setParent(task.mParentForTarget);
    90069080            if (task.mParentForTarget)
    … …  
    90409114                    // no depth check, reduces depth
    90419115                    pMedium->i_setParent(pTarget);
     9116
     9117                    if (task.NotifyAboutChanges())
     9118                        pMediumsForNotify.insert(pMedium);
    90429119                }
    90439120            }
     9121            pMediumsForNotify.insert(pTarget);
    90449122        }
    90459123
    … …  
    90669144            }
    90679145
     9146            uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
    90689147            rc2 = pMedium->m->pVirtualBox->i_unregisterMedium(pMedium);
    90699148            AssertComRC(rc2);
    … …  
    91269205        if (task.isAsync())
    91279206            i_cancelMergeTo(task.mpChildrenToReparent, task.mpMediumLockList);
     9207    }
     9208    else if (task.NotifyAboutChanges())
     9209    {
     9210        for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
     9211             it != pMediumsForNotify.end();
     9212             ++it)
     9213        {
     9214            if (it->isNotNull())
     9215                m->pVirtualBox->i_onMediumConfigChanged(*it);
     9216        }
     9217        for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
     9218             it != uIdsForNotify.end();
     9219             ++it)
     9220        {
     9221            m->pVirtualBox->i_onMediumRegistered(it->first, it->second, FALSE);
     9222        }
    91289223    }
    91299224
    … …  
    94469541                m->pVirtualBox->i_saveModifiedRegistries();
    94479542                eik.fetch();
     9543
     9544                if (task.NotifyAboutChanges())
     9545                {
     9546                    if (!fCreatingTarget)
     9547                    {
     9548                        if (!aFilterPropNames.empty())
     9549                            m->pVirtualBox->i_onMediumConfigChanged(pTargetBase);
     9550                        m->pVirtualBox->i_onMediumConfigChanged(pParent);
     9551                    }
     9552                    else
     9553                    {
     9554                        m->pVirtualBox->i_onMediumRegistered(pTarget->i_getId(), pTarget->i_getDeviceType(), TRUE);
     9555                    }
     9556                }
    94489557            }
    94499558        }
    … …  
    96219730    task.mpMediumLockList->Clear();
    96229731
     9732    if (task.NotifyAboutChanges() && SUCCEEDED(mrc))
     9733        m->pVirtualBox->i_onMediumConfigChanged(this);
    96239734    return mrc;
    96249735}
    … …  
    96889799    /* Reset UUID to prevent Create* from reusing it again */
    96899800    unconst(m->id).clear();
     9801
     9802    if (task.NotifyAboutChanges() && SUCCEEDED(rc) && m->pParent.isNotNull())
     9803        m->pVirtualBox->i_onMediumConfigChanged(m->pParent);
    96909804
    96919805    return rc;
    … …  
    98319945    m->logicalSize = logicalSize;
    98329946    m->variant = variant;
     9947
     9948    if (task.NotifyAboutChanges() && SUCCEEDED(rc))
     9949        m->pVirtualBox->i_onMediumConfigChanged(this);
    98339950
    98349951    /* Everything is explicitly unlocked when the task exits,
    … …  
    992810045    }
    992910046    catch (HRESULT aRC) { rc = aRC; }
     10047
     10048    if (task.NotifyAboutChanges() && SUCCEEDED(rc))
     10049        m->pVirtualBox->i_onMediumConfigChanged(this);
    993010050
    993110051    /* Everything is explicitly unlocked when the task exits,
    … …  
    1004410164        m->size = size;
    1004510165        m->logicalSize = logicalSize;
     10166
     10167        if (task.NotifyAboutChanges())
     10168            m->pVirtualBox->i_onMediumConfigChanged(this);
    1004610169    }
    1004710170
    … …  
    1031210435    task.mpTargetMediumLockList->Clear();
    1031310436
     10437    if (task.NotifyAboutChanges() && SUCCEEDED(mrc))
     10438    {
     10439        if (pParent)
     10440            m->pVirtualBox->i_onMediumConfigChanged(pParent);
     10441        if (fCreatingTarget)
     10442            m->pVirtualBox->i_onMediumConfigChanged(this);
     10443        else
     10444            m->pVirtualBox->i_onMediumRegistered(m->id, m->devType, TRUE);
     10445    }
     10446
    1031410447    return mrc;
    1031510448}

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

    r75373 r76215  
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1616 */
     17
     18#include <set>
     19#include <map>
    1720
    1821#include "Logging.h"
    … …  
    16371640    BOOL fSuspendedBySave     = FALSE;
    16381641
     1642    std::set<ComObjPtr<Medium> > pMediumsForNotify;
     1643    std::map<Guid, DeviceType_T> uIdsForNotify;
     1644
    16391645    try
    16401646    {
    … …  
    17731779            if (FAILED(rc))
    17741780                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
     1794                bool fFound = false;
     1795                /* was this medium attached before? */
     1796                for (MediumAttachmentList::iterator
     1797                     oldIt = oldAtts.begin();
     1798                     oldIt != oldAtts.end();
     1799                     ++oldIt)
     1800                {
     1801                    MediumAttachment *pOldAttach = *oldIt;
     1802                    if (pOldAttach->i_getMedium() == pMedium)
     1803                    {
     1804                        fFound = true;
     1805                        break;
     1806                    }
     1807                }
     1808                if (!fFound)
     1809                {
     1810                    pMediumsForNotify.insert(pMedium->i_getParent());
     1811                    uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
     1812                }
     1813            }
    17751814        }
    17761815
    … …  
    18771916        mParent->i_onSnapshotTaken(mData->mUuid, task.m_uuidSnapshot);
    18781917    LogFlowThisFuncLeave();
     1918
     1919    if (SUCCEEDED(rc))
     1920    {
     1921        for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
     1922             it != uIdsForNotify.end();
     1923             ++it)
     1924        {
     1925            mParent->i_onMediumRegistered(it->first, it->second, TRUE);
     1926        }
     1927
     1928        for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
     1929             it != pMediumsForNotify.end();
     1930             ++it)
     1931        {
     1932            if (it->isNotNull())
     1933                mParent->i_onMediumConfigChanged(*it);
     1934        }
     1935    }
    18791936}
    18801937
    … …  
    21202177    HRESULT rc = S_OK;
    21212178    Guid snapshotId;
     2179    std::set<ComObjPtr<Medium> > pMediumsForNotify;
     2180    std::map<Guid, DeviceType_T> uIdsForNotify;
    21222181
    21232182    try
    … …  
    22142273            /* make the snapshot we restored from the current snapshot */
    22152274            mData->mCurrentSnapshot = task.m_pSnapshot;
     2275        }
     2276
     2277        // store parent of newly created diffs for notify
     2278        {
     2279            MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
     2280            for (MediumAttachmentList::const_iterator
     2281                 it = mMediumAttachments->begin();
     2282                 it != mMediumAttachments->end();
     2283                 ++it)
     2284            {
     2285                MediumAttachment *pAttach = *it;
     2286                Medium *pMedium = pAttach->i_getMedium();
     2287
     2288                bool fFound = false;
     2289                /* was this medium attached before? */
     2290                for (MediumAttachmentList::iterator
     2291                     oldIt = oldAtts.begin();
     2292                     oldIt != oldAtts.end();
     2293                     ++oldIt)
     2294                {
     2295                    MediumAttachment *pOldAttach = *oldIt;
     2296                    if (pOldAttach->i_getMedium() == pMedium)
     2297                    {
     2298                        fFound = true;
     2299                        break;
     2300                    }
     2301                }
     2302                if (!fFound)
     2303                {
     2304                    pMediumsForNotify.insert(pMedium->i_getParent());
     2305                    uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
     2306                }
     2307            }
    22162308        }
    22172309
    … …  
    23142406            LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->i_getName().c_str()));
    23152407
     2408            ComObjPtr<Medium> pParent = pMedium->i_getParent();
    23162409            HRESULT rc2 = pMedium->i_deleteStorage(NULL /* aProgress */,
    2317                                                    true /* aWait */);
     2410                                                   true /* aWait */,
     2411                                                   false /* aNotify */);
    23182412            // ignore errors here because we cannot roll back after i_saveSettings() above
    23192413            if (SUCCEEDED(rc2))
     2414            {
     2415                pMediumsForNotify.insert(pParent);
    23202416                pMedium->uninit();
     2417            }
    23212418        }
    23222419    }
    … …  
    23452442
    23462443    if (SUCCEEDED(rc))
     2444    {
    23472445        mParent->i_onSnapshotRestored(mData->mUuid, snapshotId);
     2446        for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
     2447             it != uIdsForNotify.end();
     2448             ++it)
     2449        {
     2450            mParent->i_onMediumRegistered(it->first, it->second, TRUE);
     2451        }
     2452        for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
     2453             it != pMediumsForNotify.end();
     2454             ++it)
     2455        {
     2456            if (it->isNotNull())
     2457                mParent->i_onMediumConfigChanged(*it);
     2458        }
     2459    }
    23482460
    23492461    LogFlowThisFunc(("Done restoring snapshot (rc=%08X)\n", rc));
    … …  
    26962808    MediumDeleteRecList toDelete;
    26972809    Guid snapshotId;
     2810    std::set<ComObjPtr<Medium> > pMediumsForNotify;
     2811    std::map<Guid,DeviceType_T> uIdsForNotify;
    26982812
    26992813    try
    … …  
    30703184                    /* No need to hold the lock any longer. */
    30713185                    mLock.release();
     3186                    ComObjPtr<Medium> pParent = pMedium->i_getParent();
     3187                    Guid uMedium = pMedium->i_getId();
     3188                    DeviceType_T uMediumType = pMedium->i_getDeviceType();
    30723189                    rc = pMedium->i_deleteStorage(&task.m_pProgress,
    3073                                                   true /* aWait */);
     3190                                                  true /* aWait */,
     3191                                                  false /* aNotify */);
    30743192                    if (FAILED(rc))
    30753193                        throw rc;
     3194
     3195                    pMediumsForNotify.insert(pParent);
     3196                    uIdsForNotify[uMedium] = uMediumType;
    30763197
    30773198                    // need to uninit the deleted medium
    … …  
    30813202            else
    30823203            {
     3204                {
     3205                    //store ids before merging for notify
     3206                    pMediumsForNotify.insert(it->mpTarget);
     3207                    if (it->mfMergeForward)
     3208                        pMediumsForNotify.insert(it->mpSource->i_getParent());
     3209                    else
     3210                    {
     3211                        //children which will be reparented to target
     3212                        for (MediaList::const_iterator iit = it->mpSource->i_getChildren().begin();
     3213                             iit != it->mpSource->i_getChildren().end();
     3214                             ++iit)
     3215                        {
     3216                            pMediumsForNotify.insert(*iit);
     3217                        }
     3218                    }
     3219                    if (it->mfMergeForward)
     3220                    {
     3221                        for (ComObjPtr<Medium> pTmpMedium = it->mpTarget->i_getParent();
     3222                             pTmpMedium != it->mpSource;
     3223                             pTmpMedium = pTmpMedium->i_getParent())
     3224                        {
     3225                            uIdsForNotify[pTmpMedium->i_getId()] = pTmpMedium->i_getDeviceType();
     3226                        }
     3227                        uIdsForNotify[it->mpSource->i_getId()] = it->mpSource->i_getDeviceType();
     3228                    }
     3229                    else
     3230                    {
     3231                        for (ComObjPtr<Medium> pTmpMedium = it->mpSource->i_getParent();
     3232                             pTmpMedium != it->mpTarget;
     3233                             pTmpMedium = pTmpMedium->i_getParent())
     3234                        {
     3235                            uIdsForNotify[pTmpMedium->i_getId()] = pTmpMedium->i_getDeviceType();
     3236                        }
     3237                    }
     3238                }
     3239
    30833240                bool fNeedsSave = false;
    30843241                if (it->mfNeedsOnlineMerge)
    … …  
    31113268                                                 it->mpMediumLockList,
    31123269                                                 &task.m_pProgress,
    3113                                                  true /* aWait */);
     3270                                                 true /* aWait */,
     3271                                                 false /* aNotify */);
    31143272                }
    31153273
    … …  
    32783436
    32793437    if (SUCCEEDED(mrc))
     3438    {
    32803439        mParent->i_onSnapshotDeleted(mData->mUuid, snapshotId);
     3440        for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
     3441             it != uIdsForNotify.end();
     3442             ++it)
     3443        {
     3444            mParent->i_onMediumRegistered(it->first, it->second, FALSE);
     3445        }
     3446        for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
     3447             it != pMediumsForNotify.end();
     3448             ++it)
     3449        {
     3450            if (it->isNotNull())
     3451                mParent->i_onMediumConfigChanged(*it);
     3452        }
     3453    }
    32813454
    32823455    LogFlowThisFunc(("Done deleting snapshot (rc=%08X)\n", (HRESULT)mrc));

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

    r76091 r76215  
    19631963
    19641964    if (SUCCEEDED(rc))
     1965    {
    19651966        medium.queryInterfaceTo(aMedium.asOutParam());
     1967        i_onMediumRegistered(medium->i_getId(), medium->i_getDeviceType(), TRUE);
     1968    }
    19661969
    19671970    return rc;
    … …  
    20142017    }
    20152018
     2019    bool fMediumRegistered = false;
    20162020    if (pMedium.isNull())
    20172021    {
    … …  
    20402044                rc = VBOX_E_OBJECT_NOT_FOUND;
    20412045            }
     2046            else
     2047            {
     2048                fMediumRegistered = true;
     2049            }
    20422050        }
    20432051        else
    … …  
    20492057
    20502058    if (SUCCEEDED(rc))
     2059    {
    20512060        pMedium.queryInterfaceTo(aMedium.asOutParam());
     2061        if (fMediumRegistered)
     2062            i_onMediumRegistered(pMedium->i_getId(), pMedium->i_getDeviceType() ,TRUE);
     2063    }
    20522064
    20532065    return rc;
    … …  
    22522264        if (RT_FAILURE(vrc))
    22532265            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        }
    22542275    }
    22552276    return fFailure ? VERR_INVALID_PARAMETER : VINF_SUCCESS;
    … …  
    29172938}
    29182939
     2940
     2941/** Event for onMediumRegistered() */
     2942struct 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 */
     2963void 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() */
     2969struct 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
     2984void VirtualBox::i_onMediumConfigChanged(IMedium *aMedium)
     2985{
     2986    i_postEvent(new MediumConfigChangedEvent(this, aMedium));
     2987}
     2988
     2989/** Event for onMediumChanged() */
     2990struct 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
     3005void VirtualBox::i_onMediumChanged(IMediumAttachment *aMediumAttachment)
     3006{
     3007    i_postEvent(new MediumChangedEvent(this, aMediumAttachment));
     3008}
     3009
     3010/** Event for onStorageDeviceChanged() */
     3011struct 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
     3030void VirtualBox::i_onStorageDeviceChanged(IMediumAttachment *aStorageDevice, const BOOL fRemoved, const BOOL fSilent)
     3031{
     3032    i_postEvent(new StorageDeviceChangedEvent(this, aStorageDevice, fRemoved, fSilent));
     3033}
    29193034
    29203035/**
Note: See TracChangeset for help on using the changeset viewer.

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