VirtualBox

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

Last change on this file since 47408 was 47408, checked in by vboxsync, 11 years ago

build fix for Windows
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 57.2 KB
Line 
1/* $Id: MachineImpl.h 47408 2013-07-25 19:41:10Z 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.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef ____H_MACHINEIMPL
19#define ____H_MACHINEIMPL
20
21#include "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 mHWVirtExExclusive;
273 BOOL mHWVirtExNestedPagingEnabled;
274 BOOL mHWVirtExLargePagesEnabled;
275 BOOL mHWVirtExVPIDEnabled;
276 BOOL mHWVirtExUXEnabled;
277 BOOL mHWVirtExForceEnabled;
278 BOOL mAccelerate2DVideoEnabled;
279 BOOL mPAEEnabled;
280 settings::Hardware::LongModeType mLongMode;
281 BOOL mSyntheticCpu;
282 ULONG mCPUCount;
283 BOOL mCPUHotPlugEnabled;
284 ULONG mCpuExecutionCap;
285 BOOL mAccelerate3DEnabled;
286 BOOL mHPETEnabled;
287
288 BOOL mCPUAttached[SchemaDefs::MaxCPUCount];
289
290 settings::CpuIdLeaf mCpuIdStdLeafs[11];
291 settings::CpuIdLeaf mCpuIdExtLeafs[11];
292
293 DeviceType_T mBootOrder[SchemaDefs::MaxBootPosition];
294
295 typedef std::list<ComObjPtr<SharedFolder> > SharedFolderList;
296 SharedFolderList mSharedFolders;
297
298 ClipboardMode_T mClipboardMode;
299 DragAndDropMode_T mDragAndDropMode;
300
301 typedef std::map<Utf8Str, GuestProperty> GuestPropertyMap;
302 GuestPropertyMap mGuestProperties;
303 Utf8Str mGuestPropertyNotificationPatterns;
304
305 FirmwareType_T mFirmwareType;
306 KeyboardHIDType_T mKeyboardHIDType;
307 PointingHIDType_T mPointingHIDType;
308 ChipsetType_T mChipsetType;
309 BOOL mEmulatedUSBWebcamEnabled;
310 BOOL mEmulatedUSBCardReaderEnabled;
311
312 BOOL mIOCacheEnabled;
313 ULONG mIOCacheSize;
314
315 typedef std::list<ComObjPtr<PCIDeviceAttachment> > PCIDeviceAssignmentList;
316 PCIDeviceAssignmentList mPCIDeviceAssignments;
317
318 settings::Debugging mDebugging;
319 settings::Autostart mAutostart;
320
321 Utf8Str mDefaultFrontend;
322 };
323
324 /**
325 * Hard disk and other media data.
326 *
327 * The usage policy is the same as for HWData, but a separate structure
328 * is necessary because hard disk data requires different procedures when
329 * taking or deleting snapshots, etc.
330 *
331 * The data variable is |mMediaData|.
332 */
333 struct MediaData
334 {
335 MediaData();
336 ~MediaData();
337
338 typedef std::list<ComObjPtr<MediumAttachment> > AttachmentList;
339 AttachmentList mAttachments;
340 };
341
342 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine, IMachine)
343
344 DECLARE_NOT_AGGREGATABLE(Machine)
345
346 DECLARE_PROTECT_FINAL_CONSTRUCT()
347
348 BEGIN_COM_MAP(Machine)
349 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
350 END_COM_MAP()
351
352 DECLARE_EMPTY_CTOR_DTOR(Machine)
353
354 HRESULT FinalConstruct();
355 void FinalRelease();
356
357 // public initializer/uninitializer for internal purposes only:
358
359 // initializer for creating a new, empty machine
360 HRESULT init(VirtualBox *aParent,
361 const Utf8Str &strConfigFile,
362 const Utf8Str &strName,
363 const StringsList &llGroups,
364 GuestOSType *aOsType,
365 const Guid &aId,
366 bool fForceOverwrite,
367 bool fDirectoryIncludesUUID);
368
369 // initializer for loading existing machine XML (either registered or not)
370 HRESULT initFromSettings(VirtualBox *aParent,
371 const Utf8Str &strConfigFile,
372 const Guid *aId);
373
374 // initializer for machine config in memory (OVF import)
375 HRESULT init(VirtualBox *aParent,
376 const Utf8Str &strName,
377 const settings::MachineConfigFile &config);
378
379 void uninit();
380
381#ifdef VBOX_WITH_RESOURCE_USAGE_API
382 // Needed from VirtualBox, for the delayed metrics cleanup.
383 void unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
384#endif /* VBOX_WITH_RESOURCE_USAGE_API */
385
386protected:
387 HRESULT initImpl(VirtualBox *aParent,
388 const Utf8Str &strConfigFile);
389 HRESULT initDataAndChildObjects();
390 HRESULT registeredInit();
391 HRESULT tryCreateMachineConfigFile(bool fForceOverwrite);
392 void uninitDataAndChildObjects();
393
394public:
395 // IMachine properties
396 STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
397 STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible);
398 STDMETHOD(COMGETTER(AccessError))(IVirtualBoxErrorInfo **aAccessError);
399 STDMETHOD(COMGETTER(Name))(BSTR *aName);
400 STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
401 STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
402 STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
403 STDMETHOD(COMGETTER(Id))(BSTR *aId);
404 STDMETHOD(COMGETTER(Groups))(ComSafeArrayOut(BSTR, aGroups));
405 STDMETHOD(COMSETTER(Groups))(ComSafeArrayIn(IN_BSTR, aGroups));
406 STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId);
407 STDMETHOD(COMSETTER(OSTypeId))(IN_BSTR aOSTypeId);
408 STDMETHOD(COMGETTER(HardwareVersion))(BSTR *aVersion);
409 STDMETHOD(COMSETTER(HardwareVersion))(IN_BSTR aVersion);
410 STDMETHOD(COMGETTER(HardwareUUID))(BSTR *aUUID);
411 STDMETHOD(COMSETTER(HardwareUUID))(IN_BSTR aUUID);
412 STDMETHOD(COMGETTER(MemorySize))(ULONG *memorySize);
413 STDMETHOD(COMSETTER(MemorySize))(ULONG memorySize);
414 STDMETHOD(COMGETTER(CPUCount))(ULONG *cpuCount);
415 STDMETHOD(COMSETTER(CPUCount))(ULONG cpuCount);
416 STDMETHOD(COMGETTER(CPUHotPlugEnabled))(BOOL *enabled);
417 STDMETHOD(COMSETTER(CPUHotPlugEnabled))(BOOL enabled);
418 STDMETHOD(COMGETTER(CPUExecutionCap))(ULONG *aExecutionCap);
419 STDMETHOD(COMSETTER(CPUExecutionCap))(ULONG aExecutionCap);
420 STDMETHOD(COMGETTER(EmulatedUSBCardReaderEnabled))(BOOL *aEnabled);
421 STDMETHOD(COMSETTER(EmulatedUSBCardReaderEnabled))(BOOL aEnabled);
422 STDMETHOD(COMGETTER(EmulatedUSBWebcameraEnabled))(BOOL *aEnabled);
423 STDMETHOD(COMSETTER(EmulatedUSBWebcameraEnabled))(BOOL aEnabled);
424 STDMETHOD(COMGETTER(HPETEnabled))(BOOL *enabled);
425 STDMETHOD(COMSETTER(HPETEnabled))(BOOL enabled);
426 STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
427 STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
428 STDMETHOD(COMGETTER(PageFusionEnabled))(BOOL *enabled);
429 STDMETHOD(COMSETTER(PageFusionEnabled))(BOOL enabled);
430 STDMETHOD(COMGETTER(GraphicsControllerType))(GraphicsControllerType_T *aGraphicsController);
431 STDMETHOD(COMSETTER(GraphicsControllerType))(GraphicsControllerType_T aGraphicsController);
432 STDMETHOD(COMGETTER(VRAMSize))(ULONG *memorySize);
433 STDMETHOD(COMSETTER(VRAMSize))(ULONG memorySize);
434 STDMETHOD(COMGETTER(Accelerate3DEnabled))(BOOL *aEnabled);
435 STDMETHOD(COMSETTER(Accelerate3DEnabled))(BOOL aEnabled);
436 STDMETHOD(COMGETTER(Accelerate2DVideoEnabled))(BOOL *aEnabled);
437 STDMETHOD(COMSETTER(Accelerate2DVideoEnabled))(BOOL aEnabled);
438 STDMETHOD(COMGETTER(MonitorCount))(ULONG *monitorCount);
439 STDMETHOD(COMSETTER(MonitorCount))(ULONG monitorCount);
440 STDMETHOD(COMGETTER(VideoCaptureEnabled))(BOOL *u8VideoRecEnabled);
441 STDMETHOD(COMSETTER(VideoCaptureEnabled))(BOOL u8VideoRecEnabled);
442 STDMETHOD(COMGETTER(VideoCaptureScreens))(ComSafeArrayOut(BOOL, aScreens));
443 STDMETHOD(COMSETTER(VideoCaptureScreens))(ComSafeArrayIn(BOOL, aScreens));
444 STDMETHOD(COMGETTER(VideoCaptureFile))(BSTR * ppChVideoRecFilename);
445 STDMETHOD(COMSETTER(VideoCaptureFile))(IN_BSTR pChVideoRecFilename);
446 STDMETHOD(COMGETTER(VideoCaptureWidth))(ULONG *aHorzRes);
447 STDMETHOD(COMSETTER(VideoCaptureWidth))(ULONG aorzRes);
448 STDMETHOD(COMGETTER(VideoCaptureHeight))(ULONG *aVertRes);
449 STDMETHOD(COMSETTER(VideoCaptureHeight))(ULONG aVertRes);
450 STDMETHOD(COMGETTER(VideoCaptureRate))(ULONG *aRate);
451 STDMETHOD(COMSETTER(VideoCaptureRate))(ULONG aRate);
452 STDMETHOD(COMGETTER(VideoCaptureFPS))(ULONG *aFPS);
453 STDMETHOD(COMSETTER(VideoCaptureFPS))(ULONG aFPS);
454 STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **biosSettings);
455 STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
456 STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSavedStateFolder);
457 STDMETHOD(COMGETTER(MediumAttachments))(ComSafeArrayOut(IMediumAttachment *, aAttachments));
458 STDMETHOD(COMGETTER(VRDEServer))(IVRDEServer **vrdeServer);
459 STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
460 STDMETHOD(COMGETTER(USBControllers))(ComSafeArrayOut(IUSBController *, aUSBControllers));
461 STDMETHOD(COMGETTER(USBDeviceFilters))(IUSBDeviceFilters * *aUSBDeviceFilters);
462 STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aFilePath);
463 STDMETHOD(COMGETTER(SettingsModified))(BOOL *aModified);
464 STDMETHOD(COMGETTER(SessionState))(SessionState_T *aSessionState);
465 STDMETHOD(COMGETTER(SessionType))(BSTR *aSessionType);
466 STDMETHOD(COMGETTER(SessionPID))(ULONG *aSessionPID);
467 STDMETHOD(COMGETTER(State))(MachineState_T *machineState);
468 STDMETHOD(COMGETTER(LastStateChange))(LONG64 *aLastStateChange);
469 STDMETHOD(COMGETTER(StateFilePath))(BSTR *aStateFilePath);
470 STDMETHOD(COMGETTER(LogFolder))(BSTR *aLogFolder);
471 STDMETHOD(COMGETTER(CurrentSnapshot))(ISnapshot **aCurrentSnapshot);
472 STDMETHOD(COMGETTER(SnapshotCount))(ULONG *aSnapshotCount);
473 STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
474 STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
475 STDMETHOD(COMGETTER(ClipboardMode))(ClipboardMode_T *aClipboardMode);
476 STDMETHOD(COMSETTER(ClipboardMode))(ClipboardMode_T aClipboardMode);
477 STDMETHOD(COMGETTER(DragAndDropMode))(DragAndDropMode_T *aDragAndDropMode);
478 STDMETHOD(COMSETTER(DragAndDropMode))(DragAndDropMode_T aDragAndDropMode);
479 STDMETHOD(COMGETTER(GuestPropertyNotificationPatterns))(BSTR *aPattern);
480 STDMETHOD(COMSETTER(GuestPropertyNotificationPatterns))(IN_BSTR aPattern);
481 STDMETHOD(COMGETTER(StorageControllers))(ComSafeArrayOut(IStorageController *, aStorageControllers));
482 STDMETHOD(COMGETTER(TeleporterEnabled))(BOOL *aEnabled);
483 STDMETHOD(COMSETTER(TeleporterEnabled))(BOOL aEnabled);
484 STDMETHOD(COMGETTER(TeleporterPort))(ULONG *aPort);
485 STDMETHOD(COMSETTER(TeleporterPort))(ULONG aPort);
486 STDMETHOD(COMGETTER(TeleporterAddress))(BSTR *aAddress);
487 STDMETHOD(COMSETTER(TeleporterAddress))(IN_BSTR aAddress);
488 STDMETHOD(COMGETTER(TeleporterPassword))(BSTR *aPassword);
489 STDMETHOD(COMSETTER(TeleporterPassword))(IN_BSTR aPassword);
490 STDMETHOD(COMGETTER(FaultToleranceState))(FaultToleranceState_T *aEnabled);
491 STDMETHOD(COMSETTER(FaultToleranceState))(FaultToleranceState_T aEnabled);
492 STDMETHOD(COMGETTER(FaultToleranceAddress))(BSTR *aAddress);
493 STDMETHOD(COMSETTER(FaultToleranceAddress))(IN_BSTR aAddress);
494 STDMETHOD(COMGETTER(FaultTolerancePort))(ULONG *aPort);
495 STDMETHOD(COMSETTER(FaultTolerancePort))(ULONG aPort);
496 STDMETHOD(COMGETTER(FaultTolerancePassword))(BSTR *aPassword);
497 STDMETHOD(COMSETTER(FaultTolerancePassword))(IN_BSTR aPassword);
498 STDMETHOD(COMGETTER(FaultToleranceSyncInterval))(ULONG *aInterval);
499 STDMETHOD(COMSETTER(FaultToleranceSyncInterval))(ULONG aInterval);
500 STDMETHOD(COMGETTER(RTCUseUTC))(BOOL *aEnabled);
501 STDMETHOD(COMSETTER(RTCUseUTC))(BOOL aEnabled);
502 STDMETHOD(COMGETTER(FirmwareType))(FirmwareType_T *aFirmware);
503 STDMETHOD(COMSETTER(FirmwareType))(FirmwareType_T aFirmware);
504 STDMETHOD(COMGETTER(KeyboardHIDType))(KeyboardHIDType_T *aKeyboardHIDType);
505 STDMETHOD(COMSETTER(KeyboardHIDType))(KeyboardHIDType_T aKeyboardHIDType);
506 STDMETHOD(COMGETTER(PointingHIDType))(PointingHIDType_T *aPointingHIDType);
507 STDMETHOD(COMSETTER(PointingHIDType))(PointingHIDType_T aPointingHIDType);
508 STDMETHOD(COMGETTER(ChipsetType))(ChipsetType_T *aChipsetType);
509 STDMETHOD(COMSETTER(ChipsetType))(ChipsetType_T aChipsetType);
510 STDMETHOD(COMGETTER(IOCacheEnabled))(BOOL *aEnabled);
511 STDMETHOD(COMSETTER(IOCacheEnabled))(BOOL aEnabled);
512 STDMETHOD(COMGETTER(IOCacheSize))(ULONG *aIOCacheSize);
513 STDMETHOD(COMSETTER(IOCacheSize))(ULONG aIOCacheSize);
514 STDMETHOD(COMGETTER(PCIDeviceAssignments))(ComSafeArrayOut(IPCIDeviceAttachment *, aAssignments));
515 STDMETHOD(COMGETTER(BandwidthControl))(IBandwidthControl **aBandwidthControl);
516 STDMETHOD(COMGETTER(TracingEnabled))(BOOL *pfEnabled);
517 STDMETHOD(COMSETTER(TracingEnabled))(BOOL fEnabled);
518 STDMETHOD(COMGETTER(TracingConfig))(BSTR *pbstrConfig);
519 STDMETHOD(COMSETTER(TracingConfig))(IN_BSTR bstrConfig);
520 STDMETHOD(COMGETTER(AllowTracingToAccessVM))(BOOL *pfAllow);
521 STDMETHOD(COMSETTER(AllowTracingToAccessVM))(BOOL fAllow);
522 STDMETHOD(COMGETTER(AutostartEnabled))(BOOL *pfEnabled);
523 STDMETHOD(COMSETTER(AutostartEnabled))(BOOL fEnabled);
524 STDMETHOD(COMGETTER(AutostartDelay))(ULONG *puDelay);
525 STDMETHOD(COMSETTER(AutostartDelay))(ULONG uDelay);
526 STDMETHOD(COMGETTER(AutostopType))(AutostopType_T *penmAutostopType);
527 STDMETHOD(COMSETTER(AutostopType))(AutostopType_T enmAutostopType);
528 STDMETHOD(COMGETTER(DefaultFrontend))(BSTR *aDefaultFrontend);
529 STDMETHOD(COMSETTER(DefaultFrontend))(IN_BSTR aDefaultFrontend);
530 STDMETHOD(COMGETTER(Icon))(ComSafeArrayOut(BYTE, aIcon));
531 STDMETHOD(COMSETTER(Icon))(ComSafeArrayIn(BYTE, aIcon));
532 STDMETHOD(COMGETTER(USBProxyAvailable))(BOOL *aAvailable);
533
534 // IMachine methods
535 STDMETHOD(LockMachine)(ISession *aSession, LockType_T lockType);
536 STDMETHOD(LaunchVMProcess)(ISession *aSession, IN_BSTR aType, IN_BSTR aEnvironment, IProgress **aProgress);
537
538 STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
539 STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
540 STDMETHOD(AttachDeviceWithoutMedium)(IN_BSTR aControllerName, LONG aControllerPort,
541 LONG aDevice, DeviceType_T aType);
542 STDMETHOD(AttachDevice)(IN_BSTR aControllerName, LONG aControllerPort,
543 LONG aDevice, DeviceType_T aType, IMedium *aMedium);
544 STDMETHOD(DetachDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice);
545 STDMETHOD(PassthroughDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aPassthrough);
546 STDMETHOD(TemporaryEjectDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aTempEject);
547 STDMETHOD(NonRotationalDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aNonRotational);
548 STDMETHOD(SetAutoDiscardForDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aDiscard);
549 STDMETHOD(SetNoBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
550 LONG aDevice);
551 STDMETHOD(SetBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
552 LONG aDevice, IBandwidthGroup *aBandwidthGroup);
553 STDMETHOD(MountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
554 LONG aDevice, IMedium *aMedium, BOOL aForce);
555 STDMETHOD(UnmountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
556 LONG aDevice, BOOL aForce);
557 STDMETHOD(GetMedium)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice,
558 IMedium **aMedium);
559 STDMETHOD(GetSerialPort)(ULONG slot, ISerialPort **port);
560 STDMETHOD(GetParallelPort)(ULONG slot, IParallelPort **port);
561 STDMETHOD(GetNetworkAdapter)(ULONG slot, INetworkAdapter **adapter);
562 STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
563 STDMETHOD(GetExtraData)(IN_BSTR aKey, BSTR *aValue);
564 STDMETHOD(SetExtraData)(IN_BSTR aKey, IN_BSTR aValue);
565 STDMETHOD(GetCPUProperty)(CPUPropertyType_T property, BOOL *aVal);
566 STDMETHOD(SetCPUProperty)(CPUPropertyType_T property, BOOL aVal);
567 STDMETHOD(GetCPUIDLeaf)(ULONG id, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx);
568 STDMETHOD(SetCPUIDLeaf)(ULONG id, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx);
569 STDMETHOD(RemoveCPUIDLeaf)(ULONG id);
570 STDMETHOD(RemoveAllCPUIDLeaves)();
571 STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL *aVal);
572 STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL aVal);
573 STDMETHOD(SaveSettings)();
574 STDMETHOD(DiscardSettings)();
575 STDMETHOD(Unregister)(CleanupMode_T cleanupMode, ComSafeArrayOut(IMedium*, aMedia));
576 STDMETHOD(DeleteConfig)(ComSafeArrayIn(IMedium*, aMedia), IProgress **aProgress);
577 STDMETHOD(ExportTo)(IAppliance *aAppliance, IN_BSTR location, IVirtualSystemDescription **aDescription);
578 STDMETHOD(FindSnapshot)(IN_BSTR aNameOrId, ISnapshot **aSnapshot);
579 STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
580 STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
581 STDMETHOD(CanShowConsoleWindow)(BOOL *aCanShow);
582 STDMETHOD(ShowConsoleWindow)(LONG64 *aWinId);
583 STDMETHOD(GetGuestProperty)(IN_BSTR aName, BSTR *aValue, LONG64 *aTimestamp, BSTR *aFlags);
584 STDMETHOD(GetGuestPropertyValue)(IN_BSTR aName, BSTR *aValue);
585 STDMETHOD(GetGuestPropertyTimestamp)(IN_BSTR aName, LONG64 *aTimestamp);
586 STDMETHOD(SetGuestProperty)(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags);
587 STDMETHOD(SetGuestPropertyValue)(IN_BSTR aName, IN_BSTR aValue);
588 STDMETHOD(DeleteGuestProperty)(IN_BSTR aName);
589 STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
590 STDMETHOD(GetMediumAttachmentsOfController)(IN_BSTR aName, ComSafeArrayOut(IMediumAttachment *, aAttachments));
591 STDMETHOD(GetMediumAttachment)(IN_BSTR aConstrollerName, LONG aControllerPort, LONG aDevice, IMediumAttachment **aAttachment);
592 STDMETHOD(AddStorageController)(IN_BSTR aName, StorageBus_T aConnectionType, IStorageController **controller);
593 STDMETHOD(RemoveStorageController(IN_BSTR aName));
594 STDMETHOD(GetStorageControllerByName(IN_BSTR aName, IStorageController **storageController));
595 STDMETHOD(GetStorageControllerByInstance(ULONG aInstance, IStorageController **storageController));
596 STDMETHOD(SetStorageControllerBootable)(IN_BSTR aName, BOOL fBootable);
597 STDMETHOD(AddUSBController)(IN_BSTR aName, StorageBus_T aConnectionType, IUSBController **controller);
598 STDMETHOD(RemoveUSBController(IN_BSTR aName));
599 STDMETHOD(GetUSBControllerByName(IN_BSTR aName, IUSBController **usbController));
600 STDMETHOD(GetUSBControllerCountByType(USBControllerType_T aType, ULONG *aControllers));
601 STDMETHOD(QuerySavedGuestScreenInfo)(ULONG uScreenId, ULONG *puOriginX, ULONG *puOriginY, ULONG *puWidth, ULONG *puHeight, BOOL *pfEnabled);
602 STDMETHOD(QuerySavedThumbnailSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
603 STDMETHOD(ReadSavedThumbnailToArray)(ULONG aScreenId, BOOL aBGR, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
604 STDMETHOD(ReadSavedThumbnailPNGToArray)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
605 STDMETHOD(QuerySavedScreenshotPNGSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
606 STDMETHOD(ReadSavedScreenshotPNGToArray)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
607 STDMETHOD(HotPlugCPU(ULONG aCpu));
608 STDMETHOD(HotUnplugCPU(ULONG aCpu));
609 STDMETHOD(GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached));
610 STDMETHOD(QueryLogFilename(ULONG aIdx, BSTR *aName));
611 STDMETHOD(ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData)));
612 STDMETHOD(AttachHostPCIDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL tryToUnbind));
613 STDMETHOD(DetachHostPCIDevice(LONG hostAddress));
614 STDMETHOD(CloneTo(IMachine *pTarget, CloneMode_T mode, ComSafeArrayIn(CloneOptions_T, options), IProgress **pProgress));
615 // public methods only for internal purposes
616
617 virtual bool isSnapshotMachine() const
618 {
619 return false;
620 }
621
622 virtual bool isSessionMachine() const
623 {
624 return false;
625 }
626
627 /**
628 * Override of the default locking class to be used for validating lock
629 * order with the standard member lock handle.
630 */
631 virtual VBoxLockingClass getLockingClass() const
632 {
633 return LOCKCLASS_MACHINEOBJECT;
634 }
635
636 /// @todo (dmik) add lock and make non-inlined after revising classes
637 // that use it. Note: they should enter Machine lock to keep the returned
638 // information valid!
639 bool isRegistered() { return !!mData->mRegistered; }
640
641 // unsafe inline public methods for internal purposes only (ensure there is
642 // a caller and a read lock before calling them!)
643
644 /**
645 * Returns the VirtualBox object this machine belongs to.
646 *
647 * @note This method doesn't check this object's readiness. Intended to be
648 * used by ready Machine children (whose readiness is bound to the parent's
649 * one) or after doing addCaller() manually.
650 */
651 VirtualBox* getVirtualBox() const { return mParent; }
652
653 /**
654 * Checks if this machine is accessible, without attempting to load the
655 * config file.
656 *
657 * @note This method doesn't check this object's readiness. Intended to be
658 * used by ready Machine children (whose readiness is bound to the parent's
659 * one) or after doing addCaller() manually.
660 */
661 bool isAccessible() const { return !!mData->mAccessible; }
662
663 /**
664 * Returns this machine ID.
665 *
666 * @note This method doesn't check this object's readiness. Intended to be
667 * used by ready Machine children (whose readiness is bound to the parent's
668 * one) or after adding a caller manually.
669 */
670 const Guid& getId() const { return mData->mUuid; }
671
672 /**
673 * Returns the snapshot ID this machine represents or an empty UUID if this
674 * instance is not SnapshotMachine.
675 *
676 * @note This method doesn't check this object's readiness. Intended to be
677 * used by ready Machine children (whose readiness is bound to the parent's
678 * one) or after adding a caller manually.
679 */
680 inline const Guid& getSnapshotId() const;
681
682 /**
683 * Returns this machine's full settings file path.
684 *
685 * @note This method doesn't lock this object or check its readiness.
686 * Intended to be used only after doing addCaller() manually and locking it
687 * for reading.
688 */
689 const Utf8Str& getSettingsFileFull() const { return mData->m_strConfigFileFull; }
690
691 /**
692 * Returns this machine name.
693 *
694 * @note This method doesn't lock this object or check its readiness.
695 * Intended to be used only after doing addCaller() manually and locking it
696 * for reading.
697 */
698 const Utf8Str& getName() const { return mUserData->s.strName; }
699
700 enum
701 {
702 IsModified_MachineData = 0x0001,
703 IsModified_Storage = 0x0002,
704 IsModified_NetworkAdapters = 0x0008,
705 IsModified_SerialPorts = 0x0010,
706 IsModified_ParallelPorts = 0x0020,
707 IsModified_VRDEServer = 0x0040,
708 IsModified_AudioAdapter = 0x0080,
709 IsModified_USB = 0x0100,
710 IsModified_BIOS = 0x0200,
711 IsModified_SharedFolders = 0x0400,
712 IsModified_Snapshots = 0x0800,
713 IsModified_BandwidthControl = 0x1000
714 };
715
716 /**
717 * Returns various information about this machine.
718 *
719 * @note This method doesn't lock this object or check its readiness.
720 * Intended to be used only after doing addCaller() manually and locking it
721 * for reading.
722 */
723 ChipsetType_T getChipsetType() const { return mHWData->mChipsetType; }
724
725 void setModified(uint32_t fl, bool fAllowStateModification = true);
726 void setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
727
728 bool isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
729 void allowStateModification() { mData->m_fAllowStateModification = true; }
730 void disallowStateModification() { mData->m_fAllowStateModification = false; }
731
732 const StringsList &getGroups() const { return mUserData->s.llGroups; }
733
734 // callback handlers
735 virtual HRESULT onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
736 virtual HRESULT onNATRedirectRuleChange(ULONG /* slot */, BOOL /* fRemove */ , IN_BSTR /* name */,
737 NATProtocol_T /* protocol */, IN_BSTR /* host ip */, LONG /* host port */, IN_BSTR /* guest port */, LONG /* guest port */ ) { return S_OK; }
738 virtual HRESULT onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
739 virtual HRESULT onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
740 virtual HRESULT onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
741 virtual HRESULT onUSBControllerChange() { return S_OK; }
742 virtual HRESULT onStorageControllerChange() { return S_OK; }
743 virtual HRESULT onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
744 virtual HRESULT onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
745 virtual HRESULT onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
746 virtual HRESULT onSharedFolderChange() { return S_OK; }
747 virtual HRESULT onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
748 virtual HRESULT onDragAndDropModeChange(DragAndDropMode_T /* aDragAndDropMode */) { return S_OK; }
749 virtual HRESULT onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
750 virtual HRESULT onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */, BOOL /* silent */) { return S_OK; }
751 virtual HRESULT onVideoCaptureChange() { return S_OK; }
752
753 HRESULT saveRegistryEntry(settings::MachineRegistryEntry &data);
754
755 int calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
756 void copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
757
758 void getLogFolder(Utf8Str &aLogFolder);
759 Utf8Str queryLogFilename(ULONG idx);
760
761 void composeSavedStateFilename(Utf8Str &strStateFilePath);
762
763 void getDefaultVideoCaptureFile(Utf8Str &strFile);
764
765 bool isUSBControllerPresent();
766
767 HRESULT launchVMProcess(IInternalSessionControl *aControl,
768 const Utf8Str &strType,
769 const Utf8Str &strEnvironment,
770 ProgressProxy *aProgress);
771
772 HRESULT getDirectControl(ComPtr<IInternalSessionControl> *directControl)
773 {
774 HRESULT rc;
775 *directControl = mData->mSession.mDirectControl;
776
777 if (!*directControl)
778 rc = E_ACCESSDENIED;
779 else
780 rc = S_OK;
781
782 return rc;
783 }
784
785#if defined(RT_OS_WINDOWS)
786
787 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
788 ComPtr<IInternalSessionControl> *aControl = NULL,
789 HANDLE *aIPCSem = NULL, bool aAllowClosing = false);
790 bool isSessionSpawning(RTPROCESS *aPID = NULL);
791
792 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
793 ComPtr<IInternalSessionControl> *aControl = NULL,
794 HANDLE *aIPCSem = NULL)
795 { return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
796
797#elif defined(RT_OS_OS2)
798
799 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
800 ComPtr<IInternalSessionControl> *aControl = NULL,
801 HMTX *aIPCSem = NULL, bool aAllowClosing = false);
802
803 bool isSessionSpawning(RTPROCESS *aPID = NULL);
804
805 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
806 ComPtr<IInternalSessionControl> *aControl = NULL,
807 HMTX *aIPCSem = NULL)
808 { return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
809
810#else
811
812 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
813 ComPtr<IInternalSessionControl> *aControl = NULL,
814 bool aAllowClosing = false);
815 bool isSessionSpawning();
816
817 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
818 ComPtr<IInternalSessionControl> *aControl = NULL)
819 { return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
820
821#endif
822
823 bool checkForSpawnFailure();
824
825 HRESULT prepareRegister();
826
827 HRESULT getSharedFolder(CBSTR aName,
828 ComObjPtr<SharedFolder> &aSharedFolder,
829 bool aSetError = false)
830 {
831 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
832 return findSharedFolder(aName, aSharedFolder, aSetError);
833 }
834
835 HRESULT addStateDependency(StateDependency aDepType = AnyStateDep,
836 MachineState_T *aState = NULL,
837 BOOL *aRegistered = NULL);
838 void releaseStateDependency();
839
840 HRESULT getBandwidthGroup(const Utf8Str &strBandwidthGroup,
841 ComObjPtr<BandwidthGroup> &pBandwidthGroup,
842 bool fSetError = false)
843 {
844 return mBandwidthControl->getBandwidthGroupByName(strBandwidthGroup,
845 pBandwidthGroup,
846 fSetError);
847 }
848
849protected:
850
851 HRESULT checkStateDependency(StateDependency aDepType);
852
853 Machine *getMachine();
854
855 void ensureNoStateDependencies();
856
857 virtual HRESULT setMachineState(MachineState_T aMachineState);
858
859 HRESULT findSharedFolder(const Utf8Str &aName,
860 ComObjPtr<SharedFolder> &aSharedFolder,
861 bool aSetError = false);
862
863 HRESULT loadSettings(bool aRegistered);
864 HRESULT loadMachineDataFromSettings(const settings::MachineConfigFile &config,
865 const Guid *puuidRegistry);
866 HRESULT loadSnapshot(const settings::Snapshot &data,
867 const Guid &aCurSnapshotId,
868 Snapshot *aParentSnapshot);
869 HRESULT loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
870 const settings::Autostart *pAutostart);
871 HRESULT loadDebugging(const settings::Debugging *pDbg);
872 HRESULT loadAutostart(const settings::Autostart *pAutostart);
873 HRESULT loadStorageControllers(const settings::Storage &data,
874 const Guid *puuidRegistry,
875 const Guid *puuidSnapshot);
876 HRESULT loadStorageDevices(StorageController *aStorageController,
877 const settings::StorageController &data,
878 const Guid *puuidRegistry,
879 const Guid *puuidSnapshot);
880
881 HRESULT findSnapshotById(const Guid &aId,
882 ComObjPtr<Snapshot> &aSnapshot,
883 bool aSetError = false);
884 HRESULT findSnapshotByName(const Utf8Str &strName,
885 ComObjPtr<Snapshot> &aSnapshot,
886 bool aSetError = false);
887
888 HRESULT getStorageControllerByName(const Utf8Str &aName,
889 ComObjPtr<StorageController> &aStorageController,
890 bool aSetError = false);
891
892 HRESULT getMediumAttachmentsOfController(CBSTR aName,
893 MediaData::AttachmentList &aAttachments);
894
895 HRESULT getUSBControllerByName(const Utf8Str &aName,
896 ComObjPtr<USBController> &aUSBController,
897 bool aSetError = false);
898
899 ULONG getUSBControllerCountByType(USBControllerType_T enmType);
900
901 enum
902 {
903 /* flags for #saveSettings() */
904 SaveS_ResetCurStateModified = 0x01,
905 SaveS_InformCallbacksAnyway = 0x02,
906 SaveS_Force = 0x04,
907 /* flags for #saveStateSettings() */
908 SaveSTS_CurStateModified = 0x20,
909 SaveSTS_StateFilePath = 0x40,
910 SaveSTS_StateTimeStamp = 0x80
911 };
912
913 HRESULT prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
914 HRESULT saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
915
916 void copyMachineDataToSettings(settings::MachineConfigFile &config);
917 HRESULT saveAllSnapshots(settings::MachineConfigFile &config);
918 HRESULT saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
919 settings::Autostart *pAutostart);
920 HRESULT saveStorageControllers(settings::Storage &data);
921 HRESULT saveStorageDevices(ComObjPtr<StorageController> aStorageController,
922 settings::StorageController &data);
923 HRESULT saveStateSettings(int aFlags);
924
925 void addMediumToRegistry(ComObjPtr<Medium> &pMedium);
926
927 HRESULT createImplicitDiffs(IProgress *aProgress,
928 ULONG aWeight,
929 bool aOnline);
930 HRESULT deleteImplicitDiffs(bool aOnline);
931
932 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
933 IN_BSTR aControllerName,
934 LONG aControllerPort,
935 LONG aDevice);
936 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
937 ComObjPtr<Medium> pMedium);
938 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
939 Guid &id);
940
941 HRESULT detachDevice(MediumAttachment *pAttach,
942 AutoWriteLock &writeLock,
943 Snapshot *pSnapshot);
944
945 HRESULT detachAllMedia(AutoWriteLock &writeLock,
946 Snapshot *pSnapshot,
947 CleanupMode_T cleanupMode,
948 MediaList &llMedia);
949
950 void commitMedia(bool aOnline = false);
951 void rollbackMedia();
952
953 bool isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
954
955 void rollback(bool aNotify);
956 void commit();
957 void copyFrom(Machine *aThat);
958 bool isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
959
960 struct DeleteTask;
961 static DECLCALLBACK(int) deleteThread(RTTHREAD Thread, void *pvUser);
962 HRESULT deleteTaskWorker(DeleteTask &task);
963
964 Utf8Str getExtraData(const Utf8Str &strKey);
965
966#ifdef VBOX_WITH_GUEST_PROPS
967 HRESULT getGuestPropertyFromService(IN_BSTR aName, BSTR *aValue,
968 LONG64 *aTimestamp, BSTR *aFlags) const;
969 HRESULT getGuestPropertyFromVM(IN_BSTR aName, BSTR *aValue,
970 LONG64 *aTimestamp, BSTR *aFlags) const;
971 HRESULT setGuestPropertyToService(IN_BSTR aName, IN_BSTR aValue,
972 IN_BSTR aFlags);
973 HRESULT setGuestPropertyToVM(IN_BSTR aName, IN_BSTR aValue,
974 IN_BSTR aFlags);
975 HRESULT enumerateGuestPropertiesInService
976 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
977 ComSafeArrayOut(BSTR, aValues),
978 ComSafeArrayOut(LONG64, aTimestamps),
979 ComSafeArrayOut(BSTR, aFlags));
980 HRESULT enumerateGuestPropertiesOnVM
981 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
982 ComSafeArrayOut(BSTR, aValues),
983 ComSafeArrayOut(LONG64, aTimestamps),
984 ComSafeArrayOut(BSTR, aFlags));
985#endif /* VBOX_WITH_GUEST_PROPS */
986
987#ifdef VBOX_WITH_RESOURCE_USAGE_API
988 void getDiskList(MediaList &list);
989 void registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
990
991 pm::CollectorGuest *mCollectorGuest;
992#endif /* VBOX_WITH_RESOURCE_USAGE_API */
993
994 Machine * const mPeer;
995
996 VirtualBox * const mParent;
997
998 Shareable<Data> mData;
999 Shareable<SSData> mSSData;
1000
1001 Backupable<UserData> mUserData;
1002 Backupable<HWData> mHWData;
1003 Backupable<MediaData> mMediaData;
1004
1005 // the following fields need special backup/rollback/commit handling,
1006 // so they cannot be a part of HWData
1007
1008 const ComObjPtr<VRDEServer> mVRDEServer;
1009 const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
1010 const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
1011 const ComObjPtr<AudioAdapter> mAudioAdapter;
1012 const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
1013 const ComObjPtr<BIOSSettings> mBIOSSettings;
1014 const ComObjPtr<BandwidthControl> mBandwidthControl;
1015
1016 typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
1017 NetworkAdapterVector mNetworkAdapters;
1018
1019 typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
1020 Backupable<StorageControllerList> mStorageControllers;
1021
1022 typedef std::list<ComObjPtr<USBController> > USBControllerList;
1023 Backupable<USBControllerList> mUSBControllers;
1024
1025 uint64_t uRegistryNeedsSaving;
1026
1027 friend class SessionMachine;
1028 friend class SnapshotMachine;
1029 friend class Appliance;
1030 friend class VirtualBox;
1031
1032 friend class MachineCloneVM;
1033};
1034
1035// SessionMachine class
1036////////////////////////////////////////////////////////////////////////////////
1037
1038/**
1039 * @note Notes on locking objects of this class:
1040 * SessionMachine shares some data with the primary Machine instance (pointed
1041 * to by the |mPeer| member). In order to provide data consistency it also
1042 * shares its lock handle. This means that whenever you lock a SessionMachine
1043 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1044 * instance is also locked in the same lock mode. Keep it in mind.
1045 */
1046class ATL_NO_VTABLE SessionMachine :
1047 public Machine,
1048 VBOX_SCRIPTABLE_IMPL(IInternalMachineControl)
1049{
1050public:
1051 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1052
1053 DECLARE_NOT_AGGREGATABLE(SessionMachine)
1054
1055 DECLARE_PROTECT_FINAL_CONSTRUCT()
1056
1057 BEGIN_COM_MAP(SessionMachine)
1058 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1059 COM_INTERFACE_ENTRY(IInternalMachineControl)
1060 END_COM_MAP()
1061
1062 DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1063
1064 HRESULT FinalConstruct();
1065 void FinalRelease();
1066
1067 // public initializer/uninitializer for internal purposes only
1068 HRESULT init(Machine *aMachine);
1069 void uninit() { uninit(Uninit::Unexpected); }
1070
1071 // util::Lockable interface
1072 RWLockHandle *lockHandle() const;
1073
1074 // IInternalMachineControl methods
1075 STDMETHOD(SetRemoveSavedStateFile)(BOOL aRemove);
1076 STDMETHOD(UpdateState)(MachineState_T machineState);
1077 STDMETHOD(GetIPCId)(BSTR *id);
1078 STDMETHOD(BeginPowerUp)(IProgress *aProgress);
1079 STDMETHOD(EndPowerUp)(LONG iResult);
1080 STDMETHOD(BeginPoweringDown)(IProgress **aProgress);
1081 STDMETHOD(EndPoweringDown)(LONG aResult, IN_BSTR aErrMsg);
1082 STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
1083 STDMETHOD(CaptureUSBDevice)(IN_BSTR aId);
1084 STDMETHOD(DetachUSBDevice)(IN_BSTR aId, BOOL aDone);
1085 STDMETHOD(AutoCaptureUSBDevices)();
1086 STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
1087 STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
1088 STDMETHOD(BeginSavingState)(IProgress **aProgress, BSTR *aStateFilePath);
1089 STDMETHOD(EndSavingState)(LONG aResult, IN_BSTR aErrMsg);
1090 STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
1091 STDMETHOD(BeginTakingSnapshot)(IConsole *aInitiator,
1092 IN_BSTR aName,
1093 IN_BSTR aDescription,
1094 IProgress *aConsoleProgress,
1095 BOOL fTakingSnapshotOnline,
1096 BSTR *aStateFilePath);
1097 STDMETHOD(EndTakingSnapshot)(BOOL aSuccess);
1098 STDMETHOD(DeleteSnapshot)(IConsole *aInitiator, IN_BSTR aStartId,
1099 IN_BSTR aEndID, BOOL fDeleteAllChildren,
1100 MachineState_T *aMachineState, IProgress **aProgress);
1101 STDMETHOD(FinishOnlineMergeMedium)(IMediumAttachment *aMediumAttachment,
1102 IMedium *aSource, IMedium *aTarget,
1103 BOOL fMergeForward,
1104 IMedium *pParentForTarget,
1105 ComSafeArrayIn(IMedium *, aChildrenToReparent));
1106 STDMETHOD(RestoreSnapshot)(IConsole *aInitiator,
1107 ISnapshot *aSnapshot,
1108 MachineState_T *aMachineState,
1109 IProgress **aProgress);
1110 STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
1111 ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
1112 STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
1113 LONG64 aTimestamp, IN_BSTR aFlags);
1114 STDMETHOD(LockMedia)();
1115 STDMETHOD(UnlockMedia)();
1116 STDMETHOD(EjectMedium)(IMediumAttachment *aAttachment,
1117 IMediumAttachment **aNewAttachment);
1118 STDMETHOD(ReportVmStatistics)(ULONG aValidStats, ULONG aCpuUser,
1119 ULONG aCpuKernel, ULONG aCpuIdle,
1120 ULONG aMemTotal, ULONG aMemFree,
1121 ULONG aMemBalloon, ULONG aMemShared,
1122 ULONG aMemCache, ULONG aPageTotal,
1123 ULONG aAllocVMM, ULONG aFreeVMM,
1124 ULONG aBalloonedVMM, ULONG aSharedVMM,
1125 ULONG aVmNetRx, ULONG aVmNetTx);
1126
1127 // public methods only for internal purposes
1128
1129 virtual bool isSessionMachine() const
1130 {
1131 return true;
1132 }
1133
1134 bool checkForDeath();
1135
1136 HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1137 HRESULT onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1138 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
1139 HRESULT onStorageControllerChange();
1140 HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1141 HRESULT onSerialPortChange(ISerialPort *serialPort);
1142 HRESULT onParallelPortChange(IParallelPort *parallelPort);
1143 HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
1144 HRESULT onVRDEServerChange(BOOL aRestart);
1145 HRESULT onVideoCaptureChange();
1146 HRESULT onUSBControllerChange();
1147 HRESULT onUSBDeviceAttach(IUSBDevice *aDevice,
1148 IVirtualBoxErrorInfo *aError,
1149 ULONG aMaskedIfs);
1150 HRESULT onUSBDeviceDetach(IN_BSTR aId,
1151 IVirtualBoxErrorInfo *aError);
1152 HRESULT onSharedFolderChange();
1153 HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
1154 HRESULT onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode);
1155 HRESULT onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1156 HRESULT onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1157 HRESULT onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1158
1159 bool hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1160
1161 HRESULT lockMedia();
1162 void unlockMedia();
1163
1164private:
1165
1166 struct ConsoleTaskData
1167 {
1168 ConsoleTaskData()
1169 : mLastState(MachineState_Null)
1170 { }
1171
1172 MachineState_T mLastState;
1173 ComObjPtr<Progress> mProgress;
1174
1175 // used when taking snapshot
1176 ComObjPtr<Snapshot> mSnapshot;
1177
1178 // used when saving state (either as part of a snapshot or separate)
1179 Utf8Str strStateFilePath;
1180 };
1181
1182 struct Uninit
1183 {
1184 enum Reason { Unexpected, Abnormal, Normal };
1185 };
1186
1187 struct SnapshotTask;
1188 struct DeleteSnapshotTask;
1189 struct RestoreSnapshotTask;
1190
1191 friend struct DeleteSnapshotTask;
1192 friend struct RestoreSnapshotTask;
1193
1194 void uninit(Uninit::Reason aReason);
1195
1196 HRESULT endSavingState(HRESULT aRC, const Utf8Str &aErrMsg);
1197 void releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1198
1199 void deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1200 void restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1201
1202 HRESULT prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1203 const Guid &machineId,
1204 const Guid &snapshotId,
1205 bool fOnlineMergePossible,
1206 MediumLockList *aVMMALockList,
1207 ComObjPtr<Medium> &aSource,
1208 ComObjPtr<Medium> &aTarget,
1209 bool &fMergeForward,
1210 ComObjPtr<Medium> &pParentForTarget,
1211 MediaList &aChildrenToReparent,
1212 bool &fNeedOnlineMerge,
1213 MediumLockList * &aMediumLockList);
1214 void cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1215 const ComObjPtr<Medium> &aSource,
1216 const MediaList &aChildrenToReparent,
1217 bool fNeedsOnlineMerge,
1218 MediumLockList *aMediumLockList,
1219 const Guid &aMediumId,
1220 const Guid &aSnapshotId);
1221 HRESULT onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1222 const ComObjPtr<Medium> &aSource,
1223 const ComObjPtr<Medium> &aTarget,
1224 bool fMergeForward,
1225 const ComObjPtr<Medium> &pParentForTarget,
1226 const MediaList &aChildrenToReparent,
1227 MediumLockList *aMediumLockList,
1228 ComObjPtr<Progress> &aProgress,
1229 bool *pfNeedsMachineSaveSettings);
1230
1231 HRESULT setMachineState(MachineState_T aMachineState);
1232 HRESULT updateMachineStateOnClient();
1233
1234 HRESULT mRemoveSavedState;
1235
1236 ConsoleTaskData mConsoleTaskData;
1237
1238 /** interprocess semaphore handle for this machine */
1239#if defined(RT_OS_WINDOWS)
1240 HANDLE mIPCSem;
1241 Bstr mIPCSemName;
1242 friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
1243 ComPtr<IInternalSessionControl> *aControl,
1244 HANDLE *aIPCSem, bool aAllowClosing);
1245#elif defined(RT_OS_OS2)
1246 HMTX mIPCSem;
1247 Bstr mIPCSemName;
1248 friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
1249 ComPtr<IInternalSessionControl> *aControl,
1250 HMTX *aIPCSem, bool aAllowClosing);
1251#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
1252 int mIPCSem;
1253# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
1254 Bstr mIPCKey;
1255# endif /*VBOX_WITH_NEW_SYS_V_KEYGEN */
1256#else
1257# error "Port me!"
1258#endif
1259
1260 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
1261};
1262
1263// SnapshotMachine class
1264////////////////////////////////////////////////////////////////////////////////
1265
1266/**
1267 * @note Notes on locking objects of this class:
1268 * SnapshotMachine shares some data with the primary Machine instance (pointed
1269 * to by the |mPeer| member). In order to provide data consistency it also
1270 * shares its lock handle. This means that whenever you lock a SessionMachine
1271 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1272 * instance is also locked in the same lock mode. Keep it in mind.
1273 */
1274class ATL_NO_VTABLE SnapshotMachine :
1275 public Machine
1276{
1277public:
1278 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1279
1280 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1281
1282 DECLARE_PROTECT_FINAL_CONSTRUCT()
1283
1284 BEGIN_COM_MAP(SnapshotMachine)
1285 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1286 END_COM_MAP()
1287
1288 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1289
1290 HRESULT FinalConstruct();
1291 void FinalRelease();
1292
1293 // public initializer/uninitializer for internal purposes only
1294 HRESULT init(SessionMachine *aSessionMachine,
1295 IN_GUID aSnapshotId,
1296 const Utf8Str &aStateFilePath);
1297 HRESULT initFromSettings(Machine *aMachine,
1298 const settings::Hardware &hardware,
1299 const settings::Debugging *pDbg,
1300 const settings::Autostart *pAutostart,
1301 const settings::Storage &storage,
1302 IN_GUID aSnapshotId,
1303 const Utf8Str &aStateFilePath);
1304 void uninit();
1305
1306 // util::Lockable interface
1307 RWLockHandle *lockHandle() const;
1308
1309 // public methods only for internal purposes
1310
1311 virtual bool isSnapshotMachine() const
1312 {
1313 return true;
1314 }
1315
1316 HRESULT onSnapshotChange(Snapshot *aSnapshot);
1317
1318 // unsafe inline public methods for internal purposes only (ensure there is
1319 // a caller and a read lock before calling them!)
1320
1321 const Guid& getSnapshotId() const { return mSnapshotId; }
1322
1323private:
1324
1325 Guid mSnapshotId;
1326 /** This field replaces mPeer for SessionMachine instances, as having
1327 * a peer reference is plain meaningless and causes many subtle problems
1328 * with saving settings and the like. */
1329 Machine * const mMachine;
1330
1331 friend class Snapshot;
1332};
1333
1334// third party methods that depend on SnapshotMachine definition
1335
1336inline const Guid &Machine::getSnapshotId() const
1337{
1338 return (isSnapshotMachine())
1339 ? static_cast<const SnapshotMachine*>(this)->getSnapshotId()
1340 : Guid::Empty;
1341}
1342
1343
1344#endif // ____H_MACHINEIMPL
1345/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

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