VirtualBox

source: vbox/trunk/src/VBox/Main/src-server/SnapshotImpl.cpp@ 91326

最後變更 在這個檔案從91326是 91326,由 vboxsync 提交於 3 年 前

Main/NvramStore,FE/VBoxManage: Allow multiple NVRAM states (UEFI,TPM,etc.) to exist for a VM and and manage them in a central place. This allows to collect them in a single tar archive and provide a single interface to get access to the individual states (work in progress), bugref:10098

  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 159.4 KB
 
1/* $Id: SnapshotImpl.cpp 91326 2021-09-22 15:10:38Z vboxsync $ */
2/** @file
3 * COM class implementation for Snapshot and SnapshotMachine in VBoxSVC.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.alldomusa.eu.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
18#define LOG_GROUP LOG_GROUP_MAIN_SNAPSHOT
19#include <set>
20#include <map>
21
22#include "SnapshotImpl.h"
23#include "LoggingNew.h"
24
25#include "MachineImpl.h"
26#include "MediumImpl.h"
27#include "MediumFormatImpl.h"
28#include "Global.h"
29#include "ProgressImpl.h"
30
31/// @todo these three includes are required for about one or two lines, try
32// to remove them and put that code in shared code in MachineImplcpp
33#include "SharedFolderImpl.h"
34#include "USBControllerImpl.h"
35#include "USBDeviceFiltersImpl.h"
36#include "VirtualBoxImpl.h"
37
38#include "AutoCaller.h"
39#include "VBox/com/MultiResult.h"
40
41#include <iprt/path.h>
42#include <iprt/cpp/utils.h>
43
44#include <VBox/param.h>
45#include <iprt/errcore.h>
46
47#include <VBox/settings.h>
48
49////////////////////////////////////////////////////////////////////////////////
50//
51// Snapshot private data definition
52//
53////////////////////////////////////////////////////////////////////////////////
54
55typedef std::list< ComObjPtr<Snapshot> > SnapshotsList;
56
57struct Snapshot::Data
58{
59 Data()
60 : pVirtualBox(NULL)
61 {
62 RTTimeSpecSetMilli(&timeStamp, 0);
63 };
64
65 ~Data()
66 {}
67
68 const Guid uuid;
69 Utf8Str strName;
70 Utf8Str strDescription;
71 RTTIMESPEC timeStamp;
72 ComObjPtr<SnapshotMachine> pMachine;
73
74 /** weak VirtualBox parent */
75 VirtualBox * const pVirtualBox;
76
77 // pParent and llChildren are protected by the machine lock
78 ComObjPtr<Snapshot> pParent;
79 SnapshotsList llChildren;
80};
81
82////////////////////////////////////////////////////////////////////////////////
83//
84// Constructor / destructor
85//
86////////////////////////////////////////////////////////////////////////////////
87DEFINE_EMPTY_CTOR_DTOR(Snapshot)
88
89HRESULT Snapshot::FinalConstruct()
90{
91 LogFlowThisFunc(("\n"));
92 return BaseFinalConstruct();
93}
94
95void Snapshot::FinalRelease()
96{
97 LogFlowThisFunc(("\n"));
98 uninit();
99 BaseFinalRelease();
100}
101
102/**
103 * Initializes the instance
104 *
105 * @param aVirtualBox VirtualBox object
106 * @param aId id of the snapshot
107 * @param aName name of the snapshot
108 * @param aDescription name of the snapshot (NULL if no description)
109 * @param aTimeStamp timestamp of the snapshot, in ms since 1970-01-01 UTC
110 * @param aMachine machine associated with this snapshot
111 * @param aParent parent snapshot (NULL if no parent)
112 */
113HRESULT Snapshot::init(VirtualBox *aVirtualBox,
114 const Guid &aId,
115 const Utf8Str &aName,
116 const Utf8Str &aDescription,
117 const RTTIMESPEC &aTimeStamp,
118 SnapshotMachine *aMachine,
119 Snapshot *aParent)
120{
121 LogFlowThisFunc(("uuid=%s aParent->uuid=%s\n", aId.toString().c_str(), (aParent) ? aParent->m->uuid.toString().c_str() : ""));
122
123 ComAssertRet(!aId.isZero() && aId.isValid() && aMachine, E_INVALIDARG);
124
125 /* Enclose the state transition NotReady->InInit->Ready */
126 AutoInitSpan autoInitSpan(this);
127 AssertReturn(autoInitSpan.isOk(), E_FAIL);
128
129 m = new Data;
130
131 /* share parent weakly */
132 unconst(m->pVirtualBox) = aVirtualBox;
133
134 m->pParent = aParent;
135
136 unconst(m->uuid) = aId;
137 m->strName = aName;
138 m->strDescription = aDescription;
139 m->timeStamp = aTimeStamp;
140 m->pMachine = aMachine;
141
142 if (aParent)
143 aParent->m->llChildren.push_back(this);
144
145 /* Confirm a successful initialization when it's the case */
146 autoInitSpan.setSucceeded();
147
148 return S_OK;
149}
150
151/**
152 * Uninitializes the instance and sets the ready flag to FALSE.
153 * Called either from FinalRelease(), by the parent when it gets destroyed,
154 * or by a third party when it decides this object is no more valid.
155 *
156 * Since this manipulates the snapshots tree, the caller must hold the
157 * machine lock in write mode (which protects the snapshots tree)!
158 */
159void Snapshot::uninit()
160{
161 LogFlowThisFunc(("\n"));
162
163 /* Enclose the state transition Ready->InUninit->NotReady */
164 AutoUninitSpan autoUninitSpan(this);
165 if (autoUninitSpan.uninitDone())
166 return;
167
168 Assert(m->pMachine->isWriteLockOnCurrentThread());
169
170 // uninit all children
171 SnapshotsList::iterator it;
172 for (it = m->llChildren.begin();
173 it != m->llChildren.end();
174 ++it)
175 {
176 Snapshot *pChild = *it;
177 pChild->m->pParent.setNull();
178 pChild->uninit();
179 }
180 m->llChildren.clear(); // this unsets all the ComPtrs and probably calls delete
181
182 // since there is no guarantee anyone holds a reference to us except the
183 // list of children in our parent, make sure that the reference count
184 // will not drop to 0 before we've declared ourselves as uninitialized,
185 // otherwise there will be another uninit call which causes a self-deadlock
186 // because this uninit isn't complete yet.
187 ComObjPtr<Snapshot> pSnapshot(this);
188 if (m->pParent)
189 i_deparent();
190
191 if (m->pMachine)
192 {
193 m->pMachine->uninit();
194 m->pMachine.setNull();
195 }
196
197 delete m;
198 m = NULL;
199
200 autoUninitSpan.setSucceeded();
201 // see above, now the refcount may reach 0
202 pSnapshot.setNull();
203}
204
205/**
206 * Delete the current snapshot by removing it from the tree of snapshots
207 * and reparenting its children.
208 *
209 * After this, the caller must call uninit() on the snapshot. We can't call
210 * that from here because if we do, the AutoUninitSpan waits forever for
211 * the number of callers to become 0 (it is 1 because of the AutoCaller in here).
212 *
213 * NOTE: this does NOT lock the snapshot, it is assumed that the machine state
214 * (and the snapshots tree) is protected by the caller having requested the machine
215 * lock in write mode AND the machine state must be DeletingSnapshot.
216 */
217void Snapshot::i_beginSnapshotDelete()
218{
219 AutoCaller autoCaller(this);
220 if (FAILED(autoCaller.rc()))
221 return;
222
223 // caller must have acquired the machine's write lock
224 Assert( m->pMachine->mData->mMachineState == MachineState_DeletingSnapshot
225 || m->pMachine->mData->mMachineState == MachineState_DeletingSnapshotOnline
226 || m->pMachine->mData->mMachineState == MachineState_DeletingSnapshotPaused);
227 Assert(m->pMachine->isWriteLockOnCurrentThread());
228
229 // the snapshot must have only one child when being deleted or no children at all
230 AssertReturnVoid(m->llChildren.size() <= 1);
231
232 ComObjPtr<Snapshot> parentSnapshot = m->pParent;
233
234 /// @todo (dmik):
235 // when we introduce clones later, deleting the snapshot will affect
236 // the current and first snapshots of clones, if they are direct children
237 // of this snapshot. So we will need to lock machines associated with
238 // child snapshots as well and update mCurrentSnapshot and/or
239 // mFirstSnapshot fields.
240
241 if (this == m->pMachine->mData->mCurrentSnapshot)
242 {
243 m->pMachine->mData->mCurrentSnapshot = parentSnapshot;
244
245 /* we've changed the base of the current state so mark it as
246 * modified as it no longer guaranteed to be its copy */
247 m->pMachine->mData->mCurrentStateModified = TRUE;
248 }
249
250 if (this == m->pMachine->mData->mFirstSnapshot)
251 {
252 if (m->llChildren.size() == 1)
253 {
254 ComObjPtr<Snapshot> childSnapshot = m->llChildren.front();
255 m->pMachine->mData->mFirstSnapshot = childSnapshot;
256 }
257 else
258 m->pMachine->mData->mFirstSnapshot.setNull();
259 }
260
261 // reparent our children
262 for (SnapshotsList::const_iterator it = m->llChildren.begin();
263 it != m->llChildren.end();
264 ++it)
265 {
266 ComObjPtr<Snapshot> child = *it;
267 // no need to lock, snapshots tree is protected by machine lock
268 child->m->pParent = m->pParent;
269 if (m->pParent)
270 m->pParent->m->llChildren.push_back(child);
271 }
272
273 // clear our own children list (since we reparented the children)
274 m->llChildren.clear();
275}
276
277/**
278 * Internal helper that removes "this" from the list of children of its
279 * parent. Used in uninit() and other places when reparenting is necessary.
280 *
281 * The caller must hold the machine lock in write mode (which protects the snapshots tree)!
282 */
283void Snapshot::i_deparent()
284{
285 Assert(m->pMachine->isWriteLockOnCurrentThread());
286
287 SnapshotsList &llParent = m->pParent->m->llChildren;
288 for (SnapshotsList::iterator it = llParent.begin();
289 it != llParent.end();
290 ++it)
291 {
292 Snapshot *pParentsChild = *it;
293 if (this == pParentsChild)
294 {
295 llParent.erase(it);
296 break;
297 }
298 }
299
300 m->pParent.setNull();
301}
302
303////////////////////////////////////////////////////////////////////////////////
304//
305// ISnapshot public methods
306//
307////////////////////////////////////////////////////////////////////////////////
308
309HRESULT Snapshot::getId(com::Guid &aId)
310{
311 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
312
313 aId = m->uuid;
314
315 return S_OK;
316}
317
318HRESULT Snapshot::getName(com::Utf8Str &aName)
319{
320 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
321 aName = m->strName;
322 return S_OK;
323}
324
325/**
326 * @note Locks this object for writing, then calls Machine::onSnapshotChange()
327 * (see its lock requirements).
328 */
329HRESULT Snapshot::setName(const com::Utf8Str &aName)
330{
331 HRESULT rc = S_OK;
332
333 // prohibit setting a UUID only as the machine name, or else it can
334 // never be found by findMachine()
335 Guid test(aName);
336
337 if (!test.isZero() && test.isValid())
338 return setError(E_INVALIDARG, tr("A machine cannot have a UUID as its name"));
339
340 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
341
342 if (m->strName != aName)
343 {
344 m->strName = aName;
345 alock.release(); /* Important! (child->parent locks are forbidden) */
346 rc = m->pMachine->i_onSnapshotChange(this);
347 }
348
349 return rc;
350}
351
352HRESULT Snapshot::getDescription(com::Utf8Str &aDescription)
353{
354 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
355 aDescription = m->strDescription;
356 return S_OK;
357}
358
359HRESULT Snapshot::setDescription(const com::Utf8Str &aDescription)
360{
361 HRESULT rc = S_OK;
362
363 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
364 if (m->strDescription != aDescription)
365 {
366 m->strDescription = aDescription;
367 alock.release(); /* Important! (child->parent locks are forbidden) */
368 rc = m->pMachine->i_onSnapshotChange(this);
369 }
370
371 return rc;
372}
373
374HRESULT Snapshot::getTimeStamp(LONG64 *aTimeStamp)
375{
376 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
377
378 *aTimeStamp = RTTimeSpecGetMilli(&m->timeStamp);
379 return S_OK;
380}
381
382HRESULT Snapshot::getOnline(BOOL *aOnline)
383{
384 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
385
386 *aOnline = i_getStateFilePath().isNotEmpty();
387 return S_OK;
388}
389
390HRESULT Snapshot::getMachine(ComPtr<IMachine> &aMachine)
391{
392 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
393
394 m->pMachine.queryInterfaceTo(aMachine.asOutParam());
395
396 return S_OK;
397}
398
399
400HRESULT Snapshot::getParent(ComPtr<ISnapshot> &aParent)
401{
402 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
403
404 m->pParent.queryInterfaceTo(aParent.asOutParam());
405 return S_OK;
406}
407
408HRESULT Snapshot::getChildren(std::vector<ComPtr<ISnapshot> > &aChildren)
409{
410 // snapshots tree is protected by machine lock
411 AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
412 aChildren.resize(0);
413 for (SnapshotsList::const_iterator it = m->llChildren.begin();
414 it != m->llChildren.end();
415 ++it)
416 aChildren.push_back(*it);
417 return S_OK;
418}
419
420HRESULT Snapshot::getChildrenCount(ULONG *count)
421{
422 *count = i_getChildrenCount();
423
424 return S_OK;
425}
426
427////////////////////////////////////////////////////////////////////////////////
428//
429// Snapshot public internal methods
430//
431////////////////////////////////////////////////////////////////////////////////
432
433/**
434 * Returns the parent snapshot or NULL if there's none. Must have caller + locking!
435 * @return
436 */
437const ComObjPtr<Snapshot>& Snapshot::i_getParent() const
438{
439 return m->pParent;
440}
441
442/**
443 * Returns the first child snapshot or NULL if there's none. Must have caller + locking!
444 * @return
445 */
446const ComObjPtr<Snapshot> Snapshot::i_getFirstChild() const
447{
448 if (!m->llChildren.size())
449 return NULL;
450 return m->llChildren.front();
451}
452
453/**
454 * @note
455 * Must be called from under the object's lock!
456 */
457const Utf8Str& Snapshot::i_getStateFilePath() const
458{
459 return m->pMachine->mSSData->strStateFilePath;
460}
461
462/**
463 * Returns the depth in the snapshot tree for this snapshot.
464 *
465 * @note takes the snapshot tree lock
466 */
467
468uint32_t Snapshot::i_getDepth()
469{
470 AutoCaller autoCaller(this);
471 AssertComRC(autoCaller.rc());
472
473 // snapshots tree is protected by machine lock
474 AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
475
476 uint32_t cDepth = 0;
477 ComObjPtr<Snapshot> pSnap(this);
478 while (!pSnap.isNull())
479 {
480 pSnap = pSnap->m->pParent;
481 cDepth++;
482 }
483
484 return cDepth;
485}
486
487/**
488 * Returns the number of direct child snapshots, without grandchildren.
489 * Does not recurse.
490 * @return
491 */
492ULONG Snapshot::i_getChildrenCount()
493{
494 AutoCaller autoCaller(this);
495 AssertComRC(autoCaller.rc());
496
497 // snapshots tree is protected by machine lock
498 AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
499
500 return (ULONG)m->llChildren.size();
501}
502
503/**
504 * Implementation method for getAllChildrenCount() so we request the
505 * tree lock only once before recursing. Don't call directly.
506 * @return
507 */
508ULONG Snapshot::i_getAllChildrenCountImpl()
509{
510 AutoCaller autoCaller(this);
511 AssertComRC(autoCaller.rc());
512
513 ULONG count = (ULONG)m->llChildren.size();
514 for (SnapshotsList::const_iterator it = m->llChildren.begin();
515 it != m->llChildren.end();
516 ++it)
517 {
518 count += (*it)->i_getAllChildrenCountImpl();
519 }
520
521 return count;
522}
523
524/**
525 * Returns the number of child snapshots including all grandchildren.
526 * Recurses into the snapshots tree.
527 * @return
528 */
529ULONG Snapshot::i_getAllChildrenCount()
530{
531 AutoCaller autoCaller(this);
532 AssertComRC(autoCaller.rc());
533
534 // snapshots tree is protected by machine lock
535 AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
536
537 return i_getAllChildrenCountImpl();
538}
539
540/**
541 * Returns the SnapshotMachine that this snapshot belongs to.
542 * Caller must hold the snapshot's object lock!
543 * @return
544 */
545const ComObjPtr<SnapshotMachine>& Snapshot::i_getSnapshotMachine() const
546{
547 return m->pMachine;
548}
549
550/**
551 * Returns the UUID of this snapshot.
552 * Caller must hold the snapshot's object lock!
553 * @return
554 */
555Guid Snapshot::i_getId() const
556{
557 return m->uuid;
558}
559
560/**
561 * Returns the name of this snapshot.
562 * Caller must hold the snapshot's object lock!
563 * @return
564 */
565const Utf8Str& Snapshot::i_getName() const
566{
567 return m->strName;
568}
569
570/**
571 * Returns the time stamp of this snapshot.
572 * Caller must hold the snapshot's object lock!
573 * @return
574 */
575RTTIMESPEC Snapshot::i_getTimeStamp() const
576{
577 return m->timeStamp;
578}
579
580/**
581 * Searches for a snapshot with the given ID among children, grand-children,
582 * etc. of this snapshot. This snapshot itself is also included in the search.
583 *
584 * Caller must hold the machine lock (which protects the snapshots tree!)
585 */
586ComObjPtr<Snapshot> Snapshot::i_findChildOrSelf(IN_GUID aId)
587{
588 ComObjPtr<Snapshot> child;
589
590 AutoCaller autoCaller(this);
591 AssertComRC(autoCaller.rc());
592
593 // no need to lock, uuid is const
594 if (m->uuid == aId)
595 child = this;
596 else
597 {
598 for (SnapshotsList::const_iterator it = m->llChildren.begin();
599 it != m->llChildren.end();
600 ++it)
601 {
602 if ((child = (*it)->i_findChildOrSelf(aId)))
603 break;
604 }
605 }
606
607 return child;
608}
609
610/**
611 * Searches for a first snapshot with the given name among children,
612 * grand-children, etc. of this snapshot. This snapshot itself is also included
613 * in the search.
614 *
615 * Caller must hold the machine lock (which protects the snapshots tree!)
616 */
617ComObjPtr<Snapshot> Snapshot::i_findChildOrSelf(const Utf8Str &aName)
618{
619 ComObjPtr<Snapshot> child;
620 AssertReturn(!aName.isEmpty(), child);
621
622 AutoCaller autoCaller(this);
623 AssertComRC(autoCaller.rc());
624
625 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
626
627 if (m->strName == aName)
628 child = this;
629 else
630 {
631 alock.release();
632 for (SnapshotsList::const_iterator it = m->llChildren.begin();
633 it != m->llChildren.end();
634 ++it)
635 {
636 if ((child = (*it)->i_findChildOrSelf(aName)))
637 break;
638 }
639 }
640
641 return child;
642}
643
644/**
645 * Internal implementation for Snapshot::updateSavedStatePaths (below).
646 * @param strOldPath
647 * @param strNewPath
648 */
649void Snapshot::i_updateSavedStatePathsImpl(const Utf8Str &strOldPath,
650 const Utf8Str &strNewPath)
651{
652 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
653
654 const Utf8Str &path = m->pMachine->mSSData->strStateFilePath;
655 LogFlowThisFunc(("Snap[%s].statePath={%s}\n", m->strName.c_str(), path.c_str()));
656
657 /* state file may be NULL (for offline snapshots) */
658 if ( path.isNotEmpty()
659 && RTPathStartsWith(path.c_str(), strOldPath.c_str())
660 )
661 {
662 m->pMachine->mSSData->strStateFilePath = Utf8StrFmt("%s%s",
663 strNewPath.c_str(),
664 path.c_str() + strOldPath.length());
665 LogFlowThisFunc(("-> updated: {%s}\n", m->pMachine->mSSData->strStateFilePath.c_str()));
666 }
667
668 for (SnapshotsList::const_iterator it = m->llChildren.begin();
669 it != m->llChildren.end();
670 ++it)
671 {
672 Snapshot *pChild = *it;
673 pChild->i_updateSavedStatePathsImpl(strOldPath, strNewPath);
674 }
675}
676
677/**
678 * Checks if the specified path change affects the saved state file path of
679 * this snapshot or any of its (grand-)children and updates it accordingly.
680 *
681 * Intended to be called by Machine::openConfigLoader() only.
682 *
683 * @param strOldPath old path (full)
684 * @param strNewPath new path (full)
685 *
686 * @note Locks the machine (for the snapshots tree) + this object + children for writing.
687 */
688void Snapshot::i_updateSavedStatePaths(const Utf8Str &strOldPath,
689 const Utf8Str &strNewPath)
690{
691 LogFlowThisFunc(("aOldPath={%s} aNewPath={%s}\n", strOldPath.c_str(), strNewPath.c_str()));
692
693 AutoCaller autoCaller(this);
694 AssertComRC(autoCaller.rc());
695
696 // snapshots tree is protected by machine lock
697 AutoWriteLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
698
699 // call the implementation under the tree lock
700 i_updateSavedStatePathsImpl(strOldPath, strNewPath);
701}
702
703/**
704 * Returns true if this snapshot or one of its children uses the given file,
705 * whose path must be fully qualified, as its saved state. When invoked on a
706 * machine's first snapshot, this can be used to check if a saved state file
707 * is shared with any snapshots.
708 *
709 * Caller must hold the machine lock, which protects the snapshots tree.
710 *
711 * @param strPath
712 * @param pSnapshotToIgnore If != NULL, this snapshot is ignored during the checks.
713 * @return
714 */
715bool Snapshot::i_sharesSavedStateFile(const Utf8Str &strPath,
716 Snapshot *pSnapshotToIgnore)
717{
718 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
719 const Utf8Str &path = m->pMachine->mSSData->strStateFilePath;
720
721 if (!pSnapshotToIgnore || pSnapshotToIgnore != this)
722 if (path.isNotEmpty())
723 if (path == strPath)
724 return true; // no need to recurse then
725
726 // but otherwise we must check children
727 for (SnapshotsList::const_iterator it = m->llChildren.begin();
728 it != m->llChildren.end();
729 ++it)
730 {
731 Snapshot *pChild = *it;
732 if (!pSnapshotToIgnore || pSnapshotToIgnore != pChild)
733 if (pChild->i_sharesSavedStateFile(strPath, pSnapshotToIgnore))
734 return true;
735 }
736
737 return false;
738}
739
740
741/**
742 * Internal implementation for Snapshot::updateNVRAMPaths (below).
743 * @param strOldPath
744 * @param strNewPath
745 */
746void Snapshot::i_updateNVRAMPathsImpl(const Utf8Str &strOldPath,
747 const Utf8Str &strNewPath)
748{
749 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
750
751 const Utf8Str path = m->pMachine->mNvramStore->i_getNonVolatileStorageFile();
752 LogFlowThisFunc(("Snap[%s].nvramPath={%s}\n", m->strName.c_str(), path.c_str()));
753
754 /* NVRAM filename may be empty */
755 if ( path.isNotEmpty()
756 && RTPathStartsWith(path.c_str(), strOldPath.c_str())
757 )
758 {
759 m->pMachine->mNvramStore->i_updateNonVolatileStorageFile(Utf8StrFmt("%s%s",
760 strNewPath.c_str(),
761 path.c_str() + strOldPath.length()));
762 LogFlowThisFunc(("-> updated: {%s}\n", m->pMachine->mNvramStore->i_getNonVolatileStorageFile().c_str()));
763 }
764
765 for (SnapshotsList::const_iterator it = m->llChildren.begin();
766 it != m->llChildren.end();
767 ++it)
768 {
769 Snapshot *pChild = *it;
770 pChild->i_updateNVRAMPathsImpl(strOldPath, strNewPath);
771 }
772}
773
774/**
775 * Checks if the specified path change affects the NVRAM file path of
776 * this snapshot or any of its (grand-)children and updates it accordingly.
777 *
778 * Intended to be called by Machine::openConfigLoader() only.
779 *
780 * @param strOldPath old path (full)
781 * @param strNewPath new path (full)
782 *
783 * @note Locks the machine (for the snapshots tree) + this object + children for writing.
784 */
785void Snapshot::i_updateNVRAMPaths(const Utf8Str &strOldPath,
786 const Utf8Str &strNewPath)
787{
788 LogFlowThisFunc(("aOldPath={%s} aNewPath={%s}\n", strOldPath.c_str(), strNewPath.c_str()));
789
790 AutoCaller autoCaller(this);
791 AssertComRC(autoCaller.rc());
792
793 // snapshots tree is protected by machine lock
794 AutoWriteLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
795
796 // call the implementation under the tree lock
797 i_updateSavedStatePathsImpl(strOldPath, strNewPath);
798}
799
800/**
801 * Saves the settings attributes of one snapshot.
802 *
803 * @param data Target for saving snapshot settings.
804 * @return
805 */
806HRESULT Snapshot::i_saveSnapshotImplOne(settings::Snapshot &data) const
807{
808 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
809
810 data.uuid = m->uuid;
811 data.strName = m->strName;
812 data.timestamp = m->timeStamp;
813 data.strDescription = m->strDescription;
814
815 // state file (only if this snapshot is online)
816 if (i_getStateFilePath().isNotEmpty())
817 m->pMachine->i_copyPathRelativeToMachine(i_getStateFilePath(), data.strStateFile);
818 else
819 data.strStateFile.setNull();
820
821 HRESULT rc = m->pMachine->i_saveHardware(data.hardware, &data.debugging, &data.autostart);
822 if (FAILED(rc)) return rc;
823
824 return S_OK;
825}
826
827/**
828 * Internal implementation for Snapshot::saveSnapshot (below). Caller has
829 * requested the snapshots tree (machine) lock.
830 *
831 * @param data Target for saving snapshot settings.
832 * @return
833 */
834HRESULT Snapshot::i_saveSnapshotImpl(settings::Snapshot &data) const
835{
836 HRESULT rc = i_saveSnapshotImplOne(data);
837 if (FAILED(rc))
838 return rc;
839
840 settings::SnapshotsList &llSettingsChildren = data.llChildSnapshots;
841 for (SnapshotsList::const_iterator it = m->llChildren.begin();
842 it != m->llChildren.end();
843 ++it)
844 {
845 // Use the heap (indirectly through the list container) to reduce the
846 // stack footprint, avoiding local settings objects on the stack which
847 // need a lot of stack space. There can be VMs with deeply nested
848 // snapshots. The stack can be quite small, especially with XPCOM.
849 llSettingsChildren.push_back(settings::Snapshot::Empty);
850 Snapshot *pSnap = *it;
851 rc = pSnap->i_saveSnapshotImpl(llSettingsChildren.back());
852 if (FAILED(rc))
853 {
854 llSettingsChildren.pop_back();
855 return rc;
856 }
857 }
858
859 return S_OK;
860}
861
862/**
863 * Saves the given snapshot and all its children.
864 * It is assumed that the given node is empty.
865 *
866 * @param data Target for saving snapshot settings.
867 */
868HRESULT Snapshot::i_saveSnapshot(settings::Snapshot &data) const
869{
870 // snapshots tree is protected by machine lock
871 AutoReadLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
872
873 return i_saveSnapshotImpl(data);
874}
875
876/**
877 * Part of the cleanup engine of Machine::Unregister().
878 *
879 * This removes all medium attachments from the snapshot's machine and returns
880 * the snapshot's saved state file name, if any, and then calls uninit() on
881 * "this" itself.
882 *
883 * Caller must hold the machine write lock (which protects the snapshots tree!)
884 *
885 * @param writeLock Machine write lock, which can get released temporarily here.
886 * @param cleanupMode Cleanup mode; see Machine::detachAllMedia().
887 * @param llMedia List of media returned to caller, depending on cleanupMode.
888 * @param llFilenames
889 * @return
890 */
891HRESULT Snapshot::i_uninitOne(AutoWriteLock &writeLock,
892 CleanupMode_T cleanupMode,
893 MediaList &llMedia,
894 std::list<Utf8Str> &llFilenames)
895{
896 // now call detachAllMedia on the snapshot machine
897 HRESULT rc = m->pMachine->i_detachAllMedia(writeLock,
898 this /* pSnapshot */,
899 cleanupMode,
900 llMedia);
901 if (FAILED(rc))
902 return rc;
903
904 // report the saved state file if it's not on the list yet
905 if (m->pMachine->mSSData->strStateFilePath.isNotEmpty())
906 {
907 bool fFound = false;
908 for (std::list<Utf8Str>::const_iterator it = llFilenames.begin();
909 it != llFilenames.end();
910 ++it)
911 {
912 const Utf8Str &str = *it;
913 if (str == m->pMachine->mSSData->strStateFilePath)
914 {
915 fFound = true;
916 break;
917 }
918 }
919 if (!fFound)
920 llFilenames.push_back(m->pMachine->mSSData->strStateFilePath);
921 }
922
923 Utf8Str strNVRAMFile = m->pMachine->mNvramStore->i_getNonVolatileStorageFile();
924 if (strNVRAMFile.isNotEmpty() && RTFileExists(strNVRAMFile.c_str()))
925 llFilenames.push_back(strNVRAMFile);
926
927 i_beginSnapshotDelete();
928 uninit();
929
930 return S_OK;
931}
932
933/**
934 * Part of the cleanup engine of Machine::Unregister().
935 *
936 * This recursively removes all medium attachments from the snapshot's machine
937 * and returns the snapshot's saved state file name, if any, and then calls
938 * uninit() on "this" itself.
939 *
940 * This recurses into children first, so the given MediaList receives child
941 * media first before their parents. If the caller wants to close all media,
942 * they should go thru the list from the beginning to the end because media
943 * cannot be closed if they have children.
944 *
945 * This calls uninit() on itself, so the snapshots tree (beginning with a machine's pFirstSnapshot) becomes invalid after this.
946 * It does not alter the main machine's snapshot pointers (pFirstSnapshot, pCurrentSnapshot).
947 *
948 * Caller must hold the machine write lock (which protects the snapshots tree!)
949 *
950 * @param writeLock Machine write lock, which can get released temporarily here.
951 * @param cleanupMode Cleanup mode; see Machine::detachAllMedia().
952 * @param llMedia List of media returned to caller, depending on cleanupMode.
953 * @param llFilenames
954 * @return
955 */
956HRESULT Snapshot::i_uninitRecursively(AutoWriteLock &writeLock,
957 CleanupMode_T cleanupMode,
958 MediaList &llMedia,
959 std::list<Utf8Str> &llFilenames)
960{
961 Assert(m->pMachine->isWriteLockOnCurrentThread());
962
963 HRESULT rc = S_OK;
964
965 // make a copy of the Guid for logging before we uninit ourselves
966#ifdef LOG_ENABLED
967 Guid uuid = i_getId();
968 Utf8Str name = i_getName();
969 LogFlowThisFunc(("Entering for snapshot '%s' {%RTuuid}\n", name.c_str(), uuid.raw()));
970#endif
971
972 // Recurse into children first so that the child media appear on the list
973 // first; this way caller can close the media from the beginning to the end
974 // because parent media can't be closed if they have children and
975 // additionally it postpones the uninit() call until we no longer need
976 // anything from the list. Oh, and remember that the child removes itself
977 // from the list, so keep the iterator at the beginning.
978 for (SnapshotsList::const_iterator it = m->llChildren.begin();
979 it != m->llChildren.end();
980 it = m->llChildren.begin())
981 {
982 Snapshot *pChild = *it;
983 rc = pChild->i_uninitRecursively(writeLock, cleanupMode, llMedia, llFilenames);
984 if (FAILED(rc))
985 break;
986 }
987
988 if (SUCCEEDED(rc))
989 rc = i_uninitOne(writeLock, cleanupMode, llMedia, llFilenames);
990
991#ifdef LOG_ENABLED
992 LogFlowThisFunc(("Leaving for snapshot '%s' {%RTuuid}: %Rhrc\n", name.c_str(), uuid.raw(), rc));
993#endif
994
995 return rc;
996}
997
998////////////////////////////////////////////////////////////////////////////////
999//
1000// SnapshotMachine implementation
1001//
1002////////////////////////////////////////////////////////////////////////////////
1003
1004SnapshotMachine::SnapshotMachine()
1005 : mMachine(NULL)
1006{}
1007
1008SnapshotMachine::~SnapshotMachine()
1009{}
1010
1011HRESULT SnapshotMachine::FinalConstruct()
1012{
1013 LogFlowThisFunc(("\n"));
1014
1015 return BaseFinalConstruct();
1016}
1017
1018void SnapshotMachine::FinalRelease()
1019{
1020 LogFlowThisFunc(("\n"));
1021
1022 uninit();
1023
1024 BaseFinalRelease();
1025}
1026
1027/**
1028 * Initializes the SnapshotMachine object when taking a snapshot.
1029 *
1030 * @param aSessionMachine machine to take a snapshot from
1031 * @param aSnapshotId snapshot ID of this snapshot machine
1032 * @param aStateFilePath file where the execution state will be later saved
1033 * (or NULL for the offline snapshot)
1034 *
1035 * @note The aSessionMachine must be locked for writing.
1036 */
1037HRESULT SnapshotMachine::init(SessionMachine *aSessionMachine,
1038 IN_GUID aSnapshotId,
1039 const Utf8Str &aStateFilePath)
1040{
1041 LogFlowThisFuncEnter();
1042 LogFlowThisFunc(("mName={%s}\n", aSessionMachine->mUserData->s.strName.c_str()));
1043
1044 Guid l_guid(aSnapshotId);
1045 AssertReturn(aSessionMachine && (!l_guid.isZero() && l_guid.isValid()), E_INVALIDARG);
1046
1047 /* Enclose the state transition NotReady->InInit->Ready */
1048 AutoInitSpan autoInitSpan(this);
1049 AssertReturn(autoInitSpan.isOk(), E_FAIL);
1050
1051 AssertReturn(aSessionMachine->isWriteLockOnCurrentThread(), E_FAIL);
1052
1053 mSnapshotId = aSnapshotId;
1054 ComObjPtr<Machine> pMachine = aSessionMachine->mPeer;
1055
1056 /* mPeer stays NULL */
1057 /* memorize the primary Machine instance (i.e. not SessionMachine!) */
1058 unconst(mMachine) = pMachine;
1059 /* share the parent pointer */
1060 unconst(mParent) = pMachine->mParent;
1061
1062 /* take the pointer to Data to share */
1063 mData.share(pMachine->mData);
1064
1065 /* take the pointer to UserData to share (our UserData must always be the
1066 * same as Machine's data) */
1067 mUserData.share(pMachine->mUserData);
1068
1069 /* make a private copy of all other data */
1070 mHWData.attachCopy(aSessionMachine->mHWData);
1071
1072 /* SSData is always unique for SnapshotMachine */
1073 mSSData.allocate();
1074 mSSData->strStateFilePath = aStateFilePath;
1075
1076 HRESULT rc = S_OK;
1077
1078 /* Create copies of all attachments (mMediaData after attaching a copy
1079 * contains just references to original objects). Additionally associate
1080 * media with the snapshot (Machine::uninitDataAndChildObjects() will
1081 * deassociate at destruction). */
1082 mMediumAttachments.allocate();
1083 for (MediumAttachmentList::const_iterator
1084 it = aSessionMachine->mMediumAttachments->begin();
1085 it != aSessionMachine->mMediumAttachments->end();
1086 ++it)
1087 {
1088 ComObjPtr<MediumAttachment> pAtt;
1089 pAtt.createObject();
1090 rc = pAtt->initCopy(this, *it);
1091 if (FAILED(rc)) return rc;
1092 mMediumAttachments->push_back(pAtt);
1093
1094 Medium *pMedium = pAtt->i_getMedium();
1095 if (pMedium) // can be NULL for non-harddisk
1096 {
1097 rc = pMedium->i_addBackReference(mData->mUuid, mSnapshotId);
1098 AssertComRC(rc);
1099 }
1100 }
1101
1102 /* create copies of all shared folders (mHWData after attaching a copy
1103 * contains just references to original objects) */
1104 for (HWData::SharedFolderList::iterator
1105 it = mHWData->mSharedFolders.begin();
1106 it != mHWData->mSharedFolders.end();
1107 ++it)
1108 {
1109 ComObjPtr<SharedFolder> pFolder;
1110 pFolder.createObject();
1111 rc = pFolder->initCopy(this, *it);
1112 if (FAILED(rc)) return rc;
1113 *it = pFolder;
1114 }
1115
1116 /* create copies of all PCI device assignments (mHWData after attaching
1117 * a copy contains just references to original objects) */
1118 for (HWData::PCIDeviceAssignmentList::iterator
1119 it = mHWData->mPCIDeviceAssignments.begin();
1120 it != mHWData->mPCIDeviceAssignments.end();
1121 ++it)
1122 {
1123 ComObjPtr<PCIDeviceAttachment> pDev;
1124 pDev.createObject();
1125 rc = pDev->initCopy(this, *it);
1126 if (FAILED(rc)) return rc;
1127 *it = pDev;
1128 }
1129
1130 /* create copies of all storage controllers (mStorageControllerData
1131 * after attaching a copy contains just references to original objects) */
1132 mStorageControllers.allocate();
1133 for (StorageControllerList::const_iterator
1134 it = aSessionMachine->mStorageControllers->begin();
1135 it != aSessionMachine->mStorageControllers->end();
1136 ++it)
1137 {
1138 ComObjPtr<StorageController> ctrl;
1139 ctrl.createObject();
1140 rc = ctrl->initCopy(this, *it);
1141 if (FAILED(rc)) return rc;
1142 mStorageControllers->push_back(ctrl);
1143 }
1144
1145 /* create all other child objects that will be immutable private copies */
1146
1147 unconst(mBIOSSettings).createObject();
1148 rc = mBIOSSettings->initCopy(this, pMachine->mBIOSSettings);
1149 if (FAILED(rc)) return rc;
1150
1151 unconst(mTrustedPlatformModule).createObject();
1152 rc = mTrustedPlatformModule->initCopy(this, pMachine->mTrustedPlatformModule);
1153 if (FAILED(rc)) return rc;
1154
1155 unconst(mNvramStore).createObject();
1156 rc = mNvramStore->initCopy(this, pMachine->mNvramStore);
1157 if (FAILED(rc)) return rc;
1158
1159 unconst(mRecordingSettings).createObject();
1160 rc = mRecordingSettings->initCopy(this, pMachine->mRecordingSettings);
1161 if (FAILED(rc)) return rc;
1162
1163 unconst(mGraphicsAdapter).createObject();
1164 rc = mGraphicsAdapter->initCopy(this, pMachine->mGraphicsAdapter);
1165 if (FAILED(rc)) return rc;
1166
1167 unconst(mVRDEServer).createObject();
1168 rc = mVRDEServer->initCopy(this, pMachine->mVRDEServer);
1169 if (FAILED(rc)) return rc;
1170
1171 unconst(mAudioAdapter).createObject();
1172 rc = mAudioAdapter->initCopy(this, pMachine->mAudioAdapter);
1173 if (FAILED(rc)) return rc;
1174
1175 /* create copies of all USB controllers (mUSBControllerData
1176 * after attaching a copy contains just references to original objects) */
1177 mUSBControllers.allocate();
1178 for (USBControllerList::const_iterator
1179 it = aSessionMachine->mUSBControllers->begin();
1180 it != aSessionMachine->mUSBControllers->end();
1181 ++it)
1182 {
1183 ComObjPtr<USBController> ctrl;
1184 ctrl.createObject();
1185 rc = ctrl->initCopy(this, *it);
1186 if (FAILED(rc)) return rc;
1187 mUSBControllers->push_back(ctrl);
1188 }
1189
1190 unconst(mUSBDeviceFilters).createObject();
1191 rc = mUSBDeviceFilters->initCopy(this, pMachine->mUSBDeviceFilters);
1192 if (FAILED(rc)) return rc;
1193
1194 mNetworkAdapters.resize(pMachine->mNetworkAdapters.size());
1195 for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
1196 {
1197 unconst(mNetworkAdapters[slot]).createObject();
1198 rc = mNetworkAdapters[slot]->initCopy(this, pMachine->mNetworkAdapters[slot]);
1199 if (FAILED(rc)) return rc;
1200 }
1201
1202 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
1203 {
1204 unconst(mSerialPorts[slot]).createObject();
1205 rc = mSerialPorts[slot]->initCopy(this, pMachine->mSerialPorts[slot]);
1206 if (FAILED(rc)) return rc;
1207 }
1208
1209 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
1210 {
1211 unconst(mParallelPorts[slot]).createObject();
1212 rc = mParallelPorts[slot]->initCopy(this, pMachine->mParallelPorts[slot]);
1213 if (FAILED(rc)) return rc;
1214 }
1215
1216 unconst(mBandwidthControl).createObject();
1217 rc = mBandwidthControl->initCopy(this, pMachine->mBandwidthControl);
1218 if (FAILED(rc)) return rc;
1219
1220 /* Confirm a successful initialization when it's the case */
1221 autoInitSpan.setSucceeded();
1222
1223 LogFlowThisFuncLeave();
1224 return S_OK;
1225}
1226
1227/**
1228 * Initializes the SnapshotMachine object when loading from the settings file.
1229 *
1230 * @param aMachine machine the snapshot belongs to
1231 * @param hardware hardware settings
1232 * @param pDbg debuging settings
1233 * @param pAutostart autostart settings
1234 * @param aSnapshotId snapshot ID of this snapshot machine
1235 * @param aStateFilePath file where the execution state is saved
1236 * (or NULL for the offline snapshot)
1237 *
1238 * @note Doesn't lock anything.
1239 */
1240HRESULT SnapshotMachine::initFromSettings(Machine *aMachine,
1241 const settings::Hardware &hardware,
1242 const settings::Debugging *pDbg,
1243 const settings::Autostart *pAutostart,
1244 IN_GUID aSnapshotId,
1245 const Utf8Str &aStateFilePath)
1246{
1247 LogFlowThisFuncEnter();
1248 LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
1249
1250 Guid l_guid(aSnapshotId);
1251 AssertReturn(aMachine && (!l_guid.isZero() && l_guid.isValid()), E_INVALIDARG);
1252
1253 /* Enclose the state transition NotReady->InInit->Ready */
1254 AutoInitSpan autoInitSpan(this);
1255 AssertReturn(autoInitSpan.isOk(), E_FAIL);
1256
1257 /* Don't need to lock aMachine when VirtualBox is starting up */
1258
1259 mSnapshotId = aSnapshotId;
1260
1261 /* mPeer stays NULL */
1262 /* memorize the primary Machine instance (i.e. not SessionMachine!) */
1263 unconst(mMachine) = aMachine;
1264 /* share the parent pointer */
1265 unconst(mParent) = aMachine->mParent;
1266
1267 /* take the pointer to Data to share */
1268 mData.share(aMachine->mData);
1269 /*
1270 * take the pointer to UserData to share
1271 * (our UserData must always be the same as Machine's data)
1272 */
1273 mUserData.share(aMachine->mUserData);
1274 /* allocate private copies of all other data (will be loaded from settings) */
1275 mHWData.allocate();
1276 mMediumAttachments.allocate();
1277 mStorageControllers.allocate();
1278 mUSBControllers.allocate();
1279
1280 /* SSData is always unique for SnapshotMachine */
1281 mSSData.allocate();
1282 mSSData->strStateFilePath = aStateFilePath;
1283
1284 /* create all other child objects that will be immutable private copies */
1285
1286 unconst(mBIOSSettings).createObject();
1287 mBIOSSettings->init(this);
1288
1289 unconst(mTrustedPlatformModule).createObject();
1290 mTrustedPlatformModule->init(this);
1291
1292 unconst(mNvramStore).createObject();
1293 mNvramStore->init(this);
1294
1295 unconst(mRecordingSettings).createObject();
1296 mRecordingSettings->init(this);
1297
1298 unconst(mGraphicsAdapter).createObject();
1299 mGraphicsAdapter->init(this);
1300
1301 unconst(mVRDEServer).createObject();
1302 mVRDEServer->init(this);
1303
1304 unconst(mAudioAdapter).createObject();
1305 mAudioAdapter->init(this);
1306
1307 unconst(mUSBDeviceFilters).createObject();
1308 mUSBDeviceFilters->init(this);
1309
1310 mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
1311 for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
1312 {
1313 unconst(mNetworkAdapters[slot]).createObject();
1314 mNetworkAdapters[slot]->init(this, slot);
1315 }
1316
1317 for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
1318 {
1319 unconst(mSerialPorts[slot]).createObject();
1320 mSerialPorts[slot]->init(this, slot);
1321 }
1322
1323 for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
1324 {
1325 unconst(mParallelPorts[slot]).createObject();
1326 mParallelPorts[slot]->init(this, slot);
1327 }
1328
1329 unconst(mBandwidthControl).createObject();
1330 mBandwidthControl->init(this);
1331
1332 /* load hardware and storage settings */
1333 HRESULT rc = i_loadHardware(NULL, &mSnapshotId, hardware, pDbg, pAutostart);
1334
1335 if (SUCCEEDED(rc))
1336 /* commit all changes made during the initialization */
1337 i_commit(); /// @todo r=dj why do we need a commit in init?!? this is very expensive
1338 /// @todo r=klaus for some reason the settings loading logic backs up
1339 // the settings, and therefore a commit is needed. Should probably be changed.
1340
1341 /* Confirm a successful initialization when it's the case */
1342 if (SUCCEEDED(rc))
1343 autoInitSpan.setSucceeded();
1344
1345 LogFlowThisFuncLeave();
1346 return rc;
1347}
1348
1349/**
1350 * Uninitializes this SnapshotMachine object.
1351 */
1352void SnapshotMachine::uninit()
1353{
1354 LogFlowThisFuncEnter();
1355
1356 /* Enclose the state transition Ready->InUninit->NotReady */
1357 AutoUninitSpan autoUninitSpan(this);
1358 if (autoUninitSpan.uninitDone())
1359 return;
1360
1361 uninitDataAndChildObjects();
1362
1363 /* free the essential data structure last */
1364 mData.free();
1365
1366 unconst(mMachine) = NULL;
1367 unconst(mParent) = NULL;
1368 unconst(mPeer) = NULL;
1369
1370 LogFlowThisFuncLeave();
1371}
1372
1373/**
1374 * Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
1375 * with the primary Machine instance (mMachine) if it exists.
1376 */
1377RWLockHandle *SnapshotMachine::lockHandle() const
1378{
1379 AssertReturn(mMachine != NULL, NULL);
1380 return mMachine->lockHandle();
1381}
1382
1383////////////////////////////////////////////////////////////////////////////////
1384//
1385// SnapshotMachine public internal methods
1386//
1387////////////////////////////////////////////////////////////////////////////////
1388
1389/**
1390 * Called by the snapshot object associated with this SnapshotMachine when
1391 * snapshot data such as name or description is changed.
1392 *
1393 * @warning Caller must hold no locks when calling this.
1394 */
1395HRESULT SnapshotMachine::i_onSnapshotChange(Snapshot *aSnapshot)
1396{
1397 AutoMultiWriteLock2 mlock(this, aSnapshot COMMA_LOCKVAL_SRC_POS);
1398 Guid uuidMachine(mData->mUuid),
1399 uuidSnapshot(aSnapshot->i_getId());
1400 bool fNeedsGlobalSaveSettings = false;
1401
1402 /* Flag the machine as dirty or change won't get saved. We disable the
1403 * modification of the current state flag, cause this snapshot data isn't
1404 * related to the current state. */
1405 mMachine->i_setModified(Machine::IsModified_Snapshots, false /* fAllowStateModification */);
1406 HRESULT rc = mMachine->i_saveSettings(&fNeedsGlobalSaveSettings,
1407 SaveS_Force); // we know we need saving, no need to check
1408 mlock.release();
1409
1410 if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
1411 {
1412 // save the global settings
1413 AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
1414 rc = mParent->i_saveSettings();
1415 }
1416
1417 /* inform callbacks */
1418 mParent->i_onSnapshotChanged(uuidMachine, uuidSnapshot);
1419
1420 return rc;
1421}
1422
1423////////////////////////////////////////////////////////////////////////////////
1424//
1425// SessionMachine task records
1426//
1427////////////////////////////////////////////////////////////////////////////////
1428
1429/**
1430 * Still abstract base class for SessionMachine::TakeSnapshotTask,
1431 * SessionMachine::RestoreSnapshotTask and SessionMachine::DeleteSnapshotTask.
1432 */
1433class SessionMachine::SnapshotTask
1434 : public SessionMachine::Task
1435{
1436public:
1437 SnapshotTask(SessionMachine *m,
1438 Progress *p,
1439 const Utf8Str &t,
1440 Snapshot *s)
1441 : Task(m, p, t),
1442 m_pSnapshot(s)
1443 {}
1444
1445 ComObjPtr<Snapshot> m_pSnapshot;
1446};
1447
1448/** Take snapshot task */
1449class SessionMachine::TakeSnapshotTask
1450 : public SessionMachine::SnapshotTask
1451{
1452public:
1453 TakeSnapshotTask(SessionMachine *m,
1454 Progress *p,
1455 const Utf8Str &t,
1456 Snapshot *s,
1457 const Utf8Str &strName,
1458 const Utf8Str &strDescription,
1459 const Guid &uuidSnapshot,
1460 bool fPause,
1461 uint32_t uMemSize,
1462 bool fTakingSnapshotOnline)
1463 : SnapshotTask(m, p, t, s)
1464 , m_strName(strName)
1465 , m_strDescription(strDescription)
1466 , m_uuidSnapshot(uuidSnapshot)
1467 , m_fPause(fPause)
1468#if 0 /*unused*/
1469 , m_uMemSize(uMemSize)
1470#endif
1471 , m_fTakingSnapshotOnline(fTakingSnapshotOnline)
1472 {
1473 RT_NOREF(uMemSize);
1474 if (fTakingSnapshotOnline)
1475 m_pDirectControl = m->mData->mSession.mDirectControl;
1476 // If the VM is already paused then there's no point trying to pause
1477 // again during taking an (always online) snapshot.
1478 if (m_machineStateBackup == MachineState_Paused)
1479 m_fPause = false;
1480 }
1481
1482private:
1483 void handler()
1484 {
1485 try
1486 {
1487 ((SessionMachine *)(Machine *)m_pMachine)->i_takeSnapshotHandler(*this);
1488 }
1489 catch(...)
1490 {
1491 LogRel(("Some exception in the function i_takeSnapshotHandler()\n"));
1492 }
1493 }
1494
1495 Utf8Str m_strName;
1496 Utf8Str m_strDescription;
1497 Guid m_uuidSnapshot;
1498 Utf8Str m_strStateFilePath;
1499 ComPtr<IInternalSessionControl> m_pDirectControl;
1500 bool m_fPause;
1501#if 0 /*unused*/
1502 uint32_t m_uMemSize;
1503#endif
1504 bool m_fTakingSnapshotOnline;
1505
1506 friend HRESULT SessionMachine::i_finishTakingSnapshot(TakeSnapshotTask &task, AutoWriteLock &alock, bool aSuccess);
1507 friend void SessionMachine::i_takeSnapshotHandler(TakeSnapshotTask &task);
1508 friend void SessionMachine::i_takeSnapshotProgressCancelCallback(void *pvUser);
1509};
1510
1511/** Restore snapshot task */
1512class SessionMachine::RestoreSnapshotTask
1513 : public SessionMachine::SnapshotTask
1514{
1515public:
1516 RestoreSnapshotTask(SessionMachine *m,
1517 Progress *p,
1518 const Utf8Str &t,
1519 Snapshot *s)
1520 : SnapshotTask(m, p, t, s)
1521 {}
1522
1523private:
1524 void handler()
1525 {
1526 try
1527 {
1528 ((SessionMachine *)(Machine *)m_pMachine)->i_restoreSnapshotHandler(*this);
1529 }
1530 catch(...)
1531 {
1532 LogRel(("Some exception in the function i_restoreSnapshotHandler()\n"));
1533 }
1534 }
1535};
1536
1537/** Delete snapshot task */
1538class SessionMachine::DeleteSnapshotTask
1539 : public SessionMachine::SnapshotTask
1540{
1541public:
1542 DeleteSnapshotTask(SessionMachine *m,
1543 Progress *p,
1544 const Utf8Str &t,
1545 bool fDeleteOnline,
1546 Snapshot *s)
1547 : SnapshotTask(m, p, t, s),
1548 m_fDeleteOnline(fDeleteOnline)
1549 {}
1550
1551private:
1552 void handler()
1553 {
1554 try
1555 {
1556 ((SessionMachine *)(Machine *)m_pMachine)->i_deleteSnapshotHandler(*this);
1557 }
1558 catch(...)
1559 {
1560 LogRel(("Some exception in the function i_deleteSnapshotHandler()\n"));
1561 }
1562 }
1563
1564 bool m_fDeleteOnline;
1565 friend void SessionMachine::i_deleteSnapshotHandler(DeleteSnapshotTask &task);
1566};
1567
1568
1569////////////////////////////////////////////////////////////////////////////////
1570//
1571// TakeSnapshot methods (Machine and related tasks)
1572//
1573////////////////////////////////////////////////////////////////////////////////
1574
1575HRESULT Machine::takeSnapshot(const com::Utf8Str &aName,
1576 const com::Utf8Str &aDescription,
1577 BOOL fPause,
1578 com::Guid &aId,
1579 ComPtr<IProgress> &aProgress)
1580{
1581 NOREF(aName);
1582 NOREF(aDescription);
1583 NOREF(fPause);
1584 NOREF(aId);
1585 NOREF(aProgress);
1586 ReturnComNotImplemented();
1587}
1588
1589HRESULT SessionMachine::takeSnapshot(const com::Utf8Str &aName,
1590 const com::Utf8Str &aDescription,
1591 BOOL fPause,
1592 com::Guid &aId,
1593 ComPtr<IProgress> &aProgress)
1594{
1595 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1596 LogFlowThisFunc(("aName='%s' mMachineState=%d\n", aName.c_str(), mData->mMachineState));
1597
1598 if (Global::IsTransient(mData->mMachineState))
1599 return setError(VBOX_E_INVALID_VM_STATE,
1600 tr("Cannot take a snapshot of the machine while it is changing the state (machine state: %s)"),
1601 Global::stringifyMachineState(mData->mMachineState));
1602
1603 HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
1604 if (FAILED(rc))
1605 return rc;
1606
1607 // prepare the progress object:
1608 // a) count the no. of hard disk attachments to get a matching no. of progress sub-operations
1609 ULONG cOperations = 2; // always at least setting up + finishing up
1610 ULONG ulTotalOperationsWeight = 2; // one each for setting up + finishing up
1611
1612 for (MediumAttachmentList::iterator
1613 it = mMediumAttachments->begin();
1614 it != mMediumAttachments->end();
1615 ++it)
1616 {
1617 const ComObjPtr<MediumAttachment> pAtt(*it);
1618 AutoReadLock attlock(pAtt COMMA_LOCKVAL_SRC_POS);
1619 AutoCaller attCaller(pAtt);
1620 if (pAtt->i_getType() == DeviceType_HardDisk)
1621 {
1622 ++cOperations;
1623
1624 // assume that creating a diff image takes as long as saving a 1MB state
1625 ulTotalOperationsWeight += 1;
1626 }
1627 }
1628
1629 // b) one extra sub-operations for online snapshots OR offline snapshots that have a saved state (needs to be copied)
1630 const bool fTakingSnapshotOnline = Global::IsOnline(mData->mMachineState);
1631 LogFlowThisFunc(("fTakingSnapshotOnline = %d\n", fTakingSnapshotOnline));
1632 if (fTakingSnapshotOnline)
1633 {
1634 ++cOperations;
1635 ulTotalOperationsWeight += mHWData->mMemorySize;
1636 }
1637
1638 // finally, create the progress object
1639 ComObjPtr<Progress> pProgress;
1640 pProgress.createObject();
1641 rc = pProgress->init(mParent,
1642 static_cast<IMachine *>(this),
1643 Bstr(tr("Taking a snapshot of the virtual machine")).raw(),
1644 fTakingSnapshotOnline /* aCancelable */,
1645 cOperations,
1646 ulTotalOperationsWeight,
1647 Bstr(tr("Setting up snapshot operation")).raw(), // first sub-op description
1648 1); // ulFirstOperationWeight
1649 if (FAILED(rc))
1650 return rc;
1651
1652 /* create an ID for the snapshot */
1653 Guid snapshotId;
1654 snapshotId.create();
1655
1656 /* create and start the task on a separate thread (note that it will not
1657 * start working until we release alock) */
1658 TakeSnapshotTask *pTask = new TakeSnapshotTask(this,
1659 pProgress,
1660 "TakeSnap",
1661 NULL /* pSnapshot */,
1662 aName,
1663 aDescription,
1664 snapshotId,
1665 !!fPause,
1666 mHWData->mMemorySize,
1667 fTakingSnapshotOnline);
1668 MachineState_T const machineStateBackup = pTask->m_machineStateBackup;
1669 rc = pTask->createThread();
1670 pTask = NULL;
1671 if (FAILED(rc))
1672 return rc;
1673
1674 /* set the proper machine state (note: after creating a Task instance) */
1675 if (fTakingSnapshotOnline)
1676 {
1677 if (machineStateBackup != MachineState_Paused && !fPause)
1678 i_setMachineState(MachineState_LiveSnapshotting);
1679 else
1680 i_setMachineState(MachineState_OnlineSnapshotting);
1681 i_updateMachineStateOnClient();
1682 }
1683 else
1684 i_setMachineState(MachineState_Snapshotting);
1685
1686 aId = snapshotId;
1687 pProgress.queryInterfaceTo(aProgress.asOutParam());
1688
1689 return rc;
1690}
1691
1692/**
1693 * Task thread implementation for SessionMachine::TakeSnapshot(), called from
1694 * SessionMachine::taskHandler().
1695 *
1696 * @note Locks this object for writing.
1697 *
1698 * @param task
1699 * @return
1700 */
1701void SessionMachine::i_takeSnapshotHandler(TakeSnapshotTask &task)
1702{
1703 LogFlowThisFuncEnter();
1704
1705 // Taking a snapshot consists of the following:
1706 // 1) creating a Snapshot object with the current state of the machine
1707 // (hardware + storage)
1708 // 2) creating a diff image for each virtual hard disk, into which write
1709 // operations go after the snapshot has been created
1710 // 3) if the machine is online: saving the state of the virtual machine
1711 // (in the VM process)
1712 // 4) reattach the hard disks
1713 // 5) update the various snapshot/machine objects, save settings
1714
1715 HRESULT rc = S_OK;
1716 AutoCaller autoCaller(this);
1717 LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
1718 if (FAILED(autoCaller.rc()))
1719 {
1720 /* we might have been uninitialized because the session was accidentally
1721 * closed by the client, so don't assert */
1722 rc = setError(E_FAIL,
1723 tr("The session has been accidentally closed"));
1724 task.m_pProgress->i_notifyComplete(rc);
1725 LogFlowThisFuncLeave();
1726 return;
1727 }
1728
1729 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1730
1731 bool fBeganTakingSnapshot = false;
1732 BOOL fSuspendedBySave = FALSE;
1733
1734 std::set<ComObjPtr<Medium> > pMediumsForNotify;
1735 std::map<Guid, DeviceType_T> uIdsForNotify;
1736
1737 try
1738 {
1739 /// @todo at this point we have to be in the right state!!!!
1740 AssertStmt( mData->mMachineState == MachineState_Snapshotting
1741 || mData->mMachineState == MachineState_OnlineSnapshotting
1742 || mData->mMachineState == MachineState_LiveSnapshotting, throw E_FAIL);
1743 AssertStmt(task.m_machineStateBackup != mData->mMachineState, throw E_FAIL);
1744 AssertStmt(task.m_pSnapshot.isNull(), throw E_FAIL);
1745
1746 if ( mData->mCurrentSnapshot
1747 && mData->mCurrentSnapshot->i_getDepth() >= SETTINGS_SNAPSHOT_DEPTH_MAX)
1748 {
1749 throw setError(VBOX_E_INVALID_OBJECT_STATE,
1750 tr("Cannot take another snapshot for machine '%s', because it exceeds the maximum snapshot depth limit. Please delete some earlier snapshot which you no longer need"),
1751 mUserData->s.strName.c_str());
1752 }
1753
1754 /* save settings to ensure current changes are committed and
1755 * hard disks are fixed up */
1756 rc = i_saveSettings(NULL);
1757 // no need to check for whether VirtualBox.xml needs changing since
1758 // we can't have a machine XML rename pending at this point
1759 if (FAILED(rc))
1760 throw rc;
1761
1762 /* task.m_strStateFilePath is "" when the machine is offline or saved */
1763 if (task.m_fTakingSnapshotOnline)
1764 {
1765 Bstr value;
1766 rc = GetExtraData(Bstr("VBoxInternal2/ForceTakeSnapshotWithoutState").raw(),
1767 value.asOutParam());
1768 if (FAILED(rc) || value != "1")
1769 // creating a new online snapshot: we need a fresh saved state file
1770 i_composeSavedStateFilename(task.m_strStateFilePath);
1771 }
1772 else if (task.m_machineStateBackup == MachineState_Saved)
1773 // taking an offline snapshot from machine in "saved" state: use existing state file
1774 task.m_strStateFilePath = mSSData->strStateFilePath;
1775
1776 if (task.m_strStateFilePath.isNotEmpty())
1777 {
1778 // ensure the directory for the saved state file exists
1779 rc = VirtualBox::i_ensureFilePathExists(task.m_strStateFilePath, true /* fCreate */);
1780 if (FAILED(rc))
1781 throw rc;
1782 }
1783
1784 /* STEP 1: create the snapshot object */
1785
1786 /* create a snapshot machine object */
1787 ComObjPtr<SnapshotMachine> pSnapshotMachine;
1788 pSnapshotMachine.createObject();
1789 rc = pSnapshotMachine->init(this, task.m_uuidSnapshot.ref(), task.m_strStateFilePath);
1790 AssertComRCThrowRC(rc);
1791
1792 /* create a snapshot object */
1793 RTTIMESPEC time;
1794 RTTimeNow(&time);
1795 task.m_pSnapshot.createObject();
1796 rc = task.m_pSnapshot->init(mParent,
1797 task.m_uuidSnapshot,
1798 task.m_strName,
1799 task.m_strDescription,
1800 time,
1801 pSnapshotMachine,
1802 mData->mCurrentSnapshot);
1803 AssertComRCThrowRC(rc);
1804
1805 /* STEP 2: create the diff images */
1806 LogFlowThisFunc(("Creating differencing hard disks (online=%d)...\n",
1807 task.m_fTakingSnapshotOnline));
1808
1809 // Backup the media data so we can recover if something goes wrong.
1810 // The matching commit() is in fixupMedia() during SessionMachine::i_finishTakingSnapshot()
1811 i_setModified(IsModified_Storage);
1812 mMediumAttachments.backup();
1813
1814 alock.release();
1815 /* create new differencing hard disks and attach them to this machine */
1816 rc = i_createImplicitDiffs(task.m_pProgress,
1817 1, // operation weight; must be the same as in Machine::TakeSnapshot()
1818 task.m_fTakingSnapshotOnline);
1819 if (FAILED(rc))
1820 throw rc;
1821 alock.acquire();
1822
1823 // MUST NOT save the settings or the media registry here, because
1824 // this causes trouble with rolling back settings if the user cancels
1825 // taking the snapshot after the diff images have been created.
1826
1827 fBeganTakingSnapshot = true;
1828
1829 // STEP 3: save the VM state (if online)
1830 if (task.m_fTakingSnapshotOnline)
1831 {
1832 task.m_pProgress->SetNextOperation(Bstr(tr("Saving the machine state")).raw(),
1833 mHWData->mMemorySize); // operation weight, same as computed
1834 // when setting up progress object
1835
1836 if (task.m_strStateFilePath.isNotEmpty())
1837 {
1838 alock.release();
1839 task.m_pProgress->i_setCancelCallback(i_takeSnapshotProgressCancelCallback, &task);
1840 rc = task.m_pDirectControl->SaveStateWithReason(Reason_Snapshot,
1841 task.m_pProgress,
1842 task.m_pSnapshot,
1843 Bstr(task.m_strStateFilePath).raw(),
1844 task.m_fPause,
1845 &fSuspendedBySave);
1846 task.m_pProgress->i_setCancelCallback(NULL, NULL);
1847 alock.acquire();
1848 if (FAILED(rc))
1849 throw rc;
1850 }
1851 else
1852 LogRel(("Machine: skipped saving state as part of online snapshot\n"));
1853
1854 if (FAILED(task.m_pProgress->NotifyPointOfNoReturn()))
1855 throw setError(E_FAIL, tr("Canceled"));
1856
1857 // STEP 4: reattach hard disks
1858 LogFlowThisFunc(("Reattaching new differencing hard disks...\n"));
1859
1860 task.m_pProgress->SetNextOperation(Bstr(tr("Reconfiguring medium attachments")).raw(),
1861 1); // operation weight, same as computed when setting up progress object
1862
1863 com::SafeIfaceArray<IMediumAttachment> atts;
1864 rc = COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
1865 if (FAILED(rc))
1866 throw rc;
1867
1868 alock.release();
1869 rc = task.m_pDirectControl->ReconfigureMediumAttachments(ComSafeArrayAsInParam(atts));
1870 alock.acquire();
1871 if (FAILED(rc))
1872 throw rc;
1873 }
1874
1875 // Handle NVRAM file snapshotting
1876 Utf8Str strNVRAM = mNvramStore->i_getNonVolatileStorageFile();
1877 Utf8Str strNVRAMSnap = pSnapshotMachine->i_getSnapshotNVRAMFilename();
1878 if (strNVRAM.isNotEmpty() && strNVRAMSnap.isNotEmpty() && RTFileExists(strNVRAM.c_str()))
1879 {
1880 Utf8Str strNVRAMSnapAbs;
1881 i_calculateFullPath(strNVRAMSnap, strNVRAMSnapAbs);
1882 rc = VirtualBox::i_ensureFilePathExists(strNVRAMSnapAbs, true /* fCreate */);
1883 if (FAILED(rc))
1884 throw rc;
1885 int vrc = RTFileCopy(strNVRAM.c_str(), strNVRAMSnapAbs.c_str());
1886 if (RT_FAILURE(vrc))
1887 throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
1888 tr("Could not copy NVRAM file '%s' to '%s' (%Rrc)"),
1889 strNVRAM.c_str(), strNVRAMSnapAbs.c_str(), vrc);
1890 pSnapshotMachine->mNvramStore->i_updateNonVolatileStorageFile(strNVRAMSnap);
1891 }
1892
1893 // store parent of newly created diffs before commit for notify
1894 {
1895 MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
1896 for (MediumAttachmentList::const_iterator
1897 it = mMediumAttachments->begin();
1898 it != mMediumAttachments->end();
1899 ++it)
1900 {
1901 MediumAttachment *pAttach = *it;
1902 Medium *pMedium = pAttach->i_getMedium();
1903 if (!pMedium)
1904 continue;
1905
1906 bool fFound = false;
1907 /* was this medium attached before? */
1908 for (MediumAttachmentList::iterator
1909 oldIt = oldAtts.begin();
1910 oldIt != oldAtts.end();
1911 ++oldIt)
1912 {
1913 MediumAttachment *pOldAttach = *oldIt;
1914 if (pOldAttach->i_getMedium() == pMedium)
1915 {
1916 fFound = true;
1917 break;
1918 }
1919 }
1920 if (!fFound)
1921 {
1922 pMediumsForNotify.insert(pMedium->i_getParent());
1923 uIdsForNotify[pMedium->i_getId()] = pMedium->i_getDeviceType();
1924 }
1925 }
1926 }
1927
1928 /*
1929 * Finalize the requested snapshot object. This will reset the
1930 * machine state to the state it had at the beginning.
1931 */
1932 rc = i_finishTakingSnapshot(task, alock, true /*aSuccess*/);
1933 // do not throw rc here because we can't call i_finishTakingSnapshot() twice
1934 LogFlowThisFunc(("i_finishTakingSnapshot -> %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(mData->mMachineState)));
1935 }
1936 catch (HRESULT rcThrown)
1937 {
1938 rc = rcThrown;
1939 LogThisFunc(("Caught %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(mData->mMachineState)));
1940
1941 /// @todo r=klaus check that the implicit diffs created above are cleaned up im the relevant error cases
1942
1943 /* preserve existing error info */
1944 ErrorInfoKeeper eik;
1945
1946 if (fBeganTakingSnapshot)
1947 i_finishTakingSnapshot(task, alock, false /*aSuccess*/);
1948
1949 // have to postpone this to the end as i_finishTakingSnapshot() needs
1950 // it for various cleanup steps
1951 if (task.m_pSnapshot)
1952 {
1953 task.m_pSnapshot->uninit();
1954 task.m_pSnapshot.setNull();
1955 }
1956 }
1957 Assert(alock.isWriteLockOnCurrentThread());
1958
1959 {
1960 // Keep all error information over the cleanup steps
1961 ErrorInfoKeeper eik;
1962
1963 /*
1964 * Fix up the machine state.
1965 *
1966 * For offline snapshots we just update the local copy, for the other
1967 * variants do the entire work. This ensures that the state is in sync
1968 * with the VM process (in particular the VM execution state).
1969 */
1970 bool fNeedClientMachineStateUpdate = false;
1971 if ( mData->mMachineState == MachineState_LiveSnapshotting
1972 || mData->mMachineState == MachineState_OnlineSnapshotting
1973 || mData->mMachineState == MachineState_Snapshotting)
1974 {
1975 if (!task.m_fTakingSnapshotOnline)
1976 i_setMachineState(task.m_machineStateBackup);
1977 else
1978 {
1979 MachineState_T enmMachineState = MachineState_Null;
1980 HRESULT rc2 = task.m_pDirectControl->COMGETTER(NominalState)(&enmMachineState);
1981 if (FAILED(rc2) || enmMachineState == MachineState_Null)
1982 {
1983 AssertMsgFailed(("state=%s\n", Global::stringifyMachineState(enmMachineState)));
1984 // pure nonsense, try to continue somehow
1985 enmMachineState = MachineState_Aborted;
1986 }
1987 if (enmMachineState == MachineState_Paused)
1988 {
1989 if (fSuspendedBySave)
1990 {
1991 alock.release();
1992 rc2 = task.m_pDirectControl->ResumeWithReason(Reason_Snapshot);
1993 alock.acquire();
1994 if (SUCCEEDED(rc2))
1995 enmMachineState = task.m_machineStateBackup;
1996 }
1997 else
1998 enmMachineState = task.m_machineStateBackup;
1999 }
2000 if (enmMachineState != mData->mMachineState)
2001 {
2002 fNeedClientMachineStateUpdate = true;
2003 i_setMachineState(enmMachineState);
2004 }
2005 }
2006 }
2007
2008 /* check the remote state to see that we got it right. */
2009 MachineState_T enmMachineState = MachineState_Null;
2010 if (!task.m_pDirectControl.isNull())
2011 {
2012 ComPtr<IConsole> pConsole;
2013 task.m_pDirectControl->COMGETTER(RemoteConsole)(pConsole.asOutParam());
2014 if (!pConsole.isNull())
2015 pConsole->COMGETTER(State)(&enmMachineState);
2016 }
2017 LogFlowThisFunc(("local mMachineState=%s remote mMachineState=%s\n",
2018 Global::stringifyMachineState(mData->mMachineState),
2019 Global::stringifyMachineState(enmMachineState)));
2020
2021 if (fNeedClientMachineStateUpdate)
2022 i_updateMachineStateOnClient();
2023 }
2024
2025 task.m_pProgress->i_notifyComplete(rc);
2026
2027 if (SUCCEEDED(rc))
2028 mParent->i_onSnapshotTaken(mData->mUuid, task.m_uuidSnapshot);
2029
2030 if (SUCCEEDED(rc))
2031 {
2032 for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
2033 it != uIdsForNotify.end();
2034 ++it)
2035 {
2036 mParent->i_onMediumRegistered(it->first, it->second, TRUE);
2037 }
2038
2039 for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
2040 it != pMediumsForNotify.end();
2041 ++it)
2042 {
2043 if (it->isNotNull())
2044 mParent->i_onMediumConfigChanged(*it);
2045 }
2046 }
2047 LogFlowThisFuncLeave();
2048}
2049
2050
2051/**
2052 * Progress cancelation callback employed by SessionMachine::i_takeSnapshotHandler.
2053 */
2054/*static*/
2055void SessionMachine::i_takeSnapshotProgressCancelCallback(void *pvUser)
2056{
2057 TakeSnapshotTask *pTask = (TakeSnapshotTask *)pvUser;
2058 AssertPtrReturnVoid(pTask);
2059 AssertReturnVoid(!pTask->m_pDirectControl.isNull());
2060 pTask->m_pDirectControl->CancelSaveStateWithReason();
2061}
2062
2063
2064/**
2065 * Called by the Console when it's done saving the VM state into the snapshot
2066 * (if online) and reconfiguring the hard disks. See BeginTakingSnapshot() above.
2067 *
2068 * This also gets called if the console part of snapshotting failed after the
2069 * BeginTakingSnapshot() call, to clean up the server side.
2070 *
2071 * @note Locks VirtualBox and this object for writing.
2072 *
2073 * @param task
2074 * @param alock
2075 * @param aSuccess Whether Console was successful with the client-side
2076 * snapshot things.
2077 * @return
2078 */
2079HRESULT SessionMachine::i_finishTakingSnapshot(TakeSnapshotTask &task, AutoWriteLock &alock, bool aSuccess)
2080{
2081 LogFlowThisFunc(("\n"));
2082
2083 Assert(alock.isWriteLockOnCurrentThread());
2084
2085 AssertReturn( !aSuccess
2086 || mData->mMachineState == MachineState_Snapshotting
2087 || mData->mMachineState == MachineState_OnlineSnapshotting
2088 || mData->mMachineState == MachineState_LiveSnapshotting, E_FAIL);
2089
2090 ComObjPtr<Snapshot> pOldFirstSnap = mData->mFirstSnapshot;
2091 ComObjPtr<Snapshot> pOldCurrentSnap = mData->mCurrentSnapshot;
2092
2093 HRESULT rc = S_OK;
2094
2095 if (aSuccess)
2096 {
2097 // new snapshot becomes the current one
2098 mData->mCurrentSnapshot = task.m_pSnapshot;
2099
2100 /* memorize the first snapshot if necessary */
2101 if (!mData->mFirstSnapshot)
2102 mData->mFirstSnapshot = mData->mCurrentSnapshot;
2103
2104 int flSaveSettings = SaveS_Force; // do not do a deep compare in machine settings,
2105 // snapshots change, so we know we need to save
2106 if (!task.m_fTakingSnapshotOnline)
2107 /* the machine was powered off or saved when taking a snapshot, so
2108 * reset the mCurrentStateModified flag */
2109 flSaveSettings |= SaveS_ResetCurStateModified;
2110
2111 rc = i_saveSettings(NULL, flSaveSettings);
2112 }
2113
2114 if (aSuccess && SUCCEEDED(rc))
2115 {
2116 /* associate old hard disks with the snapshot and do locking/unlocking*/
2117 i_commitMedia(task.m_fTakingSnapshotOnline);
2118 alock.release();
2119 }
2120 else
2121 {
2122 /* delete all differencing hard disks created (this will also attach
2123 * their parents back by rolling back mMediaData) */
2124 alock.release();
2125
2126 i_rollbackMedia();
2127
2128 mData->mFirstSnapshot = pOldFirstSnap; // might have been changed above
2129 mData->mCurrentSnapshot = pOldCurrentSnap; // might have been changed above
2130
2131 // delete the saved state file (it might have been already created)
2132 if (task.m_fTakingSnapshotOnline)
2133 // no need to test for whether the saved state file is shared: an online
2134 // snapshot means that a new saved state file was created, which we must
2135 // clean up now
2136 RTFileDelete(task.m_pSnapshot->i_getStateFilePath().c_str());
2137
2138 alock.acquire();
2139
2140 task.m_pSnapshot->uninit();
2141 alock.release();
2142
2143 }
2144
2145 /* clear out the snapshot data */
2146 task.m_pSnapshot.setNull();
2147
2148 /* alock has been released already */
2149 mParent->i_saveModifiedRegistries();
2150
2151 alock.acquire();
2152
2153 return rc;
2154}
2155
2156////////////////////////////////////////////////////////////////////////////////
2157//
2158// RestoreSnapshot methods (Machine and related tasks)
2159//
2160////////////////////////////////////////////////////////////////////////////////
2161
2162HRESULT Machine::restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
2163 ComPtr<IProgress> &aProgress)
2164{
2165 NOREF(aSnapshot);
2166 NOREF(aProgress);
2167 ReturnComNotImplemented();
2168}
2169
2170/**
2171 * Restoring a snapshot happens entirely on the server side, the machine cannot be running.
2172 *
2173 * This creates a new thread that does the work and returns a progress object to the client.
2174 * Actual work then takes place in RestoreSnapshotTask::handler().
2175 *
2176 * @note Locks this + children objects for writing!
2177 *
2178 * @param aSnapshot in: the snapshot to restore.
2179 * @param aProgress out: progress object to monitor restore thread.
2180 * @return
2181 */
2182HRESULT SessionMachine::restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
2183 ComPtr<IProgress> &aProgress)
2184{
2185 LogFlowThisFuncEnter();
2186
2187 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2188
2189 // machine must not be running
2190 if (Global::IsOnlineOrTransient(mData->mMachineState))
2191 return setError(VBOX_E_INVALID_VM_STATE,
2192 tr("Cannot delete the current state of the running machine (machine state: %s)"),
2193 Global::stringifyMachineState(mData->mMachineState));
2194
2195 HRESULT rc = i_checkStateDependency(MutableOrSavedStateDep);
2196 if (FAILED(rc))
2197 return rc;
2198
2199 ISnapshot* iSnapshot = aSnapshot;
2200 ComObjPtr<Snapshot> pSnapshot(static_cast<Snapshot*>(iSnapshot));
2201 ComObjPtr<SnapshotMachine> pSnapMachine = pSnapshot->i_getSnapshotMachine();
2202
2203 // create a progress object. The number of operations is:
2204 // 1 (preparing) + # of hard disks + 1 (if we need to copy the saved state file) */
2205 LogFlowThisFunc(("Going thru snapshot machine attachments to determine progress setup\n"));
2206
2207 ULONG ulOpCount = 1; // one for preparations
2208 ULONG ulTotalWeight = 1; // one for preparations
2209 for (MediumAttachmentList::iterator
2210 it = pSnapMachine->mMediumAttachments->begin();
2211 it != pSnapMachine->mMediumAttachments->end();
2212 ++it)
2213 {
2214 ComObjPtr<MediumAttachment> &pAttach = *it;
2215 AutoReadLock attachLock(pAttach COMMA_LOCKVAL_SRC_POS);
2216 if (pAttach->i_getType() == DeviceType_HardDisk)
2217 {
2218 ++ulOpCount;
2219 ++ulTotalWeight; // assume one MB weight for each differencing hard disk to manage
2220 Assert(pAttach->i_getMedium());
2221 LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount,
2222 pAttach->i_getMedium()->i_getName().c_str()));
2223 }
2224 }
2225
2226 ComObjPtr<Progress> pProgress;
2227 pProgress.createObject();
2228 pProgress->init(mParent, static_cast<IMachine*>(this),
2229 BstrFmt(tr("Restoring snapshot '%s'"), pSnapshot->i_getName().c_str()).raw(),
2230 FALSE /* aCancelable */,
2231 ulOpCount,
2232 ulTotalWeight,
2233 Bstr(tr("Restoring machine settings")).raw(),
2234 1);
2235
2236 /* create and start the task on a separate thread (note that it will not
2237 * start working until we release alock) */
2238 RestoreSnapshotTask *pTask = new RestoreSnapshotTask(this,
2239 pProgress,
2240 "RestoreSnap",
2241 pSnapshot);
2242 rc = pTask->createThread();
2243 pTask = NULL;
2244 if (FAILED(rc))
2245 return rc;
2246
2247 /* set the proper machine state (note: after creating a Task instance) */
2248 i_setMachineState(MachineState_RestoringSnapshot);
2249
2250 /* return the progress to the caller */
2251 pProgress.queryInterfaceTo(aProgress.asOutParam());
2252
2253 LogFlowThisFuncLeave();
2254
2255 return S_OK;
2256}
2257
2258/**
2259 * Worker method for the restore snapshot thread created by SessionMachine::RestoreSnapshot().
2260 * This method gets called indirectly through SessionMachine::taskHandler() which then
2261 * calls RestoreSnapshotTask::handler().
2262 *
2263 * The RestoreSnapshotTask contains the progress object returned to the console by
2264 * SessionMachine::RestoreSnapshot, through which progress and results are reported.
2265 *
2266 * @note Locks mParent + this object for writing.
2267 *
2268 * @param task Task data.
2269 */
2270void SessionMachine::i_restoreSnapshotHandler(RestoreSnapshotTask &task)
2271{
2272 LogFlowThisFuncEnter();
2273
2274 AutoCaller autoCaller(this);
2275
2276 LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
2277 if (!autoCaller.isOk())
2278 {
2279 /* we might have been uninitialized because the session was accidentally
2280 * closed by the client, so don't assert */
2281 task.m_pProgress->i_notifyComplete(E_FAIL,
2282 COM_IIDOF(IMachine),
2283 getComponentName(),
2284 tr("The session has been accidentally closed"));
2285
2286 LogFlowThisFuncLeave();
2287 return;
2288 }
2289
2290 HRESULT rc = S_OK;
2291 Guid snapshotId;
2292 std::set<ComObjPtr<Medium> > pMediumsForNotify;
2293 std::map<Guid, std::pair<DeviceType_T, BOOL> > uIdsForNotify;
2294
2295 try
2296 {
2297 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2298
2299 /* Discard all current changes to mUserData (name, OSType etc.).
2300 * Note that the machine is powered off, so there is no need to inform
2301 * the direct session. */
2302 if (mData->flModifications)
2303 i_rollback(false /* aNotify */);
2304
2305 /* Delete the saved state file if the machine was Saved prior to this
2306 * operation */
2307 if (task.m_machineStateBackup == MachineState_Saved)
2308 {
2309 Assert(!mSSData->strStateFilePath.isEmpty());
2310
2311 // release the saved state file AFTER unsetting the member variable
2312 // so that releaseSavedStateFile() won't think it's still in use
2313 Utf8Str strStateFile(mSSData->strStateFilePath);
2314 mSSData->strStateFilePath.setNull();
2315 i_releaseSavedStateFile(strStateFile, NULL /* pSnapshotToIgnore */ );
2316
2317 task.modifyBackedUpState(MachineState_PoweredOff);
2318
2319 rc = i_saveStateSettings(SaveSTS_StateFilePath);
2320 if (FAILED(rc))
2321 throw rc;
2322 }
2323
2324 RTTIMESPEC snapshotTimeStamp;
2325 RTTimeSpecSetMilli(&snapshotTimeStamp, 0);
2326
2327 {
2328 AutoReadLock snapshotLock(task.m_pSnapshot COMMA_LOCKVAL_SRC_POS);
2329
2330 /* remember the timestamp of the snapshot we're restoring from */
2331 snapshotTimeStamp = task.m_pSnapshot->i_getTimeStamp();
2332
2333 // save the snapshot ID (paranoia, here we hold the lock)
2334 snapshotId = task.m_pSnapshot->i_getId();
2335
2336 ComPtr<SnapshotMachine> pSnapshotMachine(task.m_pSnapshot->i_getSnapshotMachine());
2337
2338 /* copy all hardware data from the snapshot */
2339 i_copyFrom(pSnapshotMachine);
2340
2341 LogFlowThisFunc(("Restoring hard disks from the snapshot...\n"));
2342
2343 // restore the attachments from the snapshot
2344 i_setModified(IsModified_Storage);
2345 mMediumAttachments.backup();
2346 mMediumAttachments->clear();
2347 for (MediumAttachmentList::const_iterator
2348 it = pSnapshotMachine->mMediumAttachments->begin();
2349 it != pSnapshotMachine->mMediumAttachments->end();
2350 ++it)
2351 {
2352 ComObjPtr<MediumAttachment> pAttach;
2353 pAttach.createObject();
2354 pAttach->initCopy(this, *it);
2355 mMediumAttachments->push_back(pAttach);
2356 }
2357
2358 /* release the locks before the potentially lengthy operation */
2359 snapshotLock.release();
2360 alock.release();
2361
2362 rc = i_createImplicitDiffs(task.m_pProgress,
2363 1,
2364 false /* aOnline */);
2365 if (FAILED(rc))
2366 throw rc;
2367
2368 alock.acquire();
2369 snapshotLock.acquire();
2370
2371 /* Note: on success, current (old) hard disks will be
2372 * deassociated/deleted on #commit() called from #i_saveSettings() at
2373 * the end. On failure, newly created implicit diffs will be
2374 * deleted by #rollback() at the end. */
2375
2376 /* should not have a saved state file associated at this point */
2377 Assert(mSSData->strStateFilePath.isEmpty());
2378
2379 const Utf8Str &strSnapshotStateFile = task.m_pSnapshot->i_getStateFilePath();
2380
2381 if (strSnapshotStateFile.isNotEmpty())
2382 // online snapshot: then share the state file
2383 mSSData->strStateFilePath = strSnapshotStateFile;
2384
2385 const Utf8Str srcNVRAM(pSnapshotMachine->mNvramStore->i_getNonVolatileStorageFile());
2386 const Utf8Str dstNVRAM(mNvramStore->i_getNonVolatileStorageFile());
2387 if (dstNVRAM.isNotEmpty() && RTFileExists(dstNVRAM.c_str()))
2388 RTFileDelete(dstNVRAM.c_str());
2389 if (srcNVRAM.isNotEmpty() && dstNVRAM.isNotEmpty() && RTFileExists(srcNVRAM.c_str()))
2390 RTFileCopy(srcNVRAM.c_str(), dstNVRAM.c_str());
2391
2392 LogFlowThisFunc(("Setting new current snapshot {%RTuuid}\n", task.m_pSnapshot->i_getId().raw()));
2393 /* make the snapshot we restored from the current snapshot */
2394 mData->mCurrentSnapshot = task.m_pSnapshot;
2395 }
2396
2397 // store parent of newly created diffs for notify
2398 {
2399 MediumAttachmentList &oldAtts = *mMediumAttachments.backedUpData();
2400 for (MediumAttachmentList::const_iterator
2401 it = mMediumAttachments->begin();
2402 it != mMediumAttachments->end();
2403 ++it)
2404 {
2405 MediumAttachment *pAttach = *it;
2406 Medium *pMedium = pAttach->i_getMedium();
2407 if (!pMedium)
2408 continue;
2409
2410 bool fFound = false;
2411 /* was this medium attached before? */
2412 for (MediumAttachmentList::iterator
2413 oldIt = oldAtts.begin();
2414 oldIt != oldAtts.end();
2415 ++oldIt)
2416 {
2417 MediumAttachment *pOldAttach = *oldIt;
2418 if (pOldAttach->i_getMedium() == pMedium)
2419 {
2420 fFound = true;
2421 break;
2422 }
2423 }
2424 if (!fFound)
2425 {
2426 pMediumsForNotify.insert(pMedium->i_getParent());
2427 uIdsForNotify[pMedium->i_getId()] = std::pair<DeviceType_T, BOOL>(pMedium->i_getDeviceType(), TRUE);
2428 }
2429 }
2430 }
2431
2432 /* grab differencing hard disks from the old attachments that will
2433 * become unused and need to be auto-deleted */
2434 std::list< ComObjPtr<MediumAttachment> > llDiffAttachmentsToDelete;
2435
2436 for (MediumAttachmentList::const_iterator
2437 it = mMediumAttachments.backedUpData()->begin();
2438 it != mMediumAttachments.backedUpData()->end();
2439 ++it)
2440 {
2441 ComObjPtr<MediumAttachment> pAttach = *it;
2442 ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
2443
2444 /* while the hard disk is attached, the number of children or the
2445 * parent cannot change, so no lock */
2446 if ( !pMedium.isNull()
2447 && pAttach->i_getType() == DeviceType_HardDisk
2448 && !pMedium->i_getParent().isNull()
2449 && pMedium->i_getChildren().size() == 0
2450 )
2451 {
2452 LogFlowThisFunc(("Picked differencing image '%s' for deletion\n", pMedium->i_getName().c_str()));
2453
2454 llDiffAttachmentsToDelete.push_back(pAttach);
2455 }
2456 }
2457
2458 /* we have already deleted the current state, so set the execution
2459 * state accordingly no matter of the delete snapshot result */
2460 if (mSSData->strStateFilePath.isNotEmpty())
2461 task.modifyBackedUpState(MachineState_Saved);
2462 else
2463 task.modifyBackedUpState(MachineState_PoweredOff);
2464
2465 /* Paranoia: no one must have saved the settings in the mean time. If
2466 * it happens nevertheless we'll close our eyes and continue below. */
2467 Assert(mMediumAttachments.isBackedUp());
2468
2469 /* assign the timestamp from the snapshot */
2470 Assert(RTTimeSpecGetMilli(&snapshotTimeStamp) != 0);
2471 mData->mLastStateChange = snapshotTimeStamp;
2472
2473 // detach the current-state diffs that we detected above and build a list of
2474 // image files to delete _after_ i_saveSettings()
2475
2476 MediaList llDiffsToDelete;
2477
2478 for (std::list< ComObjPtr<MediumAttachment> >::iterator it = llDiffAttachmentsToDelete.begin();
2479 it != llDiffAttachmentsToDelete.end();
2480 ++it)
2481 {
2482 ComObjPtr<MediumAttachment> pAttach = *it; // guaranteed to have only attachments where medium != NULL
2483 ComObjPtr<Medium> pMedium = pAttach->i_getMedium();
2484
2485 AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
2486
2487 LogFlowThisFunc(("Detaching old current state in differencing image '%s'\n", pMedium->i_getName().c_str()));
2488
2489 // Normally we "detach" the medium by removing the attachment object
2490 // from the current machine data; i_saveSettings() below would then
2491 // compare the current machine data with the one in the backup
2492 // and actually call Medium::removeBackReference(). But that works only half
2493 // the time in our case so instead we force a detachment here:
2494 // remove from machine data
2495 mMediumAttachments->remove(pAttach);
2496 // Remove it from the backup or else i_saveSettings will try to detach
2497 // it again and assert. The paranoia check avoids crashes (see
2498 // assert above) if this code is buggy and saves settings in the
2499 // wrong place.
2500 if (mMediumAttachments.isBackedUp())
2501 mMediumAttachments.backedUpData()->remove(pAttach);
2502 // then clean up backrefs
2503 pMedium->i_removeBackReference(mData->mUuid);
2504
2505 llDiffsToDelete.push_back(pMedium);
2506 }
2507
2508 // save machine settings, reset the modified flag and commit;
2509 bool fNeedsGlobalSaveSettings = false;
2510 rc = i_saveSettings(&fNeedsGlobalSaveSettings,
2511 SaveS_ResetCurStateModified);
2512 if (FAILED(rc))
2513 throw rc;
2514
2515 // release the locks before updating registry and deleting image files
2516 alock.release();
2517
2518 // unconditionally add the parent registry.
2519 mParent->i_markRegistryModified(mParent->i_getGlobalRegistryId());
2520
2521 // from here on we cannot roll back on failure any more
2522
2523 for (MediaList::iterator it = llDiffsToDelete.begin();
2524 it != llDiffsToDelete.end();
2525 ++it)
2526 {
2527 ComObjPtr<Medium> &pMedium = *it;
2528 LogFlowThisFunc(("Deleting old current state in differencing image '%s'\n", pMedium->i_getName().c_str()));
2529
2530 ComObjPtr<Medium> pParent = pMedium->i_getParent();
2531 // store the id here because it becomes NULL after deleting storage.
2532 com::Guid id = pMedium->i_getId();
2533 HRESULT rc2 = pMedium->i_deleteStorage(NULL /* aProgress */,
2534 true /* aWait */,
2535 false /* aNotify */);
2536 // ignore errors here because we cannot roll back after i_saveSettings() above
2537 if (SUCCEEDED(rc2))
2538 {
2539 pMediumsForNotify.insert(pParent);
2540 uIdsForNotify[id] = std::pair<DeviceType_T, BOOL>(pMedium->i_getDeviceType(), FALSE);
2541 pMedium->uninit();
2542 }
2543 }
2544 }
2545 catch (HRESULT aRC)
2546 {
2547 rc = aRC;
2548 }
2549
2550 if (FAILED(rc))
2551 {
2552 /* preserve existing error info */
2553 ErrorInfoKeeper eik;
2554
2555 /* undo all changes on failure */
2556 i_rollback(false /* aNotify */);
2557
2558 }
2559
2560 mParent->i_saveModifiedRegistries();
2561
2562 /* restore the machine state */
2563 i_setMachineState(task.m_machineStateBackup);
2564
2565 /* set the result (this will try to fetch current error info on failure) */
2566 task.m_pProgress->i_notifyComplete(rc);
2567
2568 if (SUCCEEDED(rc))
2569 {
2570 mParent->i_onSnapshotRestored(mData->mUuid, snapshotId);
2571 for (std::map<Guid, std::pair<DeviceType_T, BOOL> >::const_iterator it = uIdsForNotify.begin();
2572 it != uIdsForNotify.end();
2573 ++it)
2574 {
2575 mParent->i_onMediumRegistered(it->first, it->second.first, it->second.second);
2576 }
2577 for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
2578 it != pMediumsForNotify.end();
2579 ++it)
2580 {
2581 if (it->isNotNull())
2582 mParent->i_onMediumConfigChanged(*it);
2583 }
2584 }
2585
2586 LogFlowThisFunc(("Done restoring snapshot (rc=%08X)\n", rc));
2587
2588 LogFlowThisFuncLeave();
2589}
2590
2591////////////////////////////////////////////////////////////////////////////////
2592//
2593// DeleteSnapshot methods (SessionMachine and related tasks)
2594//
2595////////////////////////////////////////////////////////////////////////////////
2596
2597HRESULT Machine::deleteSnapshot(const com::Guid &aId, ComPtr<IProgress> &aProgress)
2598{
2599 NOREF(aId);
2600 NOREF(aProgress);
2601 ReturnComNotImplemented();
2602}
2603
2604HRESULT SessionMachine::deleteSnapshot(const com::Guid &aId, ComPtr<IProgress> &aProgress)
2605{
2606 return i_deleteSnapshot(aId, aId,
2607 FALSE /* fDeleteAllChildren */,
2608 aProgress);
2609}
2610
2611HRESULT Machine::deleteSnapshotAndAllChildren(const com::Guid &aId, ComPtr<IProgress> &aProgress)
2612{
2613 NOREF(aId);
2614 NOREF(aProgress);
2615 ReturnComNotImplemented();
2616}
2617
2618HRESULT SessionMachine::deleteSnapshotAndAllChildren(const com::Guid &aId, ComPtr<IProgress> &aProgress)
2619{
2620 return i_deleteSnapshot(aId, aId,
2621 TRUE /* fDeleteAllChildren */,
2622 aProgress);
2623}
2624
2625HRESULT Machine::deleteSnapshotRange(const com::Guid &aStartId, const com::Guid &aEndId, ComPtr<IProgress> &aProgress)
2626{
2627 NOREF(aStartId);
2628 NOREF(aEndId);
2629 NOREF(aProgress);
2630 ReturnComNotImplemented();
2631}
2632
2633HRESULT SessionMachine::deleteSnapshotRange(const com::Guid &aStartId, const com::Guid &aEndId, ComPtr<IProgress> &aProgress)
2634{
2635 return i_deleteSnapshot(aStartId, aEndId,
2636 FALSE /* fDeleteAllChildren */,
2637 aProgress);
2638}
2639
2640
2641/**
2642 * Implementation for SessionMachine::i_deleteSnapshot().
2643 *
2644 * Gets called from SessionMachine::DeleteSnapshot(). Deleting a snapshot
2645 * happens entirely on the server side if the machine is not running, and
2646 * if it is running then the merges are done via internal session callbacks.
2647 *
2648 * This creates a new thread that does the work and returns a progress
2649 * object to the client.
2650 *
2651 * Actual work then takes place in SessionMachine::i_deleteSnapshotHandler().
2652 *
2653 * @note Locks mParent + this + children objects for writing!
2654 */
2655HRESULT SessionMachine::i_deleteSnapshot(const com::Guid &aStartId,
2656 const com::Guid &aEndId,
2657 BOOL aDeleteAllChildren,
2658 ComPtr<IProgress> &aProgress)
2659{
2660 LogFlowThisFuncEnter();
2661
2662 AssertReturn(!aStartId.isZero() && !aEndId.isZero() && aStartId.isValid() && aEndId.isValid(), E_INVALIDARG);
2663
2664 /** @todo implement the "and all children" and "range" variants */
2665 if (aDeleteAllChildren || aStartId != aEndId)
2666 ReturnComNotImplemented();
2667
2668 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
2669
2670 if (Global::IsTransient(mData->mMachineState))
2671 return setError(VBOX_E_INVALID_VM_STATE,
2672 tr("Cannot delete a snapshot of the machine while it is changing the state (machine state: %s)"),
2673 Global::stringifyMachineState(mData->mMachineState));
2674
2675 // be very picky about machine states
2676 if ( Global::IsOnlineOrTransient(mData->mMachineState)
2677 && mData->mMachineState != MachineState_PoweredOff
2678 && mData->mMachineState != MachineState_Saved
2679 && mData->mMachineState != MachineState_Teleported
2680 && mData->mMachineState != MachineState_Aborted
2681 && mData->mMachineState != MachineState_Running
2682 && mData->mMachineState != MachineState_Paused)
2683 return setError(VBOX_E_INVALID_VM_STATE,
2684 tr("Invalid machine state: %s"),
2685 Global::stringifyMachineState(mData->mMachineState));
2686
2687 HRESULT rc = i_checkStateDependency(MutableOrSavedOrRunningStateDep);
2688 if (FAILED(rc))
2689 return rc;
2690
2691 ComObjPtr<Snapshot> pSnapshot;
2692 rc = i_findSnapshotById(aStartId, pSnapshot, true /* aSetError */);
2693 if (FAILED(rc))
2694 return rc;
2695
2696 AutoWriteLock snapshotLock(pSnapshot COMMA_LOCKVAL_SRC_POS);
2697 Utf8Str str;
2698
2699 size_t childrenCount = pSnapshot->i_getChildrenCount();
2700 if (childrenCount > 1)
2701 return setError(VBOX_E_INVALID_OBJECT_STATE,
2702 tr("Snapshot '%s' of the machine '%s' cannot be deleted, because it has %d child snapshots, which is more than the one snapshot allowed for deletion"),
2703 pSnapshot->i_getName().c_str(),
2704 mUserData->s.strName.c_str(),
2705 childrenCount);
2706
2707 if (pSnapshot == mData->mCurrentSnapshot && childrenCount >= 1)
2708 return setError(VBOX_E_INVALID_OBJECT_STATE,
2709 tr("Snapshot '%s' of the machine '%s' cannot be deleted, because it is the current snapshot and has one child snapshot"),
2710 pSnapshot->i_getName().c_str(),
2711 mUserData->s.strName.c_str());
2712
2713 /* If the snapshot being deleted is the current one, ensure current
2714 * settings are committed and saved.
2715 */
2716 if (pSnapshot == mData->mCurrentSnapshot)
2717 {
2718 if (mData->flModifications)
2719 {
2720 rc = i_saveSettings(NULL);
2721 // no need to change for whether VirtualBox.xml needs saving since
2722 // we can't have a machine XML rename pending at this point
2723 if (FAILED(rc)) return rc;
2724 }
2725 }
2726
2727 ComObjPtr<SnapshotMachine> pSnapMachine = pSnapshot->i_getSnapshotMachine();
2728
2729 /* create a progress object. The number of operations is:
2730 * 1 (preparing) + 1 if the snapshot is online + # of normal hard disks
2731 */
2732 LogFlowThisFunc(("Going thru snapshot machine attachments to determine progress setup\n"));
2733
2734 ULONG ulOpCount = 1; // one for preparations
2735 ULONG ulTotalWeight = 1; // one for preparations
2736
2737 if (pSnapshot->i_getStateFilePath().isNotEmpty())
2738 {
2739 ++ulOpCount;
2740 ++ulTotalWeight; // assume 1 MB for deleting the state file
2741 }
2742
2743 bool fDeleteOnline = mData->mMachineState == MachineState_Running || mData->mMachineState == MachineState_Paused;
2744
2745 // count normal hard disks and add their sizes to the weight
2746 for (MediumAttachmentList::iterator
2747 it = pSnapMachine->mMediumAttachments->begin();
2748 it != pSnapMachine->mMediumAttachments->end();
2749 ++it)
2750 {
2751 ComObjPtr<MediumAttachment> &pAttach = *it;
2752 AutoReadLock attachLock(pAttach COMMA_LOCKVAL_SRC_POS);
2753 if (pAttach->i_getType() == DeviceType_HardDisk)
2754 {
2755 ComObjPtr<Medium> pHD = pAttach->i_getMedium();
2756 Assert(pHD);
2757 AutoReadLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
2758
2759 MediumType_T type = pHD->i_getType();
2760 // writethrough and shareable images are unaffected by snapshots,
2761 // so do nothing for them
2762 if ( type != MediumType_Writethrough
2763 && type != MediumType_Shareable
2764 && type != MediumType_Readonly)
2765 {
2766 // normal or immutable media need attention
2767 ++ulOpCount;
2768 // offline merge includes medium resizing
2769 if (!fDeleteOnline)
2770 ++ulOpCount;
2771 ulTotalWeight += (ULONG)(pHD->i_getSize() / _1M);
2772 }
2773 LogFlowThisFunc(("op %d: considering hard disk attachment %s\n", ulOpCount, pHD->i_getName().c_str()));
2774 }
2775 }
2776
2777 ComObjPtr<Progress> pProgress;
2778 pProgress.createObject();
2779 pProgress->init(mParent, static_cast<IMachine*>(this),
2780 BstrFmt(tr("Deleting snapshot '%s'"), pSnapshot->i_getName().c_str()).raw(),
2781 FALSE /* aCancelable */,
2782 ulOpCount,
2783 ulTotalWeight,
2784 Bstr(tr("Setting up")).raw(),
2785 1);
2786
2787 /* create and start the task on a separate thread */
2788 DeleteSnapshotTask *pTask = new DeleteSnapshotTask(this, pProgress,
2789 "DeleteSnap",
2790 fDeleteOnline,
2791 pSnapshot);
2792 rc = pTask->createThread();
2793 pTask = NULL;
2794 if (FAILED(rc))
2795 return rc;
2796
2797 // the task might start running but will block on acquiring the machine's write lock
2798 // which we acquired above; once this function leaves, the task will be unblocked;
2799 // set the proper machine state here now (note: after creating a Task instance)
2800 if (mData->mMachineState == MachineState_Running)
2801 {
2802 i_setMachineState(MachineState_DeletingSnapshotOnline);
2803 i_updateMachineStateOnClient();
2804 }
2805 else if (mData->mMachineState == MachineState_Paused)
2806 {
2807 i_setMachineState(MachineState_DeletingSnapshotPaused);
2808 i_updateMachineStateOnClient();
2809 }
2810 else
2811 i_setMachineState(MachineState_DeletingSnapshot);
2812
2813 /* return the progress to the caller */
2814 pProgress.queryInterfaceTo(aProgress.asOutParam());
2815
2816 LogFlowThisFuncLeave();
2817
2818 return S_OK;
2819}
2820
2821/**
2822 * Helper struct for SessionMachine::deleteSnapshotHandler().
2823 */
2824struct MediumDeleteRec
2825{
2826 MediumDeleteRec()
2827 : mfNeedsOnlineMerge(false),
2828 mpMediumLockList(NULL)
2829 {}
2830
2831 MediumDeleteRec(const ComObjPtr<Medium> &aHd,
2832 const ComObjPtr<Medium> &aSource,
2833 const ComObjPtr<Medium> &aTarget,
2834 const ComObjPtr<MediumAttachment> &aOnlineMediumAttachment,
2835 bool fMergeForward,
2836 const ComObjPtr<Medium> &aParentForTarget,
2837 MediumLockList *aChildrenToReparent,
2838 bool fNeedsOnlineMerge,
2839 MediumLockList *aMediumLockList,
2840 const ComPtr<IToken> &aHDLockToken)
2841 : mpHD(aHd),
2842 mpSource(aSource),
2843 mpTarget(aTarget),
2844 mpOnlineMediumAttachment(aOnlineMediumAttachment),
2845 mfMergeForward(fMergeForward),
2846 mpParentForTarget(aParentForTarget),
2847 mpChildrenToReparent(aChildrenToReparent),
2848 mfNeedsOnlineMerge(fNeedsOnlineMerge),
2849 mpMediumLockList(aMediumLockList),
2850 mpHDLockToken(aHDLockToken)
2851 {}
2852
2853 MediumDeleteRec(const ComObjPtr<Medium> &aHd,
2854 const ComObjPtr<Medium> &aSource,
2855 const ComObjPtr<Medium> &aTarget,
2856 const ComObjPtr<MediumAttachment> &aOnlineMediumAttachment,
2857 bool fMergeForward,
2858 const ComObjPtr<Medium> &aParentForTarget,
2859 MediumLockList *aChildrenToReparent,
2860 bool fNeedsOnlineMerge,
2861 MediumLockList *aMediumLockList,
2862 const ComPtr<IToken> &aHDLockToken,
2863 const Guid &aMachineId,
2864 const Guid &aSnapshotId)
2865 : mpHD(aHd),
2866 mpSource(aSource),
2867 mpTarget(aTarget),
2868 mpOnlineMediumAttachment(aOnlineMediumAttachment),
2869 mfMergeForward(fMergeForward),
2870 mpParentForTarget(aParentForTarget),
2871 mpChildrenToReparent(aChildrenToReparent),
2872 mfNeedsOnlineMerge(fNeedsOnlineMerge),
2873 mpMediumLockList(aMediumLockList),
2874 mpHDLockToken(aHDLockToken),
2875 mMachineId(aMachineId),
2876 mSnapshotId(aSnapshotId)
2877 {}
2878
2879 ComObjPtr<Medium> mpHD;
2880 ComObjPtr<Medium> mpSource;
2881 ComObjPtr<Medium> mpTarget;
2882 ComObjPtr<MediumAttachment> mpOnlineMediumAttachment;
2883 bool mfMergeForward;
2884 ComObjPtr<Medium> mpParentForTarget;
2885 MediumLockList *mpChildrenToReparent;
2886 bool mfNeedsOnlineMerge;
2887 MediumLockList *mpMediumLockList;
2888 /** optional lock token, used only in case mpHD is not merged/deleted */
2889 ComPtr<IToken> mpHDLockToken;
2890 /* these are for reattaching the hard disk in case of a failure: */
2891 Guid mMachineId;
2892 Guid mSnapshotId;
2893};
2894
2895typedef std::list<MediumDeleteRec> MediumDeleteRecList;
2896
2897/**
2898 * Worker method for the delete snapshot thread created by
2899 * SessionMachine::DeleteSnapshot(). This method gets called indirectly
2900 * through SessionMachine::taskHandler() which then calls
2901 * DeleteSnapshotTask::handler().
2902 *
2903 * The DeleteSnapshotTask contains the progress object returned to the console
2904 * by SessionMachine::DeleteSnapshot, through which progress and results are
2905 * reported.
2906 *
2907 * SessionMachine::DeleteSnapshot() has set the machine state to
2908 * MachineState_DeletingSnapshot right after creating this task. Since we block
2909 * on the machine write lock at the beginning, once that has been acquired, we
2910 * can assume that the machine state is indeed that.
2911 *
2912 * @note Locks the machine + the snapshot + the media tree for writing!
2913 *
2914 * @param task Task data.
2915 */
2916void SessionMachine::i_deleteSnapshotHandler(DeleteSnapshotTask &task)
2917{
2918 LogFlowThisFuncEnter();
2919
2920 MultiResult mrc(S_OK);
2921 AutoCaller autoCaller(this);
2922 LogFlowThisFunc(("state=%d\n", getObjectState().getState()));
2923 if (FAILED(autoCaller.rc()))
2924 {
2925 /* we might have been uninitialized because the session was accidentally
2926 * closed by the client, so don't assert */
2927 mrc = setError(E_FAIL,
2928 tr("The session has been accidentally closed"));
2929 task.m_pProgress->i_notifyComplete(mrc);
2930 LogFlowThisFuncLeave();
2931 return;
2932 }
2933
2934 MediumDeleteRecList toDelete;
2935 Guid snapshotId;
2936 std::set<ComObjPtr<Medium> > pMediumsForNotify;
2937 std::map<Guid,DeviceType_T> uIdsForNotify;
2938
2939 try
2940 {
2941 HRESULT rc = S_OK;
2942
2943 /* Locking order: */
2944 AutoMultiWriteLock2 multiLock(this->lockHandle(), // machine
2945 task.m_pSnapshot->lockHandle() // snapshot
2946 COMMA_LOCKVAL_SRC_POS);
2947 // once we have this lock, we know that SessionMachine::DeleteSnapshot()
2948 // has exited after setting the machine state to MachineState_DeletingSnapshot
2949
2950 AutoWriteLock treeLock(mParent->i_getMediaTreeLockHandle()
2951 COMMA_LOCKVAL_SRC_POS);
2952
2953 ComObjPtr<SnapshotMachine> pSnapMachine = task.m_pSnapshot->i_getSnapshotMachine();
2954 // no need to lock the snapshot machine since it is const by definition
2955 Guid machineId = pSnapMachine->i_getId();
2956
2957 // save the snapshot ID (for callbacks)
2958 snapshotId = task.m_pSnapshot->i_getId();
2959
2960 // first pass:
2961 LogFlowThisFunc(("1: Checking hard disk merge prerequisites...\n"));
2962
2963 // Go thru the attachments of the snapshot machine (the media in here
2964 // point to the disk states _before_ the snapshot was taken, i.e. the
2965 // state we're restoring to; for each such medium, we will need to
2966 // merge it with its one and only child (the diff image holding the
2967 // changes written after the snapshot was taken).
2968 for (MediumAttachmentList::iterator
2969 it = pSnapMachine->mMediumAttachments->begin();
2970 it != pSnapMachine->mMediumAttachments->end();
2971 ++it)
2972 {
2973 ComObjPtr<MediumAttachment> &pAttach = *it;
2974 AutoReadLock attachLock(pAttach COMMA_LOCKVAL_SRC_POS);
2975 if (pAttach->i_getType() != DeviceType_HardDisk)
2976 continue;
2977
2978 ComObjPtr<Medium> pHD = pAttach->i_getMedium();
2979 Assert(!pHD.isNull());
2980
2981 {
2982 // writethrough, shareable and readonly images are
2983 // unaffected by snapshots, skip them
2984 AutoReadLock medlock(pHD COMMA_LOCKVAL_SRC_POS);
2985 MediumType_T type = pHD->i_getType();
2986 if ( type == MediumType_Writethrough
2987 || type == MediumType_Shareable
2988 || type == MediumType_Readonly)
2989 continue;
2990 }
2991
2992#ifdef DEBUG
2993 pHD->i_dumpBackRefs();
2994#endif
2995
2996 // needs to be merged with child or deleted, check prerequisites
2997 ComObjPtr<Medium> pTarget;
2998 ComObjPtr<Medium> pSource;
2999 bool fMergeForward = false;
3000 ComObjPtr<Medium> pParentForTarget;
3001 MediumLockList *pChildrenToReparent = NULL;
3002 bool fNeedsOnlineMerge = false;
3003 bool fOnlineMergePossible = task.m_fDeleteOnline;
3004 MediumLockList *pMediumLockList = NULL;
3005 MediumLockList *pVMMALockList = NULL;
3006 ComPtr<IToken> pHDLockToken;
3007 ComObjPtr<MediumAttachment> pOnlineMediumAttachment;
3008 if (fOnlineMergePossible)
3009 {
3010 // Look up the corresponding medium attachment in the currently
3011 // running VM. Any failure prevents a live merge. Could be made
3012 // a tad smarter by trying a few candidates, so that e.g. disks
3013 // which are simply moved to a different controller slot do not
3014 // prevent online merging in general.
3015 pOnlineMediumAttachment =
3016 i_findAttachment(*mMediumAttachments.data(),
3017 pAttach->i_getControllerName(),
3018 pAttach->i_getPort(),
3019 pAttach->i_getDevice());
3020 if (pOnlineMediumAttachment)
3021 {
3022 rc = mData->mSession.mLockedMedia.Get(pOnlineMediumAttachment,
3023 pVMMALockList);
3024 if (FAILED(rc))
3025 fOnlineMergePossible = false;
3026 }
3027 else
3028 fOnlineMergePossible = false;
3029 }
3030
3031 // no need to hold the lock any longer
3032 attachLock.release();
3033
3034 treeLock.release();
3035 rc = i_prepareDeleteSnapshotMedium(pHD, machineId, snapshotId,
3036 fOnlineMergePossible,
3037 pVMMALockList, pSource, pTarget,
3038 fMergeForward, pParentForTarget,
3039 pChildrenToReparent,
3040 fNeedsOnlineMerge,
3041 pMediumLockList,
3042 pHDLockToken);
3043 treeLock.acquire();
3044 if (FAILED(rc))
3045 throw rc;
3046
3047 // For simplicity, prepareDeleteSnapshotMedium selects the merge
3048 // direction in the following way: we merge pHD onto its child
3049 // (forward merge), not the other way round, because that saves us
3050 // from unnecessarily shuffling around the attachments for the
3051 // machine that follows the snapshot (next snapshot or current
3052 // state), unless it's a base image. Backwards merges of the first
3053 // snapshot into the base image is essential, as it ensures that
3054 // when all snapshots are deleted the only remaining image is a
3055 // base image. Important e.g. for medium formats which do not have
3056 // a file representation such as iSCSI.
3057
3058 // not going to merge a big source into a small target on online merge. Otherwise it will be resized
3059 if (fNeedsOnlineMerge && pSource->i_getLogicalSize() > pTarget->i_getLogicalSize())
3060 {
3061 rc = setError(E_FAIL,
3062 tr("Unable to merge storage '%s', because it is smaller than the source image. If you resize it to have a capacity of at least %lld bytes you can retry"),
3063 pTarget->i_getLocationFull().c_str(), pSource->i_getLogicalSize());
3064 throw rc;
3065 }
3066
3067 // a couple paranoia checks for backward merges
3068 if (pMediumLockList != NULL && !fMergeForward)
3069 {
3070 // parent is null -> this disk is a base hard disk: we will
3071 // then do a backward merge, i.e. merge its only child onto the
3072 // base disk. Here we need then to update the attachment that
3073 // refers to the child and have it point to the parent instead
3074 Assert(pHD->i_getChildren().size() == 1);
3075
3076 ComObjPtr<Medium> pReplaceHD = pHD->i_getChildren().front();
3077
3078 ComAssertThrow(pReplaceHD == pSource, E_FAIL);
3079 }
3080
3081 Guid replaceMachineId;
3082 Guid replaceSnapshotId;
3083
3084 const Guid *pReplaceMachineId = pSource->i_getFirstMachineBackrefId();
3085 // minimal sanity checking
3086 Assert(!pReplaceMachineId || *pReplaceMachineId == mData->mUuid);
3087 if (pReplaceMachineId)
3088 replaceMachineId = *pReplaceMachineId;
3089
3090 const Guid *pSnapshotId = pSource->i_getFirstMachineBackrefSnapshotId();
3091 if (pSnapshotId)
3092 replaceSnapshotId = *pSnapshotId;
3093
3094 if (replaceMachineId.isValid() && !replaceMachineId.isZero())
3095 {
3096 // Adjust the backreferences, otherwise merging will assert.
3097 // Note that the medium attachment object stays associated
3098 // with the snapshot until the merge was successful.
3099 HRESULT rc2 = S_OK;
3100 rc2 = pSource->i_removeBackReference(replaceMachineId, replaceSnapshotId);
3101 AssertComRC(rc2);
3102
3103 toDelete.push_back(MediumDeleteRec(pHD, pSource, pTarget,
3104 pOnlineMediumAttachment,
3105 fMergeForward,
3106 pParentForTarget,
3107 pChildrenToReparent,
3108 fNeedsOnlineMerge,
3109 pMediumLockList,
3110 pHDLockToken,
3111 replaceMachineId,
3112 replaceSnapshotId));
3113 }
3114 else
3115 toDelete.push_back(MediumDeleteRec(pHD, pSource, pTarget,
3116 pOnlineMediumAttachment,
3117 fMergeForward,
3118 pParentForTarget,
3119 pChildrenToReparent,
3120 fNeedsOnlineMerge,
3121 pMediumLockList,
3122 pHDLockToken));
3123 }
3124
3125 {
3126 /* check available space on the storage */
3127 RTFOFF pcbTotal = 0;
3128 RTFOFF pcbFree = 0;
3129 uint32_t pcbBlock = 0;
3130 uint32_t pcbSector = 0;
3131 std::multimap<uint32_t, uint64_t> neededStorageFreeSpace;
3132 std::map<uint32_t, const char*> serialMapToStoragePath;
3133
3134 for (MediumDeleteRecList::const_iterator
3135 it = toDelete.begin();
3136 it != toDelete.end();
3137 ++it)
3138 {
3139 uint64_t diskSize = 0;
3140 uint32_t pu32Serial = 0;
3141 ComObjPtr<Medium> pSource_local = it->mpSource;
3142 ComObjPtr<Medium> pTarget_local = it->mpTarget;
3143 ComPtr<IMediumFormat> pTargetFormat;
3144
3145 {
3146 if ( pSource_local.isNull()
3147 || pSource_local == pTarget_local)
3148 continue;
3149 }
3150
3151 rc = pTarget_local->COMGETTER(MediumFormat)(pTargetFormat.asOutParam());
3152 if (FAILED(rc))
3153 throw rc;
3154
3155 if (pTarget_local->i_isMediumFormatFile())
3156 {
3157 int vrc = RTFsQuerySerial(pTarget_local->i_getLocationFull().c_str(), &pu32Serial);
3158 if (RT_FAILURE(vrc))
3159 {
3160 rc = setError(E_FAIL,
3161 tr("Unable to merge storage '%s'. Can't get storage UID"),
3162 pTarget_local->i_getLocationFull().c_str());
3163 throw rc;
3164 }
3165
3166 pSource_local->COMGETTER(Size)((LONG64*)&diskSize);
3167
3168 /** @todo r=klaus this is too pessimistic... should take
3169 * the current size and maximum size of the target image
3170 * into account, because a X GB image with Y GB capacity
3171 * can only grow by Y-X GB (ignoring overhead, which
3172 * unfortunately is hard to estimate, some have next to
3173 * nothing, some have a certain percentage...) */
3174 /* store needed free space in multimap */
3175 neededStorageFreeSpace.insert(std::make_pair(pu32Serial, diskSize));
3176 /* linking storage UID with snapshot path, it is a helper container (just for easy finding needed path) */
3177 serialMapToStoragePath.insert(std::make_pair(pu32Serial, pTarget_local->i_getLocationFull().c_str()));
3178 }
3179 }
3180
3181 while (!neededStorageFreeSpace.empty())
3182 {
3183 std::pair<std::multimap<uint32_t,uint64_t>::iterator,std::multimap<uint32_t,uint64_t>::iterator> ret;
3184 uint64_t commonSourceStoragesSize = 0;
3185
3186 /* find all records in multimap with identical storage UID */
3187 ret = neededStorageFreeSpace.equal_range(neededStorageFreeSpace.begin()->first);
3188 std::multimap<uint32_t,uint64_t>::const_iterator it_ns = ret.first;
3189
3190 for (; it_ns != ret.second ; ++it_ns)
3191 {
3192 commonSourceStoragesSize += it_ns->second;
3193 }
3194
3195 /* find appropriate path by storage UID */
3196 std::map<uint32_t,const char*>::const_iterator it_sm = serialMapToStoragePath.find(ret.first->first);
3197 /* get info about a storage */
3198 if (it_sm == serialMapToStoragePath.end())
3199 {
3200 LogFlowThisFunc(("Path to the storage wasn't found...\n"));
3201
3202 rc = setError(E_INVALIDARG,
3203 tr("Unable to merge storage '%s'. Path to the storage wasn't found"),
3204 it_sm->second);
3205 throw rc;
3206 }
3207
3208 int vrc = RTFsQuerySizes(it_sm->second, &pcbTotal, &pcbFree, &pcbBlock, &pcbSector);
3209 if (RT_FAILURE(vrc))
3210 {
3211 rc = setError(E_FAIL,
3212 tr("Unable to merge storage '%s'. Can't get the storage size"),
3213 it_sm->second);
3214 throw rc;
3215 }
3216
3217 if (commonSourceStoragesSize > (uint64_t)pcbFree)
3218 {
3219 LogFlowThisFunc(("Not enough free space to merge...\n"));
3220
3221 rc = setError(E_OUTOFMEMORY,
3222 tr("Unable to merge storage '%s'. Not enough free storage space"),
3223 it_sm->second);
3224 throw rc;
3225 }
3226
3227 neededStorageFreeSpace.erase(ret.first, ret.second);
3228 }
3229
3230 serialMapToStoragePath.clear();
3231 }
3232
3233 // we can release the locks now since the machine state is MachineState_DeletingSnapshot
3234 treeLock.release();
3235 multiLock.release();
3236
3237 /* Now we checked that we can successfully merge all normal hard disks
3238 * (unless a runtime error like end-of-disc happens). Now get rid of
3239 * the saved state (if present), as that will free some disk space.
3240 * The snapshot itself will be deleted as late as possible, so that
3241 * the user can repeat the delete operation if he runs out of disk
3242 * space or cancels the delete operation. */
3243
3244 /* second pass: */
3245 LogFlowThisFunc(("2: Deleting saved state...\n"));
3246
3247 {
3248 // saveAllSnapshots() needs a machine lock, and the snapshots
3249 // tree is protected by the machine lock as well
3250 AutoWriteLock machineLock(this COMMA_LOCKVAL_SRC_POS);
3251
3252 Utf8Str stateFilePath = task.m_pSnapshot->i_getStateFilePath();
3253 if (!stateFilePath.isEmpty())
3254 {
3255 task.m_pProgress->SetNextOperation(Bstr(tr("Deleting the execution state")).raw(),
3256 1); // weight
3257
3258 i_releaseSavedStateFile(stateFilePath, task.m_pSnapshot /* pSnapshotToIgnore */);
3259
3260 // machine will need saving now
3261 machineLock.release();
3262 mParent->i_markRegistryModified(i_getId());
3263 }
3264 }
3265
3266 /* third pass: */
3267 LogFlowThisFunc(("3: Performing actual hard disk merging...\n"));
3268
3269 /// @todo NEWMEDIA turn the following errors into warnings because the
3270 /// snapshot itself has been already deleted (and interpret these
3271 /// warnings properly on the GUI side)
3272 for (MediumDeleteRecList::iterator it = toDelete.begin();
3273 it != toDelete.end();)
3274 {
3275 const ComObjPtr<Medium> &pMedium(it->mpHD);
3276 ULONG ulWeight;
3277
3278 {
3279 AutoReadLock alock(pMedium COMMA_LOCKVAL_SRC_POS);
3280 ulWeight = (ULONG)(pMedium->i_getSize() / _1M);
3281 }
3282
3283 const char *pszOperationText = it->mfNeedsOnlineMerge ?
3284 tr("Merging differencing image '%s'")
3285 : tr("Resizing before merge differencing image '%s'");
3286
3287 task.m_pProgress->SetNextOperation(BstrFmt(pszOperationText,
3288 pMedium->i_getName().c_str()).raw(),
3289 ulWeight);
3290
3291 bool fNeedSourceUninit = false;
3292 bool fReparentTarget = false;
3293 if (it->mpMediumLockList == NULL)
3294 {
3295 /* no real merge needed, just updating state and delete
3296 * diff files if necessary */
3297 AutoMultiWriteLock2 mLock(&mParent->i_getMediaTreeLockHandle(), pMedium->lockHandle() COMMA_LOCKVAL_SRC_POS);
3298
3299 Assert( !it->mfMergeForward
3300 || pMedium->i_getChildren().size() == 0);
3301
3302 /* Delete the differencing hard disk (has no children). Two
3303 * exceptions: if it's the last medium in the chain or if it's
3304 * a backward merge we don't want to handle due to complexity.
3305 * In both cases leave the image in place. If it's the first
3306 * exception the user can delete it later if he wants. */
3307 if (!pMedium->i_getParent().isNull())
3308 {
3309 Assert(pMedium->i_getState() == MediumState_Deleting);
3310 /* No need to hold the lock any longer. */
3311 mLock.release();
3312 ComObjPtr<Medium> pParent = pMedium->i_getParent();
3313 Guid uMedium = pMedium->i_getId();
3314 DeviceType_T uMediumType = pMedium->i_getDeviceType();
3315 rc = pMedium->i_deleteStorage(&task.m_pProgress,
3316 true /* aWait */,
3317 false /* aNotify */);
3318 if (FAILED(rc))
3319 throw rc;
3320
3321 pMediumsForNotify.insert(pParent);
3322 uIdsForNotify[uMedium] = uMediumType;
3323
3324 // need to uninit the deleted medium
3325 fNeedSourceUninit = true;
3326 }
3327 }
3328 else
3329 {
3330 {
3331 //store ids before merging for notify
3332 pMediumsForNotify.insert(it->mpTarget);
3333 if (it->mfMergeForward)
3334 pMediumsForNotify.insert(it->mpSource->i_getParent());
3335 else
3336 {
3337 //children which will be reparented to target
3338 for (MediaList::const_iterator iit = it->mpSource->i_getChildren().begin();
3339 iit != it->mpSource->i_getChildren().end();
3340 ++iit)
3341 {
3342 pMediumsForNotify.insert(*iit);
3343 }
3344 }
3345 if (it->mfMergeForward)
3346 {
3347 for (ComObjPtr<Medium> pTmpMedium = it->mpTarget->i_getParent();
3348 pTmpMedium && pTmpMedium != it->mpSource;
3349 pTmpMedium = pTmpMedium->i_getParent())
3350 {
3351 uIdsForNotify[pTmpMedium->i_getId()] = pTmpMedium->i_getDeviceType();
3352 }
3353 uIdsForNotify[it->mpSource->i_getId()] = it->mpSource->i_getDeviceType();
3354 }
3355 else
3356 {
3357 for (ComObjPtr<Medium> pTmpMedium = it->mpSource;
3358 pTmpMedium && pTmpMedium != it->mpTarget;
3359 pTmpMedium = pTmpMedium->i_getParent())
3360 {
3361 uIdsForNotify[pTmpMedium->i_getId()] = pTmpMedium->i_getDeviceType();
3362 }
3363 }
3364 }
3365
3366 bool fNeedsSave = false;
3367 if (it->mfNeedsOnlineMerge)
3368 {
3369 // Put the medium merge information (MediumDeleteRec) where
3370 // SessionMachine::FinishOnlineMergeMedium can get at it.
3371 // This callback will arrive while onlineMergeMedium is
3372 // still executing, and there can't be two tasks.
3373 /// @todo r=klaus this hack needs to go, and the logic needs to be "unconvoluted", putting SessionMachine in charge of coordinating the reconfig/resume.
3374 mConsoleTaskData.mDeleteSnapshotInfo = (void *)&(*it);
3375 // online medium merge, in the direction decided earlier
3376 rc = i_onlineMergeMedium(it->mpOnlineMediumAttachment,
3377 it->mpSource,
3378 it->mpTarget,
3379 it->mfMergeForward,
3380 it->mpParentForTarget,
3381 it->mpChildrenToReparent,
3382 it->mpMediumLockList,
3383 task.m_pProgress,
3384 &fNeedsSave);
3385 mConsoleTaskData.mDeleteSnapshotInfo = NULL;
3386 }
3387 else
3388 {
3389 // normal medium merge, in the direction decided earlier
3390 rc = it->mpSource->i_mergeTo(it->mpTarget,
3391 it->mfMergeForward,
3392 it->mpParentForTarget,
3393 it->mpChildrenToReparent,
3394 it->mpMediumLockList,
3395 &task.m_pProgress,
3396 true /* aWait */,
3397 false /* aNotify */);
3398 }
3399
3400 // If the merge failed, we need to do our best to have a usable
3401 // VM configuration afterwards. The return code doesn't tell
3402 // whether the merge completed and so we have to check if the
3403 // source medium (diff images are always file based at the
3404 // moment) is still there or not. Be careful not to lose the
3405 // error code below, before the "Delayed failure exit".
3406 if (FAILED(rc))
3407 {
3408 AutoReadLock mlock(it->mpSource COMMA_LOCKVAL_SRC_POS);
3409 if (!it->mpSource->i_isMediumFormatFile())
3410 // Diff medium not backed by a file - cannot get status so
3411 // be pessimistic.
3412 throw rc;
3413 const Utf8Str &loc = it->mpSource->i_getLocationFull();
3414 // Source medium is still there, so merge failed early.
3415 if (RTFileExists(loc.c_str()))
3416 throw rc;
3417
3418 // Source medium is gone. Assume the merge succeeded and
3419 // thus it's safe to remove the attachment. We use the
3420 // "Delayed failure exit" below.
3421 }
3422
3423 // need to change the medium attachment for backward merges
3424 fReparentTarget = !it->mfMergeForward;
3425
3426 if (!it->mfNeedsOnlineMerge)
3427 {
3428 // need to uninit the medium deleted by the merge
3429 fNeedSourceUninit = true;
3430
3431 // delete the no longer needed medium lock list, which
3432 // implicitly handled the unlocking
3433 delete it->mpMediumLockList;
3434 it->mpMediumLockList = NULL;
3435 }
3436 }
3437
3438 // Now that the medium is successfully merged/deleted/whatever,
3439 // remove the medium attachment from the snapshot. For a backwards
3440 // merge the target attachment needs to be removed from the
3441 // snapshot, as the VM will take it over. For forward merges the
3442 // source medium attachment needs to be removed.
3443 ComObjPtr<MediumAttachment> pAtt;
3444 if (fReparentTarget)
3445 {
3446 pAtt = i_findAttachment(*(pSnapMachine->mMediumAttachments.data()),
3447 it->mpTarget);
3448 it->mpTarget->i_removeBackReference(machineId, snapshotId);
3449 }
3450 else
3451 pAtt = i_findAttachment(*(pSnapMachine->mMediumAttachments.data()),
3452 it->mpSource);
3453 pSnapMachine->mMediumAttachments->remove(pAtt);
3454
3455 if (fReparentTarget)
3456 {
3457 // Search for old source attachment and replace with target.
3458 // There can be only one child snapshot in this case.
3459 ComObjPtr<Machine> pMachine = this;
3460 Guid childSnapshotId;
3461 ComObjPtr<Snapshot> pChildSnapshot = task.m_pSnapshot->i_getFirstChild();
3462 if (pChildSnapshot)
3463 {
3464 pMachine = pChildSnapshot->i_getSnapshotMachine();
3465 childSnapshotId = pChildSnapshot->i_getId();
3466 }
3467 pAtt = i_findAttachment(*(pMachine->mMediumAttachments).data(), it->mpSource);
3468 if (pAtt)
3469 {
3470 AutoWriteLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
3471 pAtt->i_updateMedium(it->mpTarget);
3472 it->mpTarget->i_addBackReference(pMachine->mData->mUuid, childSnapshotId);
3473 }
3474 else
3475 {
3476 // If no attachment is found do not change anything. Maybe
3477 // the source medium was not attached to the snapshot.
3478 // If this is an online deletion the attachment was updated
3479 // already to allow the VM continue execution immediately.
3480 // Needs a bit of special treatment due to this difference.
3481 if (it->mfNeedsOnlineMerge)
3482 it->mpTarget->i_addBackReference(pMachine->mData->mUuid, childSnapshotId);
3483 }
3484 }
3485
3486 if (fNeedSourceUninit)
3487 {
3488 // make sure that the diff image to be deleted has no parent,
3489 // even in error cases (where the deparenting may be missing)
3490 if (it->mpSource->i_getParent())
3491 it->mpSource->i_deparent();
3492 it->mpSource->uninit();
3493 }
3494
3495 // One attachment is merged, must save the settings
3496 mParent->i_markRegistryModified(i_getId());
3497
3498 // prevent calling cancelDeleteSnapshotMedium() for this attachment
3499 it = toDelete.erase(it);
3500
3501 // Delayed failure exit when the merge cleanup failed but the
3502 // merge actually succeeded.
3503 if (FAILED(rc))
3504 throw rc;
3505 }
3506
3507 /* 3a: delete NVRAM file if present. */
3508 {
3509 Utf8Str NVRAMPath = pSnapMachine->mNvramStore->i_getNonVolatileStorageFile();
3510 if (NVRAMPath.isNotEmpty() && RTFileExists(NVRAMPath.c_str()))
3511 RTFileDelete(NVRAMPath.c_str());
3512 }
3513
3514 /* third pass: */
3515 {
3516 // beginSnapshotDelete() needs the machine lock, and the snapshots
3517 // tree is protected by the machine lock as well
3518 AutoWriteLock machineLock(this COMMA_LOCKVAL_SRC_POS);
3519
3520 task.m_pSnapshot->i_beginSnapshotDelete();
3521 task.m_pSnapshot->uninit();
3522
3523 machineLock.release();
3524 mParent->i_markRegistryModified(i_getId());
3525 }
3526 }
3527 catch (HRESULT aRC) {
3528 mrc = aRC;
3529 }
3530
3531 if (FAILED(mrc))
3532 {
3533 // preserve existing error info so that the result can
3534 // be properly reported to the progress object below
3535 ErrorInfoKeeper eik;
3536
3537 AutoMultiWriteLock2 multiLock(this->lockHandle(), // machine
3538 &mParent->i_getMediaTreeLockHandle() // media tree
3539 COMMA_LOCKVAL_SRC_POS);
3540
3541 // un-prepare the remaining hard disks
3542 for (MediumDeleteRecList::const_iterator it = toDelete.begin();
3543 it != toDelete.end();
3544 ++it)
3545 i_cancelDeleteSnapshotMedium(it->mpHD, it->mpSource,
3546 it->mpChildrenToReparent,
3547 it->mfNeedsOnlineMerge,
3548 it->mpMediumLockList, it->mpHDLockToken,
3549 it->mMachineId, it->mSnapshotId);
3550 }
3551
3552 // whether we were successful or not, we need to set the machine
3553 // state and save the machine settings;
3554 {
3555 // preserve existing error info so that the result can
3556 // be properly reported to the progress object below
3557 ErrorInfoKeeper eik;
3558
3559 // restore the machine state that was saved when the
3560 // task was started
3561 i_setMachineState(task.m_machineStateBackup);
3562 if (Global::IsOnline(mData->mMachineState))
3563 i_updateMachineStateOnClient();
3564
3565 mParent->i_saveModifiedRegistries();
3566 }
3567
3568 // report the result (this will try to fetch current error info on failure)
3569 task.m_pProgress->i_notifyComplete(mrc);
3570
3571 if (SUCCEEDED(mrc))
3572 {
3573 mParent->i_onSnapshotDeleted(mData->mUuid, snapshotId);
3574 for (std::map<Guid, DeviceType_T>::const_iterator it = uIdsForNotify.begin();
3575 it != uIdsForNotify.end();
3576 ++it)
3577 {
3578 mParent->i_onMediumRegistered(it->first, it->second, FALSE);
3579 }
3580 for (std::set<ComObjPtr<Medium> >::const_iterator it = pMediumsForNotify.begin();
3581 it != pMediumsForNotify.end();
3582 ++it)
3583 {
3584 if (it->isNotNull())
3585 mParent->i_onMediumConfigChanged(*it);
3586 }
3587 }
3588
3589 LogFlowThisFunc(("Done deleting snapshot (rc=%08X)\n", (HRESULT)mrc));
3590 LogFlowThisFuncLeave();
3591}
3592
3593/**
3594 * Checks that this hard disk (part of a snapshot) may be deleted/merged and
3595 * performs necessary state changes. Must not be called for writethrough disks
3596 * because there is nothing to delete/merge then.
3597 *
3598 * This method is to be called prior to calling #deleteSnapshotMedium().
3599 * If #deleteSnapshotMedium() is not called or fails, the state modifications
3600 * performed by this method must be undone by #cancelDeleteSnapshotMedium().
3601 *
3602 * @return COM status code
3603 * @param aHD Hard disk which is connected to the snapshot.
3604 * @param aMachineId UUID of machine this hard disk is attached to.
3605 * @param aSnapshotId UUID of snapshot this hard disk is attached to. May
3606 * be a zero UUID if no snapshot is applicable.
3607 * @param fOnlineMergePossible Flag whether an online merge is possible.
3608 * @param aVMMALockList Medium lock list for the medium attachment of this VM.
3609 * Only used if @a fOnlineMergePossible is @c true, and
3610 * must be non-NULL in this case.
3611 * @param aSource Source hard disk for merge (out).
3612 * @param aTarget Target hard disk for merge (out).
3613 * @param aMergeForward Merge direction decision (out).
3614 * @param aParentForTarget New parent if target needs to be reparented (out).
3615 * @param aChildrenToReparent MediumLockList with children which have to be
3616 * reparented to the target (out).
3617 * @param fNeedsOnlineMerge Whether this merge needs to be done online (out).
3618 * If this is set to @a true then the @a aVMMALockList
3619 * parameter has been modified and is returned as
3620 * @a aMediumLockList.
3621 * @param aMediumLockList Where to store the created medium lock list (may
3622 * return NULL if no real merge is necessary).
3623 * @param aHDLockToken Where to store the write lock token for aHD, in case
3624 * it is not merged or deleted (out).
3625 *
3626 * @note Caller must hold media tree lock for writing. This locks this object
3627 * and every medium object on the merge chain for writing.
3628 */
3629HRESULT SessionMachine::i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
3630 const Guid &aMachineId,
3631 const Guid &aSnapshotId,
3632 bool fOnlineMergePossible,
3633 MediumLockList *aVMMALockList,
3634 ComObjPtr<Medium> &aSource,
3635 ComObjPtr<Medium> &aTarget,
3636 bool &aMergeForward,
3637 ComObjPtr<Medium> &aParentForTarget,
3638 MediumLockList * &aChildrenToReparent,
3639 bool &fNeedsOnlineMerge,
3640 MediumLockList * &aMediumLockList,
3641 ComPtr<IToken> &aHDLockToken)
3642{
3643 Assert(!mParent->i_getMediaTreeLockHandle().isWriteLockOnCurrentThread());
3644 Assert(!fOnlineMergePossible || RT_VALID_PTR(aVMMALockList));
3645
3646 AutoWriteLock alock(aHD COMMA_LOCKVAL_SRC_POS);
3647
3648 // Medium must not be writethrough/shareable/readonly at this point
3649 MediumType_T type = aHD->i_getType();
3650 AssertReturn( type != MediumType_Writethrough
3651 && type != MediumType_Shareable
3652 && type != MediumType_Readonly, E_FAIL);
3653
3654 aChildrenToReparent = NULL;
3655 aMediumLockList = NULL;
3656 fNeedsOnlineMerge = false;
3657
3658 if (aHD->i_getChildren().size() == 0)
3659 {
3660 /* This technically is no merge, set those values nevertheless.
3661 * Helps with updating the medium attachments. */
3662 aSource = aHD;
3663 aTarget = aHD;
3664
3665 /* special treatment of the last hard disk in the chain: */
3666 if (aHD->i_getParent().isNull())
3667 {
3668 /* lock only, to prevent any usage until the snapshot deletion
3669 * is completed */
3670 alock.release();
3671 return aHD->LockWrite(aHDLockToken.asOutParam());
3672 }
3673
3674 /* the differencing hard disk w/o children will be deleted, protect it
3675 * from attaching to other VMs (this is why Deleting) */
3676 return aHD->i_markForDeletion();
3677 }
3678
3679 /* not going multi-merge as it's too expensive */
3680 if (aHD->i_getChildren().size() > 1)
3681 return setError(E_FAIL,
3682 tr("Hard disk '%s' has more than one child hard disk (%d)"),
3683 aHD->i_getLocationFull().c_str(),
3684 aHD->i_getChildren().size());
3685
3686 ComObjPtr<Medium> pChild = aHD->i_getChildren().front();
3687
3688 AutoWriteLock childLock(pChild COMMA_LOCKVAL_SRC_POS);
3689
3690 /* the rest is a normal merge setup */
3691 if (aHD->i_getParent().isNull())
3692 {
3693 /* base hard disk, backward merge */
3694 const Guid *pMachineId1 = pChild->i_getFirstMachineBackrefId();
3695 const Guid *pMachineId2 = aHD->i_getFirstMachineBackrefId();
3696 if (pMachineId1 && pMachineId2 && *pMachineId1 != *pMachineId2)
3697 {
3698 /* backward merge is too tricky, we'll just detach on snapshot
3699 * deletion, so lock only, to prevent any usage */
3700 childLock.release();
3701 alock.release();
3702 return aHD->LockWrite(aHDLockToken.asOutParam());
3703 }
3704
3705 aSource = pChild;
3706 aTarget = aHD;
3707 }
3708 else
3709 {
3710 /* Determine best merge direction. */
3711 bool fMergeForward = true;
3712
3713 childLock.release();
3714 alock.release();
3715 HRESULT rc = aHD->i_queryPreferredMergeDirection(pChild, fMergeForward);
3716 alock.acquire();
3717 childLock.acquire();
3718
3719 if (FAILED(rc) && rc != E_FAIL)
3720 return rc;
3721
3722 if (fMergeForward)
3723 {
3724 aSource = aHD;
3725 aTarget = pChild;
3726 LogFlowThisFunc(("Forward merging selected\n"));
3727 }
3728 else
3729 {
3730 aSource = pChild;
3731 aTarget = aHD;
3732 LogFlowThisFunc(("Backward merging selected\n"));
3733 }
3734 }
3735
3736 HRESULT rc;
3737 childLock.release();
3738 alock.release();
3739 rc = aSource->i_prepareMergeTo(aTarget, &aMachineId, &aSnapshotId,
3740 !fOnlineMergePossible /* fLockMedia */,
3741 aMergeForward, aParentForTarget,
3742 aChildrenToReparent, aMediumLockList);
3743 alock.acquire();
3744 childLock.acquire();
3745 if (SUCCEEDED(rc) && fOnlineMergePossible)
3746 {
3747 /* Try to lock the newly constructed medium lock list. If it succeeds
3748 * this can be handled as an offline merge, i.e. without the need of
3749 * asking the VM to do the merging. Only continue with the online
3750 * merging preparation if applicable. */
3751 childLock.release();
3752 alock.release();
3753 rc = aMediumLockList->Lock();
3754 alock.acquire();
3755 childLock.acquire();
3756 if (FAILED(rc))
3757 {
3758 /* Locking failed, this cannot be done as an offline merge. Try to
3759 * combine the locking information into the lock list of the medium
3760 * attachment in the running VM. If that fails or locking the
3761 * resulting lock list fails then the merge cannot be done online.
3762 * It can be repeated by the user when the VM is shut down. */
3763 MediumLockList::Base::iterator lockListVMMABegin =
3764 aVMMALockList->GetBegin();
3765 MediumLockList::Base::iterator lockListVMMAEnd =
3766 aVMMALockList->GetEnd();
3767 MediumLockList::Base::iterator lockListBegin =
3768 aMediumLockList->GetBegin();
3769 MediumLockList::Base::iterator lockListEnd =
3770 aMediumLockList->GetEnd();
3771 for (MediumLockList::Base::iterator it = lockListVMMABegin,
3772 it2 = lockListBegin;
3773 it2 != lockListEnd;
3774 ++it, ++it2)
3775 {
3776 if ( it == lockListVMMAEnd
3777 || it->GetMedium() != it2->GetMedium())
3778 {
3779 fOnlineMergePossible = false;
3780 break;
3781 }
3782 bool fLockReq = (it2->GetLockRequest() || it->GetLockRequest());
3783 childLock.release();
3784 alock.release();
3785 rc = it->UpdateLock(fLockReq);
3786 alock.acquire();
3787 childLock.acquire();
3788 if (FAILED(rc))
3789 {
3790 // could not update the lock, trigger cleanup below
3791 fOnlineMergePossible = false;
3792 break;
3793 }
3794 }
3795
3796 if (fOnlineMergePossible)
3797 {
3798 /* we will lock the children of the source for reparenting */
3799 if (aChildrenToReparent && !aChildrenToReparent->IsEmpty())
3800 {
3801 /* Cannot just call aChildrenToReparent->Lock(), as one of
3802 * the children is the one under which the current state of
3803 * the VM is located, and this means it is already locked
3804 * (for reading). Note that no special unlocking is needed,
3805 * because cancelMergeTo will unlock everything locked in
3806 * its context (using the unlock on destruction), and both
3807 * cancelDeleteSnapshotMedium (in case something fails) and
3808 * FinishOnlineMergeMedium re-define the read/write lock
3809 * state of everything which the VM need, search for the
3810 * UpdateLock method calls. */
3811 childLock.release();
3812 alock.release();
3813 rc = aChildrenToReparent->Lock(true /* fSkipOverLockedMedia */);
3814 alock.acquire();
3815 childLock.acquire();
3816 MediumLockList::Base::iterator childrenToReparentBegin = aChildrenToReparent->GetBegin();
3817 MediumLockList::Base::iterator childrenToReparentEnd = aChildrenToReparent->GetEnd();
3818 for (MediumLockList::Base::iterator it = childrenToReparentBegin;
3819 it != childrenToReparentEnd;
3820 ++it)
3821 {
3822 ComObjPtr<Medium> pMedium = it->GetMedium();
3823 AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3824 if (!it->IsLocked())
3825 {
3826 mediumLock.release();
3827 childLock.release();
3828 alock.release();
3829 rc = aVMMALockList->Update(pMedium, true);
3830 alock.acquire();
3831 childLock.acquire();
3832 mediumLock.acquire();
3833 if (FAILED(rc))
3834 throw rc;
3835 }
3836 }
3837 }
3838 }
3839
3840 if (fOnlineMergePossible)
3841 {
3842 childLock.release();
3843 alock.release();
3844 rc = aVMMALockList->Lock();
3845 alock.acquire();
3846 childLock.acquire();
3847 if (FAILED(rc))
3848 {
3849 aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
3850 rc = setError(rc,
3851 tr("Cannot lock hard disk '%s' for a live merge"),
3852 aHD->i_getLocationFull().c_str());
3853 }
3854 else
3855 {
3856 delete aMediumLockList;
3857 aMediumLockList = aVMMALockList;
3858 fNeedsOnlineMerge = true;
3859 }
3860 }
3861 else
3862 {
3863 aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
3864 rc = setError(rc,
3865 tr("Failed to construct lock list for a live merge of hard disk '%s'"),
3866 aHD->i_getLocationFull().c_str());
3867 }
3868
3869 // fix the VM's lock list if anything failed
3870 if (FAILED(rc))
3871 {
3872 lockListVMMABegin = aVMMALockList->GetBegin();
3873 lockListVMMAEnd = aVMMALockList->GetEnd();
3874 MediumLockList::Base::iterator lockListLast = lockListVMMAEnd;
3875 --lockListLast;
3876 for (MediumLockList::Base::iterator it = lockListVMMABegin;
3877 it != lockListVMMAEnd;
3878 ++it)
3879 {
3880 childLock.release();
3881 alock.release();
3882 it->UpdateLock(it == lockListLast);
3883 alock.acquire();
3884 childLock.acquire();
3885 ComObjPtr<Medium> pMedium = it->GetMedium();
3886 AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3887 // blindly apply this, only needed for medium objects which
3888 // would be deleted as part of the merge
3889 pMedium->i_unmarkLockedForDeletion();
3890 }
3891 }
3892 }
3893 }
3894 else if (FAILED(rc))
3895 {
3896 aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
3897 rc = setError(rc,
3898 tr("Cannot lock hard disk '%s' when deleting a snapshot"),
3899 aHD->i_getLocationFull().c_str());
3900 }
3901
3902 return rc;
3903}
3904
3905/**
3906 * Cancels the deletion/merging of this hard disk (part of a snapshot). Undoes
3907 * what #prepareDeleteSnapshotMedium() did. Must be called if
3908 * #deleteSnapshotMedium() is not called or fails.
3909 *
3910 * @param aHD Hard disk which is connected to the snapshot.
3911 * @param aSource Source hard disk for merge.
3912 * @param aChildrenToReparent Children to unlock.
3913 * @param fNeedsOnlineMerge Whether this merge needs to be done online.
3914 * @param aMediumLockList Medium locks to cancel.
3915 * @param aHDLockToken Optional write lock token for aHD.
3916 * @param aMachineId Machine id to attach the medium to.
3917 * @param aSnapshotId Snapshot id to attach the medium to.
3918 *
3919 * @note Locks the medium tree and the hard disks in the chain for writing.
3920 */
3921void SessionMachine::i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
3922 const ComObjPtr<Medium> &aSource,
3923 MediumLockList *aChildrenToReparent,
3924 bool fNeedsOnlineMerge,
3925 MediumLockList *aMediumLockList,
3926 const ComPtr<IToken> &aHDLockToken,
3927 const Guid &aMachineId,
3928 const Guid &aSnapshotId)
3929{
3930 if (aMediumLockList == NULL)
3931 {
3932 AutoMultiWriteLock2 mLock(&mParent->i_getMediaTreeLockHandle(), aHD->lockHandle() COMMA_LOCKVAL_SRC_POS);
3933
3934 Assert(aHD->i_getChildren().size() == 0);
3935
3936 if (aHD->i_getParent().isNull())
3937 {
3938 Assert(!aHDLockToken.isNull());
3939 if (!aHDLockToken.isNull())
3940 {
3941 HRESULT rc = aHDLockToken->Abandon();
3942 AssertComRC(rc);
3943 }
3944 }
3945 else
3946 {
3947 HRESULT rc = aHD->i_unmarkForDeletion();
3948 AssertComRC(rc);
3949 }
3950 }
3951 else
3952 {
3953 if (fNeedsOnlineMerge)
3954 {
3955 // Online merge uses the medium lock list of the VM, so give
3956 // an empty list to cancelMergeTo so that it works as designed.
3957 aSource->i_cancelMergeTo(aChildrenToReparent, new MediumLockList());
3958
3959 // clean up the VM medium lock list ourselves
3960 MediumLockList::Base::iterator lockListBegin =
3961 aMediumLockList->GetBegin();
3962 MediumLockList::Base::iterator lockListEnd =
3963 aMediumLockList->GetEnd();
3964 MediumLockList::Base::iterator lockListLast = lockListEnd;
3965 --lockListLast;
3966 for (MediumLockList::Base::iterator it = lockListBegin;
3967 it != lockListEnd;
3968 ++it)
3969 {
3970 ComObjPtr<Medium> pMedium = it->GetMedium();
3971 AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
3972 if (pMedium->i_getState() == MediumState_Deleting)
3973 pMedium->i_unmarkForDeletion();
3974 else
3975 {
3976 // blindly apply this, only needed for medium objects which
3977 // would be deleted as part of the merge
3978 pMedium->i_unmarkLockedForDeletion();
3979 }
3980 mediumLock.release();
3981 it->UpdateLock(it == lockListLast);
3982 mediumLock.acquire();
3983 }
3984 }
3985 else
3986 {
3987 aSource->i_cancelMergeTo(aChildrenToReparent, aMediumLockList);
3988 }
3989 }
3990
3991 if (aMachineId.isValid() && !aMachineId.isZero())
3992 {
3993 // reattach the source media to the snapshot
3994 HRESULT rc = aSource->i_addBackReference(aMachineId, aSnapshotId);
3995 AssertComRC(rc);
3996 }
3997}
3998
3999/**
4000 * Perform an online merge of a hard disk, i.e. the equivalent of
4001 * Medium::mergeTo(), just for running VMs. If this fails you need to call
4002 * #cancelDeleteSnapshotMedium().
4003 *
4004 * @return COM status code
4005 * @param aMediumAttachment Identify where the disk is attached in the VM.
4006 * @param aSource Source hard disk for merge.
4007 * @param aTarget Target hard disk for merge.
4008 * @param fMergeForward Merge direction.
4009 * @param aParentForTarget New parent if target needs to be reparented.
4010 * @param aChildrenToReparent Medium lock list with children which have to be
4011 * reparented to the target.
4012 * @param aMediumLockList Where to store the created medium lock list (may
4013 * return NULL if no real merge is necessary).
4014 * @param aProgress Progress indicator.
4015 * @param pfNeedsMachineSaveSettings Whether the VM settings need to be saved (out).
4016 */
4017HRESULT SessionMachine::i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
4018 const ComObjPtr<Medium> &aSource,
4019 const ComObjPtr<Medium> &aTarget,
4020 bool fMergeForward,
4021 const ComObjPtr<Medium> &aParentForTarget,
4022 MediumLockList *aChildrenToReparent,
4023 MediumLockList *aMediumLockList,
4024 ComObjPtr<Progress> &aProgress,
4025 bool *pfNeedsMachineSaveSettings)
4026{
4027 AssertReturn(aSource != NULL, E_FAIL);
4028 AssertReturn(aTarget != NULL, E_FAIL);
4029 AssertReturn(aSource != aTarget, E_FAIL);
4030 AssertReturn(aMediumLockList != NULL, E_FAIL);
4031 NOREF(fMergeForward);
4032 NOREF(aParentForTarget);
4033 NOREF(aChildrenToReparent);
4034
4035 HRESULT rc = S_OK;
4036
4037 try
4038 {
4039 // Similar code appears in Medium::taskMergeHandle, so
4040 // if you make any changes below check whether they are applicable
4041 // in that context as well.
4042
4043 unsigned uTargetIdx = (unsigned)-1;
4044 unsigned uSourceIdx = (unsigned)-1;
4045 /* Sanity check all hard disks in the chain. */
4046 MediumLockList::Base::iterator lockListBegin =
4047 aMediumLockList->GetBegin();
4048 MediumLockList::Base::iterator lockListEnd =
4049 aMediumLockList->GetEnd();
4050 unsigned i = 0;
4051 for (MediumLockList::Base::iterator it = lockListBegin;
4052 it != lockListEnd;
4053 ++it)
4054 {
4055 MediumLock &mediumLock = *it;
4056 const ComObjPtr<Medium> &pMedium = mediumLock.GetMedium();
4057
4058 if (pMedium == aSource)
4059 uSourceIdx = i;
4060 else if (pMedium == aTarget)
4061 uTargetIdx = i;
4062
4063 // In Medium::taskMergeHandler there is lots of consistency
4064 // checking which we cannot do here, as the state details are
4065 // impossible to get outside the Medium class. The locking should
4066 // have done the checks already.
4067
4068 i++;
4069 }
4070
4071 ComAssertThrow( uSourceIdx != (unsigned)-1
4072 && uTargetIdx != (unsigned)-1, E_FAIL);
4073
4074 ComPtr<IInternalSessionControl> directControl;
4075 {
4076 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
4077
4078 if (mData->mSession.mState != SessionState_Locked)
4079 throw setError(VBOX_E_INVALID_VM_STATE,
4080 tr("Machine is not locked by a session (session state: %s)"),
4081 Global::stringifySessionState(mData->mSession.mState));
4082 directControl = mData->mSession.mDirectControl;
4083 }
4084
4085 // Must not hold any locks here, as this will call back to finish
4086 // updating the medium attachment, chain linking and state.
4087 rc = directControl->OnlineMergeMedium(aMediumAttachment,
4088 uSourceIdx, uTargetIdx,
4089 aProgress);
4090 if (FAILED(rc))
4091 throw rc;
4092 }
4093 catch (HRESULT aRC) { rc = aRC; }
4094
4095 // The callback mentioned above takes care of update the medium state
4096
4097 if (pfNeedsMachineSaveSettings)
4098 *pfNeedsMachineSaveSettings = true;
4099
4100 return rc;
4101}
4102
4103/**
4104 * Implementation for IInternalMachineControl::finishOnlineMergeMedium().
4105 *
4106 * Gets called after the successful completion of an online merge from
4107 * Console::onlineMergeMedium(), which gets invoked indirectly above in
4108 * the call to IInternalSessionControl::onlineMergeMedium.
4109 *
4110 * This updates the medium information and medium state so that the VM
4111 * can continue with the updated state of the medium chain.
4112 */
4113HRESULT SessionMachine::finishOnlineMergeMedium()
4114{
4115 HRESULT rc = S_OK;
4116 MediumDeleteRec *pDeleteRec = (MediumDeleteRec *)mConsoleTaskData.mDeleteSnapshotInfo;
4117 AssertReturn(pDeleteRec, E_FAIL);
4118 bool fSourceHasChildren = false;
4119
4120 // all hard disks but the target were successfully deleted by
4121 // the merge; reparent target if necessary and uninitialize media
4122
4123 AutoWriteLock treeLock(mParent->i_getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
4124
4125 // Declare this here to make sure the object does not get uninitialized
4126 // before this method completes. Would normally happen as halfway through
4127 // we delete the last reference to the no longer existing medium object.
4128 ComObjPtr<Medium> targetChild;
4129
4130 if (pDeleteRec->mfMergeForward)
4131 {
4132 // first, unregister the target since it may become a base
4133 // hard disk which needs re-registration
4134 rc = mParent->i_unregisterMedium(pDeleteRec->mpTarget);
4135 AssertComRC(rc);
4136
4137 // then, reparent it and disconnect the deleted branch at
4138 // both ends (chain->parent() is source's parent)
4139 pDeleteRec->mpTarget->i_deparent();
4140 pDeleteRec->mpTarget->i_setParent(pDeleteRec->mpParentForTarget);
4141 if (pDeleteRec->mpParentForTarget)
4142 pDeleteRec->mpSource->i_deparent();
4143
4144 // then, register again
4145 rc = mParent->i_registerMedium(pDeleteRec->mpTarget, &pDeleteRec->mpTarget, treeLock);
4146 AssertComRC(rc);
4147 }
4148 else
4149 {
4150 Assert(pDeleteRec->mpTarget->i_getChildren().size() == 1);
4151 targetChild = pDeleteRec->mpTarget->i_getChildren().front();
4152
4153 // disconnect the deleted branch at the elder end
4154 targetChild->i_deparent();
4155
4156 // Update parent UUIDs of the source's children, reparent them and
4157 // disconnect the deleted branch at the younger end
4158 if (pDeleteRec->mpChildrenToReparent && !pDeleteRec->mpChildrenToReparent->IsEmpty())
4159 {
4160 fSourceHasChildren = true;
4161 // Fix the parent UUID of the images which needs to be moved to
4162 // underneath target. The running machine has the images opened,
4163 // but only for reading since the VM is paused. If anything fails
4164 // we must continue. The worst possible result is that the images
4165 // need manual fixing via VBoxManage to adjust the parent UUID.
4166 treeLock.release();
4167 pDeleteRec->mpTarget->i_fixParentUuidOfChildren(pDeleteRec->mpChildrenToReparent);
4168 // The childen are still write locked, unlock them now and don't
4169 // rely on the destructor doing it very late.
4170 pDeleteRec->mpChildrenToReparent->Unlock();
4171 treeLock.acquire();
4172
4173 // obey {parent,child} lock order
4174 AutoWriteLock sourceLock(pDeleteRec->mpSource COMMA_LOCKVAL_SRC_POS);
4175
4176 MediumLockList::Base::iterator childrenBegin = pDeleteRec->mpChildrenToReparent->GetBegin();
4177 MediumLockList::Base::iterator childrenEnd = pDeleteRec->mpChildrenToReparent->GetEnd();
4178 for (MediumLockList::Base::iterator it = childrenBegin;
4179 it != childrenEnd;
4180 ++it)
4181 {
4182 Medium *pMedium = it->GetMedium();
4183 AutoWriteLock childLock(pMedium COMMA_LOCKVAL_SRC_POS);
4184
4185 pMedium->i_deparent(); // removes pMedium from source
4186 pMedium->i_setParent(pDeleteRec->mpTarget);
4187 }
4188 }
4189 }
4190
4191 /* unregister and uninitialize all hard disks removed by the merge */
4192 MediumLockList *pMediumLockList = NULL;
4193 rc = mData->mSession.mLockedMedia.Get(pDeleteRec->mpOnlineMediumAttachment, pMediumLockList);
4194 const ComObjPtr<Medium> &pLast = pDeleteRec->mfMergeForward ? pDeleteRec->mpTarget : pDeleteRec->mpSource;
4195 AssertReturn(SUCCEEDED(rc) && pMediumLockList, E_FAIL);
4196 MediumLockList::Base::iterator lockListBegin =
4197 pMediumLockList->GetBegin();
4198 MediumLockList::Base::iterator lockListEnd =
4199 pMediumLockList->GetEnd();
4200 for (MediumLockList::Base::iterator it = lockListBegin;
4201 it != lockListEnd;
4202 )
4203 {
4204 MediumLock &mediumLock = *it;
4205 /* Create a real copy of the medium pointer, as the medium
4206 * lock deletion below would invalidate the referenced object. */
4207 const ComObjPtr<Medium> pMedium = mediumLock.GetMedium();
4208
4209 /* The target and all images not merged (readonly) are skipped */
4210 if ( pMedium == pDeleteRec->mpTarget
4211 || pMedium->i_getState() == MediumState_LockedRead)
4212 {
4213 ++it;
4214 }
4215 else
4216 {
4217 rc = mParent->i_unregisterMedium(pMedium);
4218 AssertComRC(rc);
4219
4220 /* now, uninitialize the deleted hard disk (note that
4221 * due to the Deleting state, uninit() will not touch
4222 * the parent-child relationship so we need to
4223 * uninitialize each disk individually) */
4224
4225 /* note that the operation initiator hard disk (which is
4226 * normally also the source hard disk) is a special case
4227 * -- there is one more caller added by Task to it which
4228 * we must release. Also, if we are in sync mode, the
4229 * caller may still hold an AutoCaller instance for it
4230 * and therefore we cannot uninit() it (it's therefore
4231 * the caller's responsibility) */
4232 if (pMedium == pDeleteRec->mpSource)
4233 {
4234 Assert(pDeleteRec->mpSource->i_getChildren().size() == 0);
4235 Assert(pDeleteRec->mpSource->i_getFirstMachineBackrefId() == NULL);
4236 }
4237
4238 /* Delete the medium lock list entry, which also releases the
4239 * caller added by MergeChain before uninit() and updates the
4240 * iterator to point to the right place. */
4241 rc = pMediumLockList->RemoveByIterator(it);
4242 AssertComRC(rc);
4243
4244 treeLock.release();
4245 pMedium->uninit();
4246 treeLock.acquire();
4247 }
4248
4249 /* Stop as soon as we reached the last medium affected by the merge.
4250 * The remaining images must be kept unchanged. */
4251 if (pMedium == pLast)
4252 break;
4253 }
4254
4255 /* Could be in principle folded into the previous loop, but let's keep
4256 * things simple. Update the medium locking to be the standard state:
4257 * all parent images locked for reading, just the last diff for writing. */
4258 lockListBegin = pMediumLockList->GetBegin();
4259 lockListEnd = pMediumLockList->GetEnd();
4260 MediumLockList::Base::iterator lockListLast = lockListEnd;
4261 --lockListLast;
4262 for (MediumLockList::Base::iterator it = lockListBegin;
4263 it != lockListEnd;
4264 ++it)
4265 {
4266 it->UpdateLock(it == lockListLast);
4267 }
4268
4269 /* If this is a backwards merge of the only remaining snapshot (i.e. the
4270 * source has no children) then update the medium associated with the
4271 * attachment, as the previously associated one (source) is now deleted.
4272 * Without the immediate update the VM could not continue running. */
4273 if (!pDeleteRec->mfMergeForward && !fSourceHasChildren)
4274 {
4275 AutoWriteLock attLock(pDeleteRec->mpOnlineMediumAttachment COMMA_LOCKVAL_SRC_POS);
4276 pDeleteRec->mpOnlineMediumAttachment->i_updateMedium(pDeleteRec->mpTarget);
4277 }
4278
4279 return S_OK;
4280}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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