VirtualBox

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

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

Main/StorageController: Fix storage controller renaming, it needs updating all corresponding attachments (otherwise they get instantly lost). Also eliminates some Utf8Str/Bstr conversions, and a bit of whitespace cleanup
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 67.5 KB
Line 
1/* $Id: MachineImpl.h 56820 2015-07-06 15:05:40Z 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 name string (of the primary session) */
152 Utf8Str mName;
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 mTripleFaultReset;
287 ULONG mCPUCount;
288 BOOL mCPUHotPlugEnabled;
289 ULONG mCpuExecutionCap;
290 uint32_t mCpuIdPortabilityLevel;
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
310 FirmwareType_T mFirmwareType;
311 KeyboardHIDType_T mKeyboardHIDType;
312 PointingHIDType_T mPointingHIDType;
313 ChipsetType_T mChipsetType;
314 ParavirtProvider_T mParavirtProvider;
315 BOOL mEmulatedUSBCardReaderEnabled;
316
317 BOOL mIOCacheEnabled;
318 ULONG mIOCacheSize;
319
320 typedef std::list<ComObjPtr<PCIDeviceAttachment> > PCIDeviceAssignmentList;
321 PCIDeviceAssignmentList mPCIDeviceAssignments;
322
323 settings::Debugging mDebugging;
324 settings::Autostart mAutostart;
325
326 Utf8Str mDefaultFrontend;
327 };
328
329 /**
330 * Hard disk and other media data.
331 *
332 * The usage policy is the same as for HWData, but a separate structure
333 * is necessary because hard disk data requires different procedures when
334 * taking or deleting snapshots, etc.
335 *
336 * The data variable is |mMediaData|.
337 */
338 struct MediaData
339 {
340 MediaData();
341 ~MediaData();
342
343 typedef std::list<ComObjPtr<MediumAttachment> > AttachmentList;
344 AttachmentList mAttachments;
345 };
346
347 DECLARE_EMPTY_CTOR_DTOR(Machine)
348
349 HRESULT FinalConstruct();
350 void FinalRelease();
351
352 // public initializer/uninitializer for internal purposes only:
353
354 // initializer for creating a new, empty machine
355 HRESULT init(VirtualBox *aParent,
356 const Utf8Str &strConfigFile,
357 const Utf8Str &strName,
358 const StringsList &llGroups,
359 GuestOSType *aOsType,
360 const Guid &aId,
361 bool fForceOverwrite,
362 bool fDirectoryIncludesUUID);
363
364 // initializer for loading existing machine XML (either registered or not)
365 HRESULT initFromSettings(VirtualBox *aParent,
366 const Utf8Str &strConfigFile,
367 const Guid *aId);
368
369 // initializer for machine config in memory (OVF import)
370 HRESULT init(VirtualBox *aParent,
371 const Utf8Str &strName,
372 const settings::MachineConfigFile &config);
373
374 void uninit();
375
376#ifdef VBOX_WITH_RESOURCE_USAGE_API
377 // Needed from VirtualBox, for the delayed metrics cleanup.
378 void i_unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
379#endif /* VBOX_WITH_RESOURCE_USAGE_API */
380
381protected:
382 HRESULT initImpl(VirtualBox *aParent,
383 const Utf8Str &strConfigFile);
384 HRESULT initDataAndChildObjects();
385 HRESULT i_registeredInit();
386 HRESULT i_tryCreateMachineConfigFile(bool fForceOverwrite);
387 void uninitDataAndChildObjects();
388
389public:
390
391
392 // public methods only for internal purposes
393
394 virtual bool i_isSnapshotMachine() const
395 {
396 return false;
397 }
398
399 virtual bool i_isSessionMachine() const
400 {
401 return false;
402 }
403
404 /**
405 * Override of the default locking class to be used for validating lock
406 * order with the standard member lock handle.
407 */
408 virtual VBoxLockingClass getLockingClass() const
409 {
410 return LOCKCLASS_MACHINEOBJECT;
411 }
412
413 /// @todo (dmik) add lock and make non-inlined after revising classes
414 // that use it. Note: they should enter Machine lock to keep the returned
415 // information valid!
416 bool i_isRegistered() { return !!mData->mRegistered; }
417
418 // unsafe inline public methods for internal purposes only (ensure there is
419 // a caller and a read lock before calling them!)
420
421 /**
422 * Returns the VirtualBox object this machine belongs to.
423 *
424 * @note This method doesn't check this object's readiness. Intended to be
425 * used by ready Machine children (whose readiness is bound to the parent's
426 * one) or after doing addCaller() manually.
427 */
428 VirtualBox* i_getVirtualBox() const { return mParent; }
429
430 /**
431 * Checks if this machine is accessible, without attempting to load the
432 * config file.
433 *
434 * @note This method doesn't check this object's readiness. Intended to be
435 * used by ready Machine children (whose readiness is bound to the parent's
436 * one) or after doing addCaller() manually.
437 */
438 bool i_isAccessible() const { return !!mData->mAccessible; }
439
440 /**
441 * Returns this machine ID.
442 *
443 * @note This method doesn't check this object's readiness. Intended to be
444 * used by ready Machine children (whose readiness is bound to the parent's
445 * one) or after adding a caller manually.
446 */
447 const Guid& i_getId() const { return mData->mUuid; }
448
449 /**
450 * Returns the snapshot ID this machine represents or an empty UUID if this
451 * instance is not SnapshotMachine.
452 *
453 * @note This method doesn't check this object's readiness. Intended to be
454 * used by ready Machine children (whose readiness is bound to the parent's
455 * one) or after adding a caller manually.
456 */
457 inline const Guid& i_getSnapshotId() const;
458
459 /**
460 * Returns this machine's full settings file path.
461 *
462 * @note This method doesn't lock this object or check its readiness.
463 * Intended to be used only after doing addCaller() manually and locking it
464 * for reading.
465 */
466 const Utf8Str& i_getSettingsFileFull() const { return mData->m_strConfigFileFull; }
467
468 /**
469 * Returns this machine name.
470 *
471 * @note This method doesn't lock this object or check its readiness.
472 * Intended to be used only after doing addCaller() manually and locking it
473 * for reading.
474 */
475 const Utf8Str& i_getName() const { return mUserData->s.strName; }
476
477 enum
478 {
479 IsModified_MachineData = 0x0001,
480 IsModified_Storage = 0x0002,
481 IsModified_NetworkAdapters = 0x0008,
482 IsModified_SerialPorts = 0x0010,
483 IsModified_ParallelPorts = 0x0020,
484 IsModified_VRDEServer = 0x0040,
485 IsModified_AudioAdapter = 0x0080,
486 IsModified_USB = 0x0100,
487 IsModified_BIOS = 0x0200,
488 IsModified_SharedFolders = 0x0400,
489 IsModified_Snapshots = 0x0800,
490 IsModified_BandwidthControl = 0x1000
491 };
492
493 /**
494 * Returns various information about this machine.
495 *
496 * @note This method doesn't lock this object or check its readiness.
497 * Intended to be used only after doing addCaller() manually and locking it
498 * for reading.
499 */
500 ChipsetType_T i_getChipsetType() const { return mHWData->mChipsetType; }
501 ParavirtProvider_T i_getParavirtProvider() const { return mHWData->mParavirtProvider; }
502
503 void i_setModified(uint32_t fl, bool fAllowStateModification = true);
504 void i_setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
505
506 bool i_isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
507 void i_allowStateModification() { mData->m_fAllowStateModification = true; }
508 void i_disallowStateModification() { mData->m_fAllowStateModification = false; }
509
510 const StringsList &i_getGroups() const { return mUserData->s.llGroups; }
511
512 // callback handlers
513 virtual HRESULT i_onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
514 virtual HRESULT i_onNATRedirectRuleChange(ULONG /* slot */, BOOL /* fRemove */ , IN_BSTR /* name */,
515 NATProtocol_T /* protocol */, IN_BSTR /* host ip */, LONG /* host port */,
516 IN_BSTR /* guest port */, LONG /* guest port */ ) { return S_OK; }
517 virtual HRESULT i_onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
518 virtual HRESULT i_onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
519 virtual HRESULT i_onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
520 virtual HRESULT i_onUSBControllerChange() { return S_OK; }
521 virtual HRESULT i_onStorageControllerChange() { return S_OK; }
522 virtual HRESULT i_onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
523 virtual HRESULT i_onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
524 virtual HRESULT i_onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
525 virtual HRESULT i_onSharedFolderChange() { return S_OK; }
526 virtual HRESULT i_onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
527 virtual HRESULT i_onDnDModeChange(DnDMode_T /* aDnDMode */) { return S_OK; }
528 virtual HRESULT i_onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
529 virtual HRESULT i_onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */,
530 BOOL /* silent */) { return S_OK; }
531 virtual HRESULT i_onVideoCaptureChange() { return S_OK; }
532
533 HRESULT i_saveRegistryEntry(settings::MachineRegistryEntry &data);
534
535 int i_calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
536 void i_copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
537
538 void i_getLogFolder(Utf8Str &aLogFolder);
539 Utf8Str i_queryLogFilename(ULONG idx);
540 Utf8Str i_getStartupLogFilename(void);
541
542 void i_composeSavedStateFilename(Utf8Str &strStateFilePath);
543
544 void i_getDefaultVideoCaptureFile(Utf8Str &strFile);
545
546 bool i_isUSBControllerPresent();
547
548 HRESULT i_launchVMProcess(IInternalSessionControl *aControl,
549 const Utf8Str &strType,
550 const Utf8Str &strEnvironment,
551 ProgressProxy *aProgress);
552
553 HRESULT i_getDirectControl(ComPtr<IInternalSessionControl> *directControl)
554 {
555 HRESULT rc;
556 *directControl = mData->mSession.mDirectControl;
557
558 if (!*directControl)
559 rc = E_ACCESSDENIED;
560 else
561 rc = S_OK;
562
563 return rc;
564 }
565
566 bool i_isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
567 ComPtr<IInternalSessionControl> *aControl = NULL,
568 bool aAllowClosing = false);
569 bool i_isSessionSpawning();
570
571 bool i_isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
572 ComPtr<IInternalSessionControl> *aControl = NULL)
573 { return i_isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
574
575 bool i_checkForSpawnFailure();
576
577 HRESULT i_prepareRegister();
578
579 HRESULT i_getSharedFolder(CBSTR aName,
580 ComObjPtr<SharedFolder> &aSharedFolder,
581 bool aSetError = false)
582 {
583 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
584 return i_findSharedFolder(aName, aSharedFolder, aSetError);
585 }
586
587 HRESULT i_addStateDependency(StateDependency aDepType = AnyStateDep,
588 MachineState_T *aState = NULL,
589 BOOL *aRegistered = NULL);
590 void i_releaseStateDependency();
591
592 HRESULT i_getStorageControllerByName(const Utf8Str &aName,
593 ComObjPtr<StorageController> &aStorageController,
594 bool aSetError = false);
595
596 HRESULT i_getMediumAttachmentsOfController(const Utf8Str &aName,
597 MediaData::AttachmentList &aAttachments);
598
599 HRESULT i_getUSBControllerByName(const Utf8Str &aName,
600 ComObjPtr<USBController> &aUSBController,
601 bool aSetError = false);
602
603 HRESULT i_getBandwidthGroup(const Utf8Str &strBandwidthGroup,
604 ComObjPtr<BandwidthGroup> &pBandwidthGroup,
605 bool fSetError = false)
606 {
607 return mBandwidthControl->i_getBandwidthGroupByName(strBandwidthGroup,
608 pBandwidthGroup,
609 fSetError);
610 }
611
612 static HRESULT i_setErrorStatic(HRESULT aResultCode, const char *pcszMsg, ...);
613
614protected:
615
616 class ClientToken;
617
618 HRESULT i_checkStateDependency(StateDependency aDepType);
619
620 Machine *i_getMachine();
621
622 void i_ensureNoStateDependencies();
623
624 virtual HRESULT i_setMachineState(MachineState_T aMachineState);
625
626 HRESULT i_findSharedFolder(const Utf8Str &aName,
627 ComObjPtr<SharedFolder> &aSharedFolder,
628 bool aSetError = false);
629
630 HRESULT i_loadSettings(bool aRegistered);
631 HRESULT i_loadMachineDataFromSettings(const settings::MachineConfigFile &config,
632 const Guid *puuidRegistry);
633 HRESULT i_loadSnapshot(const settings::Snapshot &data,
634 const Guid &aCurSnapshotId,
635 Snapshot *aParentSnapshot);
636 HRESULT i_loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
637 const settings::Autostart *pAutostart);
638 HRESULT i_loadDebugging(const settings::Debugging *pDbg);
639 HRESULT i_loadAutostart(const settings::Autostart *pAutostart);
640 HRESULT i_loadStorageControllers(const settings::Storage &data,
641 const Guid *puuidRegistry,
642 const Guid *puuidSnapshot);
643 HRESULT i_loadStorageDevices(StorageController *aStorageController,
644 const settings::StorageController &data,
645 const Guid *puuidRegistry,
646 const Guid *puuidSnapshot);
647
648 HRESULT i_findSnapshotById(const Guid &aId,
649 ComObjPtr<Snapshot> &aSnapshot,
650 bool aSetError = false);
651 HRESULT i_findSnapshotByName(const Utf8Str &strName,
652 ComObjPtr<Snapshot> &aSnapshot,
653 bool aSetError = false);
654
655 ULONG i_getUSBControllerCountByType(USBControllerType_T enmType);
656
657 enum
658 {
659 /* flags for #saveSettings() */
660 SaveS_ResetCurStateModified = 0x01,
661 SaveS_InformCallbacksAnyway = 0x02,
662 SaveS_Force = 0x04,
663 /* flags for #saveStateSettings() */
664 SaveSTS_CurStateModified = 0x20,
665 SaveSTS_StateFilePath = 0x40,
666 SaveSTS_StateTimeStamp = 0x80
667 };
668
669 HRESULT i_prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
670 HRESULT i_saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
671
672 void i_copyMachineDataToSettings(settings::MachineConfigFile &config);
673 HRESULT i_saveAllSnapshots(settings::MachineConfigFile &config);
674 HRESULT i_saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
675 settings::Autostart *pAutostart);
676 HRESULT i_saveStorageControllers(settings::Storage &data);
677 HRESULT i_saveStorageDevices(ComObjPtr<StorageController> aStorageController,
678 settings::StorageController &data);
679 HRESULT i_saveStateSettings(int aFlags);
680
681 void i_addMediumToRegistry(ComObjPtr<Medium> &pMedium);
682
683 HRESULT i_createImplicitDiffs(IProgress *aProgress,
684 ULONG aWeight,
685 bool aOnline);
686 HRESULT i_deleteImplicitDiffs(bool aOnline);
687
688 MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
689 const Utf8Str &aControllerName,
690 LONG aControllerPort,
691 LONG aDevice);
692 MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
693 ComObjPtr<Medium> pMedium);
694 MediumAttachment* i_findAttachment(const MediaData::AttachmentList &ll,
695 Guid &id);
696
697 HRESULT i_detachDevice(MediumAttachment *pAttach,
698 AutoWriteLock &writeLock,
699 Snapshot *pSnapshot);
700
701 HRESULT i_detachAllMedia(AutoWriteLock &writeLock,
702 Snapshot *pSnapshot,
703 CleanupMode_T cleanupMode,
704 MediaList &llMedia);
705
706 void i_commitMedia(bool aOnline = false);
707 void i_rollbackMedia();
708
709 bool i_isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
710
711 void i_rollback(bool aNotify);
712 void i_commit();
713 void i_copyFrom(Machine *aThat);
714 bool i_isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
715
716 Utf8Str i_getExtraData(const Utf8Str &strKey);
717
718#ifdef VBOX_WITH_GUEST_PROPS
719 HRESULT i_getGuestPropertyFromService(const com::Utf8Str &aName, com::Utf8Str &aValue,
720 LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
721 HRESULT i_setGuestPropertyToService(const com::Utf8Str &aName, const com::Utf8Str &aValue,
722 const com::Utf8Str &aFlags, bool fDelete);
723 HRESULT i_getGuestPropertyFromVM(const com::Utf8Str &aName, com::Utf8Str &aValue,
724 LONG64 *aTimestamp, com::Utf8Str &aFlags) const;
725 HRESULT i_setGuestPropertyToVM(const com::Utf8Str &aName, const com::Utf8Str &aValue,
726 const com::Utf8Str &aFlags, bool fDelete);
727 HRESULT i_enumerateGuestPropertiesInService(const com::Utf8Str &aPatterns,
728 std::vector<com::Utf8Str> &aNames,
729 std::vector<com::Utf8Str> &aValues,
730 std::vector<LONG64> &aTimestamps,
731 std::vector<com::Utf8Str> &aFlags);
732 HRESULT i_enumerateGuestPropertiesOnVM(const com::Utf8Str &aPatterns,
733 std::vector<com::Utf8Str> &aNames,
734 std::vector<com::Utf8Str> &aValues,
735 std::vector<LONG64> &aTimestamps,
736 std::vector<com::Utf8Str> &aFlags);
737
738#endif /* VBOX_WITH_GUEST_PROPS */
739
740#ifdef VBOX_WITH_RESOURCE_USAGE_API
741 void i_getDiskList(MediaList &list);
742 void i_registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
743
744 pm::CollectorGuest *mCollectorGuest;
745#endif /* VBOX_WITH_RESOURCE_USAGE_API */
746
747 Machine * const mPeer;
748
749 VirtualBox * const mParent;
750
751 Shareable<Data> mData;
752 Shareable<SSData> mSSData;
753
754 Backupable<UserData> mUserData;
755 Backupable<HWData> mHWData;
756 Backupable<MediaData> mMediaData;
757
758 // the following fields need special backup/rollback/commit handling,
759 // so they cannot be a part of HWData
760
761 const ComObjPtr<VRDEServer> mVRDEServer;
762 const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
763 const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
764 const ComObjPtr<AudioAdapter> mAudioAdapter;
765 const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
766 const ComObjPtr<BIOSSettings> mBIOSSettings;
767 const ComObjPtr<BandwidthControl> mBandwidthControl;
768
769 typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
770 NetworkAdapterVector mNetworkAdapters;
771
772 typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
773 Backupable<StorageControllerList> mStorageControllers;
774
775 typedef std::list<ComObjPtr<USBController> > USBControllerList;
776 Backupable<USBControllerList> mUSBControllers;
777
778 uint64_t uRegistryNeedsSaving;
779
780 /**
781 * Abstract base class for all Machine or SessionMachine related
782 * asynchronous tasks. This is necessary since RTThreadCreate cannot call
783 * a (non-static) method as its thread function, so instead we have it call
784 * the static Machine::taskHandler, which then calls the handler() method
785 * in here (implemented by the subclasses).
786 */
787 struct Task
788 {
789 Task(Machine *m, Progress *p, const Utf8Str &t)
790 : m_pMachine(m),
791 m_machineCaller(m),
792 m_pProgress(p),
793 m_strTaskName(t),
794 m_machineStateBackup(m->mData->mMachineState) // save the current machine state
795 {}
796
797 HRESULT createThread()
798 {
799 int vrc = RTThreadCreate(NULL,
800 taskHandler,
801 (void *)this,
802 0,
803 RTTHREADTYPE_MAIN_WORKER,
804 0,
805 m_strTaskName.c_str());
806 if (RT_FAILURE(vrc))
807 {
808 HRESULT rc = Machine::i_setErrorStatic(E_FAIL, Machine::tr("Could not create thread \"%s\" (%Rrc)"), m_strTaskName.c_str(), vrc);
809 delete this;
810 return rc;
811 }
812 return S_OK;
813 }
814
815 void modifyBackedUpState(MachineState_T s)
816 {
817 *const_cast<MachineState_T *>(&m_machineStateBackup) = s;
818 }
819
820 virtual void handler() = 0;
821
822 ComObjPtr<Machine> m_pMachine;
823 AutoCaller m_machineCaller;
824 ComObjPtr<Progress> m_pProgress;
825 Utf8Str m_strTaskName;
826 const MachineState_T m_machineStateBackup;
827 };
828
829 struct DeleteConfigTask;
830 void i_deleteConfigHandler(DeleteConfigTask &task);
831
832 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
833
834 friend class SessionMachine;
835 friend class SnapshotMachine;
836 friend class Appliance;
837 friend class VirtualBox;
838
839 friend class MachineCloneVM;
840
841private:
842 // wrapped IMachine properties
843 HRESULT getParent(ComPtr<IVirtualBox> &aParent);
844 HRESULT getIcon(std::vector<BYTE> &aIcon);
845 HRESULT setIcon(const std::vector<BYTE> &aIcon);
846 HRESULT getAccessible(BOOL *aAccessible);
847 HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError);
848 HRESULT getName(com::Utf8Str &aName);
849 HRESULT setName(const com::Utf8Str &aName);
850 HRESULT getDescription(com::Utf8Str &aDescription);
851 HRESULT setDescription(const com::Utf8Str &aDescription);
852 HRESULT getId(com::Guid &aId);
853 HRESULT getGroups(std::vector<com::Utf8Str> &aGroups);
854 HRESULT setGroups(const std::vector<com::Utf8Str> &aGroups);
855 HRESULT getOSTypeId(com::Utf8Str &aOSTypeId);
856 HRESULT setOSTypeId(const com::Utf8Str &aOSTypeId);
857 HRESULT getHardwareVersion(com::Utf8Str &aHardwareVersion);
858 HRESULT setHardwareVersion(const com::Utf8Str &aHardwareVersion);
859 HRESULT getHardwareUUID(com::Guid &aHardwareUUID);
860 HRESULT setHardwareUUID(const com::Guid &aHardwareUUID);
861 HRESULT getCPUCount(ULONG *aCPUCount);
862 HRESULT setCPUCount(ULONG aCPUCount);
863 HRESULT getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled);
864 HRESULT setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled);
865 HRESULT getCPUExecutionCap(ULONG *aCPUExecutionCap);
866 HRESULT setCPUExecutionCap(ULONG aCPUExecutionCap);
867 HRESULT getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel);
868 HRESULT setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel);
869 HRESULT getMemorySize(ULONG *aMemorySize);
870 HRESULT setMemorySize(ULONG aMemorySize);
871 HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize);
872 HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize);
873 HRESULT getPageFusionEnabled(BOOL *aPageFusionEnabled);
874 HRESULT setPageFusionEnabled(BOOL aPageFusionEnabled);
875 HRESULT getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType);
876 HRESULT setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType);
877 HRESULT getVRAMSize(ULONG *aVRAMSize);
878 HRESULT setVRAMSize(ULONG aVRAMSize);
879 HRESULT getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled);
880 HRESULT setAccelerate3DEnabled(BOOL aAccelerate3DEnabled);
881 HRESULT getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled);
882 HRESULT setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled);
883 HRESULT getMonitorCount(ULONG *aMonitorCount);
884 HRESULT setMonitorCount(ULONG aMonitorCount);
885 HRESULT getVideoCaptureEnabled(BOOL *aVideoCaptureEnabled);
886 HRESULT setVideoCaptureEnabled(BOOL aVideoCaptureEnabled);
887 HRESULT getVideoCaptureScreens(std::vector<BOOL> &aVideoCaptureScreens);
888 HRESULT setVideoCaptureScreens(const std::vector<BOOL> &aVideoCaptureScreens);
889 HRESULT getVideoCaptureFile(com::Utf8Str &aVideoCaptureFile);
890 HRESULT setVideoCaptureFile(const com::Utf8Str &aVideoCaptureFile);
891 HRESULT getVideoCaptureWidth(ULONG *aVideoCaptureWidth);
892 HRESULT setVideoCaptureWidth(ULONG aVideoCaptureWidth);
893 HRESULT getVideoCaptureHeight(ULONG *aVideoCaptureHeight);
894 HRESULT setVideoCaptureHeight(ULONG aVideoCaptureHeight);
895 HRESULT getVideoCaptureRate(ULONG *aVideoCaptureRate);
896 HRESULT setVideoCaptureRate(ULONG aVideoCaptureRate);
897 HRESULT getVideoCaptureFPS(ULONG *aVideoCaptureFPS);
898 HRESULT setVideoCaptureFPS(ULONG aVideoCaptureFPS);
899 HRESULT getVideoCaptureMaxTime(ULONG *aVideoCaptureMaxTime);
900 HRESULT setVideoCaptureMaxTime(ULONG aVideoCaptureMaxTime);
901 HRESULT getVideoCaptureMaxFileSize(ULONG *aVideoCaptureMaxFileSize);
902 HRESULT setVideoCaptureMaxFileSize(ULONG aVideoCaptureMaxFileSize);
903 HRESULT getVideoCaptureOptions(com::Utf8Str &aVideoCaptureOptions);
904 HRESULT setVideoCaptureOptions(const com::Utf8Str &aVideoCaptureOptions);
905 HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings);
906 HRESULT getFirmwareType(FirmwareType_T *aFirmwareType);
907 HRESULT setFirmwareType(FirmwareType_T aFirmwareType);
908 HRESULT getPointingHIDType(PointingHIDType_T *aPointingHIDType);
909 HRESULT setPointingHIDType(PointingHIDType_T aPointingHIDType);
910 HRESULT getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType);
911 HRESULT setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType);
912 HRESULT getHPETEnabled(BOOL *aHPETEnabled);
913 HRESULT setHPETEnabled(BOOL aHPETEnabled);
914 HRESULT getChipsetType(ChipsetType_T *aChipsetType);
915 HRESULT setChipsetType(ChipsetType_T aChipsetType);
916 HRESULT getSnapshotFolder(com::Utf8Str &aSnapshotFolder);
917 HRESULT setSnapshotFolder(const com::Utf8Str &aSnapshotFolder);
918 HRESULT getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer);
919 HRESULT getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled);
920 HRESULT setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled);
921 HRESULT getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
922 HRESULT getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers);
923 HRESULT getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters);
924 HRESULT getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter);
925 HRESULT getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers);
926 HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath);
927 HRESULT getSettingsModified(BOOL *aSettingsModified);
928 HRESULT getSessionState(SessionState_T *aSessionState);
929 HRESULT getSessionType(SessionType_T *aSessionType);
930 HRESULT getSessionName(com::Utf8Str &aSessionType);
931 HRESULT getSessionPID(ULONG *aSessionPID);
932 HRESULT getState(MachineState_T *aState);
933 HRESULT getLastStateChange(LONG64 *aLastStateChange);
934 HRESULT getStateFilePath(com::Utf8Str &aStateFilePath);
935 HRESULT getLogFolder(com::Utf8Str &aLogFolder);
936 HRESULT getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot);
937 HRESULT getSnapshotCount(ULONG *aSnapshotCount);
938 HRESULT getCurrentStateModified(BOOL *aCurrentStateModified);
939 HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders);
940 HRESULT getClipboardMode(ClipboardMode_T *aClipboardMode);
941 HRESULT setClipboardMode(ClipboardMode_T aClipboardMode);
942 HRESULT getDnDMode(DnDMode_T *aDnDMode);
943 HRESULT setDnDMode(DnDMode_T aDnDMode);
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 HRESULT getVMProcessPriority(com::Utf8Str &aVMProcessPriority);
988 HRESULT setVMProcessPriority(const com::Utf8Str &aVMProcessPriority);
989
990 // wrapped IMachine methods
991 HRESULT lockMachine(const ComPtr<ISession> &aSession,
992 LockType_T aLockType);
993 HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
994 const com::Utf8Str &aType,
995 const com::Utf8Str &aEnvironment,
996 ComPtr<IProgress> &aProgress);
997 HRESULT setBootOrder(ULONG aPosition,
998 DeviceType_T aDevice);
999 HRESULT getBootOrder(ULONG aPosition,
1000 DeviceType_T *aDevice);
1001 HRESULT attachDevice(const com::Utf8Str &aName,
1002 LONG aControllerPort,
1003 LONG aDevice,
1004 DeviceType_T aType,
1005 const ComPtr<IMedium> &aMedium);
1006 HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
1007 LONG aControllerPort,
1008 LONG aDevice,
1009 DeviceType_T aType);
1010 HRESULT detachDevice(const com::Utf8Str &aName,
1011 LONG aControllerPort,
1012 LONG aDevice);
1013 HRESULT passthroughDevice(const com::Utf8Str &aName,
1014 LONG aControllerPort,
1015 LONG aDevice,
1016 BOOL aPassthrough);
1017 HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
1018 LONG aControllerPort,
1019 LONG aDevice,
1020 BOOL aTemporaryEject);
1021 HRESULT nonRotationalDevice(const com::Utf8Str &aName,
1022 LONG aControllerPort,
1023 LONG aDevice,
1024 BOOL aNonRotational);
1025 HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
1026 LONG aControllerPort,
1027 LONG aDevice,
1028 BOOL aDiscard);
1029 HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
1030 LONG aControllerPort,
1031 LONG aDevice,
1032 BOOL aHotPluggable);
1033 HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
1034 LONG aControllerPort,
1035 LONG aDevice,
1036 const ComPtr<IBandwidthGroup> &aBandwidthGroup);
1037 HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
1038 LONG aControllerPort,
1039 LONG aDevice);
1040 HRESULT unmountMedium(const com::Utf8Str &aName,
1041 LONG aControllerPort,
1042 LONG aDevice,
1043 BOOL aForce);
1044 HRESULT mountMedium(const com::Utf8Str &aName,
1045 LONG aControllerPort,
1046 LONG aDevice,
1047 const ComPtr<IMedium> &aMedium,
1048 BOOL aForce);
1049 HRESULT getMedium(const com::Utf8Str &aName,
1050 LONG aControllerPort,
1051 LONG aDevice,
1052 ComPtr<IMedium> &aMedium);
1053 HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
1054 std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments);
1055 HRESULT getMediumAttachment(const com::Utf8Str &aName,
1056 LONG aControllerPort,
1057 LONG aDevice,
1058 ComPtr<IMediumAttachment> &aAttachment);
1059 HRESULT attachHostPCIDevice(LONG aHostAddress,
1060 LONG aDesiredGuestAddress,
1061 BOOL aTryToUnbind);
1062 HRESULT detachHostPCIDevice(LONG aHostAddress);
1063 HRESULT getNetworkAdapter(ULONG aSlot,
1064 ComPtr<INetworkAdapter> &aAdapter);
1065 HRESULT addStorageController(const com::Utf8Str &aName,
1066 StorageBus_T aConnectionType,
1067 ComPtr<IStorageController> &aController);
1068 HRESULT getStorageControllerByName(const com::Utf8Str &aName,
1069 ComPtr<IStorageController> &aStorageController);
1070 HRESULT getStorageControllerByInstance(StorageBus_T aConnectionType,
1071 ULONG aInstance,
1072 ComPtr<IStorageController> &aStorageController);
1073 HRESULT removeStorageController(const com::Utf8Str &aName);
1074 HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
1075 BOOL aBootable);
1076 HRESULT addUSBController(const com::Utf8Str &aName,
1077 USBControllerType_T aType,
1078 ComPtr<IUSBController> &aController);
1079 HRESULT removeUSBController(const com::Utf8Str &aName);
1080 HRESULT getUSBControllerByName(const com::Utf8Str &aName,
1081 ComPtr<IUSBController> &aController);
1082 HRESULT getUSBControllerCountByType(USBControllerType_T aType,
1083 ULONG *aControllers);
1084 HRESULT getSerialPort(ULONG aSlot,
1085 ComPtr<ISerialPort> &aPort);
1086 HRESULT getParallelPort(ULONG aSlot,
1087 ComPtr<IParallelPort> &aPort);
1088 HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys);
1089 HRESULT getExtraData(const com::Utf8Str &aKey,
1090 com::Utf8Str &aValue);
1091 HRESULT setExtraData(const com::Utf8Str &aKey,
1092 const com::Utf8Str &aValue);
1093 HRESULT getCPUProperty(CPUPropertyType_T aProperty,
1094 BOOL *aValue);
1095 HRESULT setCPUProperty(CPUPropertyType_T aProperty,
1096 BOOL aValue);
1097 HRESULT getCPUIDLeaf(ULONG aId,
1098 ULONG *aValEax,
1099 ULONG *aValEbx,
1100 ULONG *aValEcx,
1101 ULONG *aValEdx);
1102 HRESULT setCPUIDLeaf(ULONG aId,
1103 ULONG aValEax,
1104 ULONG aValEbx,
1105 ULONG aValEcx,
1106 ULONG aValEdx);
1107 HRESULT removeCPUIDLeaf(ULONG aId);
1108 HRESULT removeAllCPUIDLeaves();
1109 HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1110 BOOL *aValue);
1111 HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
1112 BOOL aValue);
1113 HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
1114 ComPtr<IProgress> &aProgress);
1115 HRESULT saveSettings();
1116 HRESULT discardSettings();
1117 HRESULT unregister(AutoCaller &aAutoCaller,
1118 CleanupMode_T aCleanupMode,
1119 std::vector<ComPtr<IMedium> > &aMedia);
1120 HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
1121 ComPtr<IProgress> &aProgress);
1122 HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
1123 const com::Utf8Str &aLocation,
1124 ComPtr<IVirtualSystemDescription> &aDescription);
1125 HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
1126 ComPtr<ISnapshot> &aSnapshot);
1127 HRESULT createSharedFolder(const com::Utf8Str &aName,
1128 const com::Utf8Str &aHostPath,
1129 BOOL aWritable,
1130 BOOL aAutomount);
1131 HRESULT removeSharedFolder(const com::Utf8Str &aName);
1132 HRESULT canShowConsoleWindow(BOOL *aCanShow);
1133 HRESULT showConsoleWindow(LONG64 *aWinId);
1134 HRESULT getGuestProperty(const com::Utf8Str &aName,
1135 com::Utf8Str &aValue,
1136 LONG64 *aTimestamp,
1137 com::Utf8Str &aFlags);
1138 HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
1139 com::Utf8Str &aValue);
1140 HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
1141 LONG64 *aValue);
1142 HRESULT setGuestProperty(const com::Utf8Str &aProperty,
1143 const com::Utf8Str &aValue,
1144 const com::Utf8Str &aFlags);
1145 HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
1146 const com::Utf8Str &aValue);
1147 HRESULT deleteGuestProperty(const com::Utf8Str &aName);
1148 HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
1149 std::vector<com::Utf8Str> &aNames,
1150 std::vector<com::Utf8Str> &aValues,
1151 std::vector<LONG64> &aTimestamps,
1152 std::vector<com::Utf8Str> &aFlags);
1153 HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
1154 ULONG *aOriginX,
1155 ULONG *aOriginY,
1156 ULONG *aWidth,
1157 ULONG *aHeight,
1158 BOOL *aEnabled);
1159 HRESULT readSavedThumbnailToArray(ULONG aScreenId,
1160 BitmapFormat_T aBitmapFormat,
1161 ULONG *aWidth,
1162 ULONG *aHeight,
1163 std::vector<BYTE> &aData);
1164 HRESULT querySavedScreenshotInfo(ULONG aScreenId,
1165 ULONG *aWidth,
1166 ULONG *aHeight,
1167 std::vector<BitmapFormat_T> &aBitmapFormats);
1168 HRESULT readSavedScreenshotToArray(ULONG aScreenId,
1169 BitmapFormat_T aBitmapFormat,
1170 ULONG *aWidth,
1171 ULONG *aHeight,
1172 std::vector<BYTE> &aData);
1173
1174 HRESULT hotPlugCPU(ULONG aCpu);
1175 HRESULT hotUnplugCPU(ULONG aCpu);
1176 HRESULT getCPUStatus(ULONG aCpu,
1177 BOOL *aAttached);
1178 HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider);
1179 HRESULT queryLogFilename(ULONG aIdx,
1180 com::Utf8Str &aFilename);
1181 HRESULT readLog(ULONG aIdx,
1182 LONG64 aOffset,
1183 LONG64 aSize,
1184 std::vector<BYTE> &aData);
1185 HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
1186 CloneMode_T aMode,
1187 const std::vector<CloneOptions_T> &aOptions,
1188 ComPtr<IProgress> &aProgress);
1189 HRESULT saveState(ComPtr<IProgress> &aProgress);
1190 HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1191 HRESULT discardSavedState(BOOL aFRemoveFile);
1192 HRESULT takeSnapshot(const com::Utf8Str &aName,
1193 const com::Utf8Str &aDescription,
1194 BOOL aPause,
1195 com::Guid &aId,
1196 ComPtr<IProgress> &aProgress);
1197 HRESULT deleteSnapshot(const com::Guid &aId,
1198 ComPtr<IProgress> &aProgress);
1199 HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1200 ComPtr<IProgress> &aProgress);
1201 HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1202 const com::Guid &aEndId,
1203 ComPtr<IProgress> &aProgress);
1204 HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1205 ComPtr<IProgress> &aProgress);
1206 HRESULT applyDefaults(const com::Utf8Str &aFlags);
1207
1208 // wrapped IInternalMachineControl properties
1209
1210 // wrapped IInternalMachineControl methods
1211 HRESULT updateState(MachineState_T aState);
1212 HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1213 HRESULT endPowerUp(LONG aResult);
1214 HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1215 HRESULT endPoweringDown(LONG aResult,
1216 const com::Utf8Str &aErrMsg);
1217 HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1218 BOOL *aMatched,
1219 ULONG *aMaskedInterfaces);
1220 HRESULT captureUSBDevice(const com::Guid &aId,
1221 const com::Utf8Str &aCaptureFilename);
1222 HRESULT detachUSBDevice(const com::Guid &aId,
1223 BOOL aDone);
1224 HRESULT autoCaptureUSBDevices();
1225 HRESULT detachAllUSBDevices(BOOL aDone);
1226 HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1227 ComPtr<IProgress> &aProgress);
1228 HRESULT finishOnlineMergeMedium();
1229 HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1230 std::vector<com::Utf8Str> &aValues,
1231 std::vector<LONG64> &aTimestamps,
1232 std::vector<com::Utf8Str> &aFlags);
1233 HRESULT pushGuestProperty(const com::Utf8Str &aName,
1234 const com::Utf8Str &aValue,
1235 LONG64 aTimestamp,
1236 const com::Utf8Str &aFlags);
1237 HRESULT lockMedia();
1238 HRESULT unlockMedia();
1239 HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1240 ComPtr<IMediumAttachment> &aNewAttachment);
1241 HRESULT reportVmStatistics(ULONG aValidStats,
1242 ULONG aCpuUser,
1243 ULONG aCpuKernel,
1244 ULONG aCpuIdle,
1245 ULONG aMemTotal,
1246 ULONG aMemFree,
1247 ULONG aMemBalloon,
1248 ULONG aMemShared,
1249 ULONG aMemCache,
1250 ULONG aPagedTotal,
1251 ULONG aMemAllocTotal,
1252 ULONG aMemFreeTotal,
1253 ULONG aMemBalloonTotal,
1254 ULONG aMemSharedTotal,
1255 ULONG aVmNetRx,
1256 ULONG aVmNetTx);
1257};
1258
1259// SessionMachine class
1260////////////////////////////////////////////////////////////////////////////////
1261
1262/**
1263 * @note Notes on locking objects of this class:
1264 * SessionMachine shares some data with the primary Machine instance (pointed
1265 * to by the |mPeer| member). In order to provide data consistency it also
1266 * shares its lock handle. This means that whenever you lock a SessionMachine
1267 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1268 * instance is also locked in the same lock mode. Keep it in mind.
1269 */
1270class ATL_NO_VTABLE SessionMachine :
1271 public Machine
1272{
1273public:
1274 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1275
1276 DECLARE_NOT_AGGREGATABLE(SessionMachine)
1277
1278 DECLARE_PROTECT_FINAL_CONSTRUCT()
1279
1280 BEGIN_COM_MAP(SessionMachine)
1281 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1282 COM_INTERFACE_ENTRY(IInternalMachineControl)
1283 END_COM_MAP()
1284
1285 DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1286
1287 HRESULT FinalConstruct();
1288 void FinalRelease();
1289
1290 struct Uninit
1291 {
1292 enum Reason { Unexpected, Abnormal, Normal };
1293 };
1294
1295 // public initializer/uninitializer for internal purposes only
1296 HRESULT init(Machine *aMachine);
1297 void uninit() { uninit(Uninit::Unexpected); }
1298 void uninit(Uninit::Reason aReason);
1299
1300
1301 // util::Lockable interface
1302 RWLockHandle *lockHandle() const;
1303
1304 // public methods only for internal purposes
1305
1306 virtual bool i_isSessionMachine() const
1307 {
1308 return true;
1309 }
1310
1311#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
1312 bool i_checkForDeath();
1313
1314 void i_getTokenId(Utf8Str &strTokenId);
1315#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1316 IToken *i_getToken();
1317#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1318 // getClientToken must be only used by callers who can guarantee that
1319 // the object cannot be deleted in the mean time, i.e. have a caller/lock.
1320 ClientToken *i_getClientToken();
1321
1322 HRESULT i_onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1323 HRESULT i_onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1324 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort,
1325 IN_BSTR aGuestIp, LONG aGuestPort);
1326 HRESULT i_onStorageControllerChange();
1327 HRESULT i_onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1328 HRESULT i_onSerialPortChange(ISerialPort *serialPort);
1329 HRESULT i_onParallelPortChange(IParallelPort *parallelPort);
1330 HRESULT i_onCPUChange(ULONG aCPU, BOOL aRemove);
1331 HRESULT i_onVRDEServerChange(BOOL aRestart);
1332 HRESULT i_onVideoCaptureChange();
1333 HRESULT i_onUSBControllerChange();
1334 HRESULT i_onUSBDeviceAttach(IUSBDevice *aDevice,
1335 IVirtualBoxErrorInfo *aError,
1336 ULONG aMaskedIfs,
1337 const com::Utf8Str &aCaptureFilename);
1338 HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
1339 IVirtualBoxErrorInfo *aError);
1340 HRESULT i_onSharedFolderChange();
1341 HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode);
1342 HRESULT i_onDnDModeChange(DnDMode_T aDnDMode);
1343 HRESULT i_onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1344 HRESULT i_onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1345 HRESULT i_onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1346
1347 bool i_hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1348
1349 HRESULT i_lockMedia();
1350 HRESULT i_unlockMedia();
1351
1352 HRESULT i_saveStateWithReason(Reason_T aReason, ComPtr<IProgress> &aProgress);
1353
1354private:
1355
1356 // wrapped IInternalMachineControl properties
1357
1358 // wrapped IInternalMachineControl methods
1359 HRESULT setRemoveSavedStateFile(BOOL aRemove);
1360 HRESULT updateState(MachineState_T aState);
1361 HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress);
1362 HRESULT endPowerUp(LONG aResult);
1363 HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress);
1364 HRESULT endPoweringDown(LONG aResult,
1365 const com::Utf8Str &aErrMsg);
1366 HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
1367 BOOL *aMatched,
1368 ULONG *aMaskedInterfaces);
1369 HRESULT captureUSBDevice(const com::Guid &aId, const com::Utf8Str &aCaptureFilename);
1370 HRESULT detachUSBDevice(const com::Guid &aId,
1371 BOOL aDone);
1372 HRESULT autoCaptureUSBDevices();
1373 HRESULT detachAllUSBDevices(BOOL aDone);
1374 HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
1375 ComPtr<IProgress> &aProgress);
1376 HRESULT finishOnlineMergeMedium();
1377 HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
1378 std::vector<com::Utf8Str> &aValues,
1379 std::vector<LONG64> &aTimestamps,
1380 std::vector<com::Utf8Str> &aFlags);
1381 HRESULT pushGuestProperty(const com::Utf8Str &aName,
1382 const com::Utf8Str &aValue,
1383 LONG64 aTimestamp,
1384 const com::Utf8Str &aFlags);
1385 HRESULT lockMedia();
1386 HRESULT unlockMedia();
1387 HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
1388 ComPtr<IMediumAttachment> &aNewAttachment);
1389 HRESULT reportVmStatistics(ULONG aValidStats,
1390 ULONG aCpuUser,
1391 ULONG aCpuKernel,
1392 ULONG aCpuIdle,
1393 ULONG aMemTotal,
1394 ULONG aMemFree,
1395 ULONG aMemBalloon,
1396 ULONG aMemShared,
1397 ULONG aMemCache,
1398 ULONG aPagedTotal,
1399 ULONG aMemAllocTotal,
1400 ULONG aMemFreeTotal,
1401 ULONG aMemBalloonTotal,
1402 ULONG aMemSharedTotal,
1403 ULONG aVmNetRx,
1404 ULONG aVmNetTx);
1405
1406
1407 struct ConsoleTaskData
1408 {
1409 ConsoleTaskData()
1410 : mLastState(MachineState_Null),
1411 mDeleteSnapshotInfo(NULL)
1412 { }
1413
1414 MachineState_T mLastState;
1415 ComObjPtr<Progress> mProgress;
1416
1417 // used when deleting online snaphshot
1418 void *mDeleteSnapshotInfo;
1419 };
1420
1421 struct SaveStateTask;
1422 struct SnapshotTask;
1423 struct TakeSnapshotTask;
1424 struct DeleteSnapshotTask;
1425 struct RestoreSnapshotTask;
1426
1427 friend struct TakeSnapshotTask;
1428 friend struct DeleteSnapshotTask;
1429 friend struct RestoreSnapshotTask;
1430
1431 void i_saveStateHandler(SaveStateTask &aTask);
1432
1433 // Override some functionality for SessionMachine, this is where the
1434 // real action happens (the Machine methods are just dummies).
1435 HRESULT saveState(ComPtr<IProgress> &aProgress);
1436 HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile);
1437 HRESULT discardSavedState(BOOL aFRemoveFile);
1438 HRESULT takeSnapshot(const com::Utf8Str &aName,
1439 const com::Utf8Str &aDescription,
1440 BOOL aPause,
1441 com::Guid &aId,
1442 ComPtr<IProgress> &aProgress);
1443 HRESULT deleteSnapshot(const com::Guid &aId,
1444 ComPtr<IProgress> &aProgress);
1445 HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
1446 ComPtr<IProgress> &aProgress);
1447 HRESULT deleteSnapshotRange(const com::Guid &aStartId,
1448 const com::Guid &aEndId,
1449 ComPtr<IProgress> &aProgress);
1450 HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
1451 ComPtr<IProgress> &aProgress);
1452
1453 void i_releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1454
1455 void i_takeSnapshotHandler(TakeSnapshotTask &aTask);
1456 static void i_takeSnapshotProgressCancelCallback(void *pvUser);
1457 HRESULT i_finishTakingSnapshot(TakeSnapshotTask &aTask, AutoWriteLock &alock, bool aSuccess);
1458 HRESULT i_deleteSnapshot(const com::Guid &aStartId,
1459 const com::Guid &aEndId,
1460 BOOL aDeleteAllChildren,
1461 ComPtr<IProgress> &aProgress);
1462 void i_deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1463 void i_restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1464
1465 HRESULT i_prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1466 const Guid &machineId,
1467 const Guid &snapshotId,
1468 bool fOnlineMergePossible,
1469 MediumLockList *aVMMALockList,
1470 ComObjPtr<Medium> &aSource,
1471 ComObjPtr<Medium> &aTarget,
1472 bool &fMergeForward,
1473 ComObjPtr<Medium> &pParentForTarget,
1474 MediumLockList * &aChildrenToReparent,
1475 bool &fNeedOnlineMerge,
1476 MediumLockList * &aMediumLockList,
1477 ComPtr<IToken> &aHDLockToken);
1478 void i_cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1479 const ComObjPtr<Medium> &aSource,
1480 MediumLockList *aChildrenToReparent,
1481 bool fNeedsOnlineMerge,
1482 MediumLockList *aMediumLockList,
1483 const ComPtr<IToken> &aHDLockToken,
1484 const Guid &aMediumId,
1485 const Guid &aSnapshotId);
1486 HRESULT i_onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1487 const ComObjPtr<Medium> &aSource,
1488 const ComObjPtr<Medium> &aTarget,
1489 bool fMergeForward,
1490 const ComObjPtr<Medium> &pParentForTarget,
1491 MediumLockList *aChildrenToReparent,
1492 MediumLockList *aMediumLockList,
1493 ComObjPtr<Progress> &aProgress,
1494 bool *pfNeedsMachineSaveSettings);
1495
1496 HRESULT i_setMachineState(MachineState_T aMachineState);
1497 HRESULT i_updateMachineStateOnClient();
1498
1499 bool mRemoveSavedState;
1500
1501 ConsoleTaskData mConsoleTaskData;
1502
1503 /** client token for this machine */
1504 ClientToken *mClientToken;
1505
1506 int miNATNetworksStarted;
1507};
1508
1509// SnapshotMachine class
1510////////////////////////////////////////////////////////////////////////////////
1511
1512/**
1513 * @note Notes on locking objects of this class:
1514 * SnapshotMachine shares some data with the primary Machine instance (pointed
1515 * to by the |mPeer| member). In order to provide data consistency it also
1516 * shares its lock handle. This means that whenever you lock a SessionMachine
1517 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1518 * instance is also locked in the same lock mode. Keep it in mind.
1519 */
1520class ATL_NO_VTABLE SnapshotMachine :
1521 public Machine
1522{
1523public:
1524 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1525
1526 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1527
1528 DECLARE_PROTECT_FINAL_CONSTRUCT()
1529
1530 BEGIN_COM_MAP(SnapshotMachine)
1531 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1532 END_COM_MAP()
1533
1534 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1535
1536 HRESULT FinalConstruct();
1537 void FinalRelease();
1538
1539 // public initializer/uninitializer for internal purposes only
1540 HRESULT init(SessionMachine *aSessionMachine,
1541 IN_GUID aSnapshotId,
1542 const Utf8Str &aStateFilePath);
1543 HRESULT initFromSettings(Machine *aMachine,
1544 const settings::Hardware &hardware,
1545 const settings::Debugging *pDbg,
1546 const settings::Autostart *pAutostart,
1547 const settings::Storage &storage,
1548 IN_GUID aSnapshotId,
1549 const Utf8Str &aStateFilePath);
1550 void uninit();
1551
1552 // util::Lockable interface
1553 RWLockHandle *lockHandle() const;
1554
1555 // public methods only for internal purposes
1556
1557 virtual bool i_isSnapshotMachine() const
1558 {
1559 return true;
1560 }
1561
1562 HRESULT i_onSnapshotChange(Snapshot *aSnapshot);
1563
1564 // unsafe inline public methods for internal purposes only (ensure there is
1565 // a caller and a read lock before calling them!)
1566
1567 const Guid& i_getSnapshotId() const { return mSnapshotId; }
1568
1569private:
1570
1571 Guid mSnapshotId;
1572 /** This field replaces mPeer for SessionMachine instances, as having
1573 * a peer reference is plain meaningless and causes many subtle problems
1574 * with saving settings and the like. */
1575 Machine * const mMachine;
1576
1577 friend class Snapshot;
1578};
1579
1580// third party methods that depend on SnapshotMachine definition
1581
1582inline const Guid &Machine::i_getSnapshotId() const
1583{
1584 return (i_isSnapshotMachine())
1585 ? static_cast<const SnapshotMachine*>(this)->i_getSnapshotId()
1586 : Guid::Empty;
1587}
1588
1589
1590#endif // ____H_MACHINEIMPL
1591/* 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