VirtualBox

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

Last change on this file since 67230 was 66925, checked in by vboxsync, 8 years ago

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