VirtualBox

source: vbox/trunk/src/VBox/Main/MachineImpl.cpp@ 7964

Last change on this file since 7964 was 7964, checked in by vboxsync, 17 years ago

Attempt at making OSE build again.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 314.8 KB
Line 
1/* $Id: MachineImpl.cpp 7964 2008-04-14 17:56:52Z vboxsync $ */
2/** @file
3 * Implementation of IMachine in VBoxSVC.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
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#if defined(RT_OS_WINDOWS)
19#elif defined(RT_OS_LINUX)
20#endif
21
22#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
23# include <errno.h>
24# include <sys/types.h>
25# include <sys/stat.h>
26# include <sys/ipc.h>
27# include <sys/sem.h>
28#endif
29
30#include "VirtualBoxImpl.h"
31#include "MachineImpl.h"
32#include "HardDiskImpl.h"
33#include "ProgressImpl.h"
34#include "HardDiskAttachmentImpl.h"
35#include "USBControllerImpl.h"
36#include "HostImpl.h"
37#include "SystemPropertiesImpl.h"
38#include "SharedFolderImpl.h"
39#include "GuestOSTypeImpl.h"
40#include "VirtualBoxErrorInfoImpl.h"
41#include "GuestImpl.h"
42#include "SATAControllerImpl.h"
43
44#ifdef VBOX_WITH_USB
45# include "USBProxyService.h"
46#endif
47
48#include "VirtualBoxXMLUtil.h"
49
50#include "Logging.h"
51
52#include <stdio.h>
53#include <stdlib.h>
54
55#include <iprt/path.h>
56#include <iprt/dir.h>
57#include <iprt/asm.h>
58#include <iprt/process.h>
59#include <iprt/cpputils.h>
60#include <iprt/env.h>
61
62#include <VBox/err.h>
63#include <VBox/param.h>
64
65#include <algorithm>
66
67#include <typeinfo>
68
69#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
70#define HOSTSUFF_EXE ".exe"
71#else /* !RT_OS_WINDOWS */
72#define HOSTSUFF_EXE ""
73#endif /* !RT_OS_WINDOWS */
74
75// defines / prototypes
76/////////////////////////////////////////////////////////////////////////////
77
78// globals
79/////////////////////////////////////////////////////////////////////////////
80
81/**
82 * @note The template is NOT completely valid according to VBOX_XML_SCHEMA
83 * (when loading a newly created settings file, validation will be turned off)
84 */
85static const char DefaultMachineConfig[] =
86{
87 "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" RTFILE_LINEFEED
88 "<!-- innotek VirtualBox Machine Configuration -->" RTFILE_LINEFEED
89 "<VirtualBox xmlns=\"" VBOX_XML_NAMESPACE "\" "
90 "version=\"" VBOX_XML_VERSION_FULL "\">" RTFILE_LINEFEED
91 "</VirtualBox>" RTFILE_LINEFEED
92};
93
94/**
95 * Progress callback handler for lengthy operations
96 * (corresponds to the FNRTPROGRESS typedef).
97 *
98 * @param uPercentage Completetion precentage (0-100).
99 * @param pvUser Pointer to the Progress instance.
100 */
101static DECLCALLBACK(int) progressCallback (unsigned uPercentage, void *pvUser)
102{
103 Progress *progress = static_cast <Progress *> (pvUser);
104
105 /* update the progress object */
106 if (progress)
107 progress->notifyProgress (uPercentage);
108
109 return VINF_SUCCESS;
110}
111
112/////////////////////////////////////////////////////////////////////////////
113// Machine::Data structure
114/////////////////////////////////////////////////////////////////////////////
115
116Machine::Data::Data()
117{
118 mRegistered = FALSE;
119 /* mUuid is initialized in Machine::init() */
120
121 mMachineState = MachineState_PoweredOff;
122 RTTimeNow (&mLastStateChange);
123
124 mMachineStateDeps = 0;
125 mZeroMachineStateDepsSem = NIL_RTSEMEVENT;
126 mWaitingStateDeps = FALSE;
127
128 mCurrentStateModified = TRUE;
129 mHandleCfgFile = NIL_RTFILE;
130
131 mSession.mPid = NIL_RTPROCESS;
132 mSession.mState = SessionState_Closed;
133}
134
135Machine::Data::~Data()
136{
137 if (mZeroMachineStateDepsSem != NIL_RTSEMEVENT)
138 {
139 RTSemEventDestroy (mZeroMachineStateDepsSem);
140 mZeroMachineStateDepsSem = NIL_RTSEMEVENT;
141 }
142}
143
144/////////////////////////////////////////////////////////////////////////////
145// Machine::UserData structure
146/////////////////////////////////////////////////////////////////////////////
147
148Machine::UserData::UserData()
149{
150 /* default values for a newly created machine */
151
152 mNameSync = TRUE;
153
154 /* mName, mOSTypeId, mSnapshotFolder, mSnapshotFolderFull are initialized in
155 * Machine::init() */
156}
157
158Machine::UserData::~UserData()
159{
160}
161
162/////////////////////////////////////////////////////////////////////////////
163// Machine::HWData structure
164/////////////////////////////////////////////////////////////////////////////
165
166Machine::HWData::HWData()
167{
168 /* default values for a newly created machine */
169 mMemorySize = 128;
170 mMemoryBalloonSize = 0;
171 mStatisticsUpdateInterval = 0;
172 mVRAMSize = 8;
173 mMonitorCount = 1;
174 mHWVirtExEnabled = TSBool_False;
175
176 /* default boot order: floppy - DVD - HDD */
177 mBootOrder [0] = DeviceType_Floppy;
178 mBootOrder [1] = DeviceType_DVD;
179 mBootOrder [2] = DeviceType_HardDisk;
180 for (size_t i = 3; i < ELEMENTS (mBootOrder); i++)
181 mBootOrder [i] = DeviceType_Null;
182
183 mClipboardMode = ClipboardMode_Bidirectional;
184}
185
186Machine::HWData::~HWData()
187{
188}
189
190bool Machine::HWData::operator== (const HWData &that) const
191{
192 if (this == &that)
193 return true;
194
195 if (mMemorySize != that.mMemorySize ||
196 mMemoryBalloonSize != that.mMemoryBalloonSize ||
197 mStatisticsUpdateInterval != that.mStatisticsUpdateInterval ||
198 mVRAMSize != that.mVRAMSize ||
199 mMonitorCount != that.mMonitorCount ||
200 mHWVirtExEnabled != that.mHWVirtExEnabled ||
201 mClipboardMode != that.mClipboardMode)
202 return false;
203
204 for (size_t i = 0; i < ELEMENTS (mBootOrder); ++ i)
205 if (mBootOrder [i] != that.mBootOrder [i])
206 return false;
207
208 if (mSharedFolders.size() != that.mSharedFolders.size())
209 return false;
210
211 if (mSharedFolders.size() == 0)
212 return true;
213
214 /* Make copies to speed up comparison */
215 SharedFolderList folders = mSharedFolders;
216 SharedFolderList thatFolders = that.mSharedFolders;
217
218 SharedFolderList::iterator it = folders.begin();
219 while (it != folders.end())
220 {
221 bool found = false;
222 SharedFolderList::iterator thatIt = thatFolders.begin();
223 while (thatIt != thatFolders.end())
224 {
225 if ((*it)->name() == (*thatIt)->name() &&
226 RTPathCompare (Utf8Str ((*it)->hostPath()),
227 Utf8Str ((*thatIt)->hostPath())) == 0)
228 {
229 thatFolders.erase (thatIt);
230 found = true;
231 break;
232 }
233 else
234 ++ thatIt;
235 }
236 if (found)
237 it = folders.erase (it);
238 else
239 return false;
240 }
241
242 Assert (folders.size() == 0 && thatFolders.size() == 0);
243
244 return true;
245}
246
247/////////////////////////////////////////////////////////////////////////////
248// Machine::HDData structure
249/////////////////////////////////////////////////////////////////////////////
250
251Machine::HDData::HDData()
252{
253 /* default values for a newly created machine */
254 mHDAttachmentsChanged = false;
255}
256
257Machine::HDData::~HDData()
258{
259}
260
261bool Machine::HDData::operator== (const HDData &that) const
262{
263 if (this == &that)
264 return true;
265
266 if (mHDAttachments.size() != that.mHDAttachments.size())
267 return false;
268
269 if (mHDAttachments.size() == 0)
270 return true;
271
272 /* Make copies to speed up comparison */
273 HDAttachmentList atts = mHDAttachments;
274 HDAttachmentList thatAtts = that.mHDAttachments;
275
276 HDAttachmentList::iterator it = atts.begin();
277 while (it != atts.end())
278 {
279 bool found = false;
280 HDAttachmentList::iterator thatIt = thatAtts.begin();
281 while (thatIt != thatAtts.end())
282 {
283 if ((*it)->bus() == (*thatIt)->bus() &&
284 (*it)->channel() == (*thatIt)->channel() &&
285 (*it)->device() == (*thatIt)->device() &&
286 (*it)->hardDisk().equalsTo ((*thatIt)->hardDisk()))
287 {
288 thatAtts.erase (thatIt);
289 found = true;
290 break;
291 }
292 else
293 ++ thatIt;
294 }
295 if (found)
296 it = atts.erase (it);
297 else
298 return false;
299 }
300
301 Assert (atts.size() == 0 && thatAtts.size() == 0);
302
303 return true;
304}
305
306/////////////////////////////////////////////////////////////////////////////
307// Machine class
308/////////////////////////////////////////////////////////////////////////////
309
310// constructor / destructor
311/////////////////////////////////////////////////////////////////////////////
312
313Machine::Machine() : mType (IsMachine) {}
314
315Machine::~Machine() {}
316
317HRESULT Machine::FinalConstruct()
318{
319 LogFlowThisFunc (("\n"));
320 return S_OK;
321}
322
323void Machine::FinalRelease()
324{
325 LogFlowThisFunc (("\n"));
326 uninit();
327}
328
329/**
330 * Initializes the instance.
331 *
332 * @param aParent Associated parent object
333 * @param aConfigFile Local file system path to the VM settings file (can
334 * be relative to the VirtualBox config directory).
335 * @param aMode Init_New, Init_Existing or Init_Registered
336 * @param aName name for the machine when aMode is Init_New
337 * (ignored otherwise)
338 * @param aNameSync |TRUE| to automatically sync settings dir and file
339 * name with the machine name. |FALSE| is used for legacy
340 * machines where the file name is specified by the
341 * user and should never change. Used only in Init_New
342 * mode (ignored otherwise).
343 * @param aId UUID of the machine. Required for aMode==Init_Registered
344 * and optional for aMode==Init_New. Used for consistency
345 * check when aMode is Init_Registered; must match UUID
346 * stored in the settings file. Used for predefining the
347 * UUID of a VM when aMode is Init_New.
348 *
349 * @return Success indicator. if not S_OK, the machine object is invalid
350 */
351HRESULT Machine::init (VirtualBox *aParent, const BSTR aConfigFile,
352 InitMode aMode, const BSTR aName /* = NULL */,
353 BOOL aNameSync /* = TRUE */,
354 const Guid *aId /* = NULL */)
355{
356 LogFlowThisFuncEnter();
357 LogFlowThisFunc (("aConfigFile='%ls', aMode=%d\n", aConfigFile, aMode));
358
359 AssertReturn (aParent, E_INVALIDARG);
360 AssertReturn (aConfigFile, E_INVALIDARG);
361 AssertReturn (aMode != Init_New || (aName != NULL && *aName != '\0'),
362 E_INVALIDARG);
363 AssertReturn (aMode != Init_Registered || aId != NULL, E_FAIL);
364
365 /* Enclose the state transition NotReady->InInit->Ready */
366 AutoInitSpan autoInitSpan (this);
367 AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
368
369 HRESULT rc = S_OK;
370
371 /* share the parent weakly */
372 unconst (mParent) = aParent;
373
374 /* register with parent early, since uninit() will unconditionally
375 * unregister on failure */
376 mParent->addDependentChild (this);
377
378 /* allocate the essential machine data structure (the rest will be
379 * allocated later by initDataAndChildObjects() */
380 mData.allocate();
381
382 char configFileFull [RTPATH_MAX] = {0};
383
384 /* memorize the config file name (as provided) */
385 mData->mConfigFile = aConfigFile;
386
387 /* get the full file name */
388 int vrc = RTPathAbsEx (mParent->homeDir(), Utf8Str (aConfigFile),
389 configFileFull, sizeof (configFileFull));
390 if (VBOX_FAILURE (vrc))
391 return setError (E_FAIL,
392 tr ("Invalid settings file name: '%ls' (%Vrc)"),
393 aConfigFile, vrc);
394 mData->mConfigFileFull = configFileFull;
395
396 /* start with accessible */
397 mData->mAccessible = TRUE;
398
399 if (aMode != Init_New)
400 {
401 /* lock the settings file */
402 rc = lockConfig();
403
404 if (aMode == Init_Registered && FAILED (rc))
405 {
406 /* If the machine is registered, then, instead of returning a
407 * failure, we mark it as inaccessible and set the result to
408 * success to give it a try later */
409 mData->mAccessible = FALSE;
410 /* fetch the current error info */
411 mData->mAccessError = com::ErrorInfo();
412 LogWarning (("Machine {%Vuuid} is inaccessible! [%ls]\n",
413 mData->mUuid.raw(),
414 mData->mAccessError.getText().raw()));
415 rc = S_OK;
416 }
417 }
418 else
419 {
420 /* check for the file existence */
421 RTFILE f = NIL_RTFILE;
422 int vrc = RTFileOpen (&f, configFileFull, RTFILE_O_READ);
423 if (VBOX_SUCCESS (vrc) || vrc == VERR_SHARING_VIOLATION)
424 {
425 rc = setError (E_FAIL,
426 tr ("Settings file '%s' already exists"), configFileFull);
427 if (VBOX_SUCCESS (vrc))
428 RTFileClose (f);
429 }
430 else
431 {
432 if (vrc != VERR_FILE_NOT_FOUND && vrc != VERR_PATH_NOT_FOUND)
433 rc = setError (E_FAIL,
434 tr ("Invalid settings file name: '%ls' (%Vrc)"),
435 mData->mConfigFileFull.raw(), vrc);
436 }
437
438 /* reset mAccessible to make sure uninit() called by the AutoInitSpan
439 * destructor will not call uninitDataAndChildObjects() (we haven't
440 * initialized anything yet) */
441 if (FAILED (rc))
442 mData->mAccessible = FALSE;
443 }
444
445 CheckComRCReturnRC (rc);
446
447 if (aMode == Init_Registered)
448 {
449 /* store the supplied UUID (will be used to check for UUID consistency
450 * in loadSettings() */
451 unconst (mData->mUuid) = *aId;
452 /* try to load settings only if the settings file is accessible */
453 if (mData->mAccessible)
454 rc = registeredInit();
455 }
456 else
457 {
458 rc = initDataAndChildObjects();
459
460 if (SUCCEEDED (rc))
461 {
462 if (aMode != Init_New)
463 {
464 rc = loadSettings (false /* aRegistered */);
465 }
466 else
467 {
468 /* create the machine UUID */
469 if (aId)
470 unconst (mData->mUuid) = *aId;
471 else
472 unconst (mData->mUuid).create();
473
474 /* memorize the provided new machine's name */
475 mUserData->mName = aName;
476 mUserData->mNameSync = aNameSync;
477
478 /* initialize the default snapshots folder
479 * (note: depends on the name value set above!) */
480 rc = COMSETTER(SnapshotFolder) (NULL);
481 AssertComRC (rc);
482 }
483
484 /* commit all changes made during the initialization */
485 if (SUCCEEDED (rc))
486 commit();
487 }
488 }
489
490 /* Confirm a successful initialization when it's the case */
491 if (SUCCEEDED (rc))
492 {
493 if (mData->mAccessible)
494 autoInitSpan.setSucceeded();
495 else
496 autoInitSpan.setLimited();
497 }
498
499 LogFlowThisFunc (("mName='%ls', mRegistered=%RTbool, mAccessible=%RTbool "
500 "rc=%08X\n",
501 !!mUserData ? mUserData->mName.raw() : NULL,
502 mData->mRegistered, mData->mAccessible, rc));
503
504 LogFlowThisFuncLeave();
505
506 return rc;
507}
508
509/**
510 * Initializes the registered machine by loading the settings file.
511 * This method is separated from #init() in order to make it possible to
512 * retry the operation after VirtualBox startup instead of refusing to
513 * startup the whole VirtualBox server in case if the settings file of some
514 * registered VM is invalid or inaccessible.
515 *
516 * @note Must be always called from this object's write lock
517 * (unless called from #init() that doesn't need any locking).
518 * @note Locks the mUSBController method for writing.
519 * @note Subclasses must not call this method.
520 */
521HRESULT Machine::registeredInit()
522{
523 AssertReturn (mType == IsMachine, E_FAIL);
524 AssertReturn (!mData->mUuid.isEmpty(), E_FAIL);
525
526 HRESULT rc = initDataAndChildObjects();
527 CheckComRCReturnRC (rc);
528
529 if (!mData->mAccessible)
530 rc = lockConfig();
531
532 /* Temporarily reset the registered flag in order to let setters potentially
533 * called from loadSettings() succeed (isMutable() used in all setters
534 * will return FALSE for a Machine instance if mRegistered is TRUE). */
535 mData->mRegistered = FALSE;
536
537 if (SUCCEEDED (rc))
538 {
539 rc = loadSettings (true /* aRegistered */);
540
541 if (FAILED (rc))
542 unlockConfig();
543 }
544
545 if (SUCCEEDED (rc))
546 {
547 mData->mAccessible = TRUE;
548
549 /* commit all changes made during loading the settings file */
550 commit();
551
552 /* VirtualBox will not call trySetRegistered(), so
553 * inform the USB proxy about all attached USB filters */
554 mUSBController->onMachineRegistered (TRUE);
555 }
556 else
557 {
558 /* If the machine is registered, then, instead of returning a
559 * failure, we mark it as inaccessible and set the result to
560 * success to give it a try later */
561 mData->mAccessible = FALSE;
562 /* fetch the current error info */
563 mData->mAccessError = com::ErrorInfo();
564 LogWarning (("Machine {%Vuuid} is inaccessible! [%ls]\n",
565 mData->mUuid.raw(),
566 mData->mAccessError.getText().raw()));
567
568 /* rollback all changes */
569 rollback (false /* aNotify */);
570
571 /* uninitialize the common part to make sure all data is reset to
572 * default (null) values */
573 uninitDataAndChildObjects();
574
575 rc = S_OK;
576 }
577
578 /* Restore the registered flag (even on failure) */
579 mData->mRegistered = TRUE;
580
581 return rc;
582}
583
584/**
585 * Uninitializes the instance.
586 * Called either from FinalRelease() or by the parent when it gets destroyed.
587 *
588 * @note The caller of this method must make sure that this object
589 * a) doesn't have active callers on the current thread and b) is not locked
590 * by the current thread; otherwise uninit() will hang either a) due to
591 * AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
592 * a dead-lock caused by this thread waiting for all callers on the other
593 * threads are are done but preventing them from doing so by holding a lock.
594 */
595void Machine::uninit()
596{
597 LogFlowThisFuncEnter();
598
599 Assert (!isLockedOnCurrentThread());
600
601 /* Enclose the state transition Ready->InUninit->NotReady */
602 AutoUninitSpan autoUninitSpan (this);
603 if (autoUninitSpan.uninitDone())
604 return;
605
606 Assert (mType == IsMachine);
607 Assert (!!mData);
608
609 LogFlowThisFunc (("initFailed()=%d\n", autoUninitSpan.initFailed()));
610 LogFlowThisFunc (("mRegistered=%d\n", mData->mRegistered));
611
612 /*
613 * Enter this object's lock because there may be a SessionMachine instance
614 * somewhere around, that shares our data and lock but doesn't use our
615 * addCaller()/removeCaller(), and it may be also accessing the same
616 * data members. mParent lock is necessary as well because of
617 * SessionMachine::uninit(), etc.
618 */
619 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
620
621 if (!mData->mSession.mMachine.isNull())
622 {
623 /*
624 * Theoretically, this can only happen if the VirtualBox server has
625 * been terminated while there were clients running that owned open
626 * direct sessions. Since in this case we are definitely called by
627 * VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
628 * won't happen on the client watcher thread (because it does
629 * VirtualBox::addCaller() for the duration of the
630 * SessionMachine::checkForDeath() call, so that VirtualBox::uninit()
631 * cannot happen until the VirtualBox caller is released). This is
632 * important, because SessionMachine::uninit() cannot correctly operate
633 * after we return from this method (it expects the Machine instance
634 * is still valid). We'll call it ourselves below.
635 */
636 LogWarningThisFunc (("Session machine is not NULL (%p), "
637 "the direct session is still open!\n",
638 (SessionMachine *) mData->mSession.mMachine));
639
640 if (mData->mMachineState >= MachineState_Running)
641 {
642 LogWarningThisFunc (("Setting state to Aborted!\n"));
643 /* set machine state using SessionMachine reimplementation */
644 static_cast <Machine *> (mData->mSession.mMachine)
645 ->setMachineState (MachineState_Aborted);
646 }
647
648 /*
649 * Uninitialize SessionMachine using public uninit() to indicate
650 * an unexpected uninitialization.
651 */
652 mData->mSession.mMachine->uninit();
653 /* SessionMachine::uninit() must set mSession.mMachine to null */
654 Assert (mData->mSession.mMachine.isNull());
655 }
656
657 /* the lock is no more necessary (SessionMachine is uninitialized) */
658 alock.leave();
659
660 /* make sure the configuration is unlocked */
661 unlockConfig();
662
663 if (isModified())
664 {
665 LogWarningThisFunc (("Discarding unsaved settings changes!\n"));
666 rollback (false /* aNotify */);
667 }
668
669 if (mData->mAccessible)
670 uninitDataAndChildObjects();
671
672 /* free the essential data structure last */
673 mData.free();
674
675 mParent->removeDependentChild (this);
676
677 LogFlowThisFuncLeave();
678}
679
680// IMachine properties
681/////////////////////////////////////////////////////////////////////////////
682
683STDMETHODIMP Machine::COMGETTER(Parent) (IVirtualBox **aParent)
684{
685 if (!aParent)
686 return E_POINTER;
687
688 AutoLimitedCaller autoCaller (this);
689 CheckComRCReturnRC (autoCaller.rc());
690
691 /* mParent is constant during life time, no need to lock */
692 mParent.queryInterfaceTo (aParent);
693
694 return S_OK;
695}
696
697STDMETHODIMP Machine::COMGETTER(Accessible) (BOOL *aAccessible)
698{
699 if (!aAccessible)
700 return E_POINTER;
701
702 AutoLimitedCaller autoCaller (this);
703 CheckComRCReturnRC (autoCaller.rc());
704
705 AutoLock alock (this);
706
707 HRESULT rc = S_OK;
708
709 if (!mData->mAccessible)
710 {
711 /* try to initialize the VM once more if not accessible */
712
713 AutoReadySpan autoReadySpan (this);
714 AssertReturn (autoReadySpan.isOk(), E_FAIL);
715
716 rc = registeredInit();
717
718 if (mData->mAccessible)
719 autoReadySpan.setSucceeded();
720 }
721
722 if (SUCCEEDED (rc))
723 *aAccessible = mData->mAccessible;
724
725 return rc;
726}
727
728STDMETHODIMP Machine::COMGETTER(AccessError) (IVirtualBoxErrorInfo **aAccessError)
729{
730 if (!aAccessError)
731 return E_POINTER;
732
733 AutoLimitedCaller autoCaller (this);
734 CheckComRCReturnRC (autoCaller.rc());
735
736 AutoReaderLock alock (this);
737
738 if (mData->mAccessible || !mData->mAccessError.isBasicAvailable())
739 {
740 /* return shortly */
741 aAccessError = NULL;
742 return S_OK;
743 }
744
745 HRESULT rc = S_OK;
746
747 ComObjPtr <VirtualBoxErrorInfo> errorInfo;
748 rc = errorInfo.createObject();
749 if (SUCCEEDED (rc))
750 {
751 errorInfo->init (mData->mAccessError.getResultCode(),
752 mData->mAccessError.getInterfaceID(),
753 mData->mAccessError.getComponent(),
754 mData->mAccessError.getText());
755 rc = errorInfo.queryInterfaceTo (aAccessError);
756 }
757
758 return rc;
759}
760
761STDMETHODIMP Machine::COMGETTER(Name) (BSTR *aName)
762{
763 if (!aName)
764 return E_POINTER;
765
766 AutoCaller autoCaller (this);
767 CheckComRCReturnRC (autoCaller.rc());
768
769 AutoReaderLock alock (this);
770
771 mUserData->mName.cloneTo (aName);
772
773 return S_OK;
774}
775
776STDMETHODIMP Machine::COMSETTER(Name) (INPTR BSTR aName)
777{
778 if (!aName)
779 return E_INVALIDARG;
780
781 if (!*aName)
782 return setError (E_INVALIDARG,
783 tr ("Machine name cannot be empty"));
784
785 AutoCaller autoCaller (this);
786 CheckComRCReturnRC (autoCaller.rc());
787
788 AutoLock alock (this);
789
790 HRESULT rc = checkStateDependency (MutableStateDep);
791 CheckComRCReturnRC (rc);
792
793 mUserData.backup();
794 mUserData->mName = aName;
795
796 return S_OK;
797}
798
799STDMETHODIMP Machine::COMGETTER(Description) (BSTR *aDescription)
800{
801 if (!aDescription)
802 return E_POINTER;
803
804 AutoCaller autoCaller (this);
805 CheckComRCReturnRC (autoCaller.rc());
806
807 AutoReaderLock alock (this);
808
809 mUserData->mDescription.cloneTo (aDescription);
810
811 return S_OK;
812}
813
814STDMETHODIMP Machine::COMSETTER(Description) (INPTR BSTR aDescription)
815{
816 AutoCaller autoCaller (this);
817 CheckComRCReturnRC (autoCaller.rc());
818
819 AutoLock alock (this);
820
821 HRESULT rc = checkStateDependency (MutableStateDep);
822 CheckComRCReturnRC (rc);
823
824 mUserData.backup();
825 mUserData->mDescription = aDescription;
826
827 return S_OK;
828}
829
830STDMETHODIMP Machine::COMGETTER(Id) (GUIDPARAMOUT aId)
831{
832 if (!aId)
833 return E_POINTER;
834
835 AutoLimitedCaller autoCaller (this);
836 CheckComRCReturnRC (autoCaller.rc());
837
838 AutoReaderLock alock (this);
839
840 mData->mUuid.cloneTo (aId);
841
842 return S_OK;
843}
844
845STDMETHODIMP Machine::COMGETTER(OSTypeId) (BSTR *aOSTypeId)
846{
847 if (!aOSTypeId)
848 return E_POINTER;
849
850 AutoCaller autoCaller (this);
851 CheckComRCReturnRC (autoCaller.rc());
852
853 AutoReaderLock alock (this);
854
855 mUserData->mOSTypeId.cloneTo (aOSTypeId);
856
857 return S_OK;
858}
859
860STDMETHODIMP Machine::COMSETTER(OSTypeId) (INPTR BSTR aOSTypeId)
861{
862 if (!aOSTypeId)
863 return E_INVALIDARG;
864
865 AutoCaller autoCaller (this);
866 CheckComRCReturnRC (autoCaller.rc());
867
868 /* look up the object by Id to check it is valid */
869 ComPtr <IGuestOSType> guestOSType;
870 HRESULT rc = mParent->GetGuestOSType (aOSTypeId,
871 guestOSType.asOutParam());
872 CheckComRCReturnRC (rc);
873
874 AutoLock alock (this);
875
876 rc = checkStateDependency (MutableStateDep);
877 CheckComRCReturnRC (rc);
878
879 mUserData.backup();
880 mUserData->mOSTypeId = aOSTypeId;
881
882 return S_OK;
883}
884
885STDMETHODIMP Machine::COMGETTER(MemorySize) (ULONG *memorySize)
886{
887 if (!memorySize)
888 return E_POINTER;
889
890 AutoCaller autoCaller (this);
891 CheckComRCReturnRC (autoCaller.rc());
892
893 AutoReaderLock alock (this);
894
895 *memorySize = mHWData->mMemorySize;
896
897 return S_OK;
898}
899
900STDMETHODIMP Machine::COMSETTER(MemorySize) (ULONG memorySize)
901{
902 /* check RAM limits */
903 if (memorySize < SchemaDefs::MinGuestRAM ||
904 memorySize > SchemaDefs::MaxGuestRAM)
905 return setError (E_INVALIDARG,
906 tr ("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
907 memorySize, SchemaDefs::MinGuestRAM, SchemaDefs::MaxGuestRAM);
908
909 AutoCaller autoCaller (this);
910 CheckComRCReturnRC (autoCaller.rc());
911
912 AutoLock alock (this);
913
914 HRESULT rc = checkStateDependency (MutableStateDep);
915 CheckComRCReturnRC (rc);
916
917 mHWData.backup();
918 mHWData->mMemorySize = memorySize;
919
920 return S_OK;
921}
922
923STDMETHODIMP Machine::COMGETTER(VRAMSize) (ULONG *memorySize)
924{
925 if (!memorySize)
926 return E_POINTER;
927
928 AutoCaller autoCaller (this);
929 CheckComRCReturnRC (autoCaller.rc());
930
931 AutoReaderLock alock (this);
932
933 *memorySize = mHWData->mVRAMSize;
934
935 return S_OK;
936}
937
938STDMETHODIMP Machine::COMSETTER(VRAMSize) (ULONG memorySize)
939{
940 /* check VRAM limits */
941 if (memorySize < SchemaDefs::MinGuestVRAM ||
942 memorySize > SchemaDefs::MaxGuestVRAM)
943 return setError (E_INVALIDARG,
944 tr ("Invalid VRAM size: %lu MB (must be in range [%lu, %lu] MB)"),
945 memorySize, SchemaDefs::MinGuestVRAM, SchemaDefs::MaxGuestVRAM);
946
947 AutoCaller autoCaller (this);
948 CheckComRCReturnRC (autoCaller.rc());
949
950 AutoLock alock (this);
951
952 HRESULT rc = checkStateDependency (MutableStateDep);
953 CheckComRCReturnRC (rc);
954
955 mHWData.backup();
956 mHWData->mVRAMSize = memorySize;
957
958 return S_OK;
959}
960
961/** @todo this method should not be public */
962STDMETHODIMP Machine::COMGETTER(MemoryBalloonSize) (ULONG *memoryBalloonSize)
963{
964 if (!memoryBalloonSize)
965 return E_POINTER;
966
967 AutoCaller autoCaller (this);
968 CheckComRCReturnRC (autoCaller.rc());
969
970 AutoReaderLock alock (this);
971
972 *memoryBalloonSize = mHWData->mMemoryBalloonSize;
973
974 return S_OK;
975}
976
977/** @todo this method should not be public */
978STDMETHODIMP Machine::COMSETTER(MemoryBalloonSize) (ULONG memoryBalloonSize)
979{
980 /* check limits */
981 if (memoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
982 return setError (E_INVALIDARG,
983 tr ("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
984 memoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
985
986 AutoCaller autoCaller (this);
987 CheckComRCReturnRC (autoCaller.rc());
988
989 AutoLock alock (this);
990
991 HRESULT rc = checkStateDependency (MutableStateDep);
992 CheckComRCReturnRC (rc);
993
994 mHWData.backup();
995 mHWData->mMemoryBalloonSize = memoryBalloonSize;
996
997 return S_OK;
998}
999
1000/** @todo this method should not be public */
1001STDMETHODIMP Machine::COMGETTER(StatisticsUpdateInterval) (ULONG *statisticsUpdateInterval)
1002{
1003 if (!statisticsUpdateInterval)
1004 return E_POINTER;
1005
1006 AutoCaller autoCaller (this);
1007 CheckComRCReturnRC (autoCaller.rc());
1008
1009 AutoReaderLock alock (this);
1010
1011 *statisticsUpdateInterval = mHWData->mStatisticsUpdateInterval;
1012
1013 return S_OK;
1014}
1015
1016/** @todo this method should not be public */
1017STDMETHODIMP Machine::COMSETTER(StatisticsUpdateInterval) (ULONG statisticsUpdateInterval)
1018{
1019 AutoCaller autoCaller (this);
1020 CheckComRCReturnRC (autoCaller.rc());
1021
1022 AutoLock alock (this);
1023
1024 HRESULT rc = checkStateDependency (MutableStateDep);
1025 CheckComRCReturnRC (rc);
1026
1027 mHWData.backup();
1028 mHWData->mStatisticsUpdateInterval = statisticsUpdateInterval;
1029
1030 return S_OK;
1031}
1032
1033
1034STDMETHODIMP Machine::COMGETTER(MonitorCount) (ULONG *monitorCount)
1035{
1036 if (!monitorCount)
1037 return E_POINTER;
1038
1039 AutoCaller autoCaller (this);
1040 CheckComRCReturnRC (autoCaller.rc());
1041
1042 AutoReaderLock alock (this);
1043
1044 *monitorCount = mHWData->mMonitorCount;
1045
1046 return S_OK;
1047}
1048
1049STDMETHODIMP Machine::COMSETTER(MonitorCount) (ULONG monitorCount)
1050{
1051 /* make sure monitor count is a sensible number */
1052 if (monitorCount < 1 || monitorCount > SchemaDefs::MaxGuestMonitors)
1053 return setError (E_INVALIDARG,
1054 tr ("Invalid monitor count: %lu (must be in range [%lu, %lu])"),
1055 monitorCount, 1, SchemaDefs::MaxGuestMonitors);
1056
1057 AutoCaller autoCaller (this);
1058 CheckComRCReturnRC (autoCaller.rc());
1059
1060 AutoLock alock (this);
1061
1062 HRESULT rc = checkStateDependency (MutableStateDep);
1063 CheckComRCReturnRC (rc);
1064
1065 mHWData.backup();
1066 mHWData->mMonitorCount = monitorCount;
1067
1068 return S_OK;
1069}
1070
1071STDMETHODIMP Machine::COMGETTER(BIOSSettings)(IBIOSSettings **biosSettings)
1072{
1073 if (!biosSettings)
1074 return E_POINTER;
1075
1076 AutoCaller autoCaller (this);
1077 CheckComRCReturnRC (autoCaller.rc());
1078
1079 /* mBIOSSettings is constant during life time, no need to lock */
1080 mBIOSSettings.queryInterfaceTo (biosSettings);
1081
1082 return S_OK;
1083}
1084
1085STDMETHODIMP Machine::COMGETTER(HWVirtExEnabled)(TSBool_T *enabled)
1086{
1087 if (!enabled)
1088 return E_POINTER;
1089
1090 AutoCaller autoCaller (this);
1091 CheckComRCReturnRC (autoCaller.rc());
1092
1093 AutoReaderLock alock (this);
1094
1095 *enabled = mHWData->mHWVirtExEnabled;
1096
1097 return S_OK;
1098}
1099
1100STDMETHODIMP Machine::COMSETTER(HWVirtExEnabled)(TSBool_T enable)
1101{
1102 AutoCaller autoCaller (this);
1103 CheckComRCReturnRC (autoCaller.rc());
1104
1105 AutoLock alock (this);
1106
1107 HRESULT rc = checkStateDependency (MutableStateDep);
1108 CheckComRCReturnRC (rc);
1109
1110 /** @todo check validity! */
1111
1112 mHWData.backup();
1113 mHWData->mHWVirtExEnabled = enable;
1114
1115 return S_OK;
1116}
1117
1118STDMETHODIMP Machine::COMGETTER(SnapshotFolder) (BSTR *aSnapshotFolder)
1119{
1120 if (!aSnapshotFolder)
1121 return E_POINTER;
1122
1123 AutoCaller autoCaller (this);
1124 CheckComRCReturnRC (autoCaller.rc());
1125
1126 AutoReaderLock alock (this);
1127
1128 mUserData->mSnapshotFolderFull.cloneTo (aSnapshotFolder);
1129
1130 return S_OK;
1131}
1132
1133STDMETHODIMP Machine::COMSETTER(SnapshotFolder) (INPTR BSTR aSnapshotFolder)
1134{
1135 /* @todo (r=dmik):
1136 * 1. Allow to change the name of the snapshot folder containing snapshots
1137 * 2. Rename the folder on disk instead of just changing the property
1138 * value (to be smart and not to leave garbage). Note that it cannot be
1139 * done here because the change may be rolled back. Thus, the right
1140 * place is #saveSettings().
1141 */
1142
1143 AutoCaller autoCaller (this);
1144 CheckComRCReturnRC (autoCaller.rc());
1145
1146 AutoLock alock (this);
1147
1148 HRESULT rc = checkStateDependency (MutableStateDep);
1149 CheckComRCReturnRC (rc);
1150
1151 if (!mData->mCurrentSnapshot.isNull())
1152 return setError (E_FAIL,
1153 tr ("The snapshot folder of a machine with snapshots cannot "
1154 "be changed (please discard all snapshots first)"));
1155
1156 Utf8Str snapshotFolder = aSnapshotFolder;
1157
1158 if (snapshotFolder.isEmpty())
1159 {
1160 if (isInOwnDir())
1161 {
1162 /* the default snapshots folder is 'Snapshots' in the machine dir */
1163 snapshotFolder = Utf8Str ("Snapshots");
1164 }
1165 else
1166 {
1167 /* the default snapshots folder is {UUID}, for backwards
1168 * compatibility and to resolve conflicts */
1169 snapshotFolder = Utf8StrFmt ("{%Vuuid}", mData->mUuid.raw());
1170 }
1171 }
1172
1173 int vrc = calculateFullPath (snapshotFolder, snapshotFolder);
1174 if (VBOX_FAILURE (vrc))
1175 return setError (E_FAIL,
1176 tr ("Invalid snapshot folder: '%ls' (%Vrc)"),
1177 aSnapshotFolder, vrc);
1178
1179 mUserData.backup();
1180 mUserData->mSnapshotFolder = aSnapshotFolder;
1181 mUserData->mSnapshotFolderFull = snapshotFolder;
1182
1183 return S_OK;
1184}
1185
1186STDMETHODIMP Machine::COMGETTER(HardDiskAttachments) (IHardDiskAttachmentCollection **attachments)
1187{
1188 if (!attachments)
1189 return E_POINTER;
1190
1191 AutoCaller autoCaller (this);
1192 CheckComRCReturnRC (autoCaller.rc());
1193
1194 AutoReaderLock alock (this);
1195
1196 ComObjPtr <HardDiskAttachmentCollection> collection;
1197 collection.createObject();
1198 collection->init (mHDData->mHDAttachments);
1199 collection.queryInterfaceTo (attachments);
1200
1201 return S_OK;
1202}
1203
1204STDMETHODIMP Machine::COMGETTER(VRDPServer)(IVRDPServer **vrdpServer)
1205{
1206#ifdef VBOX_VRDP
1207 if (!vrdpServer)
1208 return E_POINTER;
1209
1210 AutoCaller autoCaller (this);
1211 CheckComRCReturnRC (autoCaller.rc());
1212
1213 AutoReaderLock alock (this);
1214
1215 Assert (!!mVRDPServer);
1216 mVRDPServer.queryInterfaceTo (vrdpServer);
1217
1218 return S_OK;
1219#else
1220 return E_NOTIMPL;
1221#endif
1222}
1223
1224STDMETHODIMP Machine::COMGETTER(DVDDrive) (IDVDDrive **dvdDrive)
1225{
1226 if (!dvdDrive)
1227 return E_POINTER;
1228
1229 AutoCaller autoCaller (this);
1230 CheckComRCReturnRC (autoCaller.rc());
1231
1232 AutoReaderLock alock (this);
1233
1234 Assert (!!mDVDDrive);
1235 mDVDDrive.queryInterfaceTo (dvdDrive);
1236 return S_OK;
1237}
1238
1239STDMETHODIMP Machine::COMGETTER(FloppyDrive) (IFloppyDrive **floppyDrive)
1240{
1241 if (!floppyDrive)
1242 return E_POINTER;
1243
1244 AutoCaller autoCaller (this);
1245 CheckComRCReturnRC (autoCaller.rc());
1246
1247 AutoReaderLock alock (this);
1248
1249 Assert (!!mFloppyDrive);
1250 mFloppyDrive.queryInterfaceTo (floppyDrive);
1251 return S_OK;
1252}
1253
1254STDMETHODIMP Machine::COMGETTER(AudioAdapter)(IAudioAdapter **audioAdapter)
1255{
1256 if (!audioAdapter)
1257 return E_POINTER;
1258
1259 AutoCaller autoCaller (this);
1260 CheckComRCReturnRC (autoCaller.rc());
1261
1262 AutoReaderLock alock (this);
1263
1264 mAudioAdapter.queryInterfaceTo (audioAdapter);
1265 return S_OK;
1266}
1267
1268STDMETHODIMP Machine::COMGETTER(USBController) (IUSBController **aUSBController)
1269{
1270#ifdef VBOX_WITH_USB
1271 if (!aUSBController)
1272 return E_POINTER;
1273
1274 AutoCaller autoCaller (this);
1275 CheckComRCReturnRC (autoCaller.rc());
1276
1277 MultiResult rc = mParent->host()->checkUSBProxyService();
1278 CheckComRCReturnRC (rc);
1279
1280 AutoReaderLock alock (this);
1281
1282 return rc = mUSBController.queryInterfaceTo (aUSBController);
1283#else
1284 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1285 * extended error info to indicate that USB is simply not available
1286 * (w/o treting it as a failure), for example, as in OSE */
1287 return E_NOTIMPL;
1288#endif
1289}
1290
1291STDMETHODIMP Machine::COMGETTER(SATAController) (ISATAController **aSATAController)
1292{
1293#ifdef VBOX_WITH_AHCI
1294 if (!aSATAController)
1295 return E_POINTER;
1296
1297 AutoCaller autoCaller (this);
1298 CheckComRCReturnRC (autoCaller.rc());
1299
1300 AutoReaderLock alock (this);
1301
1302 return mSATAController.queryInterfaceTo (aSATAController);
1303#else
1304 /* Note: The GUI depends on this method returning E_NOTIMPL with no
1305 * extended error info to indicate that SATA is simply not available
1306 * (w/o treting it as a failure), for example, as in OSE */
1307 return E_NOTIMPL;
1308#endif
1309}
1310
1311STDMETHODIMP Machine::COMGETTER(SettingsFilePath) (BSTR *aFilePath)
1312{
1313 if (!aFilePath)
1314 return E_POINTER;
1315
1316 AutoLimitedCaller autoCaller (this);
1317 CheckComRCReturnRC (autoCaller.rc());
1318
1319 AutoReaderLock alock (this);
1320
1321 mData->mConfigFileFull.cloneTo (aFilePath);
1322 return S_OK;
1323}
1324
1325STDMETHODIMP Machine::
1326COMGETTER(SettingsFileVersion) (BSTR *aSettingsFileVersion)
1327{
1328 if (!aSettingsFileVersion)
1329 return E_INVALIDARG;
1330
1331 AutoCaller autoCaller (this);
1332 CheckComRCReturnRC (autoCaller.rc());
1333
1334 AutoReaderLock alock (this);
1335
1336 mData->mSettingsFileVersion.cloneTo (aSettingsFileVersion);
1337 return S_OK;
1338}
1339
1340STDMETHODIMP Machine::COMGETTER(SettingsModified) (BOOL *aModified)
1341{
1342 if (!aModified)
1343 return E_POINTER;
1344
1345 AutoCaller autoCaller (this);
1346 CheckComRCReturnRC (autoCaller.rc());
1347
1348 AutoLock alock (this);
1349
1350 HRESULT rc = checkStateDependency (MutableStateDep);
1351 CheckComRCReturnRC (rc);
1352
1353 if (!isConfigLocked())
1354 {
1355 /*
1356 * if we're ready and isConfigLocked() is FALSE then it means
1357 * that no config file exists yet, so always return TRUE
1358 */
1359 *aModified = TRUE;
1360 }
1361 else
1362 {
1363 *aModified = isModified();
1364 }
1365
1366 return S_OK;
1367}
1368
1369STDMETHODIMP Machine::COMGETTER(SessionState) (SessionState_T *aSessionState)
1370{
1371 if (!aSessionState)
1372 return E_POINTER;
1373
1374 AutoCaller autoCaller (this);
1375 CheckComRCReturnRC (autoCaller.rc());
1376
1377 AutoReaderLock alock (this);
1378
1379 *aSessionState = mData->mSession.mState;
1380
1381 return S_OK;
1382}
1383
1384STDMETHODIMP Machine::COMGETTER(SessionType) (BSTR *aSessionType)
1385{
1386 if (!aSessionType)
1387 return E_POINTER;
1388
1389 AutoCaller autoCaller (this);
1390 CheckComRCReturnRC (autoCaller.rc());
1391
1392 AutoReaderLock alock (this);
1393
1394 mData->mSession.mType.cloneTo (aSessionType);
1395
1396 return S_OK;
1397}
1398
1399STDMETHODIMP Machine::COMGETTER(SessionPid) (ULONG *aSessionPid)
1400{
1401 if (!aSessionPid)
1402 return E_POINTER;
1403
1404 AutoCaller autoCaller (this);
1405 CheckComRCReturnRC (autoCaller.rc());
1406
1407 AutoReaderLock alock (this);
1408
1409 *aSessionPid = mData->mSession.mPid;
1410
1411 return S_OK;
1412}
1413
1414STDMETHODIMP Machine::COMGETTER(State) (MachineState_T *machineState)
1415{
1416 if (!machineState)
1417 return E_POINTER;
1418
1419 AutoCaller autoCaller (this);
1420 CheckComRCReturnRC (autoCaller.rc());
1421
1422 AutoReaderLock alock (this);
1423
1424 *machineState = mData->mMachineState;
1425
1426 return S_OK;
1427}
1428
1429STDMETHODIMP Machine::COMGETTER(LastStateChange) (LONG64 *aLastStateChange)
1430{
1431 if (!aLastStateChange)
1432 return E_POINTER;
1433
1434 AutoCaller autoCaller (this);
1435 CheckComRCReturnRC (autoCaller.rc());
1436
1437 AutoReaderLock alock (this);
1438
1439 *aLastStateChange = RTTimeSpecGetMilli (&mData->mLastStateChange);
1440
1441 return S_OK;
1442}
1443
1444STDMETHODIMP Machine::COMGETTER(StateFilePath) (BSTR *aStateFilePath)
1445{
1446 if (!aStateFilePath)
1447 return E_POINTER;
1448
1449 AutoCaller autoCaller (this);
1450 CheckComRCReturnRC (autoCaller.rc());
1451
1452 AutoReaderLock alock (this);
1453
1454 mSSData->mStateFilePath.cloneTo (aStateFilePath);
1455
1456 return S_OK;
1457}
1458
1459STDMETHODIMP Machine::COMGETTER(LogFolder) (BSTR *aLogFolder)
1460{
1461 if (!aLogFolder)
1462 return E_POINTER;
1463
1464 AutoCaller autoCaller (this);
1465 AssertComRCReturnRC (autoCaller.rc());
1466
1467 AutoReaderLock alock (this);
1468
1469 Utf8Str logFolder;
1470 getLogFolder (logFolder);
1471
1472 Bstr (logFolder).cloneTo (aLogFolder);
1473
1474 return S_OK;
1475}
1476
1477STDMETHODIMP Machine::COMGETTER(CurrentSnapshot) (ISnapshot **aCurrentSnapshot)
1478{
1479 if (!aCurrentSnapshot)
1480 return E_POINTER;
1481
1482 AutoCaller autoCaller (this);
1483 CheckComRCReturnRC (autoCaller.rc());
1484
1485 AutoReaderLock alock (this);
1486
1487 mData->mCurrentSnapshot.queryInterfaceTo (aCurrentSnapshot);
1488
1489 return S_OK;
1490}
1491
1492STDMETHODIMP Machine::COMGETTER(SnapshotCount) (ULONG *aSnapshotCount)
1493{
1494 if (!aSnapshotCount)
1495 return E_POINTER;
1496
1497 AutoCaller autoCaller (this);
1498 CheckComRCReturnRC (autoCaller.rc());
1499
1500 AutoReaderLock alock (this);
1501
1502 *aSnapshotCount = !mData->mFirstSnapshot ? 0 :
1503 mData->mFirstSnapshot->descendantCount() + 1 /* self */;
1504
1505 return S_OK;
1506}
1507
1508STDMETHODIMP Machine::COMGETTER(CurrentStateModified) (BOOL *aCurrentStateModified)
1509{
1510 if (!aCurrentStateModified)
1511 return E_POINTER;
1512
1513 AutoCaller autoCaller (this);
1514 CheckComRCReturnRC (autoCaller.rc());
1515
1516 AutoReaderLock alock (this);
1517
1518 /*
1519 * Note: for machines with no snapshots, we always return FALSE
1520 * (mData->mCurrentStateModified will be TRUE in this case, for historical
1521 * reasons :)
1522 */
1523
1524 *aCurrentStateModified = !mData->mFirstSnapshot ? FALSE :
1525 mData->mCurrentStateModified;
1526
1527 return S_OK;
1528}
1529
1530STDMETHODIMP
1531Machine::COMGETTER(SharedFolders) (ISharedFolderCollection **aSharedFolders)
1532{
1533 if (!aSharedFolders)
1534 return E_POINTER;
1535
1536 AutoCaller autoCaller (this);
1537 CheckComRCReturnRC (autoCaller.rc());
1538
1539 AutoReaderLock alock (this);
1540
1541 ComObjPtr <SharedFolderCollection> coll;
1542 coll.createObject();
1543 coll->init (mHWData->mSharedFolders);
1544 coll.queryInterfaceTo (aSharedFolders);
1545
1546 return S_OK;
1547}
1548
1549STDMETHODIMP
1550Machine::COMGETTER(ClipboardMode) (ClipboardMode_T *aClipboardMode)
1551{
1552 if (!aClipboardMode)
1553 return E_POINTER;
1554
1555 AutoCaller autoCaller (this);
1556 CheckComRCReturnRC (autoCaller.rc());
1557
1558 AutoReaderLock alock (this);
1559
1560 *aClipboardMode = mHWData->mClipboardMode;
1561
1562 return S_OK;
1563}
1564
1565STDMETHODIMP
1566Machine::COMSETTER(ClipboardMode) (ClipboardMode_T aClipboardMode)
1567{
1568 AutoCaller autoCaller (this);
1569 CheckComRCReturnRC (autoCaller.rc());
1570
1571 AutoLock alock (this);
1572
1573 HRESULT rc = checkStateDependency (MutableStateDep);
1574 CheckComRCReturnRC (rc);
1575
1576 mHWData.backup();
1577 mHWData->mClipboardMode = aClipboardMode;
1578
1579 return S_OK;
1580}
1581
1582// IMachine methods
1583/////////////////////////////////////////////////////////////////////////////
1584
1585STDMETHODIMP Machine::SetBootOrder (ULONG aPosition, DeviceType_T aDevice)
1586{
1587 if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
1588 return setError (E_INVALIDARG,
1589 tr ("Invalid boot position: %lu (must be in range [1, %lu])"),
1590 aPosition, SchemaDefs::MaxBootPosition);
1591
1592 if (aDevice == DeviceType_USB)
1593 return setError (E_FAIL,
1594 tr ("Booting from USB devices is not currently supported"));
1595
1596 AutoCaller autoCaller (this);
1597 CheckComRCReturnRC (autoCaller.rc());
1598
1599 AutoLock alock (this);
1600
1601 HRESULT rc = checkStateDependency (MutableStateDep);
1602 CheckComRCReturnRC (rc);
1603
1604 mHWData.backup();
1605 mHWData->mBootOrder [aPosition - 1] = aDevice;
1606
1607 return S_OK;
1608}
1609
1610STDMETHODIMP Machine::GetBootOrder (ULONG aPosition, DeviceType_T *aDevice)
1611{
1612 if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
1613 return setError (E_INVALIDARG,
1614 tr ("Invalid boot position: %lu (must be in range [1, %lu])"),
1615 aPosition, SchemaDefs::MaxBootPosition);
1616
1617 AutoCaller autoCaller (this);
1618 CheckComRCReturnRC (autoCaller.rc());
1619
1620 AutoReaderLock alock (this);
1621
1622 *aDevice = mHWData->mBootOrder [aPosition - 1];
1623
1624 return S_OK;
1625}
1626
1627STDMETHODIMP Machine::AttachHardDisk (INPTR GUIDPARAM aId,
1628 StorageBus_T aBus, LONG aChannel, LONG aDevice)
1629{
1630 Guid id = aId;
1631
1632 if (id.isEmpty() || aBus == StorageBus_Null)
1633 return E_INVALIDARG;
1634
1635 AutoCaller autoCaller (this);
1636 CheckComRCReturnRC (autoCaller.rc());
1637
1638 /* VirtualBox::getHardDisk() need read lock */
1639 AutoMultiLock <2> alock (mParent->rlock(), this->wlock());
1640
1641 HRESULT rc = checkStateDependency (MutableStateDep);
1642 CheckComRCReturnRC (rc);
1643
1644 if (!mData->mRegistered)
1645 return setError (E_FAIL,
1646 tr ("Cannot attach hard disks to an unregistered machine"));
1647
1648 AssertReturn (mData->mMachineState != MachineState_Saved, E_FAIL);
1649
1650 if (mData->mMachineState >= MachineState_Running)
1651 return setError (E_FAIL,
1652 tr ("Invalid machine state: %d"), mData->mMachineState);
1653
1654 /* see if the device on the controller is already busy */
1655 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
1656 it != mHDData->mHDAttachments.end(); ++ it)
1657 {
1658 ComObjPtr <HardDiskAttachment> hda = *it;
1659 if (hda->bus() == aBus && hda->channel() == aChannel && hda->device() == aDevice)
1660 {
1661 ComObjPtr <HardDisk> hd = hda->hardDisk();
1662 AutoLock hdLock (hd);
1663 return setError (E_FAIL,
1664 tr ("Hard disk '%ls' is already attached to device slot %d on "
1665 "channel %d of bus %d"),
1666 hd->toString().raw(), aDevice, aChannel, aBus);
1667 }
1668 }
1669
1670 /* find a hard disk by UUID */
1671 ComObjPtr <HardDisk> hd;
1672 rc = mParent->getHardDisk (id, hd);
1673 CheckComRCReturnRC (rc);
1674
1675 /* create an attachment object early to let it check argiuments */
1676 ComObjPtr <HardDiskAttachment> attachment;
1677 attachment.createObject();
1678 rc = attachment->init (hd, aBus, aChannel, aDevice, false /* aDirty */);
1679 CheckComRCReturnRC (rc);
1680
1681 AutoLock hdLock (hd);
1682
1683 if (hd->isDifferencing())
1684 return setError (E_FAIL,
1685 tr ("Cannot attach the differencing hard disk '%ls'"),
1686 hd->toString().raw());
1687
1688 bool dirty = false;
1689
1690 switch (hd->type())
1691 {
1692 case HardDiskType_Immutable:
1693 {
1694 Assert (hd->machineId().isEmpty());
1695 /*
1696 * increase readers to protect from unregistration
1697 * until rollback()/commit() is done
1698 */
1699 hd->addReader();
1700 Log3 (("A: %ls proteced\n", hd->toString().raw()));
1701 dirty = true;
1702 break;
1703 }
1704 case HardDiskType_Writethrough:
1705 {
1706 Assert (hd->children().size() == 0);
1707 Assert (hd->snapshotId().isEmpty());
1708 /* fall through */
1709 }
1710 case HardDiskType_Normal:
1711 {
1712 if (hd->machineId().isEmpty())
1713 {
1714 /* attach directly */
1715 hd->setMachineId (mData->mUuid);
1716 Log3 (("A: %ls associated with %Vuuid\n",
1717 hd->toString().raw(), mData->mUuid.raw()));
1718 dirty = true;
1719 }
1720 else
1721 {
1722 /* determine what the hard disk is already attached to */
1723 if (hd->snapshotId().isEmpty())
1724 {
1725 /* attached to some VM in its current state */
1726 if (hd->machineId() == mData->mUuid)
1727 {
1728 /*
1729 * attached to us, either in the backed up list of the
1730 * attachments or in the current one; the former is ok
1731 * (reattachment takes place within the same
1732 * "transaction") the latter is an error so check for it
1733 */
1734 for (HDData::HDAttachmentList::const_iterator it =
1735 mHDData->mHDAttachments.begin();
1736 it != mHDData->mHDAttachments.end(); ++ it)
1737 {
1738 if ((*it)->hardDisk().equalsTo (hd))
1739 {
1740 return setError (E_FAIL,
1741 tr ("Normal/Writethrough hard disk '%ls' is "
1742 "currently attached to device slot %d on channel %d "
1743 "of bus %d of this machine"),
1744 hd->toString().raw(),
1745 (*it)->device(),
1746 (*it)->channel(), (*it)->bus());
1747 }
1748 }
1749 /*
1750 * dirty = false to indicate we didn't set machineId
1751 * and prevent it from being reset in DetachHardDisk()
1752 */
1753 Log3 (("A: %ls found in old\n", hd->toString().raw()));
1754 }
1755 else
1756 {
1757 /* attached to other VM */
1758 return setError (E_FAIL,
1759 tr ("Normal/Writethrough hard disk '%ls' is "
1760 "currently attached to a machine with "
1761 "UUID {%Vuuid}"),
1762 hd->toString().raw(), hd->machineId().raw());
1763 }
1764 }
1765 else
1766 {
1767 /*
1768 * here we go when the HardDiskType_Normal
1769 * is attached to some VM (probably to this one, too)
1770 * at some particular snapshot, so we can create a diff
1771 * based on it
1772 */
1773 Assert (!hd->machineId().isEmpty());
1774 /*
1775 * increase readers to protect from unregistration
1776 * until rollback()/commit() is done
1777 */
1778 hd->addReader();
1779 Log3 (("A: %ls proteced\n", hd->toString().raw()));
1780 dirty = true;
1781 }
1782 }
1783
1784 break;
1785 }
1786 }
1787
1788 attachment->setDirty (dirty);
1789
1790 mHDData.backup();
1791 mHDData->mHDAttachments.push_back (attachment);
1792 Log3 (("A: %ls attached\n", hd->toString().raw()));
1793
1794 /* note: diff images are actually created only in commit() */
1795
1796 return S_OK;
1797}
1798
1799STDMETHODIMP Machine::GetHardDisk (StorageBus_T aBus, LONG aChannel,
1800 LONG aDevice, IHardDisk **aHardDisk)
1801{
1802 if (aBus == StorageBus_Null)
1803 return E_INVALIDARG;
1804
1805 AutoCaller autoCaller (this);
1806 CheckComRCReturnRC (autoCaller.rc());
1807
1808 AutoReaderLock alock (this);
1809
1810 *aHardDisk = NULL;
1811
1812 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
1813 it != mHDData->mHDAttachments.end(); ++ it)
1814 {
1815 ComObjPtr <HardDiskAttachment> hda = *it;
1816 if (hda->bus() == aBus && hda->channel() == aChannel && hda->device() == aDevice)
1817 {
1818 hda->hardDisk().queryInterfaceTo (aHardDisk);
1819 return S_OK;
1820 }
1821 }
1822
1823 return setError (E_INVALIDARG,
1824 tr ("No hard disk attached to device slot %d on channel %d of bus %d"),
1825 aDevice, aChannel, aBus);
1826}
1827
1828STDMETHODIMP Machine::DetachHardDisk (StorageBus_T aBus, LONG aChannel, LONG aDevice)
1829{
1830 if (aBus == StorageBus_Null)
1831 return E_INVALIDARG;
1832
1833 AutoCaller autoCaller (this);
1834 CheckComRCReturnRC (autoCaller.rc());
1835
1836 AutoLock alock (this);
1837
1838 HRESULT rc = checkStateDependency (MutableStateDep);
1839 CheckComRCReturnRC (rc);
1840
1841 AssertReturn (mData->mMachineState != MachineState_Saved, E_FAIL);
1842
1843 if (mData->mMachineState >= MachineState_Running)
1844 return setError (E_FAIL,
1845 tr ("Invalid machine state: %d"), mData->mMachineState);
1846
1847 for (HDData::HDAttachmentList::iterator it = mHDData->mHDAttachments.begin();
1848 it != mHDData->mHDAttachments.end(); ++ it)
1849 {
1850 ComObjPtr <HardDiskAttachment> hda = *it;
1851 if (hda->bus() == aBus && hda->channel() == aChannel && hda->device() == aDevice)
1852 {
1853 ComObjPtr <HardDisk> hd = hda->hardDisk();
1854 AutoLock hdLock (hd);
1855
1856 ComAssertRet (hd->children().size() == 0 &&
1857 hd->machineId() == mData->mUuid, E_FAIL);
1858
1859 if (hda->isDirty())
1860 {
1861 switch (hd->type())
1862 {
1863 case HardDiskType_Immutable:
1864 {
1865 /* decrease readers increased in AttachHardDisk() */
1866 hd->releaseReader();
1867 Log3 (("D: %ls released\n", hd->toString().raw()));
1868 break;
1869 }
1870 case HardDiskType_Writethrough:
1871 {
1872 /* deassociate from this machine */
1873 hd->setMachineId (Guid());
1874 Log3 (("D: %ls deassociated\n", hd->toString().raw()));
1875 break;
1876 }
1877 case HardDiskType_Normal:
1878 {
1879 if (hd->snapshotId().isEmpty())
1880 {
1881 /* deassociate from this machine */
1882 hd->setMachineId (Guid());
1883 Log3 (("D: %ls deassociated\n", hd->toString().raw()));
1884 }
1885 else
1886 {
1887 /* decrease readers increased in AttachHardDisk() */
1888 hd->releaseReader();
1889 Log3 (("%ls released\n", hd->toString().raw()));
1890 }
1891
1892 break;
1893 }
1894 }
1895 }
1896
1897 mHDData.backup();
1898 /*
1899 * we cannot use erase (it) below because backup() above will create
1900 * a copy of the list and make this copy active, but the iterator
1901 * still refers to the original and is not valid for a copy
1902 */
1903 mHDData->mHDAttachments.remove (hda);
1904 Log3 (("D: %ls detached\n", hd->toString().raw()));
1905
1906 /*
1907 * note: Non-dirty hard disks are actually deassociated
1908 * and diff images are deleted only in commit()
1909 */
1910
1911 return S_OK;
1912 }
1913 }
1914
1915 return setError (E_INVALIDARG,
1916 tr ("No hard disk attached to device slot %d on channel %d of bus %d"),
1917 aDevice, aChannel, aBus);
1918}
1919
1920STDMETHODIMP Machine::GetSerialPort (ULONG slot, ISerialPort **port)
1921{
1922 if (!port)
1923 return E_POINTER;
1924 if (slot >= ELEMENTS (mSerialPorts))
1925 return setError (E_INVALIDARG, tr ("Invalid slot number: %d"), slot);
1926
1927 AutoCaller autoCaller (this);
1928 CheckComRCReturnRC (autoCaller.rc());
1929
1930 AutoReaderLock alock (this);
1931
1932 mSerialPorts [slot].queryInterfaceTo (port);
1933
1934 return S_OK;
1935}
1936
1937STDMETHODIMP Machine::GetParallelPort (ULONG slot, IParallelPort **port)
1938{
1939 if (!port)
1940 return E_POINTER;
1941 if (slot >= ELEMENTS (mParallelPorts))
1942 return setError (E_INVALIDARG, tr ("Invalid slot number: %d"), slot);
1943
1944 AutoCaller autoCaller (this);
1945 CheckComRCReturnRC (autoCaller.rc());
1946
1947 AutoReaderLock alock (this);
1948
1949 mParallelPorts [slot].queryInterfaceTo (port);
1950
1951 return S_OK;
1952}
1953
1954STDMETHODIMP Machine::GetNetworkAdapter (ULONG slot, INetworkAdapter **adapter)
1955{
1956 if (!adapter)
1957 return E_POINTER;
1958 if (slot >= ELEMENTS (mNetworkAdapters))
1959 return setError (E_INVALIDARG, tr ("Invalid slot number: %d"), slot);
1960
1961 AutoCaller autoCaller (this);
1962 CheckComRCReturnRC (autoCaller.rc());
1963
1964 AutoReaderLock alock (this);
1965
1966 mNetworkAdapters [slot].queryInterfaceTo (adapter);
1967
1968 return S_OK;
1969}
1970
1971/**
1972 * @note Locks this object for reading.
1973 */
1974STDMETHODIMP Machine::GetNextExtraDataKey (INPTR BSTR aKey, BSTR *aNextKey, BSTR *aNextValue)
1975{
1976 if (!aNextKey)
1977 return E_POINTER;
1978
1979 AutoCaller autoCaller (this);
1980 CheckComRCReturnRC (autoCaller.rc());
1981
1982 AutoReaderLock alock (this);
1983
1984 /* start with nothing found */
1985 *aNextKey = NULL;
1986 if (aNextValue)
1987 *aNextValue = NULL;
1988
1989 /* if we're ready and isConfigLocked() is FALSE then it means
1990 * that no config file exists yet, so return shortly */
1991 if (!isConfigLocked())
1992 return S_OK;
1993
1994 HRESULT rc = S_OK;
1995
1996 try
1997 {
1998 using namespace settings;
1999
2000 /* load the config file */
2001 File file (File::ReadWrite, mData->mHandleCfgFile,
2002 Utf8Str (mData->mConfigFileFull));
2003 XmlTreeBackend tree;
2004
2005 rc = VirtualBox::loadSettingsTree_Again (tree, file);
2006 CheckComRCReturnRC (rc);
2007
2008 Key machineNode = tree.rootKey().key ("Machine");
2009 Key extraDataNode = machineNode.findKey ("ExtraData");
2010
2011 if (!extraDataNode.isNull())
2012 {
2013 Key::List items = extraDataNode.keys ("ExtraDataItem");
2014 if (items.size())
2015 {
2016 for (Key::List::const_iterator it = items.begin();
2017 it != items.end(); ++ it)
2018 {
2019 Bstr key = (*it).stringValue ("name");
2020
2021 /* if we're supposed to return the first one */
2022 if (aKey == NULL)
2023 {
2024 key.cloneTo (aNextKey);
2025 if (aNextValue)
2026 {
2027 Bstr val = (*it).stringValue ("value");
2028 val.cloneTo (aNextValue);
2029 }
2030 return S_OK;
2031 }
2032
2033 /* did we find the key we're looking for? */
2034 if (key == aKey)
2035 {
2036 ++ it;
2037 /* is there another item? */
2038 if (it != items.end())
2039 {
2040 Bstr key = (*it).stringValue ("name");
2041 key.cloneTo (aNextKey);
2042 if (aNextValue)
2043 {
2044 Bstr val = (*it).stringValue ("value");
2045 val.cloneTo (aNextValue);
2046 }
2047 }
2048 /* else it's the last one, arguments are already NULL */
2049 return S_OK;
2050 }
2051 }
2052 }
2053 }
2054
2055 /* Here we are when a) there are no items at all or b) there are items
2056 * but none of them equals to the requested non-NULL key. b) is an
2057 * error as well as a) if the key is non-NULL. When the key is NULL
2058 * (which is the case only when there are no items), we just fall
2059 * through to return NULLs and S_OK. */
2060
2061 if (aKey != NULL)
2062 return setError (E_FAIL,
2063 tr ("Could not find the extra data key '%ls'"), aKey);
2064 }
2065 catch (...)
2066 {
2067 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
2068 }
2069
2070 return rc;
2071}
2072
2073/**
2074 * @note Locks this object for reading.
2075 */
2076STDMETHODIMP Machine::GetExtraData (INPTR BSTR aKey, BSTR *aValue)
2077{
2078 if (!aKey)
2079 return E_INVALIDARG;
2080 if (!aValue)
2081 return E_POINTER;
2082
2083 AutoCaller autoCaller (this);
2084 CheckComRCReturnRC (autoCaller.rc());
2085
2086 AutoReaderLock alock (this);
2087
2088 /* start with nothing found */
2089 *aValue = NULL;
2090
2091 /* if we're ready and isConfigLocked() is FALSE then it means
2092 * that no config file exists yet, so return shortly */
2093 if (!isConfigLocked())
2094 return S_OK;
2095
2096 HRESULT rc = S_OK;
2097
2098 try
2099 {
2100 using namespace settings;
2101
2102 /* load the config file */
2103 File file (File::ReadWrite, mData->mHandleCfgFile,
2104 Utf8Str (mData->mConfigFileFull));
2105 XmlTreeBackend tree;
2106
2107 rc = VirtualBox::loadSettingsTree_Again (tree, file);
2108 CheckComRCReturnRC (rc);
2109
2110 const Utf8Str key = aKey;
2111
2112 Key machineNode = tree.rootKey().key ("Machine");
2113 Key extraDataNode = machineNode.findKey ("ExtraData");
2114
2115 if (!extraDataNode.isNull())
2116 {
2117 /* check if the key exists */
2118 Key::List items = extraDataNode.keys ("ExtraDataItem");
2119 for (Key::List::const_iterator it = items.begin();
2120 it != items.end(); ++ it)
2121 {
2122 if (key == (*it).stringValue ("name"))
2123 {
2124 Bstr val = (*it).stringValue ("value");
2125 val.cloneTo (aValue);
2126 break;
2127 }
2128 }
2129 }
2130 }
2131 catch (...)
2132 {
2133 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
2134 }
2135
2136 return rc;
2137}
2138
2139/**
2140 * @note Locks mParent for writing + this object for writing.
2141 */
2142STDMETHODIMP Machine::SetExtraData (INPTR BSTR aKey, INPTR BSTR aValue)
2143{
2144 if (!aKey)
2145 return E_INVALIDARG;
2146
2147 AutoCaller autoCaller (this);
2148 CheckComRCReturnRC (autoCaller.rc());
2149
2150 /* VirtualBox::onExtraDataCanChange() and saveSettings() need mParent
2151 * lock (saveSettings() needs a write one) */
2152 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
2153
2154 if (mType == IsSnapshotMachine)
2155 {
2156 HRESULT rc = checkStateDependency (MutableStateDep);
2157 CheckComRCReturnRC (rc);
2158 }
2159
2160 bool changed = false;
2161 HRESULT rc = S_OK;
2162
2163 /* If we're ready and isConfigLocked() is FALSE then it means that no
2164 * config file exists yet, so call saveSettings() to create one. */
2165 if (!isConfigLocked())
2166 {
2167 rc = saveSettings (false /* aMarkCurStateAsModified */);
2168 CheckComRCReturnRC (rc);
2169 }
2170
2171 try
2172 {
2173 using namespace settings;
2174
2175 /* load the config file */
2176 File file (File::ReadWrite, mData->mHandleCfgFile,
2177 Utf8Str (mData->mConfigFileFull));
2178 XmlTreeBackend tree;
2179
2180 rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
2181 CheckComRCReturnRC (rc);
2182
2183 const Utf8Str key = aKey;
2184 Bstr oldVal;
2185
2186 Key machineNode = tree.rootKey().key ("Machine");
2187 Key extraDataNode = machineNode.createKey ("ExtraData");
2188 Key extraDataItemNode;
2189
2190 Key::List items = extraDataNode.keys ("ExtraDataItem");
2191 for (Key::List::const_iterator it = items.begin();
2192 it != items.end(); ++ it)
2193 {
2194 if (key == (*it).stringValue ("name"))
2195 {
2196 extraDataItemNode = *it;
2197 oldVal = (*it).stringValue ("value");
2198 break;
2199 }
2200 }
2201
2202 /* When no key is found, oldVal is null */
2203 changed = oldVal != aValue;
2204
2205 if (changed)
2206 {
2207 /* ask for permission from all listeners */
2208 Bstr error;
2209 if (!mParent->onExtraDataCanChange (mData->mUuid, aKey, aValue, error))
2210 {
2211 const char *sep = error.isEmpty() ? "" : ": ";
2212 const BSTR err = error.isNull() ? (const BSTR) L"" : error.raw();
2213 LogWarningFunc (("Someone vetoed! Change refused%s%ls\n",
2214 sep, err));
2215 return setError (E_ACCESSDENIED,
2216 tr ("Could not set extra data because someone refused "
2217 "the requested change of '%ls' to '%ls'%s%ls"),
2218 aKey, aValue, sep, err);
2219 }
2220
2221 if (aValue != NULL)
2222 {
2223 if (extraDataItemNode.isNull())
2224 {
2225 extraDataItemNode = extraDataNode.appendKey ("ExtraDataItem");
2226 extraDataItemNode.setStringValue ("name", key);
2227 }
2228 extraDataItemNode.setStringValue ("value", Utf8Str (aValue));
2229 }
2230 else
2231 {
2232 /* an old value does for sure exist here (XML schema
2233 * guarantees that "value" may not absent in the
2234 * <ExtraDataItem> element) */
2235 Assert (!extraDataItemNode.isNull());
2236 extraDataItemNode.zap();
2237 }
2238
2239 /* save settings on success */
2240 rc = VirtualBox::saveSettingsTree (tree, file,
2241 mData->mSettingsFileVersion);
2242 CheckComRCReturnRC (rc);
2243 }
2244 }
2245 catch (...)
2246 {
2247 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
2248 }
2249
2250 /* fire a notification */
2251 if (SUCCEEDED (rc) && changed)
2252 mParent->onExtraDataChange (mData->mUuid, aKey, aValue);
2253
2254 return rc;
2255}
2256
2257STDMETHODIMP Machine::SaveSettings()
2258{
2259 AutoCaller autoCaller (this);
2260 CheckComRCReturnRC (autoCaller.rc());
2261
2262 /* saveSettings() needs mParent lock */
2263 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
2264
2265 HRESULT rc = checkStateDependency (MutableStateDep);
2266 CheckComRCReturnRC (rc);
2267
2268 /* the settings file path may never be null */
2269 ComAssertRet (mData->mConfigFileFull, E_FAIL);
2270
2271 /* save all VM data excluding snapshots */
2272 return saveSettings();
2273}
2274
2275STDMETHODIMP Machine::SaveSettingsWithBackup (BSTR *aBakFileName)
2276{
2277 if (!aBakFileName)
2278 return E_POINTER;
2279
2280 AutoCaller autoCaller (this);
2281 CheckComRCReturnRC (autoCaller.rc());
2282
2283 /* saveSettings() needs mParent lock */
2284 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
2285
2286 HRESULT rc = checkStateDependency (MutableStateDep);
2287 CheckComRCReturnRC (rc);
2288
2289 /* the settings file path may never be null */
2290 ComAssertRet (mData->mConfigFileFull, E_FAIL);
2291
2292 /* perform backup only when there was auto-conversion */
2293 if (mData->mSettingsFileVersion != VBOX_XML_VERSION_FULL)
2294 {
2295 Bstr bakFileName;
2296
2297 HRESULT rc = VirtualBox::backupSettingsFile (mData->mConfigFileFull,
2298 mData->mSettingsFileVersion,
2299 bakFileName);
2300 CheckComRCReturnRC (rc);
2301
2302 bakFileName.cloneTo (aBakFileName);
2303 }
2304
2305 /* save all VM data excluding snapshots */
2306 return saveSettings();
2307}
2308
2309STDMETHODIMP Machine::DiscardSettings()
2310{
2311 AutoCaller autoCaller (this);
2312 CheckComRCReturnRC (autoCaller.rc());
2313
2314 AutoLock alock (this);
2315
2316 HRESULT rc = checkStateDependency (MutableStateDep);
2317 CheckComRCReturnRC (rc);
2318
2319 /*
2320 * during this rollback, the session will be notified if data has
2321 * been actually changed
2322 */
2323 rollback (true /* aNotify */);
2324
2325 return S_OK;
2326}
2327
2328STDMETHODIMP Machine::DeleteSettings()
2329{
2330 AutoCaller autoCaller (this);
2331 CheckComRCReturnRC (autoCaller.rc());
2332
2333 AutoLock alock (this);
2334
2335 HRESULT rc = checkStateDependency (MutableStateDep);
2336 CheckComRCReturnRC (rc);
2337
2338 if (mData->mRegistered)
2339 return setError (E_FAIL,
2340 tr ("Cannot delete settings of a registered machine"));
2341
2342 /* delete the settings only when the file actually exists */
2343 if (isConfigLocked())
2344 {
2345 unlockConfig();
2346 int vrc = RTFileDelete (Utf8Str (mData->mConfigFileFull));
2347 if (VBOX_FAILURE (vrc))
2348 return setError (E_FAIL,
2349 tr ("Could not delete the settings file '%ls' (%Vrc)"),
2350 mData->mConfigFileFull.raw(), vrc);
2351
2352 /* delete the Logs folder, nothing important should be left
2353 * there (we don't check for errors because the user might have
2354 * some private files there that we don't want to delete) */
2355 Utf8Str logFolder;
2356 getLogFolder (logFolder);
2357 Assert (!logFolder.isEmpty());
2358 if (RTDirExists (logFolder))
2359 {
2360 /* Delete all VBox.log[.N] files from the Logs folder
2361 * (this must be in sync with the rotation logic in
2362 * Console::powerUpThread()). Also, delete the VBox.png[.N]
2363 * files that may have been created by the GUI. */
2364 Utf8Str log = Utf8StrFmt ("%s/VBox.log", logFolder.raw());
2365 RTFileDelete (log);
2366 log = Utf8StrFmt ("%s/VBox.png", logFolder.raw());
2367 RTFileDelete (log);
2368 for (int i = 3; i >= 0; i--)
2369 {
2370 log = Utf8StrFmt ("%s/VBox.log.%d", logFolder.raw(), i);
2371 RTFileDelete (log);
2372 log = Utf8StrFmt ("%s/VBox.png.%d", logFolder.raw(), i);
2373 RTFileDelete (log);
2374 }
2375
2376 RTDirRemove (logFolder);
2377 }
2378
2379 /* delete the Snapshots folder, nothing important should be left
2380 * there (we don't check for errors because the user might have
2381 * some private files there that we don't want to delete) */
2382 Utf8Str snapshotFolder = mUserData->mSnapshotFolderFull;
2383 Assert (!snapshotFolder.isEmpty());
2384 if (RTDirExists (snapshotFolder))
2385 RTDirRemove (snapshotFolder);
2386
2387 /* delete the directory that contains the settings file, but only
2388 * if it matches the VM name (i.e. a structure created by default in
2389 * prepareSaveSettings()) */
2390 {
2391 Utf8Str settingsDir;
2392 if (isInOwnDir (&settingsDir))
2393 RTDirRemove (settingsDir);
2394 }
2395 }
2396
2397 return S_OK;
2398}
2399
2400STDMETHODIMP Machine::GetSnapshot (INPTR GUIDPARAM aId, ISnapshot **aSnapshot)
2401{
2402 if (!aSnapshot)
2403 return E_POINTER;
2404
2405 AutoCaller autoCaller (this);
2406 CheckComRCReturnRC (autoCaller.rc());
2407
2408 AutoReaderLock alock (this);
2409
2410 Guid id = aId;
2411 ComObjPtr <Snapshot> snapshot;
2412
2413 HRESULT rc = findSnapshot (id, snapshot, true /* aSetError */);
2414 snapshot.queryInterfaceTo (aSnapshot);
2415
2416 return rc;
2417}
2418
2419STDMETHODIMP Machine::FindSnapshot (INPTR BSTR aName, ISnapshot **aSnapshot)
2420{
2421 if (!aName)
2422 return E_INVALIDARG;
2423 if (!aSnapshot)
2424 return E_POINTER;
2425
2426 AutoCaller autoCaller (this);
2427 CheckComRCReturnRC (autoCaller.rc());
2428
2429 AutoReaderLock alock (this);
2430
2431 ComObjPtr <Snapshot> snapshot;
2432
2433 HRESULT rc = findSnapshot (aName, snapshot, true /* aSetError */);
2434 snapshot.queryInterfaceTo (aSnapshot);
2435
2436 return rc;
2437}
2438
2439STDMETHODIMP Machine::SetCurrentSnapshot (INPTR GUIDPARAM aId)
2440{
2441 /// @todo (dmik) don't forget to set
2442 // mData->mCurrentStateModified to FALSE
2443
2444 return setError (E_NOTIMPL, "Not implemented");
2445}
2446
2447STDMETHODIMP
2448Machine::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable)
2449{
2450 if (!aName || !aHostPath)
2451 return E_INVALIDARG;
2452
2453 AutoCaller autoCaller (this);
2454 CheckComRCReturnRC (autoCaller.rc());
2455
2456 AutoLock alock (this);
2457
2458 HRESULT rc = checkStateDependency (MutableStateDep);
2459 CheckComRCReturnRC (rc);
2460
2461 ComObjPtr <SharedFolder> sharedFolder;
2462 rc = findSharedFolder (aName, sharedFolder, false /* aSetError */);
2463 if (SUCCEEDED (rc))
2464 return setError (E_FAIL,
2465 tr ("Shared folder named '%ls' already exists"), aName);
2466
2467 sharedFolder.createObject();
2468 rc = sharedFolder->init (machine(), aName, aHostPath, aWritable);
2469 CheckComRCReturnRC (rc);
2470
2471 BOOL accessible = FALSE;
2472 rc = sharedFolder->COMGETTER(Accessible) (&accessible);
2473 CheckComRCReturnRC (rc);
2474
2475 if (!accessible)
2476 return setError (E_FAIL,
2477 tr ("Shared folder host path '%ls' is not accessible"), aHostPath);
2478
2479 mHWData.backup();
2480 mHWData->mSharedFolders.push_back (sharedFolder);
2481
2482 /* inform the direct session if any */
2483 alock.leave();
2484 onSharedFolderChange();
2485
2486 return S_OK;
2487}
2488
2489STDMETHODIMP Machine::RemoveSharedFolder (INPTR BSTR aName)
2490{
2491 if (!aName)
2492 return E_INVALIDARG;
2493
2494 AutoCaller autoCaller (this);
2495 CheckComRCReturnRC (autoCaller.rc());
2496
2497 AutoReaderLock alock (this);
2498
2499 HRESULT rc = checkStateDependency (MutableStateDep);
2500 CheckComRCReturnRC (rc);
2501
2502 ComObjPtr <SharedFolder> sharedFolder;
2503 rc = findSharedFolder (aName, sharedFolder, true /* aSetError */);
2504 CheckComRCReturnRC (rc);
2505
2506 mHWData.backup();
2507 mHWData->mSharedFolders.remove (sharedFolder);
2508
2509 /* inform the direct session if any */
2510 alock.leave();
2511 onSharedFolderChange();
2512
2513 return S_OK;
2514}
2515
2516STDMETHODIMP Machine::CanShowConsoleWindow (BOOL *aCanShow)
2517{
2518 if (!aCanShow)
2519 return E_POINTER;
2520
2521 /* start with No */
2522 *aCanShow = FALSE;
2523
2524 AutoCaller autoCaller (this);
2525 AssertComRCReturnRC (autoCaller.rc());
2526
2527 ComPtr <IInternalSessionControl> directControl;
2528 {
2529 AutoReaderLock alock (this);
2530
2531 if (mData->mSession.mState != SessionState_Open)
2532 return setError (E_FAIL,
2533 tr ("Machine session is not open (session state: %d)"),
2534 mData->mSession.mState);
2535
2536 directControl = mData->mSession.mDirectControl;
2537 }
2538
2539 /* ignore calls made after #OnSessionEnd() is called */
2540 if (!directControl)
2541 return S_OK;
2542
2543 ULONG64 dummy;
2544 return directControl->OnShowWindow (TRUE /* aCheck */, aCanShow, &dummy);
2545}
2546
2547STDMETHODIMP Machine::ShowConsoleWindow (ULONG64 *aWinId)
2548{
2549 if (!aWinId)
2550 return E_POINTER;
2551
2552 AutoCaller autoCaller (this);
2553 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
2554
2555 ComPtr <IInternalSessionControl> directControl;
2556 {
2557 AutoReaderLock alock (this);
2558
2559 if (mData->mSession.mState != SessionState_Open)
2560 return setError (E_FAIL,
2561 tr ("Machine session is not open (session state: %d)"),
2562 mData->mSession.mState);
2563
2564 directControl = mData->mSession.mDirectControl;
2565 }
2566
2567 /* ignore calls made after #OnSessionEnd() is called */
2568 if (!directControl)
2569 return S_OK;
2570
2571 BOOL dummy;
2572 return directControl->OnShowWindow (FALSE /* aCheck */, &dummy, aWinId);
2573}
2574
2575// public methods for internal purposes
2576/////////////////////////////////////////////////////////////////////////////
2577
2578/**
2579 * Returns the session machine object associated with the this machine.
2580 * The returned session machine is null if no direct session is currently open.
2581 *
2582 * @note locks this object for reading.
2583 */
2584ComObjPtr <SessionMachine> Machine::sessionMachine()
2585{
2586 ComObjPtr <SessionMachine> sm;
2587
2588 AutoLimitedCaller autoCaller (this);
2589 AssertComRCReturn (autoCaller.rc(), sm);
2590
2591 /* return null for inaccessible machines */
2592 if (autoCaller.state() != Ready)
2593 return sm;
2594
2595 AutoReaderLock alock (this);
2596
2597 sm = mData->mSession.mMachine;
2598 Assert (!sm.isNull() ||
2599 mData->mSession.mState != SessionState_Open);
2600
2601 return sm;
2602}
2603
2604/**
2605 * Saves the registry entry of this machine to the given configuration node.
2606 *
2607 * @param aEntryNode Node to save the registry entry to.
2608 *
2609 * @note locks this object for reading.
2610 */
2611HRESULT Machine::saveRegistryEntry (settings::Key &aEntryNode)
2612{
2613 AssertReturn (!aEntryNode.isNull(), E_FAIL);
2614
2615 AutoLimitedCaller autoCaller (this);
2616 AssertComRCReturnRC (autoCaller.rc());
2617
2618 AutoReaderLock alock (this);
2619
2620 /* UUID */
2621 aEntryNode.setValue <Guid> ("uuid", mData->mUuid);
2622 /* settings file name (possibly, relative) */
2623 aEntryNode.setValue <Bstr> ("src", mData->mConfigFile);
2624
2625 return S_OK;
2626}
2627
2628/**
2629 * Calculates the absolute path of the given path taking the directory of
2630 * the machine settings file as the current directory.
2631 *
2632 * @param aPath path to calculate the absolute path for
2633 * @param aResult where to put the result (used only on success,
2634 * so can be the same Utf8Str instance as passed as \a aPath)
2635 * @return VirtualBox result
2636 *
2637 * @note Locks this object for reading.
2638 */
2639int Machine::calculateFullPath (const char *aPath, Utf8Str &aResult)
2640{
2641 AutoCaller autoCaller (this);
2642 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
2643
2644 AutoReaderLock alock (this);
2645
2646 AssertReturn (!mData->mConfigFileFull.isNull(), VERR_GENERAL_FAILURE);
2647
2648 Utf8Str settingsDir = mData->mConfigFileFull;
2649
2650 RTPathStripFilename (settingsDir.mutableRaw());
2651 char folder [RTPATH_MAX];
2652 int vrc = RTPathAbsEx (settingsDir, aPath,
2653 folder, sizeof (folder));
2654 if (VBOX_SUCCESS (vrc))
2655 aResult = folder;
2656
2657 return vrc;
2658}
2659
2660/**
2661 * Tries to calculate the relative path of the given absolute path using the
2662 * directory of the machine settings file as the base directory.
2663 *
2664 * @param aPath absolute path to calculate the relative path for
2665 * @param aResult where to put the result (used only when it's possible to
2666 * make a relative path from the given absolute path;
2667 * otherwise left untouched)
2668 *
2669 * @note Locks this object for reading.
2670 */
2671void Machine::calculateRelativePath (const char *aPath, Utf8Str &aResult)
2672{
2673 AutoCaller autoCaller (this);
2674 AssertComRCReturn (autoCaller.rc(), (void) 0);
2675
2676 AutoReaderLock alock (this);
2677
2678 AssertReturnVoid (!mData->mConfigFileFull.isNull());
2679
2680 Utf8Str settingsDir = mData->mConfigFileFull;
2681
2682 RTPathStripFilename (settingsDir.mutableRaw());
2683 if (RTPathStartsWith (aPath, settingsDir))
2684 {
2685 /* when assigning, we create a separate Utf8Str instance because both
2686 * aPath and aResult can point to the same memory location when this
2687 * func is called (if we just do aResult = aPath, aResult will be freed
2688 * first, and since its the same as aPath, an attempt to copy garbage
2689 * will be made. */
2690 aResult = Utf8Str (aPath + settingsDir.length() + 1);
2691 }
2692}
2693
2694/**
2695 * Returns the full path to the machine's log folder in the
2696 * \a aLogFolder argument.
2697 */
2698void Machine::getLogFolder (Utf8Str &aLogFolder)
2699{
2700 AutoCaller autoCaller (this);
2701 AssertComRCReturnVoid (autoCaller.rc());
2702
2703 AutoReaderLock alock (this);
2704
2705 Utf8Str settingsDir;
2706 if (isInOwnDir (&settingsDir))
2707 {
2708 /* Log folder is <Machines>/<VM_Name>/Logs */
2709 aLogFolder = Utf8StrFmt ("%s%cLogs", settingsDir.raw(), RTPATH_DELIMITER);
2710 }
2711 else
2712 {
2713 /* Log folder is <Machines>/<VM_SnapshotFolder>/Logs */
2714 Assert (!mUserData->mSnapshotFolderFull.isEmpty());
2715 aLogFolder = Utf8StrFmt ("%ls%cLogs", mUserData->mSnapshotFolderFull.raw(),
2716 RTPATH_DELIMITER);
2717 }
2718}
2719
2720/**
2721 * Returns @c true if the given DVD image is attached to this machine either
2722 * in the current state or in any of the snapshots.
2723 *
2724 * @param aId Image ID to check.
2725 * @param aUsage Type of the check.
2726 *
2727 * @note Locks this object + DVD object for reading.
2728 */
2729bool Machine::isDVDImageUsed (const Guid &aId, ResourceUsage_T aUsage)
2730{
2731 AutoLimitedCaller autoCaller (this);
2732 AssertComRCReturn (autoCaller.rc(), false);
2733
2734 /* answer 'not attached' if the VM is limited */
2735 if (autoCaller.state() == Limited)
2736 return false;
2737
2738 AutoReaderLock alock (this);
2739
2740 Machine *m = this;
2741
2742 /* take the session machine when appropriate */
2743 if (!mData->mSession.mMachine.isNull())
2744 m = mData->mSession.mMachine;
2745
2746 /* first, check the current state */
2747 {
2748 const ComObjPtr <DVDDrive> &dvd = m->mDVDDrive;
2749 AssertReturn (!dvd.isNull(), false);
2750
2751 AutoReaderLock dvdLock (dvd);
2752
2753 /* loop over the backed up (permanent) and current (temporary) DVD data */
2754 DVDDrive::Data *d [2];
2755 if (dvd->data().isBackedUp())
2756 {
2757 d [0] = dvd->data().backedUpData();
2758 d [1] = dvd->data().data();
2759 }
2760 else
2761 {
2762 d [0] = dvd->data().data();
2763 d [1] = NULL;
2764 }
2765
2766 if (!(aUsage & ResourceUsage_Permanent))
2767 d [0] = NULL;
2768 if (!(aUsage & ResourceUsage_Temporary))
2769 d [1] = NULL;
2770
2771 for (unsigned i = 0; i < ELEMENTS (d); ++ i)
2772 {
2773 if (d [i] &&
2774 d [i]->mDriveState == DriveState_ImageMounted)
2775 {
2776 Guid id;
2777 HRESULT rc = d [i]->mDVDImage->COMGETTER(Id) (id.asOutParam());
2778 AssertComRC (rc);
2779 if (id == aId)
2780 return true;
2781 }
2782 }
2783 }
2784
2785 /* then, check snapshots if any */
2786 if (aUsage & ResourceUsage_Permanent)
2787 {
2788 if (!mData->mFirstSnapshot.isNull() &&
2789 mData->mFirstSnapshot->isDVDImageUsed (aId))
2790 return true;
2791 }
2792
2793 return false;
2794}
2795
2796/**
2797 * Returns @c true if the given Floppy image is attached to this machine either
2798 * in the current state or in any of the snapshots.
2799 *
2800 * @param aId Image ID to check.
2801 * @param aUsage Type of the check.
2802 *
2803 * @note Locks this object + Floppy object for reading.
2804 */
2805bool Machine::isFloppyImageUsed (const Guid &aId, ResourceUsage_T aUsage)
2806{
2807 AutoCaller autoCaller (this);
2808 AssertComRCReturn (autoCaller.rc(), false);
2809
2810 /* answer 'not attached' if the VM is limited */
2811 if (autoCaller.state() == Limited)
2812 return false;
2813
2814 AutoReaderLock alock (this);
2815
2816 Machine *m = this;
2817
2818 /* take the session machine when appropriate */
2819 if (!mData->mSession.mMachine.isNull())
2820 m = mData->mSession.mMachine;
2821
2822 /* first, check the current state */
2823 {
2824 const ComObjPtr <FloppyDrive> &floppy = m->mFloppyDrive;
2825 AssertReturn (!floppy.isNull(), false);
2826
2827 AutoReaderLock floppyLock (floppy);
2828
2829 /* loop over the backed up (permanent) and current (temporary) Floppy data */
2830 FloppyDrive::Data *d [2];
2831 if (floppy->data().isBackedUp())
2832 {
2833 d [0] = floppy->data().backedUpData();
2834 d [1] = floppy->data().data();
2835 }
2836 else
2837 {
2838 d [0] = floppy->data().data();
2839 d [1] = NULL;
2840 }
2841
2842 if (!(aUsage & ResourceUsage_Permanent))
2843 d [0] = NULL;
2844 if (!(aUsage & ResourceUsage_Temporary))
2845 d [1] = NULL;
2846
2847 for (unsigned i = 0; i < ELEMENTS (d); ++ i)
2848 {
2849 if (d [i] &&
2850 d [i]->mDriveState == DriveState_ImageMounted)
2851 {
2852 Guid id;
2853 HRESULT rc = d [i]->mFloppyImage->COMGETTER(Id) (id.asOutParam());
2854 AssertComRC (rc);
2855 if (id == aId)
2856 return true;
2857 }
2858 }
2859 }
2860
2861 /* then, check snapshots if any */
2862 if (aUsage & ResourceUsage_Permanent)
2863 {
2864 if (!mData->mFirstSnapshot.isNull() &&
2865 mData->mFirstSnapshot->isFloppyImageUsed (aId))
2866 return true;
2867 }
2868
2869 return false;
2870}
2871
2872/**
2873 * @note Locks mParent and this object for writing,
2874 * calls the client process (outside the lock).
2875 */
2876HRESULT Machine::openSession (IInternalSessionControl *aControl)
2877{
2878 LogFlowThisFuncEnter();
2879
2880 AssertReturn (aControl, E_FAIL);
2881
2882 AutoCaller autoCaller (this);
2883 CheckComRCReturnRC (autoCaller.rc());
2884
2885 /* We need VirtualBox lock because of Progress::notifyComplete() */
2886 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
2887
2888 if (!mData->mRegistered)
2889 return setError (E_UNEXPECTED,
2890 tr ("The machine '%ls' is not registered"), mUserData->mName.raw());
2891
2892 LogFlowThisFunc (("mSession.mState=%d\n", mData->mSession.mState));
2893
2894 if (mData->mSession.mState == SessionState_Open ||
2895 mData->mSession.mState == SessionState_Closing)
2896 return setError (E_ACCESSDENIED,
2897 tr ("A session for the machine '%ls' is currently open "
2898 "(or being closed)"),
2899 mUserData->mName.raw());
2900
2901 /* may not be Running */
2902 AssertReturn (mData->mMachineState < MachineState_Running, E_FAIL);
2903
2904 /* get the sesion PID */
2905 RTPROCESS pid = NIL_RTPROCESS;
2906 AssertCompile (sizeof (ULONG) == sizeof (RTPROCESS));
2907 aControl->GetPID ((ULONG *) &pid);
2908 Assert (pid != NIL_RTPROCESS);
2909
2910 if (mData->mSession.mState == SessionState_Spawning)
2911 {
2912 /* This machine is awaiting for a spawning session to be opened, so
2913 * reject any other open attempts from processes other than one
2914 * started by #openRemoteSession(). */
2915
2916 LogFlowThisFunc (("mSession.mPid=%d(0x%x)\n",
2917 mData->mSession.mPid, mData->mSession.mPid));
2918 LogFlowThisFunc (("session.pid=%d(0x%x)\n", pid, pid));
2919
2920 if (mData->mSession.mPid != pid)
2921 return setError (E_ACCESSDENIED,
2922 tr ("An unexpected process (PID=0x%08X) has tried to open a direct "
2923 "session with the machine named '%ls', while only a process "
2924 "started by OpenRemoteSession (PID=0x%08X) is allowed"),
2925 pid, mUserData->mName.raw(), mData->mSession.mPid);
2926 }
2927
2928 /* create a SessionMachine object */
2929 ComObjPtr <SessionMachine> sessionMachine;
2930 sessionMachine.createObject();
2931 HRESULT rc = sessionMachine->init (this);
2932 AssertComRC (rc);
2933
2934 if (SUCCEEDED (rc))
2935 {
2936 /*
2937 * Set the session state to Spawning to protect against subsequent
2938 * attempts to open a session and to unregister the machine after
2939 * we leave the lock.
2940 */
2941 SessionState_T origState = mData->mSession.mState;
2942 mData->mSession.mState = SessionState_Spawning;
2943
2944 /*
2945 * Leave the lock before calling the client process -- it will call
2946 * Machine/SessionMachine methods. Leaving the lock here is quite safe
2947 * because the state is Spawning, so that openRemotesession() and
2948 * openExistingSession() calls will fail. This method, called before we
2949 * enter the lock again, will fail because of the wrong PID.
2950 *
2951 * Note that mData->mSession.mRemoteControls accessed outside
2952 * the lock may not be modified when state is Spawning, so it's safe.
2953 */
2954 alock.leave();
2955
2956 LogFlowThisFunc (("Calling AssignMachine()...\n"));
2957 rc = aControl->AssignMachine (sessionMachine);
2958 LogFlowThisFunc (("AssignMachine() returned %08X\n", rc));
2959
2960 /* The failure may w/o any error info (from RPC), so provide one */
2961 if (FAILED (rc))
2962 setError (rc,
2963 tr ("Failed to assign the machine to the session"));
2964
2965 if (SUCCEEDED (rc) && origState == SessionState_Spawning)
2966 {
2967 /* complete the remote session initialization */
2968
2969 /* get the console from the direct session */
2970 ComPtr <IConsole> console;
2971 rc = aControl->GetRemoteConsole (console.asOutParam());
2972 ComAssertComRC (rc);
2973
2974 if (SUCCEEDED (rc) && !console)
2975 {
2976 ComAssert (!!console);
2977 rc = E_FAIL;
2978 }
2979
2980 /* assign machine & console to the remote sesion */
2981 if (SUCCEEDED (rc))
2982 {
2983 /*
2984 * after openRemoteSession(), the first and the only
2985 * entry in remoteControls is that remote session
2986 */
2987 LogFlowThisFunc (("Calling AssignRemoteMachine()...\n"));
2988 rc = mData->mSession.mRemoteControls.front()->
2989 AssignRemoteMachine (sessionMachine, console);
2990 LogFlowThisFunc (("AssignRemoteMachine() returned %08X\n", rc));
2991
2992 /* The failure may w/o any error info (from RPC), so provide one */
2993 if (FAILED (rc))
2994 setError (rc,
2995 tr ("Failed to assign the machine to the remote session"));
2996 }
2997
2998 if (FAILED (rc))
2999 aControl->Uninitialize();
3000 }
3001
3002 /* enter the lock again */
3003 alock.enter();
3004
3005 /* Restore the session state */
3006 mData->mSession.mState = origState;
3007 }
3008
3009 /* finalize spawning amyway (this is why we don't return on errors above) */
3010 if (mData->mSession.mState == SessionState_Spawning)
3011 {
3012 /* Note that the progress object is finalized later */
3013
3014 /* We don't reset mSession.mPid and mType here because both are
3015 * necessary for SessionMachine::uninit() to reap the child process
3016 * later. */
3017
3018 if (FAILED (rc))
3019 {
3020 /* Remove the remote control from the list on failure
3021 * and reset session state to Closed. */
3022 mData->mSession.mRemoteControls.clear();
3023 mData->mSession.mState = SessionState_Closed;
3024 }
3025 }
3026 else
3027 {
3028 /* memorize PID of the directly opened session */
3029 if (SUCCEEDED (rc))
3030 mData->mSession.mPid = pid;
3031 }
3032
3033 if (SUCCEEDED (rc))
3034 {
3035 /* memorize the direct session control and cache IUnknown for it */
3036 mData->mSession.mDirectControl = aControl;
3037 mData->mSession.mState = SessionState_Open;
3038 /* associate the SessionMachine with this Machine */
3039 mData->mSession.mMachine = sessionMachine;
3040
3041 /* request an IUnknown pointer early from the remote party for later
3042 * identity checks (it will be internally cached within mDirectControl
3043 * at least on XPCOM) */
3044 ComPtr <IUnknown> unk = mData->mSession.mDirectControl;
3045 NOREF (unk);
3046 }
3047
3048 if (mData->mSession.mProgress)
3049 {
3050 /* finalize the progress after setting the state, for consistency */
3051 mData->mSession.mProgress->notifyComplete (rc);
3052 mData->mSession.mProgress.setNull();
3053 }
3054
3055 /* uninitialize the created session machine on failure */
3056 if (FAILED (rc))
3057 sessionMachine->uninit();
3058
3059 LogFlowThisFunc (("rc=%08X\n", rc));
3060 LogFlowThisFuncLeave();
3061 return rc;
3062}
3063
3064/**
3065 * @note Locks this object for writing, calls the client process
3066 * (inside the lock).
3067 */
3068HRESULT Machine::openRemoteSession (IInternalSessionControl *aControl,
3069 INPTR BSTR aType, INPTR BSTR aEnvironment,
3070 Progress *aProgress)
3071{
3072 LogFlowThisFuncEnter();
3073
3074 AssertReturn (aControl, E_FAIL);
3075 AssertReturn (aProgress, E_FAIL);
3076
3077 AutoCaller autoCaller (this);
3078 CheckComRCReturnRC (autoCaller.rc());
3079
3080 AutoLock alock (this);
3081
3082 if (!mData->mRegistered)
3083 return setError (E_UNEXPECTED,
3084 tr ("The machine '%ls' is not registered"), mUserData->mName.raw());
3085
3086 LogFlowThisFunc (("mSession.mState=%d\n", mData->mSession.mState));
3087
3088 if (mData->mSession.mState == SessionState_Open ||
3089 mData->mSession.mState == SessionState_Spawning ||
3090 mData->mSession.mState == SessionState_Closing)
3091 return setError (E_ACCESSDENIED,
3092 tr ("A session for the machine '%ls' is currently open "
3093 "(or being opened or closed)"),
3094 mUserData->mName.raw());
3095
3096 /* may not be Running */
3097 AssertReturn (mData->mMachineState < MachineState_Running, E_FAIL);
3098
3099 /* get the path to the executable */
3100 char path [RTPATH_MAX];
3101 RTPathAppPrivateArch (path, RTPATH_MAX);
3102 size_t sz = strlen (path);
3103 path [sz++] = RTPATH_DELIMITER;
3104 path [sz] = 0;
3105 char *cmd = path + sz;
3106 sz = RTPATH_MAX - sz;
3107
3108 int vrc = VINF_SUCCESS;
3109 RTPROCESS pid = NIL_RTPROCESS;
3110
3111 RTENV env = RTENV_DEFAULT;
3112
3113 if (aEnvironment)
3114 {
3115 char *newEnvStr = NULL;
3116
3117 do
3118 {
3119 /* clone the current environment */
3120 int vrc2 = RTEnvClone (&env, RTENV_DEFAULT);
3121 AssertRCBreak (vrc2, vrc = vrc2);
3122
3123 newEnvStr = RTStrDup(Utf8Str (aEnvironment));
3124 AssertPtrBreak (newEnvStr, vrc = vrc2);
3125
3126 /* put new variables to the environment
3127 * (ignore empty variable names here since RTEnv API
3128 * intentionally doesn't do that) */
3129 char *var = newEnvStr;
3130 for (char *p = newEnvStr; *p; ++ p)
3131 {
3132 if (*p == '\n' && (p == newEnvStr || *(p - 1) != '\\'))
3133 {
3134 *p = '\0';
3135 if (*var)
3136 {
3137 char *val = strchr (var, '=');
3138 if (val)
3139 {
3140 *val++ = '\0';
3141 vrc2 = RTEnvSetEx (env, var, val);
3142 }
3143 else
3144 vrc2 = RTEnvUnsetEx (env, var);
3145 if (VBOX_FAILURE (vrc2))
3146 break;
3147 }
3148 var = p + 1;
3149 }
3150 }
3151 if (VBOX_SUCCESS (vrc2) && *var)
3152 vrc2 = RTEnvPutEx (env, var);
3153
3154 AssertRCBreak (vrc2, vrc = vrc2);
3155 }
3156 while (0);
3157
3158 if (newEnvStr != NULL)
3159 RTStrFree(newEnvStr);
3160 }
3161
3162 Bstr type (aType);
3163 if (type == "gui" || type == "GUI/Qt3")
3164 {
3165#ifdef RT_OS_DARWIN /* Avoid Lanuch Services confusing this with the selector by using a helper app. */
3166 const char VirtualBox_exe[] = "../Resources/VirtualBoxVM.app/Contents/MacOS/VirtualBoxVM";
3167#else
3168 const char VirtualBox_exe[] = "VirtualBox" HOSTSUFF_EXE;
3169#endif
3170 Assert (sz >= sizeof (VirtualBox_exe));
3171 strcpy (cmd, VirtualBox_exe);
3172
3173 Utf8Str idStr = mData->mUuid.toString();
3174#ifdef RT_OS_WINDOWS /** @todo drop this once the RTProcCreate bug has been fixed */
3175 const char * args[] = {path, "-startvm", idStr, 0 };
3176#else
3177 Utf8Str name = mUserData->mName;
3178 const char * args[] = {path, "-comment", name, "-startvm", idStr, 0 };
3179#endif
3180 vrc = RTProcCreate (path, args, env, 0, &pid);
3181 }
3182 else
3183 if (type == "GUI/Qt4")
3184 {
3185#ifdef RT_OS_DARWIN /* Avoid Lanuch Services confusing this with the selector by using a helper app. */
3186 const char VirtualBox_exe[] = "../Resources/VirtualBoxVM.app/Contents/MacOS/VirtualBoxVM4";
3187#else
3188 const char VirtualBox_exe[] = "VirtualBox4" HOSTSUFF_EXE;
3189#endif
3190 Assert (sz >= sizeof (VirtualBox_exe));
3191 strcpy (cmd, VirtualBox_exe);
3192
3193 Utf8Str idStr = mData->mUuid.toString();
3194#ifdef RT_OS_WINDOWS /** @todo drop this once the RTProcCreate bug has been fixed */
3195 const char * args[] = {path, "-startvm", idStr, 0 };
3196#else
3197 Utf8Str name = mUserData->mName;
3198 const char * args[] = {path, "-comment", name, "-startvm", idStr, 0 };
3199#endif
3200 vrc = RTProcCreate (path, args, env, 0, &pid);
3201 }
3202 else
3203#ifdef VBOX_VRDP
3204 if (type == "vrdp")
3205 {
3206 const char VBoxVRDP_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
3207 Assert (sz >= sizeof (VBoxVRDP_exe));
3208 strcpy (cmd, VBoxVRDP_exe);
3209
3210 Utf8Str idStr = mData->mUuid.toString();
3211#ifdef RT_OS_WINDOWS
3212 const char * args[] = {path, "-startvm", idStr, 0 };
3213#else
3214 Utf8Str name = mUserData->mName;
3215 const char * args[] = {path, "-comment", name, "-startvm", idStr, 0 };
3216#endif
3217 vrc = RTProcCreate (path, args, env, 0, &pid);
3218 }
3219 else
3220#endif /* VBOX_VRDP */
3221 if (type == "capture")
3222 {
3223 const char VBoxVRDP_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
3224 Assert (sz >= sizeof (VBoxVRDP_exe));
3225 strcpy (cmd, VBoxVRDP_exe);
3226
3227 Utf8Str idStr = mData->mUuid.toString();
3228#ifdef RT_OS_WINDOWS
3229 const char * args[] = {path, "-startvm", idStr, "-capture", 0 };
3230#else
3231 Utf8Str name = mUserData->mName;
3232 const char * args[] = {path, "-comment", name, "-startvm", idStr, "-capture", 0 };
3233#endif
3234 vrc = RTProcCreate (path, args, env, 0, &pid);
3235 }
3236 else
3237 {
3238 RTEnvDestroy (env);
3239 return setError (E_INVALIDARG,
3240 tr ("Invalid session type: '%ls'"), aType);
3241 }
3242
3243 RTEnvDestroy (env);
3244
3245 if (VBOX_FAILURE (vrc))
3246 return setError (E_FAIL,
3247 tr ("Could not launch a process for the machine '%ls' (%Vrc)"),
3248 mUserData->mName.raw(), vrc);
3249
3250 LogFlowThisFunc (("launched.pid=%d(0x%x)\n", pid, pid));
3251
3252 /*
3253 * Note that we don't leave the lock here before calling the client,
3254 * because it doesn't need to call us back if called with a NULL argument.
3255 * Leaving the lock herer is dangerous because we didn't prepare the
3256 * launch data yet, but the client we've just started may happen to be
3257 * too fast and call openSession() that will fail (because of PID, etc.),
3258 * so that the Machine will never get out of the Spawning session state.
3259 */
3260
3261 /* inform the session that it will be a remote one */
3262 LogFlowThisFunc (("Calling AssignMachine (NULL)...\n"));
3263 HRESULT rc = aControl->AssignMachine (NULL);
3264 LogFlowThisFunc (("AssignMachine (NULL) returned %08X\n", rc));
3265
3266 if (FAILED (rc))
3267 {
3268 /* restore the session state */
3269 mData->mSession.mState = SessionState_Closed;
3270 /* The failure may w/o any error info (from RPC), so provide one */
3271 return setError (rc,
3272 tr ("Failed to assign the machine to the session"));
3273 }
3274
3275 /* attach launch data to the machine */
3276 Assert (mData->mSession.mPid == NIL_RTPROCESS);
3277 mData->mSession.mRemoteControls.push_back (aControl);
3278 mData->mSession.mProgress = aProgress;
3279 mData->mSession.mPid = pid;
3280 mData->mSession.mState = SessionState_Spawning;
3281 mData->mSession.mType = type;
3282
3283 LogFlowThisFuncLeave();
3284 return S_OK;
3285}
3286
3287/**
3288 * @note Locks this object for writing, calls the client process
3289 * (outside the lock).
3290 */
3291HRESULT Machine::openExistingSession (IInternalSessionControl *aControl)
3292{
3293 LogFlowThisFuncEnter();
3294
3295 AssertReturn (aControl, E_FAIL);
3296
3297 AutoCaller autoCaller (this);
3298 CheckComRCReturnRC (autoCaller.rc());
3299
3300 AutoLock alock (this);
3301
3302 if (!mData->mRegistered)
3303 return setError (E_UNEXPECTED,
3304 tr ("The machine '%ls' is not registered"), mUserData->mName.raw());
3305
3306 LogFlowThisFunc (("mSession.state=%d\n", mData->mSession.mState));
3307
3308 if (mData->mSession.mState != SessionState_Open)
3309 return setError (E_ACCESSDENIED,
3310 tr ("The machine '%ls' does not have an open session"),
3311 mUserData->mName.raw());
3312
3313 ComAssertRet (!mData->mSession.mDirectControl.isNull(), E_FAIL);
3314
3315 /*
3316 * Get the console from the direct session (note that we don't leave the
3317 * lock here because GetRemoteConsole must not call us back).
3318 */
3319 ComPtr <IConsole> console;
3320 HRESULT rc = mData->mSession.mDirectControl->
3321 GetRemoteConsole (console.asOutParam());
3322 if (FAILED (rc))
3323 {
3324 /* The failure may w/o any error info (from RPC), so provide one */
3325 return setError (rc,
3326 tr ("Failed to get a console object from the direct session"));
3327 }
3328
3329 ComAssertRet (!console.isNull(), E_FAIL);
3330
3331 ComObjPtr <SessionMachine> sessionMachine = mData->mSession.mMachine;
3332 AssertReturn (!sessionMachine.isNull(), E_FAIL);
3333
3334 /*
3335 * Leave the lock before calling the client process. It's safe here
3336 * since the only thing to do after we get the lock again is to add
3337 * the remote control to the list (which doesn't directly influence
3338 * anything).
3339 */
3340 alock.leave();
3341
3342 /* attach the remote session to the machine */
3343 LogFlowThisFunc (("Calling AssignRemoteMachine()...\n"));
3344 rc = aControl->AssignRemoteMachine (sessionMachine, console);
3345 LogFlowThisFunc (("AssignRemoteMachine() returned %08X\n", rc));
3346
3347 /* The failure may w/o any error info (from RPC), so provide one */
3348 if (FAILED (rc))
3349 return setError (rc,
3350 tr ("Failed to assign the machine to the session"));
3351
3352 alock.enter();
3353
3354 /* need to revalidate the state after entering the lock again */
3355 if (mData->mSession.mState != SessionState_Open)
3356 {
3357 aControl->Uninitialize();
3358
3359 return setError (E_ACCESSDENIED,
3360 tr ("The machine '%ls' does not have an open session"),
3361 mUserData->mName.raw());
3362 }
3363
3364 /* store the control in the list */
3365 mData->mSession.mRemoteControls.push_back (aControl);
3366
3367 LogFlowThisFuncLeave();
3368 return S_OK;
3369}
3370
3371/**
3372 * Checks that the registered flag of the machine can be set according to
3373 * the argument and sets it. On success, commits and saves all settings.
3374 *
3375 * @note When this machine is inaccessible, the only valid value for \a
3376 * aRegistered is FALSE (i.e. unregister the machine) because unregistered
3377 * inaccessible machines are not currently supported. Note that unregistering
3378 * an inaccessible machine will \b uninitialize this machine object. Therefore,
3379 * the caller must make sure there are no active Machine::addCaller() calls
3380 * on the current thread because this will block Machine::uninit().
3381 *
3382 * @note Must be called from mParent's write lock. Locks this object and
3383 * children for writing.
3384 */
3385HRESULT Machine::trySetRegistered (BOOL aRegistered)
3386{
3387 AssertReturn (mParent->isLockedOnCurrentThread(), E_FAIL);
3388
3389 AutoLimitedCaller autoCaller (this);
3390 AssertComRCReturnRC (autoCaller.rc());
3391
3392 AutoLock alock (this);
3393
3394 /* wait for state dependants to drop to zero */
3395 checkStateDependencies (alock);
3396
3397 ComAssertRet (mData->mRegistered != aRegistered, E_FAIL);
3398
3399 if (!mData->mAccessible)
3400 {
3401 /* A special case: the machine is not accessible. */
3402
3403 /* inaccessible machines can only be unregistered */
3404 AssertReturn (!aRegistered, E_FAIL);
3405
3406 /* Uninitialize ourselves here because currently there may be no
3407 * unregistered that are inaccessible (this state combination is not
3408 * supported). Note releasing the caller and leaving the lock before
3409 * calling uninit() */
3410
3411 alock.leave();
3412 autoCaller.release();
3413
3414 uninit();
3415
3416 return S_OK;
3417 }
3418
3419 AssertReturn (autoCaller.state() == Ready, E_FAIL);
3420
3421 if (aRegistered)
3422 {
3423 if (mData->mRegistered)
3424 return setError (E_FAIL,
3425 tr ("The machine '%ls' with UUID {%s} is already registered"),
3426 mUserData->mName.raw(),
3427 mData->mUuid.toString().raw());
3428 }
3429 else
3430 {
3431 if (mData->mMachineState == MachineState_Saved)
3432 return setError (E_FAIL,
3433 tr ("Cannot unregister the machine '%ls' because it "
3434 "is in the Saved state"),
3435 mUserData->mName.raw());
3436
3437 size_t snapshotCount = 0;
3438 if (mData->mFirstSnapshot)
3439 snapshotCount = mData->mFirstSnapshot->descendantCount() + 1;
3440 if (snapshotCount)
3441 return setError (E_FAIL,
3442 tr ("Cannot unregister the machine '%ls' because it "
3443 "has %d snapshots"),
3444 mUserData->mName.raw(), snapshotCount);
3445
3446 if (mData->mSession.mState != SessionState_Closed)
3447 return setError (E_FAIL,
3448 tr ("Cannot unregister the machine '%ls' because it has an "
3449 "open session"),
3450 mUserData->mName.raw());
3451
3452 if (mHDData->mHDAttachments.size() != 0)
3453 return setError (E_FAIL,
3454 tr ("Cannot unregister the machine '%ls' because it "
3455 "has %d hard disks attached"),
3456 mUserData->mName.raw(), mHDData->mHDAttachments.size());
3457 }
3458
3459 /* Ensure the settings are saved. If we are going to be registered and
3460 * isConfigLocked() is FALSE then it means that no config file exists yet,
3461 * so create it. */
3462 if (isModified() || (aRegistered && !isConfigLocked()))
3463 {
3464 HRESULT rc = saveSettings();
3465 CheckComRCReturnRC (rc);
3466 }
3467
3468 mData->mRegistered = aRegistered;
3469
3470 /* inform the USB proxy about all attached/detached USB filters */
3471 mUSBController->onMachineRegistered (aRegistered);
3472
3473 return S_OK;
3474}
3475
3476/**
3477 * Increases the number of objects dependent on the machine state or on the
3478 * registered state. Guarantees that these two states will not change at
3479 * least until #releaseStateDependency() is called.
3480 *
3481 * Depending on the @a aDepType value, additional state checks may be
3482 * made. These checks will set extended error info on failure. See
3483 * #checkStateDependency() for more info.
3484 *
3485 * If this method returns a failure, the dependency is not added and the
3486 * caller is not allowed to rely on any particular machine state or
3487 * registration state value and may return the failed result code to the
3488 * upper level.
3489 *
3490 * @param aDepType Dependency type to add.
3491 * @param aState Current machine state (NULL if not interested).
3492 * @param aRegistered Current registered state (NULL if not interested).
3493 */
3494HRESULT Machine::addStateDependency (StateDependency aDepType /* = AnyStateDep */,
3495 MachineState_T *aState /* = NULL */,
3496 BOOL *aRegistered /* = NULL */)
3497{
3498 AutoCaller autoCaller (this);
3499 AssertComRCReturnRC (autoCaller.rc());
3500
3501 AutoLock alock (this);
3502
3503 if (mData->mWaitingStateDeps && mData->mMachineStateDeps == 0)
3504 {
3505 /* checkStateDependencies() is at the point after RTSemEventWait() but
3506 * before entering the lock. Report an error. It would be better to
3507 * leave the lock now and re-schedule ourselves, but we don't have a
3508 * framework that can guarantee such a behavior in 100% cases. */
3509
3510 AssertFailed(); /* <-- this is just to see how often it can happen */
3511
3512 return setError (E_ACCESSDENIED,
3513 tr ("The machine is busy: state transition is in progress. "
3514 "Retry the operation (state is %d)"),
3515 mData->mMachineState);
3516 }
3517
3518 HRESULT rc = checkStateDependency (aDepType);
3519 CheckComRCReturnRC (rc);
3520
3521 if (aState)
3522 *aState = mData->mMachineState;
3523 if (aRegistered)
3524 *aRegistered = mData->mRegistered;
3525
3526 ++ mData->mMachineStateDeps;
3527
3528 return S_OK;
3529}
3530
3531/**
3532 * Decreases the number of objects dependent on the machine state.
3533 * Must always complete the #addStateDependency() call after the state
3534 * dependency no more necessary.
3535 */
3536void Machine::releaseStateDependency()
3537{
3538 AutoCaller autoCaller (this);
3539 AssertComRCReturnVoid (autoCaller.rc());
3540
3541 AutoLock alock (this);
3542
3543 AssertReturnVoid (mData->mMachineStateDeps > 0);
3544 -- mData->mMachineStateDeps;
3545
3546 if (mData->mMachineStateDeps == 0 &&
3547 mData->mZeroMachineStateDepsSem != NIL_RTSEMEVENT)
3548 {
3549 /* inform checkStateDependencies() that there are no more deps */
3550 RTSemEventSignal (mData->mZeroMachineStateDepsSem);
3551 }
3552}
3553
3554// protected methods
3555/////////////////////////////////////////////////////////////////////////////
3556
3557/**
3558 * Performs machine state checks based on the @a aDepType value. If a check
3559 * fails, this method will set extended error info, otherwise it will return
3560 * S_OK. It is supposed, that on failure, the caller will immedieately return
3561 * the return value of this method to the upper level.
3562 *
3563 * When @a aDepType is AnyStateDep, this method always returns S_OK.
3564 *
3565 * When @a aDepType is MutableStateDep, this method returns S_OK only if the
3566 * current state of this machine object allows to change settings of the
3567 * machine (i.e. the machine is not registered, or registered but not running
3568 * and not saved). It is useful to call this method from Machine setters
3569 * before performing any change.
3570 *
3571 * When @a aDepType is MutableOrSavedStateDep, this method behaves the same
3572 * as for MutableStateDep except that if the machine is saved, S_OK is also
3573 * returned. This is useful in setters which allow changing machine
3574 * properties when it is in the saved state.
3575 *
3576 * @param aDepType Dependency type to check.
3577 *
3578 * @note External classes should use #addStateDependency() and
3579 * #releaseStateDependency() methods or the smart AutoStateDependency
3580 * template.
3581 *
3582 * @note This method must be called from under this object's lock.
3583 */
3584HRESULT Machine::checkStateDependency (StateDependency aDepType)
3585{
3586 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
3587
3588 switch (aDepType)
3589 {
3590 case AnyStateDep:
3591 {
3592 break;
3593 }
3594 case MutableStateDep:
3595 {
3596 if (mData->mRegistered &&
3597 (mType != IsSessionMachine ||
3598 mData->mMachineState > MachineState_Paused ||
3599 mData->mMachineState == MachineState_Saved))
3600 return setError (E_ACCESSDENIED,
3601 tr ("The machine is not mutable (state is %d)"),
3602 mData->mMachineState);
3603 break;
3604 }
3605 case MutableOrSavedStateDep:
3606 {
3607 if (mData->mRegistered &&
3608 (mType != IsSessionMachine ||
3609 mData->mMachineState > MachineState_Paused))
3610 return setError (E_ACCESSDENIED,
3611 tr ("The machine is not mutable (state is %d)"),
3612 mData->mMachineState);
3613 break;
3614 }
3615 }
3616
3617 return S_OK;
3618}
3619
3620/**
3621 * Helper to initialize all associated child objects
3622 * and allocate data structures.
3623 *
3624 * This method must be called as a part of the object's initialization
3625 * procedure (usually done in the #init() method).
3626 *
3627 * @note Must be called only from #init() or from #registeredInit().
3628 */
3629HRESULT Machine::initDataAndChildObjects()
3630{
3631 AutoCaller autoCaller (this);
3632 AssertComRCReturnRC (autoCaller.rc());
3633 AssertComRCReturn (autoCaller.state() == InInit ||
3634 autoCaller.state() == Limited, E_FAIL);
3635
3636 /* allocate data structures */
3637 mSSData.allocate();
3638 mUserData.allocate();
3639 mHWData.allocate();
3640 mHDData.allocate();
3641
3642 /* initialize mOSTypeId */
3643 mUserData->mOSTypeId = mParent->getUnknownOSType()->id();
3644
3645 /* create associated BIOS settings object */
3646 unconst (mBIOSSettings).createObject();
3647 mBIOSSettings->init (this);
3648
3649#ifdef VBOX_VRDP
3650 /* create an associated VRDPServer object (default is disabled) */
3651 unconst (mVRDPServer).createObject();
3652 mVRDPServer->init (this);
3653#endif
3654
3655 /* create an associated DVD drive object */
3656 unconst (mDVDDrive).createObject();
3657 mDVDDrive->init (this);
3658
3659 /* create an associated floppy drive object */
3660 unconst (mFloppyDrive).createObject();
3661 mFloppyDrive->init (this);
3662
3663 /* create associated serial port objects */
3664 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
3665 {
3666 unconst (mSerialPorts [slot]).createObject();
3667 mSerialPorts [slot]->init (this, slot);
3668 }
3669
3670 /* create associated parallel port objects */
3671 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
3672 {
3673 unconst (mParallelPorts [slot]).createObject();
3674 mParallelPorts [slot]->init (this, slot);
3675 }
3676
3677 /* create the audio adapter object (always present, default is disabled) */
3678 unconst (mAudioAdapter).createObject();
3679 mAudioAdapter->init (this);
3680
3681 /* create the USB controller object (always present, default is disabled) */
3682 unconst (mUSBController).createObject();
3683 mUSBController->init (this);
3684
3685 /* create the SATA controller object (always present, default is disabled) */
3686 unconst (mSATAController).createObject();
3687 mSATAController->init (this);
3688
3689 /* create associated network adapter objects */
3690 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
3691 {
3692 unconst (mNetworkAdapters [slot]).createObject();
3693 mNetworkAdapters [slot]->init (this, slot);
3694 }
3695
3696 return S_OK;
3697}
3698
3699/**
3700 * Helper to uninitialize all associated child objects
3701 * and to free all data structures.
3702 *
3703 * This method must be called as a part of the object's uninitialization
3704 * procedure (usually done in the #uninit() method).
3705 *
3706 * @note Must be called only from #uninit() or from #registeredInit().
3707 */
3708void Machine::uninitDataAndChildObjects()
3709{
3710 AutoCaller autoCaller (this);
3711 AssertComRCReturnVoid (autoCaller.rc());
3712 AssertComRCReturnVoid (autoCaller.state() == InUninit ||
3713 autoCaller.state() == Limited);
3714
3715 /* uninit all children using addDependentChild()/removeDependentChild()
3716 * in their init()/uninit() methods */
3717 uninitDependentChildren();
3718
3719 /* tell all our other child objects we've been uninitialized */
3720
3721 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
3722 {
3723 if (mNetworkAdapters [slot])
3724 {
3725 mNetworkAdapters [slot]->uninit();
3726 unconst (mNetworkAdapters [slot]).setNull();
3727 }
3728 }
3729
3730 if (mUSBController)
3731 {
3732 mUSBController->uninit();
3733 unconst (mUSBController).setNull();
3734 }
3735
3736 if (mSATAController)
3737 {
3738 mSATAController->uninit();
3739 unconst (mSATAController).setNull();
3740 }
3741
3742 if (mAudioAdapter)
3743 {
3744 mAudioAdapter->uninit();
3745 unconst (mAudioAdapter).setNull();
3746 }
3747
3748 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
3749 {
3750 if (mParallelPorts [slot])
3751 {
3752 mParallelPorts [slot]->uninit();
3753 unconst (mParallelPorts [slot]).setNull();
3754 }
3755 }
3756
3757 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
3758 {
3759 if (mSerialPorts [slot])
3760 {
3761 mSerialPorts [slot]->uninit();
3762 unconst (mSerialPorts [slot]).setNull();
3763 }
3764 }
3765
3766 if (mFloppyDrive)
3767 {
3768 mFloppyDrive->uninit();
3769 unconst (mFloppyDrive).setNull();
3770 }
3771
3772 if (mDVDDrive)
3773 {
3774 mDVDDrive->uninit();
3775 unconst (mDVDDrive).setNull();
3776 }
3777
3778#ifdef VBOX_VRDP
3779 if (mVRDPServer)
3780 {
3781 mVRDPServer->uninit();
3782 unconst (mVRDPServer).setNull();
3783 }
3784#endif
3785
3786 if (mBIOSSettings)
3787 {
3788 mBIOSSettings->uninit();
3789 unconst (mBIOSSettings).setNull();
3790 }
3791
3792 /* Deassociate hard disks (only when a real Machine or a SnapshotMachine
3793 * instance is uninitialized; SessionMachine instances refer to real
3794 * Machine hard disks). This is necessary for a clean re-initialization of
3795 * the VM after successfully re-checking the accessibility state. Note
3796 * that in case of normal Machine or SnapshotMachine uninitialization (as
3797 * a result of unregistering or discarding the snapshot), outdated hard
3798 * disk attachments will already be uninitialized and deleted, so this
3799 * code will not affect them. */
3800 if (!!mHDData && (mType == IsMachine || mType == IsSnapshotMachine))
3801 {
3802 for (HDData::HDAttachmentList::const_iterator it =
3803 mHDData->mHDAttachments.begin();
3804 it != mHDData->mHDAttachments.end();
3805 ++ it)
3806 {
3807 (*it)->hardDisk()->setMachineId (Guid());
3808 }
3809 }
3810
3811 if (mType == IsMachine)
3812 {
3813 /* reset some important fields of mData */
3814 mData->mCurrentSnapshot.setNull();
3815 mData->mFirstSnapshot.setNull();
3816 }
3817
3818 /* free data structures (the essential mData structure is not freed here
3819 * since it may be still in use) */
3820 mHDData.free();
3821 mHWData.free();
3822 mUserData.free();
3823 mSSData.free();
3824}
3825
3826
3827/**
3828 * Chhecks that there are no state dependants. If necessary, waits for the
3829 * number of dependants to drop to zero. Must be called from under
3830 * this object's lock.
3831 *
3832 * @param aLock This object's lock.
3833 *
3834 * @note This method may leave the object lock during its execution!
3835 */
3836void Machine::checkStateDependencies (AutoLock &aLock)
3837{
3838 AssertReturnVoid (isLockedOnCurrentThread());
3839 AssertReturnVoid (aLock.belongsTo (this));
3840
3841 /* Wait for all state dependants if necessary */
3842 if (mData->mMachineStateDeps > 0)
3843 {
3844 /* lazy creation */
3845 if (mData->mZeroMachineStateDepsSem == NIL_RTSEMEVENT)
3846 RTSemEventCreate (&mData->mZeroMachineStateDepsSem);
3847
3848 LogFlowThisFunc (("Waiting for state deps (%d) to drop to zero...\n",
3849 mData->mMachineStateDeps));
3850
3851 mData->mWaitingStateDeps = TRUE;
3852
3853 aLock.leave();
3854
3855 RTSemEventWait (mData->mZeroMachineStateDepsSem, RT_INDEFINITE_WAIT);
3856
3857 aLock.enter();
3858
3859 mData->mWaitingStateDeps = FALSE;
3860 }
3861}
3862
3863/**
3864 * Helper to change the machine state.
3865 *
3866 * @note Locks this object for writing.
3867 */
3868HRESULT Machine::setMachineState (MachineState_T aMachineState)
3869{
3870 LogFlowThisFuncEnter();
3871 LogFlowThisFunc (("aMachineState=%d\n", aMachineState));
3872
3873 AutoCaller autoCaller (this);
3874 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
3875
3876 AutoLock alock (this);
3877
3878 /* wait for state dependants to drop to zero */
3879 /// @todo it may be potentially unsafe to leave the lock here as
3880 // the below method does. Needs some thinking. The easiest solution may
3881 // be to provide a separate mutex for mMachineState and mRegistered.
3882 checkStateDependencies (alock);
3883
3884 if (mData->mMachineState != aMachineState)
3885 {
3886 mData->mMachineState = aMachineState;
3887
3888 RTTimeNow (&mData->mLastStateChange);
3889
3890 mParent->onMachineStateChange (mData->mUuid, aMachineState);
3891 }
3892
3893 LogFlowThisFuncLeave();
3894 return S_OK;
3895}
3896
3897/**
3898 * Searches for a shared folder with the given logical name
3899 * in the collection of shared folders.
3900 *
3901 * @param aName logical name of the shared folder
3902 * @param aSharedFolder where to return the found object
3903 * @param aSetError whether to set the error info if the folder is
3904 * not found
3905 * @return
3906 * S_OK when found or E_INVALIDARG when not found
3907 *
3908 * @note
3909 * must be called from under the object's lock!
3910 */
3911HRESULT Machine::findSharedFolder (const BSTR aName,
3912 ComObjPtr <SharedFolder> &aSharedFolder,
3913 bool aSetError /* = false */)
3914{
3915 bool found = false;
3916 for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
3917 !found && it != mHWData->mSharedFolders.end();
3918 ++ it)
3919 {
3920 AutoLock alock (*it);
3921 found = (*it)->name() == aName;
3922 if (found)
3923 aSharedFolder = *it;
3924 }
3925
3926 HRESULT rc = found ? S_OK : E_INVALIDARG;
3927
3928 if (aSetError && !found)
3929 setError (rc, tr ("Could not find a shared folder named '%ls'"), aName);
3930
3931 return rc;
3932}
3933
3934/**
3935 * Loads all the VM settings by walking down the <Machine> node.
3936 *
3937 * @param aRegistered true when the machine is being loaded on VirtualBox
3938 * startup
3939 *
3940 * @note This method is intended to be called only from init(), so it assumes
3941 * all machine data fields have appropriate default values when it is called.
3942 *
3943 * @note Doesn't lock any objects.
3944 */
3945HRESULT Machine::loadSettings (bool aRegistered)
3946{
3947 LogFlowThisFuncEnter();
3948 AssertReturn (mType == IsMachine, E_FAIL);
3949
3950 AutoCaller autoCaller (this);
3951 AssertReturn (autoCaller.state() == InInit, E_FAIL);
3952
3953 HRESULT rc = S_OK;
3954
3955 try
3956 {
3957 using namespace settings;
3958
3959 File file (File::Read, mData->mHandleCfgFile,
3960 Utf8Str (mData->mConfigFileFull));
3961 XmlTreeBackend tree;
3962
3963 rc = VirtualBox::loadSettingsTree_FirstTime (tree, file,
3964 mData->mSettingsFileVersion);
3965 CheckComRCThrowRC (rc);
3966
3967 Key machineNode = tree.rootKey().key ("Machine");
3968
3969 /* uuid (required) */
3970 Guid id = machineNode.value <Guid> ("uuid");
3971
3972 /* If the stored UUID is not empty, it means the registered machine
3973 * is being loaded. Compare the loaded UUID with the stored one taken
3974 * from the global registry. */
3975 if (!mData->mUuid.isEmpty())
3976 {
3977 if (mData->mUuid != id)
3978 {
3979 throw setError (E_FAIL,
3980 tr ("Machine UUID {%Vuuid} in '%ls' doesn't match its "
3981 "UUID {%s} in the registry file '%ls'"),
3982 id.raw(), mData->mConfigFileFull.raw(),
3983 mData->mUuid.toString().raw(),
3984 mParent->settingsFileName().raw());
3985 }
3986 }
3987 else
3988 unconst (mData->mUuid) = id;
3989
3990 /* name (required) */
3991 mUserData->mName = machineNode.stringValue ("name");
3992
3993 /* nameSync (optional, default is true) */
3994 mUserData->mNameSync = machineNode.value <bool> ("nameSync");
3995
3996 /* Description (optional, default is null) */
3997 {
3998 Key descNode = machineNode.findKey ("Description");
3999 if (!descNode.isNull())
4000 mUserData->mDescription = descNode.keyStringValue();
4001 else
4002 mUserData->mDescription.setNull();
4003 }
4004
4005 /* OSType (required) */
4006 {
4007 mUserData->mOSTypeId = machineNode.stringValue ("OSType");
4008
4009 /* look up the object by Id to check it is valid */
4010 ComPtr <IGuestOSType> guestOSType;
4011 rc = mParent->GetGuestOSType (mUserData->mOSTypeId,
4012 guestOSType.asOutParam());
4013 CheckComRCThrowRC (rc);
4014 }
4015
4016 /* stateFile (optional) */
4017 {
4018 Bstr stateFilePath = machineNode.stringValue ("stateFile");
4019 if (stateFilePath)
4020 {
4021 Utf8Str stateFilePathFull = stateFilePath;
4022 int vrc = calculateFullPath (stateFilePathFull, stateFilePathFull);
4023 if (VBOX_FAILURE (vrc))
4024 {
4025 throw setError (E_FAIL,
4026 tr ("Invalid saved state file path: '%ls' (%Vrc)"),
4027 stateFilePath.raw(), vrc);
4028 }
4029 mSSData->mStateFilePath = stateFilePathFull;
4030 }
4031 else
4032 mSSData->mStateFilePath.setNull();
4033 }
4034
4035 /*
4036 * currentSnapshot ID (optional)
4037 *
4038 * Note that due to XML Schema constaraints, this attribute, when
4039 * present, will guaranteedly refer to an existing snapshot
4040 * definition in XML
4041 */
4042 Guid currentSnapshotId = machineNode.valueOr <Guid> ("currentSnapshot",
4043 Guid());
4044
4045 /* snapshotFolder (optional) */
4046 {
4047 Bstr folder = machineNode.stringValue ("snapshotFolder");
4048 rc = COMSETTER(SnapshotFolder) (folder);
4049 CheckComRCThrowRC (rc);
4050 }
4051
4052 /* currentStateModified (optional, default is true) */
4053 mData->mCurrentStateModified = machineNode.value <bool> ("currentStateModified");
4054
4055 /* lastStateChange (optional, defaults to now) */
4056 {
4057 RTTIMESPEC now;
4058 RTTimeNow (&now);
4059 mData->mLastStateChange =
4060 machineNode.valueOr <RTTIMESPEC> ("lastStateChange", now);
4061 }
4062
4063 /* aborted (optional, default is false) */
4064 bool aborted = machineNode.value <bool> ("aborted");
4065
4066 /*
4067 * note: all mUserData members must be assigned prior this point because
4068 * we need to commit changes in order to let mUserData be shared by all
4069 * snapshot machine instances.
4070 */
4071 mUserData.commitCopy();
4072
4073 /* Snapshot node (optional) */
4074 {
4075 Key snapshotNode = machineNode.findKey ("Snapshot");
4076 if (!snapshotNode.isNull())
4077 {
4078 /* read all snapshots recursively */
4079 rc = loadSnapshot (snapshotNode, currentSnapshotId, NULL);
4080 CheckComRCThrowRC (rc);
4081 }
4082 }
4083
4084 /* Hardware node (required) */
4085 rc = loadHardware (machineNode.key ("Hardware"));
4086 CheckComRCThrowRC (rc);
4087
4088 /* HardDiskAttachments node (required) */
4089 rc = loadHardDisks (machineNode.key ("HardDiskAttachments"), aRegistered);
4090 CheckComRCThrowRC (rc);
4091
4092 /*
4093 * NOTE: the assignment below must be the last thing to do,
4094 * otherwise it will be not possible to change the settings
4095 * somewehere in the code above because all setters will be
4096 * blocked by checkStateDependency (MutableStateDep).
4097 */
4098
4099 /* set the machine state to Aborted or Saved when appropriate */
4100 if (aborted)
4101 {
4102 Assert (!mSSData->mStateFilePath);
4103 mSSData->mStateFilePath.setNull();
4104
4105 /* no need to use setMachineState() during init() */
4106 mData->mMachineState = MachineState_Aborted;
4107 }
4108 else if (mSSData->mStateFilePath)
4109 {
4110 /* no need to use setMachineState() during init() */
4111 mData->mMachineState = MachineState_Saved;
4112 }
4113 }
4114 catch (HRESULT err)
4115 {
4116 /* we assume that error info is set by the thrower */
4117 rc = err;
4118 }
4119 catch (...)
4120 {
4121 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
4122 }
4123
4124 LogFlowThisFuncLeave();
4125 return rc;
4126}
4127
4128/**
4129 * Recursively loads all snapshots starting from the given.
4130 *
4131 * @param aNode <Snapshot> node.
4132 * @param aCurSnapshotId Current snapshot ID from the settings file.
4133 * @param aParentSnapshot Parent snapshot.
4134 */
4135HRESULT Machine::loadSnapshot (const settings::Key &aNode,
4136 const Guid &aCurSnapshotId,
4137 Snapshot *aParentSnapshot)
4138{
4139 using namespace settings;
4140
4141 AssertReturn (!aNode.isNull(), E_INVALIDARG);
4142 AssertReturn (mType == IsMachine, E_FAIL);
4143
4144 /* create a snapshot machine object */
4145 ComObjPtr <SnapshotMachine> snapshotMachine;
4146 snapshotMachine.createObject();
4147
4148 HRESULT rc = S_OK;
4149
4150 /* required */
4151 Guid uuid = aNode.value <Guid> ("uuid");
4152
4153 {
4154 /* optional */
4155 Bstr stateFilePath = aNode.stringValue ("stateFile");
4156 if (stateFilePath)
4157 {
4158 Utf8Str stateFilePathFull = stateFilePath;
4159 int vrc = calculateFullPath (stateFilePathFull, stateFilePathFull);
4160 if (VBOX_FAILURE (vrc))
4161 return setError (E_FAIL,
4162 tr ("Invalid saved state file path: '%ls' (%Vrc)"),
4163 stateFilePath.raw(), vrc);
4164
4165 stateFilePath = stateFilePathFull;
4166 }
4167
4168 /* Hardware node (required) */
4169 Key hardwareNode = aNode.key ("Hardware");
4170
4171 /* HardDiskAttachments node (required) */
4172 Key hdasNode = aNode.key ("HardDiskAttachments");
4173
4174 /* initialize the snapshot machine */
4175 rc = snapshotMachine->init (this, hardwareNode, hdasNode,
4176 uuid, stateFilePath);
4177 CheckComRCReturnRC (rc);
4178 }
4179
4180 /* create a snapshot object */
4181 ComObjPtr <Snapshot> snapshot;
4182 snapshot.createObject();
4183
4184 {
4185 /* required */
4186 Bstr name = aNode.stringValue ("name");
4187
4188 /* required */
4189 RTTIMESPEC timeStamp = aNode.value <RTTIMESPEC> ("timeStamp");
4190
4191 /* optional */
4192 Bstr description;
4193 {
4194 Key descNode = aNode.findKey ("Description");
4195 if (!descNode.isNull())
4196 description = descNode.keyStringValue();
4197 }
4198
4199 /* initialize the snapshot */
4200 rc = snapshot->init (uuid, name, description, timeStamp,
4201 snapshotMachine, aParentSnapshot);
4202 CheckComRCReturnRC (rc);
4203 }
4204
4205 /* memorize the first snapshot if necessary */
4206 if (!mData->mFirstSnapshot)
4207 mData->mFirstSnapshot = snapshot;
4208
4209 /* memorize the current snapshot when appropriate */
4210 if (!mData->mCurrentSnapshot && snapshot->data().mId == aCurSnapshotId)
4211 mData->mCurrentSnapshot = snapshot;
4212
4213 /* Snapshots node (optional) */
4214 {
4215 Key snapshotsNode = aNode.findKey ("Snapshots");
4216 if (!snapshotsNode.isNull())
4217 {
4218 Key::List children = snapshotsNode.keys ("Snapshot");
4219 for (Key::List::const_iterator it = children.begin();
4220 it != children.end(); ++ it)
4221 {
4222 rc = loadSnapshot ((*it), aCurSnapshotId, snapshot);
4223 CheckComRCBreakRC (rc);
4224 }
4225 }
4226 }
4227
4228 return rc;
4229}
4230
4231/**
4232 * @param aNode <Hardware> node.
4233 */
4234HRESULT Machine::loadHardware (const settings::Key &aNode)
4235{
4236 using namespace settings;
4237
4238 AssertReturn (!aNode.isNull(), E_INVALIDARG);
4239 AssertReturn (mType == IsMachine || mType == IsSnapshotMachine, E_FAIL);
4240
4241 HRESULT rc = S_OK;
4242
4243 /* CPU node (currently not required) */
4244 {
4245 /* default value in case the node is not there */
4246 mHWData->mHWVirtExEnabled = TSBool_Default;
4247
4248 Key cpuNode = aNode.findKey ("CPU");
4249 if (!cpuNode.isNull())
4250 {
4251 Key hwVirtExNode = cpuNode.key ("HardwareVirtEx");
4252 if (!hwVirtExNode.isNull())
4253 {
4254 const char *enabled = hwVirtExNode.stringValue ("enabled");
4255 if (strcmp (enabled, "false") == 0)
4256 mHWData->mHWVirtExEnabled = TSBool_False;
4257 else if (strcmp (enabled, "true") == 0)
4258 mHWData->mHWVirtExEnabled = TSBool_True;
4259 else
4260 mHWData->mHWVirtExEnabled = TSBool_Default;
4261 }
4262 }
4263 }
4264
4265 /* Memory node (required) */
4266 {
4267 Key memoryNode = aNode.key ("Memory");
4268
4269 mHWData->mMemorySize = memoryNode.value <ULONG> ("RAMSize");
4270 }
4271
4272 /* Boot node (required) */
4273 {
4274 /* reset all boot order positions to NoDevice */
4275 for (size_t i = 0; i < ELEMENTS (mHWData->mBootOrder); i++)
4276 mHWData->mBootOrder [i] = DeviceType_Null;
4277
4278 Key bootNode = aNode.key ("Boot");
4279
4280 Key::List orderNodes = bootNode.keys ("Order");
4281 for (Key::List::const_iterator it = orderNodes.begin();
4282 it != orderNodes.end(); ++ it)
4283 {
4284 /* position (required) */
4285 /* position unicity is guaranteed by XML Schema */
4286 uint32_t position = (*it).value <uint32_t> ("position");
4287 -- position;
4288 Assert (position < ELEMENTS (mHWData->mBootOrder));
4289
4290 /* device (required) */
4291 const char *device = (*it).stringValue ("device");
4292 if (strcmp (device, "None") == 0)
4293 mHWData->mBootOrder [position] = DeviceType_Null;
4294 else if (strcmp (device, "Floppy") == 0)
4295 mHWData->mBootOrder [position] = DeviceType_Floppy;
4296 else if (strcmp (device, "DVD") == 0)
4297 mHWData->mBootOrder [position] = DeviceType_DVD;
4298 else if (strcmp (device, "HardDisk") == 0)
4299 mHWData->mBootOrder [position] = DeviceType_HardDisk;
4300 else if (strcmp (device, "Network") == 0)
4301 mHWData->mBootOrder [position] = DeviceType_Network;
4302 else
4303 ComAssertMsgFailed (("Invalid device: %s\n", device));
4304 }
4305 }
4306
4307 /* Display node (required) */
4308 {
4309 Key displayNode = aNode.key ("Display");
4310
4311 mHWData->mVRAMSize = displayNode.value <ULONG> ("VRAMSize");
4312 mHWData->mMonitorCount = displayNode.value <ULONG> ("MonitorCount");
4313 }
4314
4315#ifdef VBOX_VRDP
4316 /* RemoteDisplay */
4317 rc = mVRDPServer->loadSettings (aNode);
4318 CheckComRCReturnRC (rc);
4319#endif
4320
4321 /* BIOS */
4322 rc = mBIOSSettings->loadSettings (aNode);
4323 CheckComRCReturnRC (rc);
4324
4325 /* DVD drive */
4326 rc = mDVDDrive->loadSettings (aNode);
4327 CheckComRCReturnRC (rc);
4328
4329 /* Floppy drive */
4330 rc = mFloppyDrive->loadSettings (aNode);
4331 CheckComRCReturnRC (rc);
4332
4333 /* USB Controller */
4334 rc = mUSBController->loadSettings (aNode);
4335 CheckComRCReturnRC (rc);
4336
4337 /* SATA Controller */
4338 rc = mSATAController->loadSettings (aNode);
4339 CheckComRCReturnRC (rc);
4340
4341 /* Network node (required) */
4342 {
4343 /* we assume that all network adapters are initially disabled
4344 * and detached */
4345
4346 Key networkNode = aNode.key ("Network");
4347
4348 rc = S_OK;
4349
4350 Key::List adapters = networkNode.keys ("Adapter");
4351 for (Key::List::const_iterator it = adapters.begin();
4352 it != adapters.end(); ++ it)
4353 {
4354 /* slot number (required) */
4355 /* slot unicity is guaranteed by XML Schema */
4356 uint32_t slot = (*it).value <uint32_t> ("slot");
4357 AssertBreakVoid (slot < ELEMENTS (mNetworkAdapters));
4358
4359 rc = mNetworkAdapters [slot]->loadSettings (*it);
4360 CheckComRCReturnRC (rc);
4361 }
4362 }
4363
4364 /* Serial node (required) */
4365 {
4366 Key serialNode = aNode.key ("UART");
4367
4368 rc = S_OK;
4369
4370 Key::List ports = serialNode.keys ("Port");
4371 for (Key::List::const_iterator it = ports.begin();
4372 it != ports.end(); ++ it)
4373 {
4374 /* slot number (required) */
4375 /* slot unicity is guaranteed by XML Schema */
4376 uint32_t slot = (*it).value <uint32_t> ("slot");
4377 AssertBreakVoid (slot < ELEMENTS (mSerialPorts));
4378
4379 rc = mSerialPorts [slot]->loadSettings (*it);
4380 CheckComRCReturnRC (rc);
4381 }
4382 }
4383
4384 /* Parallel node (optional) */
4385 {
4386 Key parallelNode = aNode.key ("LPT");
4387
4388 rc = S_OK;
4389
4390 Key::List ports = parallelNode.keys ("Port");
4391 for (Key::List::const_iterator it = ports.begin();
4392 it != ports.end(); ++ it)
4393 {
4394 /* slot number (required) */
4395 /* slot unicity is guaranteed by XML Schema */
4396 uint32_t slot = (*it).value <uint32_t> ("slot");
4397 AssertBreakVoid (slot < ELEMENTS (mSerialPorts));
4398
4399 rc = mParallelPorts [slot]->loadSettings (*it);
4400 CheckComRCReturnRC (rc);
4401 }
4402 }
4403
4404 /* AudioAdapter */
4405 rc = mAudioAdapter->loadSettings (aNode);
4406 CheckComRCReturnRC (rc);
4407
4408 /* Shared folders (required) */
4409 {
4410 Key sharedFoldersNode = aNode.key ("SharedFolders");
4411
4412 rc = S_OK;
4413
4414 Key::List folders = sharedFoldersNode.keys ("SharedFolder");
4415 for (Key::List::const_iterator it = folders.begin();
4416 it != folders.end(); ++ it)
4417 {
4418 /* folder logical name (required) */
4419 Bstr name = (*it).stringValue ("name");
4420 /* folder host path (required) */
4421 Bstr hostPath = (*it).stringValue ("hostPath");
4422
4423 bool writable = (*it).value <bool> ("writable");
4424
4425 rc = CreateSharedFolder (name, hostPath, writable);
4426 CheckComRCReturnRC (rc);
4427 }
4428 }
4429
4430 /* Clipboard node (required) */
4431 {
4432 Key clipNode = aNode.key ("Clipboard");
4433
4434 const char *mode = clipNode.stringValue ("mode");
4435 if (strcmp (mode, "Disabled") == 0)
4436 mHWData->mClipboardMode = ClipboardMode_Disabled;
4437 else if (strcmp (mode, "HostToGuest") == 0)
4438 mHWData->mClipboardMode = ClipboardMode_HostToGuest;
4439 else if (strcmp (mode, "GuestToHost") == 0)
4440 mHWData->mClipboardMode = ClipboardMode_GuestToHost;
4441 else if (strcmp (mode, "Bidirectional") == 0)
4442 mHWData->mClipboardMode = ClipboardMode_Bidirectional;
4443 else
4444 AssertMsgFailed (("Invalid clipboard mode '%s'\n", mode));
4445 }
4446
4447 /* Guest node (required) */
4448 {
4449 Key guestNode = aNode.key ("Guest");
4450
4451 /* optional, defaults to 0 */
4452 mHWData->mMemoryBalloonSize =
4453 guestNode.value <ULONG> ("memoryBalloonSize");
4454 /* optional, defaults to 0 */
4455 mHWData->mStatisticsUpdateInterval =
4456 guestNode.value <ULONG> ("statisticsUpdateInterval");
4457 }
4458
4459 AssertComRC (rc);
4460 return rc;
4461}
4462
4463/**
4464 * @param aNode <HardDiskAttachments> node.
4465 * @param aRegistered true when the machine is being loaded on VirtualBox
4466 * startup, or when a snapshot is being loaded (wchich
4467 * currently can happen on startup only)
4468 * @param aSnapshotId pointer to the snapshot ID if this is a snapshot machine
4469 */
4470HRESULT Machine::loadHardDisks (const settings::Key &aNode, bool aRegistered,
4471 const Guid *aSnapshotId /* = NULL */)
4472{
4473 using namespace settings;
4474
4475 AssertReturn (!aNode.isNull(), E_INVALIDARG);
4476 AssertReturn ((mType == IsMachine && aSnapshotId == NULL) ||
4477 (mType == IsSnapshotMachine && aSnapshotId != NULL), E_FAIL);
4478
4479 HRESULT rc = S_OK;
4480
4481 Key::List children = aNode.keys ("HardDiskAttachment");
4482
4483 if (!aRegistered && children.size() > 0)
4484 {
4485 /* when the machine is being loaded (opened) from a file, it cannot
4486 * have hard disks attached (this should not happen normally,
4487 * because we don't allow to attach hard disks to an unregistered
4488 * VM at all */
4489 return setError (E_FAIL,
4490 tr ("Unregistered machine '%ls' cannot have hard disks attached "
4491 "(found %d hard disk attachments)"),
4492 mUserData->mName.raw(), children.size());
4493 }
4494
4495
4496 for (Key::List::const_iterator it = children.begin();
4497 it != children.end(); ++ it)
4498 {
4499 /* hardDisk uuid (required) */
4500 Guid uuid = (*it).value <Guid> ("hardDisk");
4501 /* bus (controller) type (required) */
4502 const char *busStr = (*it).stringValue ("bus");
4503 /* channel (required) */
4504 LONG channel = (*it).value <LONG> ("channel");
4505 /* device (required) */
4506 LONG device = (*it).value <LONG> ("device");
4507
4508 /* find a hard disk by UUID */
4509 ComObjPtr <HardDisk> hd;
4510 rc = mParent->getHardDisk (uuid, hd);
4511 CheckComRCReturnRC (rc);
4512
4513 AutoLock hdLock (hd);
4514
4515 if (!hd->machineId().isEmpty())
4516 {
4517 return setError (E_FAIL,
4518 tr ("Hard disk '%ls' with UUID {%s} is already "
4519 "attached to a machine with UUID {%s} (see '%ls')"),
4520 hd->toString().raw(), uuid.toString().raw(),
4521 hd->machineId().toString().raw(),
4522 mData->mConfigFileFull.raw());
4523 }
4524
4525 if (hd->type() == HardDiskType_Immutable)
4526 {
4527 return setError (E_FAIL,
4528 tr ("Immutable hard disk '%ls' with UUID {%s} cannot be "
4529 "directly attached to a machine (see '%ls')"),
4530 hd->toString().raw(), uuid.toString().raw(),
4531 mData->mConfigFileFull.raw());
4532 }
4533
4534 /* attach the device */
4535 StorageBus_T bus = StorageBus_Null;
4536
4537 if (strcmp (busStr, "IDE") == 0)
4538 {
4539 bus = StorageBus_IDE;
4540 }
4541 else if (strcmp (busStr, "SATA") == 0)
4542 {
4543 bus = StorageBus_SATA;
4544 }
4545 else
4546 ComAssertMsgFailedRet (("Invalid bus '%s'\n", bus),
4547 E_FAIL);
4548
4549 ComObjPtr <HardDiskAttachment> attachment;
4550 attachment.createObject();
4551 rc = attachment->init (hd, bus, channel, device, false /* aDirty */);
4552 CheckComRCBreakRC (rc);
4553
4554 /* associate the hard disk with this machine */
4555 hd->setMachineId (mData->mUuid);
4556
4557 /* associate the hard disk with the given snapshot ID */
4558 if (mType == IsSnapshotMachine)
4559 hd->setSnapshotId (*aSnapshotId);
4560
4561 mHDData->mHDAttachments.push_back (attachment);
4562 }
4563
4564 return rc;
4565}
4566
4567/**
4568 * Searches for a <Snapshot> node for the given snapshot.
4569 * If the search is successful, \a aSnapshotNode will contain the found node.
4570 * In this case, \a aSnapshotsNode can be NULL meaning the found node is a
4571 * direct child of \a aMachineNode.
4572 *
4573 * If the search fails, a failure is returned and both \a aSnapshotsNode and
4574 * \a aSnapshotNode are set to 0.
4575 *
4576 * @param aSnapshot Snapshot to search for.
4577 * @param aMachineNode <Machine> node to start from.
4578 * @param aSnapshotsNode <Snapshots> node containing the found <Snapshot> node
4579 * (may be NULL if the caller is not interested).
4580 * @param aSnapshotNode Found <Snapshot> node.
4581 */
4582HRESULT Machine::findSnapshotNode (Snapshot *aSnapshot, settings::Key &aMachineNode,
4583 settings::Key *aSnapshotsNode,
4584 settings::Key *aSnapshotNode)
4585{
4586 using namespace settings;
4587
4588 AssertReturn (aSnapshot && !aMachineNode.isNull()
4589 && aSnapshotNode != NULL, E_FAIL);
4590
4591 if (aSnapshotsNode)
4592 aSnapshotsNode->setNull();
4593 aSnapshotNode->setNull();
4594
4595 // build the full uuid path (from the top parent to the given snapshot)
4596 std::list <Guid> path;
4597 {
4598 ComObjPtr <Snapshot> parent = aSnapshot;
4599 while (parent)
4600 {
4601 path.push_front (parent->data().mId);
4602 parent = parent->parent();
4603 }
4604 }
4605
4606 Key snapshotsNode = aMachineNode;
4607 Key snapshotNode;
4608
4609 for (std::list <Guid>::const_iterator it = path.begin();
4610 it != path.end();
4611 ++ it)
4612 {
4613 if (!snapshotNode.isNull())
4614 {
4615 /* proceed to the nested <Snapshots> node */
4616 snapshotsNode = snapshotNode.key ("Snapshots");
4617 snapshotNode.setNull();
4618 }
4619
4620 AssertReturn (!snapshotsNode.isNull(), E_FAIL);
4621
4622 Key::List children = snapshotsNode.keys ("Snapshot");
4623 for (Key::List::const_iterator ch = children.begin();
4624 ch != children.end();
4625 ++ ch)
4626 {
4627 Guid id = (*ch).value <Guid> ("uuid");
4628 if (id == (*it))
4629 {
4630 /* pass over to the outer loop */
4631 snapshotNode = *ch;
4632 break;
4633 }
4634 }
4635
4636 if (!snapshotNode.isNull())
4637 continue;
4638
4639 /* the next uuid is not found, no need to continue... */
4640 AssertFailedBreakVoid();
4641 }
4642
4643 // we must always succesfully find the node
4644 AssertReturn (!snapshotNode.isNull(), E_FAIL);
4645 AssertReturn (!snapshotsNode.isNull(), E_FAIL);
4646
4647 if (aSnapshotsNode && (snapshotsNode != aMachineNode))
4648 *aSnapshotsNode = snapshotsNode;
4649 *aSnapshotNode = snapshotNode;
4650
4651 return S_OK;
4652}
4653
4654/**
4655 * Returns the snapshot with the given UUID or fails of no such snapshot.
4656 *
4657 * @param aId snapshot UUID to find (empty UUID refers the first snapshot)
4658 * @param aSnapshot where to return the found snapshot
4659 * @param aSetError true to set extended error info on failure
4660 */
4661HRESULT Machine::findSnapshot (const Guid &aId, ComObjPtr <Snapshot> &aSnapshot,
4662 bool aSetError /* = false */)
4663{
4664 if (!mData->mFirstSnapshot)
4665 {
4666 if (aSetError)
4667 return setError (E_FAIL,
4668 tr ("This machine does not have any snapshots"));
4669 return E_FAIL;
4670 }
4671
4672 if (aId.isEmpty())
4673 aSnapshot = mData->mFirstSnapshot;
4674 else
4675 aSnapshot = mData->mFirstSnapshot->findChildOrSelf (aId);
4676
4677 if (!aSnapshot)
4678 {
4679 if (aSetError)
4680 return setError (E_FAIL,
4681 tr ("Could not find a snapshot with UUID {%s}"),
4682 aId.toString().raw());
4683 return E_FAIL;
4684 }
4685
4686 return S_OK;
4687}
4688
4689/**
4690 * Returns the snapshot with the given name or fails of no such snapshot.
4691 *
4692 * @param aName snapshot name to find
4693 * @param aSnapshot where to return the found snapshot
4694 * @param aSetError true to set extended error info on failure
4695 */
4696HRESULT Machine::findSnapshot (const BSTR aName, ComObjPtr <Snapshot> &aSnapshot,
4697 bool aSetError /* = false */)
4698{
4699 AssertReturn (aName, E_INVALIDARG);
4700
4701 if (!mData->mFirstSnapshot)
4702 {
4703 if (aSetError)
4704 return setError (E_FAIL,
4705 tr ("This machine does not have any snapshots"));
4706 return E_FAIL;
4707 }
4708
4709 aSnapshot = mData->mFirstSnapshot->findChildOrSelf (aName);
4710
4711 if (!aSnapshot)
4712 {
4713 if (aSetError)
4714 return setError (E_FAIL,
4715 tr ("Could not find a snapshot named '%ls'"), aName);
4716 return E_FAIL;
4717 }
4718
4719 return S_OK;
4720}
4721
4722/**
4723 * Searches for an attachment that contains the given hard disk.
4724 * The hard disk must be associated with some VM and can be optionally
4725 * associated with some snapshot. If the attachment is stored in the snapshot
4726 * (i.e. the hard disk is associated with some snapshot), @a aSnapshot
4727 * will point to a non-null object on output.
4728 *
4729 * @param aHd hard disk to search an attachment for
4730 * @param aMachine where to store the hard disk's machine (can be NULL)
4731 * @param aSnapshot where to store the hard disk's snapshot (can be NULL)
4732 * @param aHda where to store the hard disk's attachment (can be NULL)
4733 *
4734 *
4735 * @note
4736 * It is assumed that the machine where the attachment is found,
4737 * is already placed to the Discarding state, when this method is called.
4738 * @note
4739 * The object returned in @a aHda is the attachment from the snapshot
4740 * machine if the hard disk is associated with the snapshot, not from the
4741 * primary machine object returned returned in @a aMachine.
4742 */
4743HRESULT Machine::findHardDiskAttachment (const ComObjPtr <HardDisk> &aHd,
4744 ComObjPtr <Machine> *aMachine,
4745 ComObjPtr <Snapshot> *aSnapshot,
4746 ComObjPtr <HardDiskAttachment> *aHda)
4747{
4748 AssertReturn (!aHd.isNull(), E_INVALIDARG);
4749
4750 Guid mid = aHd->machineId();
4751 Guid sid = aHd->snapshotId();
4752
4753 AssertReturn (!mid.isEmpty(), E_INVALIDARG);
4754
4755 ComObjPtr <Machine> m;
4756 mParent->getMachine (mid, m);
4757 ComAssertRet (!m.isNull(), E_FAIL);
4758
4759 HDData::HDAttachmentList *attachments = &m->mHDData->mHDAttachments;
4760
4761 ComObjPtr <Snapshot> s;
4762 if (!sid.isEmpty())
4763 {
4764 m->findSnapshot (sid, s);
4765 ComAssertRet (!s.isNull(), E_FAIL);
4766 attachments = &s->data().mMachine->mHDData->mHDAttachments;
4767 }
4768
4769 AssertReturn (attachments, E_FAIL);
4770
4771 for (HDData::HDAttachmentList::const_iterator it = attachments->begin();
4772 it != attachments->end();
4773 ++ it)
4774 {
4775 if ((*it)->hardDisk() == aHd)
4776 {
4777 if (aMachine) *aMachine = m;
4778 if (aSnapshot) *aSnapshot = s;
4779 if (aHda) *aHda = (*it);
4780 return S_OK;
4781 }
4782 }
4783
4784 ComAssertFailed();
4785 return E_FAIL;
4786}
4787
4788/**
4789 * Helper for #saveSettings. Cares about renaming the settings directory and
4790 * file if the machine name was changed and about creating a new settings file
4791 * if this is a new machine.
4792 *
4793 * @note Must be never called directly but only from #saveSettings().
4794 *
4795 * @param aRenamed receives |true| if the name was changed and the settings
4796 * file was renamed as a result, or |false| otherwise. The
4797 * value makes sense only on success.
4798 * @param aNew receives |true| if a virgin settings file was created.
4799 */
4800HRESULT Machine::prepareSaveSettings (bool &aRenamed, bool &aNew)
4801{
4802 /* Note: tecnhically, mParent needs to be locked only when the machine is
4803 * registered (see prepareSaveSettings() for details) but we don't
4804 * currently differentiate it in callers of saveSettings() so we don't
4805 * make difference here too. */
4806 AssertReturn (mParent->isLockedOnCurrentThread(), E_FAIL);
4807 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
4808
4809 HRESULT rc = S_OK;
4810
4811 aRenamed = false;
4812
4813 /* if we're ready and isConfigLocked() is FALSE then it means
4814 * that no config file exists yet (we will create a virgin one) */
4815 aNew = !isConfigLocked();
4816
4817 /* attempt to rename the settings file if machine name is changed */
4818 if (mUserData->mNameSync &&
4819 mUserData.isBackedUp() &&
4820 mUserData.backedUpData()->mName != mUserData->mName)
4821 {
4822 aRenamed = true;
4823
4824 if (!aNew)
4825 {
4826 /* unlock the old config file */
4827 rc = unlockConfig();
4828 CheckComRCReturnRC (rc);
4829 }
4830
4831 bool dirRenamed = false;
4832 bool fileRenamed = false;
4833
4834 Utf8Str configFile, newConfigFile;
4835 Utf8Str configDir, newConfigDir;
4836
4837 do
4838 {
4839 int vrc = VINF_SUCCESS;
4840
4841 Utf8Str name = mUserData.backedUpData()->mName;
4842 Utf8Str newName = mUserData->mName;
4843
4844 configFile = mData->mConfigFileFull;
4845
4846 /* first, rename the directory if it matches the machine name */
4847 configDir = configFile;
4848 RTPathStripFilename (configDir.mutableRaw());
4849 newConfigDir = configDir;
4850 if (RTPathFilename (configDir) == name)
4851 {
4852 RTPathStripFilename (newConfigDir.mutableRaw());
4853 newConfigDir = Utf8StrFmt ("%s%c%s",
4854 newConfigDir.raw(), RTPATH_DELIMITER, newName.raw());
4855 /* new dir and old dir cannot be equal here because of 'if'
4856 * above and because name != newName */
4857 Assert (configDir != newConfigDir);
4858 if (!aNew)
4859 {
4860 /* perform real rename only if the machine is not new */
4861 vrc = RTPathRename (configDir.raw(), newConfigDir.raw(), 0);
4862 if (VBOX_FAILURE (vrc))
4863 {
4864 rc = setError (E_FAIL,
4865 tr ("Could not rename the directory '%s' to '%s' "
4866 "to save the settings file (%Vrc)"),
4867 configDir.raw(), newConfigDir.raw(), vrc);
4868 break;
4869 }
4870 dirRenamed = true;
4871 }
4872 }
4873
4874 newConfigFile = Utf8StrFmt ("%s%c%s.xml",
4875 newConfigDir.raw(), RTPATH_DELIMITER, newName.raw());
4876
4877 /* then try to rename the settings file itself */
4878 if (newConfigFile != configFile)
4879 {
4880 /* get the path to old settings file in renamed directory */
4881 configFile = Utf8StrFmt ("%s%c%s",
4882 newConfigDir.raw(), RTPATH_DELIMITER,
4883 RTPathFilename (configFile));
4884 if (!aNew)
4885 {
4886 /* perform real rename only if the machine is not new */
4887 vrc = RTFileRename (configFile.raw(), newConfigFile.raw(), 0);
4888 if (VBOX_FAILURE (vrc))
4889 {
4890 rc = setError (E_FAIL,
4891 tr ("Could not rename the settings file '%s' to '%s' "
4892 "(%Vrc)"),
4893 configFile.raw(), newConfigFile.raw(), vrc);
4894 break;
4895 }
4896 fileRenamed = true;
4897 }
4898 }
4899
4900 /* update mConfigFileFull amd mConfigFile */
4901 Bstr oldConfigFileFull = mData->mConfigFileFull;
4902 Bstr oldConfigFile = mData->mConfigFile;
4903 mData->mConfigFileFull = newConfigFile;
4904 /* try to get the relative path for mConfigFile */
4905 Utf8Str path = newConfigFile;
4906 mParent->calculateRelativePath (path, path);
4907 mData->mConfigFile = path;
4908
4909 /* last, try to update the global settings with the new path */
4910 if (mData->mRegistered)
4911 {
4912 rc = mParent->updateSettings (configDir, newConfigDir);
4913 if (FAILED (rc))
4914 {
4915 /* revert to old values */
4916 mData->mConfigFileFull = oldConfigFileFull;
4917 mData->mConfigFile = oldConfigFile;
4918 break;
4919 }
4920 }
4921
4922 /* update the snapshot folder */
4923 path = mUserData->mSnapshotFolderFull;
4924 if (RTPathStartsWith (path, configDir))
4925 {
4926 path = Utf8StrFmt ("%s%s", newConfigDir.raw(),
4927 path.raw() + configDir.length());
4928 mUserData->mSnapshotFolderFull = path;
4929 calculateRelativePath (path, path);
4930 mUserData->mSnapshotFolder = path;
4931 }
4932
4933 /* update the saved state file path */
4934 path = mSSData->mStateFilePath;
4935 if (RTPathStartsWith (path, configDir))
4936 {
4937 path = Utf8StrFmt ("%s%s", newConfigDir.raw(),
4938 path.raw() + configDir.length());
4939 mSSData->mStateFilePath = path;
4940 }
4941
4942 /* Update saved state file paths of all online snapshots.
4943 * Note that saveSettings() will recognize name change
4944 * and will save all snapshots in this case. */
4945 if (mData->mFirstSnapshot)
4946 mData->mFirstSnapshot->updateSavedStatePaths (configDir,
4947 newConfigDir);
4948 }
4949 while (0);
4950
4951 if (FAILED (rc))
4952 {
4953 /* silently try to rename everything back */
4954 if (fileRenamed)
4955 RTFileRename (newConfigFile.raw(), configFile.raw(), 0);
4956 if (dirRenamed)
4957 RTPathRename (newConfigDir.raw(), configDir.raw(), 0);
4958 }
4959
4960 if (!aNew)
4961 {
4962 /* lock the config again */
4963 HRESULT rc2 = lockConfig();
4964 if (SUCCEEDED (rc))
4965 rc = rc2;
4966 }
4967
4968 CheckComRCReturnRC (rc);
4969 }
4970
4971 if (aNew)
4972 {
4973 /* create a virgin config file */
4974 int vrc = VINF_SUCCESS;
4975
4976 /* ensure the settings directory exists */
4977 Utf8Str path = mData->mConfigFileFull;
4978 RTPathStripFilename (path.mutableRaw());
4979 if (!RTDirExists (path))
4980 {
4981 vrc = RTDirCreateFullPath (path, 0777);
4982 if (VBOX_FAILURE (vrc))
4983 {
4984 return setError (E_FAIL,
4985 tr ("Could not create a directory '%s' "
4986 "to save the settings file (%Vrc)"),
4987 path.raw(), vrc);
4988 }
4989 }
4990
4991 /* Note: open flags must correlate with RTFileOpen() in lockConfig() */
4992 path = Utf8Str (mData->mConfigFileFull);
4993 vrc = RTFileOpen (&mData->mHandleCfgFile, path,
4994 RTFILE_O_READWRITE | RTFILE_O_CREATE |
4995 RTFILE_O_DENY_WRITE);
4996 if (VBOX_SUCCESS (vrc))
4997 {
4998 vrc = RTFileWrite (mData->mHandleCfgFile,
4999 (void *) DefaultMachineConfig,
5000 sizeof (DefaultMachineConfig), NULL);
5001 }
5002 if (VBOX_FAILURE (vrc))
5003 {
5004 mData->mHandleCfgFile = NIL_RTFILE;
5005 return setError (E_FAIL,
5006 tr ("Could not create the settings file '%s' (%Vrc)"),
5007 path.raw(), vrc);
5008 }
5009 /* we do not close the file to simulate lockConfig() */
5010 }
5011
5012 return rc;
5013}
5014
5015/**
5016 * Saves machine data, user data and hardware data.
5017 *
5018 * @param aMarkCurStateAsModified
5019 * If true (default), mData->mCurrentStateModified will be set to
5020 * what #isReallyModified() returns prior to saving settings to a file,
5021 * otherwise the current value of mData->mCurrentStateModified will be
5022 * saved.
5023 * @param aInformCallbacksAnyway
5024 * If true, callbacks will be informed even if #isReallyModified()
5025 * returns false. This is necessary for cases when we change machine data
5026 * diectly, not through the backup()/commit() mechanism.
5027 *
5028 * @note Must be called from under mParent write lock (sometimes needed by
5029 * #prepareSaveSettings()) and this object's write lock. Locks children for
5030 * writing. There is one exception when mParent is unused and therefore may
5031 * be left unlocked: if this machine is an unregistered one.
5032 */
5033HRESULT Machine::saveSettings (bool aMarkCurStateAsModified /* = true */,
5034 bool aInformCallbacksAnyway /* = false */)
5035{
5036 LogFlowThisFuncEnter();
5037
5038 /* Note: tecnhically, mParent needs to be locked only when the machine is
5039 * registered (see prepareSaveSettings() for details) but we don't
5040 * currently differentiate it in callers of saveSettings() so we don't
5041 * make difference here too. */
5042 AssertReturn (mParent->isLockedOnCurrentThread(), E_FAIL);
5043 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
5044
5045 /// @todo (dmik) I guess we should lock all our child objects here
5046 // (such as mVRDPServer etc.) to ensure they are not changed
5047 // until completely saved to disk and committed
5048
5049 /// @todo (dmik) also, we need to delegate saving child objects' settings
5050 // to objects themselves to ensure operations 'commit + save changes'
5051 // are atomic (amd done from the object's lock so that nobody can change
5052 // settings again until completely saved).
5053
5054 AssertReturn (mType == IsMachine || mType == IsSessionMachine, E_FAIL);
5055
5056 bool wasModified;
5057
5058 if (aMarkCurStateAsModified)
5059 {
5060 /*
5061 * We ignore changes to user data when setting mCurrentStateModified
5062 * because the current state will not differ from the current snapshot
5063 * if only user data has been changed (user data is shared by all
5064 * snapshots).
5065 */
5066 mData->mCurrentStateModified = isReallyModified (true /* aIgnoreUserData */);
5067 wasModified = mUserData.hasActualChanges() || mData->mCurrentStateModified;
5068 }
5069 else
5070 {
5071 wasModified = isReallyModified();
5072 }
5073
5074 HRESULT rc = S_OK;
5075
5076 /* First, prepare to save settings. It will will care about renaming the
5077 * settings directory and file if the machine name was changed and about
5078 * creating a new settings file if this is a new machine. */
5079 bool isRenamed = false;
5080 bool isNew = false;
5081 rc = prepareSaveSettings (isRenamed, isNew);
5082 CheckComRCReturnRC (rc);
5083
5084 try
5085 {
5086 using namespace settings;
5087
5088 File file (File::ReadWrite, mData->mHandleCfgFile,
5089 Utf8Str (mData->mConfigFileFull));
5090 XmlTreeBackend tree;
5091
5092 /* The newly created settings file is incomplete therefore we turn off
5093 * validation. The rest is like in loadSettingsTree_ForUpdate().*/
5094 rc = VirtualBox::loadSettingsTree (tree, file,
5095 !isNew /* aValidate */,
5096 false /* aCatchLoadErrors */,
5097 false /* aAddDefaults */);
5098 CheckComRCThrowRC (rc);
5099
5100
5101 /* ask to save all snapshots when the machine name was changed since
5102 * it may affect saved state file paths for online snapshots (see
5103 * #openConfigLoader() for details) */
5104 bool updateAllSnapshots = isRenamed;
5105
5106 /* commit before saving, since it may change settings
5107 * (for example, perform fixup of lazy hard disk changes) */
5108 rc = commit();
5109 CheckComRCReturnRC (rc);
5110
5111 /* include hard disk changes to the modified flag */
5112 wasModified |= mHDData->mHDAttachmentsChanged;
5113 if (aMarkCurStateAsModified)
5114 mData->mCurrentStateModified |= BOOL (mHDData->mHDAttachmentsChanged);
5115
5116 Key machineNode = tree.rootKey().createKey ("Machine");
5117
5118 /* uuid (required) */
5119 Assert (!mData->mUuid.isEmpty());
5120 machineNode.setValue <Guid> ("uuid", mData->mUuid);
5121
5122 /* name (required) */
5123 Assert (!mUserData->mName.isEmpty());
5124 machineNode.setValue <Bstr> ("name", mUserData->mName);
5125
5126 /* nameSync (optional, default is true) */
5127 machineNode.setValueOr <bool> ("nameSync", !!mUserData->mNameSync, true);
5128
5129 /* Description node (optional) */
5130 if (!mUserData->mDescription.isNull())
5131 {
5132 Key descNode = machineNode.createKey ("Description");
5133 descNode.setKeyValue <Bstr> (mUserData->mDescription);
5134 }
5135 else
5136 {
5137 Key descNode = machineNode.findKey ("Description");
5138 if (!descNode.isNull())
5139 descNode.zap();
5140 }
5141
5142 /* OSType (required) */
5143 machineNode.setValue <Bstr> ("OSType", mUserData->mOSTypeId);
5144
5145 /* stateFile (optional) */
5146 if (mData->mMachineState == MachineState_Saved)
5147 {
5148 Assert (!mSSData->mStateFilePath.isEmpty());
5149 /* try to make the file name relative to the settings file dir */
5150 Utf8Str stateFilePath = mSSData->mStateFilePath;
5151 calculateRelativePath (stateFilePath, stateFilePath);
5152 machineNode.setStringValue ("stateFile", stateFilePath);
5153 }
5154 else
5155 {
5156 Assert (mSSData->mStateFilePath.isNull());
5157 machineNode.zapValue ("stateFile");
5158 }
5159
5160 /* currentSnapshot ID (optional) */
5161 if (!mData->mCurrentSnapshot.isNull())
5162 {
5163 Assert (!mData->mFirstSnapshot.isNull());
5164 machineNode.setValue <Guid> ("currentSnapshot",
5165 mData->mCurrentSnapshot->data().mId);
5166 }
5167 else
5168 {
5169 Assert (mData->mFirstSnapshot.isNull());
5170 machineNode.zapValue ("currentSnapshot");
5171 }
5172
5173 /* snapshotFolder (optional) */
5174 /// @todo use the Bstr::NullOrEmpty constant and setValueOr
5175 if (!mUserData->mSnapshotFolder.isEmpty())
5176 machineNode.setValue <Bstr> ("snapshotFolder", mUserData->mSnapshotFolder);
5177 else
5178 machineNode.zapValue ("snapshotFolder");
5179
5180 /* currentStateModified (optional, default is true) */
5181 machineNode.setValueOr <bool> ("currentStateModified",
5182 !!mData->mCurrentStateModified, true);
5183
5184 /* lastStateChange */
5185 machineNode.setValue <RTTIMESPEC> ("lastStateChange",
5186 mData->mLastStateChange);
5187
5188 /* set the aborted attribute when appropriate, defaults to false */
5189 machineNode.setValueOr <bool> ("aborted",
5190 mData->mMachineState == MachineState_Aborted,
5191 false);
5192
5193 /* Hardware node (required) */
5194 {
5195 /* first, delete the entire node if exists */
5196 Key hwNode = machineNode.findKey ("Hardware");
5197 if (!hwNode.isNull())
5198 hwNode.zap();
5199 /* then recreate it */
5200 hwNode = machineNode.createKey ("Hardware");
5201
5202 rc = saveHardware (hwNode);
5203 CheckComRCThrowRC (rc);
5204 }
5205
5206 /* HardDiskAttachments node (required) */
5207 {
5208 /* first, delete the entire node if exists */
5209 Key hdaNode = machineNode.findKey ("HardDiskAttachments");
5210 if (!hdaNode.isNull())
5211 hdaNode.zap();
5212 /* then recreate it */
5213 hdaNode = machineNode.createKey ("HardDiskAttachments");
5214
5215 rc = saveHardDisks (hdaNode);
5216 CheckComRCThrowRC (rc);
5217 }
5218
5219 /* update all snapshots if requested */
5220 if (updateAllSnapshots)
5221 {
5222 rc = saveSnapshotSettingsWorker (machineNode, NULL,
5223 SaveSS_UpdateAllOp);
5224 CheckComRCThrowRC (rc);
5225 }
5226
5227 /* save the settings on success */
5228 rc = VirtualBox::saveSettingsTree (tree, file,
5229 mData->mSettingsFileVersion);
5230 CheckComRCThrowRC (rc);
5231 }
5232 catch (HRESULT err)
5233 {
5234 /* we assume that error info is set by the thrower */
5235 rc = err;
5236 }
5237 catch (...)
5238 {
5239 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
5240 }
5241
5242 if (FAILED (rc))
5243 {
5244 /* backup arbitrary data item to cause #isModified() to still return
5245 * true in case of any error */
5246 mHWData.backup();
5247 }
5248
5249 if (wasModified || aInformCallbacksAnyway)
5250 {
5251 /* Fire the data change event, even on failure (since we've already
5252 * committed all data). This is done only for SessionMachines because
5253 * mutable Machine instances are always not registered (i.e. private
5254 * to the client process that creates them) and thus don't need to
5255 * inform callbacks. */
5256 if (mType == IsSessionMachine)
5257 mParent->onMachineDataChange (mData->mUuid);
5258 }
5259
5260 LogFlowThisFunc (("rc=%08X\n", rc));
5261 LogFlowThisFuncLeave();
5262 return rc;
5263}
5264
5265/**
5266 * Wrapper for #saveSnapshotSettingsWorker() that opens the settings file
5267 * and locates the <Machine> node in there. See #saveSnapshotSettingsWorker()
5268 * for more details.
5269 *
5270 * @param aSnapshot Snapshot to operate on
5271 * @param aOpFlags Operation to perform, one of SaveSS_NoOp, SaveSS_AddOp
5272 * or SaveSS_UpdateAttrsOp possibly combined with
5273 * SaveSS_UpdateCurrentId.
5274 *
5275 * @note Locks this object for writing + other child objects.
5276 */
5277HRESULT Machine::saveSnapshotSettings (Snapshot *aSnapshot, int aOpFlags)
5278{
5279 AutoCaller autoCaller (this);
5280 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
5281
5282 AssertReturn (mType == IsMachine || mType == IsSessionMachine, E_FAIL);
5283
5284 AutoLock alock (this);
5285
5286 AssertReturn (isConfigLocked(), E_FAIL);
5287
5288 HRESULT rc = S_OK;
5289
5290 try
5291 {
5292 using namespace settings;
5293
5294 /* load the config file */
5295 File file (File::ReadWrite, mData->mHandleCfgFile,
5296 Utf8Str (mData->mConfigFileFull));
5297 XmlTreeBackend tree;
5298
5299 rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
5300 CheckComRCReturnRC (rc);
5301
5302 Key machineNode = tree.rootKey().key ("Machine");
5303
5304 rc = saveSnapshotSettingsWorker (machineNode, aSnapshot, aOpFlags);
5305 CheckComRCReturnRC (rc);
5306
5307 /* save settings on success */
5308 rc = VirtualBox::saveSettingsTree (tree, file,
5309 mData->mSettingsFileVersion);
5310 CheckComRCReturnRC (rc);
5311 }
5312 catch (...)
5313 {
5314 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
5315 }
5316
5317 return rc;
5318}
5319
5320/**
5321 * Performs the specified operation on the given snapshot
5322 * in the settings file represented by \a aMachineNode.
5323 *
5324 * If \a aOpFlags = SaveSS_UpdateAllOp, \a aSnapshot can be NULL to indicate
5325 * that the whole tree of the snapshots should be updated in <Machine>.
5326 * One particular case is when the last (and the only) snapshot should be
5327 * removed (it is so when both mCurrentSnapshot and mFirstSnapshot are NULL).
5328 *
5329 * \a aOp may be just SaveSS_UpdateCurrentId if only the currentSnapshot
5330 * attribute of <Machine> needs to be updated.
5331 *
5332 * @param aMachineNode <Machine> node in the opened settings file.
5333 * @param aSnapshot Snapshot to operate on.
5334 * @param aOpFlags Operation to perform, one of SaveSS_NoOp, SaveSS_AddOp
5335 * or SaveSS_UpdateAttrsOp possibly combined with
5336 * SaveSS_UpdateCurrentId.
5337 *
5338 * @note Must be called with this object locked for writing.
5339 * Locks child objects.
5340 */
5341HRESULT Machine::saveSnapshotSettingsWorker (settings::Key &aMachineNode,
5342 Snapshot *aSnapshot, int aOpFlags)
5343{
5344 using namespace settings;
5345
5346 AssertReturn (!aMachineNode.isNull(), E_FAIL);
5347
5348 AssertReturn (isLockedOnCurrentThread(), E_FAIL);
5349
5350 int op = aOpFlags & SaveSS_OpMask;
5351 AssertReturn (
5352 (aSnapshot && (op == SaveSS_AddOp || op == SaveSS_UpdateAttrsOp ||
5353 op == SaveSS_UpdateAllOp)) ||
5354 (!aSnapshot && ((op == SaveSS_NoOp && (aOpFlags & SaveSS_UpdateCurrentId)) ||
5355 op == SaveSS_UpdateAllOp)),
5356 E_FAIL);
5357
5358 HRESULT rc = S_OK;
5359
5360 bool recreateWholeTree = false;
5361
5362 do
5363 {
5364 if (op == SaveSS_NoOp)
5365 break;
5366
5367 /* quick path: recreate the whole tree of the snapshots */
5368 if (op == SaveSS_UpdateAllOp && !aSnapshot)
5369 {
5370 /* first, delete the entire root snapshot node if it exists */
5371 Key snapshotNode = aMachineNode.findKey ("Snapshot");
5372 if (!snapshotNode.isNull())
5373 snapshotNode.zap();
5374
5375 /* second, if we have any snapshots left, substitute aSnapshot
5376 * with the first snapshot to recreate the whole tree, otherwise
5377 * break */
5378 if (mData->mFirstSnapshot)
5379 {
5380 aSnapshot = mData->mFirstSnapshot;
5381 recreateWholeTree = true;
5382 }
5383 else
5384 break;
5385 }
5386
5387 Assert (!!aSnapshot);
5388 ComObjPtr <Snapshot> parent = aSnapshot->parent();
5389
5390 if (op == SaveSS_AddOp)
5391 {
5392 Key parentNode;
5393
5394 if (parent)
5395 {
5396 rc = findSnapshotNode (parent, aMachineNode, NULL, &parentNode);
5397 CheckComRCBreakRC (rc);
5398
5399 ComAssertBreak (!parentNode.isNull(), rc = E_FAIL);
5400 }
5401
5402 do
5403 {
5404 Key snapshotsNode;
5405
5406 if (!parentNode.isNull())
5407 snapshotsNode = parentNode.createKey ("Snapshots");
5408 else
5409 snapshotsNode = aMachineNode;
5410 do
5411 {
5412 Key snapshotNode = snapshotsNode.appendKey ("Snapshot");
5413 rc = saveSnapshot (snapshotNode, aSnapshot, false /* aAttrsOnly */);
5414 CheckComRCBreakRC (rc);
5415
5416 /* when a new snapshot is added, this means diffs were created
5417 * for every normal/immutable hard disk of the VM, so we need to
5418 * save the current hard disk attachments */
5419
5420 Key hdaNode = aMachineNode.findKey ("HardDiskAttachments");
5421 if (!hdaNode.isNull())
5422 hdaNode.zap();
5423 hdaNode = aMachineNode.createKey ("HardDiskAttachments");
5424
5425 rc = saveHardDisks (hdaNode);
5426 CheckComRCBreakRC (rc);
5427
5428 if (mHDData->mHDAttachments.size() != 0)
5429 {
5430 /* If we have one or more attachments then we definitely
5431 * created diffs for them and associated new diffs with
5432 * current settngs. So, since we don't use saveSettings(),
5433 * we need to inform callbacks manually. */
5434 if (mType == IsSessionMachine)
5435 mParent->onMachineDataChange (mData->mUuid);
5436 }
5437 }
5438 while (0);
5439 }
5440 while (0);
5441
5442 break;
5443 }
5444
5445 Assert ((op == SaveSS_UpdateAttrsOp && !recreateWholeTree) ||
5446 op == SaveSS_UpdateAllOp);
5447
5448 Key snapshotsNode;
5449 Key snapshotNode;
5450
5451 if (!recreateWholeTree)
5452 {
5453 rc = findSnapshotNode (aSnapshot, aMachineNode,
5454 &snapshotsNode, &snapshotNode);
5455 CheckComRCBreakRC (rc);
5456 }
5457
5458 if (snapshotsNode.isNull())
5459 snapshotsNode = aMachineNode;
5460
5461 if (op == SaveSS_UpdateAttrsOp)
5462 rc = saveSnapshot (snapshotNode, aSnapshot, true /* aAttrsOnly */);
5463 else
5464 {
5465 if (!snapshotNode.isNull())
5466 snapshotNode.zap();
5467
5468 snapshotNode = snapshotsNode.appendKey ("Snapshot");
5469 rc = saveSnapshot (snapshotNode, aSnapshot, false /* aAttrsOnly */);
5470 CheckComRCBreakRC (rc);
5471 }
5472 }
5473 while (0);
5474
5475 if (SUCCEEDED (rc))
5476 {
5477 /* update currentSnapshot when appropriate */
5478 if (aOpFlags & SaveSS_UpdateCurrentId)
5479 {
5480 if (!mData->mCurrentSnapshot.isNull())
5481 aMachineNode.setValue <Guid> ("currentSnapshot",
5482 mData->mCurrentSnapshot->data().mId);
5483 else
5484 aMachineNode.zapValue ("currentSnapshot");
5485 }
5486 if (aOpFlags & SaveSS_UpdateCurStateModified)
5487 {
5488 aMachineNode.setValue <bool> ("currentStateModified", true);
5489 }
5490 }
5491
5492 return rc;
5493}
5494
5495/**
5496 * Saves the given snapshot and all its children (unless \a aAttrsOnly is true).
5497 * It is assumed that the given node is empty (unless \a aAttrsOnly is true).
5498 *
5499 * @param aNode <Snapshot> node to save the snapshot to.
5500 * @param aSnapshot Snapshot to save.
5501 * @param aAttrsOnly If true, only updatge user-changeable attrs.
5502 */
5503HRESULT Machine::saveSnapshot (settings::Key &aNode, Snapshot *aSnapshot, bool aAttrsOnly)
5504{
5505 using namespace settings;
5506
5507 AssertReturn (!aNode.isNull() && aSnapshot, E_INVALIDARG);
5508 AssertReturn (mType == IsMachine || mType == IsSessionMachine, E_FAIL);
5509
5510 /* uuid (required) */
5511 if (!aAttrsOnly)
5512 aNode.setValue <Guid> ("uuid", aSnapshot->data().mId);
5513
5514 /* name (required) */
5515 aNode.setValue <Bstr> ("name", aSnapshot->data().mName);
5516
5517 /* timeStamp (required) */
5518 aNode.setValue <RTTIMESPEC> ("timeStamp", aSnapshot->data().mTimeStamp);
5519
5520 /* Description node (optional) */
5521 if (!aSnapshot->data().mDescription.isNull())
5522 {
5523 Key descNode = aNode.createKey ("Description");
5524 descNode.setKeyValue <Bstr> (aSnapshot->data().mDescription);
5525 }
5526 else
5527 {
5528 Key descNode = aNode.findKey ("Description");
5529 if (!descNode.isNull())
5530 descNode.zap();
5531 }
5532
5533 if (aAttrsOnly)
5534 return S_OK;
5535
5536 /* stateFile (optional) */
5537 if (aSnapshot->stateFilePath())
5538 {
5539 /* try to make the file name relative to the settings file dir */
5540 Utf8Str stateFilePath = aSnapshot->stateFilePath();
5541 calculateRelativePath (stateFilePath, stateFilePath);
5542 aNode.setStringValue ("stateFile", stateFilePath);
5543 }
5544
5545 {
5546 ComObjPtr <SnapshotMachine> snapshotMachine = aSnapshot->data().mMachine;
5547 ComAssertRet (!snapshotMachine.isNull(), E_FAIL);
5548
5549 /* save hardware */
5550 {
5551 Key hwNode = aNode.createKey ("Hardware");
5552 HRESULT rc = snapshotMachine->saveHardware (hwNode);
5553 CheckComRCReturnRC (rc);
5554 }
5555
5556 /* save hard disks */
5557 {
5558 Key hdasNode = aNode.createKey ("HardDiskAttachments");
5559 HRESULT rc = snapshotMachine->saveHardDisks (hdasNode);
5560 CheckComRCReturnRC (rc);
5561 }
5562 }
5563
5564 /* save children */
5565 {
5566 AutoLock listLock (aSnapshot->childrenLock());
5567
5568 if (aSnapshot->children().size())
5569 {
5570 Key snapshotsNode = aNode.createKey ("Snapshots");
5571
5572 HRESULT rc = S_OK;
5573
5574 for (Snapshot::SnapshotList::const_iterator it = aSnapshot->children().begin();
5575 it != aSnapshot->children().end();
5576 ++ it)
5577 {
5578 Key snapshotNode = snapshotsNode.createKey ("Snapshot");
5579 rc = saveSnapshot (snapshotNode, (*it), aAttrsOnly);
5580 CheckComRCReturnRC (rc);
5581 }
5582 }
5583 }
5584
5585 return S_OK;
5586}
5587
5588/**
5589 * Saves the VM hardware configuration. It is assumed that the
5590 * given node is empty.
5591 *
5592 * @param aNode <Hardware> node to save the VM hardware confguration to.
5593 */
5594HRESULT Machine::saveHardware (settings::Key &aNode)
5595{
5596 using namespace settings;
5597
5598 AssertReturn (!aNode.isNull(), E_INVALIDARG);
5599
5600 HRESULT rc = S_OK;
5601
5602 /* CPU (optional) */
5603 {
5604 Key cpuNode = aNode.createKey ("CPU");
5605 Key hwVirtExNode = cpuNode.createKey ("HardwareVirtEx");
5606 const char *value = NULL;
5607 switch (mHWData->mHWVirtExEnabled)
5608 {
5609 case TSBool_False:
5610 value = "false";
5611 break;
5612 case TSBool_True:
5613 value = "true";
5614 break;
5615 case TSBool_Default:
5616 value = "default";
5617 }
5618 hwVirtExNode.setStringValue ("enabled", value);
5619 }
5620
5621 /* memory (required) */
5622 {
5623 Key memoryNode = aNode.createKey ("Memory");
5624 memoryNode.setValue <ULONG> ("RAMSize", mHWData->mMemorySize);
5625 }
5626
5627 /* boot (required) */
5628 {
5629 Key bootNode = aNode.createKey ("Boot");
5630
5631 for (ULONG pos = 0; pos < ELEMENTS (mHWData->mBootOrder); ++ pos)
5632 {
5633 const char *device = NULL;
5634 switch (mHWData->mBootOrder [pos])
5635 {
5636 case DeviceType_Null:
5637 /* skip, this is allowed for <Order> nodes
5638 * when loading, the default value NoDevice will remain */
5639 continue;
5640 case DeviceType_Floppy: device = "Floppy"; break;
5641 case DeviceType_DVD: device = "DVD"; break;
5642 case DeviceType_HardDisk: device = "HardDisk"; break;
5643 case DeviceType_Network: device = "Network"; break;
5644 default:
5645 {
5646 ComAssertMsgFailedRet (("Invalid boot device: %d\n",
5647 mHWData->mBootOrder [pos]),
5648 E_FAIL);
5649 }
5650 }
5651
5652 Key orderNode = bootNode.appendKey ("Order");
5653 orderNode.setValue <ULONG> ("position", pos + 1);
5654 orderNode.setStringValue ("device", device);
5655 }
5656 }
5657
5658 /* display (required) */
5659 {
5660 Key displayNode = aNode.createKey ("Display");
5661 displayNode.setValue <ULONG> ("VRAMSize", mHWData->mVRAMSize);
5662 displayNode.setValue <ULONG> ("MonitorCount", mHWData->mMonitorCount);
5663 }
5664
5665#ifdef VBOX_VRDP
5666 /* VRDP settings (optional) */
5667 rc = mVRDPServer->saveSettings (aNode);
5668 CheckComRCReturnRC (rc);
5669#endif
5670
5671 /* BIOS (required) */
5672 rc = mBIOSSettings->saveSettings (aNode);
5673 CheckComRCReturnRC (rc);
5674
5675 /* DVD drive (required) */
5676 rc = mDVDDrive->saveSettings (aNode);
5677 CheckComRCReturnRC (rc);
5678
5679 /* Flooppy drive (required) */
5680 rc = mFloppyDrive->saveSettings (aNode);
5681 CheckComRCReturnRC (rc);
5682
5683 /* USB Controller (required) */
5684 rc = mUSBController->saveSettings (aNode);
5685 CheckComRCReturnRC (rc);
5686
5687 /* SATA Controller (required) */
5688 rc = mSATAController->saveSettings (aNode);
5689 CheckComRCReturnRC (rc);
5690
5691 /* Network adapters (required) */
5692 {
5693 Key nwNode = aNode.createKey ("Network");
5694
5695 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); ++ slot)
5696 {
5697 Key adapterNode = nwNode.appendKey ("Adapter");
5698
5699 adapterNode.setValue <ULONG> ("slot", slot);
5700
5701 rc = mNetworkAdapters [slot]->saveSettings (adapterNode);
5702 CheckComRCReturnRC (rc);
5703 }
5704 }
5705
5706 /* Serial ports */
5707 {
5708 Key serialNode = aNode.createKey ("UART");
5709
5710 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); ++ slot)
5711 {
5712 Key portNode = serialNode.appendKey ("Port");
5713
5714 portNode.setValue <ULONG> ("slot", slot);
5715
5716 rc = mSerialPorts [slot]->saveSettings (portNode);
5717 CheckComRCReturnRC (rc);
5718 }
5719 }
5720
5721 /* Parallel ports */
5722 {
5723 Key parallelNode = aNode.createKey ("LPT");
5724
5725 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); ++ slot)
5726 {
5727 Key portNode = parallelNode.appendKey ("Port");
5728
5729 portNode.setValue <ULONG> ("slot", slot);
5730
5731 rc = mParallelPorts [slot]->saveSettings (portNode);
5732 CheckComRCReturnRC (rc);
5733 }
5734 }
5735
5736 /* Audio adapter */
5737 rc = mAudioAdapter->saveSettings (aNode);
5738 CheckComRCReturnRC (rc);
5739
5740 /* Shared folders */
5741 {
5742 Key sharedFoldersNode = aNode.createKey ("SharedFolders");
5743
5744 for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
5745 it != mHWData->mSharedFolders.end();
5746 ++ it)
5747 {
5748 ComObjPtr <SharedFolder> folder = *it;
5749
5750 Key folderNode = sharedFoldersNode.appendKey ("SharedFolder");
5751
5752 /* all are mandatory */
5753 folderNode.setValue <Bstr> ("name", folder->name());
5754 folderNode.setValue <Bstr> ("hostPath", folder->hostPath());
5755 folderNode.setValue <bool> ("writable", !!folder->writable());
5756 }
5757 }
5758
5759 /* Clipboard */
5760 {
5761 Key clipNode = aNode.createKey ("Clipboard");
5762
5763 const char *modeStr = "Disabled";
5764 switch (mHWData->mClipboardMode)
5765 {
5766 case ClipboardMode_Disabled:
5767 /* already assigned */
5768 break;
5769 case ClipboardMode_HostToGuest:
5770 modeStr = "HostToGuest";
5771 break;
5772 case ClipboardMode_GuestToHost:
5773 modeStr = "GuestToHost";
5774 break;
5775 case ClipboardMode_Bidirectional:
5776 modeStr = "Bidirectional";
5777 break;
5778 default:
5779 ComAssertMsgFailedRet (("Clipboard mode %d is invalid",
5780 mHWData->mClipboardMode),
5781 E_FAIL);
5782 }
5783 clipNode.setStringValue ("mode", modeStr);
5784 }
5785
5786 /* Guest */
5787 {
5788 Key guestNode = aNode.createKey ("Guest");
5789
5790 guestNode.setValue <ULONG> ("memoryBalloonSize",
5791 mHWData->mMemoryBalloonSize);
5792 guestNode.setValue <ULONG> ("statisticsUpdateInterval",
5793 mHWData->mStatisticsUpdateInterval);
5794 }
5795
5796 AssertComRC (rc);
5797 return rc;
5798}
5799
5800/**
5801 * Saves the hard disk confguration.
5802 * It is assumed that the given node is empty.
5803 *
5804 * @param aNode <HardDiskAttachments> node to save the hard disk confguration to.
5805 */
5806HRESULT Machine::saveHardDisks (settings::Key &aNode)
5807{
5808 using namespace settings;
5809
5810 AssertReturn (!aNode.isNull(), E_INVALIDARG);
5811
5812 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
5813 it != mHDData->mHDAttachments.end();
5814 ++ it)
5815 {
5816 ComObjPtr <HardDiskAttachment> att = *it;
5817
5818 Key hdNode = aNode.appendKey ("HardDiskAttachment");
5819
5820 {
5821 const char *bus = NULL;
5822 switch (att->bus())
5823 {
5824 case StorageBus_IDE: bus = "IDE"; break;
5825 case StorageBus_SATA: bus = "SATA"; break;
5826 default:
5827 ComAssertFailedRet (E_FAIL);
5828 }
5829
5830 hdNode.setValue <Guid> ("hardDisk", att->hardDisk()->id());
5831 hdNode.setStringValue ("bus", bus);
5832 hdNode.setValue <LONG> ("channel", att->channel());
5833 hdNode.setValue <LONG> ("device", att->device());
5834 }
5835 }
5836
5837 return S_OK;
5838}
5839
5840/**
5841 * Saves machine state settings as defined by aFlags
5842 * (SaveSTS_* values).
5843 *
5844 * @param aFlags Combination of SaveSTS_* flags.
5845 *
5846 * @note Locks objects for writing.
5847 */
5848HRESULT Machine::saveStateSettings (int aFlags)
5849{
5850 if (aFlags == 0)
5851 return S_OK;
5852
5853 AutoCaller autoCaller (this);
5854 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
5855
5856 AutoLock alock (this);
5857
5858 AssertReturn (isConfigLocked(), E_FAIL);
5859
5860 HRESULT rc = S_OK;
5861
5862 try
5863 {
5864 using namespace settings;
5865
5866 /* load the config file */
5867 File file (File::ReadWrite, mData->mHandleCfgFile,
5868 Utf8Str (mData->mConfigFileFull));
5869 XmlTreeBackend tree;
5870
5871 rc = VirtualBox::loadSettingsTree_ForUpdate (tree, file);
5872 CheckComRCReturnRC (rc);
5873
5874 Key machineNode = tree.rootKey().key ("Machine");
5875
5876 if (aFlags & SaveSTS_CurStateModified)
5877 {
5878 /* defaults to true */
5879 machineNode.setValueOr <bool> ("currentStateModified",
5880 !!mData->mCurrentStateModified, true);
5881 }
5882
5883 if (aFlags & SaveSTS_StateFilePath)
5884 {
5885 if (mSSData->mStateFilePath)
5886 {
5887 /* try to make the file name relative to the settings file dir */
5888 Utf8Str stateFilePath = mSSData->mStateFilePath;
5889 calculateRelativePath (stateFilePath, stateFilePath);
5890 machineNode.setStringValue ("stateFile", stateFilePath);
5891 }
5892 else
5893 machineNode.zapValue ("stateFile");
5894 }
5895
5896 if (aFlags & SaveSTS_StateTimeStamp)
5897 {
5898 Assert (mData->mMachineState != MachineState_Aborted ||
5899 mSSData->mStateFilePath.isNull());
5900
5901 machineNode.setValue <RTTIMESPEC> ("lastStateChange",
5902 mData->mLastStateChange);
5903
5904 /* set the aborted attribute when appropriate, defaults to false */
5905 machineNode.setValueOr <bool> ("aborted",
5906 mData->mMachineState == MachineState_Aborted,
5907 false);
5908 }
5909
5910 /* save settings on success */
5911 rc = VirtualBox::saveSettingsTree (tree, file,
5912 mData->mSettingsFileVersion);
5913 CheckComRCReturnRC (rc);
5914 }
5915 catch (...)
5916 {
5917 rc = VirtualBox::handleUnexpectedExceptions (RT_SRC_POS);
5918 }
5919
5920 return rc;
5921}
5922
5923/**
5924 * Cleans up all differencing hard disks based on immutable hard disks.
5925 *
5926 * @note Locks objects!
5927 */
5928HRESULT Machine::wipeOutImmutableDiffs()
5929{
5930 AutoCaller autoCaller (this);
5931 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
5932
5933 AutoReaderLock alock (this);
5934
5935 AssertReturn (mData->mMachineState == MachineState_PoweredOff ||
5936 mData->mMachineState == MachineState_Aborted, E_FAIL);
5937
5938 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
5939 it != mHDData->mHDAttachments.end();
5940 ++ it)
5941 {
5942 ComObjPtr <HardDisk> hd = (*it)->hardDisk();
5943 AutoLock hdLock (hd);
5944
5945 if(hd->isParentImmutable())
5946 {
5947 /// @todo (dmik) no error handling for now
5948 // (need async error reporting for this)
5949 hd->asVDI()->wipeOutImage();
5950 }
5951 }
5952
5953 return S_OK;
5954}
5955
5956/**
5957 * Fixes up lazy hard disk attachments by creating or deleting differencing
5958 * hard disks when machine settings are being committed.
5959 * Must be called only from #commit().
5960 *
5961 * @note Locks objects!
5962 */
5963HRESULT Machine::fixupHardDisks (bool aCommit)
5964{
5965 AutoCaller autoCaller (this);
5966 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
5967
5968 AutoLock alock (this);
5969
5970 /* no attac/detach operations -- nothing to do */
5971 if (!mHDData.isBackedUp())
5972 {
5973 mHDData->mHDAttachmentsChanged = false;
5974 return S_OK;
5975 }
5976
5977 AssertReturn (mData->mRegistered, E_FAIL);
5978
5979 if (aCommit)
5980 {
5981 /*
5982 * changes are being committed,
5983 * perform actual diff image creation, deletion etc.
5984 */
5985
5986 /* take a copy of backed up attachments (will modify it) */
5987 HDData::HDAttachmentList backedUp = mHDData.backedUpData()->mHDAttachments;
5988 /* list of new diffs created */
5989 std::list <ComObjPtr <HardDisk> > newDiffs;
5990
5991 HRESULT rc = S_OK;
5992
5993 /* go through current attachments */
5994 for (HDData::HDAttachmentList::const_iterator
5995 it = mHDData->mHDAttachments.begin();
5996 it != mHDData->mHDAttachments.end();
5997 ++ it)
5998 {
5999 ComObjPtr <HardDiskAttachment> hda = *it;
6000 ComObjPtr <HardDisk> hd = hda->hardDisk();
6001 AutoLock hdLock (hd);
6002
6003 if (!hda->isDirty())
6004 {
6005 /*
6006 * not dirty, therefore was either attached before backing up
6007 * or doesn't need any fixup (already fixed up); try to locate
6008 * this hard disk among backed up attachments and remove from
6009 * there to prevent it from being deassociated/deleted
6010 */
6011 HDData::HDAttachmentList::iterator oldIt;
6012 for (oldIt = backedUp.begin(); oldIt != backedUp.end(); ++ oldIt)
6013 if ((*oldIt)->hardDisk().equalsTo (hd))
6014 break;
6015 if (oldIt != backedUp.end())
6016 {
6017 /* remove from there */
6018 backedUp.erase (oldIt);
6019 Log3 (("FC: %ls found in old\n", hd->toString().raw()));
6020 }
6021 }
6022 else
6023 {
6024 /* dirty, determine what to do */
6025
6026 bool needDiff = false;
6027 bool searchAmongSnapshots = false;
6028
6029 switch (hd->type())
6030 {
6031 case HardDiskType_Immutable:
6032 {
6033 /* decrease readers increased in AttachHardDisk() */
6034 hd->releaseReader();
6035 Log3 (("FC: %ls released\n", hd->toString().raw()));
6036 /* indicate we need a diff (indirect attachment) */
6037 needDiff = true;
6038 break;
6039 }
6040 case HardDiskType_Writethrough:
6041 {
6042 /* reset the dirty flag */
6043 hda->updateHardDisk (hd, false /* aDirty */);
6044 Log3 (("FC: %ls updated\n", hd->toString().raw()));
6045 break;
6046 }
6047 case HardDiskType_Normal:
6048 {
6049 if (hd->snapshotId().isEmpty())
6050 {
6051 /* reset the dirty flag */
6052 hda->updateHardDisk (hd, false /* aDirty */);
6053 Log3 (("FC: %ls updated\n", hd->toString().raw()));
6054 }
6055 else
6056 {
6057 /* decrease readers increased in AttachHardDisk() */
6058 hd->releaseReader();
6059 Log3 (("FC: %ls released\n", hd->toString().raw()));
6060 /* indicate we need a diff (indirect attachment) */
6061 needDiff = true;
6062 /* search for the most recent base among snapshots */
6063 searchAmongSnapshots = true;
6064 }
6065 break;
6066 }
6067 }
6068
6069 if (!needDiff)
6070 continue;
6071
6072 bool createDiff = false;
6073
6074 /*
6075 * see whether any previously attached hard disk has the
6076 * the currently attached one (Normal or Independent) as
6077 * the root
6078 */
6079
6080 HDData::HDAttachmentList::iterator foundIt = backedUp.end();
6081
6082 for (HDData::HDAttachmentList::iterator it = backedUp.begin();
6083 it != backedUp.end();
6084 ++ it)
6085 {
6086 if ((*it)->hardDisk()->root().equalsTo (hd))
6087 {
6088 /*
6089 * matched dev and ctl (i.e. attached to the same place)
6090 * will win and immediately stop the search; otherwise
6091 * the first attachment that matched the hd only will
6092 * be used
6093 */
6094 if ((*it)->device() == hda->device() &&
6095 (*it)->channel() == hda->channel() &&
6096 (*it)->bus() == hda->bus())
6097 {
6098 foundIt = it;
6099 break;
6100 }
6101 else
6102 if (foundIt == backedUp.end())
6103 {
6104 /*
6105 * not an exact match; ensure there is no exact match
6106 * among other current attachments referring the same
6107 * root (to prevent this attachmend from reusing the
6108 * hard disk of the other attachment that will later
6109 * give the exact match or already gave it before)
6110 */
6111 bool canReuse = true;
6112 for (HDData::HDAttachmentList::const_iterator
6113 it2 = mHDData->mHDAttachments.begin();
6114 it2 != mHDData->mHDAttachments.end();
6115 ++ it2)
6116 {
6117 if ((*it2)->device() == (*it)->device() &&
6118 (*it2)->channel() == (*it)->channel() &&
6119 (*it2)->bus() == (*it)->bus() &&
6120 (*it2)->hardDisk()->root().equalsTo (hd))
6121 {
6122 /*
6123 * the exact match, either non-dirty or dirty
6124 * one refers the same root: in both cases
6125 * we cannot reuse the hard disk, so break
6126 */
6127 canReuse = false;
6128 break;
6129 }
6130 }
6131
6132 if (canReuse)
6133 foundIt = it;
6134 }
6135 }
6136 }
6137
6138 if (foundIt != backedUp.end())
6139 {
6140 /* found either one or another, reuse the diff */
6141 hda->updateHardDisk ((*foundIt)->hardDisk(),
6142 false /* aDirty */);
6143 Log3 (("FC: %ls reused as %ls\n", hd->toString().raw(),
6144 (*foundIt)->hardDisk()->toString().raw()));
6145 /* remove from there */
6146 backedUp.erase (foundIt);
6147 }
6148 else
6149 {
6150 /* was not attached, need a diff */
6151 createDiff = true;
6152 }
6153
6154 if (!createDiff)
6155 continue;
6156
6157 ComObjPtr <HardDisk> baseHd = hd;
6158
6159 if (searchAmongSnapshots)
6160 {
6161 /*
6162 * find the most recent diff based on the currently
6163 * attached root (Normal hard disk) among snapshots
6164 */
6165
6166 ComObjPtr <Snapshot> snap = mData->mCurrentSnapshot;
6167
6168 while (snap)
6169 {
6170 AutoLock snapLock (snap);
6171
6172 const HDData::HDAttachmentList &snapAtts =
6173 snap->data().mMachine->mHDData->mHDAttachments;
6174
6175 HDData::HDAttachmentList::const_iterator foundIt = snapAtts.end();
6176
6177 for (HDData::HDAttachmentList::const_iterator
6178 it = snapAtts.begin(); it != snapAtts.end(); ++ it)
6179 {
6180 if ((*it)->hardDisk()->root().equalsTo (hd))
6181 {
6182 /*
6183 * matched dev and ctl (i.e. attached to the same place)
6184 * will win and immediately stop the search; otherwise
6185 * the first attachment that matched the hd only will
6186 * be used
6187 */
6188 if ((*it)->device() == hda->device() &&
6189 (*it)->channel() == hda->channel() &&
6190 (*it)->bus() == hda->bus())
6191 {
6192 foundIt = it;
6193 break;
6194 }
6195 else
6196 if (foundIt == snapAtts.end())
6197 foundIt = it;
6198 }
6199 }
6200
6201 if (foundIt != snapAtts.end())
6202 {
6203 /* the most recent diff has been found, use as a base */
6204 baseHd = (*foundIt)->hardDisk();
6205 Log3 (("FC: %ls: recent found %ls\n",
6206 hd->toString().raw(), baseHd->toString().raw()));
6207 break;
6208 }
6209
6210 snap = snap->parent();
6211 }
6212 }
6213
6214 /* create a new diff for the hard disk being indirectly attached */
6215
6216 AutoLock baseHdLock (baseHd);
6217 baseHd->addReader();
6218
6219 ComObjPtr <HVirtualDiskImage> vdi;
6220 rc = baseHd->createDiffHardDisk (mUserData->mSnapshotFolderFull,
6221 mData->mUuid, vdi, NULL);
6222 baseHd->releaseReader();
6223 CheckComRCBreakRC (rc);
6224
6225 newDiffs.push_back (ComObjPtr <HardDisk> (vdi));
6226
6227 /* update the attachment and reset the dirty flag */
6228 hda->updateHardDisk (ComObjPtr <HardDisk> (vdi),
6229 false /* aDirty */);
6230 Log3 (("FC: %ls: diff created %ls\n",
6231 baseHd->toString().raw(), vdi->toString().raw()));
6232 }
6233 }
6234
6235 if (FAILED (rc))
6236 {
6237 /* delete diffs we created */
6238 for (std::list <ComObjPtr <HardDisk> >::const_iterator
6239 it = newDiffs.begin(); it != newDiffs.end(); ++ it)
6240 {
6241 /*
6242 * unregisterDiffHardDisk() is supposed to delete and uninit
6243 * the differencing hard disk
6244 */
6245 mParent->unregisterDiffHardDisk (*it);
6246 /* too bad if we fail here, but nothing to do, just continue */
6247 }
6248
6249 /* the best is to rollback the changes... */
6250 mHDData.rollback();
6251 mHDData->mHDAttachmentsChanged = false;
6252 Log3 (("FC: ROLLED BACK\n"));
6253 return rc;
6254 }
6255
6256 /*
6257 * go through the rest of old attachments and delete diffs
6258 * or deassociate hard disks from machines (they will become detached)
6259 */
6260 for (HDData::HDAttachmentList::iterator
6261 it = backedUp.begin(); it != backedUp.end(); ++ it)
6262 {
6263 ComObjPtr <HardDiskAttachment> hda = *it;
6264 ComObjPtr <HardDisk> hd = hda->hardDisk();
6265 AutoLock hdLock (hd);
6266
6267 if (hd->isDifferencing())
6268 {
6269 /*
6270 * unregisterDiffHardDisk() is supposed to delete and uninit
6271 * the differencing hard disk
6272 */
6273 Log3 (("FC: %ls diff deleted\n", hd->toString().raw()));
6274 rc = mParent->unregisterDiffHardDisk (hd);
6275 /*
6276 * too bad if we fail here, but nothing to do, just continue
6277 * (the last rc will be returned to the caller though)
6278 */
6279 }
6280 else
6281 {
6282 /* deassociate from this machine */
6283 Log3 (("FC: %ls deassociated\n", hd->toString().raw()));
6284 hd->setMachineId (Guid());
6285 }
6286 }
6287
6288 /* commit all the changes */
6289 mHDData->mHDAttachmentsChanged = mHDData.hasActualChanges();
6290 mHDData.commit();
6291 Log3 (("FC: COMMITTED\n"));
6292
6293 return rc;
6294 }
6295
6296 /*
6297 * changes are being rolled back,
6298 * go trhough all current attachments and fix up dirty ones
6299 * the way it is done in DetachHardDisk()
6300 */
6301
6302 for (HDData::HDAttachmentList::iterator it = mHDData->mHDAttachments.begin();
6303 it != mHDData->mHDAttachments.end();
6304 ++ it)
6305 {
6306 ComObjPtr <HardDiskAttachment> hda = *it;
6307 ComObjPtr <HardDisk> hd = hda->hardDisk();
6308 AutoLock hdLock (hd);
6309
6310 if (hda->isDirty())
6311 {
6312 switch (hd->type())
6313 {
6314 case HardDiskType_Immutable:
6315 {
6316 /* decrease readers increased in AttachHardDisk() */
6317 hd->releaseReader();
6318 Log3 (("FR: %ls released\n", hd->toString().raw()));
6319 break;
6320 }
6321 case HardDiskType_Writethrough:
6322 {
6323 /* deassociate from this machine */
6324 hd->setMachineId (Guid());
6325 Log3 (("FR: %ls deassociated\n", hd->toString().raw()));
6326 break;
6327 }
6328 case HardDiskType_Normal:
6329 {
6330 if (hd->snapshotId().isEmpty())
6331 {
6332 /* deassociate from this machine */
6333 hd->setMachineId (Guid());
6334 Log3 (("FR: %ls deassociated\n", hd->toString().raw()));
6335 }
6336 else
6337 {
6338 /* decrease readers increased in AttachHardDisk() */
6339 hd->releaseReader();
6340 Log3 (("FR: %ls released\n", hd->toString().raw()));
6341 }
6342
6343 break;
6344 }
6345 }
6346 }
6347 }
6348
6349 /* rollback all the changes */
6350 mHDData.rollback();
6351 Log3 (("FR: ROLLED BACK\n"));
6352
6353 return S_OK;
6354}
6355
6356/**
6357 * Creates differencing hard disks for all normal hard disks
6358 * and replaces attachments to refer to created disks.
6359 * Used when taking a snapshot or when discarding the current state.
6360 *
6361 * @param aSnapshotId ID of the snapshot being taken
6362 * or NULL if the current state is being discarded
6363 * @param aFolder folder where to create diff. hard disks
6364 * @param aProgress progress object to run (must contain at least as
6365 * many operations left as the number of VDIs attached)
6366 * @param aOnline whether the machine is online (i.e., when the EMT
6367 * thread is paused, OR when current hard disks are
6368 * marked as busy for some other reason)
6369 *
6370 * @note
6371 * The progress object is not marked as completed, neither on success
6372 * nor on failure. This is a responsibility of the caller.
6373 *
6374 * @note Locks mParent + this object for writing
6375 */
6376HRESULT Machine::createSnapshotDiffs (const Guid *aSnapshotId,
6377 const Bstr &aFolder,
6378 const ComObjPtr <Progress> &aProgress,
6379 bool aOnline)
6380{
6381 AssertReturn (!aFolder.isEmpty(), E_FAIL);
6382
6383 AutoCaller autoCaller (this);
6384 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
6385
6386 /* accessing mParent methods below needs mParent lock */
6387 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
6388
6389 HRESULT rc = S_OK;
6390
6391 // first pass: check accessibility before performing changes
6392 if (!aOnline)
6393 {
6394 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
6395 it != mHDData->mHDAttachments.end();
6396 ++ it)
6397 {
6398 ComObjPtr <HardDiskAttachment> hda = *it;
6399 ComObjPtr <HardDisk> hd = hda->hardDisk();
6400 AutoLock hdLock (hd);
6401
6402 ComAssertMsgBreak (hd->type() == HardDiskType_Normal,
6403 ("Invalid hard disk type %d\n", hd->type()),
6404 rc = E_FAIL);
6405
6406 ComAssertMsgBreak (!hd->isParentImmutable() ||
6407 hd->storageType() == HardDiskStorageType_VirtualDiskImage,
6408 ("Invalid hard disk storage type %d\n", hd->storageType()),
6409 rc = E_FAIL);
6410
6411 Bstr accessError;
6412 rc = hd->getAccessible (accessError);
6413 CheckComRCBreakRC (rc);
6414
6415 if (!accessError.isNull())
6416 {
6417 rc = setError (E_FAIL,
6418 tr ("Hard disk '%ls' is not accessible (%ls)"),
6419 hd->toString().raw(), accessError.raw());
6420 break;
6421 }
6422 }
6423 CheckComRCReturnRC (rc);
6424 }
6425
6426 HDData::HDAttachmentList attachments;
6427
6428 // second pass: perform changes
6429 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
6430 it != mHDData->mHDAttachments.end();
6431 ++ it)
6432 {
6433 ComObjPtr <HardDiskAttachment> hda = *it;
6434 ComObjPtr <HardDisk> hd = hda->hardDisk();
6435 AutoLock hdLock (hd);
6436
6437 ComObjPtr <HardDisk> parent = hd->parent();
6438 AutoLock parentHdLock (parent);
6439
6440 ComObjPtr <HardDisk> newHd;
6441
6442 // clear busy flag if the VM is online
6443 if (aOnline)
6444 hd->clearBusy();
6445 // increase readers
6446 hd->addReader();
6447
6448 if (hd->isParentImmutable())
6449 {
6450 aProgress->advanceOperation (Bstr (Utf8StrFmt (
6451 tr ("Preserving immutable hard disk '%ls'"),
6452 parent->toString (true /* aShort */).raw())));
6453
6454 parentHdLock.unlock();
6455 alock.leave();
6456
6457 // create a copy of the independent diff
6458 ComObjPtr <HVirtualDiskImage> vdi;
6459 rc = hd->asVDI()->cloneDiffImage (aFolder, mData->mUuid, vdi,
6460 aProgress);
6461 newHd = vdi;
6462
6463 alock.enter();
6464 parentHdLock.lock();
6465
6466 // decrease readers (hd is no more used for reading in any case)
6467 hd->releaseReader();
6468 }
6469 else
6470 {
6471 // checked in the first pass
6472 Assert (hd->type() == HardDiskType_Normal);
6473
6474 aProgress->advanceOperation (Bstr (Utf8StrFmt (
6475 tr ("Creating a differencing hard disk for '%ls'"),
6476 hd->root()->toString (true /* aShort */).raw())));
6477
6478 parentHdLock.unlock();
6479 alock.leave();
6480
6481 // create a new diff for the image being attached
6482 ComObjPtr <HVirtualDiskImage> vdi;
6483 rc = hd->createDiffHardDisk (aFolder, mData->mUuid, vdi, aProgress);
6484 newHd = vdi;
6485
6486 alock.enter();
6487 parentHdLock.lock();
6488
6489 if (SUCCEEDED (rc))
6490 {
6491 // if online, hd must keep a reader referece
6492 if (!aOnline)
6493 hd->releaseReader();
6494 }
6495 else
6496 {
6497 // decrease readers
6498 hd->releaseReader();
6499 }
6500 }
6501
6502 if (SUCCEEDED (rc))
6503 {
6504 ComObjPtr <HardDiskAttachment> newHda;
6505 newHda.createObject();
6506 rc = newHda->init (newHd, hda->bus(), hda->channel(), hda->device(),
6507 false /* aDirty */);
6508
6509 if (SUCCEEDED (rc))
6510 {
6511 // associate the snapshot id with the old hard disk
6512 if (hd->type() != HardDiskType_Writethrough && aSnapshotId)
6513 hd->setSnapshotId (*aSnapshotId);
6514
6515 // add the new attachment
6516 attachments.push_back (newHda);
6517
6518 // if online, newHd must be marked as busy
6519 if (aOnline)
6520 newHd->setBusy();
6521 }
6522 }
6523
6524 if (FAILED (rc))
6525 {
6526 // set busy flag back if the VM is online
6527 if (aOnline)
6528 hd->setBusy();
6529 break;
6530 }
6531 }
6532
6533 if (SUCCEEDED (rc))
6534 {
6535 // replace the whole list of attachments with the new one
6536 mHDData->mHDAttachments = attachments;
6537 }
6538 else
6539 {
6540 // delete those diffs we've just created
6541 for (HDData::HDAttachmentList::const_iterator it = attachments.begin();
6542 it != attachments.end();
6543 ++ it)
6544 {
6545 ComObjPtr <HardDisk> hd = (*it)->hardDisk();
6546 AutoLock hdLock (hd);
6547 Assert (hd->children().size() == 0);
6548 Assert (hd->isDifferencing());
6549 // unregisterDiffHardDisk() is supposed to delete and uninit
6550 // the differencing hard disk
6551 mParent->unregisterDiffHardDisk (hd);
6552 }
6553 }
6554
6555 return rc;
6556}
6557
6558/**
6559 * Deletes differencing hard disks created by createSnapshotDiffs() in case
6560 * if snapshot creation was failed.
6561 *
6562 * @param aSnapshot failed snapshot
6563 *
6564 * @note Locks mParent + this object for writing.
6565 */
6566HRESULT Machine::deleteSnapshotDiffs (const ComObjPtr <Snapshot> &aSnapshot)
6567{
6568 AssertReturn (!aSnapshot.isNull(), E_FAIL);
6569
6570 AutoCaller autoCaller (this);
6571 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
6572
6573 /* accessing mParent methods below needs mParent lock */
6574 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
6575
6576 /* short cut: check whether attachments are all the same */
6577 if (mHDData->mHDAttachments == aSnapshot->data().mMachine->mHDData->mHDAttachments)
6578 return S_OK;
6579
6580 HRESULT rc = S_OK;
6581
6582 for (HDData::HDAttachmentList::const_iterator it = mHDData->mHDAttachments.begin();
6583 it != mHDData->mHDAttachments.end();
6584 ++ it)
6585 {
6586 ComObjPtr <HardDiskAttachment> hda = *it;
6587 ComObjPtr <HardDisk> hd = hda->hardDisk();
6588 AutoLock hdLock (hd);
6589
6590 ComObjPtr <HardDisk> parent = hd->parent();
6591 AutoLock parentHdLock (parent);
6592
6593 if (!parent || parent->snapshotId() != aSnapshot->data().mId)
6594 continue;
6595
6596 /* must not have children */
6597 ComAssertRet (hd->children().size() == 0, E_FAIL);
6598
6599 /* deassociate the old hard disk from the given snapshot's ID */
6600 parent->setSnapshotId (Guid());
6601
6602 /* unregisterDiffHardDisk() is supposed to delete and uninit
6603 * the differencing hard disk */
6604 rc = mParent->unregisterDiffHardDisk (hd);
6605 /* continue on error */
6606 }
6607
6608 /* restore the whole list of attachments from the failed snapshot */
6609 mHDData->mHDAttachments = aSnapshot->data().mMachine->mHDData->mHDAttachments;
6610
6611 return rc;
6612}
6613
6614/**
6615 * Helper to lock the machine configuration for write access.
6616 *
6617 * @return S_OK or E_FAIL and sets error info on failure
6618 *
6619 * @note Doesn't lock anything (must be called from this object's lock)
6620 */
6621HRESULT Machine::lockConfig()
6622{
6623 HRESULT rc = S_OK;
6624
6625 if (!isConfigLocked())
6626 {
6627 /* open the associated config file */
6628 int vrc = RTFileOpen (&mData->mHandleCfgFile,
6629 Utf8Str (mData->mConfigFileFull),
6630 RTFILE_O_READWRITE | RTFILE_O_OPEN |
6631 RTFILE_O_DENY_WRITE);
6632 if (VBOX_FAILURE (vrc))
6633 mData->mHandleCfgFile = NIL_RTFILE;
6634 }
6635
6636 LogFlowThisFunc (("mConfigFile={%ls}, mHandleCfgFile=%d, rc=%08X\n",
6637 mData->mConfigFileFull.raw(), mData->mHandleCfgFile, rc));
6638 return rc;
6639}
6640
6641/**
6642 * Helper to unlock the machine configuration from write access
6643 *
6644 * @return S_OK
6645 *
6646 * @note Doesn't lock anything.
6647 * @note Not thread safe (must be called from this object's lock).
6648 */
6649HRESULT Machine::unlockConfig()
6650{
6651 HRESULT rc = S_OK;
6652
6653 if (isConfigLocked())
6654 {
6655 RTFileFlush(mData->mHandleCfgFile);
6656 RTFileClose(mData->mHandleCfgFile);
6657 /** @todo flush the directory. */
6658 mData->mHandleCfgFile = NIL_RTFILE;
6659 }
6660
6661 LogFlowThisFunc (("\n"));
6662
6663 return rc;
6664}
6665
6666/**
6667 * Returns true if the settings file is located in the directory named exactly
6668 * as the machine. This will be true if the machine settings structure was
6669 * created by default in #openConfigLoader().
6670 *
6671 * @param aSettingsDir if not NULL, the full machine settings file directory
6672 * name will be assigned there.
6673 *
6674 * @note Doesn't lock anything.
6675 * @note Not thread safe (must be called from this object's lock).
6676 */
6677bool Machine::isInOwnDir (Utf8Str *aSettingsDir /* = NULL */)
6678{
6679 Utf8Str settingsDir = mData->mConfigFileFull;
6680 RTPathStripFilename (settingsDir.mutableRaw());
6681 char *dirName = RTPathFilename (settingsDir);
6682
6683 AssertReturn (dirName, false);
6684
6685 /* if we don't rename anything on name change, return false shorlty */
6686 if (!mUserData->mNameSync)
6687 return false;
6688
6689 if (aSettingsDir)
6690 *aSettingsDir = settingsDir;
6691
6692 return Bstr (dirName) == mUserData->mName;
6693}
6694
6695/**
6696 * @note Locks objects for reading!
6697 */
6698bool Machine::isModified()
6699{
6700 AutoCaller autoCaller (this);
6701 AssertComRCReturn (autoCaller.rc(), false);
6702
6703 AutoReaderLock alock (this);
6704
6705 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
6706 if (mNetworkAdapters [slot] && mNetworkAdapters [slot]->isModified())
6707 return true;
6708
6709 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
6710 if (mSerialPorts [slot] && mSerialPorts [slot]->isModified())
6711 return true;
6712
6713 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
6714 if (mParallelPorts [slot] && mParallelPorts [slot]->isModified())
6715 return true;
6716
6717 return
6718 mUserData.isBackedUp() ||
6719 mHWData.isBackedUp() ||
6720 mHDData.isBackedUp() ||
6721#ifdef VBOX_VRDP
6722 (mVRDPServer && mVRDPServer->isModified()) ||
6723#endif
6724 (mDVDDrive && mDVDDrive->isModified()) ||
6725 (mFloppyDrive && mFloppyDrive->isModified()) ||
6726 (mAudioAdapter && mAudioAdapter->isModified()) ||
6727 (mUSBController && mUSBController->isModified()) ||
6728 (mSATAController && mSATAController->isModified()) ||
6729 (mBIOSSettings && mBIOSSettings->isModified());
6730}
6731
6732/**
6733 * @note This method doesn't check (ignores) actual changes to mHDData.
6734 * Use mHDData.mHDAttachmentsChanged right after #commit() instead.
6735 *
6736 * @param aIgnoreUserData |true| to ignore changes to mUserData
6737 *
6738 * @note Locks objects for reading!
6739 */
6740bool Machine::isReallyModified (bool aIgnoreUserData /* = false */)
6741{
6742 AutoCaller autoCaller (this);
6743 AssertComRCReturn (autoCaller.rc(), false);
6744
6745 AutoReaderLock alock (this);
6746
6747 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
6748 if (mNetworkAdapters [slot] && mNetworkAdapters [slot]->isReallyModified())
6749 return true;
6750
6751 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
6752 if (mSerialPorts [slot] && mSerialPorts [slot]->isReallyModified())
6753 return true;
6754
6755 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
6756 if (mParallelPorts [slot] && mParallelPorts [slot]->isReallyModified())
6757 return true;
6758
6759 return
6760 (!aIgnoreUserData && mUserData.hasActualChanges()) ||
6761 mHWData.hasActualChanges() ||
6762 /* ignore mHDData */
6763 //mHDData.hasActualChanges() ||
6764#ifdef VBOX_VRDP
6765 (mVRDPServer && mVRDPServer->isReallyModified()) ||
6766#endif
6767 (mDVDDrive && mDVDDrive->isReallyModified()) ||
6768 (mFloppyDrive && mFloppyDrive->isReallyModified()) ||
6769 (mAudioAdapter && mAudioAdapter->isReallyModified()) ||
6770 (mUSBController && mUSBController->isReallyModified()) ||
6771 (mSATAController && mSATAController->isReallyModified()) ||
6772 (mBIOSSettings && mBIOSSettings->isReallyModified());
6773}
6774
6775/**
6776 * Discards all changes to machine settings.
6777 *
6778 * @param aNotify whether to notify the direct session about changes or not
6779 *
6780 * @note Locks objects!
6781 */
6782void Machine::rollback (bool aNotify)
6783{
6784 AutoCaller autoCaller (this);
6785 AssertComRCReturn (autoCaller.rc(), (void) 0);
6786
6787 AutoLock alock (this);
6788
6789 /* check for changes in own data */
6790
6791 bool sharedFoldersChanged = false;
6792
6793 if (aNotify && mHWData.isBackedUp())
6794 {
6795 if (mHWData->mSharedFolders.size() !=
6796 mHWData.backedUpData()->mSharedFolders.size())
6797 sharedFoldersChanged = true;
6798 else
6799 {
6800 for (HWData::SharedFolderList::iterator rit =
6801 mHWData->mSharedFolders.begin();
6802 rit != mHWData->mSharedFolders.end() && !sharedFoldersChanged;
6803 ++ rit)
6804 {
6805 for (HWData::SharedFolderList::iterator cit =
6806 mHWData.backedUpData()->mSharedFolders.begin();
6807 cit != mHWData.backedUpData()->mSharedFolders.end();
6808 ++ cit)
6809 {
6810 if ((*cit)->name() != (*rit)->name() ||
6811 (*cit)->hostPath() != (*rit)->hostPath())
6812 {
6813 sharedFoldersChanged = true;
6814 break;
6815 }
6816 }
6817 }
6818 }
6819 }
6820
6821 mUserData.rollback();
6822
6823 mHWData.rollback();
6824
6825 if (mHDData.isBackedUp())
6826 fixupHardDisks (false /* aCommit */);
6827
6828 /* check for changes in child objects */
6829
6830 bool vrdpChanged = false, dvdChanged = false, floppyChanged = false,
6831 usbChanged = false, sataChanged = false;
6832
6833 ComPtr <INetworkAdapter> networkAdapters [ELEMENTS (mNetworkAdapters)];
6834 ComPtr <ISerialPort> serialPorts [ELEMENTS (mSerialPorts)];
6835 ComPtr <IParallelPort> parallelPorts [ELEMENTS (mParallelPorts)];
6836
6837 if (mBIOSSettings)
6838 mBIOSSettings->rollback();
6839
6840#ifdef VBOX_VRDP
6841 if (mVRDPServer)
6842 vrdpChanged = mVRDPServer->rollback();
6843#endif
6844
6845 if (mDVDDrive)
6846 dvdChanged = mDVDDrive->rollback();
6847
6848 if (mFloppyDrive)
6849 floppyChanged = mFloppyDrive->rollback();
6850
6851 if (mAudioAdapter)
6852 mAudioAdapter->rollback();
6853
6854 if (mUSBController)
6855 usbChanged = mUSBController->rollback();
6856
6857 if (mSATAController)
6858 sataChanged = mSATAController->rollback();
6859
6860 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
6861 if (mNetworkAdapters [slot])
6862 if (mNetworkAdapters [slot]->rollback())
6863 networkAdapters [slot] = mNetworkAdapters [slot];
6864
6865 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
6866 if (mSerialPorts [slot])
6867 if (mSerialPorts [slot]->rollback())
6868 serialPorts [slot] = mSerialPorts [slot];
6869
6870 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
6871 if (mParallelPorts [slot])
6872 if (mParallelPorts [slot]->rollback())
6873 parallelPorts [slot] = mParallelPorts [slot];
6874
6875 if (aNotify)
6876 {
6877 /* inform the direct session about changes */
6878
6879 ComObjPtr <Machine> that = this;
6880 alock.leave();
6881
6882 if (sharedFoldersChanged)
6883 that->onSharedFolderChange();
6884
6885 if (vrdpChanged)
6886 that->onVRDPServerChange();
6887 if (dvdChanged)
6888 that->onDVDDriveChange();
6889 if (floppyChanged)
6890 that->onFloppyDriveChange();
6891 if (usbChanged)
6892 that->onUSBControllerChange();
6893 if (sataChanged)
6894 that->onSATAControllerChange();
6895
6896 for (ULONG slot = 0; slot < ELEMENTS (networkAdapters); slot ++)
6897 if (networkAdapters [slot])
6898 that->onNetworkAdapterChange (networkAdapters [slot]);
6899 for (ULONG slot = 0; slot < ELEMENTS (serialPorts); slot ++)
6900 if (serialPorts [slot])
6901 that->onSerialPortChange (serialPorts [slot]);
6902 for (ULONG slot = 0; slot < ELEMENTS (parallelPorts); slot ++)
6903 if (parallelPorts [slot])
6904 that->onParallelPortChange (parallelPorts [slot]);
6905 }
6906}
6907
6908/**
6909 * Commits all the changes to machine settings.
6910 *
6911 * Note that when committing fails at some stage, it still continues
6912 * until the end. So, all data will either be actually committed or rolled
6913 * back (for failed cases) and the returned result code will describe the
6914 * first failure encountered. However, #isModified() will still return true
6915 * in case of failure, to indicade that settings in memory and on disk are
6916 * out of sync.
6917 *
6918 * @note Locks objects!
6919 */
6920HRESULT Machine::commit()
6921{
6922 AutoCaller autoCaller (this);
6923 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
6924
6925 AutoLock alock (this);
6926
6927 HRESULT rc = S_OK;
6928
6929 /*
6930 * use safe commit to ensure Snapshot machines (that share mUserData)
6931 * will still refer to a valid memory location
6932 */
6933 mUserData.commitCopy();
6934
6935 mHWData.commit();
6936
6937 if (mHDData.isBackedUp())
6938 rc = fixupHardDisks (true /* aCommit */);
6939
6940 mBIOSSettings->commit();
6941#ifdef VBOX_VRDP
6942 mVRDPServer->commit();
6943#endif
6944 mDVDDrive->commit();
6945 mFloppyDrive->commit();
6946 mAudioAdapter->commit();
6947 mUSBController->commit();
6948 mSATAController->commit();
6949
6950 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
6951 mNetworkAdapters [slot]->commit();
6952 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
6953 mSerialPorts [slot]->commit();
6954 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
6955 mParallelPorts [slot]->commit();
6956
6957 if (mType == IsSessionMachine)
6958 {
6959 /* attach new data to the primary machine and reshare it */
6960 mPeer->mUserData.attach (mUserData);
6961 mPeer->mHWData.attach (mHWData);
6962 mPeer->mHDData.attach (mHDData);
6963 }
6964
6965 if (FAILED (rc))
6966 {
6967 /*
6968 * backup arbitrary data item to cause #isModified() to still return
6969 * true in case of any error
6970 */
6971 mHWData.backup();
6972 }
6973
6974 return rc;
6975}
6976
6977/**
6978 * Copies all the hardware data from the given machine.
6979 *
6980 * @note
6981 * This method must be called from under this object's lock.
6982 * @note
6983 * This method doesn't call #commit(), so all data remains backed up
6984 * and unsaved.
6985 */
6986void Machine::copyFrom (Machine *aThat)
6987{
6988 AssertReturn (mType == IsMachine || mType == IsSessionMachine, (void) 0);
6989 AssertReturn (aThat->mType == IsSnapshotMachine, (void) 0);
6990
6991 mHWData.assignCopy (aThat->mHWData);
6992
6993 // create copies of all shared folders (mHWData after attiching a copy
6994 // contains just references to original objects)
6995 for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
6996 it != mHWData->mSharedFolders.end();
6997 ++ it)
6998 {
6999 ComObjPtr <SharedFolder> folder;
7000 folder.createObject();
7001 HRESULT rc = folder->initCopy (machine(), *it);
7002 AssertComRC (rc);
7003 *it = folder;
7004 }
7005
7006 mBIOSSettings->copyFrom (aThat->mBIOSSettings);
7007#ifdef VBOX_VRDP
7008 mVRDPServer->copyFrom (aThat->mVRDPServer);
7009#endif
7010 mDVDDrive->copyFrom (aThat->mDVDDrive);
7011 mFloppyDrive->copyFrom (aThat->mFloppyDrive);
7012 mAudioAdapter->copyFrom (aThat->mAudioAdapter);
7013 mUSBController->copyFrom (aThat->mUSBController);
7014 mSATAController->copyFrom (aThat->mSATAController);
7015
7016 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
7017 mNetworkAdapters [slot]->copyFrom (aThat->mNetworkAdapters [slot]);
7018 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
7019 mSerialPorts [slot]->copyFrom (aThat->mSerialPorts [slot]);
7020 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
7021 mParallelPorts [slot]->copyFrom (aThat->mParallelPorts [slot]);
7022}
7023
7024/////////////////////////////////////////////////////////////////////////////
7025// SessionMachine class
7026/////////////////////////////////////////////////////////////////////////////
7027
7028/** Task structure for asynchronous VM operations */
7029struct SessionMachine::Task
7030{
7031 Task (SessionMachine *m, Progress *p)
7032 : machine (m), progress (p)
7033 , state (m->mData->mMachineState) // save the current machine state
7034 , subTask (false), settingsChanged (false)
7035 {}
7036
7037 void modifyLastState (MachineState_T s)
7038 {
7039 *const_cast <MachineState_T *> (&state) = s;
7040 }
7041
7042 virtual void handler() = 0;
7043
7044 const ComObjPtr <SessionMachine> machine;
7045 const ComObjPtr <Progress> progress;
7046 const MachineState_T state;
7047
7048 bool subTask : 1;
7049 bool settingsChanged : 1;
7050};
7051
7052/** Take snapshot task */
7053struct SessionMachine::TakeSnapshotTask : public SessionMachine::Task
7054{
7055 TakeSnapshotTask (SessionMachine *m)
7056 : Task (m, NULL) {}
7057
7058 void handler() { machine->takeSnapshotHandler (*this); }
7059};
7060
7061/** Discard snapshot task */
7062struct SessionMachine::DiscardSnapshotTask : public SessionMachine::Task
7063{
7064 DiscardSnapshotTask (SessionMachine *m, Progress *p, Snapshot *s)
7065 : Task (m, p)
7066 , snapshot (s) {}
7067
7068 DiscardSnapshotTask (const Task &task, Snapshot *s)
7069 : Task (task)
7070 , snapshot (s) {}
7071
7072 void handler() { machine->discardSnapshotHandler (*this); }
7073
7074 const ComObjPtr <Snapshot> snapshot;
7075};
7076
7077/** Discard current state task */
7078struct SessionMachine::DiscardCurrentStateTask : public SessionMachine::Task
7079{
7080 DiscardCurrentStateTask (SessionMachine *m, Progress *p,
7081 bool discardCurSnapshot)
7082 : Task (m, p), discardCurrentSnapshot (discardCurSnapshot) {}
7083
7084 void handler() { machine->discardCurrentStateHandler (*this); }
7085
7086 const bool discardCurrentSnapshot;
7087};
7088
7089////////////////////////////////////////////////////////////////////////////////
7090
7091DEFINE_EMPTY_CTOR_DTOR (SessionMachine)
7092
7093HRESULT SessionMachine::FinalConstruct()
7094{
7095 LogFlowThisFunc (("\n"));
7096
7097 /* set the proper type to indicate we're the SessionMachine instance */
7098 unconst (mType) = IsSessionMachine;
7099
7100#if defined(RT_OS_WINDOWS)
7101 mIPCSem = NULL;
7102#elif defined(RT_OS_OS2)
7103 mIPCSem = NULLHANDLE;
7104#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
7105 mIPCSem = -1;
7106#else
7107# error "Port me!"
7108#endif
7109
7110 return S_OK;
7111}
7112
7113void SessionMachine::FinalRelease()
7114{
7115 LogFlowThisFunc (("\n"));
7116
7117 uninit (Uninit::Unexpected);
7118}
7119
7120/**
7121 * @note Must be called only by Machine::openSession() from its own write lock.
7122 */
7123HRESULT SessionMachine::init (Machine *aMachine)
7124{
7125 LogFlowThisFuncEnter();
7126 LogFlowThisFunc (("mName={%ls}\n", aMachine->mUserData->mName.raw()));
7127
7128 AssertReturn (aMachine, E_INVALIDARG);
7129
7130 AssertReturn (aMachine->lockHandle()->isLockedOnCurrentThread(), E_FAIL);
7131
7132 /* Enclose the state transition NotReady->InInit->Ready */
7133 AutoInitSpan autoInitSpan (this);
7134 AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
7135
7136 /* create the interprocess semaphore */
7137#if defined(RT_OS_WINDOWS)
7138 mIPCSemName = aMachine->mData->mConfigFileFull;
7139 for (size_t i = 0; i < mIPCSemName.length(); i++)
7140 if (mIPCSemName[i] == '\\')
7141 mIPCSemName[i] = '/';
7142 mIPCSem = ::CreateMutex (NULL, FALSE, mIPCSemName);
7143 ComAssertMsgRet (mIPCSem,
7144 ("Cannot create IPC mutex '%ls', err=%d\n",
7145 mIPCSemName.raw(), ::GetLastError()),
7146 E_FAIL);
7147#elif defined(RT_OS_OS2)
7148 Utf8Str ipcSem = Utf8StrFmt ("\\SEM32\\VBOX\\VM\\{%Vuuid}",
7149 aMachine->mData->mUuid.raw());
7150 mIPCSemName = ipcSem;
7151 APIRET arc = ::DosCreateMutexSem ((PSZ) ipcSem.raw(), &mIPCSem, 0, FALSE);
7152 ComAssertMsgRet (arc == NO_ERROR,
7153 ("Cannot create IPC mutex '%s', arc=%ld\n",
7154 ipcSem.raw(), arc),
7155 E_FAIL);
7156#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
7157 Utf8Str configFile = aMachine->mData->mConfigFileFull;
7158 char *configFileCP = NULL;
7159 int error;
7160 RTStrUtf8ToCurrentCP (&configFileCP, configFile);
7161 key_t key = ::ftok (configFileCP, 0);
7162 RTStrFree (configFileCP);
7163 mIPCSem = ::semget (key, 1, S_IRWXU | S_IRWXG | S_IRWXO | IPC_CREAT);
7164 error = errno;
7165 if (mIPCSem < 0 && error == ENOSYS)
7166 {
7167 setError(E_FAIL,
7168 tr ("Cannot create IPC semaphore. Most likely your host kernel lacks "
7169 "support for SysV IPC. Check the host kernel configuration for "
7170 "CONFIG_SYSVIPC=y"));
7171 return E_FAIL;
7172 }
7173 ComAssertMsgRet (mIPCSem >= 0, ("Cannot create IPC semaphore, errno=%d", error),
7174 E_FAIL);
7175 /* set the initial value to 1 */
7176 int rv = ::semctl (mIPCSem, 0, SETVAL, 1);
7177 ComAssertMsgRet (rv == 0, ("Cannot init IPC semaphore, errno=%d", errno),
7178 E_FAIL);
7179#else
7180# error "Port me!"
7181#endif
7182
7183 /* memorize the peer Machine */
7184 unconst (mPeer) = aMachine;
7185 /* share the parent pointer */
7186 unconst (mParent) = aMachine->mParent;
7187
7188 /* take the pointers to data to share */
7189 mData.share (aMachine->mData);
7190 mSSData.share (aMachine->mSSData);
7191
7192 mUserData.share (aMachine->mUserData);
7193 mHWData.share (aMachine->mHWData);
7194 mHDData.share (aMachine->mHDData);
7195
7196 unconst (mBIOSSettings).createObject();
7197 mBIOSSettings->init (this, aMachine->mBIOSSettings);
7198#ifdef VBOX_VRDP
7199 /* create another VRDPServer object that will be mutable */
7200 unconst (mVRDPServer).createObject();
7201 mVRDPServer->init (this, aMachine->mVRDPServer);
7202#endif
7203 /* create another DVD drive object that will be mutable */
7204 unconst (mDVDDrive).createObject();
7205 mDVDDrive->init (this, aMachine->mDVDDrive);
7206 /* create another floppy drive object that will be mutable */
7207 unconst (mFloppyDrive).createObject();
7208 mFloppyDrive->init (this, aMachine->mFloppyDrive);
7209 /* create another audio adapter object that will be mutable */
7210 unconst (mAudioAdapter).createObject();
7211 mAudioAdapter->init (this, aMachine->mAudioAdapter);
7212 /* create a list of serial ports that will be mutable */
7213 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
7214 {
7215 unconst (mSerialPorts [slot]).createObject();
7216 mSerialPorts [slot]->init (this, aMachine->mSerialPorts [slot]);
7217 }
7218 /* create a list of parallel ports that will be mutable */
7219 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
7220 {
7221 unconst (mParallelPorts [slot]).createObject();
7222 mParallelPorts [slot]->init (this, aMachine->mParallelPorts [slot]);
7223 }
7224 /* create another USB controller object that will be mutable */
7225 unconst (mUSBController).createObject();
7226 mUSBController->init (this, aMachine->mUSBController);
7227 /* create another SATA controller object that will be mutable */
7228 unconst (mSATAController).createObject();
7229 mSATAController->init (this, aMachine->mSATAController);
7230 /* create a list of network adapters that will be mutable */
7231 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
7232 {
7233 unconst (mNetworkAdapters [slot]).createObject();
7234 mNetworkAdapters [slot]->init (this, aMachine->mNetworkAdapters [slot]);
7235 }
7236
7237 /* Confirm a successful initialization when it's the case */
7238 autoInitSpan.setSucceeded();
7239
7240 LogFlowThisFuncLeave();
7241 return S_OK;
7242}
7243
7244/**
7245 * Uninitializes this session object. If the reason is other than
7246 * Uninit::Unexpected, then this method MUST be called from #checkForDeath().
7247 *
7248 * @param aReason uninitialization reason
7249 *
7250 * @note Locks mParent + this object for writing.
7251 */
7252void SessionMachine::uninit (Uninit::Reason aReason)
7253{
7254 LogFlowThisFuncEnter();
7255 LogFlowThisFunc (("reason=%d\n", aReason));
7256
7257 /*
7258 * Strongly reference ourselves to prevent this object deletion after
7259 * mData->mSession.mMachine.setNull() below (which can release the last
7260 * reference and call the destructor). Important: this must be done before
7261 * accessing any members (and before AutoUninitSpan that does it as well).
7262 * This self reference will be released as the very last step on return.
7263 */
7264 ComObjPtr <SessionMachine> selfRef = this;
7265
7266 /* Enclose the state transition Ready->InUninit->NotReady */
7267 AutoUninitSpan autoUninitSpan (this);
7268 if (autoUninitSpan.uninitDone())
7269 {
7270 LogFlowThisFunc (("Already uninitialized\n"));
7271 LogFlowThisFuncLeave();
7272 return;
7273 }
7274
7275 if (autoUninitSpan.initFailed())
7276 {
7277 /*
7278 * We've been called by init() because it's failed. It's not really
7279 * necessary (nor it's safe) to perform the regular uninit sequence
7280 * below, the following is enough.
7281 */
7282 LogFlowThisFunc (("Initialization failed.\n"));
7283#if defined(RT_OS_WINDOWS)
7284 if (mIPCSem)
7285 ::CloseHandle (mIPCSem);
7286 mIPCSem = NULL;
7287#elif defined(RT_OS_OS2)
7288 if (mIPCSem != NULLHANDLE)
7289 ::DosCloseMutexSem (mIPCSem);
7290 mIPCSem = NULLHANDLE;
7291#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
7292 if (mIPCSem >= 0)
7293 ::semctl (mIPCSem, 0, IPC_RMID);
7294 mIPCSem = -1;
7295#else
7296# error "Port me!"
7297#endif
7298 uninitDataAndChildObjects();
7299 mData.free();
7300 unconst (mParent).setNull();
7301 unconst (mPeer).setNull();
7302 LogFlowThisFuncLeave();
7303 return;
7304 }
7305
7306 /*
7307 * We need to lock this object in uninit() because the lock is shared
7308 * with mPeer (as well as data we modify below).
7309 * mParent->addProcessToReap() and others need mParent lock.
7310 */
7311 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
7312
7313 MachineState_T lastState = mData->mMachineState;
7314
7315 if (aReason == Uninit::Abnormal)
7316 {
7317 LogWarningThisFunc (("ABNORMAL client termination! (wasRunning=%d)\n",
7318 lastState >= MachineState_Running));
7319
7320 /* reset the state to Aborted */
7321 if (mData->mMachineState != MachineState_Aborted)
7322 setMachineState (MachineState_Aborted);
7323 }
7324
7325 if (isModified())
7326 {
7327 LogWarningThisFunc (("Discarding unsaved settings changes!\n"));
7328 rollback (false /* aNotify */);
7329 }
7330
7331 Assert (!mSnapshotData.mStateFilePath || !mSnapshotData.mSnapshot);
7332 if (mSnapshotData.mStateFilePath)
7333 {
7334 LogWarningThisFunc (("canceling failed save state request!\n"));
7335 endSavingState (FALSE /* aSuccess */);
7336 }
7337 else if (!!mSnapshotData.mSnapshot)
7338 {
7339 LogWarningThisFunc (("canceling untaken snapshot!\n"));
7340 endTakingSnapshot (FALSE /* aSuccess */);
7341 }
7342
7343 /* release all captured USB devices */
7344 if (aReason == Uninit::Abnormal && lastState >= MachineState_Running)
7345 {
7346 /* Console::captureUSBDevices() is called in the VM process only after
7347 * setting the machine state to Starting or Restoring.
7348 * Console::detachAllUSBDevices() will be called upon successful
7349 * termination. So, we need to release USB devices only if there was
7350 * an abnormal termination of a running VM. */
7351 DetachAllUSBDevices (TRUE /* aDone */);
7352 }
7353
7354 if (!mData->mSession.mType.isNull())
7355 {
7356 /* mType is not null when this machine's process has been started by
7357 * VirtualBox::OpenRemoteSession(), therefore it is our child. We
7358 * need to queue the PID to reap the process (and avoid zombies on
7359 * Linux). */
7360 Assert (mData->mSession.mPid != NIL_RTPROCESS);
7361 mParent->addProcessToReap (mData->mSession.mPid);
7362 }
7363
7364 mData->mSession.mPid = NIL_RTPROCESS;
7365
7366 if (aReason == Uninit::Unexpected)
7367 {
7368 /* Uninitialization didn't come from #checkForDeath(), so tell the
7369 * client watcher thread to update the set of machines that have open
7370 * sessions. */
7371 mParent->updateClientWatcher();
7372 }
7373
7374 /* uninitialize all remote controls */
7375 if (mData->mSession.mRemoteControls.size())
7376 {
7377 LogFlowThisFunc (("Closing remote sessions (%d):\n",
7378 mData->mSession.mRemoteControls.size()));
7379
7380 Data::Session::RemoteControlList::iterator it =
7381 mData->mSession.mRemoteControls.begin();
7382 while (it != mData->mSession.mRemoteControls.end())
7383 {
7384 LogFlowThisFunc ((" Calling remoteControl->Uninitialize()...\n"));
7385 HRESULT rc = (*it)->Uninitialize();
7386 LogFlowThisFunc ((" remoteControl->Uninitialize() returned %08X\n", rc));
7387 if (FAILED (rc))
7388 LogWarningThisFunc (("Forgot to close the remote session?\n"));
7389 ++ it;
7390 }
7391 mData->mSession.mRemoteControls.clear();
7392 }
7393
7394 /*
7395 * An expected uninitialization can come only from #checkForDeath().
7396 * Otherwise it means that something's got really wrong (for examlple,
7397 * the Session implementation has released the VirtualBox reference
7398 * before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
7399 * etc). However, it's also possible, that the client releases the IPC
7400 * semaphore correctly (i.e. before it releases the VirtualBox reference),
7401 * but but the VirtualBox release event comes first to the server process.
7402 * This case is practically possible, so we should not assert on an
7403 * unexpected uninit, just log a warning.
7404 */
7405
7406 if ((aReason == Uninit::Unexpected))
7407 LogWarningThisFunc (("Unexpected SessionMachine uninitialization!\n"));
7408
7409 if (aReason != Uninit::Normal)
7410 {
7411 mData->mSession.mDirectControl.setNull();
7412 }
7413 else
7414 {
7415 /* this must be null here (see #OnSessionEnd()) */
7416 Assert (mData->mSession.mDirectControl.isNull());
7417 Assert (mData->mSession.mState == SessionState_Closing);
7418 Assert (!mData->mSession.mProgress.isNull());
7419
7420 mData->mSession.mProgress->notifyComplete (S_OK);
7421 mData->mSession.mProgress.setNull();
7422 }
7423
7424 /* remove the association between the peer machine and this session machine */
7425 Assert (mData->mSession.mMachine == this ||
7426 aReason == Uninit::Unexpected);
7427
7428 /* reset the rest of session data */
7429 mData->mSession.mMachine.setNull();
7430 mData->mSession.mState = SessionState_Closed;
7431 mData->mSession.mType.setNull();
7432
7433 /* close the interprocess semaphore before leaving the shared lock */
7434#if defined(RT_OS_WINDOWS)
7435 if (mIPCSem)
7436 ::CloseHandle (mIPCSem);
7437 mIPCSem = NULL;
7438#elif defined(RT_OS_OS2)
7439 if (mIPCSem != NULLHANDLE)
7440 ::DosCloseMutexSem (mIPCSem);
7441 mIPCSem = NULLHANDLE;
7442#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
7443 if (mIPCSem >= 0)
7444 ::semctl (mIPCSem, 0, IPC_RMID);
7445 mIPCSem = -1;
7446#else
7447# error "Port me!"
7448#endif
7449
7450 /* fire an event */
7451 mParent->onSessionStateChange (mData->mUuid, SessionState_Closed);
7452
7453 uninitDataAndChildObjects();
7454
7455 /* free the essential data structure last */
7456 mData.free();
7457
7458 /* leave the shared lock before setting the below two to NULL */
7459 alock.leave();
7460
7461 unconst (mParent).setNull();
7462 unconst (mPeer).setNull();
7463
7464 LogFlowThisFuncLeave();
7465}
7466
7467// AutoLock::Lockable interface
7468////////////////////////////////////////////////////////////////////////////////
7469
7470/**
7471 * Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
7472 * with the primary Machine instance (mPeer).
7473 */
7474AutoLock::Handle *SessionMachine::lockHandle() const
7475{
7476 AssertReturn (!mPeer.isNull(), NULL);
7477 return mPeer->lockHandle();
7478}
7479
7480// IInternalMachineControl methods
7481////////////////////////////////////////////////////////////////////////////////
7482
7483/**
7484 * @note Locks the same as #setMachineState() does.
7485 */
7486STDMETHODIMP SessionMachine::UpdateState (MachineState_T machineState)
7487{
7488 return setMachineState (machineState);
7489}
7490
7491/**
7492 * @note Locks this object for reading.
7493 */
7494STDMETHODIMP SessionMachine::GetIPCId (BSTR *id)
7495{
7496 AutoCaller autoCaller (this);
7497 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7498
7499 AutoReaderLock alock (this);
7500
7501#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
7502 mIPCSemName.cloneTo (id);
7503 return S_OK;
7504#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
7505 mData->mConfigFileFull.cloneTo (id);
7506 return S_OK;
7507#else
7508# error "Port me!"
7509#endif
7510}
7511
7512/**
7513 * Goes through the USB filters of the given machine to see if the given
7514 * device matches any filter or not.
7515 *
7516 * @note Locks the same as USBController::hasMatchingFilter() does.
7517 */
7518STDMETHODIMP SessionMachine::RunUSBDeviceFilters (IUSBDevice *aUSBDevice,
7519 BOOL *aMatched,
7520 ULONG *aMaskedIfs)
7521{
7522 LogFlowThisFunc (("\n"));
7523
7524 if (!aUSBDevice)
7525 return E_INVALIDARG;
7526 if (!aMatched)
7527 return E_POINTER;
7528
7529 AutoCaller autoCaller (this);
7530 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7531
7532#ifdef VBOX_WITH_USB
7533 *aMatched = mUSBController->hasMatchingFilter (aUSBDevice, aMaskedIfs);
7534#else
7535 *aMatched = FALSE;
7536#endif
7537
7538 return S_OK;
7539}
7540
7541/**
7542 * @note Locks the same as Host::captureUSBDevice() does.
7543 */
7544STDMETHODIMP SessionMachine::CaptureUSBDevice (INPTR GUIDPARAM aId)
7545{
7546 LogFlowThisFunc (("\n"));
7547
7548 AutoCaller autoCaller (this);
7549 AssertComRCReturnRC (autoCaller.rc());
7550
7551#ifdef VBOX_WITH_USB
7552 /* if cautureUSBDevice() fails, it must have set extended error info */
7553 return mParent->host()->captureUSBDevice (this, aId);
7554#else
7555 return E_FAIL;
7556#endif
7557}
7558
7559/**
7560 * @note Locks the same as Host::detachUSBDevice() does.
7561 */
7562STDMETHODIMP SessionMachine::DetachUSBDevice (INPTR GUIDPARAM aId, BOOL aDone)
7563{
7564 LogFlowThisFunc (("\n"));
7565
7566 AutoCaller autoCaller (this);
7567 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7568
7569#ifdef VBOX_WITH_USB
7570 return mParent->host()->detachUSBDevice (this, aId, aDone);
7571#else
7572 return E_FAIL;
7573#endif
7574}
7575
7576/**
7577 * Inserts all machine filters to the USB proxy service and then calls
7578 * Host::autoCaptureUSBDevices().
7579 *
7580 * Called by Console from the VM process upon VM startup.
7581 *
7582 * @note Locks what called methods lock.
7583 */
7584STDMETHODIMP SessionMachine::AutoCaptureUSBDevices()
7585{
7586 LogFlowThisFunc (("\n"));
7587
7588 AutoCaller autoCaller (this);
7589 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7590
7591#ifdef VBOX_WITH_USB
7592 HRESULT rc = mUSBController->notifyProxy (true /* aInsertFilters */);
7593 AssertComRC (rc);
7594 NOREF (rc);
7595
7596 return mParent->host()->autoCaptureUSBDevices (this);
7597#else
7598 return S_OK;
7599#endif
7600}
7601
7602/**
7603 * Removes all machine filters from the USB proxy service and then calls
7604 * Host::detachAllUSBDevices().
7605 *
7606 * Called by Console from the VM process upon normal VM termination or by
7607 * SessionMachine::uninit() upon abnormal VM termination (from under the
7608 * Machine/SessionMachine lock).
7609 *
7610 * @note Locks what called methods lock.
7611 */
7612STDMETHODIMP SessionMachine::DetachAllUSBDevices(BOOL aDone)
7613{
7614 LogFlowThisFunc (("\n"));
7615
7616 AutoCaller autoCaller (this);
7617 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7618
7619#ifdef VBOX_WITH_USB
7620 HRESULT rc = mUSBController->notifyProxy (false /* aInsertFilters */);
7621 AssertComRC (rc);
7622 NOREF (rc);
7623
7624 return mParent->host()->detachAllUSBDevices (this, aDone);
7625#else
7626 return S_OK;
7627#endif
7628}
7629
7630/**
7631 * @note Locks mParent + this object for writing.
7632 */
7633STDMETHODIMP SessionMachine::OnSessionEnd (ISession *aSession,
7634 IProgress **aProgress)
7635{
7636 LogFlowThisFuncEnter();
7637
7638 AssertReturn (aSession, E_INVALIDARG);
7639 AssertReturn (aProgress, E_INVALIDARG);
7640
7641 AutoCaller autoCaller (this);
7642
7643 LogFlowThisFunc (("state=%d\n", autoCaller.state()));
7644 /*
7645 * We don't assert below because it might happen that a non-direct session
7646 * informs us it is closed right after we've been uninitialized -- it's ok.
7647 */
7648 CheckComRCReturnRC (autoCaller.rc());
7649
7650 /* get IInternalSessionControl interface */
7651 ComPtr <IInternalSessionControl> control (aSession);
7652
7653 ComAssertRet (!control.isNull(), E_INVALIDARG);
7654
7655 /* Progress::init() needs mParent lock */
7656 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
7657
7658 if (control.equalsTo (mData->mSession.mDirectControl))
7659 {
7660 ComAssertRet (aProgress, E_POINTER);
7661
7662 /* The direct session is being normally closed by the client process
7663 * ----------------------------------------------------------------- */
7664
7665 /* go to the closing state (essential for all open*Session() calls and
7666 * for #checkForDeath()) */
7667 Assert (mData->mSession.mState == SessionState_Open);
7668 mData->mSession.mState = SessionState_Closing;
7669
7670 /* set direct control to NULL to release the remote instance */
7671 mData->mSession.mDirectControl.setNull();
7672 LogFlowThisFunc (("Direct control is set to NULL\n"));
7673
7674 /*
7675 * Create the progress object the client will use to wait until
7676 * #checkForDeath() is called to uninitialize this session object
7677 * after it releases the IPC semaphore.
7678 */
7679 ComObjPtr <Progress> progress;
7680 progress.createObject();
7681 progress->init (mParent, static_cast <IMachine *> (mPeer),
7682 Bstr (tr ("Closing session")), FALSE /* aCancelable */);
7683 progress.queryInterfaceTo (aProgress);
7684 mData->mSession.mProgress = progress;
7685 }
7686 else
7687 {
7688 /* the remote session is being normally closed */
7689 Data::Session::RemoteControlList::iterator it =
7690 mData->mSession.mRemoteControls.begin();
7691 while (it != mData->mSession.mRemoteControls.end())
7692 {
7693 if (control.equalsTo (*it))
7694 break;
7695 ++it;
7696 }
7697 BOOL found = it != mData->mSession.mRemoteControls.end();
7698 ComAssertMsgRet (found, ("The session is not found in the session list!"),
7699 E_INVALIDARG);
7700 mData->mSession.mRemoteControls.remove (*it);
7701 }
7702
7703 LogFlowThisFuncLeave();
7704 return S_OK;
7705}
7706
7707/**
7708 * @note Locks mParent + this object for writing.
7709 */
7710STDMETHODIMP SessionMachine::BeginSavingState (IProgress *aProgress, BSTR *aStateFilePath)
7711{
7712 LogFlowThisFuncEnter();
7713
7714 AssertReturn (aProgress, E_INVALIDARG);
7715 AssertReturn (aStateFilePath, E_POINTER);
7716
7717 AutoCaller autoCaller (this);
7718 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7719
7720 /* mParent->addProgress() needs mParent lock */
7721 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
7722
7723 AssertReturn (mData->mMachineState == MachineState_Paused &&
7724 mSnapshotData.mLastState == MachineState_Null &&
7725 mSnapshotData.mProgressId.isEmpty() &&
7726 mSnapshotData.mStateFilePath.isNull(),
7727 E_FAIL);
7728
7729 /* memorize the progress ID and add it to the global collection */
7730 Guid progressId;
7731 HRESULT rc = aProgress->COMGETTER(Id) (progressId.asOutParam());
7732 AssertComRCReturn (rc, rc);
7733 rc = mParent->addProgress (aProgress);
7734 AssertComRCReturn (rc, rc);
7735
7736 Bstr stateFilePath;
7737 /* stateFilePath is null when the machine is not running */
7738 if (mData->mMachineState == MachineState_Paused)
7739 {
7740 stateFilePath = Utf8StrFmt ("%ls%c{%Vuuid}.sav",
7741 mUserData->mSnapshotFolderFull.raw(),
7742 RTPATH_DELIMITER, mData->mUuid.raw());
7743 }
7744
7745 /* fill in the snapshot data */
7746 mSnapshotData.mLastState = mData->mMachineState;
7747 mSnapshotData.mProgressId = progressId;
7748 mSnapshotData.mStateFilePath = stateFilePath;
7749
7750 /* set the state to Saving (this is expected by Console::SaveState()) */
7751 setMachineState (MachineState_Saving);
7752
7753 stateFilePath.cloneTo (aStateFilePath);
7754
7755 return S_OK;
7756}
7757
7758/**
7759 * @note Locks mParent + this objects for writing.
7760 */
7761STDMETHODIMP SessionMachine::EndSavingState (BOOL aSuccess)
7762{
7763 LogFlowThisFunc (("\n"));
7764
7765 AutoCaller autoCaller (this);
7766 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7767
7768 /* endSavingState() need mParent lock */
7769 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
7770
7771 AssertReturn (mData->mMachineState == MachineState_Saving &&
7772 mSnapshotData.mLastState != MachineState_Null &&
7773 !mSnapshotData.mProgressId.isEmpty() &&
7774 !mSnapshotData.mStateFilePath.isNull(),
7775 E_FAIL);
7776
7777 /*
7778 * on success, set the state to Saved;
7779 * on failure, set the state to the state we had when BeginSavingState() was
7780 * called (this is expected by Console::SaveState() and
7781 * Console::saveStateThread())
7782 */
7783 if (aSuccess)
7784 setMachineState (MachineState_Saved);
7785 else
7786 setMachineState (mSnapshotData.mLastState);
7787
7788 return endSavingState (aSuccess);
7789}
7790
7791/**
7792 * @note Locks this objects for writing.
7793 */
7794STDMETHODIMP SessionMachine::AdoptSavedState (INPTR BSTR aSavedStateFile)
7795{
7796 LogFlowThisFunc (("\n"));
7797
7798 AssertReturn (aSavedStateFile, E_INVALIDARG);
7799
7800 AutoCaller autoCaller (this);
7801 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7802
7803 AutoLock alock (this);
7804
7805 AssertReturn (mData->mMachineState == MachineState_PoweredOff ||
7806 mData->mMachineState == MachineState_Aborted,
7807 E_FAIL);
7808
7809 Utf8Str stateFilePathFull = aSavedStateFile;
7810 int vrc = calculateFullPath (stateFilePathFull, stateFilePathFull);
7811 if (VBOX_FAILURE (vrc))
7812 return setError (E_FAIL,
7813 tr ("Invalid saved state file path: '%ls' (%Vrc)"),
7814 aSavedStateFile, vrc);
7815
7816 mSSData->mStateFilePath = stateFilePathFull;
7817
7818 /* The below setMachineState() will detect the state transition and will
7819 * update the settings file */
7820
7821 return setMachineState (MachineState_Saved);
7822}
7823
7824/**
7825 * @note Locks mParent + this objects for writing.
7826 */
7827STDMETHODIMP SessionMachine::BeginTakingSnapshot (
7828 IConsole *aInitiator, INPTR BSTR aName, INPTR BSTR aDescription,
7829 IProgress *aProgress, BSTR *aStateFilePath,
7830 IProgress **aServerProgress)
7831{
7832 LogFlowThisFuncEnter();
7833
7834 AssertReturn (aInitiator && aName, E_INVALIDARG);
7835 AssertReturn (aStateFilePath && aServerProgress, E_POINTER);
7836
7837 LogFlowThisFunc (("aName='%ls'\n", aName));
7838
7839 AutoCaller autoCaller (this);
7840 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
7841
7842 /* Progress::init() needs mParent lock */
7843 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
7844
7845 AssertReturn ((mData->mMachineState < MachineState_Running ||
7846 mData->mMachineState == MachineState_Paused) &&
7847 mSnapshotData.mLastState == MachineState_Null &&
7848 mSnapshotData.mSnapshot.isNull() &&
7849 mSnapshotData.mServerProgress.isNull() &&
7850 mSnapshotData.mCombinedProgress.isNull(),
7851 E_FAIL);
7852
7853 bool takingSnapshotOnline = mData->mMachineState == MachineState_Paused;
7854
7855 if (!takingSnapshotOnline && mData->mMachineState != MachineState_Saved)
7856 {
7857 /*
7858 * save all current settings to ensure current changes are committed
7859 * and hard disks are fixed up
7860 */
7861 HRESULT rc = saveSettings();
7862 CheckComRCReturnRC (rc);
7863 }
7864
7865 /* check that there are no Writethrough hard disks attached */
7866 for (HDData::HDAttachmentList::const_iterator
7867 it = mHDData->mHDAttachments.begin();
7868 it != mHDData->mHDAttachments.end();
7869 ++ it)
7870 {
7871 ComObjPtr <HardDisk> hd = (*it)->hardDisk();
7872 AutoLock hdLock (hd);
7873 if (hd->type() == HardDiskType_Writethrough)
7874 return setError (E_FAIL,
7875 tr ("Cannot take a snapshot when there is a Writethrough hard "
7876 " disk attached ('%ls')"), hd->toString().raw());
7877 }
7878
7879 AssertReturn (aProgress || !takingSnapshotOnline, E_FAIL);
7880
7881 /* create an ID for the snapshot */
7882 Guid snapshotId;
7883 snapshotId.create();
7884
7885 Bstr stateFilePath;
7886 /* stateFilePath is null when the machine is not online nor saved */
7887 if (takingSnapshotOnline || mData->mMachineState == MachineState_Saved)
7888 stateFilePath = Utf8StrFmt ("%ls%c{%Vuuid}.sav",
7889 mUserData->mSnapshotFolderFull.raw(),
7890 RTPATH_DELIMITER,
7891 snapshotId.ptr());
7892
7893 /* ensure the directory for the saved state file exists */
7894 if (stateFilePath)
7895 {
7896 Utf8Str dir = stateFilePath;
7897 RTPathStripFilename (dir.mutableRaw());
7898 if (!RTDirExists (dir))
7899 {
7900 int vrc = RTDirCreateFullPath (dir, 0777);
7901 if (VBOX_FAILURE (vrc))
7902 return setError (E_FAIL,
7903 tr ("Could not create a directory '%s' to save the "
7904 "VM state to (%Vrc)"),
7905 dir.raw(), vrc);
7906 }
7907 }
7908
7909 /* create a snapshot machine object */
7910 ComObjPtr <SnapshotMachine> snapshotMachine;
7911 snapshotMachine.createObject();
7912 HRESULT rc = snapshotMachine->init (this, snapshotId, stateFilePath);
7913 AssertComRCReturn (rc, rc);
7914
7915 Bstr progressDesc = Bstr (tr ("Taking snapshot of virtual machine"));
7916 Bstr firstOpDesc = Bstr (tr ("Preparing to take snapshot"));
7917
7918 /*
7919 * create a server-side progress object (it will be descriptionless
7920 * when we need to combine it with the VM-side progress, i.e. when we're
7921 * taking a snapshot online). The number of operations is:
7922 * 1 (preparing) + # of VDIs + 1 (if the state is saved so we need to copy it)
7923 */
7924 ComObjPtr <Progress> serverProgress;
7925 {
7926 ULONG opCount = 1 + mHDData->mHDAttachments.size();
7927 if (mData->mMachineState == MachineState_Saved)
7928 opCount ++;
7929 serverProgress.createObject();
7930 if (takingSnapshotOnline)
7931 rc = serverProgress->init (FALSE, opCount, firstOpDesc);
7932 else
7933 rc = serverProgress->init (mParent, aInitiator, progressDesc, FALSE,
7934 opCount, firstOpDesc);
7935 AssertComRCReturn (rc, rc);
7936 }
7937
7938 /* create a combined server-side progress object when necessary */
7939 ComObjPtr <CombinedProgress> combinedProgress;
7940 if (takingSnapshotOnline)
7941 {
7942 combinedProgress.createObject();
7943 rc = combinedProgress->init (mParent, aInitiator, progressDesc,
7944 serverProgress, aProgress);
7945 AssertComRCReturn (rc, rc);
7946 }
7947
7948 /* create a snapshot object */
7949 RTTIMESPEC time;
7950 ComObjPtr <Snapshot> snapshot;
7951 snapshot.createObject();
7952 rc = snapshot->init (snapshotId, aName, aDescription,
7953 *RTTimeNow (&time), snapshotMachine,
7954 mData->mCurrentSnapshot);
7955 AssertComRCReturnRC (rc);
7956
7957 /*
7958 * create and start the task on a separate thread
7959 * (note that it will not start working until we release alock)
7960 */
7961 TakeSnapshotTask *task = new TakeSnapshotTask (this);
7962 int vrc = RTThreadCreate (NULL, taskHandler,
7963 (void *) task,
7964 0, RTTHREADTYPE_MAIN_WORKER, 0, "TakeSnapshot");
7965 if (VBOX_FAILURE (vrc))
7966 {
7967 snapshot->uninit();
7968 delete task;
7969 ComAssertFailedRet (E_FAIL);
7970 }
7971
7972 /* fill in the snapshot data */
7973 mSnapshotData.mLastState = mData->mMachineState;
7974 mSnapshotData.mSnapshot = snapshot;
7975 mSnapshotData.mServerProgress = serverProgress;
7976 mSnapshotData.mCombinedProgress = combinedProgress;
7977
7978 /* set the state to Saving (this is expected by Console::TakeSnapshot()) */
7979 setMachineState (MachineState_Saving);
7980
7981 if (takingSnapshotOnline)
7982 stateFilePath.cloneTo (aStateFilePath);
7983 else
7984 *aStateFilePath = NULL;
7985
7986 serverProgress.queryInterfaceTo (aServerProgress);
7987
7988 LogFlowThisFuncLeave();
7989 return S_OK;
7990}
7991
7992/**
7993 * @note Locks mParent + this objects for writing.
7994 */
7995STDMETHODIMP SessionMachine::EndTakingSnapshot (BOOL aSuccess)
7996{
7997 LogFlowThisFunc (("\n"));
7998
7999 AutoCaller autoCaller (this);
8000 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8001
8002 /* Lock mParent because of endTakingSnapshot() */
8003 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8004
8005 AssertReturn (!aSuccess ||
8006 (mData->mMachineState == MachineState_Saving &&
8007 mSnapshotData.mLastState != MachineState_Null &&
8008 !mSnapshotData.mSnapshot.isNull() &&
8009 !mSnapshotData.mServerProgress.isNull() &&
8010 !mSnapshotData.mCombinedProgress.isNull()),
8011 E_FAIL);
8012
8013 /*
8014 * set the state to the state we had when BeginTakingSnapshot() was called
8015 * (this is expected by Console::TakeSnapshot() and
8016 * Console::saveStateThread())
8017 */
8018 setMachineState (mSnapshotData.mLastState);
8019
8020 return endTakingSnapshot (aSuccess);
8021}
8022
8023/**
8024 * @note Locks mParent + this + children objects for writing!
8025 */
8026STDMETHODIMP SessionMachine::DiscardSnapshot (
8027 IConsole *aInitiator, INPTR GUIDPARAM aId,
8028 MachineState_T *aMachineState, IProgress **aProgress)
8029{
8030 LogFlowThisFunc (("\n"));
8031
8032 Guid id = aId;
8033 AssertReturn (aInitiator && !id.isEmpty(), E_INVALIDARG);
8034 AssertReturn (aMachineState && aProgress, E_POINTER);
8035
8036 AutoCaller autoCaller (this);
8037 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8038
8039 /* Progress::init() needs mParent lock */
8040 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8041
8042 ComAssertRet (mData->mMachineState < MachineState_Running, E_FAIL);
8043
8044 ComObjPtr <Snapshot> snapshot;
8045 HRESULT rc = findSnapshot (id, snapshot, true /* aSetError */);
8046 CheckComRCReturnRC (rc);
8047
8048 AutoLock snapshotLock (snapshot);
8049 if (snapshot == mData->mFirstSnapshot)
8050 {
8051 AutoLock chLock (mData->mFirstSnapshot->childrenLock());
8052 size_t childrenCount = mData->mFirstSnapshot->children().size();
8053 if (childrenCount > 1)
8054 return setError (E_FAIL,
8055 tr ("Cannot discard the snapshot '%ls' because it is the first "
8056 "snapshot of the machine '%ls' and it has more than one "
8057 "child snapshot (%d)"),
8058 snapshot->data().mName.raw(), mUserData->mName.raw(),
8059 childrenCount);
8060 }
8061
8062 /*
8063 * If the snapshot being discarded is the current one, ensure current
8064 * settings are committed and saved.
8065 */
8066 if (snapshot == mData->mCurrentSnapshot)
8067 {
8068 if (isModified())
8069 {
8070 rc = saveSettings();
8071 CheckComRCReturnRC (rc);
8072 }
8073 }
8074
8075 /*
8076 * create a progress object. The number of operations is:
8077 * 1 (preparing) + # of VDIs
8078 */
8079 ComObjPtr <Progress> progress;
8080 progress.createObject();
8081 rc = progress->init (mParent, aInitiator,
8082 Bstr (Utf8StrFmt (tr ("Discarding snapshot '%ls'"),
8083 snapshot->data().mName.raw())),
8084 FALSE /* aCancelable */,
8085 1 + snapshot->data().mMachine->mHDData->mHDAttachments.size(),
8086 Bstr (tr ("Preparing to discard snapshot")));
8087 AssertComRCReturn (rc, rc);
8088
8089 /* create and start the task on a separate thread */
8090 DiscardSnapshotTask *task = new DiscardSnapshotTask (this, progress, snapshot);
8091 int vrc = RTThreadCreate (NULL, taskHandler,
8092 (void *) task,
8093 0, RTTHREADTYPE_MAIN_WORKER, 0, "DiscardSnapshot");
8094 if (VBOX_FAILURE (vrc))
8095 delete task;
8096 ComAssertRCRet (vrc, E_FAIL);
8097
8098 /* set the proper machine state (note: after creating a Task instance) */
8099 setMachineState (MachineState_Discarding);
8100
8101 /* return the progress to the caller */
8102 progress.queryInterfaceTo (aProgress);
8103
8104 /* return the new state to the caller */
8105 *aMachineState = mData->mMachineState;
8106
8107 return S_OK;
8108}
8109
8110/**
8111 * @note Locks mParent + this + children objects for writing!
8112 */
8113STDMETHODIMP SessionMachine::DiscardCurrentState (
8114 IConsole *aInitiator, MachineState_T *aMachineState, IProgress **aProgress)
8115{
8116 LogFlowThisFunc (("\n"));
8117
8118 AssertReturn (aInitiator, E_INVALIDARG);
8119 AssertReturn (aMachineState && aProgress, E_POINTER);
8120
8121 AutoCaller autoCaller (this);
8122 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8123
8124 /* Progress::init() needs mParent lock */
8125 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8126
8127 ComAssertRet (mData->mMachineState < MachineState_Running, E_FAIL);
8128
8129 if (mData->mCurrentSnapshot.isNull())
8130 return setError (E_FAIL,
8131 tr ("Could not discard the current state of the machine '%ls' "
8132 "because it doesn't have any snapshots"),
8133 mUserData->mName.raw());
8134
8135 /*
8136 * create a progress object. The number of operations is:
8137 * 1 (preparing) + # of VDIs + 1 (if we need to copy the saved state file)
8138 */
8139 ComObjPtr <Progress> progress;
8140 progress.createObject();
8141 {
8142 ULONG opCount = 1 + mData->mCurrentSnapshot->data()
8143 .mMachine->mHDData->mHDAttachments.size();
8144 if (mData->mCurrentSnapshot->stateFilePath())
8145 ++ opCount;
8146 progress->init (mParent, aInitiator,
8147 Bstr (tr ("Discarding current machine state")),
8148 FALSE /* aCancelable */, opCount,
8149 Bstr (tr ("Preparing to discard current state")));
8150 }
8151
8152 /* create and start the task on a separate thread */
8153 DiscardCurrentStateTask *task =
8154 new DiscardCurrentStateTask (this, progress, false /* discardCurSnapshot */);
8155 int vrc = RTThreadCreate (NULL, taskHandler,
8156 (void *) task,
8157 0, RTTHREADTYPE_MAIN_WORKER, 0, "DiscardCurState");
8158 if (VBOX_FAILURE (vrc))
8159 delete task;
8160 ComAssertRCRet (vrc, E_FAIL);
8161
8162 /* set the proper machine state (note: after creating a Task instance) */
8163 setMachineState (MachineState_Discarding);
8164
8165 /* return the progress to the caller */
8166 progress.queryInterfaceTo (aProgress);
8167
8168 /* return the new state to the caller */
8169 *aMachineState = mData->mMachineState;
8170
8171 return S_OK;
8172}
8173
8174/**
8175 * @note Locks mParent + other objects for writing!
8176 */
8177STDMETHODIMP SessionMachine::DiscardCurrentSnapshotAndState (
8178 IConsole *aInitiator, MachineState_T *aMachineState, IProgress **aProgress)
8179{
8180 LogFlowThisFunc (("\n"));
8181
8182 AssertReturn (aInitiator, E_INVALIDARG);
8183 AssertReturn (aMachineState && aProgress, E_POINTER);
8184
8185 AutoCaller autoCaller (this);
8186 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8187
8188 /* Progress::init() needs mParent lock */
8189 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8190
8191 ComAssertRet (mData->mMachineState < MachineState_Running, E_FAIL);
8192
8193 if (mData->mCurrentSnapshot.isNull())
8194 return setError (E_FAIL,
8195 tr ("Could not discard the current state of the machine '%ls' "
8196 "because it doesn't have any snapshots"),
8197 mUserData->mName.raw());
8198
8199 /*
8200 * create a progress object. The number of operations is:
8201 * 1 (preparing) + # of VDIs in the current snapshot +
8202 * # of VDIs in the previous snapshot +
8203 * 1 (if we need to copy the saved state file of the previous snapshot)
8204 * or (if there is no previous snapshot):
8205 * 1 (preparing) + # of VDIs in the current snapshot * 2 +
8206 * 1 (if we need to copy the saved state file of the current snapshot)
8207 */
8208 ComObjPtr <Progress> progress;
8209 progress.createObject();
8210 {
8211 ComObjPtr <Snapshot> curSnapshot = mData->mCurrentSnapshot;
8212 ComObjPtr <Snapshot> prevSnapshot = mData->mCurrentSnapshot->parent();
8213
8214 ULONG opCount = 1;
8215 if (prevSnapshot)
8216 {
8217 opCount += curSnapshot->data().mMachine->mHDData->mHDAttachments.size();
8218 opCount += prevSnapshot->data().mMachine->mHDData->mHDAttachments.size();
8219 if (prevSnapshot->stateFilePath())
8220 ++ opCount;
8221 }
8222 else
8223 {
8224 opCount += curSnapshot->data().mMachine->mHDData->mHDAttachments.size() * 2;
8225 if (curSnapshot->stateFilePath())
8226 ++ opCount;
8227 }
8228
8229 progress->init (mParent, aInitiator,
8230 Bstr (tr ("Discarding current machine snapshot and state")),
8231 FALSE /* aCancelable */, opCount,
8232 Bstr (tr ("Preparing to discard current snapshot and state")));
8233 }
8234
8235 /* create and start the task on a separate thread */
8236 DiscardCurrentStateTask *task =
8237 new DiscardCurrentStateTask (this, progress, true /* discardCurSnapshot */);
8238 int vrc = RTThreadCreate (NULL, taskHandler,
8239 (void *) task,
8240 0, RTTHREADTYPE_MAIN_WORKER, 0, "DiscardCurState");
8241 if (VBOX_FAILURE (vrc))
8242 delete task;
8243 ComAssertRCRet (vrc, E_FAIL);
8244
8245 /* set the proper machine state (note: after creating a Task instance) */
8246 setMachineState (MachineState_Discarding);
8247
8248 /* return the progress to the caller */
8249 progress.queryInterfaceTo (aProgress);
8250
8251 /* return the new state to the caller */
8252 *aMachineState = mData->mMachineState;
8253
8254 return S_OK;
8255}
8256
8257// public methods only for internal purposes
8258/////////////////////////////////////////////////////////////////////////////
8259
8260/**
8261 * Called from the client watcher thread to check for unexpected client
8262 * process death.
8263 *
8264 * @note On Win32 and on OS/2, this method is called only when we've got the
8265 * mutex (i.e. the client has either died or terminated normally). This
8266 * method always returns true.
8267 *
8268 * @note On Linux, the method returns true if the client process has
8269 * terminated abnormally (and/or the session has been uninitialized) and
8270 * false if it is still alive.
8271 *
8272 * @note Locks this object for writing.
8273 */
8274bool SessionMachine::checkForDeath()
8275{
8276 Uninit::Reason reason;
8277 bool doUninit = false;
8278 bool ret = false;
8279
8280 /*
8281 * Enclose autoCaller with a block because calling uninit()
8282 * from under it will deadlock.
8283 */
8284 {
8285 AutoCaller autoCaller (this);
8286 if (!autoCaller.isOk())
8287 {
8288 /*
8289 * return true if not ready, to cause the client watcher to exclude
8290 * the corresponding session from watching
8291 */
8292 LogFlowThisFunc (("Already uninitialized!"));
8293 return true;
8294 }
8295
8296 AutoLock alock (this);
8297
8298 /*
8299 * Determine the reason of death: if the session state is Closing here,
8300 * everything is fine. Otherwise it means that the client did not call
8301 * OnSessionEnd() before it released the IPC semaphore.
8302 * This may happen either because the client process has abnormally
8303 * terminated, or because it simply forgot to call ISession::Close()
8304 * before exiting. We threat the latter also as an abnormal termination
8305 * (see Session::uninit() for details).
8306 */
8307 reason = mData->mSession.mState == SessionState_Closing ?
8308 Uninit::Normal :
8309 Uninit::Abnormal;
8310
8311#if defined(RT_OS_WINDOWS)
8312
8313 AssertMsg (mIPCSem, ("semaphore must be created"));
8314
8315 /* release the IPC mutex */
8316 ::ReleaseMutex (mIPCSem);
8317
8318 doUninit = true;
8319
8320 ret = true;
8321
8322#elif defined(RT_OS_OS2)
8323
8324 AssertMsg (mIPCSem, ("semaphore must be created"));
8325
8326 /* release the IPC mutex */
8327 ::DosReleaseMutexSem (mIPCSem);
8328
8329 doUninit = true;
8330
8331 ret = true;
8332
8333#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
8334
8335 AssertMsg (mIPCSem >= 0, ("semaphore must be created"));
8336
8337 int val = ::semctl (mIPCSem, 0, GETVAL);
8338 if (val > 0)
8339 {
8340 /* the semaphore is signaled, meaning the session is terminated */
8341 doUninit = true;
8342 }
8343
8344 ret = val > 0;
8345
8346#else
8347# error "Port me!"
8348#endif
8349
8350 } /* AutoCaller block */
8351
8352 if (doUninit)
8353 uninit (reason);
8354
8355 return ret;
8356}
8357
8358/**
8359 * @note Locks this object for reading.
8360 */
8361HRESULT SessionMachine::onDVDDriveChange()
8362{
8363 LogFlowThisFunc (("\n"));
8364
8365 AutoCaller autoCaller (this);
8366 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8367
8368 ComPtr <IInternalSessionControl> directControl;
8369 {
8370 AutoReaderLock alock (this);
8371 directControl = mData->mSession.mDirectControl;
8372 }
8373
8374 /* ignore notifications sent after #OnSessionEnd() is called */
8375 if (!directControl)
8376 return S_OK;
8377
8378 return directControl->OnDVDDriveChange();
8379}
8380
8381/**
8382 * @note Locks this object for reading.
8383 */
8384HRESULT SessionMachine::onFloppyDriveChange()
8385{
8386 LogFlowThisFunc (("\n"));
8387
8388 AutoCaller autoCaller (this);
8389 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8390
8391 ComPtr <IInternalSessionControl> directControl;
8392 {
8393 AutoReaderLock alock (this);
8394 directControl = mData->mSession.mDirectControl;
8395 }
8396
8397 /* ignore notifications sent after #OnSessionEnd() is called */
8398 if (!directControl)
8399 return S_OK;
8400
8401 return directControl->OnFloppyDriveChange();
8402}
8403
8404/**
8405 * @note Locks this object for reading.
8406 */
8407HRESULT SessionMachine::onNetworkAdapterChange(INetworkAdapter *networkAdapter)
8408{
8409 LogFlowThisFunc (("\n"));
8410
8411 AutoCaller autoCaller (this);
8412 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8413
8414 ComPtr <IInternalSessionControl> directControl;
8415 {
8416 AutoReaderLock alock (this);
8417 directControl = mData->mSession.mDirectControl;
8418 }
8419
8420 /* ignore notifications sent after #OnSessionEnd() is called */
8421 if (!directControl)
8422 return S_OK;
8423
8424 return directControl->OnNetworkAdapterChange(networkAdapter);
8425}
8426
8427/**
8428 * @note Locks this object for reading.
8429 */
8430HRESULT SessionMachine::onSerialPortChange(ISerialPort *serialPort)
8431{
8432 LogFlowThisFunc (("\n"));
8433
8434 AutoCaller autoCaller (this);
8435 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8436
8437 ComPtr <IInternalSessionControl> directControl;
8438 {
8439 AutoReaderLock alock (this);
8440 directControl = mData->mSession.mDirectControl;
8441 }
8442
8443 /* ignore notifications sent after #OnSessionEnd() is called */
8444 if (!directControl)
8445 return S_OK;
8446
8447 return directControl->OnSerialPortChange(serialPort);
8448}
8449
8450/**
8451 * @note Locks this object for reading.
8452 */
8453HRESULT SessionMachine::onParallelPortChange(IParallelPort *parallelPort)
8454{
8455 LogFlowThisFunc (("\n"));
8456
8457 AutoCaller autoCaller (this);
8458 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8459
8460 ComPtr <IInternalSessionControl> directControl;
8461 {
8462 AutoReaderLock alock (this);
8463 directControl = mData->mSession.mDirectControl;
8464 }
8465
8466 /* ignore notifications sent after #OnSessionEnd() is called */
8467 if (!directControl)
8468 return S_OK;
8469
8470 return directControl->OnParallelPortChange(parallelPort);
8471}
8472
8473/**
8474 * @note Locks this object for reading.
8475 */
8476HRESULT SessionMachine::onVRDPServerChange()
8477{
8478 LogFlowThisFunc (("\n"));
8479
8480 AutoCaller autoCaller (this);
8481 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8482
8483 ComPtr <IInternalSessionControl> directControl;
8484 {
8485 AutoReaderLock alock (this);
8486 directControl = mData->mSession.mDirectControl;
8487 }
8488
8489 /* ignore notifications sent after #OnSessionEnd() is called */
8490 if (!directControl)
8491 return S_OK;
8492
8493 return directControl->OnVRDPServerChange();
8494}
8495
8496/**
8497 * @note Locks this object for reading.
8498 */
8499HRESULT SessionMachine::onUSBControllerChange()
8500{
8501 LogFlowThisFunc (("\n"));
8502
8503 AutoCaller autoCaller (this);
8504 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8505
8506 ComPtr <IInternalSessionControl> directControl;
8507 {
8508 AutoReaderLock alock (this);
8509 directControl = mData->mSession.mDirectControl;
8510 }
8511
8512 /* ignore notifications sent after #OnSessionEnd() is called */
8513 if (!directControl)
8514 return S_OK;
8515
8516 return directControl->OnUSBControllerChange();
8517}
8518
8519/**
8520 * @note Locks this object for reading.
8521 */
8522HRESULT SessionMachine::onSharedFolderChange()
8523{
8524 LogFlowThisFunc (("\n"));
8525
8526 AutoCaller autoCaller (this);
8527 AssertComRCReturnRC (autoCaller.rc());
8528
8529 ComPtr <IInternalSessionControl> directControl;
8530 {
8531 AutoReaderLock alock (this);
8532 directControl = mData->mSession.mDirectControl;
8533 }
8534
8535 /* ignore notifications sent after #OnSessionEnd() is called */
8536 if (!directControl)
8537 return S_OK;
8538
8539 return directControl->OnSharedFolderChange (FALSE /* aGlobal */);
8540}
8541
8542/**
8543 * Returns @c true if this machine's USB controller reports it has a matching
8544 * filter for the given USB device and @c false otherwise.
8545 *
8546 * @note Locks this object for reading.
8547 */
8548bool SessionMachine::hasMatchingUSBFilter (const ComObjPtr <HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
8549{
8550 AutoCaller autoCaller (this);
8551 /* silently return if not ready -- this method may be called after the
8552 * direct machine session has been called */
8553 if (!autoCaller.isOk())
8554 return false;
8555
8556 AutoReaderLock alock (this);
8557
8558#ifdef VBOX_WITH_USB
8559 return mUSBController->hasMatchingFilter (aDevice, aMaskedIfs);
8560#else
8561 return false;
8562#endif
8563}
8564
8565/**
8566 * @note Locks this object for reading.
8567 */
8568HRESULT SessionMachine::onUSBDeviceAttach (IUSBDevice *aDevice,
8569 IVirtualBoxErrorInfo *aError,
8570 ULONG aMaskedIfs)
8571{
8572 LogFlowThisFunc (("\n"));
8573
8574 AutoCaller autoCaller (this);
8575
8576 /* This notification may happen after the machine object has been
8577 * uninitialized (the session was closed), so don't assert. */
8578 CheckComRCReturnRC (autoCaller.rc());
8579
8580 ComPtr <IInternalSessionControl> directControl;
8581 {
8582 AutoReaderLock alock (this);
8583 directControl = mData->mSession.mDirectControl;
8584 }
8585
8586 /* fail on notifications sent after #OnSessionEnd() is called, it is
8587 * expected by the caller */
8588 if (!directControl)
8589 return E_FAIL;
8590
8591 return directControl->OnUSBDeviceAttach (aDevice, aError, aMaskedIfs);
8592}
8593
8594/**
8595 * @note Locks this object for reading.
8596 */
8597HRESULT SessionMachine::onUSBDeviceDetach (INPTR GUIDPARAM aId,
8598 IVirtualBoxErrorInfo *aError)
8599{
8600 LogFlowThisFunc (("\n"));
8601
8602 AutoCaller autoCaller (this);
8603
8604 /* This notification may happen after the machine object has been
8605 * uninitialized (the session was closed), so don't assert. */
8606 CheckComRCReturnRC (autoCaller.rc());
8607
8608 ComPtr <IInternalSessionControl> directControl;
8609 {
8610 AutoReaderLock alock (this);
8611 directControl = mData->mSession.mDirectControl;
8612 }
8613
8614 /* fail on notifications sent after #OnSessionEnd() is called, it is
8615 * expected by the caller */
8616 if (!directControl)
8617 return E_FAIL;
8618
8619 return directControl->OnUSBDeviceDetach (aId, aError);
8620}
8621
8622// protected methods
8623/////////////////////////////////////////////////////////////////////////////
8624
8625/**
8626 * Helper method to finalize saving the state.
8627 *
8628 * @note Must be called from under this object's lock.
8629 *
8630 * @param aSuccess TRUE if the snapshot has been taken successfully
8631 *
8632 * @note Locks mParent + this objects for writing.
8633 */
8634HRESULT SessionMachine::endSavingState (BOOL aSuccess)
8635{
8636 LogFlowThisFuncEnter();
8637
8638 AutoCaller autoCaller (this);
8639 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8640
8641 /* mParent->removeProgress() and saveSettings() need mParent lock */
8642 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8643
8644 HRESULT rc = S_OK;
8645
8646 if (aSuccess)
8647 {
8648 mSSData->mStateFilePath = mSnapshotData.mStateFilePath;
8649
8650 /* save all VM settings */
8651 rc = saveSettings();
8652 }
8653 else
8654 {
8655 /* delete the saved state file (it might have been already created) */
8656 RTFileDelete (Utf8Str (mSnapshotData.mStateFilePath));
8657 }
8658
8659 /* remove the completed progress object */
8660 mParent->removeProgress (mSnapshotData.mProgressId);
8661
8662 /* clear out the temporary saved state data */
8663 mSnapshotData.mLastState = MachineState_Null;
8664 mSnapshotData.mProgressId.clear();
8665 mSnapshotData.mStateFilePath.setNull();
8666
8667 LogFlowThisFuncLeave();
8668 return rc;
8669}
8670
8671/**
8672 * Helper method to finalize taking a snapshot.
8673 * Gets called only from #EndTakingSnapshot() that is expected to
8674 * be called by the VM process when it finishes *all* the tasks related to
8675 * taking a snapshot, either scucessfully or unsuccessfilly.
8676 *
8677 * @param aSuccess TRUE if the snapshot has been taken successfully
8678 *
8679 * @note Locks mParent + this objects for writing.
8680 */
8681HRESULT SessionMachine::endTakingSnapshot (BOOL aSuccess)
8682{
8683 LogFlowThisFuncEnter();
8684
8685 AutoCaller autoCaller (this);
8686 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
8687
8688 /* Progress object uninitialization needs mParent lock */
8689 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8690
8691 HRESULT rc = S_OK;
8692
8693 if (aSuccess)
8694 {
8695 /* the server progress must be completed on success */
8696 Assert (mSnapshotData.mServerProgress->completed());
8697
8698 mData->mCurrentSnapshot = mSnapshotData.mSnapshot;
8699 /* memorize the first snapshot if necessary */
8700 if (!mData->mFirstSnapshot)
8701 mData->mFirstSnapshot = mData->mCurrentSnapshot;
8702
8703 int opFlags = SaveSS_AddOp | SaveSS_UpdateCurrentId;
8704 if (mSnapshotData.mLastState != MachineState_Paused && !isModified())
8705 {
8706 /*
8707 * the machine was powered off or saved when taking a snapshot,
8708 * so reset the mCurrentStateModified flag
8709 */
8710 mData->mCurrentStateModified = FALSE;
8711 opFlags |= SaveSS_UpdateCurStateModified;
8712 }
8713
8714 rc = saveSnapshotSettings (mSnapshotData.mSnapshot, opFlags);
8715 }
8716
8717 if (!aSuccess || FAILED (rc))
8718 {
8719 if (mSnapshotData.mSnapshot)
8720 {
8721 /* wait for the completion of the server progress (diff VDI creation) */
8722 /// @todo (dmik) later, we will definitely want to cancel it instead
8723 // (when the cancel function is implemented)
8724 mSnapshotData.mServerProgress->WaitForCompletion (-1);
8725
8726 /*
8727 * delete all differencing VDIs created
8728 * (this will attach their parents back)
8729 */
8730 rc = deleteSnapshotDiffs (mSnapshotData.mSnapshot);
8731 /* continue cleanup on error */
8732
8733 /* delete the saved state file (it might have been already created) */
8734 if (mSnapshotData.mSnapshot->stateFilePath())
8735 RTFileDelete (Utf8Str (mSnapshotData.mSnapshot->stateFilePath()));
8736
8737 mSnapshotData.mSnapshot->uninit();
8738 }
8739 }
8740
8741 /* inform callbacks */
8742 if (aSuccess && SUCCEEDED (rc))
8743 mParent->onSnapshotTaken (mData->mUuid, mSnapshotData.mSnapshot->data().mId);
8744
8745 /* clear out the snapshot data */
8746 mSnapshotData.mLastState = MachineState_Null;
8747 mSnapshotData.mSnapshot.setNull();
8748 mSnapshotData.mServerProgress.setNull();
8749 /* uninitialize the combined progress (to remove it from the VBox collection) */
8750 if (!mSnapshotData.mCombinedProgress.isNull())
8751 {
8752 mSnapshotData.mCombinedProgress->uninit();
8753 mSnapshotData.mCombinedProgress.setNull();
8754 }
8755
8756 LogFlowThisFuncLeave();
8757 return rc;
8758}
8759
8760/**
8761 * Take snapshot task handler.
8762 * Must be called only by TakeSnapshotTask::handler()!
8763 *
8764 * The sole purpose of this task is to asynchronously create differencing VDIs
8765 * and copy the saved state file (when necessary). The VM process will wait
8766 * for this task to complete using the mSnapshotData.mServerProgress
8767 * returned to it.
8768 *
8769 * @note Locks mParent + this objects for writing.
8770 */
8771void SessionMachine::takeSnapshotHandler (TakeSnapshotTask &aTask)
8772{
8773 LogFlowThisFuncEnter();
8774
8775 AutoCaller autoCaller (this);
8776
8777 LogFlowThisFunc (("state=%d\n", autoCaller.state()));
8778 if (!autoCaller.isOk())
8779 {
8780 /*
8781 * we might have been uninitialized because the session was
8782 * accidentally closed by the client, so don't assert
8783 */
8784 LogFlowThisFuncLeave();
8785 return;
8786 }
8787
8788 /* endTakingSnapshot() needs mParent lock */
8789 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
8790
8791 HRESULT rc = S_OK;
8792
8793 LogFlowThisFunc (("Creating differencing VDIs...\n"));
8794
8795 /* create new differencing hard disks and attach them to this machine */
8796 rc = createSnapshotDiffs (&mSnapshotData.mSnapshot->data().mId,
8797 mUserData->mSnapshotFolderFull,
8798 mSnapshotData.mServerProgress,
8799 true /* aOnline */);
8800
8801 if (SUCCEEDED (rc) && mSnapshotData.mLastState == MachineState_Saved)
8802 {
8803 Utf8Str stateFrom = mSSData->mStateFilePath;
8804 Utf8Str stateTo = mSnapshotData.mSnapshot->stateFilePath();
8805
8806 LogFlowThisFunc (("Copying the execution state from '%s' to '%s'...\n",
8807 stateFrom.raw(), stateTo.raw()));
8808
8809 mSnapshotData.mServerProgress->advanceOperation (
8810 Bstr (tr ("Copying the execution state")));
8811
8812 /*
8813 * We can safely leave the lock here:
8814 * mMachineState is MachineState_Saving here
8815 */
8816 alock.leave();
8817
8818 /* copy the state file */
8819 int vrc = RTFileCopyEx (stateFrom, stateTo, 0, progressCallback,
8820 static_cast <Progress *> (mSnapshotData.mServerProgress));
8821
8822 alock.enter();
8823
8824 if (VBOX_FAILURE (vrc))
8825 rc = setError (E_FAIL,
8826 tr ("Could not copy the state file '%ls' to '%ls' (%Vrc)"),
8827 stateFrom.raw(), stateTo.raw());
8828 }
8829
8830 /*
8831 * we have to call endTakingSnapshot() here if the snapshot was taken
8832 * offline, because the VM process will not do it in this case
8833 */
8834 if (mSnapshotData.mLastState != MachineState_Paused)
8835 {
8836 LogFlowThisFunc (("Finalizing the taken snapshot (rc=%08X)...\n", rc));
8837
8838 setMachineState (mSnapshotData.mLastState);
8839 updateMachineStateOnClient();
8840
8841 /* finalize the progress after setting the state, for consistency */
8842 mSnapshotData.mServerProgress->notifyComplete (rc);
8843
8844 endTakingSnapshot (SUCCEEDED (rc));
8845 }
8846 else
8847 {
8848 mSnapshotData.mServerProgress->notifyComplete (rc);
8849 }
8850
8851 LogFlowThisFuncLeave();
8852}
8853
8854/**
8855 * Discard snapshot task handler.
8856 * Must be called only by DiscardSnapshotTask::handler()!
8857 *
8858 * When aTask.subTask is true, the associated progress object is left
8859 * uncompleted on success. On failure, the progress is marked as completed
8860 * regardless of this parameter.
8861 *
8862 * @note Locks mParent + this + child objects for writing!
8863 */
8864void SessionMachine::discardSnapshotHandler (DiscardSnapshotTask &aTask)
8865{
8866 LogFlowThisFuncEnter();
8867
8868 AutoCaller autoCaller (this);
8869
8870 LogFlowThisFunc (("state=%d\n", autoCaller.state()));
8871 if (!autoCaller.isOk())
8872 {
8873 /*
8874 * we might have been uninitialized because the session was
8875 * accidentally closed by the client, so don't assert
8876 */
8877 aTask.progress->notifyComplete (
8878 E_FAIL, COM_IIDOF (IMachine), getComponentName(),
8879 tr ("The session has been accidentally closed"));
8880
8881 LogFlowThisFuncLeave();
8882 return;
8883 }
8884
8885 ComObjPtr <SnapshotMachine> sm = aTask.snapshot->data().mMachine;
8886
8887 /* Progress::notifyComplete() et al., saveSettings() need mParent lock */
8888 AutoMultiLock <3> alock (mParent->wlock(), this->wlock(), sm->rlock());
8889
8890 /* Safe locking in the direction parent->child */
8891 AutoLock snapshotLock (aTask.snapshot);
8892 AutoLock snapshotChildrenLock (aTask.snapshot->childrenLock());
8893
8894 HRESULT rc = S_OK;
8895
8896 /* save the snapshot ID (for callbacks) */
8897 Guid snapshotId = aTask.snapshot->data().mId;
8898
8899 do
8900 {
8901 /* first pass: */
8902 LogFlowThisFunc (("Check hard disk accessibility and affected machines...\n"));
8903
8904 HDData::HDAttachmentList::const_iterator it;
8905 for (it = sm->mHDData->mHDAttachments.begin();
8906 it != sm->mHDData->mHDAttachments.end();
8907 ++ it)
8908 {
8909 ComObjPtr <HardDiskAttachment> hda = *it;
8910 ComObjPtr <HardDisk> hd = hda->hardDisk();
8911 ComObjPtr <HardDisk> parent = hd->parent();
8912
8913 AutoLock hdLock (hd);
8914
8915 if (hd->hasForeignChildren())
8916 {
8917 rc = setError (E_FAIL,
8918 tr ("One or more hard disks belonging to other machines are "
8919 "based on the hard disk '%ls' stored in the snapshot '%ls'"),
8920 hd->toString().raw(), aTask.snapshot->data().mName.raw());
8921 break;
8922 }
8923
8924 if (hd->type() == HardDiskType_Normal)
8925 {
8926 AutoLock hdChildrenLock (hd->childrenLock());
8927 size_t childrenCount = hd->children().size();
8928 if (childrenCount > 1)
8929 {
8930 rc = setError (E_FAIL,
8931 tr ("Normal hard disk '%ls' stored in the snapshot '%ls' "
8932 "has more than one child hard disk (%d)"),
8933 hd->toString().raw(), aTask.snapshot->data().mName.raw(),
8934 childrenCount);
8935 break;
8936 }
8937 }
8938 else
8939 {
8940 ComAssertMsgFailedBreak (("Invalid hard disk type %d\n", hd->type()),
8941 rc = E_FAIL);
8942 }
8943
8944 Bstr accessError;
8945 rc = hd->getAccessibleWithChildren (accessError);
8946 CheckComRCBreakRC (rc);
8947
8948 if (!accessError.isNull())
8949 {
8950 rc = setError (E_FAIL,
8951 tr ("Hard disk '%ls' stored in the snapshot '%ls' is not "
8952 "accessible (%ls)"),
8953 hd->toString().raw(), aTask.snapshot->data().mName.raw(),
8954 accessError.raw());
8955 break;
8956 }
8957
8958 rc = hd->setBusyWithChildren();
8959 if (FAILED (rc))
8960 {
8961 /* reset the busy flag of all previous hard disks */
8962 while (it != sm->mHDData->mHDAttachments.begin())
8963 (*(-- it))->hardDisk()->clearBusyWithChildren();
8964 break;
8965 }
8966 }
8967
8968 CheckComRCBreakRC (rc);
8969
8970 /* second pass: */
8971 LogFlowThisFunc (("Performing actual vdi merging...\n"));
8972
8973 for (it = sm->mHDData->mHDAttachments.begin();
8974 it != sm->mHDData->mHDAttachments.end();
8975 ++ it)
8976 {
8977 ComObjPtr <HardDiskAttachment> hda = *it;
8978 ComObjPtr <HardDisk> hd = hda->hardDisk();
8979 ComObjPtr <HardDisk> parent = hd->parent();
8980
8981 AutoLock hdLock (hd);
8982
8983 Bstr hdRootString = hd->root()->toString (true /* aShort */);
8984
8985 if (parent)
8986 {
8987 if (hd->isParentImmutable())
8988 {
8989 aTask.progress->advanceOperation (Bstr (Utf8StrFmt (
8990 tr ("Discarding changes to immutable hard disk '%ls'"),
8991 hdRootString.raw())));
8992
8993 /* clear the busy flag before unregistering */
8994 hd->clearBusy();
8995
8996 /*
8997 * unregisterDiffHardDisk() is supposed to delete and uninit
8998 * the differencing hard disk
8999 */
9000 rc = mParent->unregisterDiffHardDisk (hd);
9001 CheckComRCBreakRC (rc);
9002 continue;
9003 }
9004 else
9005 {
9006 /*
9007 * differencing VDI:
9008 * merge this image to all its children
9009 */
9010
9011 aTask.progress->advanceOperation (Bstr (Utf8StrFmt (
9012 tr ("Merging changes to normal hard disk '%ls' to children"),
9013 hdRootString.raw())));
9014
9015 snapshotChildrenLock.unlock();
9016 snapshotLock.unlock();
9017 alock.leave();
9018
9019 rc = hd->asVDI()->mergeImageToChildren (aTask.progress);
9020
9021 alock.enter();
9022 snapshotLock.lock();
9023 snapshotChildrenLock.lock();
9024
9025 // debug code
9026 // if (it != sm->mHDData->mHDAttachments.begin())
9027 // {
9028 // rc = setError (E_FAIL, "Simulated failure");
9029 // break;
9030 //}
9031
9032 if (SUCCEEDED (rc))
9033 rc = mParent->unregisterDiffHardDisk (hd);
9034 else
9035 hd->clearBusyWithChildren();
9036
9037 CheckComRCBreakRC (rc);
9038 }
9039 }
9040 else if (hd->type() == HardDiskType_Normal)
9041 {
9042 /*
9043 * normal vdi has the only child or none
9044 * (checked in the first pass)
9045 */
9046
9047 ComObjPtr <HardDisk> child;
9048 {
9049 AutoLock hdChildrenLock (hd->childrenLock());
9050 if (hd->children().size())
9051 child = hd->children().front();
9052 }
9053
9054 if (child.isNull())
9055 {
9056 aTask.progress->advanceOperation (Bstr (Utf8StrFmt (
9057 tr ("Detaching normal hard disk '%ls'"),
9058 hdRootString.raw())));
9059
9060 /* just deassociate the normal image from this machine */
9061 hd->setMachineId (Guid());
9062 hd->setSnapshotId (Guid());
9063
9064 /* clear the busy flag */
9065 hd->clearBusy();
9066 }
9067 else
9068 {
9069 AutoLock childLock (child);
9070
9071 aTask.progress->advanceOperation (Bstr (Utf8StrFmt (
9072 tr ("Preserving changes to normal hard disk '%ls'"),
9073 hdRootString.raw())));
9074
9075 ComObjPtr <Machine> cm;
9076 ComObjPtr <Snapshot> cs;
9077 ComObjPtr <HardDiskAttachment> childHda;
9078 rc = findHardDiskAttachment (child, &cm, &cs, &childHda);
9079 CheckComRCBreakRC (rc);
9080 /* must be the same machine (checked in the first pass) */
9081 ComAssertBreak (cm->mData->mUuid == mData->mUuid, rc = E_FAIL);
9082
9083 /* merge the child to this basic image */
9084
9085 snapshotChildrenLock.unlock();
9086 snapshotLock.unlock();
9087 alock.leave();
9088
9089 rc = child->asVDI()->mergeImageToParent (aTask.progress);
9090
9091 alock.enter();
9092 snapshotLock.lock();
9093 snapshotChildrenLock.lock();
9094
9095 if (SUCCEEDED (rc))
9096 rc = mParent->unregisterDiffHardDisk (child);
9097 else
9098 hd->clearBusyWithChildren();
9099
9100 CheckComRCBreakRC (rc);
9101
9102 /* reset the snapshot Id */
9103 hd->setSnapshotId (Guid());
9104
9105 /* replace the child image in the appropriate place */
9106 childHda->updateHardDisk (hd, FALSE /* aDirty */);
9107
9108 if (!cs)
9109 {
9110 aTask.settingsChanged = true;
9111 }
9112 else
9113 {
9114 rc = cm->saveSnapshotSettings (cs, SaveSS_UpdateAllOp);
9115 CheckComRCBreakRC (rc);
9116 }
9117 }
9118 }
9119 else
9120 {
9121 ComAssertMsgFailedBreak (("Invalid hard disk type %d\n", hd->type()),
9122 rc = E_FAIL);
9123 }
9124 }
9125
9126 /* preserve existing error info */
9127 ErrorInfoKeeper mergeEik;
9128 HRESULT mergeRc = rc;
9129
9130 if (FAILED (rc))
9131 {
9132 /* clear the busy flag on the rest of hard disks */
9133 for (++ it; it != sm->mHDData->mHDAttachments.end(); ++ it)
9134 (*it)->hardDisk()->clearBusyWithChildren();
9135 }
9136
9137 /*
9138 * we have to try to discard the snapshot even if merging failed
9139 * because some images might have been already merged (and deleted)
9140 */
9141
9142 do
9143 {
9144 LogFlowThisFunc (("Discarding the snapshot (reparenting children)...\n"));
9145
9146 /* It is important to uninitialize and delete all snapshot's hard
9147 * disk attachments as they are no longer valid -- otherwise the
9148 * code in Machine::uninitDataAndChildObjects() will mistakenly
9149 * perform hard disk deassociation. */
9150 for (HDData::HDAttachmentList::iterator it = sm->mHDData->mHDAttachments.begin();
9151 it != sm->mHDData->mHDAttachments.end();)
9152 {
9153 (*it)->uninit();
9154 it = sm->mHDData->mHDAttachments.erase (it);
9155 }
9156
9157 ComObjPtr <Snapshot> parentSnapshot = aTask.snapshot->parent();
9158
9159 /// @todo (dmik):
9160 // when we introduce clones later, discarding the snapshot
9161 // will affect the current and first snapshots of clones, if they are
9162 // direct children of this snapshot. So we will need to lock machines
9163 // associated with child snapshots as well and update mCurrentSnapshot
9164 // and/or mFirstSnapshot fields.
9165
9166 if (aTask.snapshot == mData->mCurrentSnapshot)
9167 {
9168 /* currently, the parent snapshot must refer to the same machine */
9169 ComAssertBreak (
9170 !parentSnapshot ||
9171 parentSnapshot->data().mMachine->mData->mUuid == mData->mUuid,
9172 rc = E_FAIL);
9173 mData->mCurrentSnapshot = parentSnapshot;
9174 /* mark the current state as modified */
9175 mData->mCurrentStateModified = TRUE;
9176 }
9177
9178 if (aTask.snapshot == mData->mFirstSnapshot)
9179 {
9180 /*
9181 * the first snapshot must have only one child when discarded,
9182 * or no children at all
9183 */
9184 ComAssertBreak (aTask.snapshot->children().size() <= 1, rc = E_FAIL);
9185
9186 if (aTask.snapshot->children().size() == 1)
9187 {
9188 ComObjPtr <Snapshot> childSnapshot = aTask.snapshot->children().front();
9189 ComAssertBreak (
9190 childSnapshot->data().mMachine->mData->mUuid == mData->mUuid,
9191 rc = E_FAIL);
9192 mData->mFirstSnapshot = childSnapshot;
9193 }
9194 else
9195 mData->mFirstSnapshot.setNull();
9196 }
9197
9198 /// @todo (dmik)
9199 // if we implement some warning mechanism later, we'll have
9200 // to return a warning if the state file path cannot be deleted
9201 Bstr stateFilePath = aTask.snapshot->stateFilePath();
9202 if (stateFilePath)
9203 RTFileDelete (Utf8Str (stateFilePath));
9204
9205 aTask.snapshot->discard();
9206
9207 rc = saveSnapshotSettings (parentSnapshot,
9208 SaveSS_UpdateAllOp | SaveSS_UpdateCurrentId);
9209 }
9210 while (0);
9211
9212 /* restore the merge error if any (ErrorInfo will be restored
9213 * automatically) */
9214 if (FAILED (mergeRc))
9215 rc = mergeRc;
9216 }
9217 while (0);
9218
9219 if (!aTask.subTask || FAILED (rc))
9220 {
9221 if (!aTask.subTask)
9222 {
9223 /* preserve existing error info */
9224 ErrorInfoKeeper eik;
9225
9226 /* restore the machine state */
9227 setMachineState (aTask.state);
9228 updateMachineStateOnClient();
9229
9230 /*
9231 * save settings anyway, since we've already changed the current
9232 * machine configuration
9233 */
9234 if (aTask.settingsChanged)
9235 {
9236 saveSettings (true /* aMarkCurStateAsModified */,
9237 true /* aInformCallbacksAnyway */);
9238 }
9239 }
9240
9241 /* set the result (this will try to fetch current error info on failure) */
9242 aTask.progress->notifyComplete (rc);
9243 }
9244
9245 if (SUCCEEDED (rc))
9246 mParent->onSnapshotDiscarded (mData->mUuid, snapshotId);
9247
9248 LogFlowThisFunc (("Done discarding snapshot (rc=%08X)\n", rc));
9249 LogFlowThisFuncLeave();
9250}
9251
9252/**
9253 * Discard current state task handler.
9254 * Must be called only by DiscardCurrentStateTask::handler()!
9255 *
9256 * @note Locks mParent + this object for writing.
9257 */
9258void SessionMachine::discardCurrentStateHandler (DiscardCurrentStateTask &aTask)
9259{
9260 LogFlowThisFuncEnter();
9261
9262 AutoCaller autoCaller (this);
9263
9264 LogFlowThisFunc (("state=%d\n", autoCaller.state()));
9265 if (!autoCaller.isOk())
9266 {
9267 /*
9268 * we might have been uninitialized because the session was
9269 * accidentally closed by the client, so don't assert
9270 */
9271 aTask.progress->notifyComplete (
9272 E_FAIL, COM_IIDOF (IMachine), getComponentName(),
9273 tr ("The session has been accidentally closed"));
9274
9275 LogFlowThisFuncLeave();
9276 return;
9277 }
9278
9279 /* Progress::notifyComplete() et al., saveSettings() need mParent lock */
9280 AutoMultiLock <2> alock (mParent->wlock(), this->wlock());
9281
9282 /*
9283 * discard all current changes to mUserData (name, OSType etc.)
9284 * (note that the machine is powered off, so there is no need
9285 * to inform the direct session)
9286 */
9287 if (isModified())
9288 rollback (false /* aNotify */);
9289
9290 HRESULT rc = S_OK;
9291
9292 bool errorInSubtask = false;
9293 bool stateRestored = false;
9294
9295 const bool isLastSnapshot = mData->mCurrentSnapshot->parent().isNull();
9296
9297 do
9298 {
9299 /*
9300 * discard the saved state file if the machine was Saved prior
9301 * to this operation
9302 */
9303 if (aTask.state == MachineState_Saved)
9304 {
9305 Assert (!mSSData->mStateFilePath.isEmpty());
9306 RTFileDelete (Utf8Str (mSSData->mStateFilePath));
9307 mSSData->mStateFilePath.setNull();
9308 aTask.modifyLastState (MachineState_PoweredOff);
9309 rc = saveStateSettings (SaveSTS_StateFilePath);
9310 CheckComRCBreakRC (rc);
9311 }
9312
9313 if (aTask.discardCurrentSnapshot && !isLastSnapshot)
9314 {
9315 /*
9316 * the "discard current snapshot and state" task is in action,
9317 * the current snapshot is not the last one.
9318 * Discard the current snapshot first.
9319 */
9320
9321 DiscardSnapshotTask subTask (aTask, mData->mCurrentSnapshot);
9322 subTask.subTask = true;
9323 discardSnapshotHandler (subTask);
9324 aTask.settingsChanged = subTask.settingsChanged;
9325 if (aTask.progress->completed())
9326 {
9327 /*
9328 * the progress can be completed by a subtask only if there was
9329 * a failure
9330 */
9331 Assert (FAILED (aTask.progress->resultCode()));
9332 errorInSubtask = true;
9333 rc = aTask.progress->resultCode();
9334 break;
9335 }
9336 }
9337
9338 RTTIMESPEC snapshotTimeStamp;
9339 RTTimeSpecSetMilli (&snapshotTimeStamp, 0);
9340
9341 {
9342 ComObjPtr <Snapshot> curSnapshot = mData->mCurrentSnapshot;
9343 AutoLock snapshotLock (curSnapshot);
9344
9345 /* remember the timestamp of the snapshot we're restoring from */
9346 snapshotTimeStamp = curSnapshot->data().mTimeStamp;
9347
9348 /* copy all hardware data from the current snapshot */
9349 copyFrom (curSnapshot->data().mMachine);
9350
9351 LogFlowThisFunc (("Restoring VDIs from the snapshot...\n"));
9352
9353 /* restore the attachmends from the snapshot */
9354 mHDData.backup();
9355 mHDData->mHDAttachments =
9356 curSnapshot->data().mMachine->mHDData->mHDAttachments;
9357
9358 snapshotLock.unlock();
9359 alock.leave();
9360 rc = createSnapshotDiffs (NULL, mUserData->mSnapshotFolderFull,
9361 aTask.progress,
9362 false /* aOnline */);
9363 alock.enter();
9364 snapshotLock.lock();
9365
9366 if (FAILED (rc))
9367 {
9368 /* here we can still safely rollback, so do it */
9369 /* preserve existing error info */
9370 ErrorInfoKeeper eik;
9371 /* undo all changes */
9372 rollback (false /* aNotify */);
9373 break;
9374 }
9375
9376 /*
9377 * note: old VDIs will be deassociated/deleted on #commit() called
9378 * either from #saveSettings() or directly at the end
9379 */
9380
9381 /* should not have a saved state file associated at this point */
9382 Assert (mSSData->mStateFilePath.isNull());
9383
9384 if (curSnapshot->stateFilePath())
9385 {
9386 Utf8Str snapStateFilePath = curSnapshot->stateFilePath();
9387
9388 Utf8Str stateFilePath = Utf8StrFmt ("%ls%c{%Vuuid}.sav",
9389 mUserData->mSnapshotFolderFull.raw(),
9390 RTPATH_DELIMITER, mData->mUuid.raw());
9391
9392 LogFlowThisFunc (("Copying saved state file from '%s' to '%s'...\n",
9393 snapStateFilePath.raw(), stateFilePath.raw()));
9394
9395 aTask.progress->advanceOperation (
9396 Bstr (tr ("Restoring the execution state")));
9397
9398 /* copy the state file */
9399 snapshotLock.unlock();
9400 alock.leave();
9401 int vrc = RTFileCopyEx (snapStateFilePath, stateFilePath,
9402 0, progressCallback, aTask.progress);
9403 alock.enter();
9404 snapshotLock.lock();
9405
9406 if (VBOX_SUCCESS (vrc))
9407 {
9408 mSSData->mStateFilePath = stateFilePath;
9409 }
9410 else
9411 {
9412 rc = setError (E_FAIL,
9413 tr ("Could not copy the state file '%s' to '%s' (%Vrc)"),
9414 snapStateFilePath.raw(), stateFilePath.raw(), vrc);
9415 break;
9416 }
9417 }
9418 }
9419
9420 bool informCallbacks = false;
9421
9422 if (aTask.discardCurrentSnapshot && isLastSnapshot)
9423 {
9424 /*
9425 * discard the current snapshot and state task is in action,
9426 * the current snapshot is the last one.
9427 * Discard the current snapshot after discarding the current state.
9428 */
9429
9430 /* commit changes to fixup hard disks before discarding */
9431 rc = commit();
9432 if (SUCCEEDED (rc))
9433 {
9434 DiscardSnapshotTask subTask (aTask, mData->mCurrentSnapshot);
9435 subTask.subTask = true;
9436 discardSnapshotHandler (subTask);
9437 aTask.settingsChanged = subTask.settingsChanged;
9438 if (aTask.progress->completed())
9439 {
9440 /*
9441 * the progress can be completed by a subtask only if there
9442 * was a failure
9443 */
9444 Assert (FAILED (aTask.progress->resultCode()));
9445 errorInSubtask = true;
9446 rc = aTask.progress->resultCode();
9447 }
9448 }
9449
9450 /*
9451 * we've committed already, so inform callbacks anyway to ensure
9452 * they don't miss some change
9453 */
9454 informCallbacks = true;
9455 }
9456
9457 /*
9458 * we have already discarded the current state, so set the
9459 * execution state accordingly no matter of the discard snapshot result
9460 */
9461 if (mSSData->mStateFilePath)
9462 setMachineState (MachineState_Saved);
9463 else
9464 setMachineState (MachineState_PoweredOff);
9465
9466 updateMachineStateOnClient();
9467 stateRestored = true;
9468
9469 if (errorInSubtask)
9470 break;
9471
9472 /* assign the timestamp from the snapshot */
9473 Assert (RTTimeSpecGetMilli (&snapshotTimeStamp) != 0);
9474 mData->mLastStateChange = snapshotTimeStamp;
9475
9476 /* mark the current state as not modified */
9477 mData->mCurrentStateModified = FALSE;
9478
9479 /* save all settings and commit */
9480 rc = saveSettings (false /* aMarkCurStateAsModified */,
9481 informCallbacks);
9482 aTask.settingsChanged = false;
9483 }
9484 while (0);
9485
9486 if (FAILED (rc))
9487 {
9488 /* preserve existing error info */
9489 ErrorInfoKeeper eik;
9490
9491 if (!stateRestored)
9492 {
9493 /* restore the machine state */
9494 setMachineState (aTask.state);
9495 updateMachineStateOnClient();
9496 }
9497
9498 /*
9499 * save all settings and commit if still modified (there is no way to
9500 * rollback properly). Note that isModified() will return true after
9501 * copyFrom(). Also save the settings if requested by the subtask.
9502 */
9503 if (isModified() || aTask.settingsChanged)
9504 {
9505 if (aTask.settingsChanged)
9506 saveSettings (true /* aMarkCurStateAsModified */,
9507 true /* aInformCallbacksAnyway */);
9508 else
9509 saveSettings();
9510 }
9511 }
9512
9513 if (!errorInSubtask)
9514 {
9515 /* set the result (this will try to fetch current error info on failure) */
9516 aTask.progress->notifyComplete (rc);
9517 }
9518
9519 if (SUCCEEDED (rc))
9520 mParent->onSnapshotDiscarded (mData->mUuid, Guid());
9521
9522 LogFlowThisFunc (("Done discarding current state (rc=%08X)\n", rc));
9523
9524 LogFlowThisFuncLeave();
9525}
9526
9527/**
9528 * Helper to change the machine state (reimplementation).
9529 *
9530 * @note Locks this object for writing.
9531 */
9532HRESULT SessionMachine::setMachineState (MachineState_T aMachineState)
9533{
9534 LogFlowThisFuncEnter();
9535 LogFlowThisFunc (("aMachineState=%d\n", aMachineState));
9536
9537 AutoCaller autoCaller (this);
9538 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
9539
9540 AutoLock alock (this);
9541
9542 MachineState_T oldMachineState = mData->mMachineState;
9543
9544 AssertMsgReturn (oldMachineState != aMachineState,
9545 ("oldMachineState=%d, aMachineState=%d\n",
9546 oldMachineState, aMachineState), E_FAIL);
9547
9548 HRESULT rc = S_OK;
9549
9550 int stsFlags = 0;
9551 bool deleteSavedState = false;
9552
9553 /* detect some state transitions */
9554
9555 if (oldMachineState < MachineState_Running &&
9556 aMachineState >= MachineState_Running &&
9557 aMachineState != MachineState_Discarding)
9558 {
9559 /*
9560 * the EMT thread is about to start, so mark attached HDDs as busy
9561 * and all its ancestors as being in use
9562 */
9563 for (HDData::HDAttachmentList::const_iterator it =
9564 mHDData->mHDAttachments.begin();
9565 it != mHDData->mHDAttachments.end();
9566 ++ it)
9567 {
9568 ComObjPtr <HardDisk> hd = (*it)->hardDisk();
9569 AutoLock hdLock (hd);
9570 hd->setBusy();
9571 hd->addReaderOnAncestors();
9572 }
9573 }
9574 else
9575 if (oldMachineState >= MachineState_Running &&
9576 oldMachineState != MachineState_Discarding &&
9577 aMachineState < MachineState_Running)
9578 {
9579 /*
9580 * the EMT thread stopped, so mark attached HDDs as no more busy
9581 * and remove the in-use flag from all its ancestors
9582 */
9583 for (HDData::HDAttachmentList::const_iterator it =
9584 mHDData->mHDAttachments.begin();
9585 it != mHDData->mHDAttachments.end();
9586 ++ it)
9587 {
9588 ComObjPtr <HardDisk> hd = (*it)->hardDisk();
9589 AutoLock hdLock (hd);
9590 hd->releaseReaderOnAncestors();
9591 hd->clearBusy();
9592 }
9593 }
9594
9595 if (oldMachineState == MachineState_Restoring)
9596 {
9597 if (aMachineState != MachineState_Saved)
9598 {
9599 /*
9600 * delete the saved state file once the machine has finished
9601 * restoring from it (note that Console sets the state from
9602 * Restoring to Saved if the VM couldn't restore successfully,
9603 * to give the user an ability to fix an error and retry --
9604 * we keep the saved state file in this case)
9605 */
9606 deleteSavedState = true;
9607 }
9608 }
9609 else
9610 if (oldMachineState == MachineState_Saved &&
9611 (aMachineState == MachineState_PoweredOff ||
9612 aMachineState == MachineState_Aborted))
9613 {
9614 /*
9615 * delete the saved state after Console::DiscardSavedState() is called
9616 * or if the VM process (owning a direct VM session) crashed while the
9617 * VM was Saved
9618 */
9619
9620 /// @todo (dmik)
9621 // Not sure that deleting the saved state file just because of the
9622 // client death before it attempted to restore the VM is a good
9623 // thing. But when it crashes we need to go to the Aborted state
9624 // which cannot have the saved state file associated... The only
9625 // way to fix this is to make the Aborted condition not a VM state
9626 // but a bool flag: i.e., when a crash occurs, set it to true and
9627 // change the state to PoweredOff or Saved depending on the
9628 // saved state presence.
9629
9630 deleteSavedState = true;
9631 mData->mCurrentStateModified = TRUE;
9632 stsFlags |= SaveSTS_CurStateModified;
9633 }
9634
9635 if (aMachineState == MachineState_Starting ||
9636 aMachineState == MachineState_Restoring)
9637 {
9638 /*
9639 * set the current state modified flag to indicate that the
9640 * current state is no more identical to the state in the
9641 * current snapshot
9642 */
9643 if (!mData->mCurrentSnapshot.isNull())
9644 {
9645 mData->mCurrentStateModified = TRUE;
9646 stsFlags |= SaveSTS_CurStateModified;
9647 }
9648 }
9649
9650 if (deleteSavedState == true)
9651 {
9652 Assert (!mSSData->mStateFilePath.isEmpty());
9653 RTFileDelete (Utf8Str (mSSData->mStateFilePath));
9654 mSSData->mStateFilePath.setNull();
9655 stsFlags |= SaveSTS_StateFilePath;
9656 }
9657
9658 /* redirect to the underlying peer machine */
9659 mPeer->setMachineState (aMachineState);
9660
9661 if (aMachineState == MachineState_PoweredOff ||
9662 aMachineState == MachineState_Aborted ||
9663 aMachineState == MachineState_Saved)
9664 {
9665 /* the machine has stopped execution
9666 * (or the saved state file was adopted) */
9667 stsFlags |= SaveSTS_StateTimeStamp;
9668 }
9669
9670 if ((oldMachineState == MachineState_PoweredOff ||
9671 oldMachineState == MachineState_Aborted) &&
9672 aMachineState == MachineState_Saved)
9673 {
9674 /* the saved state file was adopted */
9675 Assert (!mSSData->mStateFilePath.isNull());
9676 stsFlags |= SaveSTS_StateFilePath;
9677 }
9678
9679 rc = saveStateSettings (stsFlags);
9680
9681 if ((oldMachineState != MachineState_PoweredOff &&
9682 oldMachineState != MachineState_Aborted) &&
9683 (aMachineState == MachineState_PoweredOff ||
9684 aMachineState == MachineState_Aborted))
9685 {
9686 /*
9687 * clear differencing hard disks based on immutable hard disks
9688 * once we've been shut down for any reason
9689 */
9690 rc = wipeOutImmutableDiffs();
9691 }
9692
9693 LogFlowThisFunc (("rc=%08X\n", rc));
9694 LogFlowThisFuncLeave();
9695 return rc;
9696}
9697
9698/**
9699 * Sends the current machine state value to the VM process.
9700 *
9701 * @note Locks this object for reading, then calls a client process.
9702 */
9703HRESULT SessionMachine::updateMachineStateOnClient()
9704{
9705 AutoCaller autoCaller (this);
9706 AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
9707
9708 ComPtr <IInternalSessionControl> directControl;
9709 {
9710 AutoReaderLock alock (this);
9711 AssertReturn (!!mData, E_FAIL);
9712 directControl = mData->mSession.mDirectControl;
9713
9714 /* directControl may be already set to NULL here in #OnSessionEnd()
9715 * called too early by the direct session process while there is still
9716 * some operation (like discarding the snapshot) in progress. The client
9717 * process in this case is waiting inside Session::close() for the
9718 * "end session" process object to complete, while #uninit() called by
9719 * #checkForDeath() on the Watcher thread is waiting for the pending
9720 * operation to complete. For now, we accept this inconsitent behavior
9721 * and simply do nothing here. */
9722
9723 if (mData->mSession.mState == SessionState_Closing)
9724 return S_OK;
9725
9726 AssertReturn (!directControl.isNull(), E_FAIL);
9727 }
9728
9729 return directControl->UpdateMachineState (mData->mMachineState);
9730}
9731
9732/* static */
9733DECLCALLBACK(int) SessionMachine::taskHandler (RTTHREAD thread, void *pvUser)
9734{
9735 AssertReturn (pvUser, VERR_INVALID_POINTER);
9736
9737 Task *task = static_cast <Task *> (pvUser);
9738 task->handler();
9739
9740 // it's our responsibility to delete the task
9741 delete task;
9742
9743 return 0;
9744}
9745
9746/////////////////////////////////////////////////////////////////////////////
9747// SnapshotMachine class
9748/////////////////////////////////////////////////////////////////////////////
9749
9750DEFINE_EMPTY_CTOR_DTOR (SnapshotMachine)
9751
9752HRESULT SnapshotMachine::FinalConstruct()
9753{
9754 LogFlowThisFunc (("\n"));
9755
9756 /* set the proper type to indicate we're the SnapshotMachine instance */
9757 unconst (mType) = IsSnapshotMachine;
9758
9759 return S_OK;
9760}
9761
9762void SnapshotMachine::FinalRelease()
9763{
9764 LogFlowThisFunc (("\n"));
9765
9766 uninit();
9767}
9768
9769/**
9770 * Initializes the SnapshotMachine object when taking a snapshot.
9771 *
9772 * @param aSessionMachine machine to take a snapshot from
9773 * @param aSnapshotId snapshot ID of this snapshot machine
9774 * @param aStateFilePath file where the execution state will be later saved
9775 * (or NULL for the offline snapshot)
9776 *
9777 * @note Locks aSessionMachine object for reading.
9778 */
9779HRESULT SnapshotMachine::init (SessionMachine *aSessionMachine,
9780 INPTR GUIDPARAM aSnapshotId,
9781 INPTR BSTR aStateFilePath)
9782{
9783 LogFlowThisFuncEnter();
9784 LogFlowThisFunc (("mName={%ls}\n", aSessionMachine->mUserData->mName.raw()));
9785
9786 AssertReturn (aSessionMachine && !Guid (aSnapshotId).isEmpty(), E_INVALIDARG);
9787
9788 /* Enclose the state transition NotReady->InInit->Ready */
9789 AutoInitSpan autoInitSpan (this);
9790 AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
9791
9792 mSnapshotId = aSnapshotId;
9793
9794 AutoReaderLock alock (aSessionMachine);
9795
9796 /* memorize the primary Machine instance (i.e. not SessionMachine!) */
9797 unconst (mPeer) = aSessionMachine->mPeer;
9798 /* share the parent pointer */
9799 unconst (mParent) = mPeer->mParent;
9800
9801 /* take the pointer to Data to share */
9802 mData.share (mPeer->mData);
9803 /*
9804 * take the pointer to UserData to share
9805 * (our UserData must always be the same as Machine's data)
9806 */
9807 mUserData.share (mPeer->mUserData);
9808 /* make a private copy of all other data (recent changes from SessionMachine) */
9809 mHWData.attachCopy (aSessionMachine->mHWData);
9810 mHDData.attachCopy (aSessionMachine->mHDData);
9811
9812 /* SSData is always unique for SnapshotMachine */
9813 mSSData.allocate();
9814 mSSData->mStateFilePath = aStateFilePath;
9815
9816 /*
9817 * create copies of all shared folders (mHWData after attiching a copy
9818 * contains just references to original objects)
9819 */
9820 for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
9821 it != mHWData->mSharedFolders.end();
9822 ++ it)
9823 {
9824 ComObjPtr <SharedFolder> folder;
9825 folder.createObject();
9826 HRESULT rc = folder->initCopy (this, *it);
9827 CheckComRCReturnRC (rc);
9828 *it = folder;
9829 }
9830
9831 /* create all other child objects that will be immutable private copies */
9832
9833 unconst (mBIOSSettings).createObject();
9834 mBIOSSettings->initCopy (this, mPeer->mBIOSSettings);
9835
9836#ifdef VBOX_VRDP
9837 unconst (mVRDPServer).createObject();
9838 mVRDPServer->initCopy (this, mPeer->mVRDPServer);
9839#endif
9840
9841 unconst (mDVDDrive).createObject();
9842 mDVDDrive->initCopy (this, mPeer->mDVDDrive);
9843
9844 unconst (mFloppyDrive).createObject();
9845 mFloppyDrive->initCopy (this, mPeer->mFloppyDrive);
9846
9847 unconst (mAudioAdapter).createObject();
9848 mAudioAdapter->initCopy (this, mPeer->mAudioAdapter);
9849
9850 unconst (mUSBController).createObject();
9851 mUSBController->initCopy (this, mPeer->mUSBController);
9852
9853 unconst (mSATAController).createObject();
9854 mSATAController->initCopy (this, mPeer->mSATAController);
9855
9856 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
9857 {
9858 unconst (mNetworkAdapters [slot]).createObject();
9859 mNetworkAdapters [slot]->initCopy (this, mPeer->mNetworkAdapters [slot]);
9860 }
9861
9862 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
9863 {
9864 unconst (mSerialPorts [slot]).createObject();
9865 mSerialPorts [slot]->initCopy (this, mPeer->mSerialPorts [slot]);
9866 }
9867
9868 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
9869 {
9870 unconst (mParallelPorts [slot]).createObject();
9871 mParallelPorts [slot]->initCopy (this, mPeer->mParallelPorts [slot]);
9872 }
9873
9874 /* Confirm a successful initialization when it's the case */
9875 autoInitSpan.setSucceeded();
9876
9877 LogFlowThisFuncLeave();
9878 return S_OK;
9879}
9880
9881/**
9882 * Initializes the SnapshotMachine object when loading from the settings file.
9883 *
9884 * @param aMachine machine the snapshot belngs to
9885 * @param aHWNode <Hardware> node
9886 * @param aHDAsNode <HardDiskAttachments> node
9887 * @param aSnapshotId snapshot ID of this snapshot machine
9888 * @param aStateFilePath file where the execution state is saved
9889 * (or NULL for the offline snapshot)
9890 *
9891 * @note Locks aMachine object for reading.
9892 */
9893HRESULT SnapshotMachine::init (Machine *aMachine,
9894 const settings::Key &aHWNode,
9895 const settings::Key &aHDAsNode,
9896 INPTR GUIDPARAM aSnapshotId, INPTR BSTR aStateFilePath)
9897{
9898 LogFlowThisFuncEnter();
9899 LogFlowThisFunc (("mName={%ls}\n", aMachine->mUserData->mName.raw()));
9900
9901 AssertReturn (aMachine && !aHWNode.isNull() && !aHDAsNode.isNull() &&
9902 !Guid (aSnapshotId).isEmpty(),
9903 E_INVALIDARG);
9904
9905 /* Enclose the state transition NotReady->InInit->Ready */
9906 AutoInitSpan autoInitSpan (this);
9907 AssertReturn (autoInitSpan.isOk(), E_UNEXPECTED);
9908
9909 mSnapshotId = aSnapshotId;
9910
9911 AutoReaderLock alock (aMachine);
9912
9913 /* memorize the primary Machine instance */
9914 unconst (mPeer) = aMachine;
9915 /* share the parent pointer */
9916 unconst (mParent) = mPeer->mParent;
9917
9918 /* take the pointer to Data to share */
9919 mData.share (mPeer->mData);
9920 /*
9921 * take the pointer to UserData to share
9922 * (our UserData must always be the same as Machine's data)
9923 */
9924 mUserData.share (mPeer->mUserData);
9925 /* allocate private copies of all other data (will be loaded from settings) */
9926 mHWData.allocate();
9927 mHDData.allocate();
9928
9929 /* SSData is always unique for SnapshotMachine */
9930 mSSData.allocate();
9931 mSSData->mStateFilePath = aStateFilePath;
9932
9933 /* create all other child objects that will be immutable private copies */
9934
9935 unconst (mBIOSSettings).createObject();
9936 mBIOSSettings->init (this);
9937
9938#ifdef VBOX_VRDP
9939 unconst (mVRDPServer).createObject();
9940 mVRDPServer->init (this);
9941#endif
9942
9943 unconst (mDVDDrive).createObject();
9944 mDVDDrive->init (this);
9945
9946 unconst (mFloppyDrive).createObject();
9947 mFloppyDrive->init (this);
9948
9949 unconst (mAudioAdapter).createObject();
9950 mAudioAdapter->init (this);
9951
9952 unconst (mUSBController).createObject();
9953 mUSBController->init (this);
9954
9955 unconst (mSATAController).createObject();
9956 mSATAController->init (this);
9957
9958 for (ULONG slot = 0; slot < ELEMENTS (mNetworkAdapters); slot ++)
9959 {
9960 unconst (mNetworkAdapters [slot]).createObject();
9961 mNetworkAdapters [slot]->init (this, slot);
9962 }
9963
9964 for (ULONG slot = 0; slot < ELEMENTS (mSerialPorts); slot ++)
9965 {
9966 unconst (mSerialPorts [slot]).createObject();
9967 mSerialPorts [slot]->init (this, slot);
9968 }
9969
9970 for (ULONG slot = 0; slot < ELEMENTS (mParallelPorts); slot ++)
9971 {
9972 unconst (mParallelPorts [slot]).createObject();
9973 mParallelPorts [slot]->init (this, slot);
9974 }
9975
9976 /* load hardware and harddisk settings */
9977
9978 HRESULT rc = loadHardware (aHWNode);
9979 if (SUCCEEDED (rc))
9980 rc = loadHardDisks (aHDAsNode, true /* aRegistered */, &mSnapshotId);
9981
9982 if (SUCCEEDED (rc))
9983 {
9984 /* commit all changes made during the initialization */
9985 commit();
9986 }
9987
9988 /* Confirm a successful initialization when it's the case */
9989 if (SUCCEEDED (rc))
9990 autoInitSpan.setSucceeded();
9991
9992 LogFlowThisFuncLeave();
9993 return rc;
9994}
9995
9996/**
9997 * Uninitializes this SnapshotMachine object.
9998 */
9999void SnapshotMachine::uninit()
10000{
10001 LogFlowThisFuncEnter();
10002
10003 /* Enclose the state transition Ready->InUninit->NotReady */
10004 AutoUninitSpan autoUninitSpan (this);
10005 if (autoUninitSpan.uninitDone())
10006 return;
10007
10008 uninitDataAndChildObjects();
10009
10010 /* free the essential data structure last */
10011 mData.free();
10012
10013 unconst (mParent).setNull();
10014 unconst (mPeer).setNull();
10015
10016 LogFlowThisFuncLeave();
10017}
10018
10019// AutoLock::Lockable interface
10020////////////////////////////////////////////////////////////////////////////////
10021
10022/**
10023 * Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
10024 * with the primary Machine instance (mPeer).
10025 */
10026AutoLock::Handle *SnapshotMachine::lockHandle() const
10027{
10028 AssertReturn (!mPeer.isNull(), NULL);
10029 return mPeer->lockHandle();
10030}
10031
10032// public methods only for internal purposes
10033////////////////////////////////////////////////////////////////////////////////
10034
10035/**
10036 * Called by the snapshot object associated with this SnapshotMachine when
10037 * snapshot data such as name or description is changed.
10038 *
10039 * @note Locks this object for writing.
10040 */
10041HRESULT SnapshotMachine::onSnapshotChange (Snapshot *aSnapshot)
10042{
10043 AutoLock alock (this);
10044
10045 mPeer->saveSnapshotSettings (aSnapshot, SaveSS_UpdateAttrsOp);
10046
10047 /* inform callbacks */
10048 mParent->onSnapshotChange (mData->mUuid, aSnapshot->data().mId);
10049
10050 return S_OK;
10051}
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