VirtualBox

source: vbox/trunk/src/VBox/Main/SnapshotImpl.cpp@ 24279

Last change on this file since 24279 was 24279, checked in by vboxsync, 15 years ago

Main: move huge amounts of snapshot code from MachineImpl.cpp to SnapshotImpl.cpp; no functional change

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 68.4 KB
Line 
1/** @file
2 *
3 * COM class implementation for Snapshot and SnapshotMachine.
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#include "SnapshotImpl.h"
23
24#include "MachineImpl.h"
25#include "Global.h"
26
27// @todo these three includes are required for about one or two lines, try
28// to remove them and put that code in shared code in MachineImplcpp
29#include "SharedFolderImpl.h"
30#include "USBControllerImpl.h"
31#include "VirtualBoxImpl.h"
32
33#include "Logging.h"
34
35#include <iprt/path.h>
36#include <VBox/param.h>
37#include <VBox/err.h>
38
39#include <VBox/settings.h>
40
41////////////////////////////////////////////////////////////////////////////////
42//
43// Globals
44//
45////////////////////////////////////////////////////////////////////////////////
46
47/**
48 * Progress callback handler for lengthy operations
49 * (corresponds to the FNRTPROGRESS typedef).
50 *
51 * @param uPercentage Completetion precentage (0-100).
52 * @param pvUser Pointer to the Progress instance.
53 */
54static DECLCALLBACK(int) progressCallback(unsigned uPercentage, void *pvUser)
55{
56 Progress *progress = static_cast<Progress*>(pvUser);
57
58 /* update the progress object */
59 if (progress)
60 progress->SetCurrentOperationProgress(uPercentage);
61
62 return VINF_SUCCESS;
63}
64
65////////////////////////////////////////////////////////////////////////////////
66//
67// Snapshot private data definition
68//
69////////////////////////////////////////////////////////////////////////////////
70
71typedef std::list< ComObjPtr<Snapshot> > SnapshotsList;
72
73struct Snapshot::Data
74{
75 Data()
76 {
77 RTTimeSpecSetMilli(&timeStamp, 0);
78 };
79
80 ~Data()
81 {}
82
83 Guid uuid;
84 Utf8Str strName;
85 Utf8Str strDescription;
86 RTTIMESPEC timeStamp;
87 ComObjPtr<SnapshotMachine> pMachine;
88
89 SnapshotsList llChildren; // protected by VirtualBox::snapshotTreeLockHandle()
90};
91
92////////////////////////////////////////////////////////////////////////////////
93//
94// Constructor / destructor
95//
96////////////////////////////////////////////////////////////////////////////////
97
98HRESULT Snapshot::FinalConstruct()
99{
100 LogFlowMember (("Snapshot::FinalConstruct()\n"));
101 return S_OK;
102}
103
104void Snapshot::FinalRelease()
105{
106 LogFlowMember (("Snapshot::FinalRelease()\n"));
107 uninit();
108}
109
110/**
111 * Initializes the instance
112 *
113 * @param aId id of the snapshot
114 * @param aName name of the snapshot
115 * @param aDescription name of the snapshot (NULL if no description)
116 * @param aTimeStamp timestamp of the snapshot, in ms since 1970-01-01 UTC
117 * @param aMachine machine associated with this snapshot
118 * @param aParent parent snapshot (NULL if no parent)
119 */
120HRESULT Snapshot::init(VirtualBox *aVirtualBox,
121 const Guid &aId,
122 const Utf8Str &aName,
123 const Utf8Str &aDescription,
124 const RTTIMESPEC &aTimeStamp,
125 SnapshotMachine *aMachine,
126 Snapshot *aParent)
127{
128 LogFlowMember(("Snapshot::init(uuid: %s, aParent->uuid=%s)\n", aId.toString().c_str(), (aParent) ? aParent->m->uuid.toString().c_str() : ""));
129
130 ComAssertRet (!aId.isEmpty() && !aName.isEmpty() && aMachine, E_INVALIDARG);
131
132 /* Enclose the state transition NotReady->InInit->Ready */
133 AutoInitSpan autoInitSpan(this);
134 AssertReturn(autoInitSpan.isOk(), E_FAIL);
135
136 m = new Data;
137
138 /* share parent weakly */
139 unconst(mVirtualBox) = aVirtualBox;
140
141 mParent = aParent;
142
143 m->uuid = aId;
144 m->strName = aName;
145 m->strDescription = aDescription;
146 m->timeStamp = aTimeStamp;
147 m->pMachine = aMachine;
148
149 if (aParent)
150 aParent->m->llChildren.push_back(this);
151
152 /* Confirm a successful initialization when it's the case */
153 autoInitSpan.setSucceeded();
154
155 return S_OK;
156}
157
158/**
159 * Uninitializes the instance and sets the ready flag to FALSE.
160 * Called either from FinalRelease(), by the parent when it gets destroyed,
161 * or by a third party when it decides this object is no more valid.
162 */
163void Snapshot::uninit()
164{
165 LogFlowMember (("Snapshot::uninit()\n"));
166
167 /* Enclose the state transition Ready->InUninit->NotReady */
168 AutoUninitSpan autoUninitSpan(this);
169 if (autoUninitSpan.uninitDone())
170 return;
171
172 // uninit all children
173 SnapshotsList::iterator it;
174 for (it = m->llChildren.begin();
175 it != m->llChildren.end();
176 ++it)
177 {
178 Snapshot *pChild = *it;
179 pChild->mParent.setNull();
180 pChild->uninit();
181 }
182 m->llChildren.clear(); // this unsets all the ComPtrs and probably calls delete
183
184 if (mParent)
185 {
186 SnapshotsList &llParent = mParent->m->llChildren;
187 for (it = llParent.begin();
188 it != llParent.end();
189 ++it)
190 {
191 Snapshot *pParentsChild = *it;
192 if (this == pParentsChild)
193 {
194 llParent.erase(it);
195 break;
196 }
197 }
198
199 mParent.setNull();
200 }
201
202 if (m->pMachine)
203 {
204 m->pMachine->uninit();
205 m->pMachine.setNull();
206 }
207
208 delete m;
209 m = NULL;
210}
211
212/**
213 * Discards the current snapshot by removing it from the tree of snapshots
214 * and reparenting its children.
215 *
216 * After this, the caller must call uninit() on the snapshot. We can't call
217 * that from here because if we do, the AutoUninitSpan waits forever for
218 * the number of callers to become 0 (it is 1 because of the AutoCaller in here).
219 *
220 * NOTE: this does NOT lock the snapshot, it is assumed that the caller has
221 * locked a) the machine and b) the snapshots tree in write mode!
222 */
223void Snapshot::beginDiscard()
224{
225 AutoCaller autoCaller(this);
226 if (FAILED(autoCaller.rc()))
227 return;
228
229 /* for now, the snapshot must have only one child when discarded,
230 * or no children at all */
231 AssertReturnVoid(m->llChildren.size() <= 1);
232
233 ComObjPtr<Snapshot> parentSnapshot = parent();
234
235 /// @todo (dmik):
236 // when we introduce clones later, discarding the snapshot
237 // will affect the current and first snapshots of clones, if they are
238 // direct children of this snapshot. So we will need to lock machines
239 // associated with child snapshots as well and update mCurrentSnapshot
240 // and/or mFirstSnapshot fields.
241
242 if (this == m->pMachine->mData->mCurrentSnapshot)
243 {
244 m->pMachine->mData->mCurrentSnapshot = parentSnapshot;
245
246 /* we've changed the base of the current state so mark it as
247 * modified as it no longer guaranteed to be its copy */
248 m->pMachine->mData->mCurrentStateModified = TRUE;
249 }
250
251 if (this == m->pMachine->mData->mFirstSnapshot)
252 {
253 if (m->llChildren.size() == 1)
254 {
255 ComObjPtr<Snapshot> childSnapshot = m->llChildren.front();
256 m->pMachine->mData->mFirstSnapshot = childSnapshot;
257 }
258 else
259 m->pMachine->mData->mFirstSnapshot.setNull();
260 }
261
262 // reparent our children
263 for (SnapshotsList::const_iterator it = m->llChildren.begin();
264 it != m->llChildren.end();
265 ++it)
266 {
267 ComObjPtr<Snapshot> child = *it;
268 AutoWriteLock childLock(child);
269
270 child->mParent = mParent;
271 if (mParent)
272 mParent->m->llChildren.push_back(child);
273 }
274
275 // clear our own children list (since we reparented the children)
276 m->llChildren.clear();
277}
278
279////////////////////////////////////////////////////////////////////////////////
280//
281// ISnapshot public methods
282//
283////////////////////////////////////////////////////////////////////////////////
284
285STDMETHODIMP Snapshot::COMGETTER(Id) (BSTR *aId)
286{
287 CheckComArgOutPointerValid(aId);
288
289 AutoCaller autoCaller(this);
290 CheckComRCReturnRC(autoCaller.rc());
291
292 AutoReadLock alock(this);
293
294 m->uuid.toUtf16().cloneTo(aId);
295 return S_OK;
296}
297
298STDMETHODIMP Snapshot::COMGETTER(Name) (BSTR *aName)
299{
300 CheckComArgOutPointerValid(aName);
301
302 AutoCaller autoCaller(this);
303 CheckComRCReturnRC(autoCaller.rc());
304
305 AutoReadLock alock(this);
306
307 m->strName.cloneTo(aName);
308 return S_OK;
309}
310
311/**
312 * @note Locks this object for writing, then calls Machine::onSnapshotChange()
313 * (see its lock requirements).
314 */
315STDMETHODIMP Snapshot::COMSETTER(Name)(IN_BSTR aName)
316{
317 CheckComArgNotNull(aName);
318
319 AutoCaller autoCaller(this);
320 CheckComRCReturnRC(autoCaller.rc());
321
322 Utf8Str strName(aName);
323
324 AutoWriteLock alock(this);
325
326 if (m->strName != strName)
327 {
328 m->strName = strName;
329
330 alock.leave(); /* Important! (child->parent locks are forbidden) */
331
332 return m->pMachine->onSnapshotChange(this);
333 }
334
335 return S_OK;
336}
337
338STDMETHODIMP Snapshot::COMGETTER(Description) (BSTR *aDescription)
339{
340 CheckComArgOutPointerValid(aDescription);
341
342 AutoCaller autoCaller(this);
343 CheckComRCReturnRC(autoCaller.rc());
344
345 AutoReadLock alock(this);
346
347 m->strDescription.cloneTo(aDescription);
348 return S_OK;
349}
350
351STDMETHODIMP Snapshot::COMSETTER(Description) (IN_BSTR aDescription)
352{
353 CheckComArgNotNull(aDescription);
354
355 AutoCaller autoCaller(this);
356 CheckComRCReturnRC(autoCaller.rc());
357
358 Utf8Str strDescription(aDescription);
359
360 AutoWriteLock alock(this);
361
362 if (m->strDescription != strDescription)
363 {
364 m->strDescription = strDescription;
365
366 alock.leave(); /* Important! (child->parent locks are forbidden) */
367
368 return m->pMachine->onSnapshotChange(this);
369 }
370
371 return S_OK;
372}
373
374STDMETHODIMP Snapshot::COMGETTER(TimeStamp) (LONG64 *aTimeStamp)
375{
376 CheckComArgOutPointerValid(aTimeStamp);
377
378 AutoCaller autoCaller(this);
379 CheckComRCReturnRC(autoCaller.rc());
380
381 AutoReadLock alock(this);
382
383 *aTimeStamp = RTTimeSpecGetMilli(&m->timeStamp);
384 return S_OK;
385}
386
387STDMETHODIMP Snapshot::COMGETTER(Online)(BOOL *aOnline)
388{
389 CheckComArgOutPointerValid(aOnline);
390
391 AutoCaller autoCaller(this);
392 CheckComRCReturnRC(autoCaller.rc());
393
394 AutoReadLock alock(this);
395
396 *aOnline = !stateFilePath().isEmpty();
397 return S_OK;
398}
399
400STDMETHODIMP Snapshot::COMGETTER(Machine) (IMachine **aMachine)
401{
402 CheckComArgOutPointerValid(aMachine);
403
404 AutoCaller autoCaller(this);
405 CheckComRCReturnRC(autoCaller.rc());
406
407 AutoReadLock alock(this);
408
409 m->pMachine.queryInterfaceTo(aMachine);
410 return S_OK;
411}
412
413STDMETHODIMP Snapshot::COMGETTER(Parent) (ISnapshot **aParent)
414{
415 CheckComArgOutPointerValid(aParent);
416
417 AutoCaller autoCaller(this);
418 CheckComRCReturnRC(autoCaller.rc());
419
420 AutoReadLock alock(this);
421
422 mParent.queryInterfaceTo(aParent);
423 return S_OK;
424}
425
426STDMETHODIMP Snapshot::COMGETTER(Children) (ComSafeArrayOut(ISnapshot *, aChildren))
427{
428 CheckComArgOutSafeArrayPointerValid(aChildren);
429
430 AutoCaller autoCaller(this);
431 CheckComRCReturnRC(autoCaller.rc());
432
433 AutoReadLock alock(m->pMachine->snapshotsTreeLockHandle());
434 AutoReadLock block(this->lockHandle());
435
436 SafeIfaceArray<ISnapshot> collection(m->llChildren);
437 collection.detachTo(ComSafeArrayOutArg(aChildren));
438
439 return S_OK;
440}
441
442////////////////////////////////////////////////////////////////////////////////
443//
444// Snapshot public internal methods
445//
446////////////////////////////////////////////////////////////////////////////////
447
448/**
449 * @note
450 * Must be called from under the object's lock!
451 */
452const Utf8Str& Snapshot::stateFilePath() const
453{
454 return m->pMachine->mSSData->mStateFilePath;
455}
456
457/**
458 * Returns the number of direct child snapshots, without grandchildren.
459 * Does not recurse.
460 * @return
461 */
462ULONG Snapshot::getChildrenCount()
463{
464 AutoCaller autoCaller(this);
465 AssertComRC(autoCaller.rc());
466
467 AutoReadLock treeLock(m->pMachine->snapshotsTreeLockHandle());
468 return (ULONG)m->llChildren.size();
469}
470
471/**
472 * Implementation method for getAllChildrenCount() so we request the
473 * tree lock only once before recursing. Don't call directly.
474 * @return
475 */
476ULONG Snapshot::getAllChildrenCountImpl()
477{
478 AutoCaller autoCaller(this);
479 AssertComRC(autoCaller.rc());
480
481 ULONG count = (ULONG)m->llChildren.size();
482 for (SnapshotsList::const_iterator it = m->llChildren.begin();
483 it != m->llChildren.end();
484 ++it)
485 {
486 count += (*it)->getAllChildrenCountImpl();
487 }
488
489 return count;
490}
491
492/**
493 * Returns the number of child snapshots including all grandchildren.
494 * Recurses into the snapshots tree.
495 * @return
496 */
497ULONG Snapshot::getAllChildrenCount()
498{
499 AutoCaller autoCaller(this);
500 AssertComRC(autoCaller.rc());
501
502 AutoReadLock treeLock(m->pMachine->snapshotsTreeLockHandle());
503 return getAllChildrenCountImpl();
504}
505
506/**
507 * Returns the SnapshotMachine that this snapshot belongs to.
508 * Caller must hold the snapshot's object lock!
509 * @return
510 */
511ComPtr<SnapshotMachine> Snapshot::getSnapshotMachine()
512{
513 return (SnapshotMachine*)m->pMachine;
514}
515
516/**
517 * Returns the UUID of this snapshot.
518 * Caller must hold the snapshot's object lock!
519 * @return
520 */
521Guid Snapshot::getId() const
522{
523 return m->uuid;
524}
525
526/**
527 * Returns the name of this snapshot.
528 * Caller must hold the snapshot's object lock!
529 * @return
530 */
531const Utf8Str& Snapshot::getName() const
532{
533 return m->strName;
534}
535
536/**
537 * Returns the time stamp of this snapshot.
538 * Caller must hold the snapshot's object lock!
539 * @return
540 */
541RTTIMESPEC Snapshot::getTimeStamp() const
542{
543 return m->timeStamp;
544}
545
546/**
547 * Searches for a snapshot with the given ID among children, grand-children,
548 * etc. of this snapshot. This snapshot itself is also included in the search.
549 * Caller must hold the snapshots tree lock!
550 */
551ComObjPtr<Snapshot> Snapshot::findChildOrSelf(IN_GUID aId)
552{
553 ComObjPtr<Snapshot> child;
554
555 AutoCaller autoCaller(this);
556 AssertComRC(autoCaller.rc());
557
558 AutoReadLock alock(this);
559
560 if (m->uuid == aId)
561 child = this;
562 else
563 {
564 alock.unlock();
565 for (SnapshotsList::const_iterator it = m->llChildren.begin();
566 it != m->llChildren.end();
567 ++it)
568 {
569 if ((child = (*it)->findChildOrSelf(aId)))
570 break;
571 }
572 }
573
574 return child;
575}
576
577/**
578 * Searches for a first snapshot with the given name among children,
579 * grand-children, etc. of this snapshot. This snapshot itself is also included
580 * in the search.
581 * Caller must hold the snapshots tree lock!
582 */
583ComObjPtr<Snapshot> Snapshot::findChildOrSelf(const Utf8Str &aName)
584{
585 ComObjPtr<Snapshot> child;
586 AssertReturn(!aName.isEmpty(), child);
587
588 AutoCaller autoCaller(this);
589 AssertComRC(autoCaller.rc());
590
591 AutoReadLock alock (this);
592
593 if (m->strName == aName)
594 child = this;
595 else
596 {
597 alock.unlock();
598 for (SnapshotsList::const_iterator it = m->llChildren.begin();
599 it != m->llChildren.end();
600 ++it)
601 {
602 if ((child = (*it)->findChildOrSelf(aName)))
603 break;
604 }
605 }
606
607 return child;
608}
609
610/**
611 * Internal implementation for Snapshot::updateSavedStatePaths (below).
612 * @param aOldPath
613 * @param aNewPath
614 */
615void Snapshot::updateSavedStatePathsImpl(const char *aOldPath, const char *aNewPath)
616{
617 AutoWriteLock alock(this);
618
619 const Utf8Str &path = m->pMachine->mSSData->mStateFilePath;
620 LogFlowThisFunc(("Snap[%s].statePath={%s}\n", m->strName.c_str(), path.c_str()));
621
622 /* state file may be NULL (for offline snapshots) */
623 if ( path.length()
624 && RTPathStartsWith(path.c_str(), aOldPath)
625 )
626 {
627 m->pMachine->mSSData->mStateFilePath = Utf8StrFmt("%s%s", aNewPath, path.raw() + strlen(aOldPath));
628
629 LogFlowThisFunc(("-> updated: {%s}\n", path.raw()));
630 }
631
632 for (SnapshotsList::const_iterator it = m->llChildren.begin();
633 it != m->llChildren.end();
634 ++it)
635 {
636 Snapshot *pChild = *it;
637 pChild->updateSavedStatePathsImpl(aOldPath, aNewPath);
638 }
639}
640
641/**
642 * Checks if the specified path change affects the saved state file path of
643 * this snapshot or any of its (grand-)children and updates it accordingly.
644 *
645 * Intended to be called by Machine::openConfigLoader() only.
646 *
647 * @param aOldPath old path (full)
648 * @param aNewPath new path (full)
649 *
650 * @note Locks this object + children for writing.
651 */
652void Snapshot::updateSavedStatePaths(const char *aOldPath, const char *aNewPath)
653{
654 LogFlowThisFunc(("aOldPath={%s} aNewPath={%s}\n", aOldPath, aNewPath));
655
656 AssertReturnVoid(aOldPath);
657 AssertReturnVoid(aNewPath);
658
659 AutoCaller autoCaller(this);
660 AssertComRC(autoCaller.rc());
661
662 AutoWriteLock chLock(m->pMachine->snapshotsTreeLockHandle());
663 // call the implementation under the tree lock
664 updateSavedStatePathsImpl(aOldPath, aNewPath);
665}
666
667/**
668 * Internal implementation for Snapshot::saveSnapshot (below).
669 * @param aNode
670 * @param aAttrsOnly
671 * @return
672 */
673HRESULT Snapshot::saveSnapshotImpl(settings::Snapshot &data, bool aAttrsOnly)
674{
675 AutoReadLock alock(this);
676
677 data.uuid = m->uuid;
678 data.strName = m->strName;
679 data.timestamp = m->timeStamp;
680 data.strDescription = m->strDescription;
681
682 if (aAttrsOnly)
683 return S_OK;
684
685 /* stateFile (optional) */
686 if (!stateFilePath().isEmpty())
687 /* try to make the file name relative to the settings file dir */
688 m->pMachine->calculateRelativePath(stateFilePath(), data.strStateFile);
689 else
690 data.strStateFile.setNull();
691
692 HRESULT rc = m->pMachine->saveHardware(data.hardware);
693 CheckComRCReturnRC (rc);
694
695 rc = m->pMachine->saveStorageControllers(data.storage);
696 CheckComRCReturnRC (rc);
697
698 alock.unlock();
699
700 data.llChildSnapshots.clear();
701
702 if (m->llChildren.size())
703 {
704 for (SnapshotsList::const_iterator it = m->llChildren.begin();
705 it != m->llChildren.end();
706 ++it)
707 {
708 settings::Snapshot snap;
709 rc = (*it)->saveSnapshotImpl(snap, aAttrsOnly);
710 CheckComRCReturnRC (rc);
711
712 data.llChildSnapshots.push_back(snap);
713 }
714 }
715
716 return S_OK;
717}
718
719/**
720 * Saves the given snapshot and all its children (unless \a aAttrsOnly is true).
721 * It is assumed that the given node is empty (unless \a aAttrsOnly is true).
722 *
723 * @param aNode <Snapshot> node to save the snapshot to.
724 * @param aSnapshot Snapshot to save.
725 * @param aAttrsOnly If true, only updatge user-changeable attrs.
726 */
727HRESULT Snapshot::saveSnapshot(settings::Snapshot &data, bool aAttrsOnly)
728{
729 AutoWriteLock listLock(m->pMachine->snapshotsTreeLockHandle());
730
731 return saveSnapshotImpl(data, aAttrsOnly);
732}
733
734////////////////////////////////////////////////////////////////////////////////
735//
736// SnapshotMachine implementation
737//
738////////////////////////////////////////////////////////////////////////////////
739
740DEFINE_EMPTY_CTOR_DTOR (SnapshotMachine)
741
742HRESULT SnapshotMachine::FinalConstruct()
743{
744 LogFlowThisFunc(("\n"));
745
746 /* set the proper type to indicate we're the SnapshotMachine instance */
747 unconst(mType) = IsSnapshotMachine;
748
749 return S_OK;
750}
751
752void SnapshotMachine::FinalRelease()
753{
754 LogFlowThisFunc(("\n"));
755
756 uninit();
757}
758
759/**
760 * Initializes the SnapshotMachine object when taking a snapshot.
761 *
762 * @param aSessionMachine machine to take a snapshot from
763 * @param aSnapshotId snapshot ID of this snapshot machine
764 * @param aStateFilePath file where the execution state will be later saved
765 * (or NULL for the offline snapshot)
766 *
767 * @note The aSessionMachine must be locked for writing.
768 */
769HRESULT SnapshotMachine::init(SessionMachine *aSessionMachine,
770 IN_GUID aSnapshotId,
771 const Utf8Str &aStateFilePath)
772{
773 LogFlowThisFuncEnter();
774 LogFlowThisFunc(("mName={%ls}\n", aSessionMachine->mUserData->mName.raw()));
775
776 AssertReturn(aSessionMachine && !Guid (aSnapshotId).isEmpty(), E_INVALIDARG);
777
778 /* Enclose the state transition NotReady->InInit->Ready */
779 AutoInitSpan autoInitSpan(this);
780 AssertReturn(autoInitSpan.isOk(), E_FAIL);
781
782 AssertReturn(aSessionMachine->isWriteLockOnCurrentThread(), E_FAIL);
783
784 mSnapshotId = aSnapshotId;
785
786 /* memorize the primary Machine instance (i.e. not SessionMachine!) */
787 unconst(mPeer) = aSessionMachine->mPeer;
788 /* share the parent pointer */
789 unconst(mParent) = mPeer->mParent;
790
791 /* take the pointer to Data to share */
792 mData.share (mPeer->mData);
793
794 /* take the pointer to UserData to share (our UserData must always be the
795 * same as Machine's data) */
796 mUserData.share (mPeer->mUserData);
797 /* make a private copy of all other data (recent changes from SessionMachine) */
798 mHWData.attachCopy (aSessionMachine->mHWData);
799 mMediaData.attachCopy(aSessionMachine->mMediaData);
800
801 /* SSData is always unique for SnapshotMachine */
802 mSSData.allocate();
803 mSSData->mStateFilePath = aStateFilePath;
804
805 HRESULT rc = S_OK;
806
807 /* create copies of all shared folders (mHWData after attiching a copy
808 * contains just references to original objects) */
809 for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
810 it != mHWData->mSharedFolders.end();
811 ++it)
812 {
813 ComObjPtr<SharedFolder> folder;
814 folder.createObject();
815 rc = folder->initCopy (this, *it);
816 CheckComRCReturnRC(rc);
817 *it = folder;
818 }
819
820 /* associate hard disks with the snapshot
821 * (Machine::uninitDataAndChildObjects() will deassociate at destruction) */
822 for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
823 it != mMediaData->mAttachments.end();
824 ++it)
825 {
826 MediumAttachment *pAtt = *it;
827 Medium *pMedium = pAtt->medium();
828 if (pMedium) // can be NULL for non-harddisk
829 {
830 rc = pMedium->attachTo(mData->mUuid, mSnapshotId);
831 AssertComRC(rc);
832 }
833 }
834
835 /* create copies of all storage controllers (mStorageControllerData
836 * after attaching a copy contains just references to original objects) */
837 mStorageControllers.allocate();
838 for (StorageControllerList::const_iterator
839 it = aSessionMachine->mStorageControllers->begin();
840 it != aSessionMachine->mStorageControllers->end();
841 ++it)
842 {
843 ComObjPtr<StorageController> ctrl;
844 ctrl.createObject();
845 ctrl->initCopy (this, *it);
846 mStorageControllers->push_back(ctrl);
847 }
848
849 /* create all other child objects that will be immutable private copies */
850
851 unconst(mBIOSSettings).createObject();
852 mBIOSSettings->initCopy (this, mPeer->mBIOSSettings);
853
854#ifdef VBOX_WITH_VRDP
855 unconst(mVRDPServer).createObject();
856 mVRDPServer->initCopy (this, mPeer->mVRDPServer);
857#endif
858
859 unconst(mAudioAdapter).createObject();
860 mAudioAdapter->initCopy (this, mPeer->mAudioAdapter);
861
862 unconst(mUSBController).createObject();
863 mUSBController->initCopy (this, mPeer->mUSBController);
864
865 for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
866 {
867 unconst(mNetworkAdapters [slot]).createObject();
868 mNetworkAdapters [slot]->initCopy (this, mPeer->mNetworkAdapters [slot]);
869 }
870
871 for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
872 {
873 unconst(mSerialPorts [slot]).createObject();
874 mSerialPorts [slot]->initCopy (this, mPeer->mSerialPorts [slot]);
875 }
876
877 for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
878 {
879 unconst(mParallelPorts [slot]).createObject();
880 mParallelPorts [slot]->initCopy (this, mPeer->mParallelPorts [slot]);
881 }
882
883 /* Confirm a successful initialization when it's the case */
884 autoInitSpan.setSucceeded();
885
886 LogFlowThisFuncLeave();
887 return S_OK;
888}
889
890/**
891 * Initializes the SnapshotMachine object when loading from the settings file.
892 *
893 * @param aMachine machine the snapshot belngs to
894 * @param aHWNode <Hardware> node
895 * @param aHDAsNode <HardDiskAttachments> node
896 * @param aSnapshotId snapshot ID of this snapshot machine
897 * @param aStateFilePath file where the execution state is saved
898 * (or NULL for the offline snapshot)
899 *
900 * @note Doesn't lock anything.
901 */
902HRESULT SnapshotMachine::init(Machine *aMachine,
903 const settings::Hardware &hardware,
904 const settings::Storage &storage,
905 IN_GUID aSnapshotId,
906 const Utf8Str &aStateFilePath)
907{
908 LogFlowThisFuncEnter();
909 LogFlowThisFunc(("mName={%ls}\n", aMachine->mUserData->mName.raw()));
910
911 AssertReturn(aMachine && !Guid(aSnapshotId).isEmpty(), E_INVALIDARG);
912
913 /* Enclose the state transition NotReady->InInit->Ready */
914 AutoInitSpan autoInitSpan(this);
915 AssertReturn(autoInitSpan.isOk(), E_FAIL);
916
917 /* Don't need to lock aMachine when VirtualBox is starting up */
918
919 mSnapshotId = aSnapshotId;
920
921 /* memorize the primary Machine instance */
922 unconst(mPeer) = aMachine;
923 /* share the parent pointer */
924 unconst(mParent) = mPeer->mParent;
925
926 /* take the pointer to Data to share */
927 mData.share (mPeer->mData);
928 /*
929 * take the pointer to UserData to share
930 * (our UserData must always be the same as Machine's data)
931 */
932 mUserData.share (mPeer->mUserData);
933 /* allocate private copies of all other data (will be loaded from settings) */
934 mHWData.allocate();
935 mMediaData.allocate();
936 mStorageControllers.allocate();
937
938 /* SSData is always unique for SnapshotMachine */
939 mSSData.allocate();
940 mSSData->mStateFilePath = aStateFilePath;
941
942 /* create all other child objects that will be immutable private copies */
943
944 unconst(mBIOSSettings).createObject();
945 mBIOSSettings->init (this);
946
947#ifdef VBOX_WITH_VRDP
948 unconst(mVRDPServer).createObject();
949 mVRDPServer->init (this);
950#endif
951
952 unconst(mAudioAdapter).createObject();
953 mAudioAdapter->init (this);
954
955 unconst(mUSBController).createObject();
956 mUSBController->init (this);
957
958 for (ULONG slot = 0; slot < RT_ELEMENTS (mNetworkAdapters); slot ++)
959 {
960 unconst(mNetworkAdapters [slot]).createObject();
961 mNetworkAdapters [slot]->init (this, slot);
962 }
963
964 for (ULONG slot = 0; slot < RT_ELEMENTS (mSerialPorts); slot ++)
965 {
966 unconst(mSerialPorts [slot]).createObject();
967 mSerialPorts [slot]->init (this, slot);
968 }
969
970 for (ULONG slot = 0; slot < RT_ELEMENTS (mParallelPorts); slot ++)
971 {
972 unconst(mParallelPorts [slot]).createObject();
973 mParallelPorts [slot]->init (this, slot);
974 }
975
976 /* load hardware and harddisk settings */
977
978 HRESULT rc = loadHardware(hardware);
979 if (SUCCEEDED(rc))
980 rc = loadStorageControllers(storage, true /* aRegistered */, &mSnapshotId);
981
982 if (SUCCEEDED(rc))
983 /* commit all changes made during the initialization */
984 commit();
985
986 /* Confirm a successful initialization when it's the case */
987 if (SUCCEEDED(rc))
988 autoInitSpan.setSucceeded();
989
990 LogFlowThisFuncLeave();
991 return rc;
992}
993
994/**
995 * Uninitializes this SnapshotMachine object.
996 */
997void SnapshotMachine::uninit()
998{
999 LogFlowThisFuncEnter();
1000
1001 /* Enclose the state transition Ready->InUninit->NotReady */
1002 AutoUninitSpan autoUninitSpan(this);
1003 if (autoUninitSpan.uninitDone())
1004 return;
1005
1006 uninitDataAndChildObjects();
1007
1008 /* free the essential data structure last */
1009 mData.free();
1010
1011 unconst(mParent).setNull();
1012 unconst(mPeer).setNull();
1013
1014 LogFlowThisFuncLeave();
1015}
1016
1017/**
1018 * Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
1019 * with the primary Machine instance (mPeer).
1020 */
1021RWLockHandle *SnapshotMachine::lockHandle() const
1022{
1023 AssertReturn(!mPeer.isNull(), NULL);
1024 return mPeer->lockHandle();
1025}
1026
1027////////////////////////////////////////////////////////////////////////////////
1028//
1029// SnapshotMachine public internal methods
1030//
1031////////////////////////////////////////////////////////////////////////////////
1032
1033/**
1034 * Called by the snapshot object associated with this SnapshotMachine when
1035 * snapshot data such as name or description is changed.
1036 *
1037 * @note Locks this object for writing.
1038 */
1039HRESULT SnapshotMachine::onSnapshotChange (Snapshot *aSnapshot)
1040{
1041 AutoWriteLock alock(this);
1042
1043 // mPeer->saveAllSnapshots(); @todo
1044
1045 /* inform callbacks */
1046 mParent->onSnapshotChange(mData->mUuid, aSnapshot->getId());
1047
1048 return S_OK;
1049}
1050
1051////////////////////////////////////////////////////////////////////////////////
1052//
1053// SessionMachine task records
1054//
1055////////////////////////////////////////////////////////////////////////////////
1056
1057/** Task structure for asynchronous VM operations */
1058struct SessionMachine::Task
1059{
1060 Task (SessionMachine *m, Progress *p)
1061 : machine (m), progress (p)
1062 , state (m->mData->mMachineState) // save the current machine state
1063 , subTask (false)
1064 {}
1065
1066 void modifyLastState (MachineState_T s)
1067 {
1068 *const_cast <MachineState_T *> (&state) = s;
1069 }
1070
1071 virtual void handler() = 0;
1072
1073 ComObjPtr<SessionMachine> machine;
1074 ComObjPtr<Progress> progress;
1075 const MachineState_T state;
1076
1077 bool subTask : 1;
1078};
1079
1080/** Discard snapshot task */
1081struct SessionMachine::DeleteSnapshotTask
1082 : public SessionMachine::Task
1083{
1084 DeleteSnapshotTask(SessionMachine *m, Progress *p, Snapshot *s)
1085 : Task(m, p),
1086 snapshot(s)
1087 {}
1088
1089 DeleteSnapshotTask (const Task &task, Snapshot *s)
1090 : Task(task)
1091 , snapshot(s)
1092 {}
1093
1094 void handler()
1095 {
1096 machine->deleteSnapshotHandler(*this);
1097 }
1098
1099 ComObjPtr<Snapshot> snapshot;
1100};
1101
1102/** Restore snapshot state task */
1103struct SessionMachine::RestoreSnapshotTask
1104 : public SessionMachine::Task
1105{
1106 RestoreSnapshotTask(SessionMachine *m,
1107 ComObjPtr<Snapshot> &aSnapshot,
1108 Progress *p,
1109 ULONG ulStateFileSizeMB)
1110 : Task(m, p),
1111 m_pSnapshot(aSnapshot),
1112 m_ulStateFileSizeMB(ulStateFileSizeMB)
1113 {}
1114
1115 void handler()
1116 {
1117 machine->restoreSnapshotHandler(*this);
1118 }
1119
1120 ComObjPtr<Snapshot> m_pSnapshot;
1121 ULONG m_ulStateFileSizeMB;
1122};
1123
1124////////////////////////////////////////////////////////////////////////////////
1125//
1126// SessionMachine public internal methods
1127//
1128////////////////////////////////////////////////////////////////////////////////
1129
1130/**
1131 * @note Locks mParent + this object for writing.
1132 */
1133STDMETHODIMP SessionMachine::BeginTakingSnapshot(IConsole *aInitiator,
1134 IN_BSTR aName,
1135 IN_BSTR aDescription,
1136 IProgress *aConsoleProgress,
1137 BOOL fTakingSnapshotOnline,
1138 BSTR *aStateFilePath)
1139{
1140 LogFlowThisFuncEnter();
1141
1142 AssertReturn(aInitiator && aName, E_INVALIDARG);
1143 AssertReturn(aStateFilePath, E_POINTER);
1144
1145 LogFlowThisFunc(("aName='%ls'\n", aName));
1146
1147 AutoCaller autoCaller(this);
1148 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
1149
1150 /* saveSettings() needs mParent lock */
1151 AutoMultiWriteLock2 alock(mParent, this);
1152
1153 AssertReturn( !Global::IsOnlineOrTransient(mData->mMachineState)
1154 || mData->mMachineState == MachineState_Running
1155 || mData->mMachineState == MachineState_Paused, E_FAIL);
1156 AssertReturn(mSnapshotData.mLastState == MachineState_Null, E_FAIL);
1157 AssertReturn(mSnapshotData.mSnapshot.isNull(), E_FAIL);
1158
1159 if ( !fTakingSnapshotOnline
1160 && mData->mMachineState != MachineState_Saved
1161 )
1162 {
1163 /* save all current settings to ensure current changes are committed and
1164 * hard disks are fixed up */
1165 HRESULT rc = saveSettings();
1166 CheckComRCReturnRC(rc);
1167 }
1168
1169 /* create an ID for the snapshot */
1170 Guid snapshotId;
1171 snapshotId.create();
1172
1173 Utf8Str strStateFilePath;
1174 /* stateFilePath is null when the machine is not online nor saved */
1175 if ( fTakingSnapshotOnline
1176 || mData->mMachineState == MachineState_Saved)
1177 {
1178 strStateFilePath = Utf8StrFmt("%ls%c{%RTuuid}.sav",
1179 mUserData->mSnapshotFolderFull.raw(),
1180 RTPATH_DELIMITER,
1181 snapshotId.ptr());
1182 /* ensure the directory for the saved state file exists */
1183 HRESULT rc = VirtualBox::ensureFilePathExists(strStateFilePath);
1184 CheckComRCReturnRC(rc);
1185 }
1186
1187 /* create a snapshot machine object */
1188 ComObjPtr<SnapshotMachine> snapshotMachine;
1189 snapshotMachine.createObject();
1190 HRESULT rc = snapshotMachine->init(this, snapshotId, strStateFilePath);
1191 AssertComRCReturn(rc, rc);
1192
1193 /* create a snapshot object */
1194 RTTIMESPEC time;
1195 ComObjPtr<Snapshot> pSnapshot;
1196 pSnapshot.createObject();
1197 rc = pSnapshot->init(mParent,
1198 snapshotId,
1199 aName,
1200 aDescription,
1201 *RTTimeNow(&time),
1202 snapshotMachine,
1203 mData->mCurrentSnapshot);
1204 AssertComRCReturnRC(rc);
1205
1206 /* fill in the snapshot data */
1207 mSnapshotData.mLastState = mData->mMachineState;
1208 mSnapshotData.mSnapshot = pSnapshot;
1209
1210 try
1211 {
1212 LogFlowThisFunc(("Creating differencing hard disks (online=%d)...\n",
1213 fTakingSnapshotOnline));
1214
1215 // backup the media data so we can recover if things goes wrong along the day;
1216 // the matching commit() is in fixupMedia() during endSnapshot()
1217 mMediaData.backup();
1218
1219 /* set the state to Saving (this is expected by Console::TakeSnapshot()) */
1220 setMachineState(MachineState_Saving);
1221
1222 /* create new differencing hard disks and attach them to this machine */
1223 rc = createImplicitDiffs(mUserData->mSnapshotFolderFull,
1224 aConsoleProgress,
1225 1, // operation weight; must be the same as in Console::TakeSnapshot()
1226 !!fTakingSnapshotOnline);
1227
1228 if (SUCCEEDED(rc) && mSnapshotData.mLastState == MachineState_Saved)
1229 {
1230 Utf8Str stateFrom = mSSData->mStateFilePath;
1231 Utf8Str stateTo = mSnapshotData.mSnapshot->stateFilePath();
1232
1233 LogFlowThisFunc(("Copying the execution state from '%s' to '%s'...\n",
1234 stateFrom.raw(), stateTo.raw()));
1235
1236 aConsoleProgress->SetNextOperation(Bstr(tr("Copying the execution state")),
1237 1); // weight
1238
1239 /* Leave the lock before a lengthy operation (mMachineState is
1240 * MachineState_Saving here) */
1241 alock.leave();
1242
1243 /* copy the state file */
1244 int vrc = RTFileCopyEx(stateFrom.c_str(),
1245 stateTo.c_str(),
1246 0,
1247 progressCallback,
1248 aConsoleProgress);
1249 alock.enter();
1250
1251 if (RT_FAILURE(vrc))
1252 throw setError(E_FAIL,
1253 tr("Could not copy the state file '%s' to '%s' (%Rrc)"),
1254 stateFrom.raw(),
1255 stateTo.raw(),
1256 vrc);
1257 }
1258 }
1259 catch (HRESULT hrc)
1260 {
1261 pSnapshot->uninit();
1262 pSnapshot.setNull();
1263 rc = hrc;
1264 }
1265
1266 if (fTakingSnapshotOnline)
1267 strStateFilePath.cloneTo(aStateFilePath);
1268 else
1269 *aStateFilePath = NULL;
1270
1271 LogFlowThisFuncLeave();
1272 return rc;
1273}
1274
1275/**
1276 * @note Locks this object for writing.
1277 */
1278STDMETHODIMP SessionMachine::EndTakingSnapshot(BOOL aSuccess)
1279{
1280 LogFlowThisFunc(("\n"));
1281
1282 AutoCaller autoCaller(this);
1283 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1284
1285 AutoWriteLock alock(this);
1286
1287 AssertReturn(!aSuccess ||
1288 (mData->mMachineState == MachineState_Saving &&
1289 mSnapshotData.mLastState != MachineState_Null &&
1290 !mSnapshotData.mSnapshot.isNull()),
1291 E_FAIL);
1292
1293 /*
1294 * Restore the state we had when BeginTakingSnapshot() was called,
1295 * Console::fntTakeSnapshotWorker restores its local copy when we return.
1296 * If the state was Running, then let Console::fntTakeSnapshotWorker it
1297 * all via Console::Resume().
1298 */
1299 if ( mData->mMachineState != mSnapshotData.mLastState
1300 && mSnapshotData.mLastState != MachineState_Running)
1301 setMachineState(mSnapshotData.mLastState);
1302
1303 return endTakingSnapshot(aSuccess);
1304}
1305
1306/**
1307 * @note Locks mParent + this + children objects for writing!
1308 */
1309STDMETHODIMP SessionMachine::DeleteSnapshot(IConsole *aInitiator,
1310 IN_BSTR aId,
1311 MachineState_T *aMachineState,
1312 IProgress **aProgress)
1313{
1314 LogFlowThisFuncEnter();
1315
1316 Guid id(aId);
1317 AssertReturn(aInitiator && !id.isEmpty(), E_INVALIDARG);
1318 AssertReturn(aMachineState && aProgress, E_POINTER);
1319
1320 AutoCaller autoCaller(this);
1321 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1322
1323 /* saveSettings() needs mParent lock */
1324 AutoMultiWriteLock2 alock(mParent, this);
1325
1326 ComAssertRet (!Global::IsOnlineOrTransient (mData->mMachineState), E_FAIL);
1327
1328 AutoWriteLock treeLock(snapshotsTreeLockHandle());
1329
1330 ComObjPtr<Snapshot> snapshot;
1331 HRESULT rc = findSnapshot(id, snapshot, true /* aSetError */);
1332 CheckComRCReturnRC(rc);
1333
1334 AutoWriteLock snapshotLock(snapshot);
1335
1336 size_t childrenCount = snapshot->getChildrenCount();
1337 if (childrenCount > 1)
1338 return setError(VBOX_E_INVALID_OBJECT_STATE,
1339 tr("Snapshot '%s' of the machine '%ls' cannot be deleted because it has has more than one child snapshot (%d)"),
1340 snapshot->getName().c_str(),
1341 mUserData->mName.raw(),
1342 childrenCount);
1343
1344 /* If the snapshot being discarded is the current one, ensure current
1345 * settings are committed and saved.
1346 */
1347 if (snapshot == mData->mCurrentSnapshot)
1348 {
1349 if (isModified())
1350 {
1351 rc = saveSettings();
1352 CheckComRCReturnRC(rc);
1353 }
1354 }
1355
1356 /* create a progress object. The number of operations is:
1357 * 1 (preparing) + # of hard disks + 1 if the snapshot is online
1358 */
1359 ComObjPtr<Progress> progress;
1360 progress.createObject();
1361 rc = progress->init(mParent, aInitiator,
1362 BstrFmt(tr("Discarding snapshot '%s'"),
1363 snapshot->getName().c_str()),
1364 FALSE /* aCancelable */,
1365 1 + (ULONG)snapshot->getSnapshotMachine()->mMediaData->mAttachments.size()
1366 + (snapshot->stateFilePath().length() ? 1 : 0),
1367 Bstr(tr("Preparing to discard snapshot")));
1368 AssertComRCReturn(rc, rc);
1369
1370 /* create and start the task on a separate thread */
1371 DeleteSnapshotTask *task = new DeleteSnapshotTask(this, progress, snapshot);
1372 int vrc = RTThreadCreate(NULL,
1373 taskHandler,
1374 (void*)task,
1375 0,
1376 RTTHREADTYPE_MAIN_WORKER,
1377 0,
1378 "DeleteSnapshot");
1379 if (RT_FAILURE(vrc))
1380 {
1381 delete task;
1382 return E_FAIL;
1383 }
1384
1385 /* set the proper machine state (note: after creating a Task instance) */
1386 setMachineState(MachineState_DeletingSnapshot);
1387
1388 /* return the progress to the caller */
1389 progress.queryInterfaceTo(aProgress);
1390
1391 /* return the new state to the caller */
1392 *aMachineState = mData->mMachineState;
1393
1394 LogFlowThisFuncLeave();
1395
1396 return S_OK;
1397}
1398
1399/**
1400 * @note Locks this + children objects for writing!
1401 */
1402STDMETHODIMP SessionMachine::RestoreSnapshot(IConsole *aInitiator,
1403 ISnapshot *aSnapshot,
1404 MachineState_T *aMachineState,
1405 IProgress **aProgress)
1406{
1407 LogFlowThisFuncEnter();
1408
1409 AssertReturn(aInitiator, E_INVALIDARG);
1410 AssertReturn(aSnapshot && aMachineState && aProgress, E_POINTER);
1411
1412 AutoCaller autoCaller(this);
1413 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1414
1415 AutoWriteLock alock(this);
1416
1417 ComAssertRet(!Global::IsOnlineOrTransient(mData->mMachineState),
1418 E_FAIL);
1419
1420 ComObjPtr<Snapshot> pSnapshot(static_cast<Snapshot*>(aSnapshot));
1421
1422 /* create a progress object. The number of operations is: 1 (preparing) + #
1423 * of hard disks + 1 (if we need to copy the saved state file) */
1424 ComObjPtr<Progress> progress;
1425 progress.createObject();
1426
1427 LogFlowThisFunc(("Going thru snapshot machine attachments to determine progress setup\n"));
1428
1429 ULONG ulOpCount = 1; // one for preparations
1430 ULONG ulTotalWeight = 1; // one for preparations
1431 for (MediaData::AttachmentList::iterator it = pSnapshot->getSnapshotMachine()->mMediaData->mAttachments.begin();
1432 it != pSnapshot->getSnapshotMachine()->mMediaData->mAttachments.end();
1433 ++it)
1434 {
1435 ComObjPtr<MediumAttachment> &pAttach = *it;
1436 AutoReadLock attachLock(pAttach);
1437 if (pAttach->type() == DeviceType_HardDisk)
1438 {
1439 ++ulOpCount;
1440 ++ulTotalWeight; // assume one MB weight for each differencing hard disk to manage
1441 Assert(pAttach->medium());
1442 LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->medium()->name().c_str()));
1443 }
1444 }
1445
1446 ULONG ulStateFileSizeMB = 0;
1447 if (pSnapshot->stateFilePath().length())
1448 {
1449 ++ulOpCount; // one for the saved state
1450
1451 uint64_t ullSize;
1452 int irc = RTFileQuerySize(pSnapshot->stateFilePath().c_str(), &ullSize);
1453 if (!RT_SUCCESS(irc))
1454 // if we can't access the file here, then we'll be doomed later also, so fail right away
1455 setError(E_FAIL, tr("Cannot access state file '%s', runtime error, %Rra"), pSnapshot->stateFilePath().c_str(), irc);
1456 if (ullSize == 0) // avoid division by zero
1457 ullSize = _1M;
1458
1459 ulStateFileSizeMB = (ULONG)(ullSize / _1M);
1460 LogFlowThisFunc(("op %d: saved state file '%s' has %RI64 bytes (%d MB)\n",
1461 ulOpCount, pSnapshot->stateFilePath().raw(), ullSize, ulStateFileSizeMB));
1462
1463 ulTotalWeight += ulStateFileSizeMB;
1464 }
1465
1466 progress->init(mParent, aInitiator,
1467 Bstr(tr("Restoring snapshot")),
1468 FALSE /* aCancelable */,
1469 ulOpCount,
1470 ulTotalWeight,
1471 Bstr(tr("Restoring machine settings")),
1472 1);
1473
1474 /* create and start the task on a separate thread (note that it will not
1475 * start working until we release alock) */
1476 RestoreSnapshotTask *task = new RestoreSnapshotTask(this, pSnapshot, progress, ulStateFileSizeMB);
1477 int vrc = RTThreadCreate(NULL,
1478 taskHandler,
1479 (void*)task,
1480 0,
1481 RTTHREADTYPE_MAIN_WORKER,
1482 0,
1483 "RestoreSnap");
1484 if (RT_FAILURE(vrc))
1485 {
1486 delete task;
1487 ComAssertRCRet(vrc, E_FAIL);
1488 }
1489
1490 /* set the proper machine state (note: after creating a Task instance) */
1491 setMachineState(MachineState_RestoringSnapshot);
1492
1493 /* return the progress to the caller */
1494 progress.queryInterfaceTo(aProgress);
1495
1496 /* return the new state to the caller */
1497 *aMachineState = mData->mMachineState;
1498
1499 LogFlowThisFuncLeave();
1500
1501 return S_OK;
1502}
1503
1504////////////////////////////////////////////////////////////////////////////////
1505//
1506// SessionMachine public internal methods related to snapshots
1507//
1508////////////////////////////////////////////////////////////////////////////////
1509
1510/* static */
1511DECLCALLBACK(int) SessionMachine::taskHandler (RTTHREAD /* thread */, void *pvUser)
1512{
1513 AssertReturn(pvUser, VERR_INVALID_POINTER);
1514
1515 Task *task = static_cast <Task *> (pvUser);
1516 task->handler();
1517
1518 // it's our responsibility to delete the task
1519 delete task;
1520
1521 return 0;
1522}
1523
1524/**
1525 * Helper method to finalize taking a snapshot. Gets called to finalize the
1526 * "take snapshot" procedure, either from the public SessionMachine::EndTakingSnapshot()
1527 * if taking the snapshot failed/was aborted or from the takeSnapshotHandler thread
1528 * when taking the snapshot succeeded.
1529 *
1530 * Expected to be called after completing *all* the tasks related to taking the
1531 * snapshot, either successfully or unsuccessfilly.
1532 *
1533 * @param aSuccess TRUE if the snapshot has been taken successfully.
1534 *
1535 * @note Locks this objects for writing.
1536 */
1537HRESULT SessionMachine::endTakingSnapshot(BOOL aSuccess)
1538{
1539 LogFlowThisFuncEnter();
1540
1541 AutoCaller autoCaller(this);
1542 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1543
1544 AutoMultiWriteLock2 alock(mParent, this);
1545 // saveSettings needs VirtualBox lock
1546
1547 AssertReturn(!mSnapshotData.mSnapshot.isNull(), E_FAIL);
1548
1549 MultiResult rc(S_OK);
1550
1551 ComObjPtr<Snapshot> pOldFirstSnap = mData->mFirstSnapshot;
1552 ComObjPtr<Snapshot> pOldCurrentSnap = mData->mCurrentSnapshot;
1553
1554 bool fOnline = Global::IsOnline(mSnapshotData.mLastState);
1555
1556 if (aSuccess)
1557 {
1558 // new snapshot becomes the current one
1559 mData->mCurrentSnapshot = mSnapshotData.mSnapshot;
1560
1561 /* memorize the first snapshot if necessary */
1562 if (!mData->mFirstSnapshot)
1563 mData->mFirstSnapshot = mData->mCurrentSnapshot;
1564
1565 if (!fOnline)
1566 /* the machine was powered off or saved when taking a snapshot, so
1567 * reset the mCurrentStateModified flag */
1568 mData->mCurrentStateModified = FALSE;
1569
1570 rc = saveSettings();
1571 }
1572
1573 if (aSuccess && SUCCEEDED(rc))
1574 {
1575 /* associate old hard disks with the snapshot and do locking/unlocking*/
1576 fixupMedia(true /* aCommit */, fOnline);
1577
1578 /* inform callbacks */
1579 mParent->onSnapshotTaken(mData->mUuid,
1580 mSnapshotData.mSnapshot->getId());
1581 }
1582 else
1583 {
1584 /* delete all differencing hard disks created (this will also attach
1585 * their parents back by rolling back mMediaData) */
1586 fixupMedia(false /* aCommit */);
1587
1588 mData->mFirstSnapshot = pOldFirstSnap; // might have been changed above
1589 mData->mCurrentSnapshot = pOldCurrentSnap; // might have been changed above
1590
1591 /* delete the saved state file (it might have been already created) */
1592 if (mSnapshotData.mSnapshot->stateFilePath().length())
1593 RTFileDelete(mSnapshotData.mSnapshot->stateFilePath().c_str());
1594
1595 mSnapshotData.mSnapshot->uninit();
1596 }
1597
1598 /* clear out the snapshot data */
1599 mSnapshotData.mLastState = MachineState_Null;
1600 mSnapshotData.mSnapshot.setNull();
1601
1602 LogFlowThisFuncLeave();
1603 return rc;
1604}
1605
1606/**
1607 * Helper struct for SessionMachine::deleteSnapshotHandler().
1608 */
1609struct MediumDiscardRec
1610{
1611 MediumDiscardRec() : chain (NULL) {}
1612
1613 MediumDiscardRec (const ComObjPtr<Medium> &aHd,
1614 Medium::MergeChain *aChain = NULL)
1615 : hd (aHd), chain (aChain) {}
1616
1617 MediumDiscardRec (const ComObjPtr<Medium> &aHd,
1618 Medium::MergeChain *aChain,
1619 const ComObjPtr<Medium> &aReplaceHd,
1620 const ComObjPtr<MediumAttachment> &aReplaceHda,
1621 const Guid &aSnapshotId)
1622 : hd (aHd), chain (aChain)
1623 , replaceHd (aReplaceHd), replaceHda (aReplaceHda)
1624 , snapshotId (aSnapshotId) {}
1625
1626 ComObjPtr<Medium> hd;
1627 Medium::MergeChain *chain;
1628 /* these are for the replace hard disk case: */
1629 ComObjPtr<Medium> replaceHd;
1630 ComObjPtr<MediumAttachment> replaceHda;
1631 Guid snapshotId;
1632};
1633
1634typedef std::list <MediumDiscardRec> MediumDiscardRecList;
1635
1636/**
1637 * Discard snapshot task handler. Must be called only by
1638 * DeleteSnapshotTask::handler()!
1639 *
1640 * When aTask.subTask is true, the associated progress object is left
1641 * uncompleted on success. On failure, the progress is marked as completed
1642 * regardless of this parameter.
1643 *
1644 * @note Locks mParent + this + child objects for writing!
1645 */
1646void SessionMachine::deleteSnapshotHandler(DeleteSnapshotTask &aTask)
1647{
1648 LogFlowThisFuncEnter();
1649
1650 AutoCaller autoCaller(this);
1651
1652 LogFlowThisFunc(("state=%d\n", autoCaller.state()));
1653 if (!autoCaller.isOk())
1654 {
1655 /* we might have been uninitialized because the session was accidentally
1656 * closed by the client, so don't assert */
1657 aTask.progress->notifyComplete(E_FAIL,
1658 COM_IIDOF(IMachine),
1659 getComponentName(),
1660 tr("The session has been accidentally closed"));
1661 LogFlowThisFuncLeave();
1662 return;
1663 }
1664
1665 /* Locking order: */
1666 AutoMultiWriteLock3 alock(this->lockHandle(),
1667 this->snapshotsTreeLockHandle(),
1668 aTask.snapshot->lockHandle());
1669
1670 ComPtr<SnapshotMachine> sm = aTask.snapshot->getSnapshotMachine();
1671 /* no need to lock the snapshot machine since it is const by definiton */
1672
1673 HRESULT rc = S_OK;
1674
1675 /* save the snapshot ID (for callbacks) */
1676 Guid snapshotId = aTask.snapshot->getId();
1677
1678 MediumDiscardRecList toDiscard;
1679
1680 bool settingsChanged = false;
1681
1682 try
1683 {
1684 /* first pass: */
1685 LogFlowThisFunc(("1: Checking hard disk merge prerequisites...\n"));
1686
1687 for (MediaData::AttachmentList::const_iterator it = sm->mMediaData->mAttachments.begin();
1688 it != sm->mMediaData->mAttachments.end();
1689 ++it)
1690 {
1691 ComObjPtr<MediumAttachment> hda = *it;
1692 ComObjPtr<Medium> hd = hda->medium();
1693
1694 // medium can be NULL only for non-hard-disk types
1695 Assert( !hd.isNull()
1696 || hda->type() != DeviceType_HardDisk);
1697 if (hd.isNull())
1698 continue;
1699
1700 /* Medium::prepareDiscard() reqiuires a write lock */
1701 AutoWriteLock hdLock(hd);
1702
1703 if (hd->type() != MediumType_Normal)
1704 {
1705 /* skip writethrough hard disks */
1706 Assert(hd->type() == MediumType_Writethrough);
1707 rc = aTask.progress->SetNextOperation(BstrFmt(tr("Skipping writethrough hard disk '%s'"),
1708 hd->base()->name().raw()),
1709 1); // weight
1710 CheckComRCThrowRC(rc);
1711 continue;
1712 }
1713
1714 Medium::MergeChain *chain = NULL;
1715
1716 /* needs to be discarded (merged with the child if any), check
1717 * prerequisites */
1718 rc = hd->prepareDiscard(chain);
1719 CheckComRCThrowRC(rc);
1720
1721 if (hd->parent().isNull() && chain != NULL)
1722 {
1723 /* it's a base hard disk so it will be a backward merge of its
1724 * only child to it (prepareDiscard() does necessary checks). We
1725 * need then to update the attachment that refers to the child
1726 * to refer to the parent instead. Don't forget to detach the
1727 * child (otherwise mergeTo() called by discard() will assert
1728 * because it will be going to delete the child) */
1729
1730 /* The below assert would be nice but I don't want to move
1731 * Medium::MergeChain to the header just for that
1732 * Assert (!chain->isForward()); */
1733
1734 Assert(hd->children().size() == 1);
1735
1736 ComObjPtr<Medium> replaceHd = hd->children().front();
1737
1738 const Guid *pReplaceMachineId = replaceHd->getFirstMachineBackrefId();
1739 Assert(pReplaceMachineId && *pReplaceMachineId == mData->mUuid);
1740
1741 Guid snapshotId;
1742 const Guid *pSnapshotId = replaceHd->getFirstMachineBackrefSnapshotId();
1743 if (pSnapshotId)
1744 snapshotId = *pSnapshotId;
1745
1746 HRESULT rc2 = S_OK;
1747
1748 /* adjust back references */
1749 rc2 = replaceHd->detachFrom (mData->mUuid, snapshotId);
1750 AssertComRC(rc2);
1751
1752 rc2 = hd->attachTo (mData->mUuid, snapshotId);
1753 AssertComRC(rc2);
1754
1755 /* replace the hard disk in the attachment object */
1756 if (snapshotId.isEmpty())
1757 {
1758 /* in current state */
1759 AssertBreak(hda = findAttachment(mMediaData->mAttachments, replaceHd));
1760 }
1761 else
1762 {
1763 /* in snapshot */
1764 ComObjPtr<Snapshot> snapshot;
1765 rc2 = findSnapshot(snapshotId, snapshot);
1766 AssertComRC(rc2);
1767
1768 /* don't lock the snapshot; cannot be modified outside */
1769 MediaData::AttachmentList &snapAtts = snapshot->getSnapshotMachine()->mMediaData->mAttachments;
1770 AssertBreak(hda = findAttachment(snapAtts, replaceHd));
1771 }
1772
1773 AutoWriteLock attLock(hda);
1774 hda->updateMedium(hd, false /* aImplicit */);
1775
1776 toDiscard.push_back(MediumDiscardRec(hd,
1777 chain,
1778 replaceHd,
1779 hda,
1780 snapshotId));
1781 continue;
1782 }
1783
1784 toDiscard.push_back(MediumDiscardRec(hd, chain));
1785 }
1786
1787 /* Now we checked that we can successfully merge all normal hard disks
1788 * (unless a runtime error like end-of-disc happens). Prior to
1789 * performing the actual merge, we want to discard the snapshot itself
1790 * and remove it from the XML file to make sure that a possible merge
1791 * ruintime error will not make this snapshot inconsistent because of
1792 * the partially merged or corrupted hard disks */
1793
1794 /* second pass: */
1795 LogFlowThisFunc(("2: Discarding snapshot...\n"));
1796
1797 {
1798 ComObjPtr<Snapshot> parentSnapshot = aTask.snapshot->parent();
1799 Bstr stateFilePath = aTask.snapshot->stateFilePath();
1800
1801 /* Note that discarding the snapshot will deassociate it from the
1802 * hard disks which will allow the merge+delete operation for them*/
1803 aTask.snapshot->beginDiscard();
1804 aTask.snapshot->uninit();
1805
1806 rc = saveAllSnapshots();
1807 CheckComRCThrowRC(rc);
1808
1809 /// @todo (dmik)
1810 // if we implement some warning mechanism later, we'll have
1811 // to return a warning if the state file path cannot be deleted
1812 if (stateFilePath)
1813 {
1814 aTask.progress->SetNextOperation(Bstr(tr("Discarding the execution state")),
1815 1); // weight
1816
1817 RTFileDelete(Utf8Str(stateFilePath).c_str());
1818 }
1819
1820 /// @todo NEWMEDIA to provide a good level of fauilt tolerance, we
1821 /// should restore the shapshot in the snapshot tree if
1822 /// saveSnapshotSettings fails. Actually, we may call
1823 /// #saveSnapshotSettings() with a special flag that will tell it to
1824 /// skip the given snapshot as if it would have been discarded and
1825 /// only actually discard it if the save operation succeeds.
1826 }
1827
1828 /* here we come when we've irrevesibly discarded the snapshot which
1829 * means that the VM settigns (our relevant changes to mData) need to be
1830 * saved too */
1831 /// @todo NEWMEDIA maybe save everything in one operation in place of
1832 /// saveSnapshotSettings() above
1833 settingsChanged = true;
1834
1835 /* third pass: */
1836 LogFlowThisFunc(("3: Performing actual hard disk merging...\n"));
1837
1838 /* leave the locks before the potentially lengthy operation */
1839 alock.leave();
1840
1841 /// @todo NEWMEDIA turn the following errors into warnings because the
1842 /// snapshot itself has been already deleted (and interpret these
1843 /// warnings properly on the GUI side)
1844
1845 for (MediumDiscardRecList::iterator it = toDiscard.begin();
1846 it != toDiscard.end();)
1847 {
1848 rc = it->hd->discard (aTask.progress, it->chain);
1849 CheckComRCBreakRC(rc);
1850
1851 /* prevent from calling cancelDiscard() */
1852 it = toDiscard.erase (it);
1853 }
1854
1855 alock.enter();
1856
1857 CheckComRCThrowRC(rc);
1858 }
1859 catch (HRESULT aRC) { rc = aRC; }
1860
1861 if (FAILED(rc))
1862 {
1863 HRESULT rc2 = S_OK;
1864
1865 /* un-prepare the remaining hard disks */
1866 for (MediumDiscardRecList::const_iterator it = toDiscard.begin();
1867 it != toDiscard.end(); ++it)
1868 {
1869 it->hd->cancelDiscard (it->chain);
1870
1871 if (!it->replaceHd.isNull())
1872 {
1873 /* undo hard disk replacement */
1874
1875 rc2 = it->replaceHd->attachTo (mData->mUuid, it->snapshotId);
1876 AssertComRC(rc2);
1877
1878 rc2 = it->hd->detachFrom (mData->mUuid, it->snapshotId);
1879 AssertComRC(rc2);
1880
1881 AutoWriteLock attLock (it->replaceHda);
1882 it->replaceHda->updateMedium(it->replaceHd, false /* aImplicit */);
1883 }
1884 }
1885 }
1886
1887 if (!aTask.subTask || FAILED(rc))
1888 {
1889 if (!aTask.subTask)
1890 {
1891 /* saveSettings() below needs a VirtualBox write lock and we need to
1892 * leave this object's lock to do this to follow the {parent-child}
1893 * locking rule. This is the last chance to do that while we are
1894 * still in a protective state which allows us to temporarily leave
1895 * the lock */
1896 alock.unlock();
1897 AutoWriteLock vboxLock(mParent);
1898 alock.lock();
1899
1900 /* preserve existing error info */
1901 ErrorInfoKeeper eik;
1902
1903 /* restore the machine state */
1904 setMachineState(aTask.state);
1905 updateMachineStateOnClient();
1906
1907 if (settingsChanged)
1908 saveSettings(SaveS_InformCallbacksAnyway);
1909 }
1910
1911 /* set the result (this will try to fetch current error info on failure) */
1912 aTask.progress->notifyComplete (rc);
1913 }
1914
1915 if (SUCCEEDED(rc))
1916 mParent->onSnapshotDiscarded (mData->mUuid, snapshotId);
1917
1918 LogFlowThisFunc(("Done discarding snapshot (rc=%08X)\n", rc));
1919 LogFlowThisFuncLeave();
1920}
1921
1922/**
1923 * Restore snapshot state task handler. Must be called only by
1924 * RestoreSnapshotTask::handler()!
1925 *
1926 * @note Locks mParent + this object for writing.
1927 */
1928void SessionMachine::restoreSnapshotHandler(RestoreSnapshotTask &aTask)
1929{
1930 LogFlowThisFuncEnter();
1931
1932 AutoCaller autoCaller(this);
1933
1934 LogFlowThisFunc(("state=%d\n", autoCaller.state()));
1935 if (!autoCaller.isOk())
1936 {
1937 /* we might have been uninitialized because the session was accidentally
1938 * closed by the client, so don't assert */
1939 aTask.progress->notifyComplete(E_FAIL,
1940 COM_IIDOF(IMachine),
1941 getComponentName(),
1942 tr("The session has been accidentally closed"));
1943
1944 LogFlowThisFuncLeave();
1945 return;
1946 }
1947
1948 /* saveSettings() needs mParent lock */
1949 AutoWriteLock vboxLock(mParent);
1950
1951 /* @todo We don't need mParent lock so far so unlock() it. Better is to
1952 * provide an AutoWriteLock argument that lets create a non-locking
1953 * instance */
1954 vboxLock.unlock();
1955
1956 AutoWriteLock alock(this);
1957
1958 /* discard all current changes to mUserData (name, OSType etc.) (note that
1959 * the machine is powered off, so there is no need to inform the direct
1960 * session) */
1961 if (isModified())
1962 rollback(false /* aNotify */);
1963
1964 HRESULT rc = S_OK;
1965
1966 bool stateRestored = false;
1967
1968 try
1969 {
1970 /* discard the saved state file if the machine was Saved prior to this
1971 * operation */
1972 if (aTask.state == MachineState_Saved)
1973 {
1974 Assert(!mSSData->mStateFilePath.isEmpty());
1975 RTFileDelete(mSSData->mStateFilePath.c_str());
1976 mSSData->mStateFilePath.setNull();
1977 aTask.modifyLastState(MachineState_PoweredOff);
1978 rc = saveStateSettings(SaveSTS_StateFilePath);
1979 CheckComRCThrowRC(rc);
1980 }
1981
1982 RTTIMESPEC snapshotTimeStamp;
1983 RTTimeSpecSetMilli(&snapshotTimeStamp, 0);
1984
1985 {
1986 AutoReadLock snapshotLock(aTask.m_pSnapshot);
1987
1988 /* remember the timestamp of the snapshot we're restoring from */
1989 snapshotTimeStamp = aTask.m_pSnapshot->getTimeStamp();
1990
1991 ComPtr<SnapshotMachine> pSnapshotMachine(aTask.m_pSnapshot->getSnapshotMachine());
1992
1993 /* copy all hardware data from the snapshot */
1994 copyFrom(pSnapshotMachine);
1995
1996 LogFlowThisFunc(("Restoring hard disks from the snapshot...\n"));
1997
1998 /* restore the attachments from the snapshot */
1999 mMediaData.backup();
2000 mMediaData->mAttachments = pSnapshotMachine->mMediaData->mAttachments;
2001
2002 /* leave the locks before the potentially lengthy operation */
2003 snapshotLock.unlock();
2004 alock.leave();
2005
2006 rc = createImplicitDiffs(mUserData->mSnapshotFolderFull,
2007 aTask.progress,
2008 1,
2009 false /* aOnline */);
2010
2011 alock.enter();
2012 snapshotLock.lock();
2013
2014 CheckComRCThrowRC(rc);
2015
2016 /* Note: on success, current (old) hard disks will be
2017 * deassociated/deleted on #commit() called from #saveSettings() at
2018 * the end. On failure, newly created implicit diffs will be
2019 * deleted by #rollback() at the end. */
2020
2021 /* should not have a saved state file associated at this point */
2022 Assert(mSSData->mStateFilePath.isEmpty());
2023
2024 if (!aTask.m_pSnapshot->stateFilePath().isEmpty())
2025 {
2026 Utf8Str snapStateFilePath = aTask.m_pSnapshot->stateFilePath();
2027
2028 Utf8Str stateFilePath = Utf8StrFmt("%ls%c{%RTuuid}.sav",
2029 mUserData->mSnapshotFolderFull.raw(),
2030 RTPATH_DELIMITER,
2031 mData->mUuid.raw());
2032
2033 LogFlowThisFunc(("Copying saved state file from '%s' to '%s'...\n",
2034 snapStateFilePath.raw(), stateFilePath.raw()));
2035
2036 aTask.progress->SetNextOperation(Bstr(tr("Restoring the execution state")),
2037 aTask.m_ulStateFileSizeMB); // weight
2038
2039 /* leave the lock before the potentially lengthy operation */
2040 snapshotLock.unlock();
2041 alock.leave();
2042
2043 /* copy the state file */
2044 int vrc = RTFileCopyEx(snapStateFilePath.c_str(),
2045 stateFilePath.c_str(),
2046 0,
2047 progressCallback,
2048 aTask.progress);
2049
2050 alock.enter();
2051 snapshotLock.lock();
2052
2053 if (RT_SUCCESS(vrc))
2054 mSSData->mStateFilePath = stateFilePath;
2055 else
2056 throw setError(E_FAIL,
2057 tr("Could not copy the state file '%s' to '%s' (%Rrc)"),
2058 snapStateFilePath.raw(),
2059 stateFilePath.raw(),
2060 vrc);
2061 }
2062
2063 LogFlowThisFunc(("Setting new current snapshot {%RTuuid}\n", aTask.m_pSnapshot->getId().raw()));
2064 /* make the snapshot we restored from the current snapshot */
2065 mData->mCurrentSnapshot = aTask.m_pSnapshot;
2066 }
2067
2068 /* grab differencing hard disks from the old attachments that will
2069 * become unused and need to be auto-deleted */
2070
2071 std::list< ComObjPtr<MediumAttachment> > llDiffAttachmentsToDelete;
2072
2073 for (MediaData::AttachmentList::const_iterator it = mMediaData.backedUpData()->mAttachments.begin();
2074 it != mMediaData.backedUpData()->mAttachments.end();
2075 ++it)
2076 {
2077 ComObjPtr<MediumAttachment> pAttach = *it;
2078 ComObjPtr<Medium> pMedium = pAttach->medium();
2079
2080 /* while the hard disk is attached, the number of children or the
2081 * parent cannot change, so no lock */
2082 if ( !pMedium.isNull()
2083 && pAttach->type() == DeviceType_HardDisk
2084 && !pMedium->parent().isNull()
2085 && pMedium->children().size() == 0
2086 )
2087 {
2088 LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->name().raw()));
2089
2090 llDiffAttachmentsToDelete.push_back(pAttach);
2091 }
2092 }
2093
2094 int saveFlags = 0;
2095
2096 /* @todo saveSettings() below needs a VirtualBox write lock and we need
2097 * to leave this object's lock to do this to follow the {parent-child}
2098 * locking rule. This is the last chance to do that while we are still
2099 * in a protective state which allows us to temporarily leave the lock*/
2100 alock.unlock();
2101 vboxLock.lock();
2102 alock.lock();
2103
2104 /* we have already discarded the current state, so set the execution
2105 * state accordingly no matter of the discard snapshot result */
2106 if (!mSSData->mStateFilePath.isEmpty())
2107 setMachineState(MachineState_Saved);
2108 else
2109 setMachineState(MachineState_PoweredOff);
2110
2111 updateMachineStateOnClient();
2112 stateRestored = true;
2113
2114 /* assign the timestamp from the snapshot */
2115 Assert(RTTimeSpecGetMilli (&snapshotTimeStamp) != 0);
2116 mData->mLastStateChange = snapshotTimeStamp;
2117
2118 // detach the current-state diffs that we detected above and build a list of
2119 // images to delete _after_ saveSettings()
2120
2121 std::list< ComObjPtr<Medium> > llDiffsToDelete;
2122
2123 for (std::list< ComObjPtr<MediumAttachment> >::iterator it = llDiffAttachmentsToDelete.begin();
2124 it != llDiffAttachmentsToDelete.end();
2125 ++it)
2126 {
2127 ComObjPtr<MediumAttachment> pAttach = *it; // guaranteed to have only attachments where medium != NULL
2128 ComObjPtr<Medium> pMedium = pAttach->medium();
2129
2130 AutoWriteLock mlock(pMedium);
2131
2132 LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->name().raw()));
2133
2134 mMediaData->mAttachments.remove(pAttach);
2135 pMedium->detachFrom(mData->mUuid);
2136
2137 llDiffsToDelete.push_back(pMedium);
2138 }
2139
2140 // save all settings, reset the modified flag and commit;
2141 rc = saveSettings(SaveS_ResetCurStateModified | saveFlags);
2142 CheckComRCThrowRC(rc);
2143 // from here on we cannot roll back on failure any more
2144
2145 for (std::list< ComObjPtr<Medium> >::iterator it = llDiffsToDelete.begin();
2146 it != llDiffsToDelete.end();
2147 ++it)
2148 {
2149 ComObjPtr<Medium> &pMedium = *it;
2150 LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->name().raw()));
2151
2152 HRESULT rc2 = pMedium->deleteStorageAndWait();
2153 // ignore errors here because we cannot roll back after saveSettings() above
2154 if (SUCCEEDED(rc2))
2155 pMedium->uninit();
2156 }
2157 }
2158 catch (HRESULT aRC)
2159 {
2160 rc = aRC;
2161 }
2162
2163 if (FAILED(rc))
2164 {
2165 /* preserve existing error info */
2166 ErrorInfoKeeper eik;
2167
2168 /* undo all changes on failure */
2169 rollback(false /* aNotify */);
2170
2171 if (!stateRestored)
2172 {
2173 /* restore the machine state */
2174 setMachineState(aTask.state);
2175 updateMachineStateOnClient();
2176 }
2177 }
2178
2179 /* set the result (this will try to fetch current error info on failure) */
2180 aTask.progress->notifyComplete(rc);
2181
2182 if (SUCCEEDED(rc))
2183 mParent->onSnapshotDiscarded(mData->mUuid, Guid());
2184
2185 LogFlowThisFunc(("Done restoring snapshot (rc=%08X)\n", rc));
2186
2187 LogFlowThisFuncLeave();
2188}
2189
Note: See TracBrowser for help on using the repository browser.

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