VirtualBox

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

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

Main/MediumAttachment+Machine: stub attribute/method for an explicit hot-pluggable medium attachment flag, to be used by AHCI soon
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 55.7 KB
Line 
1/* $Id: MachineImpl.h 48879 2013-10-04 08:37: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.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 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(SetHotPluggableForDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aHotPluggable);
546 STDMETHOD(SetNoBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
547 LONG aDevice);
548 STDMETHOD(SetBandwidthGroupForDevice)(IN_BSTR aControllerName, LONG aControllerPort,
549 LONG aDevice, IBandwidthGroup *aBandwidthGroup);
550 STDMETHOD(MountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
551 LONG aDevice, IMedium *aMedium, BOOL aForce);
552 STDMETHOD(UnmountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
553 LONG aDevice, BOOL aForce);
554 STDMETHOD(GetMedium)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice,
555 IMedium **aMedium);
556 STDMETHOD(GetSerialPort)(ULONG slot, ISerialPort **port);
557 STDMETHOD(GetParallelPort)(ULONG slot, IParallelPort **port);
558 STDMETHOD(GetNetworkAdapter)(ULONG slot, INetworkAdapter **adapter);
559 STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
560 STDMETHOD(GetExtraData)(IN_BSTR aKey, BSTR *aValue);
561 STDMETHOD(SetExtraData)(IN_BSTR aKey, IN_BSTR aValue);
562 STDMETHOD(GetCPUProperty)(CPUPropertyType_T property, BOOL *aVal);
563 STDMETHOD(SetCPUProperty)(CPUPropertyType_T property, BOOL aVal);
564 STDMETHOD(GetCPUIDLeaf)(ULONG id, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx);
565 STDMETHOD(SetCPUIDLeaf)(ULONG id, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx);
566 STDMETHOD(RemoveCPUIDLeaf)(ULONG id);
567 STDMETHOD(RemoveAllCPUIDLeaves)();
568 STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL *aVal);
569 STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL aVal);
570 STDMETHOD(SetSettingsFilePath)(IN_BSTR aFilePath, IProgress **aProgress);
571 STDMETHOD(SaveSettings)();
572 STDMETHOD(DiscardSettings)();
573 STDMETHOD(Unregister)(CleanupMode_T cleanupMode, ComSafeArrayOut(IMedium*, aMedia));
574 STDMETHOD(DeleteConfig)(ComSafeArrayIn(IMedium*, aMedia), IProgress **aProgress);
575 STDMETHOD(ExportTo)(IAppliance *aAppliance, IN_BSTR location, IVirtualSystemDescription **aDescription);
576 STDMETHOD(FindSnapshot)(IN_BSTR aNameOrId, ISnapshot **aSnapshot);
577 STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount);
578 STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
579 STDMETHOD(CanShowConsoleWindow)(BOOL *aCanShow);
580 STDMETHOD(ShowConsoleWindow)(LONG64 *aWinId);
581 STDMETHOD(GetGuestProperty)(IN_BSTR aName, BSTR *aValue, LONG64 *aTimestamp, BSTR *aFlags);
582 STDMETHOD(GetGuestPropertyValue)(IN_BSTR aName, BSTR *aValue);
583 STDMETHOD(GetGuestPropertyTimestamp)(IN_BSTR aName, LONG64 *aTimestamp);
584 STDMETHOD(SetGuestProperty)(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags);
585 STDMETHOD(SetGuestPropertyValue)(IN_BSTR aName, IN_BSTR aValue);
586 STDMETHOD(DeleteGuestProperty)(IN_BSTR aName);
587 STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
588 STDMETHOD(GetMediumAttachmentsOfController)(IN_BSTR aName, ComSafeArrayOut(IMediumAttachment *, aAttachments));
589 STDMETHOD(GetMediumAttachment)(IN_BSTR aConstrollerName, LONG aControllerPort, LONG aDevice, IMediumAttachment **aAttachment);
590 STDMETHOD(AddStorageController)(IN_BSTR aName, StorageBus_T aConnectionType, IStorageController **controller);
591 STDMETHOD(RemoveStorageController(IN_BSTR aName));
592 STDMETHOD(GetStorageControllerByName(IN_BSTR aName, IStorageController **storageController));
593 STDMETHOD(GetStorageControllerByInstance(ULONG aInstance, IStorageController **storageController));
594 STDMETHOD(SetStorageControllerBootable)(IN_BSTR aName, BOOL fBootable);
595 STDMETHOD(AddUSBController)(IN_BSTR aName, USBControllerType_T aConnectionType, IUSBController **controller);
596 STDMETHOD(RemoveUSBController(IN_BSTR aName));
597 STDMETHOD(GetUSBControllerByName(IN_BSTR aName, IUSBController **usbController));
598 STDMETHOD(GetUSBControllerCountByType(USBControllerType_T aType, ULONG *aControllers));
599 STDMETHOD(QuerySavedGuestScreenInfo)(ULONG uScreenId, ULONG *puOriginX, ULONG *puOriginY, ULONG *puWidth, ULONG *puHeight, BOOL *pfEnabled);
600 STDMETHOD(QuerySavedThumbnailSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
601 STDMETHOD(ReadSavedThumbnailToArray)(ULONG aScreenId, BOOL aBGR, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
602 STDMETHOD(ReadSavedThumbnailPNGToArray)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
603 STDMETHOD(QuerySavedScreenshotPNGSize)(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight);
604 STDMETHOD(ReadSavedScreenshotPNGToArray)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData));
605 STDMETHOD(HotPlugCPU(ULONG aCpu));
606 STDMETHOD(HotUnplugCPU(ULONG aCpu));
607 STDMETHOD(GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached));
608 STDMETHOD(QueryLogFilename(ULONG aIdx, BSTR *aName));
609 STDMETHOD(ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData)));
610 STDMETHOD(AttachHostPCIDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL tryToUnbind));
611 STDMETHOD(DetachHostPCIDevice(LONG hostAddress));
612 STDMETHOD(CloneTo(IMachine *pTarget, CloneMode_T mode, ComSafeArrayIn(CloneOptions_T, options), IProgress **pProgress));
613 // public methods only for internal purposes
614
615 virtual bool isSnapshotMachine() const
616 {
617 return false;
618 }
619
620 virtual bool isSessionMachine() const
621 {
622 return false;
623 }
624
625 /**
626 * Override of the default locking class to be used for validating lock
627 * order with the standard member lock handle.
628 */
629 virtual VBoxLockingClass getLockingClass() const
630 {
631 return LOCKCLASS_MACHINEOBJECT;
632 }
633
634 /// @todo (dmik) add lock and make non-inlined after revising classes
635 // that use it. Note: they should enter Machine lock to keep the returned
636 // information valid!
637 bool isRegistered() { return !!mData->mRegistered; }
638
639 // unsafe inline public methods for internal purposes only (ensure there is
640 // a caller and a read lock before calling them!)
641
642 /**
643 * Returns the VirtualBox object this machine belongs to.
644 *
645 * @note This method doesn't check this object's readiness. Intended to be
646 * used by ready Machine children (whose readiness is bound to the parent's
647 * one) or after doing addCaller() manually.
648 */
649 VirtualBox* getVirtualBox() const { return mParent; }
650
651 /**
652 * Checks if this machine is accessible, without attempting to load the
653 * config file.
654 *
655 * @note This method doesn't check this object's readiness. Intended to be
656 * used by ready Machine children (whose readiness is bound to the parent's
657 * one) or after doing addCaller() manually.
658 */
659 bool isAccessible() const { return !!mData->mAccessible; }
660
661 /**
662 * Returns this machine ID.
663 *
664 * @note This method doesn't check this object's readiness. Intended to be
665 * used by ready Machine children (whose readiness is bound to the parent's
666 * one) or after adding a caller manually.
667 */
668 const Guid& getId() const { return mData->mUuid; }
669
670 /**
671 * Returns the snapshot ID this machine represents or an empty UUID if this
672 * instance is not SnapshotMachine.
673 *
674 * @note This method doesn't check this object's readiness. Intended to be
675 * used by ready Machine children (whose readiness is bound to the parent's
676 * one) or after adding a caller manually.
677 */
678 inline const Guid& getSnapshotId() const;
679
680 /**
681 * Returns this machine's full settings file path.
682 *
683 * @note This method doesn't lock this object or check its readiness.
684 * Intended to be used only after doing addCaller() manually and locking it
685 * for reading.
686 */
687 const Utf8Str& getSettingsFileFull() const { return mData->m_strConfigFileFull; }
688
689 /**
690 * Returns this machine name.
691 *
692 * @note This method doesn't lock this object or check its readiness.
693 * Intended to be used only after doing addCaller() manually and locking it
694 * for reading.
695 */
696 const Utf8Str& getName() const { return mUserData->s.strName; }
697
698 enum
699 {
700 IsModified_MachineData = 0x0001,
701 IsModified_Storage = 0x0002,
702 IsModified_NetworkAdapters = 0x0008,
703 IsModified_SerialPorts = 0x0010,
704 IsModified_ParallelPorts = 0x0020,
705 IsModified_VRDEServer = 0x0040,
706 IsModified_AudioAdapter = 0x0080,
707 IsModified_USB = 0x0100,
708 IsModified_BIOS = 0x0200,
709 IsModified_SharedFolders = 0x0400,
710 IsModified_Snapshots = 0x0800,
711 IsModified_BandwidthControl = 0x1000
712 };
713
714 /**
715 * Returns various information about this machine.
716 *
717 * @note This method doesn't lock this object or check its readiness.
718 * Intended to be used only after doing addCaller() manually and locking it
719 * for reading.
720 */
721 ChipsetType_T getChipsetType() const { return mHWData->mChipsetType; }
722
723 void setModified(uint32_t fl, bool fAllowStateModification = true);
724 void setModifiedLock(uint32_t fl, bool fAllowStateModification = true);
725
726 bool isStateModificationAllowed() const { return mData->m_fAllowStateModification; }
727 void allowStateModification() { mData->m_fAllowStateModification = true; }
728 void disallowStateModification() { mData->m_fAllowStateModification = false; }
729
730 const StringsList &getGroups() const { return mUserData->s.llGroups; }
731
732 // callback handlers
733 virtual HRESULT onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
734 virtual HRESULT onNATRedirectRuleChange(ULONG /* slot */, BOOL /* fRemove */ , IN_BSTR /* name */,
735 NATProtocol_T /* protocol */, IN_BSTR /* host ip */, LONG /* host port */, IN_BSTR /* guest port */, LONG /* guest port */ ) { return S_OK; }
736 virtual HRESULT onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
737 virtual HRESULT onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
738 virtual HRESULT onVRDEServerChange(BOOL /* aRestart */) { return S_OK; }
739 virtual HRESULT onUSBControllerChange() { return S_OK; }
740 virtual HRESULT onStorageControllerChange() { return S_OK; }
741 virtual HRESULT onCPUChange(ULONG /* aCPU */, BOOL /* aRemove */) { return S_OK; }
742 virtual HRESULT onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
743 virtual HRESULT onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
744 virtual HRESULT onSharedFolderChange() { return S_OK; }
745 virtual HRESULT onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
746 virtual HRESULT onDragAndDropModeChange(DragAndDropMode_T /* aDragAndDropMode */) { return S_OK; }
747 virtual HRESULT onBandwidthGroupChange(IBandwidthGroup * /* aBandwidthGroup */) { return S_OK; }
748 virtual HRESULT onStorageDeviceChange(IMediumAttachment * /* mediumAttachment */, BOOL /* remove */, BOOL /* silent */) { return S_OK; }
749 virtual HRESULT onVideoCaptureChange() { return S_OK; }
750
751 HRESULT saveRegistryEntry(settings::MachineRegistryEntry &data);
752
753 int calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
754 void copyPathRelativeToMachine(const Utf8Str &strSource, Utf8Str &strTarget);
755
756 void getLogFolder(Utf8Str &aLogFolder);
757 Utf8Str queryLogFilename(ULONG idx);
758
759 void composeSavedStateFilename(Utf8Str &strStateFilePath);
760
761 void getDefaultVideoCaptureFile(Utf8Str &strFile);
762
763 bool isUSBControllerPresent();
764
765 HRESULT launchVMProcess(IInternalSessionControl *aControl,
766 const Utf8Str &strType,
767 const Utf8Str &strEnvironment,
768 ProgressProxy *aProgress);
769
770 HRESULT getDirectControl(ComPtr<IInternalSessionControl> *directControl)
771 {
772 HRESULT rc;
773 *directControl = mData->mSession.mDirectControl;
774
775 if (!*directControl)
776 rc = E_ACCESSDENIED;
777 else
778 rc = S_OK;
779
780 return rc;
781 }
782
783 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
784 ComPtr<IInternalSessionControl> *aControl = NULL,
785 bool aAllowClosing = false);
786 bool isSessionSpawning();
787
788 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
789 ComPtr<IInternalSessionControl> *aControl = NULL)
790 { return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
791
792#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
793 bool checkForSpawnFailure();
794#endif /* !VBOX_WITH_GENERIC_SESSION_WATCHER */
795
796 HRESULT prepareRegister();
797
798 HRESULT getSharedFolder(CBSTR aName,
799 ComObjPtr<SharedFolder> &aSharedFolder,
800 bool aSetError = false)
801 {
802 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
803 return findSharedFolder(aName, aSharedFolder, aSetError);
804 }
805
806 HRESULT addStateDependency(StateDependency aDepType = AnyStateDep,
807 MachineState_T *aState = NULL,
808 BOOL *aRegistered = NULL);
809 void releaseStateDependency();
810
811 HRESULT getBandwidthGroup(const Utf8Str &strBandwidthGroup,
812 ComObjPtr<BandwidthGroup> &pBandwidthGroup,
813 bool fSetError = false)
814 {
815 return mBandwidthControl->getBandwidthGroupByName(strBandwidthGroup,
816 pBandwidthGroup,
817 fSetError);
818 }
819
820protected:
821
822 class ClientToken;
823
824 HRESULT checkStateDependency(StateDependency aDepType);
825
826 Machine *getMachine();
827
828 void ensureNoStateDependencies();
829
830 virtual HRESULT setMachineState(MachineState_T aMachineState);
831
832 HRESULT findSharedFolder(const Utf8Str &aName,
833 ComObjPtr<SharedFolder> &aSharedFolder,
834 bool aSetError = false);
835
836 HRESULT loadSettings(bool aRegistered);
837 HRESULT loadMachineDataFromSettings(const settings::MachineConfigFile &config,
838 const Guid *puuidRegistry);
839 HRESULT loadSnapshot(const settings::Snapshot &data,
840 const Guid &aCurSnapshotId,
841 Snapshot *aParentSnapshot);
842 HRESULT loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
843 const settings::Autostart *pAutostart);
844 HRESULT loadDebugging(const settings::Debugging *pDbg);
845 HRESULT loadAutostart(const settings::Autostart *pAutostart);
846 HRESULT loadStorageControllers(const settings::Storage &data,
847 const Guid *puuidRegistry,
848 const Guid *puuidSnapshot);
849 HRESULT loadStorageDevices(StorageController *aStorageController,
850 const settings::StorageController &data,
851 const Guid *puuidRegistry,
852 const Guid *puuidSnapshot);
853
854 HRESULT findSnapshotById(const Guid &aId,
855 ComObjPtr<Snapshot> &aSnapshot,
856 bool aSetError = false);
857 HRESULT findSnapshotByName(const Utf8Str &strName,
858 ComObjPtr<Snapshot> &aSnapshot,
859 bool aSetError = false);
860
861 HRESULT getStorageControllerByName(const Utf8Str &aName,
862 ComObjPtr<StorageController> &aStorageController,
863 bool aSetError = false);
864
865 HRESULT getMediumAttachmentsOfController(CBSTR aName,
866 MediaData::AttachmentList &aAttachments);
867
868 HRESULT getUSBControllerByName(const Utf8Str &aName,
869 ComObjPtr<USBController> &aUSBController,
870 bool aSetError = false);
871
872 ULONG getUSBControllerCountByType(USBControllerType_T enmType);
873
874 enum
875 {
876 /* flags for #saveSettings() */
877 SaveS_ResetCurStateModified = 0x01,
878 SaveS_InformCallbacksAnyway = 0x02,
879 SaveS_Force = 0x04,
880 /* flags for #saveStateSettings() */
881 SaveSTS_CurStateModified = 0x20,
882 SaveSTS_StateFilePath = 0x40,
883 SaveSTS_StateTimeStamp = 0x80
884 };
885
886 HRESULT prepareSaveSettings(bool *pfNeedsGlobalSaveSettings);
887 HRESULT saveSettings(bool *pfNeedsGlobalSaveSettings, int aFlags = 0);
888
889 void copyMachineDataToSettings(settings::MachineConfigFile &config);
890 HRESULT saveAllSnapshots(settings::MachineConfigFile &config);
891 HRESULT saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
892 settings::Autostart *pAutostart);
893 HRESULT saveStorageControllers(settings::Storage &data);
894 HRESULT saveStorageDevices(ComObjPtr<StorageController> aStorageController,
895 settings::StorageController &data);
896 HRESULT saveStateSettings(int aFlags);
897
898 void addMediumToRegistry(ComObjPtr<Medium> &pMedium);
899
900 HRESULT createImplicitDiffs(IProgress *aProgress,
901 ULONG aWeight,
902 bool aOnline);
903 HRESULT deleteImplicitDiffs(bool aOnline);
904
905 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
906 IN_BSTR aControllerName,
907 LONG aControllerPort,
908 LONG aDevice);
909 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
910 ComObjPtr<Medium> pMedium);
911 MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
912 Guid &id);
913
914 HRESULT detachDevice(MediumAttachment *pAttach,
915 AutoWriteLock &writeLock,
916 Snapshot *pSnapshot);
917
918 HRESULT detachAllMedia(AutoWriteLock &writeLock,
919 Snapshot *pSnapshot,
920 CleanupMode_T cleanupMode,
921 MediaList &llMedia);
922
923 void commitMedia(bool aOnline = false);
924 void rollbackMedia();
925
926 bool isInOwnDir(Utf8Str *aSettingsDir = NULL) const;
927
928 void rollback(bool aNotify);
929 void commit();
930 void copyFrom(Machine *aThat);
931 bool isControllerHotplugCapable(StorageControllerType_T enmCtrlType);
932
933 struct DeleteTask;
934 static DECLCALLBACK(int) deleteThread(RTTHREAD Thread, void *pvUser);
935 HRESULT deleteTaskWorker(DeleteTask &task);
936
937 Utf8Str getExtraData(const Utf8Str &strKey);
938
939#ifdef VBOX_WITH_GUEST_PROPS
940 HRESULT getGuestPropertyFromService(IN_BSTR aName, BSTR *aValue,
941 LONG64 *aTimestamp, BSTR *aFlags) const;
942 HRESULT getGuestPropertyFromVM(IN_BSTR aName, BSTR *aValue,
943 LONG64 *aTimestamp, BSTR *aFlags) const;
944 HRESULT setGuestPropertyToService(IN_BSTR aName, IN_BSTR aValue,
945 IN_BSTR aFlags);
946 HRESULT setGuestPropertyToVM(IN_BSTR aName, IN_BSTR aValue,
947 IN_BSTR aFlags);
948 HRESULT enumerateGuestPropertiesInService
949 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
950 ComSafeArrayOut(BSTR, aValues),
951 ComSafeArrayOut(LONG64, aTimestamps),
952 ComSafeArrayOut(BSTR, aFlags));
953 HRESULT enumerateGuestPropertiesOnVM
954 (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
955 ComSafeArrayOut(BSTR, aValues),
956 ComSafeArrayOut(LONG64, aTimestamps),
957 ComSafeArrayOut(BSTR, aFlags));
958#endif /* VBOX_WITH_GUEST_PROPS */
959
960#ifdef VBOX_WITH_RESOURCE_USAGE_API
961 void getDiskList(MediaList &list);
962 void registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
963
964 pm::CollectorGuest *mCollectorGuest;
965#endif /* VBOX_WITH_RESOURCE_USAGE_API */
966
967 Machine * const mPeer;
968
969 VirtualBox * const mParent;
970
971 Shareable<Data> mData;
972 Shareable<SSData> mSSData;
973
974 Backupable<UserData> mUserData;
975 Backupable<HWData> mHWData;
976 Backupable<MediaData> mMediaData;
977
978 // the following fields need special backup/rollback/commit handling,
979 // so they cannot be a part of HWData
980
981 const ComObjPtr<VRDEServer> mVRDEServer;
982 const ComObjPtr<SerialPort> mSerialPorts[SchemaDefs::SerialPortCount];
983 const ComObjPtr<ParallelPort> mParallelPorts[SchemaDefs::ParallelPortCount];
984 const ComObjPtr<AudioAdapter> mAudioAdapter;
985 const ComObjPtr<USBDeviceFilters> mUSBDeviceFilters;
986 const ComObjPtr<BIOSSettings> mBIOSSettings;
987 const ComObjPtr<BandwidthControl> mBandwidthControl;
988
989 typedef std::vector<ComObjPtr<NetworkAdapter> > NetworkAdapterVector;
990 NetworkAdapterVector mNetworkAdapters;
991
992 typedef std::list<ComObjPtr<StorageController> > StorageControllerList;
993 Backupable<StorageControllerList> mStorageControllers;
994
995 typedef std::list<ComObjPtr<USBController> > USBControllerList;
996 Backupable<USBControllerList> mUSBControllers;
997
998 uint64_t uRegistryNeedsSaving;
999
1000 friend class SessionMachine;
1001 friend class SnapshotMachine;
1002 friend class Appliance;
1003 friend class VirtualBox;
1004
1005 friend class MachineCloneVM;
1006};
1007
1008// SessionMachine class
1009////////////////////////////////////////////////////////////////////////////////
1010
1011/**
1012 * @note Notes on locking objects of this class:
1013 * SessionMachine shares some data with the primary Machine instance (pointed
1014 * to by the |mPeer| member). In order to provide data consistency it also
1015 * shares its lock handle. This means that whenever you lock a SessionMachine
1016 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1017 * instance is also locked in the same lock mode. Keep it in mind.
1018 */
1019class ATL_NO_VTABLE SessionMachine :
1020 public Machine,
1021 VBOX_SCRIPTABLE_IMPL(IInternalMachineControl)
1022{
1023public:
1024 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionMachine, IMachine)
1025
1026 DECLARE_NOT_AGGREGATABLE(SessionMachine)
1027
1028 DECLARE_PROTECT_FINAL_CONSTRUCT()
1029
1030 BEGIN_COM_MAP(SessionMachine)
1031 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1032 COM_INTERFACE_ENTRY(IInternalMachineControl)
1033 END_COM_MAP()
1034
1035 DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
1036
1037 HRESULT FinalConstruct();
1038 void FinalRelease();
1039
1040 struct Uninit
1041 {
1042 enum Reason { Unexpected, Abnormal, Normal };
1043 };
1044
1045 // public initializer/uninitializer for internal purposes only
1046 HRESULT init(Machine *aMachine);
1047 void uninit() { uninit(Uninit::Unexpected); }
1048 void uninit(Uninit::Reason aReason);
1049
1050
1051 // util::Lockable interface
1052 RWLockHandle *lockHandle() const;
1053
1054 // IInternalMachineControl methods
1055 STDMETHOD(SetRemoveSavedStateFile)(BOOL aRemove);
1056 STDMETHOD(UpdateState)(MachineState_T machineState);
1057 STDMETHOD(BeginPowerUp)(IProgress *aProgress);
1058 STDMETHOD(EndPowerUp)(LONG iResult);
1059 STDMETHOD(BeginPoweringDown)(IProgress **aProgress);
1060 STDMETHOD(EndPoweringDown)(LONG aResult, IN_BSTR aErrMsg);
1061 STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
1062 STDMETHOD(CaptureUSBDevice)(IN_BSTR aId);
1063 STDMETHOD(DetachUSBDevice)(IN_BSTR aId, BOOL aDone);
1064 STDMETHOD(AutoCaptureUSBDevices)();
1065 STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
1066 STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
1067 STDMETHOD(BeginSavingState)(IProgress **aProgress, BSTR *aStateFilePath);
1068 STDMETHOD(EndSavingState)(LONG aResult, IN_BSTR aErrMsg);
1069 STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
1070 STDMETHOD(BeginTakingSnapshot)(IConsole *aInitiator,
1071 IN_BSTR aName,
1072 IN_BSTR aDescription,
1073 IProgress *aConsoleProgress,
1074 BOOL fTakingSnapshotOnline,
1075 BSTR *aStateFilePath);
1076 STDMETHOD(EndTakingSnapshot)(BOOL aSuccess);
1077 STDMETHOD(DeleteSnapshot)(IConsole *aInitiator, IN_BSTR aStartId,
1078 IN_BSTR aEndID, BOOL fDeleteAllChildren,
1079 MachineState_T *aMachineState, IProgress **aProgress);
1080 STDMETHOD(FinishOnlineMergeMedium)();
1081 STDMETHOD(RestoreSnapshot)(IConsole *aInitiator,
1082 ISnapshot *aSnapshot,
1083 MachineState_T *aMachineState,
1084 IProgress **aProgress);
1085 STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
1086 ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
1087 STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
1088 LONG64 aTimestamp, IN_BSTR aFlags);
1089 STDMETHOD(LockMedia)();
1090 STDMETHOD(UnlockMedia)();
1091 STDMETHOD(EjectMedium)(IMediumAttachment *aAttachment,
1092 IMediumAttachment **aNewAttachment);
1093 STDMETHOD(ReportVmStatistics)(ULONG aValidStats, ULONG aCpuUser,
1094 ULONG aCpuKernel, ULONG aCpuIdle,
1095 ULONG aMemTotal, ULONG aMemFree,
1096 ULONG aMemBalloon, ULONG aMemShared,
1097 ULONG aMemCache, ULONG aPageTotal,
1098 ULONG aAllocVMM, ULONG aFreeVMM,
1099 ULONG aBalloonedVMM, ULONG aSharedVMM,
1100 ULONG aVmNetRx, ULONG aVmNetTx);
1101
1102 // public methods only for internal purposes
1103
1104 virtual bool isSessionMachine() const
1105 {
1106 return true;
1107 }
1108
1109#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
1110 bool checkForDeath();
1111
1112 void getTokenId(Utf8Str &strTokenId);
1113#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1114 IToken *getToken();
1115#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
1116 // getClientToken must be only used by callers who can guarantee that
1117 // the object cannot be deleted in the mean time, i.e. have a caller/lock.
1118 ClientToken *getClientToken();
1119
1120 HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1121 HRESULT onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1122 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
1123 HRESULT onStorageControllerChange();
1124 HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1125 HRESULT onSerialPortChange(ISerialPort *serialPort);
1126 HRESULT onParallelPortChange(IParallelPort *parallelPort);
1127 HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
1128 HRESULT onVRDEServerChange(BOOL aRestart);
1129 HRESULT onVideoCaptureChange();
1130 HRESULT onUSBControllerChange();
1131 HRESULT onUSBDeviceAttach(IUSBDevice *aDevice,
1132 IVirtualBoxErrorInfo *aError,
1133 ULONG aMaskedIfs);
1134 HRESULT onUSBDeviceDetach(IN_BSTR aId,
1135 IVirtualBoxErrorInfo *aError);
1136 HRESULT onSharedFolderChange();
1137 HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
1138 HRESULT onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode);
1139 HRESULT onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1140 HRESULT onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1141 HRESULT onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1142
1143 bool hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1144
1145 HRESULT lockMedia();
1146 void unlockMedia();
1147
1148private:
1149
1150 struct ConsoleTaskData
1151 {
1152 ConsoleTaskData()
1153 : mLastState(MachineState_Null), mDeleteSnapshotInfo(NULL)
1154 { }
1155
1156 MachineState_T mLastState;
1157 ComObjPtr<Progress> mProgress;
1158
1159 // used when taking snapshot
1160 ComObjPtr<Snapshot> mSnapshot;
1161
1162 // used when deleting online snapshot
1163 void *mDeleteSnapshotInfo;
1164
1165 // used when saving state (either as part of a snapshot or separate)
1166 Utf8Str strStateFilePath;
1167 };
1168
1169 struct SnapshotTask;
1170 struct DeleteSnapshotTask;
1171 struct RestoreSnapshotTask;
1172
1173 friend struct DeleteSnapshotTask;
1174 friend struct RestoreSnapshotTask;
1175
1176 HRESULT endSavingState(HRESULT aRC, const Utf8Str &aErrMsg);
1177 void releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1178
1179 void deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1180 void restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1181
1182 HRESULT prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1183 const Guid &machineId,
1184 const Guid &snapshotId,
1185 bool fOnlineMergePossible,
1186 MediumLockList *aVMMALockList,
1187 ComObjPtr<Medium> &aSource,
1188 ComObjPtr<Medium> &aTarget,
1189 bool &fMergeForward,
1190 ComObjPtr<Medium> &pParentForTarget,
1191 MediumLockList * &aChildrenToReparent,
1192 bool &fNeedOnlineMerge,
1193 MediumLockList * &aMediumLockList,
1194 ComPtr<IToken> &aHDLockToken);
1195 void cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1196 const ComObjPtr<Medium> &aSource,
1197 MediumLockList *aChildrenToReparent,
1198 bool fNeedsOnlineMerge,
1199 MediumLockList *aMediumLockList,
1200 const ComPtr<IToken> &aHDLockToken,
1201 const Guid &aMediumId,
1202 const Guid &aSnapshotId);
1203 HRESULT onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1204 const ComObjPtr<Medium> &aSource,
1205 const ComObjPtr<Medium> &aTarget,
1206 bool fMergeForward,
1207 const ComObjPtr<Medium> &pParentForTarget,
1208 MediumLockList *aChildrenToReparent,
1209 MediumLockList *aMediumLockList,
1210 ComObjPtr<Progress> &aProgress,
1211 bool *pfNeedsMachineSaveSettings);
1212
1213 HRESULT setMachineState(MachineState_T aMachineState);
1214 HRESULT updateMachineStateOnClient();
1215
1216 HRESULT mRemoveSavedState;
1217
1218 ConsoleTaskData mConsoleTaskData;
1219
1220 /** client token for this machine */
1221 ClientToken *mClientToken;
1222
1223 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
1224};
1225
1226// SnapshotMachine class
1227////////////////////////////////////////////////////////////////////////////////
1228
1229/**
1230 * @note Notes on locking objects of this class:
1231 * SnapshotMachine shares some data with the primary Machine instance (pointed
1232 * to by the |mPeer| member). In order to provide data consistency it also
1233 * shares its lock handle. This means that whenever you lock a SessionMachine
1234 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1235 * instance is also locked in the same lock mode. Keep it in mind.
1236 */
1237class ATL_NO_VTABLE SnapshotMachine :
1238 public Machine
1239{
1240public:
1241 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1242
1243 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1244
1245 DECLARE_PROTECT_FINAL_CONSTRUCT()
1246
1247 BEGIN_COM_MAP(SnapshotMachine)
1248 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1249 END_COM_MAP()
1250
1251 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1252
1253 HRESULT FinalConstruct();
1254 void FinalRelease();
1255
1256 // public initializer/uninitializer for internal purposes only
1257 HRESULT init(SessionMachine *aSessionMachine,
1258 IN_GUID aSnapshotId,
1259 const Utf8Str &aStateFilePath);
1260 HRESULT initFromSettings(Machine *aMachine,
1261 const settings::Hardware &hardware,
1262 const settings::Debugging *pDbg,
1263 const settings::Autostart *pAutostart,
1264 const settings::Storage &storage,
1265 IN_GUID aSnapshotId,
1266 const Utf8Str &aStateFilePath);
1267 void uninit();
1268
1269 // util::Lockable interface
1270 RWLockHandle *lockHandle() const;
1271
1272 // public methods only for internal purposes
1273
1274 virtual bool isSnapshotMachine() const
1275 {
1276 return true;
1277 }
1278
1279 HRESULT onSnapshotChange(Snapshot *aSnapshot);
1280
1281 // unsafe inline public methods for internal purposes only (ensure there is
1282 // a caller and a read lock before calling them!)
1283
1284 const Guid& getSnapshotId() const { return mSnapshotId; }
1285
1286private:
1287
1288 Guid mSnapshotId;
1289 /** This field replaces mPeer for SessionMachine instances, as having
1290 * a peer reference is plain meaningless and causes many subtle problems
1291 * with saving settings and the like. */
1292 Machine * const mMachine;
1293
1294 friend class Snapshot;
1295};
1296
1297// third party methods that depend on SnapshotMachine definition
1298
1299inline const Guid &Machine::getSnapshotId() const
1300{
1301 return (isSnapshotMachine())
1302 ? static_cast<const SnapshotMachine*>(this)->getSnapshotId()
1303 : Guid::Empty;
1304}
1305
1306
1307#endif // ____H_MACHINEIMPL
1308/* 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