VirtualBox

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

Last change on this file since 98846 was 98288, checked in by vboxsync, 23 months ago

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