VirtualBox

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

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

Main,Frontends: Added two new running states: Teleporting and LiveSnapshotting. Also added TeleportingPausedVM. Renamed TeleportingFrom to TeleportingIn.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 73.5 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/**
1058 * Abstract base class for SessionMachine::RestoreSnapshotTask and
1059 * SessionMachine::DeleteSnapshotTask. This is necessary since
1060 * RTThreadCreate cannot call a method as its thread function, so
1061 * instead we have it call the static SessionMachine::taskHandler,
1062 * which can then call the handler() method in here (implemented
1063 * by the children).
1064 */
1065struct SessionMachine::SnapshotTask
1066{
1067 SnapshotTask(SessionMachine *m,
1068 Progress *p,
1069 Snapshot *s)
1070 : pMachine(m),
1071 pProgress(p),
1072 machineStateBackup(m->mData->mMachineState), // save the current machine state
1073 pSnapshot(s)
1074 {}
1075
1076 void modifyBackedUpState(MachineState_T s)
1077 {
1078 *const_cast<MachineState_T*>(&machineStateBackup) = s;
1079 }
1080
1081 virtual void handler() = 0;
1082
1083 ComObjPtr<SessionMachine> pMachine;
1084 ComObjPtr<Progress> pProgress;
1085 const MachineState_T machineStateBackup;
1086 ComObjPtr<Snapshot> pSnapshot;
1087};
1088
1089/** Restore snapshot state task */
1090struct SessionMachine::RestoreSnapshotTask
1091 : public SessionMachine::SnapshotTask
1092{
1093 RestoreSnapshotTask(SessionMachine *m,
1094 Progress *p,
1095 Snapshot *s,
1096 ULONG ulStateFileSizeMB)
1097 : SnapshotTask(m, p, s),
1098 m_ulStateFileSizeMB(ulStateFileSizeMB)
1099 {}
1100
1101 void handler()
1102 {
1103 pMachine->restoreSnapshotHandler(*this);
1104 }
1105
1106 ULONG m_ulStateFileSizeMB;
1107};
1108
1109/** Discard snapshot task */
1110struct SessionMachine::DeleteSnapshotTask
1111 : public SessionMachine::SnapshotTask
1112{
1113 DeleteSnapshotTask(SessionMachine *m,
1114 Progress *p,
1115 Snapshot *s)
1116 : SnapshotTask(m, p, s)
1117 {}
1118
1119 void handler()
1120 {
1121 pMachine->deleteSnapshotHandler(*this);
1122 }
1123
1124private:
1125 DeleteSnapshotTask(const SnapshotTask &task)
1126 : SnapshotTask(task)
1127 {}
1128};
1129
1130/**
1131 * Static SessionMachine method that can get passed to RTThreadCreate to
1132 * have a thread started for a SnapshotTask. See SnapshotTask above.
1133 *
1134 * This calls either RestoreSnapshotTask::handler() or DeleteSnapshotTask::handler().
1135 */
1136
1137/* static */ DECLCALLBACK(int) SessionMachine::taskHandler(RTTHREAD /* thread */, void *pvUser)
1138{
1139 AssertReturn(pvUser, VERR_INVALID_POINTER);
1140
1141 SnapshotTask *task = static_cast<SnapshotTask*>(pvUser);
1142 task->handler();
1143
1144 // it's our responsibility to delete the task
1145 delete task;
1146
1147 return 0;
1148}
1149
1150////////////////////////////////////////////////////////////////////////////////
1151//
1152// TakeSnapshot methods (SessionMachine and related tasks)
1153//
1154////////////////////////////////////////////////////////////////////////////////
1155
1156/**
1157 * Implementation for IInternalMachineControl::beginTakingSnapshot().
1158 *
1159 * Gets called indirectly from Console::TakeSnapshot, which creates a
1160 * progress object in the client and then starts a thread
1161 * (Console::fntTakeSnapshotWorker) which then calls this.
1162 *
1163 * In other words, the asynchronous work for taking snapshots takes place
1164 * on the _client_ (in the Console). This is different from restoring
1165 * or deleting snapshots, which start threads on the server.
1166 *
1167 * This does the server-side work of taking a snapshot: it creates diffencing
1168 * images for all hard disks attached to the machine and then creates a
1169 * Snapshot object with a corresponding SnapshotMachine to save the VM settings.
1170 *
1171 * The client's fntTakeSnapshotWorker() blocks while this takes place.
1172 * After this returns successfully, fntTakeSnapshotWorker() will begin
1173 * saving the machine state to the snapshot object and reconfigure the
1174 * hard disks.
1175 *
1176 * When the console is done, it calls SessionMachine::EndTakingSnapshot().
1177 *
1178 * @note Locks mParent + this object for writing.
1179 *
1180 * @param aInitiator in: The console on which Console::TakeSnapshot was called.
1181 * @param aName in: The name for the new snapshot.
1182 * @param aDescription in: A description for the new snapshot.
1183 * @param aConsoleProgress in: The console's (client's) progress object.
1184 * @param fTakingSnapshotOnline in: True if an online snapshot is being taken (i.e. machine is running).
1185 * @param aStateFilePath out: name of file in snapshots folder to which the console should write the VM state.
1186 * @return
1187 */
1188STDMETHODIMP SessionMachine::BeginTakingSnapshot(IConsole *aInitiator,
1189 IN_BSTR aName,
1190 IN_BSTR aDescription,
1191 IProgress *aConsoleProgress,
1192 BOOL fTakingSnapshotOnline,
1193 BSTR *aStateFilePath)
1194{
1195 LogFlowThisFuncEnter();
1196
1197 AssertReturn(aInitiator && aName, E_INVALIDARG);
1198 AssertReturn(aStateFilePath, E_POINTER);
1199
1200 LogFlowThisFunc(("aName='%ls'\n", aName));
1201
1202 AutoCaller autoCaller(this);
1203 AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
1204
1205 /* saveSettings() needs mParent lock */
1206 AutoMultiWriteLock2 alock(mParent, this);
1207
1208 AssertReturn( !Global::IsOnlineOrTransient(mData->mMachineState)
1209 || mData->mMachineState == MachineState_Running
1210 || mData->mMachineState == MachineState_Paused, E_FAIL);
1211 AssertReturn(mSnapshotData.mLastState == MachineState_Null, E_FAIL);
1212 AssertReturn(mSnapshotData.mSnapshot.isNull(), E_FAIL);
1213
1214 if ( !fTakingSnapshotOnline
1215 && mData->mMachineState != MachineState_Saved
1216 )
1217 {
1218 /* save all current settings to ensure current changes are committed and
1219 * hard disks are fixed up */
1220 HRESULT rc = saveSettings();
1221 CheckComRCReturnRC(rc);
1222 }
1223
1224 /* create an ID for the snapshot */
1225 Guid snapshotId;
1226 snapshotId.create();
1227
1228 Utf8Str strStateFilePath;
1229 /* stateFilePath is null when the machine is not online nor saved */
1230 if ( fTakingSnapshotOnline
1231 || mData->mMachineState == MachineState_Saved)
1232 {
1233 strStateFilePath = Utf8StrFmt("%ls%c{%RTuuid}.sav",
1234 mUserData->mSnapshotFolderFull.raw(),
1235 RTPATH_DELIMITER,
1236 snapshotId.ptr());
1237 /* ensure the directory for the saved state file exists */
1238 HRESULT rc = VirtualBox::ensureFilePathExists(strStateFilePath);
1239 CheckComRCReturnRC(rc);
1240 }
1241
1242 /* create a snapshot machine object */
1243 ComObjPtr<SnapshotMachine> snapshotMachine;
1244 snapshotMachine.createObject();
1245 HRESULT rc = snapshotMachine->init(this, snapshotId, strStateFilePath);
1246 AssertComRCReturn(rc, rc);
1247
1248 /* create a snapshot object */
1249 RTTIMESPEC time;
1250 ComObjPtr<Snapshot> pSnapshot;
1251 pSnapshot.createObject();
1252 rc = pSnapshot->init(mParent,
1253 snapshotId,
1254 aName,
1255 aDescription,
1256 *RTTimeNow(&time),
1257 snapshotMachine,
1258 mData->mCurrentSnapshot);
1259 AssertComRCReturnRC(rc);
1260
1261 /* fill in the snapshot data */
1262 mSnapshotData.mLastState = mData->mMachineState;
1263 mSnapshotData.mSnapshot = pSnapshot;
1264
1265 try
1266 {
1267 LogFlowThisFunc(("Creating differencing hard disks (online=%d)...\n",
1268 fTakingSnapshotOnline));
1269
1270 // backup the media data so we can recover if things goes wrong along the day;
1271 // the matching commit() is in fixupMedia() during endSnapshot()
1272 mMediaData.backup();
1273
1274 /* Console::fntTakeSnapshotWorker and friends expects this. */
1275 if (mSnapshotData.mLastState == MachineState_Running)
1276 setMachineState(MachineState_LiveSnapshotting);
1277 else
1278 setMachineState(MachineState_Saving); /** @todo Confusing! Saving is used for both online and offline snapshots. */
1279
1280 /* create new differencing hard disks and attach them to this machine */
1281 rc = createImplicitDiffs(mUserData->mSnapshotFolderFull,
1282 aConsoleProgress,
1283 1, // operation weight; must be the same as in Console::TakeSnapshot()
1284 !!fTakingSnapshotOnline);
1285
1286 if (SUCCEEDED(rc) && mSnapshotData.mLastState == MachineState_Saved)
1287 {
1288 Utf8Str stateFrom = mSSData->mStateFilePath;
1289 Utf8Str stateTo = mSnapshotData.mSnapshot->stateFilePath();
1290
1291 LogFlowThisFunc(("Copying the execution state from '%s' to '%s'...\n",
1292 stateFrom.raw(), stateTo.raw()));
1293
1294 aConsoleProgress->SetNextOperation(Bstr(tr("Copying the execution state")),
1295 1); // weight
1296
1297 /* Leave the lock before a lengthy operation (mMachineState is
1298 * MachineState_Saving here) */
1299 alock.leave();
1300
1301 /* copy the state file */
1302 int vrc = RTFileCopyEx(stateFrom.c_str(),
1303 stateTo.c_str(),
1304 0,
1305 progressCallback,
1306 aConsoleProgress);
1307 alock.enter();
1308
1309 if (RT_FAILURE(vrc))
1310 throw setError(E_FAIL,
1311 tr("Could not copy the state file '%s' to '%s' (%Rrc)"),
1312 stateFrom.raw(),
1313 stateTo.raw(),
1314 vrc);
1315 }
1316 }
1317 catch (HRESULT hrc)
1318 {
1319 pSnapshot->uninit();
1320 pSnapshot.setNull();
1321 rc = hrc;
1322 }
1323
1324 if (fTakingSnapshotOnline)
1325 strStateFilePath.cloneTo(aStateFilePath);
1326 else
1327 *aStateFilePath = NULL;
1328
1329 LogFlowThisFuncLeave();
1330 return rc;
1331}
1332
1333/**
1334 * Implementation for IInternalMachineControl::beginTakingSnapshot().
1335 *
1336 * Called by the Console when it's done saving the VM state into the snapshot
1337 * (if online) and reconfiguring the hard disks. See BeginTakingSnapshot() above.
1338 *
1339 * This also gets called if the console part of snapshotting failed after the
1340 * BeginTakingSnapshot() call, to clean up the server side.
1341 *
1342 * @note Locks this object for writing.
1343 *
1344 * @param aSuccess Whether Console was successful with the client-side snapshot things.
1345 * @return
1346 */
1347STDMETHODIMP SessionMachine::EndTakingSnapshot(BOOL aSuccess)
1348{
1349 LogFlowThisFunc(("\n"));
1350
1351 AutoCaller autoCaller(this);
1352 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1353
1354 AutoWriteLock alock(this);
1355
1356 AssertReturn( !aSuccess
1357 || ( ( mData->mMachineState == MachineState_Saving
1358 || mData->mMachineState == MachineState_LiveSnapshotting)
1359 && mSnapshotData.mLastState != MachineState_Null
1360 && !mSnapshotData.mSnapshot.isNull()
1361 )
1362 , E_FAIL);
1363
1364 /*
1365 * Restore the state we had when BeginTakingSnapshot() was called,
1366 * Console::fntTakeSnapshotWorker restores its local copy when we return.
1367 * If the state was Running, then let Console::fntTakeSnapshotWorker it
1368 * all via Console::Resume().
1369 */
1370 if ( mData->mMachineState != mSnapshotData.mLastState
1371 && mSnapshotData.mLastState != MachineState_Running)
1372 setMachineState(mSnapshotData.mLastState);
1373
1374 return endTakingSnapshot(aSuccess);
1375}
1376
1377/**
1378 * Internal helper method to finalize taking a snapshot. Gets called from
1379 * SessionMachine::EndTakingSnapshot() to finalize the server-side
1380 * parts of snapshotting.
1381 *
1382 * This also gets called from SessionMachine::uninit() if an untaken
1383 * snapshot needs cleaning up.
1384 *
1385 * Expected to be called after completing *all* the tasks related to
1386 * taking the snapshot, either successfully or unsuccessfilly.
1387 *
1388 * @param aSuccess TRUE if the snapshot has been taken successfully.
1389 *
1390 * @note Locks this objects for writing.
1391 */
1392HRESULT SessionMachine::endTakingSnapshot(BOOL aSuccess)
1393{
1394 LogFlowThisFuncEnter();
1395
1396 AutoCaller autoCaller(this);
1397 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1398
1399 AutoMultiWriteLock2 alock(mParent, this);
1400 // saveSettings needs VirtualBox lock
1401
1402 AssertReturn(!mSnapshotData.mSnapshot.isNull(), E_FAIL);
1403
1404 MultiResult rc(S_OK);
1405
1406 ComObjPtr<Snapshot> pOldFirstSnap = mData->mFirstSnapshot;
1407 ComObjPtr<Snapshot> pOldCurrentSnap = mData->mCurrentSnapshot;
1408
1409 bool fOnline = Global::IsOnline(mSnapshotData.mLastState);
1410
1411 if (aSuccess)
1412 {
1413 // new snapshot becomes the current one
1414 mData->mCurrentSnapshot = mSnapshotData.mSnapshot;
1415
1416 /* memorize the first snapshot if necessary */
1417 if (!mData->mFirstSnapshot)
1418 mData->mFirstSnapshot = mData->mCurrentSnapshot;
1419
1420 if (!fOnline)
1421 /* the machine was powered off or saved when taking a snapshot, so
1422 * reset the mCurrentStateModified flag */
1423 mData->mCurrentStateModified = FALSE;
1424
1425 rc = saveSettings();
1426 }
1427
1428 if (aSuccess && SUCCEEDED(rc))
1429 {
1430 /* associate old hard disks with the snapshot and do locking/unlocking*/
1431 fixupMedia(true /* aCommit */, fOnline);
1432
1433 /* inform callbacks */
1434 mParent->onSnapshotTaken(mData->mUuid,
1435 mSnapshotData.mSnapshot->getId());
1436 }
1437 else
1438 {
1439 /* delete all differencing hard disks created (this will also attach
1440 * their parents back by rolling back mMediaData) */
1441 fixupMedia(false /* aCommit */);
1442
1443 mData->mFirstSnapshot = pOldFirstSnap; // might have been changed above
1444 mData->mCurrentSnapshot = pOldCurrentSnap; // might have been changed above
1445
1446 /* delete the saved state file (it might have been already created) */
1447 if (mSnapshotData.mSnapshot->stateFilePath().length())
1448 RTFileDelete(mSnapshotData.mSnapshot->stateFilePath().c_str());
1449
1450 mSnapshotData.mSnapshot->uninit();
1451 }
1452
1453 /* clear out the snapshot data */
1454 mSnapshotData.mLastState = MachineState_Null;
1455 mSnapshotData.mSnapshot.setNull();
1456
1457 LogFlowThisFuncLeave();
1458 return rc;
1459}
1460
1461////////////////////////////////////////////////////////////////////////////////
1462//
1463// RestoreSnapshot methods (SessionMachine and related tasks)
1464//
1465////////////////////////////////////////////////////////////////////////////////
1466
1467/**
1468 * Implementation for IInternalMachineControl::restoreSnapshot().
1469 *
1470 * Gets called from Console::RestoreSnapshot(), and that's basically the
1471 * only thing Console does. Restoring a snapshot happens entirely on the
1472 * server side since the machine cannot be running.
1473 *
1474 * This creates a new thread that does the work and returns a progress
1475 * object to the client which is then returned to the caller of
1476 * Console::RestoreSnapshot().
1477 *
1478 * Actual work then takes place in RestoreSnapshotTask::handler().
1479 *
1480 * @note Locks this + children objects for writing!
1481 *
1482 * @param aInitiator in: rhe console on which Console::RestoreSnapshot was called.
1483 * @param aSnapshot in: the snapshot to restore.
1484 * @param aMachineState in: client-side machine state.
1485 * @param aProgress out: progress object to monitor restore thread.
1486 * @return
1487 */
1488STDMETHODIMP SessionMachine::RestoreSnapshot(IConsole *aInitiator,
1489 ISnapshot *aSnapshot,
1490 MachineState_T *aMachineState,
1491 IProgress **aProgress)
1492{
1493 LogFlowThisFuncEnter();
1494
1495 AssertReturn(aInitiator, E_INVALIDARG);
1496 AssertReturn(aSnapshot && aMachineState && aProgress, E_POINTER);
1497
1498 AutoCaller autoCaller(this);
1499 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1500
1501 AutoWriteLock alock(this);
1502
1503 // machine must not be running
1504 ComAssertRet(!Global::IsOnlineOrTransient(mData->mMachineState),
1505 E_FAIL);
1506
1507 ComObjPtr<Snapshot> pSnapshot(static_cast<Snapshot*>(aSnapshot));
1508
1509 // create a progress object. The number of operations is:
1510 // 1 (preparing) + # of hard disks + 1 (if we need to copy the saved state file) */
1511 ComObjPtr<Progress> progress;
1512 progress.createObject();
1513
1514 LogFlowThisFunc(("Going thru snapshot machine attachments to determine progress setup\n"));
1515
1516 ULONG ulOpCount = 1; // one for preparations
1517 ULONG ulTotalWeight = 1; // one for preparations
1518 for (MediaData::AttachmentList::iterator it = pSnapshot->getSnapshotMachine()->mMediaData->mAttachments.begin();
1519 it != pSnapshot->getSnapshotMachine()->mMediaData->mAttachments.end();
1520 ++it)
1521 {
1522 ComObjPtr<MediumAttachment> &pAttach = *it;
1523 AutoReadLock attachLock(pAttach);
1524 if (pAttach->type() == DeviceType_HardDisk)
1525 {
1526 ++ulOpCount;
1527 ++ulTotalWeight; // assume one MB weight for each differencing hard disk to manage
1528 Assert(pAttach->medium());
1529 LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pAttach->medium()->name().c_str()));
1530 }
1531 }
1532
1533 ULONG ulStateFileSizeMB = 0;
1534 if (pSnapshot->stateFilePath().length())
1535 {
1536 ++ulOpCount; // one for the saved state
1537
1538 uint64_t ullSize;
1539 int irc = RTFileQuerySize(pSnapshot->stateFilePath().c_str(), &ullSize);
1540 if (!RT_SUCCESS(irc))
1541 // if we can't access the file here, then we'll be doomed later also, so fail right away
1542 setError(E_FAIL, tr("Cannot access state file '%s', runtime error, %Rra"), pSnapshot->stateFilePath().c_str(), irc);
1543 if (ullSize == 0) // avoid division by zero
1544 ullSize = _1M;
1545
1546 ulStateFileSizeMB = (ULONG)(ullSize / _1M);
1547 LogFlowThisFunc(("op %d: saved state file '%s' has %RI64 bytes (%d MB)\n",
1548 ulOpCount, pSnapshot->stateFilePath().raw(), ullSize, ulStateFileSizeMB));
1549
1550 ulTotalWeight += ulStateFileSizeMB;
1551 }
1552
1553 progress->init(mParent, aInitiator,
1554 Bstr(tr("Restoring snapshot")),
1555 FALSE /* aCancelable */,
1556 ulOpCount,
1557 ulTotalWeight,
1558 Bstr(tr("Restoring machine settings")),
1559 1);
1560
1561 /* create and start the task on a separate thread (note that it will not
1562 * start working until we release alock) */
1563 RestoreSnapshotTask *task = new RestoreSnapshotTask(this,
1564 progress,
1565 pSnapshot,
1566 ulStateFileSizeMB);
1567 int vrc = RTThreadCreate(NULL,
1568 taskHandler,
1569 (void*)task,
1570 0,
1571 RTTHREADTYPE_MAIN_WORKER,
1572 0,
1573 "RestoreSnap");
1574 if (RT_FAILURE(vrc))
1575 {
1576 delete task;
1577 ComAssertRCRet(vrc, E_FAIL);
1578 }
1579
1580 /* set the proper machine state (note: after creating a Task instance) */
1581 setMachineState(MachineState_RestoringSnapshot);
1582
1583 /* return the progress to the caller */
1584 progress.queryInterfaceTo(aProgress);
1585
1586 /* return the new state to the caller */
1587 *aMachineState = mData->mMachineState;
1588
1589 LogFlowThisFuncLeave();
1590
1591 return S_OK;
1592}
1593
1594/**
1595 * Worker method for the restore snapshot thread created by SessionMachine::RestoreSnapshot().
1596 * This method gets called indirectly through SessionMachine::taskHandler() which then
1597 * calls RestoreSnapshotTask::handler().
1598 *
1599 * The RestoreSnapshotTask contains the progress object returned to the console by
1600 * SessionMachine::RestoreSnapshot, through which progress and results are reported.
1601 *
1602 * @note Locks mParent + this object for writing.
1603 *
1604 * @param aTask Task data.
1605 */
1606void SessionMachine::restoreSnapshotHandler(RestoreSnapshotTask &aTask)
1607{
1608 LogFlowThisFuncEnter();
1609
1610 AutoCaller autoCaller(this);
1611
1612 LogFlowThisFunc(("state=%d\n", autoCaller.state()));
1613 if (!autoCaller.isOk())
1614 {
1615 /* we might have been uninitialized because the session was accidentally
1616 * closed by the client, so don't assert */
1617 aTask.pProgress->notifyComplete(E_FAIL,
1618 COM_IIDOF(IMachine),
1619 getComponentName(),
1620 tr("The session has been accidentally closed"));
1621
1622 LogFlowThisFuncLeave();
1623 return;
1624 }
1625
1626 /* saveSettings() needs mParent lock */
1627 AutoWriteLock vboxLock(mParent);
1628
1629 /* @todo We don't need mParent lock so far so unlock() it. Better is to
1630 * provide an AutoWriteLock argument that lets create a non-locking
1631 * instance */
1632 vboxLock.unlock();
1633
1634 AutoWriteLock alock(this);
1635
1636 /* discard all current changes to mUserData (name, OSType etc.) (note that
1637 * the machine is powered off, so there is no need to inform the direct
1638 * session) */
1639 if (isModified())
1640 rollback(false /* aNotify */);
1641
1642 HRESULT rc = S_OK;
1643
1644 bool stateRestored = false;
1645
1646 try
1647 {
1648 /* discard the saved state file if the machine was Saved prior to this
1649 * operation */
1650 if (aTask.machineStateBackup == MachineState_Saved)
1651 {
1652 Assert(!mSSData->mStateFilePath.isEmpty());
1653 RTFileDelete(mSSData->mStateFilePath.c_str());
1654 mSSData->mStateFilePath.setNull();
1655 aTask.modifyBackedUpState(MachineState_PoweredOff);
1656 rc = saveStateSettings(SaveSTS_StateFilePath);
1657 CheckComRCThrowRC(rc);
1658 }
1659
1660 RTTIMESPEC snapshotTimeStamp;
1661 RTTimeSpecSetMilli(&snapshotTimeStamp, 0);
1662
1663 {
1664 AutoReadLock snapshotLock(aTask.pSnapshot);
1665
1666 /* remember the timestamp of the snapshot we're restoring from */
1667 snapshotTimeStamp = aTask.pSnapshot->getTimeStamp();
1668
1669 ComPtr<SnapshotMachine> pSnapshotMachine(aTask.pSnapshot->getSnapshotMachine());
1670
1671 /* copy all hardware data from the snapshot */
1672 copyFrom(pSnapshotMachine);
1673
1674 LogFlowThisFunc(("Restoring hard disks from the snapshot...\n"));
1675
1676 /* restore the attachments from the snapshot */
1677 mMediaData.backup();
1678 mMediaData->mAttachments = pSnapshotMachine->mMediaData->mAttachments;
1679
1680 /* leave the locks before the potentially lengthy operation */
1681 snapshotLock.unlock();
1682 alock.leave();
1683
1684 rc = createImplicitDiffs(mUserData->mSnapshotFolderFull,
1685 aTask.pProgress,
1686 1,
1687 false /* aOnline */);
1688
1689 alock.enter();
1690 snapshotLock.lock();
1691
1692 CheckComRCThrowRC(rc);
1693
1694 /* Note: on success, current (old) hard disks will be
1695 * deassociated/deleted on #commit() called from #saveSettings() at
1696 * the end. On failure, newly created implicit diffs will be
1697 * deleted by #rollback() at the end. */
1698
1699 /* should not have a saved state file associated at this point */
1700 Assert(mSSData->mStateFilePath.isEmpty());
1701
1702 if (!aTask.pSnapshot->stateFilePath().isEmpty())
1703 {
1704 Utf8Str snapStateFilePath = aTask.pSnapshot->stateFilePath();
1705
1706 Utf8Str stateFilePath = Utf8StrFmt("%ls%c{%RTuuid}.sav",
1707 mUserData->mSnapshotFolderFull.raw(),
1708 RTPATH_DELIMITER,
1709 mData->mUuid.raw());
1710
1711 LogFlowThisFunc(("Copying saved state file from '%s' to '%s'...\n",
1712 snapStateFilePath.raw(), stateFilePath.raw()));
1713
1714 aTask.pProgress->SetNextOperation(Bstr(tr("Restoring the execution state")),
1715 aTask.m_ulStateFileSizeMB); // weight
1716
1717 /* leave the lock before the potentially lengthy operation */
1718 snapshotLock.unlock();
1719 alock.leave();
1720
1721 /* copy the state file */
1722 int vrc = RTFileCopyEx(snapStateFilePath.c_str(),
1723 stateFilePath.c_str(),
1724 0,
1725 progressCallback,
1726 aTask.pProgress);
1727
1728 alock.enter();
1729 snapshotLock.lock();
1730
1731 if (RT_SUCCESS(vrc))
1732 mSSData->mStateFilePath = stateFilePath;
1733 else
1734 throw setError(E_FAIL,
1735 tr("Could not copy the state file '%s' to '%s' (%Rrc)"),
1736 snapStateFilePath.raw(),
1737 stateFilePath.raw(),
1738 vrc);
1739 }
1740
1741 LogFlowThisFunc(("Setting new current snapshot {%RTuuid}\n", aTask.pSnapshot->getId().raw()));
1742 /* make the snapshot we restored from the current snapshot */
1743 mData->mCurrentSnapshot = aTask.pSnapshot;
1744 }
1745
1746 /* grab differencing hard disks from the old attachments that will
1747 * become unused and need to be auto-deleted */
1748
1749 std::list< ComObjPtr<MediumAttachment> > llDiffAttachmentsToDelete;
1750
1751 for (MediaData::AttachmentList::const_iterator it = mMediaData.backedUpData()->mAttachments.begin();
1752 it != mMediaData.backedUpData()->mAttachments.end();
1753 ++it)
1754 {
1755 ComObjPtr<MediumAttachment> pAttach = *it;
1756 ComObjPtr<Medium> pMedium = pAttach->medium();
1757
1758 /* while the hard disk is attached, the number of children or the
1759 * parent cannot change, so no lock */
1760 if ( !pMedium.isNull()
1761 && pAttach->type() == DeviceType_HardDisk
1762 && !pMedium->parent().isNull()
1763 && pMedium->children().size() == 0
1764 )
1765 {
1766 LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->name().raw()));
1767
1768 llDiffAttachmentsToDelete.push_back(pAttach);
1769 }
1770 }
1771
1772 int saveFlags = 0;
1773
1774 /* @todo saveSettings() below needs a VirtualBox write lock and we need
1775 * to leave this object's lock to do this to follow the {parent-child}
1776 * locking rule. This is the last chance to do that while we are still
1777 * in a protective state which allows us to temporarily leave the lock*/
1778 alock.unlock();
1779 vboxLock.lock();
1780 alock.lock();
1781
1782 /* we have already discarded the current state, so set the execution
1783 * state accordingly no matter of the discard snapshot result */
1784 if (!mSSData->mStateFilePath.isEmpty())
1785 setMachineState(MachineState_Saved);
1786 else
1787 setMachineState(MachineState_PoweredOff);
1788
1789 updateMachineStateOnClient();
1790 stateRestored = true;
1791
1792 /* assign the timestamp from the snapshot */
1793 Assert(RTTimeSpecGetMilli (&snapshotTimeStamp) != 0);
1794 mData->mLastStateChange = snapshotTimeStamp;
1795
1796 // detach the current-state diffs that we detected above and build a list of
1797 // images to delete _after_ saveSettings()
1798
1799 std::list< ComObjPtr<Medium> > llDiffsToDelete;
1800
1801 for (std::list< ComObjPtr<MediumAttachment> >::iterator it = llDiffAttachmentsToDelete.begin();
1802 it != llDiffAttachmentsToDelete.end();
1803 ++it)
1804 {
1805 ComObjPtr<MediumAttachment> pAttach = *it; // guaranteed to have only attachments where medium != NULL
1806 ComObjPtr<Medium> pMedium = pAttach->medium();
1807
1808 AutoWriteLock mlock(pMedium);
1809
1810 LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->name().raw()));
1811
1812 mMediaData->mAttachments.remove(pAttach);
1813 pMedium->detachFrom(mData->mUuid);
1814
1815 llDiffsToDelete.push_back(pMedium);
1816 }
1817
1818 // save all settings, reset the modified flag and commit;
1819 rc = saveSettings(SaveS_ResetCurStateModified | saveFlags);
1820 CheckComRCThrowRC(rc);
1821 // from here on we cannot roll back on failure any more
1822
1823 for (std::list< ComObjPtr<Medium> >::iterator it = llDiffsToDelete.begin();
1824 it != llDiffsToDelete.end();
1825 ++it)
1826 {
1827 ComObjPtr<Medium> &pMedium = *it;
1828 LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->name().raw()));
1829
1830 HRESULT rc2 = pMedium->deleteStorageAndWait();
1831 // ignore errors here because we cannot roll back after saveSettings() above
1832 if (SUCCEEDED(rc2))
1833 pMedium->uninit();
1834 }
1835 }
1836 catch (HRESULT aRC)
1837 {
1838 rc = aRC;
1839 }
1840
1841 if (FAILED(rc))
1842 {
1843 /* preserve existing error info */
1844 ErrorInfoKeeper eik;
1845
1846 /* undo all changes on failure */
1847 rollback(false /* aNotify */);
1848
1849 if (!stateRestored)
1850 {
1851 /* restore the machine state */
1852 setMachineState(aTask.machineStateBackup);
1853 updateMachineStateOnClient();
1854 }
1855 }
1856
1857 /* set the result (this will try to fetch current error info on failure) */
1858 aTask.pProgress->notifyComplete(rc);
1859
1860 if (SUCCEEDED(rc))
1861 mParent->onSnapshotDeleted(mData->mUuid, Guid());
1862
1863 LogFlowThisFunc(("Done restoring snapshot (rc=%08X)\n", rc));
1864
1865 LogFlowThisFuncLeave();
1866}
1867
1868////////////////////////////////////////////////////////////////////////////////
1869//
1870// DeleteSnapshot methods (SessionMachine and related tasks)
1871//
1872////////////////////////////////////////////////////////////////////////////////
1873
1874/**
1875 * Implementation for IInternalMachineControl::deleteSnapshot().
1876 *
1877 * Gets called from Console::DeleteSnapshot(), and that's basically the
1878 * only thing Console does. Deleting a snapshot happens entirely on the
1879 * server side since the machine cannot be running.
1880 *
1881 * This creates a new thread that does the work and returns a progress
1882 * object to the client which is then returned to the caller of
1883 * Console::DeleteSnapshot().
1884 *
1885 * Actual work then takes place in DeleteSnapshotTask::handler().
1886 *
1887 * @note Locks mParent + this + children objects for writing!
1888 */
1889STDMETHODIMP SessionMachine::DeleteSnapshot(IConsole *aInitiator,
1890 IN_BSTR aId,
1891 MachineState_T *aMachineState,
1892 IProgress **aProgress)
1893{
1894 LogFlowThisFuncEnter();
1895
1896 Guid id(aId);
1897 AssertReturn(aInitiator && !id.isEmpty(), E_INVALIDARG);
1898 AssertReturn(aMachineState && aProgress, E_POINTER);
1899
1900 AutoCaller autoCaller(this);
1901 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
1902
1903 /* saveSettings() needs mParent lock */
1904 AutoMultiWriteLock2 alock(mParent, this);
1905
1906 // machine must not be running
1907 ComAssertRet(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
1908
1909 AutoWriteLock treeLock(snapshotsTreeLockHandle());
1910
1911 ComObjPtr<Snapshot> snapshot;
1912 HRESULT rc = findSnapshot(id, snapshot, true /* aSetError */);
1913 CheckComRCReturnRC(rc);
1914
1915 AutoWriteLock snapshotLock(snapshot);
1916
1917 size_t childrenCount = snapshot->getChildrenCount();
1918 if (childrenCount > 1)
1919 return setError(VBOX_E_INVALID_OBJECT_STATE,
1920 tr("Snapshot '%s' of the machine '%ls' cannot be deleted. because it has %d child snapshots, which is more than the one snapshot allowed for deletion"),
1921 snapshot->getName().c_str(),
1922 mUserData->mName.raw(),
1923 childrenCount);
1924
1925 /* If the snapshot being discarded is the current one, ensure current
1926 * settings are committed and saved.
1927 */
1928 if (snapshot == mData->mCurrentSnapshot)
1929 {
1930 if (isModified())
1931 {
1932 rc = saveSettings();
1933 CheckComRCReturnRC(rc);
1934 }
1935 }
1936
1937 /* create a progress object. The number of operations is:
1938 * 1 (preparing) + # of hard disks + 1 if the snapshot is online
1939 */
1940 ComObjPtr<Progress> progress;
1941 progress.createObject();
1942 rc = progress->init(mParent, aInitiator,
1943 BstrFmt(tr("Discarding snapshot '%s'"),
1944 snapshot->getName().c_str()),
1945 FALSE /* aCancelable */,
1946 1 + (ULONG)snapshot->getSnapshotMachine()->mMediaData->mAttachments.size()
1947 + (snapshot->stateFilePath().length() ? 1 : 0),
1948 Bstr(tr("Preparing to discard snapshot")));
1949 AssertComRCReturn(rc, rc);
1950
1951 /* create and start the task on a separate thread */
1952 DeleteSnapshotTask *task = new DeleteSnapshotTask(this, progress, snapshot);
1953 int vrc = RTThreadCreate(NULL,
1954 taskHandler,
1955 (void*)task,
1956 0,
1957 RTTHREADTYPE_MAIN_WORKER,
1958 0,
1959 "DeleteSnapshot");
1960 if (RT_FAILURE(vrc))
1961 {
1962 delete task;
1963 return E_FAIL;
1964 }
1965
1966 /* set the proper machine state (note: after creating a Task instance) */
1967 setMachineState(MachineState_DeletingSnapshot);
1968
1969 /* return the progress to the caller */
1970 progress.queryInterfaceTo(aProgress);
1971
1972 /* return the new state to the caller */
1973 *aMachineState = mData->mMachineState;
1974
1975 LogFlowThisFuncLeave();
1976
1977 return S_OK;
1978}
1979
1980/**
1981 * Helper struct for SessionMachine::deleteSnapshotHandler().
1982 */
1983struct MediumDiscardRec
1984{
1985 MediumDiscardRec()
1986 : chain(NULL)
1987 {}
1988
1989 MediumDiscardRec(const ComObjPtr<Medium> &aHd,
1990 Medium::MergeChain *aChain = NULL)
1991 : hd(aHd),
1992 chain(aChain)
1993 {}
1994
1995 MediumDiscardRec(const ComObjPtr<Medium> &aHd,
1996 Medium::MergeChain *aChain,
1997 const ComObjPtr<Medium> &aReplaceHd,
1998 const ComObjPtr<MediumAttachment> &aReplaceHda,
1999 const Guid &aSnapshotId)
2000 : hd(aHd),
2001 chain(aChain),
2002 replaceHd(aReplaceHd),
2003 replaceHda(aReplaceHda),
2004 snapshotId(aSnapshotId)
2005 {}
2006
2007 ComObjPtr<Medium> hd;
2008 Medium::MergeChain *chain;
2009 /* these are for the replace hard disk case: */
2010 ComObjPtr<Medium> replaceHd;
2011 ComObjPtr<MediumAttachment> replaceHda;
2012 Guid snapshotId;
2013};
2014
2015typedef std::list <MediumDiscardRec> MediumDiscardRecList;
2016
2017/**
2018 * Worker method for the delete snapshot thread created by SessionMachine::DeleteSnapshot().
2019 * This method gets called indirectly through SessionMachine::taskHandler() which then
2020 * calls DeleteSnapshotTask::handler().
2021 *
2022 * The DeleteSnapshotTask contains the progress object returned to the console by
2023 * SessionMachine::DeleteSnapshot, through which progress and results are reported.
2024 *
2025 * @note Locks mParent + this + child objects for writing!
2026 *
2027 * @param aTask Task data.
2028 */
2029void SessionMachine::deleteSnapshotHandler(DeleteSnapshotTask &aTask)
2030{
2031 LogFlowThisFuncEnter();
2032
2033 AutoCaller autoCaller(this);
2034
2035 LogFlowThisFunc(("state=%d\n", autoCaller.state()));
2036 if (!autoCaller.isOk())
2037 {
2038 /* we might have been uninitialized because the session was accidentally
2039 * closed by the client, so don't assert */
2040 aTask.pProgress->notifyComplete(E_FAIL,
2041 COM_IIDOF(IMachine),
2042 getComponentName(),
2043 tr("The session has been accidentally closed"));
2044 LogFlowThisFuncLeave();
2045 return;
2046 }
2047
2048 /* Locking order: */
2049 AutoMultiWriteLock3 alock(this->lockHandle(),
2050 this->snapshotsTreeLockHandle(),
2051 aTask.pSnapshot->lockHandle());
2052
2053 ComPtr<SnapshotMachine> sm = aTask.pSnapshot->getSnapshotMachine();
2054 /* no need to lock the snapshot machine since it is const by definiton */
2055
2056 HRESULT rc = S_OK;
2057
2058 /* save the snapshot ID (for callbacks) */
2059 Guid snapshotId = aTask.pSnapshot->getId();
2060
2061 MediumDiscardRecList toDiscard;
2062
2063 bool settingsChanged = false;
2064
2065 try
2066 {
2067 /* first pass: */
2068 LogFlowThisFunc(("1: Checking hard disk merge prerequisites...\n"));
2069
2070 for (MediaData::AttachmentList::const_iterator it = sm->mMediaData->mAttachments.begin();
2071 it != sm->mMediaData->mAttachments.end();
2072 ++it)
2073 {
2074 ComObjPtr<MediumAttachment> hda = *it;
2075 ComObjPtr<Medium> hd = hda->medium();
2076
2077 // medium can be NULL only for non-hard-disk types
2078 Assert( !hd.isNull()
2079 || hda->type() != DeviceType_HardDisk);
2080 if (hd.isNull())
2081 continue;
2082
2083 /* Medium::prepareDiscard() reqiuires a write lock */
2084 AutoWriteLock hdLock(hd);
2085
2086 if (hd->type() != MediumType_Normal)
2087 {
2088 /* skip writethrough hard disks */
2089 Assert(hd->type() == MediumType_Writethrough);
2090 rc = aTask.pProgress->SetNextOperation(BstrFmt(tr("Skipping writethrough hard disk '%s'"),
2091 hd->base()->name().raw()),
2092 1); // weight
2093 CheckComRCThrowRC(rc);
2094 continue;
2095 }
2096
2097 Medium::MergeChain *chain = NULL;
2098
2099 /* needs to be discarded (merged with the child if any), check
2100 * prerequisites */
2101 rc = hd->prepareDiscard(chain);
2102 CheckComRCThrowRC(rc);
2103
2104 if (hd->parent().isNull() && chain != NULL)
2105 {
2106 /* it's a base hard disk so it will be a backward merge of its
2107 * only child to it (prepareDiscard() does necessary checks). We
2108 * need then to update the attachment that refers to the child
2109 * to refer to the parent instead. Don't forget to detach the
2110 * child (otherwise mergeTo() called by discard() will assert
2111 * because it will be going to delete the child) */
2112
2113 /* The below assert would be nice but I don't want to move
2114 * Medium::MergeChain to the header just for that
2115 * Assert (!chain->isForward()); */
2116
2117 Assert(hd->children().size() == 1);
2118
2119 ComObjPtr<Medium> replaceHd = hd->children().front();
2120
2121 const Guid *pReplaceMachineId = replaceHd->getFirstMachineBackrefId();
2122 Assert(pReplaceMachineId && *pReplaceMachineId == mData->mUuid);
2123
2124 Guid snapshotId;
2125 const Guid *pSnapshotId = replaceHd->getFirstMachineBackrefSnapshotId();
2126 if (pSnapshotId)
2127 snapshotId = *pSnapshotId;
2128
2129 HRESULT rc2 = S_OK;
2130
2131 /* adjust back references */
2132 rc2 = replaceHd->detachFrom (mData->mUuid, snapshotId);
2133 AssertComRC(rc2);
2134
2135 rc2 = hd->attachTo (mData->mUuid, snapshotId);
2136 AssertComRC(rc2);
2137
2138 /* replace the hard disk in the attachment object */
2139 if (snapshotId.isEmpty())
2140 {
2141 /* in current state */
2142 AssertBreak(hda = findAttachment(mMediaData->mAttachments, replaceHd));
2143 }
2144 else
2145 {
2146 /* in snapshot */
2147 ComObjPtr<Snapshot> snapshot;
2148 rc2 = findSnapshot(snapshotId, snapshot);
2149 AssertComRC(rc2);
2150
2151 /* don't lock the snapshot; cannot be modified outside */
2152 MediaData::AttachmentList &snapAtts = snapshot->getSnapshotMachine()->mMediaData->mAttachments;
2153 AssertBreak(hda = findAttachment(snapAtts, replaceHd));
2154 }
2155
2156 AutoWriteLock attLock(hda);
2157 hda->updateMedium(hd, false /* aImplicit */);
2158
2159 toDiscard.push_back(MediumDiscardRec(hd,
2160 chain,
2161 replaceHd,
2162 hda,
2163 snapshotId));
2164 continue;
2165 }
2166
2167 toDiscard.push_back(MediumDiscardRec(hd, chain));
2168 }
2169
2170 /* Now we checked that we can successfully merge all normal hard disks
2171 * (unless a runtime error like end-of-disc happens). Prior to
2172 * performing the actual merge, we want to discard the snapshot itself
2173 * and remove it from the XML file to make sure that a possible merge
2174 * ruintime error will not make this snapshot inconsistent because of
2175 * the partially merged or corrupted hard disks */
2176
2177 /* second pass: */
2178 LogFlowThisFunc(("2: Discarding snapshot...\n"));
2179
2180 {
2181 ComObjPtr<Snapshot> parentSnapshot = aTask.pSnapshot->parent();
2182 Utf8Str stateFilePath = aTask.pSnapshot->stateFilePath();
2183
2184 /* Note that discarding the snapshot will deassociate it from the
2185 * hard disks which will allow the merge+delete operation for them*/
2186 aTask.pSnapshot->beginDiscard();
2187 aTask.pSnapshot->uninit();
2188
2189 rc = saveAllSnapshots();
2190 CheckComRCThrowRC(rc);
2191
2192 /// @todo (dmik)
2193 // if we implement some warning mechanism later, we'll have
2194 // to return a warning if the state file path cannot be deleted
2195 if (!stateFilePath.isEmpty())
2196 {
2197 aTask.pProgress->SetNextOperation(Bstr(tr("Discarding the execution state")),
2198 1); // weight
2199
2200 RTFileDelete(stateFilePath.c_str());
2201 }
2202
2203 /// @todo NEWMEDIA to provide a good level of fauilt tolerance, we
2204 /// should restore the shapshot in the snapshot tree if
2205 /// saveSnapshotSettings fails. Actually, we may call
2206 /// #saveSnapshotSettings() with a special flag that will tell it to
2207 /// skip the given snapshot as if it would have been discarded and
2208 /// only actually discard it if the save operation succeeds.
2209 }
2210
2211 /* here we come when we've irrevesibly discarded the snapshot which
2212 * means that the VM settigns (our relevant changes to mData) need to be
2213 * saved too */
2214 /// @todo NEWMEDIA maybe save everything in one operation in place of
2215 /// saveSnapshotSettings() above
2216 settingsChanged = true;
2217
2218 /* third pass: */
2219 LogFlowThisFunc(("3: Performing actual hard disk merging...\n"));
2220
2221 /* leave the locks before the potentially lengthy operation */
2222 alock.leave();
2223
2224 /// @todo NEWMEDIA turn the following errors into warnings because the
2225 /// snapshot itself has been already deleted (and interpret these
2226 /// warnings properly on the GUI side)
2227
2228 for (MediumDiscardRecList::iterator it = toDiscard.begin();
2229 it != toDiscard.end();)
2230 {
2231 rc = it->hd->discard(aTask.pProgress, it->chain);
2232 CheckComRCBreakRC(rc);
2233
2234 /* prevent from calling cancelDiscard() */
2235 it = toDiscard.erase (it);
2236 }
2237
2238 alock.enter();
2239
2240 CheckComRCThrowRC(rc);
2241 }
2242 catch (HRESULT aRC) { rc = aRC; }
2243
2244 if (FAILED(rc))
2245 {
2246 HRESULT rc2 = S_OK;
2247
2248 /* un-prepare the remaining hard disks */
2249 for (MediumDiscardRecList::const_iterator it = toDiscard.begin();
2250 it != toDiscard.end(); ++it)
2251 {
2252 it->hd->cancelDiscard (it->chain);
2253
2254 if (!it->replaceHd.isNull())
2255 {
2256 /* undo hard disk replacement */
2257
2258 rc2 = it->replaceHd->attachTo (mData->mUuid, it->snapshotId);
2259 AssertComRC(rc2);
2260
2261 rc2 = it->hd->detachFrom (mData->mUuid, it->snapshotId);
2262 AssertComRC(rc2);
2263
2264 AutoWriteLock attLock (it->replaceHda);
2265 it->replaceHda->updateMedium(it->replaceHd, false /* aImplicit */);
2266 }
2267 }
2268 }
2269
2270 if (FAILED(rc))
2271 {
2272 /* saveSettings() below needs a VirtualBox write lock and we need to
2273 * leave this object's lock to do this to follow the {parent-child}
2274 * locking rule. This is the last chance to do that while we are
2275 * still in a protective state which allows us to temporarily leave
2276 * the lock */
2277 alock.unlock();
2278 AutoWriteLock vboxLock(mParent);
2279 alock.lock();
2280
2281 /* preserve existing error info */
2282 ErrorInfoKeeper eik;
2283
2284 /* restore the machine state */
2285 setMachineState(aTask.machineStateBackup);
2286 updateMachineStateOnClient();
2287
2288 if (settingsChanged)
2289 saveSettings(SaveS_InformCallbacksAnyway);
2290
2291 /* set the result (this will try to fetch current error info on failure) */
2292 aTask.pProgress->notifyComplete(rc);
2293 }
2294
2295 if (SUCCEEDED(rc))
2296 mParent->onSnapshotDeleted(mData->mUuid, snapshotId);
2297
2298 LogFlowThisFunc(("Done deleting snapshot (rc=%08X)\n", rc));
2299 LogFlowThisFuncLeave();
2300}
2301
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