VirtualBox

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

Last change on this file was 103977, checked in by vboxsync, 7 weeks ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use