VirtualBox

source: vbox/trunk/src/VBox/Main/include/MachineImpl.h@ 55361

Last change on this file since 55361 was 55214, checked in by vboxsync, 10 years ago

Main/Console+Machine+Session+Snapshot: move the save state and snapshot related methods from IConsole to IMachine, with lots of unavoidable code restructuring and cleanup. Also define two new machine states (so that the "Saving" one is specifically for saving state now) which requires more changes everywhere
Frontends: necessary adjustments
doc/SDK: document the changes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 67.3 KB
Line 
1/* $Id: MachineImpl.h 55214 2015-04-13 15:53:01Z vboxsync $ */
2/** @file
3 * Implementation of IMachine in VBoxSVC - Header.
4 */
5
6/*
7 * Copyright (C) 2006-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef ____H_MACHINEIMPL
19#define ____H_MACHINEIMPL
20
21#include "VirtualBoxBase.h"
22#include "SnapshotImpl.h"
23#include "ProgressImpl.h"
24#include "VRDEServerImpl.h"
25#include "MediumAttachmentImpl.h"
26#include "PCIDeviceAttachmentImpl.h"
27#include "MediumLock.h"
28#include "NetworkAdapterImpl.h"
29#include "AudioAdapterImpl.h"
30#include "SerialPortImpl.h"
31#include "ParallelPortImpl.h"
32#include "BIOSSettingsImpl.h"
33#include "StorageControllerImpl.h" // required for MachineImpl.h to compile on Windows
34#include "USBControllerImpl.h" // required for MachineImpl.h to compile on Windows
35#include "BandwidthControlImpl.h"
36#include "BandwidthGroupImpl.h"
37#include "VBox/settings.h"
38#ifdef VBOX_WITH_RESOURCE_USAGE_API
39#include "Performance.h"
40#include "PerformanceImpl.h"
41#endif /* VBOX_WITH_RESOURCE_USAGE_API */
42
43// generated header
44#include "SchemaDefs.h"
45
46#include "VBox/com/ErrorInfo.h"
47
48#include <iprt/file.h>
49#include <iprt/thread.h>
50#include <iprt/time.h>
51
52#include <list>
53#include <vector>
54
55#include "MachineWrap.h"
56
57// defines
58////////////////////////////////////////////////////////////////////////////////
59
60// helper declarations
61////////////////////////////////////////////////////////////////////////////////
62
63class Progress;
64class ProgressProxy;
65class Keyboard;
66class Mouse;
67class Display;
68class MachineDebugger;
69class USBController;
70class USBDeviceFilters;
71class Snapshot;
72class SharedFolder;
73class HostUSBDevice;
74class StorageController;
75class SessionMachine;
76
77namespace settings
78{
79 class MachineConfigFile;
80 struct Snapshot;
81 struct Hardware;
82 struct Storage;
83 struct StorageController;
84 struct MachineRegistryEntry;
85}
86
87// Machine class
88////////////////////////////////////////////////////////////////////////////////
89//
90class ATL_NO_VTABLE Machine :
91 public MachineWrap
92{
93
94public:
95
96 enum StateDependency
97 {
98 AnyStateDep = 0,
99 MutableStateDep,
100 MutableOrSavedStateDep,
101 MutableOrRunningStateDep,
102 MutableOrSavedOrRunningStateDep,
103 };
104
105 /**
106 * Internal machine data.
107 *
108 * Only one instance of this data exists per every machine -- it is shared
109 * by the Machine, SessionMachine and all SnapshotMachine instances
110 * associated with the given machine using the util::Shareable template
111 * through the mData variable.
112 *
113 * @note |const| members are persistent during lifetime so can be
114 * accessed without locking.
115 *
116 * @note There is no need to lock anything inside init() or uninit()
117 * methods, because they are always serialized (see AutoCaller).
118 */
119 struct Data
120 {
121 /**
122 * Data structure to hold information about sessions opened for the
123 * given machine.
124 */
125 struct Session
126 {
127 /** Type of lock which created this session */
128 LockType_T mLockType;
129
130 /** Control of the direct session opened by lockMachine() */
131 ComPtr<IInternalSessionControl> mDirectControl;
132
133 typedef std::list<ComPtr<IInternalSessionControl> > RemoteControlList;
134
135 /** list of controls of all opened remote sessions */
136 RemoteControlList mRemoteControls;
137
138 /** launchVMProcess() and OnSessionEnd() progress indicator */
139 ComObjPtr<ProgressProxy> mProgress;
140
141 /**
142 * PID of the session object that must be passed to openSession()
143 * to finalize the launchVMProcess() request (i.e., PID of the
144 * process created by launchVMProcess())
145 */
146 RTPROCESS mPID;
147
148 /** Current session state */
149 SessionState_T mState;
150
151 /** Session type string (for indirect sessions) */
152 Utf8Str mType;
153
154 /** Session machine object */
155 ComObjPtr<SessionMachine> mMachine;
156
157 /** Medium object lock collection. */
158 MediumLockListMap mLockedMedia;
159 };
160
161 Data();
162 ~Data();
163
164 const Guid mUuid;
165 BOOL mRegistered;
166
167 Utf8Str m_strConfigFile;
168 Utf8Str m_strConfigFileFull;
169
170 // machine settings XML file
171 settings::MachineConfigFile *pMachineConfigFile;
172 uint32_t flModifications;
173 bool m_fAllowStateModification;
174
175 BOOL mAccessible;
176 com::ErrorInfo mAccessError;
177
178 MachineState_T mMachineState;
179 RTTIMESPEC mLastStateChange;
180
181 /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
182 uint32_t mMachineStateDeps;
183 RTSEMEVENTMULTI mMachineStateDepsSem;
184 uint32_t mMachineStateChangePending;
185
186 BOOL mCurrentStateModified;
187 /** Guest properties have been modified and need saving since the
188 * machine was started, or there are transient properties which need
189 * deleting and the machine is being shut down. */
190 BOOL mGuestPropertiesModified;
191
192 Session mSession;
193
194 ComObjPtr<Snapshot> mFirstSnapshot;
195 ComObjPtr<Snapshot> mCurrentSnapshot;
196
197 // list of files to delete in Delete(); this list is filled by Unregister()
198 std::list<Utf8Str> llFilesToDelete;
199 };
200
201 /**
202 * Saved state data.
203 *
204 * It's actually only the state file path string, but it needs to be
205 * separate from Data, because Machine and SessionMachine instances
206 * share it, while SnapshotMachine does not.
207 *
208 * The data variable is |mSSData|.
209 */
210 struct SSData
211 {
212 Utf8Str strStateFilePath;
213 };
214
215 /**
216 * User changeable machine data.
217 *
218 * This data is common for all machine snapshots, i.e. it is shared
219 * by all SnapshotMachine instances associated with the given machine
220 * using the util::Backupable template through the |mUserData| variable.
221 *
222 * SessionMachine instances can alter this data and discard changes.
223 *
224 * @note There is no need to lock anything inside init() or uninit()
225 * methods, because they are always serialized (see AutoCaller).
226 */
227 struct UserData
228 {
229 settings::MachineUserData s;
230 typedef std::vector<uint8_t> IconBlob;
231 IconBlob mIcon;
232 };
233
234 /**
235 * Hardware data.
236 *
237 * This data is unique for a machine and for every machine snapshot.
238 * Stored using the util::Backupable template in the |mHWData| variable.
239 *
240 * SessionMachine instances can alter this data and discard changes.
241 */
242 struct HWData
243 {
244 /**
245 * Data structure to hold information about a guest property.
246 */
247 struct GuestProperty {
248 /** Property value */
249 Utf8Str strValue;
250 /** Property timestamp */
251 LONG64 mTimestamp;
252 /** Property flags */
253 ULONG mFlags;
254 };
255
256 HWData();
257 ~HWData();
258
259 Bstr mHWVersion;
260 Guid mHardwareUUID; /**< If Null, use mData.mUuid. */
261 ULONG mMemorySize;
262 ULONG mMemoryBalloonSize;
263 BOOL mPageFusionEnabled;
264 GraphicsControllerType_T mGraphicsControllerType;
265 ULONG mVRAMSize;
266 ULONG mVideoCaptureWidth;
267 ULONG mVideoCaptureHeight;
268 ULONG mVideoCaptureRate;
269 ULONG mVideoCaptureFPS;
270 ULONG mVideoCaptureMaxTime;
271 ULONG mVideoCaptureMaxFileSize;
272 Utf8Str mVideoCaptureOptions;
273 Utf8Str mVideoCaptureFile;
274 BOOL mVideoCaptureEnabled;
275 BOOL maVideoCaptureScreens[SchemaDefs::MaxGuestMonitors];
276 ULONG mMonitorCount;
277 BOOL mHWVirtExEnabled;
278 BOOL mHWVirtExNestedPagingEnabled;
279 BOOL mHWVirtExLargePagesEnabled;
280 BOOL mHWVirtExVPIDEnabled;
281 BOOL mHWVirtExUXEnabled;
282 BOOL mHWVirtExForceEnabled;
283 BOOL mAccelerate2DVideoEnabled;
284 BOOL mPAEEnabled;
285 settings::Hardware::LongModeType mLongMode;
286 BOOL mSyntheticCpu;
287 BOOL mTripleFaultReset;
288 ULONG mCPUCount;
289 BOOL mCPUHotPlugEnabled;
290 ULONG mCpuExecutionCap;
291 BOOL mAccelerate3DEnabled;
292 BOOL mHPETEnabled;
293
294 BOOL mCPUAttached[SchemaDefs::MaxCPUCount];
295
296 settings::CpuIdLeaf mCpuIdStdLeafs[11];
297 settings::CpuIdLeaf mCpuIdExtLeafs[11];
298
299 DeviceType_T mBootOrder[SchemaDefs::MaxBootPosition];
300
301 typedef std::list<ComObjPtr<SharedFolder> > SharedFolderList;
302 SharedFolderList mSharedFolders;
303
304 ClipboardMode_T mClipboardMode;
305 DnDMode_T mDnDMode;
306
307 typedef std::map<Utf8Str, GuestProperty> GuestPropertyMap;
308 GuestPropertyMap mGuestProperties;
309 Utf8Str mGuestPropertyNotificationPatterns;
310
311 FirmwareType_T mFirmwareType;
312 KeyboardHIDType_T mKeyboardHIDType;
313 PointingHIDType_T mPointingHIDType;
314 ChipsetType_T mChipsetType;
315 ParavirtProvider_T mParavirtProvider;
316 BOOL mEmulatedUSBCardReaderEnabled;
317
318 BOOL mIOCacheEnabled;
319 ULONG mIOCacheSize;
320
321 typedef std::list<ComObjPtr<PCIDeviceAttachment> > PCIDeviceAssignmentList;
322 PCIDeviceAssignmentList mPCIDeviceAssignments;
323
324 settings::Debugging mDebugging;
325 settings::Autostart mAutostart;
326
327 Utf8Str mDefaultFrontend;
328 };
329
330 /**
331 * Hard disk and other media data.
332 *
333 * The usage policy is the same as for HWData, but a separate structure
334 * is necessary because hard disk data requires different procedures when
335 * taking or deleting snapshots, etc.
336 *
337 * The data variable is |mMediaData|.
338 */
339 struct MediaData
340 {
341 MediaData();
342 ~MediaData();
343
344 typedef std::list<ComObjPtr<MediumAttachment> > AttachmentList;
345 AttachmentList mAttachments;
346 };
347
348 DECLARE_EMPTY_CTOR_DTOR(Machine)
349
350 HRESULT FinalConstruct();
351 void FinalRelease();
352
353 // public initializer/uninitializer for internal purposes only:
354
355 // initializer for creating a new, empty machine
356 HRESULT init(VirtualBox *aParent,
357 const Utf8Str &strConfigFile,
358 const Utf8Str &strName,
359 const StringsList &llGroups,
360 GuestOSType *aOsType,
361 const Guid &aId,
362 bool fForceOverwrite,
363 bool fDirectoryIncludesUUID);
364
365 // initializer for loading existing machine XML (either registered or not)
366 HRESULT initFromSettings(VirtualBox *aParent,
367 const Utf8Str &strConfigFile,
368 const Guid *aId);
369
370 // initializer for machine config in memory (OVF import)
371 HRESULT init(VirtualBox *aParent,
372 const Utf8Str &strName,
373 const settings::MachineConfigFile &config);
374
375 void uninit();
376
377#ifdef VBOX_WITH_RESOURCE_USAGE_API
378 // Needed from VirtualBox, for the delayed metrics cleanup.
379 void i_unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
380#endif /* VBOX_WITH_RESOURCE_USAGE_API */
381
382protected:
383 HRESULT initImpl(VirtualBox *aParent,
384 const Utf8Str &strConfigFile);
385 HRESULT initDataAndChildObjects();
386 HRESULT i_registeredInit();
387 HRESULT i_tryCreateMachineConfigFile(bool fForceOverwrite);
388 void uninitDataAndChildObjects();
389
390public:
391
392
393 // public methods only for internal purposes
394
395 virtual bool i_isSnapshotMachine() const
396 {
397 return false;
398 }
399
400 virtual bool i_isSessionMachine() const
401 {
402 return false;
403 }
404
405 /**
406 * Override of the default locking class to be used for validating lock
407 * order with the standard member lock handle.
408 */
409 virtual VBoxLockingClass getLockingClass() const
410 {
411 return LOCKCLASS_MACHINEOBJECT;
412 }
413
414 /// @todo (dmik) add lock and make non-inlined after revising classes
415 // that use it. Note: they should enter Machine lock to keep the returned
416 // information valid!
417 bool i_isRegistered() { return !!mData->mRegistered; }
418
419 // unsafe inline public methods for internal purposes only (ensure there is
420 // a caller and a read lock before calling them!)
421
422 /**
423 * Returns the VirtualBox object this machine belongs to.
424 *
425 * @note This method doesn't check this object's readiness. Intended to be
426 * used by ready Machine children (whose readiness is bound to the parent's
427 * one) or after doing addCaller() manually.
428 */
429 VirtualBox* i_getVirtualBox() const { return mParent; }
430
431 /**
432 * Checks if this machine is accessible, without attempting to load the
433 * config file.
434 *
435 * @note This method doesn't check this object's readiness. Intended to be
436 * used by ready Machine children (whose readiness is bound to the parent's
437 * one) or after doing addCaller() manually.
438 */
439 bool i_isAccessible() const { return !!mData->mAccessible; }
440
441 /**
442 * Returns this machine ID.
443 *
444 * @note This method doesn't check this object's readiness. Intended to be
445 * used by ready Machine children (whose readiness is bound to the parent's
446 * one) or after adding a caller manually.
447 */
448 const Guid& i_getId() const { return mData->mUuid; }
449
450 /**
451 * Returns the snapshot ID this machine represents or an empty UUID if this
452 * instance is not SnapshotMachine.
453 *
454 * @note This method doesn't check this object's readiness. Intended to be
455 * used by ready Machine children (whose readiness is bound to the parent's
456 * one) or after adding a caller manually.
457 */
458 inline const Guid& i_getSnapshotId() const;
459
460 /**
461 * Returns this machine's full settings file path.
462 *
463 * @note This method doesn't lock this object or check its readiness.
464 * Intended to be used only after doing addCaller() manually and locking it
465 * for reading.
466 */
467 const Utf8Str& i_getSettingsFileFull() const { return mData->m_strConfigFileFull; }
468
469 /**
470 * Returns this machine name.
471 *
472 * @note This method doesn't lock this object or check its readiness.
473 * Intended to be used only after doing addCaller() manually and locking it
474 * for reading.
475 */
476 const Utf8Str& i_getName() const { return mUserData->s.strName; }
477
478 enum
479 {
480 IsModified_MachineData = 0x0001,
481 IsModified_Storage = 0x0002,
482 IsModified_NetworkAdapters = 0x0008,
483 IsModified_SerialPorts = 0x0010,
484 IsModified_ParallelPorts = 0x0020,
485 IsModified_VRDEServer = 0x0040,
486 IsModified_AudioAdapter = 0x0080,
487 IsModified_USB = 0x0100,
488 IsModified_BIOS = 0x0200,
489 IsModified_SharedFolders = 0x0400,
490 IsModified_Snapshots = 0x0800,
491 IsModified_BandwidthControl = 0x1000
492 };
493
494 /**
495 * Returns various information about this machine.
496 *
497 * @note This method doesn't lock this object or check its readiness.
498 * Intended to be used only after doing addCaller() manually and locking it
499 * for reading.
500 */
501 ChipsetType_T i_getChipsetType() const { return mHWData->mChipsetType; }
502 ParavirtProvider_T i_getParavirtProvider() const { return mHWData->mParavirtProvider; }
503
504 void i_setModified(uint32_t fl, bool fAllowStateModification = true);
505 void i_setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
506
507 bool i_isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
508 void i_allowStateModification() { mData->m_fAllowStateModification = true; }
509 void i_disallowStateModification() { mData->m_fAllowStateModification = false; }
510
511 const StringsList &i_getGroups() const { return mUserData->s.llGroups; }
512
513 // callback handlers
514 virtual HRESULT i_onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
515 virtual HRESULT i_onNATRedirectRuleChange(ULONG /* slot */, BOOL /* fRemove */ , IN_BSTR /* name */,
516 NATProtocol_T /* protocol */, IN_BSTR /* host ip */, LONG /* host port */,
517 IN_BSTR /* guest port */, LONG /* guest port */ ) { return S_OK; }
518 virtual HRESULT i_onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
519 virtual HRESULT i_onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
520 virtual HRESULT i_onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
521 virtual HRESULT i_onUSBControllerChange() { return S_OK; }
522 virtual HRESULT i_onStorageControllerChange() { return S_OK; }
523 virtual HRESULT i_onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
524 virtual HRESULT i_onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
525 virtual HRESULT i_onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
526 virtual HRESULT i_onSharedFolderChange() { return S_OK; }
527 virtual HRESULT i_onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
528 virtual HRESULT i_onDnDModeChange(DnDMode_T /* aDnDMode */) { return S_OK; }
529 virtual HRESULT i_onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
530 virtual HRESULT i_onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */,
531 BOOL /* silent */) { return S_OK; }
532 virtual HRESULT i_onVideoCaptureChange() { return S_OK; }
533
534 HRESULT i_saveRegistryEntry(settings::MachineRegistryEntry &data);
535
536 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
537 void i_copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
538
539 void i_getLogFolder(Utf8Str &aLogFolder);
540 Utf8Str i_queryLogFilename(ULONG idx);
541 Utf8Str i_getStartupLogFilename(void);
542
543 void i_composeSavedStateFilename(Utf8Str &strStateFilePath);
544
545 void i_getDefaultVideoCaptureFile(Utf8Str &strFile);
546
547 bool i_isUSBControllerPresent();
548
549 HRESULT i_launchVMProcess(IInternalSessionControl *aControl,
550 const Utf8Str &strType,
551 const Utf8Str &strEnvironment,
552 ProgressProxy *aProgress);
553
554 HRESULT i_getDirectControl(ComPtr<IInternalSessionControl> *directControl)
555 {
556 HRESULT rc;
557 *directControl = mData->mSession.mDirectControl;
558
559 if (!*directControl)
560 rc = E_ACCESSDENIED;
561 else
562 rc = S_OK;
563
564 return rc;
565 }
566
567 bool i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
568 ComPtr<IInternalSessionControl> *aControl = NULL,
569 bool aAllowClosing = false);
570 bool i_isSessionSpawning();
571
572 bool i_isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
573 ComPtr<IInternalSessionControl> *aControl = NULL)
574 { return i_isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
575
576 bool i_checkForSpawnFailure();
577
578 HRESULT i_prepareRegister();
579
580 HRESULT i_getSharedFolder(CBSTR aName,
581 ComObjPtr<SharedFolder> &aSharedFolder,
582 bool aSetError = false)
583 {
584 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
585 return i_findSharedFolder(aName, aSharedFolder, aSetError);
586 }
587
588 HRESULT i_addStateDependency(StateDependency aDepType = AnyStateDep,
589 MachineState_T *aState = NULL,
590 BOOL *aRegistered = NULL);
591 void i_releaseStateDependency();
592
593 HRESULT i_getBandwidthGroup(const Utf8Str &strBandwidthGroup,
594 ComObjPtr<BandwidthGroup> &pBandwidthGroup,
595 bool fSetError = false)
596 {
597 return mBandwidthControl->i_getBandwidthGroupByName(strBandwidthGroup,
598 pBandwidthGroup,
599 fSetError);
600 }
601
602 static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...);
603
604protected:
605
606 class ClientToken;
607
608 HRESULT i_checkStateDependency(StateDependency aDepType);
609
610 Machine *i_getMachine();
611
612 void i_ensureNoStateDependencies();
613
614 virtual HRESULT i_setMachineState(MachineState_T aMachineState);
615
616 HRESULT i_findSharedFolder(const Utf8Str &aName,
617 ComObjPtr<SharedFolder> &aSharedFolder,
618 bool aSetError = false);
619
620 HRESULT i_loadSettings(bool aRegistered);
621 HRESULT i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
622 const Guid *puuidRegistry);
623 HRESULT i_loadSnapshot(const settings::Snapshot &data,
624 const Guid &aCurSnapshotId,
625 Snapshot *aParentSnapshot);
626 HRESULT i_loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
627 const settings::Autostart *pAutostart);
628 HRESULT i_loadDebugging(const settings::Debugging *pDbg);
629 HRESULT i_loadAutostart(const settings::Autostart *pAutostart);
630 HRESULT i_loadStorageControllers(const settings::Storage &data,
631 const Guid *puuidRegistry,
632 const Guid *puuidSnapshot);
633 HRESULT i_loadStorageDevices(StorageController *aStorageController,
634 const settings::StorageController &data,
635 const Guid *puuidRegistry,
636 const Guid *puuidSnapshot);
637
638 HRESULT i_findSnapshotById(const Guid &aId,
639 ComObjPtr<Snapshot> &aSnapshot,
640 bool aSetError = false);
641 HRESULT i_findSnapshotByName(const Utf8Str &strName,
642 ComObjPtr<Snapshot> &aSnapshot,
643 bool aSetError = false);
644
645 HRESULT i_getStorageControllerByName(const Utf8Str &aName,
646 ComObjPtr<StorageController> &aStorageController,
647 bool aSetError = false);
648
649 HRESULT i_getMediumAttachmentsOfController(const Utf8Str &aName,
650 MediaData::AttachmentList &aAttachments);
651
652 HRESULT i_getUSBControllerByName(const Utf8Str &aName,
653 ComObjPtr<USBController> &aUSBController,
654 bool aSetError = false);
655
656 ULONG i_getUSBControllerCountByType(USBControllerType_T enmType);
657
658 enum
659 {
660 /* flags for #saveSettings() */
661 SaveS_ResetCurStateModified = 0x01,
662 SaveS_InformCallbacksAnyway = 0x02,
663 SaveS_Force = 0x04,
664 /* flags for #saveStateSettings() */
665 SaveSTS_CurStateModified = 0x20,
666 SaveSTS_StateFilePath = 0x40,
667 SaveSTS_StateTimeStamp = 0x80
668 };
669
670 HRESULT i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
671 HRESULT i_saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
672
673 void i_copyMachineDataToSettings(settings::MachineConfigFile &config);
674 HRESULT i_saveAllSnapshots(settings::MachineConfigFile &config);
675 HRESULT i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
676 settings::Autostart *pAutostart);
677 HRESULT i_saveStorageControllers(settings::Storage &data);
678 HRESULT i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
679 settings::StorageController &data);
680 HRESULT i_saveStateSettings(int aFlags);
681
682 void i_addMediumToRegistry(ComObjPtr<Medium> &pMedium);
683
684 HRESULT i_createImplicitDiffs(IProgress *aProgress,
685 ULONG aWeight,
686 bool aOnline);
687 HRESULT i_deleteImplicitDiffs(bool aOnline);
688
689 MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
690 IN_BSTR aControllerName,
691 LONG aControllerPort,
692 LONG aDevice);
693 MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
694 ComObjPtr<Medium> pMedium);
695 MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
696 Guid &id);
697
698 HRESULT i_detachDevice(MediumAttachment *pAttach,
699 AutoWriteLock &writeLock,
700 Snapshot *pSnapshot);
701
702 HRESULT i_detachAllMedia(AutoWriteLock &writeLock,
703 Snapshot *pSnapshot,
704 CleanupMode_T cleanupMode,
705 MediaList &llMedia);
706
707 void i_commitMedia(bool aOnline = false);
708 void i_rollbackMedia();
709
710 bool i_isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
711
712 void i_rollback(bool aNotify);
713 void i_commit();
714 void i_copyFrom(Machine *aThat);
715 bool i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
716
717 Utf8Str i_getExtraData(const Utf8Str &strKey);
718
719#ifdef VBOX_WITH_GUEST_PROPS
720 HRESULT i_getGuestPropertyFromService(const com::Utf8Str &aName, com::Utf8Str &aValue,
721 LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
722 HRESULT i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
723 const com::Utf8Str &aFlags, bool fDelete);
724 HRESULT i_getGuestPropertyFromVM(const com::Utf8Str &aName, com::Utf8Str &aValue,
725 LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
726 HRESULT i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
727 const com::Utf8Str &aFlags, bool fDelete);
728 HRESULT i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
729 std::vector<com::Utf8Str> &aNames,
730 std::vector<com::Utf8Str> &aValues,
731 std::vector<LONG64> &aTimestamps,
732 std::vector<com::Utf8Str> &aFlags);
733 HRESULT i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
734 std::vector<com::Utf8Str> &aNames,
735 std::vector<com::Utf8Str> &aValues,
736 std::vector<LONG64> &aTimestamps,
737 std::vector<com::Utf8Str> &aFlags);
738
739#endif /* VBOX_WITH_GUEST_PROPS */
740
741#ifdef VBOX_WITH_RESOURCE_USAGE_API
742 void i_getDiskList(MediaList &list);
743 void i_registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
744
745 pm::CollectorGuest *mCollectorGuest;
746#endif /* VBOX_WITH_RESOURCE_USAGE_API */
747
748 Machine * const mPeer;
749
750 VirtualBox * const mParent;
751
752 Shareable<Data> mData;
753 Shareable<SSData> mSSData;
754
755 Backupable<UserData> mUserData;
756 Backupable<HWData> mHWData;
757 Backupable<MediaData> mMediaData;
758
759 // the following fields need special backup/rollback/commit handling,
760 // so they cannot be a part of HWData
761
762 const ComObjPtr<VRDEServer> mVRDEServer;
763 const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
764 const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
765 const ComObjPtr<AudioAdapter> mAudioAdapter;
766 const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
767 const ComObjPtr<BIOSSettings> mBIOSSettings;
768 const ComObjPtr<BandwidthControl> mBandwidthControl;
769
770 typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
771 NetworkAdapterVector mNetworkAdapters;
772
773 typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
774 Backupable<StorageControllerList> mStorageControllers;
775
776 typedef std::list<ComObjPtr<USBController> > USBControllerList;
777 Backupable<USBControllerList> mUSBControllers;
778
779 uint64_t uRegistryNeedsSaving;
780
781 /**
782 * Abstract base class for all Machine or SessionMachine related
783 * asynchronous tasks. This is necessary since RTThreadCreate cannot call
784 * a (non-static) method as its thread function, so instead we have it call
785 * the static Machine::taskHandler, which then calls the handler() method
786 * in here (implemented by the subclasses).
787 */
788 struct Task
789 {
790 Task(Machine *m, Progress *p, const Utf8Str &t)
791 : m_pMachine(m),
792 m_machineCaller(m),
793 m_pProgress(p),
794 m_strTaskName(t),
795 m_machineStateBackup(m->mData->mMachineState) // save the current machine state
796 {}
797
798 HRESULT createThread()
799 {
800 int vrc = RTThreadCreate(NULL,
801 taskHandler,
802 (void *)this,
803 0,
804 RTTHREADTYPE_MAIN_WORKER,
805 0,
806 m_strTaskName.c_str());
807 if (RT_FAILURE(vrc))
808 {
809 HRESULT rc = Machine::i_setErrorStatic(E_FAIL, Machine::tr("Could not create thread \"%s\" (%Rrc)"), m_strTaskName.c_str(), vrc);
810 delete this;
811 return rc;
812 }
813 return S_OK;
814 }
815
816 void modifyBackedUpState(MachineState_T s)
817 {
818 *const_cast<MachineState_T *>(&m_machineStateBackup) = s;
819 }
820
821 virtual void handler() = 0;
822
823 ComObjPtr<Machine> m_pMachine;
824 AutoCaller m_machineCaller;
825 ComObjPtr<Progress> m_pProgress;
826 Utf8Str m_strTaskName;
827 const MachineState_T m_machineStateBackup;
828 };
829
830 struct DeleteConfigTask;
831 void i_deleteConfigHandler(DeleteConfigTask &task);
832
833 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
834
835 friend class SessionMachine;
836 friend class SnapshotMachine;
837 friend class Appliance;
838 friend class VirtualBox;
839
840 friend class MachineCloneVM;
841
842private:
843 // wrapped IMachine properties
844 HRESULT getParent(ComPtr<IVirtualBox> &aParent);
845 HRESULT getIcon(std::vector<BYTE> &aIcon);
846 HRESULT setIcon(const std::vector<BYTE> &aIcon);
847 HRESULT getAccessible(BOOL *aAccessible);
848 HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError);
849 HRESULT getName(com::Utf8Str &aName);
850 HRESULT setName(const com::Utf8Str &aName);
851 HRESULT getDescription(com::Utf8Str &aDescription);
852 HRESULT setDescription(const com::Utf8Str &aDescription);
853 HRESULT getId(com::Guid &aId);
854 HRESULT getGroups(std::vector<com::Utf8Str> &aGroups);
855 HRESULT setGroups(const std::vector<com::Utf8Str> &aGroups);
856 HRESULT getOSTypeId(com::Utf8Str &aOSTypeId);
857 HRESULT setOSTypeId(const com::Utf8Str &aOSTypeId);
858 HRESULT getHardwareVersion(com::Utf8Str &aHardwareVersion);
859 HRESULT setHardwareVersion(const com::Utf8Str &aHardwareVersion);
860 HRESULT getHardwareUUID(com::Guid &aHardwareUUID);
861 HRESULT setHardwareUUID(const com::Guid &aHardwareUUID);
862 HRESULT getCPUCount(ULONG *aCPUCount);
863 HRESULT setCPUCount(ULONG aCPUCount);
864 HRESULT getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled);
865 HRESULT setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled);
866 HRESULT getCPUExecutionCap(ULONG *aCPUExecutionCap);
867 HRESULT setCPUExecutionCap(ULONG aCPUExecutionCap);
868 HRESULT getMemorySize(ULONG *aMemorySize);
869 HRESULT setMemorySize(ULONG aMemorySize);
870 HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize);
871 HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize);
872 HRESULT getPageFusionEnabled(BOOL *aPageFusionEnabled);
873 HRESULT setPageFusionEnabled(BOOL aPageFusionEnabled);
874 HRESULT getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType);
875 HRESULT setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType);
876 HRESULT getVRAMSize(ULONG *aVRAMSize);
877 HRESULT setVRAMSize(ULONG aVRAMSize);
878 HRESULT getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled);
879 HRESULT setAccelerate3DEnabled(BOOL aAccelerate3DEnabled);
880 HRESULT getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled);
881 HRESULT setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled);
882 HRESULT getMonitorCount(ULONG *aMonitorCount);
883 HRESULT setMonitorCount(ULONG aMonitorCount);
884 HRESULT getVideoCaptureEnabled(BOOL *aVideoCaptureEnabled);
885 HRESULT setVideoCaptureEnabled(BOOL aVideoCaptureEnabled);
886 HRESULT getVideoCaptureScreens(std::vector<BOOL> &aVideoCaptureScreens);
887 HRESULT setVideoCaptureScreens(const std::vector<BOOL> &aVideoCaptureScreens);
888 HRESULT getVideoCaptureFile(com::Utf8Str &aVideoCaptureFile);
889 HRESULT setVideoCaptureFile(const com::Utf8Str &aVideoCaptureFile);
890 HRESULT getVideoCaptureWidth(ULONG *aVideoCaptureWidth);
891 HRESULT setVideoCaptureWidth(ULONG aVideoCaptureWidth);
892 HRESULT getVideoCaptureHeight(ULONG *aVideoCaptureHeight);
893 HRESULT setVideoCaptureHeight(ULONG aVideoCaptureHeight);
894 HRESULT getVideoCaptureRate(ULONG *aVideoCaptureRate);
895 HRESULT setVideoCaptureRate(ULONG aVideoCaptureRate);
896 HRESULT getVideoCaptureFPS(ULONG *aVideoCaptureFPS);
897 HRESULT setVideoCaptureFPS(ULONG aVideoCaptureFPS);
898 HRESULT getVideoCaptureMaxTime(ULONG *aVideoCaptureMaxTime);
899 HRESULT setVideoCaptureMaxTime(ULONG aVideoCaptureMaxTime);
900 HRESULT getVideoCaptureMaxFileSize(ULONG *aVideoCaptureMaxFileSize);
901 HRESULT setVideoCaptureMaxFileSize(ULONG aVideoCaptureMaxFileSize);
902 HRESULT getVideoCaptureOptions(com::Utf8Str &aVideoCaptureOptions);
903 HRESULT setVideoCaptureOptions(const com::Utf8Str &aVideoCaptureOptions);
904 HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
905 HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
906 HRESULT setFirmwareType(FirmwareType_T aFirmwareType);
907 HRESULT getPointingHIDType(PointingHIDType_T *aPointingHIDType);
908 HRESULT setPointingHIDType(PointingHIDType_T aPointingHIDType);
909 HRESULT getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType);
910 HRESULT setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType);
911 HRESULT getHPETEnabled(BOOL *aHPETEnabled);
912 HRESULT setHPETEnabled(BOOL aHPETEnabled);
913 HRESULT getChipsetType(ChipsetType_T *aChipsetType);
914 HRESULT setChipsetType(ChipsetType_T aChipsetType);
915 HRESULT getSnapshotFolder(com::Utf8Str &aSnapshotFolder);
916 HRESULT setSnapshotFolder(const com::Utf8Str &aSnapshotFolder);
917 HRESULT getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer);
918 HRESULT getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled);
919 HRESULT setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled);
920 HRESULT getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
921 HRESULT getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers);
922 HRESULT getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters);
923 HRESULT getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter);
924 HRESULT getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers);
925 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
926 HRESULT getSettingsModified(BOOL *aSettingsModified);
927 HRESULT getSessionState(SessionState_T *aSessionState);
928 HRESULT getSessionType(com::Utf8Str &aSessionType);
929 HRESULT getSessionPID(ULONG *aSessionPID);
930 HRESULT getState(MachineState_T *aState);
931 HRESULT getLastStateChange(LONG64 *aLastStateChange);
932 HRESULT getStateFilePath(com::Utf8Str &aStateFilePath);
933 HRESULT getLogFolder(com::Utf8Str &aLogFolder);
934 HRESULT getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot);
935 HRESULT getSnapshotCount(ULONG *aSnapshotCount);
936 HRESULT getCurrentStateModified(BOOL *aCurrentStateModified);
937 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
938 HRESULT getClipboardMode(ClipboardMode_T *aClipboardMode);
939 HRESULT setClipboardMode(ClipboardMode_T aClipboardMode);
940 HRESULT getDnDMode(DnDMode_T *aDnDMode);
941 HRESULT setDnDMode(DnDMode_T aDnDMode);
942 HRESULT getGuestPropertyNotificationPatterns(com::Utf8Str &aGuestPropertyNotificationPatterns);
943 HRESULT setGuestPropertyNotificationPatterns(const com::Utf8Str &aGuestPropertyNotificationPatterns);
944 HRESULT getTeleporterEnabled(BOOL *aTeleporterEnabled);
945 HRESULT setTeleporterEnabled(BOOL aTeleporterEnabled);
946 HRESULT getTeleporterPort(ULONG *aTeleporterPort);
947 HRESULT setTeleporterPort(ULONG aTeleporterPort);
948 HRESULT getTeleporterAddress(com::Utf8Str &aTeleporterAddress);
949 HRESULT setTeleporterAddress(const com::Utf8Str &aTeleporterAddress);
950 HRESULT getTeleporterPassword(com::Utf8Str &aTeleporterPassword);
951 HRESULT setTeleporterPassword(const com::Utf8Str &aTeleporterPassword);
952 HRESULT getParavirtProvider(ParavirtProvider_T *aParavirtProvider);
953 HRESULT setParavirtProvider(ParavirtProvider_T aParavirtProvider);
954 HRESULT getFaultToleranceState(FaultToleranceState_T *aFaultToleranceState);
955 HRESULT setFaultToleranceState(FaultToleranceState_T aFaultToleranceState);
956 HRESULT getFaultTolerancePort(ULONG *aFaultTolerancePort);
957 HRESULT setFaultTolerancePort(ULONG aFaultTolerancePort);
958 HRESULT getFaultToleranceAddress(com::Utf8Str &aFaultToleranceAddress);
959 HRESULT setFaultToleranceAddress(const com::Utf8Str &aFaultToleranceAddress);
960 HRESULT getFaultTolerancePassword(com::Utf8Str &aFaultTolerancePassword);
961 HRESULT setFaultTolerancePassword(const com::Utf8Str &aFaultTolerancePassword);
962 HRESULT getFaultToleranceSyncInterval(ULONG *aFaultToleranceSyncInterval);
963 HRESULT setFaultToleranceSyncInterval(ULONG aFaultToleranceSyncInterval);
964 HRESULT getRTCUseUTC(BOOL *aRTCUseUTC);
965 HRESULT setRTCUseUTC(BOOL aRTCUseUTC);
966 HRESULT getIOCacheEnabled(BOOL *aIOCacheEnabled);
967 HRESULT setIOCacheEnabled(BOOL aIOCacheEnabled);
968 HRESULT getIOCacheSize(ULONG *aIOCacheSize);
969 HRESULT setIOCacheSize(ULONG aIOCacheSize);
970 HRESULT getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments);
971 HRESULT getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl);
972 HRESULT getTracingEnabled(BOOL *aTracingEnabled);
973 HRESULT setTracingEnabled(BOOL aTracingEnabled);
974 HRESULT getTracingConfig(com::Utf8Str &aTracingConfig);
975 HRESULT setTracingConfig(const com::Utf8Str &aTracingConfig);
976 HRESULT getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM);
977 HRESULT setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM);
978 HRESULT getAutostartEnabled(BOOL *aAutostartEnabled);
979 HRESULT setAutostartEnabled(BOOL aAutostartEnabled);
980 HRESULT getAutostartDelay(ULONG *aAutostartDelay);
981 HRESULT setAutostartDelay(ULONG aAutostartDelay);
982 HRESULT getAutostopType(AutostopType_T *aAutostopType);
983 HRESULT setAutostopType(AutostopType_T aAutostopType);
984 HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend);
985 HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
986 HRESULT getUSBProxyAvailable(BOOL *aUSBProxyAvailable);
987
988 // wrapped IMachine methods
989 HRESULT lockMachine(const ComPtr<ISession> &aSession,
990 LockType_T aLockType);
991 HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
992 const com::Utf8Str &aType,
993 const com::Utf8Str &aEnvironment,
994 ComPtr<IProgress> &aProgress);
995 HRESULT setBootOrder(ULONG aPosition,
996 DeviceType_T aDevice);
997 HRESULT getBootOrder(ULONG aPosition,
998 DeviceType_T *aDevice);
999 HRESULT attachDevice(const com::Utf8Str &aName,
1000 LONG aControllerPort,
1001 LONG aDevice,
1002 DeviceType_T aType,
1003 const ComPtr<IMedium> &aMedium);
1004 HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
1005 LONG aControllerPort,
1006 LONG aDevice,
1007 DeviceType_T aType);
1008 HRESULT detachDevice(const com::Utf8Str &aName,
1009 LONG aControllerPort,
1010 LONG aDevice);
1011 HRESULT passthroughDevice(const com::Utf8Str &aName,
1012 LONG aControllerPort,
1013 LONG aDevice,
1014 BOOL aPassthrough);
1015 HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
1016 LONG aControllerPort,
1017 LONG aDevice,
1018 BOOL aTemporaryEject);
1019 HRESULT nonRotationalDevice(const com::Utf8Str &aName,
1020 LONG aControllerPort,
1021 LONG aDevice,
1022 BOOL aNonRotational);
1023 HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
1024 LONG aControllerPort,
1025 LONG aDevice,
1026 BOOL aDiscard);
1027 HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
1028 LONG aControllerPort,
1029 LONG aDevice,
1030 BOOL aHotPluggable);
1031 HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
1032 LONG aControllerPort,
1033 LONG aDevice,
1034 const ComPtr<IBandwidthGroup> &aBandwidthGroup);
1035 HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
1036 LONG aControllerPort,
1037 LONG aDevice);
1038 HRESULT unmountMedium(const com::Utf8Str &aName,
1039 LONG aControllerPort,
1040 LONG aDevice,
1041 BOOL aForce);
1042 HRESULT mountMedium(const com::Utf8Str &aName,
1043 LONG aControllerPort,
1044 LONG aDevice,
1045 const ComPtr<IMedium> &aMedium,
1046 BOOL aForce);
1047 HRESULT getMedium(const com::Utf8Str &aName,
1048 LONG aControllerPort,
1049 LONG aDevice,
1050 ComPtr<IMedium> &aMedium);
1051 HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
1052 std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
1053 HRESULT getMediumAttachment(const com::Utf8Str &aName,
1054 LONG aControllerPort,
1055 LONG aDevice,
1056 ComPtr<IMediumAttachment> &aAttachment);
1057 HRESULT attachHostPCIDevice(LONG aHostAddress,
1058 LONG aDesiredGuestAddress,
1059 BOOL aTryToUnbind);
1060 HRESULT detachHostPCIDevice(LONG aHostAddress);
1061 HRESULT getNetworkAdapter(ULONG aSlot,
1062 ComPtr<INetworkAdapter> &aAdapter);
1063 HRESULT addStorageController(const com::Utf8Str &aName,
1064 StorageBus_T aConnectionType,
1065 ComPtr<IStorageController> &aController);
1066 HRESULT getStorageControllerByName(const com::Utf8Str &aName,
1067 ComPtr<IStorageController> &aStorageController);
1068 HRESULT getStorageControllerByInstance(ULONG aInstance,
1069 ComPtr<IStorageController> &aStorageController);
1070 HRESULT removeStorageController(const com::Utf8Str &aName);
1071 HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
1072 BOOL aBootable);
1073 HRESULT addUSBController(const com::Utf8Str &aName,
1074 USBControllerType_T aType,
1075 ComPtr<IUSBController> &aController);
1076 HRESULT removeUSBController(const com::Utf8Str &aName);
1077 HRESULT getUSBControllerByName(const com::Utf8Str &aName,
1078 ComPtr<IUSBController> &aController);
1079 HRESULT getUSBControllerCountByType(USBControllerType_T aType,
1080 ULONG *aControllers);
1081 HRESULT getSerialPort(ULONG aSlot,
1082 ComPtr<ISerialPort> &aPort);
1083 HRESULT getParallelPort(ULONG aSlot,
1084 ComPtr<IParallelPort> &aPort);
1085 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
1086 HRESULT getExtraData(const com::Utf8Str &aKey,
1087 com::Utf8Str &aValue);
1088 HRESULT setExtraData(const com::Utf8Str &aKey,
1089 const com::Utf8Str &aValue);
1090 HRESULT getCPUProperty(CPUPropertyType_T aProperty,
1091 BOOL *aValue);
1092 HRESULT setCPUProperty(CPUPropertyType_T aProperty,
1093 BOOL aValue);
1094 HRESULT getCPUIDLeaf(ULONG aId,
1095 ULONG *aValEax,
1096 ULONG *aValEbx,
1097 ULONG *aValEcx,
1098 ULONG *aValEdx);
1099 HRESULT setCPUIDLeaf(ULONG aId,
1100 ULONG aValEax,
1101 ULONG aValEbx,
1102 ULONG aValEcx,
1103 ULONG aValEdx);
1104 HRESULT removeCPUIDLeaf(ULONG aId);
1105 HRESULT removeAllCPUIDLeaves();
1106 HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1107 BOOL *aValue);
1108 HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1109 BOOL aValue);
1110 HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
1111 ComPtr<IProgress> &aProgress);
1112 HRESULT saveSettings();
1113 HRESULT discardSettings();
1114 HRESULT unregister(CleanupMode_T aCleanupMode,
1115 std::vector<ComPtr<IMedium> > &aMedia);
1116 HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
1117 ComPtr<IProgress> &aProgress);
1118 HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
1119 const com::Utf8Str &aLocation,
1120 ComPtr<IVirtualSystemDescription> &aDescription);
1121 HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
1122 ComPtr<ISnapshot> &aSnapshot);
1123 HRESULT createSharedFolder(const com::Utf8Str &aName,
1124 const com::Utf8Str &aHostPath,
1125 BOOL aWritable,
1126 BOOL aAutomount);
1127 HRESULT removeSharedFolder(const com::Utf8Str &aName);
1128 HRESULT canShowConsoleWindow(BOOL *aCanShow);
1129 HRESULT showConsoleWindow(LONG64 *aWinId);
1130 HRESULT getGuestProperty(const com::Utf8Str &aName,
1131 com::Utf8Str &aValue,
1132 LONG64 *aTimestamp,
1133 com::Utf8Str &aFlags);
1134 HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
1135 com::Utf8Str &aValue);
1136 HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
1137 LONG64 *aValue);
1138 HRESULT setGuestProperty(const com::Utf8Str &aProperty,
1139 const com::Utf8Str &aValue,
1140 const com::Utf8Str &aFlags);
1141 HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
1142 const com::Utf8Str &aValue);
1143 HRESULT deleteGuestProperty(const com::Utf8Str &aName);
1144 HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
1145 std::vector<com::Utf8Str> &aNames,
1146 std::vector<com::Utf8Str> &aValues,
1147 std::vector<LONG64> &aTimestamps,
1148 std::vector<com::Utf8Str> &aFlags);
1149 HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
1150 ULONG *aOriginX,
1151 ULONG *aOriginY,
1152 ULONG *aWidth,
1153 ULONG *aHeight,
1154 BOOL *aEnabled);
1155 HRESULT querySavedThumbnailSize(ULONG aScreenId,
1156 ULONG *aSize,
1157 ULONG *aWidth,
1158 ULONG *aHeight);
1159 HRESULT readSavedThumbnailToArray(ULONG aScreenId,
1160 BitmapFormat_T aBitmapFormat,
1161 ULONG *aWidth,
1162 ULONG *aHeight,
1163 std::vector<BYTE> &aData);
1164 HRESULT querySavedScreenshotPNGSize(ULONG aScreenId,
1165 ULONG *aSize,
1166 ULONG *aWidth,
1167 ULONG *aHeight);
1168 HRESULT readSavedScreenshotPNGToArray(ULONG aScreenId,
1169 ULONG *aWidth,
1170 ULONG *aHeight,
1171 std::vector<BYTE> &aData);
1172 HRESULT hotPlugCPU(ULONG aCpu);
1173 HRESULT hotUnplugCPU(ULONG aCpu);
1174 HRESULT getCPUStatus(ULONG aCpu,
1175 BOOL *aAttached);
1176 HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider);
1177 HRESULT queryLogFilename(ULONG aIdx,
1178 com::Utf8Str &aFilename);
1179 HRESULT readLog(ULONG aIdx,
1180 LONG64 aOffset,
1181 LONG64 aSize,
1182 std::vector<BYTE> &aData);
1183 HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
1184 CloneMode_T aMode,
1185 const std::vector<CloneOptions_T> &aOptions,
1186 ComPtr<IProgress> &aProgress);
1187 HRESULT saveState(ComPtr<IProgress> &aProgress);
1188 HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1189 HRESULT discardSavedState(BOOL aFRemoveFile);
1190 HRESULT takeSnapshot(const com::Utf8Str &aName,
1191 const com::Utf8Str &aDescription,
1192 BOOL aPause,
1193 ComPtr<IProgress> &aProgress);
1194 HRESULT deleteSnapshot(const com::Guid &aId,
1195 ComPtr<IProgress> &aProgress);
1196 HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1197 ComPtr<IProgress> &aProgress);
1198 HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1199 const com::Guid &aEndId,
1200 ComPtr<IProgress> &aProgress);
1201 HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1202 ComPtr<IProgress> &aProgress);
1203
1204 // wrapped IInternalMachineControl properties
1205
1206 // wrapped IInternalMachineControl methods
1207 HRESULT updateState(MachineState_T aState);
1208 HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1209 HRESULT endPowerUp(LONG aResult);
1210 HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1211 HRESULT endPoweringDown(LONG aResult,
1212 const com::Utf8Str &aErrMsg);
1213 HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1214 BOOL *aMatched,
1215 ULONG *aMaskedInterfaces);
1216 HRESULT captureUSBDevice(const com::Guid &aId,
1217 const com::Utf8Str &aCaptureFilename);
1218 HRESULT detachUSBDevice(const com::Guid &aId,
1219 BOOL aDone);
1220 HRESULT autoCaptureUSBDevices();
1221 HRESULT detachAllUSBDevices(BOOL aDone);
1222 HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1223 ComPtr<IProgress> &aProgress);
1224 HRESULT finishOnlineMergeMedium();
1225 HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1226 std::vector<com::Utf8Str> &aValues,
1227 std::vector<LONG64> &aTimestamps,
1228 std::vector<com::Utf8Str> &aFlags);
1229 HRESULT pushGuestProperty(const com::Utf8Str &aName,
1230 const com::Utf8Str &aValue,
1231 LONG64 aTimestamp,
1232 const com::Utf8Str &aFlags);
1233 HRESULT lockMedia();
1234 HRESULT unlockMedia();
1235 HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1236 ComPtr<IMediumAttachment> &aNewAttachment);
1237 HRESULT reportVmStatistics(ULONG aValidStats,
1238 ULONG aCpuUser,
1239 ULONG aCpuKernel,
1240 ULONG aCpuIdle,
1241 ULONG aMemTotal,
1242 ULONG aMemFree,
1243 ULONG aMemBalloon,
1244 ULONG aMemShared,
1245 ULONG aMemCache,
1246 ULONG aPagedTotal,
1247 ULONG aMemAllocTotal,
1248 ULONG aMemFreeTotal,
1249 ULONG aMemBalloonTotal,
1250 ULONG aMemSharedTotal,
1251 ULONG aVmNetRx,
1252 ULONG aVmNetTx);
1253};
1254
1255// SessionMachine class
1256////////////////////////////////////////////////////////////////////////////////
1257
1258/**
1259 * @note Notes on locking objects of this class:
1260 * SessionMachine shares some data with the primary Machine instance (pointed
1261 * to by the |mPeer| member). In order to provide data consistency it also
1262 * shares its lock handle. This means that whenever you lock a SessionMachine
1263 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1264 * instance is also locked in the same lock mode. Keep it in mind.
1265 */
1266class ATL_NO_VTABLE SessionMachine :
1267 public Machine
1268{
1269public:
1270 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1271
1272 DECLARE_NOT_AGGREGATABLE(SessionMachine)
1273
1274 DECLARE_PROTECT_FINAL_CONSTRUCT()
1275
1276 BEGIN_COM_MAP(SessionMachine)
1277 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1278 COM_INTERFACE_ENTRY(IInternalMachineControl)
1279 END_COM_MAP()
1280
1281 DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1282
1283 HRESULT FinalConstruct();
1284 void FinalRelease();
1285
1286 struct Uninit
1287 {
1288 enum Reason { Unexpected, Abnormal, Normal };
1289 };
1290
1291 // public initializer/uninitializer for internal purposes only
1292 HRESULT init(Machine *aMachine);
1293 void uninit() { uninit(Uninit::Unexpected); }
1294 void uninit(Uninit::Reason aReason);
1295
1296
1297 // util::Lockable interface
1298 RWLockHandle *lockHandle() const;
1299
1300 // public methods only for internal purposes
1301
1302 virtual bool i_isSessionMachine() const
1303 {
1304 return true;
1305 }
1306
1307#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
1308 bool i_checkForDeath();
1309
1310 void i_getTokenId(Utf8Str &strTokenId);
1311#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1312 IToken *i_getToken();
1313#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1314 // getClientToken must be only used by callers who can guarantee that
1315 // the object cannot be deleted in the mean time, i.e. have a caller/lock.
1316 ClientToken *i_getClientToken();
1317
1318 HRESULT i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1319 HRESULT i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1320 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
1321 IN_BSTR aGuestIp, LONG aGuestPort);
1322 HRESULT i_onStorageControllerChange();
1323 HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1324 HRESULT i_onSerialPortChange(ISerialPort *serialPort);
1325 HRESULT i_onParallelPortChange(IParallelPort *parallelPort);
1326 HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
1327 HRESULT i_onVRDEServerChange(BOOL aRestart);
1328 HRESULT i_onVideoCaptureChange();
1329 HRESULT i_onUSBControllerChange();
1330 HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,
1331 IVirtualBoxErrorInfo *aError,
1332 ULONG aMaskedIfs,
1333 const com::Utf8Str &aCaptureFilename);
1334 HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
1335 IVirtualBoxErrorInfo *aError);
1336 HRESULT i_onSharedFolderChange();
1337 HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
1338 HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
1339 HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1340 HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1341 HRESULT i_onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1342
1343 bool i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1344
1345 HRESULT i_lockMedia();
1346 HRESULT i_unlockMedia();
1347
1348 HRESULT i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress);
1349
1350private:
1351
1352 // wrapped IInternalMachineControl properties
1353
1354 // wrapped IInternalMachineControl methods
1355 HRESULT setRemoveSavedStateFile(BOOL aRemove);
1356 HRESULT updateState(MachineState_T aState);
1357 HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1358 HRESULT endPowerUp(LONG aResult);
1359 HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1360 HRESULT endPoweringDown(LONG aResult,
1361 const com::Utf8Str &aErrMsg);
1362 HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1363 BOOL *aMatched,
1364 ULONG *aMaskedInterfaces);
1365 HRESULT captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
1366 HRESULT detachUSBDevice(const com::Guid &aId,
1367 BOOL aDone);
1368 HRESULT autoCaptureUSBDevices();
1369 HRESULT detachAllUSBDevices(BOOL aDone);
1370 HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1371 ComPtr<IProgress> &aProgress);
1372 HRESULT finishOnlineMergeMedium();
1373 HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1374 std::vector<com::Utf8Str> &aValues,
1375 std::vector<LONG64> &aTimestamps,
1376 std::vector<com::Utf8Str> &aFlags);
1377 HRESULT pushGuestProperty(const com::Utf8Str &aName,
1378 const com::Utf8Str &aValue,
1379 LONG64 aTimestamp,
1380 const com::Utf8Str &aFlags);
1381 HRESULT lockMedia();
1382 HRESULT unlockMedia();
1383 HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1384 ComPtr<IMediumAttachment> &aNewAttachment);
1385 HRESULT reportVmStatistics(ULONG aValidStats,
1386 ULONG aCpuUser,
1387 ULONG aCpuKernel,
1388 ULONG aCpuIdle,
1389 ULONG aMemTotal,
1390 ULONG aMemFree,
1391 ULONG aMemBalloon,
1392 ULONG aMemShared,
1393 ULONG aMemCache,
1394 ULONG aPagedTotal,
1395 ULONG aMemAllocTotal,
1396 ULONG aMemFreeTotal,
1397 ULONG aMemBalloonTotal,
1398 ULONG aMemSharedTotal,
1399 ULONG aVmNetRx,
1400 ULONG aVmNetTx);
1401
1402
1403 struct ConsoleTaskData
1404 {
1405 ConsoleTaskData()
1406 : mLastState(MachineState_Null),
1407 mDeleteSnapshotInfo(NULL)
1408 { }
1409
1410 MachineState_T mLastState;
1411 ComObjPtr<Progress> mProgress;
1412
1413 // used when deleting online snaphshot
1414 void *mDeleteSnapshotInfo;
1415 };
1416
1417 struct SaveStateTask;
1418 struct SnapshotTask;
1419 struct TakeSnapshotTask;
1420 struct DeleteSnapshotTask;
1421 struct RestoreSnapshotTask;
1422
1423 friend struct TakeSnapshotTask;
1424 friend struct DeleteSnapshotTask;
1425 friend struct RestoreSnapshotTask;
1426
1427 void i_saveStateHandler(SaveStateTask &aTask);
1428
1429 // Override some functionality for SessionMachine, this is where the
1430 // real action happens (the Machine methods are just dummies).
1431 HRESULT saveState(ComPtr<IProgress> &aProgress);
1432 HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1433 HRESULT discardSavedState(BOOL aFRemoveFile);
1434 HRESULT takeSnapshot(const com::Utf8Str &aName,
1435 const com::Utf8Str &aDescription,
1436 BOOL aPause,
1437 ComPtr<IProgress> &aProgress);
1438 HRESULT deleteSnapshot(const com::Guid &aId,
1439 ComPtr<IProgress> &aProgress);
1440 HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1441 ComPtr<IProgress> &aProgress);
1442 HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1443 const com::Guid &aEndId,
1444 ComPtr<IProgress> &aProgress);
1445 HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1446 ComPtr<IProgress> &aProgress);
1447
1448 void i_releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1449
1450 void i_takeSnapshotHandler(TakeSnapshotTask &aTask);
1451 static void i_takeSnapshotProgressCancelCallback(void *pvUser);
1452 HRESULT i_finishTakingSnapshot(TakeSnapshotTask &aTask, AutoWriteLock &alock, bool aSuccess);
1453 HRESULT i_deleteSnapshot(const com::Guid &aStartId,
1454 const com::Guid &aEndId,
1455 BOOL aDeleteAllChildren,
1456 ComPtr<IProgress> &aProgress);
1457 void i_deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1458 void i_restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1459
1460 HRESULT i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1461 const Guid &machineId,
1462 const Guid &snapshotId,
1463 bool fOnlineMergePossible,
1464 MediumLockList *aVMMALockList,
1465 ComObjPtr<Medium> &aSource,
1466 ComObjPtr<Medium> &aTarget,
1467 bool &fMergeForward,
1468 ComObjPtr<Medium> &pParentForTarget,
1469 MediumLockList * &aChildrenToReparent,
1470 bool &fNeedOnlineMerge,
1471 MediumLockList * &aMediumLockList,
1472 ComPtr<IToken> &aHDLockToken);
1473 void i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1474 const ComObjPtr<Medium> &aSource,
1475 MediumLockList *aChildrenToReparent,
1476 bool fNeedsOnlineMerge,
1477 MediumLockList *aMediumLockList,
1478 const ComPtr<IToken> &aHDLockToken,
1479 const Guid &aMediumId,
1480 const Guid &aSnapshotId);
1481 HRESULT i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1482 const ComObjPtr<Medium> &aSource,
1483 const ComObjPtr<Medium> &aTarget,
1484 bool fMergeForward,
1485 const ComObjPtr<Medium> &pParentForTarget,
1486 MediumLockList *aChildrenToReparent,
1487 MediumLockList *aMediumLockList,
1488 ComObjPtr<Progress> &aProgress,
1489 bool *pfNeedsMachineSaveSettings);
1490
1491 HRESULT i_setMachineState(MachineState_T aMachineState);
1492 HRESULT i_updateMachineStateOnClient();
1493
1494 bool mRemoveSavedState;
1495
1496 ConsoleTaskData mConsoleTaskData;
1497
1498 /** client token for this machine */
1499 ClientToken *mClientToken;
1500
1501 int miNATNetworksStarted;
1502};
1503
1504// SnapshotMachine class
1505////////////////////////////////////////////////////////////////////////////////
1506
1507/**
1508 * @note Notes on locking objects of this class:
1509 * SnapshotMachine shares some data with the primary Machine instance (pointed
1510 * to by the |mPeer| member). In order to provide data consistency it also
1511 * shares its lock handle. This means that whenever you lock a SessionMachine
1512 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1513 * instance is also locked in the same lock mode. Keep it in mind.
1514 */
1515class ATL_NO_VTABLE SnapshotMachine :
1516 public Machine
1517{
1518public:
1519 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1520
1521 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1522
1523 DECLARE_PROTECT_FINAL_CONSTRUCT()
1524
1525 BEGIN_COM_MAP(SnapshotMachine)
1526 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1527 END_COM_MAP()
1528
1529 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1530
1531 HRESULT FinalConstruct();
1532 void FinalRelease();
1533
1534 // public initializer/uninitializer for internal purposes only
1535 HRESULT init(SessionMachine *aSessionMachine,
1536 IN_GUID aSnapshotId,
1537 const Utf8Str &aStateFilePath);
1538 HRESULT initFromSettings(Machine *aMachine,
1539 const settings::Hardware &hardware,
1540 const settings::Debugging *pDbg,
1541 const settings::Autostart *pAutostart,
1542 const settings::Storage &storage,
1543 IN_GUID aSnapshotId,
1544 const Utf8Str &aStateFilePath);
1545 void uninit();
1546
1547 // util::Lockable interface
1548 RWLockHandle *lockHandle() const;
1549
1550 // public methods only for internal purposes
1551
1552 virtual bool i_isSnapshotMachine() const
1553 {
1554 return true;
1555 }
1556
1557 HRESULT i_onSnapshotChange(Snapshot *aSnapshot);
1558
1559 // unsafe inline public methods for internal purposes only (ensure there is
1560 // a caller and a read lock before calling them!)
1561
1562 const Guid& i_getSnapshotId() const { return mSnapshotId; }
1563
1564private:
1565
1566 Guid mSnapshotId;
1567 /** This field replaces mPeer for SessionMachine instances, as having
1568 * a peer reference is plain meaningless and causes many subtle problems
1569 * with saving settings and the like. */
1570 Machine * const mMachine;
1571
1572 friend class Snapshot;
1573};
1574
1575// third party methods that depend on SnapshotMachine definition
1576
1577inline const Guid &Machine::i_getSnapshotId() const
1578{
1579 return (i_isSnapshotMachine())
1580 ? static_cast<const SnapshotMachine*>(this)->i_getSnapshotId()
1581 : Guid::Empty;
1582}
1583
1584
1585#endif // ____H_MACHINEIMPL
1586/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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