VirtualBox

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

Last change on this file since 61644 was 61009, checked in by vboxsync, 9 years ago

Main: big settings cleanup and writing optimization. Moved constructors/equality/default checks into the .cpp file, and write only settings which aren't at the default value. Greatly reduces the effort needed to write everything out, especially when a lot of snapshots have to be dealt with. Move the storage controllers to the hardware settings, where they always belonged. No change to the XML file (yet). Lots of settings related cleanups in the API code.

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

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