VirtualBox

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

Last change on this file since 78666 was 78632, checked in by vboxsync, 6 years ago

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