1 | /* $Id: MachineImpl.h 67738 2017-06-30 14:49:40Z 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 |
|
---|
44 | // generated header
|
---|
45 | #include "SchemaDefs.h"
|
---|
46 |
|
---|
47 | #include "VBox/com/ErrorInfo.h"
|
---|
48 |
|
---|
49 | #include <iprt/file.h>
|
---|
50 | #include <iprt/thread.h>
|
---|
51 | #include <iprt/time.h>
|
---|
52 |
|
---|
53 | #include <list>
|
---|
54 | #include <vector>
|
---|
55 |
|
---|
56 | #include "MachineWrap.h"
|
---|
57 |
|
---|
58 | /** @todo r=klaus after moving the various Machine settings structs to
|
---|
59 | * MachineImpl.cpp it should be possible to eliminate this include. */
|
---|
60 | #include <VBox/settings.h>
|
---|
61 |
|
---|
62 | // defines
|
---|
63 | ////////////////////////////////////////////////////////////////////////////////
|
---|
64 |
|
---|
65 | // helper declarations
|
---|
66 | ////////////////////////////////////////////////////////////////////////////////
|
---|
67 |
|
---|
68 | class Progress;
|
---|
69 | class ProgressProxy;
|
---|
70 | class Keyboard;
|
---|
71 | class Mouse;
|
---|
72 | class Display;
|
---|
73 | class MachineDebugger;
|
---|
74 | class USBController;
|
---|
75 | class USBDeviceFilters;
|
---|
76 | class Snapshot;
|
---|
77 | class SharedFolder;
|
---|
78 | class HostUSBDevice;
|
---|
79 | class StorageController;
|
---|
80 | class SessionMachine;
|
---|
81 | #ifdef VBOX_WITH_UNATTENDED
|
---|
82 | class Unattended;
|
---|
83 | #endif
|
---|
84 |
|
---|
85 | // Machine class
|
---|
86 | ////////////////////////////////////////////////////////////////////////////////
|
---|
87 | //
|
---|
88 | class ATL_NO_VTABLE Machine :
|
---|
89 | public MachineWrap
|
---|
90 | {
|
---|
91 |
|
---|
92 | public:
|
---|
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 |
|
---|
370 | protected:
|
---|
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 |
|
---|
378 | public:
|
---|
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 |
|
---|
610 | protected:
|
---|
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 |
|
---|
833 | private:
|
---|
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 | */
|
---|
1270 | class ATL_NO_VTABLE SessionMachine :
|
---|
1271 | public Machine
|
---|
1272 | {
|
---|
1273 | public:
|
---|
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 |
|
---|
1357 | private:
|
---|
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 | */
|
---|
1523 | class ATL_NO_VTABLE SnapshotMachine :
|
---|
1524 | public Machine
|
---|
1525 | {
|
---|
1526 | public:
|
---|
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 |
|
---|
1574 | private:
|
---|
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 |
|
---|
1587 | inline 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: */
|
---|