VirtualBox

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

Last change on this file since 48406 was 48406, checked in by vboxsync, 12 years ago

Main,VBoxManage: Implemented IConsole::EmulatedUSB. Removed IMachine::emulatedUSBWebcameraEnabled.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 55.2 KB
Line 
1/* $Id: MachineImpl.h 48406 2013-09-10 12:53:50Z vboxsync $ */
2/** @file
3 * Implementation of IMachine in VBoxSVC - Header.
4 */
5
6/*
7 * Copyright (C) 2006-2013 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.215389.xyz. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef ____H_MACHINEIMPL
19#define ____H_MACHINEIMPL
20
21#include "VirtualBoxBase.h"
22#include "SnapshotImpl.h"
23#include "ProgressImpl.h"
24#include "VRDEServerImpl.h"
25#include "MediumAttachmentImpl.h"
26#include "PCIDeviceAttachmentImpl.h"
27#include "MediumLock.h"
28#include "NetworkAdapterImpl.h"
29#include "AudioAdapterImpl.h"
30#include "SerialPortImpl.h"
31#include "ParallelPortImpl.h"
32#include "BIOSSettingsImpl.h"
33#include "StorageControllerImpl.h" // required for MachineImpl.h to compile on Windows
34#include "USBControllerImpl.h" // required for MachineImpl.h to compile on Windows
35#include "BandwidthControlImpl.h"
36#include "BandwidthGroupImpl.h"
37#include "VBox/settings.h"
38#ifdef VBOX_WITH_RESOURCE_USAGE_API
39#include "Performance.h"
40#include "PerformanceImpl.h"
41#endif /* VBOX_WITH_RESOURCE_USAGE_API */
42
43// generated header
44#include "SchemaDefs.h"
45
46#include "VBox/com/ErrorInfo.h"
47
48#include <iprt/file.h>
49#include <iprt/thread.h>
50#include <iprt/time.h>
51
52#include <list>
53#include <vector>
54
55// defines
56////////////////////////////////////////////////////////////////////////////////
57
58// helper declarations
59////////////////////////////////////////////////////////////////////////////////
60
61class Progress;
62class ProgressProxy;
63class Keyboard;
64class Mouse;
65class Display;
66class MachineDebugger;
67class USBController;
68class USBDeviceFilters;
69class Snapshot;
70class SharedFolder;
71class HostUSBDevice;
72class StorageController;
73
74class SessionMachine;
75
76namespace settings
77{
78 class MachineConfigFile;
79 struct Snapshot;
80 struct Hardware;
81 struct Storage;
82 struct StorageController;
83 struct MachineRegistryEntry;
84}
85
86// Machine class
87////////////////////////////////////////////////////////////////////////////////
88
89class ATL_NO_VTABLE Machine :
90 public VirtualBoxBase,
91 VBOX_SCRIPTABLE_IMPL(IMachine)
92{
93 Q_OBJECT
94
95public:
96
97 enum StateDependency
98 {
99 AnyStateDep = 0,
100 MutableStateDep,
101 MutableOrSavedStateDep,
102 OfflineStateDep
103 };
104
105 /**
106 * Internal machine data.
107 *
108 * Only one instance of this data exists per every machine -- it is shared
109 * by the Machine, SessionMachine and all SnapshotMachine instances
110 * associated with the given machine using the util::Shareable template
111 * through the mData variable.
112 *
113 * @note |const| members are persistent during lifetime so can be
114 * accessed without locking.
115 *
116 * @note There is no need to lock anything inside init() or uninit()
117 * methods, because they are always serialized (see AutoCaller).
118 */
119 struct Data
120 {
121 /**
122 * Data structure to hold information about sessions opened for the
123 * given machine.
124 */
125 struct Session
126 {
127 /** Control of the direct session opened by lockMachine() */
128 ComPtr<IInternalSessionControl> mDirectControl;
129
130 typedef std::list<ComPtr<IInternalSessionControl> > RemoteControlList;
131
132 /** list of controls of all opened remote sessions */
133 RemoteControlList mRemoteControls;
134
135 /** launchVMProcess() and OnSessionEnd() progress indicator */
136 ComObjPtr<ProgressProxy> mProgress;
137
138 /**
139 * PID of the session object that must be passed to openSession()
140 * to finalize the launchVMProcess() request (i.e., PID of the
141 * process created by launchVMProcess())
142 */
143 RTPROCESS mPID;
144
145 /** Current session state */
146 SessionState_T mState;
147
148 /** Session type string (for indirect sessions) */
149 Bstr mType;
150
151 /** Session machine object */
152 ComObjPtr<SessionMachine> mMachine;
153
154 /** Medium object lock collection. */
155 MediumLockListMap mLockedMedia;
156 };
157
158 Data();
159 ~Data();
160
161 const Guid mUuid;
162 BOOL mRegistered;
163
164 Utf8Str m_strConfigFile;
165 Utf8Str m_strConfigFileFull;
166
167 // machine settings XML file
168 settings::MachineConfigFile *pMachineConfigFile;
169 uint32_t flModifications;
170 bool m_fAllowStateModification;
171
172 BOOL mAccessible;
173 com::ErrorInfo mAccessError;
174
175 MachineState_T mMachineState;
176 RTTIMESPEC mLastStateChange;
177
178 /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
179 uint32_t mMachineStateDeps;
180 RTSEMEVENTMULTI mMachineStateDepsSem;
181 uint32_t mMachineStateChangePending;
182
183 BOOL mCurrentStateModified;
184 /** Guest properties have been modified and need saving since the
185 * machine was started, or there are transient properties which need
186 * deleting and the machine is being shut down. */
187 BOOL mGuestPropertiesModified;
188
189 Session mSession;
190
191 ComObjPtr<Snapshot> mFirstSnapshot;
192 ComObjPtr<Snapshot> mCurrentSnapshot;
193
194 // list of files to delete in Delete(); this list is filled by Unregister()
195 std::list<Utf8Str> llFilesToDelete;
196 };
197
198 /**
199 * Saved state data.
200 *
201 * It's actually only the state file path string, but it needs to be
202 * separate from Data, because Machine and SessionMachine instances
203 * share it, while SnapshotMachine does not.
204 *
205 * The data variable is |mSSData|.
206 */
207 struct SSData
208 {
209 Utf8Str strStateFilePath;
210 };
211
212 /**
213 * User changeable machine data.
214 *
215 * This data is common for all machine snapshots, i.e. it is shared
216 * by all SnapshotMachine instances associated with the given machine
217 * using the util::Backupable template through the |mUserData| variable.
218 *
219 * SessionMachine instances can alter this data and discard changes.
220 *
221 * @note There is no need to lock anything inside init() or uninit()
222 * methods, because they are always serialized (see AutoCaller).
223 */
224 struct UserData
225 {
226 settings::MachineUserData s;
227 typedef std::vector<uint8_t> IconBlob;
228 IconBlob mIcon;
229 };
230
231 /**
232 * Hardware data.
233 *
234 * This data is unique for a machine and for every machine snapshot.
235 * Stored using the util::Backupable template in the |mHWData| variable.
236 *
237 * SessionMachine instances can alter this data and discard changes.
238 */
239 struct HWData
240 {
241 /**
242 * Data structure to hold information about a guest property.
243 */
244 struct GuestProperty {
245 /** Property value */
246 Utf8Str strValue;
247 /** Property timestamp */
248 LONG64 mTimestamp;
249 /** Property flags */
250 ULONG mFlags;
251 };
252
253 HWData();
254 ~HWData();
255
256 Bstr mHWVersion;
257 Guid mHardwareUUID; /**< If Null, use mData.mUuid. */
258 ULONG mMemorySize;
259 ULONG mMemoryBalloonSize;
260 BOOL mPageFusionEnabled;
261 GraphicsControllerType_T mGraphicsControllerType;
262 ULONG mVRAMSize;
263 ULONG mVideoCaptureWidth;
264 ULONG mVideoCaptureHeight;
265 ULONG mVideoCaptureRate;
266 ULONG mVideoCaptureFPS;
267 Utf8Str mVideoCaptureFile;
268 BOOL mVideoCaptureEnabled;
269 BOOL maVideoCaptureScreens[SchemaDefs::MaxGuestMonitors];
270 ULONG mMonitorCount;
271 BOOL mHWVirtExEnabled;
272 BOOL mHWVirtExNestedPagingEnabled;
273 BOOL mHWVirtExLargePagesEnabled;
274 BOOL mHWVirtExVPIDEnabled;
275 BOOL mHWVirtExUXEnabled;
276 BOOL mHWVirtExForceEnabled;
277 BOOL mAccelerate2DVideoEnabled;
278 BOOL mPAEEnabled;
279 settings::Hardware::LongModeType mLongMode;
280 BOOL mSyntheticCpu;
281 ULONG mCPUCount;
282 BOOL mCPUHotPlugEnabled;
283 ULONG mCpuExecutionCap;
284 BOOL mAccelerate3DEnabled;
285 BOOL mHPETEnabled;
286
287 BOOL mCPUAttached[SchemaDefs::MaxCPUCount];
288
289 settings::CpuIdLeaf mCpuIdStdLeafs[11];
290 settings::CpuIdLeaf mCpuIdExtLeafs[11];
291
292 DeviceType_T mBootOrder[SchemaDefs::MaxBootPosition];
293
294 typedef std::list<ComObjPtr<SharedFolder> > SharedFolderList;
295 SharedFolderList mSharedFolders;
296
297 ClipboardMode_T mClipboardMode;
298 DragAndDropMode_T mDragAndDropMode;
299
300 typedef std::map<Utf8Str, GuestProperty> GuestPropertyMap;
301 GuestPropertyMap mGuestProperties;
302 Utf8Str mGuestPropertyNotificationPatterns;
303
304 FirmwareType_T mFirmwareType;
305 KeyboardHIDType_T mKeyboardHIDType;
306 PointingHIDType_T mPointingHIDType;
307 ChipsetType_T mChipsetType;
308 BOOL mEmulatedUSBCardReaderEnabled;
309
310 BOOL mIOCacheEnabled;
311 ULONG mIOCacheSize;
312
313 typedef std::list<ComObjPtr<PCIDeviceAttachment> > PCIDeviceAssignmentList;
314 PCIDeviceAssignmentList mPCIDeviceAssignments;
315
316 settings::Debugging mDebugging;
317 settings::Autostart mAutostart;
318
319 Utf8Str mDefaultFrontend;
320 };
321
322 /**
323 * Hard disk and other media data.
324 *
325 * The usage policy is the same as for HWData, but a separate structure
326 * is necessary because hard disk data requires different procedures when
327 * taking or deleting snapshots, etc.
328 *
329 * The data variable is |mMediaData|.
330 */
331 struct MediaData
332 {
333 MediaData();
334 ~MediaData();
335
336 typedef std::list<ComObjPtr<MediumAttachment> > AttachmentList;
337 AttachmentList mAttachments;
338 };
339
340 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine, IMachine)
341
342 DECLARE_NOT_AGGREGATABLE(Machine)
343
344 DECLARE_PROTECT_FINAL_CONSTRUCT()
345
346 BEGIN_COM_MAP(Machine)
347 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
348 END_COM_MAP()
349
350 DECLARE_EMPTY_CTOR_DTOR(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 const StringsList &llGroups,
362 GuestOSType *aOsType,
363 const Guid &aId,
364 bool fForceOverwrite,
365 bool fDirectoryIncludesUUID);
366
367 // initializer for loading existing machine XML (either registered or not)
368 HRESULT initFromSettings(VirtualBox *aParent,
369 const Utf8Str &strConfigFile,
370 const Guid *aId);
371
372 // initializer for machine config in memory (OVF import)
373 HRESULT init(VirtualBox *aParent,
374 const Utf8Str &strName,
375 const settings::MachineConfigFile &config);
376
377 void uninit();
378
379#ifdef VBOX_WITH_RESOURCE_USAGE_API
380 // Needed from VirtualBox, for the delayed metrics cleanup.
381 void unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
382#endif /* VBOX_WITH_RESOURCE_USAGE_API */
383
384protected:
385 HRESULT initImpl(VirtualBox *aParent,
386 const Utf8Str &strConfigFile);
387 HRESULT initDataAndChildObjects();
388 HRESULT registeredInit();
389 HRESULT tryCreateMachineConfigFile(bool fForceOverwrite);
390 void uninitDataAndChildObjects();
391
392public:
393 // IMachine properties
394 STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
395 STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible);
396 STDMETHOD(COMGETTER(AccessError))(IVirtualBoxErrorInfo **aAccessError);
397 STDMETHOD(COMGETTER(Name))(BSTR *aName);
398 STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
399 STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
400 STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
401 STDMETHOD(COMGETTER(Id))(BSTR *aId);
402 STDMETHOD(COMGETTER(Groups))(ComSafeArrayOut(BSTR, aGroups));
403 STDMETHOD(COMSETTER(Groups))(ComSafeArrayIn(IN_BSTR, aGroups));
404 STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId);
405 STDMETHOD(COMSETTER(OSTypeId))(IN_BSTR aOSTypeId);
406 STDMETHOD(COMGETTER(HardwareVersion))(BSTR *aVersion);
407 STDMETHOD(COMSETTER(HardwareVersion))(IN_BSTR aVersion);
408 STDMETHOD(COMGETTER(HardwareUUID))(BSTR *aUUID);
409 STDMETHOD(COMSETTER(HardwareUUID))(IN_BSTR aUUID);
410 STDMETHOD(COMGETTER(MemorySize))(ULONG *memorySize);
411 STDMETHOD(COMSETTER(MemorySize))(ULONG memorySize);
412 STDMETHOD(COMGETTER(CPUCount))(ULONG *cpuCount);
413 STDMETHOD(COMSETTER(CPUCount))(ULONG cpuCount);
414 STDMETHOD(COMGETTER(CPUHotPlugEnabled))(BOOL *enabled);
415 STDMETHOD(COMSETTER(CPUHotPlugEnabled))(BOOL enabled);
416 STDMETHOD(COMGETTER(CPUExecutionCap))(ULONG *aExecutionCap);
417 STDMETHOD(COMSETTER(CPUExecutionCap))(ULONG aExecutionCap);
418 STDMETHOD(COMGETTER(EmulatedUSBCardReaderEnabled))(BOOL *aEnabled);
419 STDMETHOD(COMSETTER(EmulatedUSBCardReaderEnabled))(BOOL aEnabled);
420 STDMETHOD(COMGETTER(HPETEnabled))(BOOL *enabled);
421 STDMETHOD(COMSETTER(HPETEnabled))(BOOL enabled);
422 STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
423 STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
424 STDMETHOD(COMGETTER(PageFusionEnabled))(BOOL *enabled);
425 STDMETHOD(COMSETTER(PageFusionEnabled))(BOOL enabled);
426 STDMETHOD(COMGETTER(GraphicsControllerType))(GraphicsControllerType_T *aGraphicsController);
427 STDMETHOD(COMSETTER(GraphicsControllerType))(GraphicsControllerType_T aGraphicsController);
428 STDMETHOD(COMGETTER(VRAMSize))(ULONG *memorySize);
429 STDMETHOD(COMSETTER(VRAMSize))(ULONG memorySize);
430 STDMETHOD(COMGETTER(Accelerate3DEnabled))(BOOL *aEnabled);
431 STDMETHOD(COMSETTER(Accelerate3DEnabled))(BOOL aEnabled);
432 STDMETHOD(COMGETTER(Accelerate2DVideoEnabled))(BOOL *aEnabled);
433 STDMETHOD(COMSETTER(Accelerate2DVideoEnabled))(BOOL aEnabled);
434 STDMETHOD(COMGETTER(MonitorCount))(ULONG *monitorCount);
435 STDMETHOD(COMSETTER(MonitorCount))(ULONG monitorCount);
436 STDMETHOD(COMGETTER(VideoCaptureEnabled))(BOOL *u8VideoRecEnabled);
437 STDMETHOD(COMSETTER(VideoCaptureEnabled))(BOOL u8VideoRecEnabled);
438 STDMETHOD(COMGETTER(VideoCaptureScreens))(ComSafeArrayOut(BOOL, aScreens));
439 STDMETHOD(COMSETTER(VideoCaptureScreens))(ComSafeArrayIn(BOOL, aScreens));
440 STDMETHOD(COMGETTER(VideoCaptureFile))(BSTR * ppChVideoRecFilename);
441 STDMETHOD(COMSETTER(VideoCaptureFile))(IN_BSTR pChVideoRecFilename);
442 STDMETHOD(COMGETTER(VideoCaptureWidth))(ULONG *aHorzRes);
443 STDMETHOD(COMSETTER(VideoCaptureWidth))(ULONG aorzRes);
444 STDMETHOD(COMGETTER(VideoCaptureHeight))(ULONG *aVertRes);
445 STDMETHOD(COMSETTER(VideoCaptureHeight))(ULONG aVertRes);
446 STDMETHOD(COMGETTER(VideoCaptureRate))(ULONG *aRate);
447 STDMETHOD(COMSETTER(VideoCaptureRate))(ULONG aRate);
448 STDMETHOD(COMGETTER(VideoCaptureFPS))(ULONG *aFPS);
449 STDMETHOD(COMSETTER(VideoCaptureFPS))(ULONG aFPS);
450 STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **biosSettings);
451 STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
452 STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSavedStateFolder);
453 STDMETHOD(COMGETTER(MediumAttachments))(ComSafeArrayOut(IMediumAttachment *, aAttachments));
454 STDMETHOD(COMGETTER(VRDEServer))(IVRDEServer **vrdeServer);
455 STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
456 STDMETHOD(COMGETTER(USBControllers))(ComSafeArrayOut(IUSBController *, aUSBControllers));
457 STDMETHOD(COMGETTER(USBDeviceFilters))(IUSBDeviceFilters * *aUSBDeviceFilters);
458 STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aFilePath);
459 STDMETHOD(COMGETTER(SettingsModified))(BOOL *aModified);
460 STDMETHOD(COMGETTER(SessionState))(SessionState_T *aSessionState);
461 STDMETHOD(COMGETTER(SessionType))(BSTR *aSessionType);
462 STDMETHOD(COMGETTER(SessionPID))(ULONG *aSessionPID);
463 STDMETHOD(COMGETTER(State))(MachineState_T *machineState);
464 STDMETHOD(COMGETTER(LastStateChange))(LONG64 *aLastStateChange);
465 STDMETHOD(COMGETTER(StateFilePath))(BSTR *aStateFilePath);
466 STDMETHOD(COMGETTER(LogFolder))(BSTR *aLogFolder);
467 STDMETHOD(COMGETTER(CurrentSnapshot))(ISnapshot **aCurrentSnapshot);
468 STDMETHOD(COMGETTER(SnapshotCount))(ULONG *aSnapshotCount);
469 STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
470 STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
471 STDMETHOD(COMGETTER(ClipboardMode))(ClipboardMode_T *aClipboardMode);
472 STDMETHOD(COMSETTER(ClipboardMode))(ClipboardMode_T aClipboardMode);
473 STDMETHOD(COMGETTER(DragAndDropMode))(DragAndDropMode_T *aDragAndDropMode);
474 STDMETHOD(COMSETTER(DragAndDropMode))(DragAndDropMode_T aDragAndDropMode);
475 STDMETHOD(COMGETTER(GuestPropertyNotificationPatterns))(BSTR *aPattern);
476 STDMETHOD(COMSETTER(GuestPropertyNotificationPatterns))(IN_BSTR aPattern);
477 STDMETHOD(COMGETTER(StorageControllers))(ComSafeArrayOut(IStorageController *, aStorageControllers));
478 STDMETHOD(COMGETTER(TeleporterEnabled))(BOOL *aEnabled);
479 STDMETHOD(COMSETTER(TeleporterEnabled))(BOOL aEnabled);
480 STDMETHOD(COMGETTER(TeleporterPort))(ULONG *aPort);
481 STDMETHOD(COMSETTER(TeleporterPort))(ULONG aPort);
482 STDMETHOD(COMGETTER(TeleporterAddress))(BSTR *aAddress);
483 STDMETHOD(COMSETTER(TeleporterAddress))(IN_BSTR aAddress);
484 STDMETHOD(COMGETTER(TeleporterPassword))(BSTR *aPassword);
485 STDMETHOD(COMSETTER(TeleporterPassword))(IN_BSTR aPassword);
486 STDMETHOD(COMGETTER(FaultToleranceState))(FaultToleranceState_T *aEnabled);
487 STDMETHOD(COMSETTER(FaultToleranceState))(FaultToleranceState_T aEnabled);
488 STDMETHOD(COMGETTER(FaultToleranceAddress))(BSTR *aAddress);
489 STDMETHOD(COMSETTER(FaultToleranceAddress))(IN_BSTR aAddress);
490 STDMETHOD(COMGETTER(FaultTolerancePort))(ULONG *aPort);
491 STDMETHOD(COMSETTER(FaultTolerancePort))(ULONG aPort);
492 STDMETHOD(COMGETTER(FaultTolerancePassword))(BSTR *aPassword);
493 STDMETHOD(COMSETTER(FaultTolerancePassword))(IN_BSTR aPassword);
494 STDMETHOD(COMGETTER(FaultToleranceSyncInterval))(ULONG *aInterval);
495 STDMETHOD(COMSETTER(FaultToleranceSyncInterval))(ULONG aInterval);
496 STDMETHOD(COMGETTER(RTCUseUTC))(BOOL *aEnabled);
497 STDMETHOD(COMSETTER(RTCUseUTC))(BOOL aEnabled);
498 STDMETHOD(COMGETTER(FirmwareType))(FirmwareType_T *aFirmware);
499 STDMETHOD(COMSETTER(FirmwareType))(FirmwareType_T aFirmware);
500 STDMETHOD(COMGETTER(KeyboardHIDType))(KeyboardHIDType_T *aKeyboardHIDType);
501 STDMETHOD(COMSETTER(KeyboardHIDType))(KeyboardHIDType_T aKeyboardHIDType);
502 STDMETHOD(COMGETTER(PointingHIDType))(PointingHIDType_T *aPointingHIDType);
503 STDMETHOD(COMSETTER(PointingHIDType))(PointingHIDType_T aPointingHIDType);
504 STDMETHOD(COMGETTER(ChipsetType))(ChipsetType_T *aChipsetType);
505 STDMETHOD(COMSETTER(ChipsetType))(ChipsetType_T aChipsetType);
506 STDMETHOD(COMGETTER(IOCacheEnabled))(BOOL *aEnabled);
507 STDMETHOD(COMSETTER(IOCacheEnabled))(BOOL aEnabled);
508 STDMETHOD(COMGETTER(IOCacheSize))(ULONG *aIOCacheSize);
509 STDMETHOD(COMSETTER(IOCacheSize))(ULONG aIOCacheSize);
510 STDMETHOD(COMGETTER(PCIDeviceAssignments))(ComSafeArrayOut(IPCIDeviceAttachment *, aAssignments));
511 STDMETHOD(COMGETTER(BandwidthControl))(IBandwidthControl **aBandwidthControl);
512 STDMETHOD(COMGETTER(TracingEnabled))(BOOL *pfEnabled);
513 STDMETHOD(COMSETTER(TracingEnabled))(BOOL fEnabled);
514 STDMETHOD(COMGETTER(TracingConfig))(BSTR *pbstrConfig);
515 STDMETHOD(COMSETTER(TracingConfig))(IN_BSTR bstrConfig);
516 STDMETHOD(COMGETTER(AllowTracingToAccessVM))(BOOL *pfAllow);
517 STDMETHOD(COMSETTER(AllowTracingToAccessVM))(BOOL fAllow);
518 STDMETHOD(COMGETTER(AutostartEnabled))(BOOL *pfEnabled);
519 STDMETHOD(COMSETTER(AutostartEnabled))(BOOL fEnabled);
520 STDMETHOD(COMGETTER(AutostartDelay))(ULONG *puDelay);
521 STDMETHOD(COMSETTER(AutostartDelay))(ULONG uDelay);
522 STDMETHOD(COMGETTER(AutostopType))(AutostopType_T *penmAutostopType);
523 STDMETHOD(COMSETTER(AutostopType))(AutostopType_T enmAutostopType);
524 STDMETHOD(COMGETTER(DefaultFrontend))(BSTR *aDefaultFrontend);
525 STDMETHOD(COMSETTER(DefaultFrontend))(IN_BSTR aDefaultFrontend);
526 STDMETHOD(COMGETTER(Icon))(ComSafeArrayOut(BYTE, aIcon));
527 STDMETHOD(COMSETTER(Icon))(ComSafeArrayIn(BYTE, aIcon));
528 STDMETHOD(COMGETTER(USBProxyAvailable))(BOOL *aAvailable);
529
530 // IMachine methods
531 STDMETHOD(LockMachine)(ISession *aSession, LockType_T lockType);
532 STDMETHOD(LaunchVMProcess)(ISession *aSession, IN_BSTR aType, IN_BSTR aEnvironment, IProgress **aProgress);
533
534 STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
535 STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
536 STDMETHOD(AttachDeviceWithoutMedium)(IN_BSTR aControllerName, LONG aControllerPort,
537 LONG aDevice, DeviceType_T aType);
538 STDMETHOD(AttachDevice)(IN_BSTR aControllerName, LONG aControllerPort,
539 LONG aDevice, DeviceType_T aType, IMedium *aMedium);
540 STDMETHOD(DetachDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice);
541 STDMETHOD(PassthroughDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aPassthrough);
542 STDMETHOD(TemporaryEjectDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aTempEject);
543 STDMETHOD(NonRotationalDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aNonRotational);
544 STDMETHOD(SetAutoDiscardForDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aDiscard);
545 STDMETHOD(SetNoBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
546 LONG aDevice);
547 STDMETHOD(SetBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
548 LONG aDevice, IBandwidthGroup *aBandwidthGroup);
549 STDMETHOD(MountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
550 LONG aDevice, IMedium *aMedium, BOOL aForce);
551 STDMETHOD(UnmountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
552 LONG aDevice, BOOL aForce);
553 STDMETHOD(GetMedium)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice,
554 IMedium **aMedium);
555 STDMETHOD(GetSerialPort)(ULONG slot, ISerialPort **port);
556 STDMETHOD(GetParallelPort)(ULONG slot, IParallelPort **port);
557 STDMETHOD(GetNetworkAdapter)(ULONG slot, INetworkAdapter **adapter);
558 STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
559 STDMETHOD(GetExtraData)(IN_BSTR aKey, BSTR *aValue);
560 STDMETHOD(SetExtraData)(IN_BSTR aKey, IN_BSTR aValue);
561 STDMETHOD(GetCPUProperty)(CPUPropertyType_T property, BOOL *aVal);
562 STDMETHOD(SetCPUProperty)(CPUPropertyType_T property, BOOL aVal);
563 STDMETHOD(GetCPUIDLeaf)(ULONG id, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx);
564 STDMETHOD(SetCPUIDLeaf)(ULONG id, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx);
565 STDMETHOD(RemoveCPUIDLeaf)(ULONG id);
566 STDMETHOD(RemoveAllCPUIDLeaves)();
567 STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL *aVal);
568 STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL aVal);
569 STDMETHOD(SaveSettings)();
570 STDMETHOD(DiscardSettings)();
571 STDMETHOD(Unregister)(CleanupMode_T cleanupMode, ComSafeArrayOut(IMedium*, aMedia));
572 STDMETHOD(DeleteConfig)(ComSafeArrayIn(IMedium*, aMedia), IProgress **aProgress);
573 STDMETHOD(ExportTo)(IAppliance *aAppliance, IN_BSTR location, IVirtualSystemDescription **aDescription);
574 STDMETHOD(FindSnapshot)(IN_BSTR aNameOrId, ISnapshot **aSnapshot);
575 STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
576 STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
577 STDMETHOD(CanShowConsoleWindow)(BOOL *aCanShow);
578 STDMETHOD(ShowConsoleWindow)(LONG64 *aWinId);
579 STDMETHOD(GetGuestProperty)(IN_BSTR aName, BSTR *aValue, LONG64 *aTimestamp, BSTR *aFlags);
580 STDMETHOD(GetGuestPropertyValue)(IN_BSTR aName, BSTR *aValue);
581 STDMETHOD(GetGuestPropertyTimestamp)(IN_BSTR aName, LONG64 *aTimestamp);
582 STDMETHOD(SetGuestProperty)(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags);
583 STDMETHOD(SetGuestPropertyValue)(IN_BSTR aName, IN_BSTR aValue);
584 STDMETHOD(DeleteGuestProperty)(IN_BSTR aName);
585 STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
586 STDMETHOD(GetMediumAttachmentsOfController)(IN_BSTR aName, ComSafeArrayOut(IMediumAttachment *, aAttachments));
587 STDMETHOD(GetMediumAttachment)(IN_BSTR aConstrollerName, LONG aControllerPort, LONG aDevice, IMediumAttachment **aAttachment);
588 STDMETHOD(AddStorageController)(IN_BSTR aName, StorageBus_T aConnectionType, IStorageController **controller);
589 STDMETHOD(RemoveStorageController(IN_BSTR aName));
590 STDMETHOD(GetStorageControllerByName(IN_BSTR aName, IStorageController **storageController));
591 STDMETHOD(GetStorageControllerByInstance(ULONG aInstance, IStorageController **storageController));
592 STDMETHOD(SetStorageControllerBootable)(IN_BSTR aName, BOOL fBootable);
593 STDMETHOD(AddUSBController)(IN_BSTR aName, USBControllerType_T aConnectionType, IUSBController **controller);
594 STDMETHOD(RemoveUSBController(IN_BSTR aName));
595 STDMETHOD(GetUSBControllerByName(IN_BSTR aName, IUSBController **usbController));
596 STDMETHOD(GetUSBControllerCountByType(USBControllerType_T aType, ULONG *aControllers));
597 STDMETHOD(QuerySavedGuestScreenInfo)(ULONG uScreenId, ULONG *puOriginX, ULONG *puOriginY, ULONG *puWidth, ULONG *puHeight, BOOL *pfEnabled);
598 STDMETHOD(QuerySavedThumbnailSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
599 STDMETHOD(ReadSavedThumbnailToArray)(ULONG aScreenId, BOOL aBGR, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
600 STDMETHOD(ReadSavedThumbnailPNGToArray)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
601 STDMETHOD(QuerySavedScreenshotPNGSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
602 STDMETHOD(ReadSavedScreenshotPNGToArray)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
603 STDMETHOD(HotPlugCPU(ULONG aCpu));
604 STDMETHOD(HotUnplugCPU(ULONG aCpu));
605 STDMETHOD(GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached));
606 STDMETHOD(QueryLogFilename(ULONG aIdx, BSTR *aName));
607 STDMETHOD(ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData)));
608 STDMETHOD(AttachHostPCIDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL tryToUnbind));
609 STDMETHOD(DetachHostPCIDevice(LONG hostAddress));
610 STDMETHOD(CloneTo(IMachine *pTarget, CloneMode_T mode, ComSafeArrayIn(CloneOptions_T, options), IProgress **pProgress));
611 // public methods only for internal purposes
612
613 virtual bool isSnapshotMachine() const
614 {
615 return false;
616 }
617
618 virtual bool isSessionMachine() const
619 {
620 return false;
621 }
622
623 /**
624 * Override of the default locking class to be used for validating lock
625 * order with the standard member lock handle.
626 */
627 virtual VBoxLockingClass getLockingClass() const
628 {
629 return LOCKCLASS_MACHINEOBJECT;
630 }
631
632 /// @todo (dmik) add lock and make non-inlined after revising classes
633 // that use it. Note: they should enter Machine lock to keep the returned
634 // information valid!
635 bool isRegistered() { return !!mData->mRegistered; }
636
637 // unsafe inline public methods for internal purposes only (ensure there is
638 // a caller and a read lock before calling them!)
639
640 /**
641 * Returns the VirtualBox object this machine belongs to.
642 *
643 * @note This method doesn't check this object's readiness. Intended to be
644 * used by ready Machine children (whose readiness is bound to the parent's
645 * one) or after doing addCaller() manually.
646 */
647 VirtualBox* getVirtualBox() const { return mParent; }
648
649 /**
650 * Checks if this machine is accessible, without attempting to load the
651 * config file.
652 *
653 * @note This method doesn't check this object's readiness. Intended to be
654 * used by ready Machine children (whose readiness is bound to the parent's
655 * one) or after doing addCaller() manually.
656 */
657 bool isAccessible() const { return !!mData->mAccessible; }
658
659 /**
660 * Returns this machine ID.
661 *
662 * @note This method doesn't check this object's readiness. Intended to be
663 * used by ready Machine children (whose readiness is bound to the parent's
664 * one) or after adding a caller manually.
665 */
666 const Guid& getId() const { return mData->mUuid; }
667
668 /**
669 * Returns the snapshot ID this machine represents or an empty UUID if this
670 * instance is not SnapshotMachine.
671 *
672 * @note This method doesn't check this object's readiness. Intended to be
673 * used by ready Machine children (whose readiness is bound to the parent's
674 * one) or after adding a caller manually.
675 */
676 inline const Guid& getSnapshotId() const;
677
678 /**
679 * Returns this machine's full settings file path.
680 *
681 * @note This method doesn't lock this object or check its readiness.
682 * Intended to be used only after doing addCaller() manually and locking it
683 * for reading.
684 */
685 const Utf8Str& getSettingsFileFull() const { return mData->m_strConfigFileFull; }
686
687 /**
688 * Returns this machine name.
689 *
690 * @note This method doesn't lock this object or check its readiness.
691 * Intended to be used only after doing addCaller() manually and locking it
692 * for reading.
693 */
694 const Utf8Str& getName() const { return mUserData->s.strName; }
695
696 enum
697 {
698 IsModified_MachineData = 0x0001,
699 IsModified_Storage = 0x0002,
700 IsModified_NetworkAdapters = 0x0008,
701 IsModified_SerialPorts = 0x0010,
702 IsModified_ParallelPorts = 0x0020,
703 IsModified_VRDEServer = 0x0040,
704 IsModified_AudioAdapter = 0x0080,
705 IsModified_USB = 0x0100,
706 IsModified_BIOS = 0x0200,
707 IsModified_SharedFolders = 0x0400,
708 IsModified_Snapshots = 0x0800,
709 IsModified_BandwidthControl = 0x1000
710 };
711
712 /**
713 * Returns various information about this machine.
714 *
715 * @note This method doesn't lock this object or check its readiness.
716 * Intended to be used only after doing addCaller() manually and locking it
717 * for reading.
718 */
719 ChipsetType_T getChipsetType() const { return mHWData->mChipsetType; }
720
721 void setModified(uint32_t fl, bool fAllowStateModification = true);
722 void setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
723
724 bool isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
725 void allowStateModification() { mData->m_fAllowStateModification = true; }
726 void disallowStateModification() { mData->m_fAllowStateModification = false; }
727
728 const StringsList &getGroups() const { return mUserData->s.llGroups; }
729
730 // callback handlers
731 virtual HRESULT onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
732 virtual HRESULT onNATRedirectRuleChange(ULONG /* slot */, BOOL /* fRemove */ , IN_BSTR /* name */,
733 NATProtocol_T /* protocol */, IN_BSTR /* host ip */, LONG /* host port */, IN_BSTR /* guest port */, LONG /* guest port */ ) { return S_OK; }
734 virtual HRESULT onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
735 virtual HRESULT onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
736 virtual HRESULT onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
737 virtual HRESULT onUSBControllerChange() { return S_OK; }
738 virtual HRESULT onStorageControllerChange() { return S_OK; }
739 virtual HRESULT onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
740 virtual HRESULT onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
741 virtual HRESULT onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
742 virtual HRESULT onSharedFolderChange() { return S_OK; }
743 virtual HRESULT onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
744 virtual HRESULT onDragAndDropModeChange(DragAndDropMode_T /* aDragAndDropMode */) { return S_OK; }
745 virtual HRESULT onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
746 virtual HRESULT onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */, BOOL /* silent */) { return S_OK; }
747 virtual HRESULT onVideoCaptureChange() { return S_OK; }
748
749 HRESULT saveRegistryEntry(settings::MachineRegistryEntry &data);
750
751 int calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
752 void copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
753
754 void getLogFolder(Utf8Str &aLogFolder);
755 Utf8Str queryLogFilename(ULONG idx);
756
757 void composeSavedStateFilename(Utf8Str &strStateFilePath);
758
759 void getDefaultVideoCaptureFile(Utf8Str &strFile);
760
761 bool isUSBControllerPresent();
762
763 HRESULT launchVMProcess(IInternalSessionControl *aControl,
764 const Utf8Str &strType,
765 const Utf8Str &strEnvironment,
766 ProgressProxy *aProgress);
767
768 HRESULT getDirectControl(ComPtr<IInternalSessionControl> *directControl)
769 {
770 HRESULT rc;
771 *directControl = mData->mSession.mDirectControl;
772
773 if (!*directControl)
774 rc = E_ACCESSDENIED;
775 else
776 rc = S_OK;
777
778 return rc;
779 }
780
781 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
782 ComPtr<IInternalSessionControl> *aControl = NULL,
783 bool aAllowClosing = false);
784 bool isSessionSpawning();
785
786 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
787 ComPtr<IInternalSessionControl> *aControl = NULL)
788 { return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
789
790 bool checkForSpawnFailure();
791
792 HRESULT prepareRegister();
793
794 HRESULT getSharedFolder(CBSTR aName,
795 ComObjPtr<SharedFolder> &aSharedFolder,
796 bool aSetError = false)
797 {
798 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
799 return findSharedFolder(aName, aSharedFolder, aSetError);
800 }
801
802 HRESULT addStateDependency(StateDependency aDepType = AnyStateDep,
803 MachineState_T *aState = NULL,
804 BOOL *aRegistered = NULL);
805 void releaseStateDependency();
806
807 HRESULT getBandwidthGroup(const Utf8Str &strBandwidthGroup,
808 ComObjPtr<BandwidthGroup> &pBandwidthGroup,
809 bool fSetError = false)
810 {
811 return mBandwidthControl->getBandwidthGroupByName(strBandwidthGroup,
812 pBandwidthGroup,
813 fSetError);
814 }
815
816protected:
817
818 class ClientToken;
819
820 HRESULT checkStateDependency(StateDependency aDepType);
821
822 Machine *getMachine();
823
824 void ensureNoStateDependencies();
825
826 virtual HRESULT setMachineState(MachineState_T aMachineState);
827
828 HRESULT findSharedFolder(const Utf8Str &aName,
829 ComObjPtr<SharedFolder> &aSharedFolder,
830 bool aSetError = false);
831
832 HRESULT loadSettings(bool aRegistered);
833 HRESULT loadMachineDataFromSettings(const settings::MachineConfigFile &config,
834 const Guid *puuidRegistry);
835 HRESULT loadSnapshot(const settings::Snapshot &data,
836 const Guid &aCurSnapshotId,
837 Snapshot *aParentSnapshot);
838 HRESULT loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
839 const settings::Autostart *pAutostart);
840 HRESULT loadDebugging(const settings::Debugging *pDbg);
841 HRESULT loadAutostart(const settings::Autostart *pAutostart);
842 HRESULT loadStorageControllers(const settings::Storage &data,
843 const Guid *puuidRegistry,
844 const Guid *puuidSnapshot);
845 HRESULT loadStorageDevices(StorageController *aStorageController,
846 const settings::StorageController &data,
847 const Guid *puuidRegistry,
848 const Guid *puuidSnapshot);
849
850 HRESULT findSnapshotById(const Guid &aId,
851 ComObjPtr<Snapshot> &aSnapshot,
852 bool aSetError = false);
853 HRESULT findSnapshotByName(const Utf8Str &strName,
854 ComObjPtr<Snapshot> &aSnapshot,
855 bool aSetError = false);
856
857 HRESULT getStorageControllerByName(const Utf8Str &aName,
858 ComObjPtr<StorageController> &aStorageController,
859 bool aSetError = false);
860
861 HRESULT getMediumAttachmentsOfController(CBSTR aName,
862 MediaData::AttachmentList &aAttachments);
863
864 HRESULT getUSBControllerByName(const Utf8Str &aName,
865 ComObjPtr<USBController> &aUSBController,
866 bool aSetError = false);
867
868 ULONG getUSBControllerCountByType(USBControllerType_T enmType);
869
870 enum
871 {
872 /* flags for #saveSettings() */
873 SaveS_ResetCurStateModified = 0x01,
874 SaveS_InformCallbacksAnyway = 0x02,
875 SaveS_Force = 0x04,
876 /* flags for #saveStateSettings() */
877 SaveSTS_CurStateModified = 0x20,
878 SaveSTS_StateFilePath = 0x40,
879 SaveSTS_StateTimeStamp = 0x80
880 };
881
882 HRESULT prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
883 HRESULT saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
884
885 void copyMachineDataToSettings(settings::MachineConfigFile &config);
886 HRESULT saveAllSnapshots(settings::MachineConfigFile &config);
887 HRESULT saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
888 settings::Autostart *pAutostart);
889 HRESULT saveStorageControllers(settings::Storage &data);
890 HRESULT saveStorageDevices(ComObjPtr<StorageController> aStorageController,
891 settings::StorageController &data);
892 HRESULT saveStateSettings(int aFlags);
893
894 void addMediumToRegistry(ComObjPtr<Medium> &pMedium);
895
896 HRESULT createImplicitDiffs(IProgress *aProgress,
897 ULONG aWeight,
898 bool aOnline);
899 HRESULT deleteImplicitDiffs(bool aOnline);
900
901 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
902 IN_BSTR aControllerName,
903 LONG aControllerPort,
904 LONG aDevice);
905 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
906 ComObjPtr<Medium> pMedium);
907 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
908 Guid &id);
909
910 HRESULT detachDevice(MediumAttachment *pAttach,
911 AutoWriteLock &writeLock,
912 Snapshot *pSnapshot);
913
914 HRESULT detachAllMedia(AutoWriteLock &writeLock,
915 Snapshot *pSnapshot,
916 CleanupMode_T cleanupMode,
917 MediaList &llMedia);
918
919 void commitMedia(bool aOnline = false);
920 void rollbackMedia();
921
922 bool isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
923
924 void rollback(bool aNotify);
925 void commit();
926 void copyFrom(Machine *aThat);
927 bool isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
928
929 struct DeleteTask;
930 static DECLCALLBACK(int) deleteThread(RTTHREAD Thread, void *pvUser);
931 HRESULT deleteTaskWorker(DeleteTask &task);
932
933 Utf8Str getExtraData(const Utf8Str &strKey);
934
935#ifdef VBOX_WITH_GUEST_PROPS
936 HRESULT getGuestPropertyFromService(IN_BSTR aName, BSTR *aValue,
937 LONG64 *aTimestamp, BSTR *aFlags) const;
938 HRESULT getGuestPropertyFromVM(IN_BSTR aName, BSTR *aValue,
939 LONG64 *aTimestamp, BSTR *aFlags) const;
940 HRESULT setGuestPropertyToService(IN_BSTR aName, IN_BSTR aValue,
941 IN_BSTR aFlags);
942 HRESULT setGuestPropertyToVM(IN_BSTR aName, IN_BSTR aValue,
943 IN_BSTR aFlags);
944 HRESULT enumerateGuestPropertiesInService
945 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
946 ComSafeArrayOut(BSTR, aValues),
947 ComSafeArrayOut(LONG64, aTimestamps),
948 ComSafeArrayOut(BSTR, aFlags));
949 HRESULT enumerateGuestPropertiesOnVM
950 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
951 ComSafeArrayOut(BSTR, aValues),
952 ComSafeArrayOut(LONG64, aTimestamps),
953 ComSafeArrayOut(BSTR, aFlags));
954#endif /* VBOX_WITH_GUEST_PROPS */
955
956#ifdef VBOX_WITH_RESOURCE_USAGE_API
957 void getDiskList(MediaList &list);
958 void registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
959
960 pm::CollectorGuest *mCollectorGuest;
961#endif /* VBOX_WITH_RESOURCE_USAGE_API */
962
963 Machine * const mPeer;
964
965 VirtualBox * const mParent;
966
967 Shareable<Data> mData;
968 Shareable<SSData> mSSData;
969
970 Backupable<UserData> mUserData;
971 Backupable<HWData> mHWData;
972 Backupable<MediaData> mMediaData;
973
974 // the following fields need special backup/rollback/commit handling,
975 // so they cannot be a part of HWData
976
977 const ComObjPtr<VRDEServer> mVRDEServer;
978 const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
979 const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
980 const ComObjPtr<AudioAdapter> mAudioAdapter;
981 const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
982 const ComObjPtr<BIOSSettings> mBIOSSettings;
983 const ComObjPtr<BandwidthControl> mBandwidthControl;
984
985 typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
986 NetworkAdapterVector mNetworkAdapters;
987
988 typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
989 Backupable<StorageControllerList> mStorageControllers;
990
991 typedef std::list<ComObjPtr<USBController> > USBControllerList;
992 Backupable<USBControllerList> mUSBControllers;
993
994 uint64_t uRegistryNeedsSaving;
995
996 friend class SessionMachine;
997 friend class SnapshotMachine;
998 friend class Appliance;
999 friend class VirtualBox;
1000
1001 friend class MachineCloneVM;
1002};
1003
1004// SessionMachine class
1005////////////////////////////////////////////////////////////////////////////////
1006
1007/**
1008 * @note Notes on locking objects of this class:
1009 * SessionMachine shares some data with the primary Machine instance (pointed
1010 * to by the |mPeer| member). In order to provide data consistency it also
1011 * shares its lock handle. This means that whenever you lock a SessionMachine
1012 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1013 * instance is also locked in the same lock mode. Keep it in mind.
1014 */
1015class ATL_NO_VTABLE SessionMachine :
1016 public Machine,
1017 VBOX_SCRIPTABLE_IMPL(IInternalMachineControl)
1018{
1019public:
1020 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1021
1022 DECLARE_NOT_AGGREGATABLE(SessionMachine)
1023
1024 DECLARE_PROTECT_FINAL_CONSTRUCT()
1025
1026 BEGIN_COM_MAP(SessionMachine)
1027 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1028 COM_INTERFACE_ENTRY(IInternalMachineControl)
1029 END_COM_MAP()
1030
1031 DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1032
1033 HRESULT FinalConstruct();
1034 void FinalRelease();
1035
1036 // public initializer/uninitializer for internal purposes only
1037 HRESULT init(Machine *aMachine);
1038 void uninit() { uninit(Uninit::Unexpected); }
1039
1040 // util::Lockable interface
1041 RWLockHandle *lockHandle() const;
1042
1043 // IInternalMachineControl methods
1044 STDMETHOD(SetRemoveSavedStateFile)(BOOL aRemove);
1045 STDMETHOD(UpdateState)(MachineState_T machineState);
1046 STDMETHOD(BeginPowerUp)(IProgress *aProgress);
1047 STDMETHOD(EndPowerUp)(LONG iResult);
1048 STDMETHOD(BeginPoweringDown)(IProgress **aProgress);
1049 STDMETHOD(EndPoweringDown)(LONG aResult, IN_BSTR aErrMsg);
1050 STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
1051 STDMETHOD(CaptureUSBDevice)(IN_BSTR aId);
1052 STDMETHOD(DetachUSBDevice)(IN_BSTR aId, BOOL aDone);
1053 STDMETHOD(AutoCaptureUSBDevices)();
1054 STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
1055 STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
1056 STDMETHOD(BeginSavingState)(IProgress **aProgress, BSTR *aStateFilePath);
1057 STDMETHOD(EndSavingState)(LONG aResult, IN_BSTR aErrMsg);
1058 STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
1059 STDMETHOD(BeginTakingSnapshot)(IConsole *aInitiator,
1060 IN_BSTR aName,
1061 IN_BSTR aDescription,
1062 IProgress *aConsoleProgress,
1063 BOOL fTakingSnapshotOnline,
1064 BSTR *aStateFilePath);
1065 STDMETHOD(EndTakingSnapshot)(BOOL aSuccess);
1066 STDMETHOD(DeleteSnapshot)(IConsole *aInitiator, IN_BSTR aStartId,
1067 IN_BSTR aEndID, BOOL fDeleteAllChildren,
1068 MachineState_T *aMachineState, IProgress **aProgress);
1069 STDMETHOD(FinishOnlineMergeMedium)();
1070 STDMETHOD(RestoreSnapshot)(IConsole *aInitiator,
1071 ISnapshot *aSnapshot,
1072 MachineState_T *aMachineState,
1073 IProgress **aProgress);
1074 STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
1075 ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
1076 STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
1077 LONG64 aTimestamp, IN_BSTR aFlags);
1078 STDMETHOD(LockMedia)();
1079 STDMETHOD(UnlockMedia)();
1080 STDMETHOD(EjectMedium)(IMediumAttachment *aAttachment,
1081 IMediumAttachment **aNewAttachment);
1082 STDMETHOD(ReportVmStatistics)(ULONG aValidStats, ULONG aCpuUser,
1083 ULONG aCpuKernel, ULONG aCpuIdle,
1084 ULONG aMemTotal, ULONG aMemFree,
1085 ULONG aMemBalloon, ULONG aMemShared,
1086 ULONG aMemCache, ULONG aPageTotal,
1087 ULONG aAllocVMM, ULONG aFreeVMM,
1088 ULONG aBalloonedVMM, ULONG aSharedVMM,
1089 ULONG aVmNetRx, ULONG aVmNetTx);
1090
1091 // public methods only for internal purposes
1092
1093 virtual bool isSessionMachine() const
1094 {
1095 return true;
1096 }
1097
1098 bool checkForDeath();
1099
1100 void getTokenId(Utf8Str &strTokenId);
1101 // getClientToken must be only used by callers who can guarantee that
1102 // the object cannot be deleted in the mean time, i.e. have a caller/lock.
1103 ClientToken *getClientToken();
1104
1105 HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1106 HRESULT onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1107 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
1108 HRESULT onStorageControllerChange();
1109 HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1110 HRESULT onSerialPortChange(ISerialPort *serialPort);
1111 HRESULT onParallelPortChange(IParallelPort *parallelPort);
1112 HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
1113 HRESULT onVRDEServerChange(BOOL aRestart);
1114 HRESULT onVideoCaptureChange();
1115 HRESULT onUSBControllerChange();
1116 HRESULT onUSBDeviceAttach(IUSBDevice *aDevice,
1117 IVirtualBoxErrorInfo *aError,
1118 ULONG aMaskedIfs);
1119 HRESULT onUSBDeviceDetach(IN_BSTR aId,
1120 IVirtualBoxErrorInfo *aError);
1121 HRESULT onSharedFolderChange();
1122 HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
1123 HRESULT onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode);
1124 HRESULT onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1125 HRESULT onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1126 HRESULT onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1127
1128 bool hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1129
1130 HRESULT lockMedia();
1131 void unlockMedia();
1132
1133private:
1134
1135 struct ConsoleTaskData
1136 {
1137 ConsoleTaskData()
1138 : mLastState(MachineState_Null), mDeleteSnapshotInfo(NULL)
1139 { }
1140
1141 MachineState_T mLastState;
1142 ComObjPtr<Progress> mProgress;
1143
1144 // used when taking snapshot
1145 ComObjPtr<Snapshot> mSnapshot;
1146
1147 // used when deleting online snapshot
1148 void *mDeleteSnapshotInfo;
1149
1150 // used when saving state (either as part of a snapshot or separate)
1151 Utf8Str strStateFilePath;
1152 };
1153
1154 struct Uninit
1155 {
1156 enum Reason { Unexpected, Abnormal, Normal };
1157 };
1158
1159 struct SnapshotTask;
1160 struct DeleteSnapshotTask;
1161 struct RestoreSnapshotTask;
1162
1163 friend struct DeleteSnapshotTask;
1164 friend struct RestoreSnapshotTask;
1165
1166 void uninit(Uninit::Reason aReason);
1167
1168 HRESULT endSavingState(HRESULT aRC, const Utf8Str &aErrMsg);
1169 void releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1170
1171 void deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1172 void restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1173
1174 HRESULT prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1175 const Guid &machineId,
1176 const Guid &snapshotId,
1177 bool fOnlineMergePossible,
1178 MediumLockList *aVMMALockList,
1179 ComObjPtr<Medium> &aSource,
1180 ComObjPtr<Medium> &aTarget,
1181 bool &fMergeForward,
1182 ComObjPtr<Medium> &pParentForTarget,
1183 MediumLockList * &aChildrenToReparent,
1184 bool &fNeedOnlineMerge,
1185 MediumLockList * &aMediumLockList,
1186 ComPtr<IToken> &aHDLockToken);
1187 void cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1188 const ComObjPtr<Medium> &aSource,
1189 MediumLockList *aChildrenToReparent,
1190 bool fNeedsOnlineMerge,
1191 MediumLockList *aMediumLockList,
1192 const ComPtr<IToken> &aHDLockToken,
1193 const Guid &aMediumId,
1194 const Guid &aSnapshotId);
1195 HRESULT onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1196 const ComObjPtr<Medium> &aSource,
1197 const ComObjPtr<Medium> &aTarget,
1198 bool fMergeForward,
1199 const ComObjPtr<Medium> &pParentForTarget,
1200 MediumLockList *aChildrenToReparent,
1201 MediumLockList *aMediumLockList,
1202 ComObjPtr<Progress> &aProgress,
1203 bool *pfNeedsMachineSaveSettings);
1204
1205 HRESULT setMachineState(MachineState_T aMachineState);
1206 HRESULT updateMachineStateOnClient();
1207
1208 HRESULT mRemoveSavedState;
1209
1210 ConsoleTaskData mConsoleTaskData;
1211
1212 /** client token for this machine */
1213 ClientToken *mClientToken;
1214
1215 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
1216};
1217
1218// SnapshotMachine class
1219////////////////////////////////////////////////////////////////////////////////
1220
1221/**
1222 * @note Notes on locking objects of this class:
1223 * SnapshotMachine shares some data with the primary Machine instance (pointed
1224 * to by the |mPeer| member). In order to provide data consistency it also
1225 * shares its lock handle. This means that whenever you lock a SessionMachine
1226 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1227 * instance is also locked in the same lock mode. Keep it in mind.
1228 */
1229class ATL_NO_VTABLE SnapshotMachine :
1230 public Machine
1231{
1232public:
1233 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1234
1235 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1236
1237 DECLARE_PROTECT_FINAL_CONSTRUCT()
1238
1239 BEGIN_COM_MAP(SnapshotMachine)
1240 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1241 END_COM_MAP()
1242
1243 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1244
1245 HRESULT FinalConstruct();
1246 void FinalRelease();
1247
1248 // public initializer/uninitializer for internal purposes only
1249 HRESULT init(SessionMachine *aSessionMachine,
1250 IN_GUID aSnapshotId,
1251 const Utf8Str &aStateFilePath);
1252 HRESULT initFromSettings(Machine *aMachine,
1253 const settings::Hardware &hardware,
1254 const settings::Debugging *pDbg,
1255 const settings::Autostart *pAutostart,
1256 const settings::Storage &storage,
1257 IN_GUID aSnapshotId,
1258 const Utf8Str &aStateFilePath);
1259 void uninit();
1260
1261 // util::Lockable interface
1262 RWLockHandle *lockHandle() const;
1263
1264 // public methods only for internal purposes
1265
1266 virtual bool isSnapshotMachine() const
1267 {
1268 return true;
1269 }
1270
1271 HRESULT onSnapshotChange(Snapshot *aSnapshot);
1272
1273 // unsafe inline public methods for internal purposes only (ensure there is
1274 // a caller and a read lock before calling them!)
1275
1276 const Guid& getSnapshotId() const { return mSnapshotId; }
1277
1278private:
1279
1280 Guid mSnapshotId;
1281 /** This field replaces mPeer for SessionMachine instances, as having
1282 * a peer reference is plain meaningless and causes many subtle problems
1283 * with saving settings and the like. */
1284 Machine * const mMachine;
1285
1286 friend class Snapshot;
1287};
1288
1289// third party methods that depend on SnapshotMachine definition
1290
1291inline const Guid &Machine::getSnapshotId() const
1292{
1293 return (isSnapshotMachine())
1294 ? static_cast<const SnapshotMachine*>(this)->getSnapshotId()
1295 : Guid::Empty;
1296}
1297
1298
1299#endif // ____H_MACHINEIMPL
1300/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette