VirtualBox

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

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

Main/VirtualBox+Machine+Session: separate out the client death detection functionality into separate objects
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 55.5 KB
Line 
1/* $Id: MachineImpl.h 47561 2013-08-06 15:18:17Z 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, USBControllerType_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 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
786 ComPtr<IInternalSessionControl> *aControl = NULL,
787 bool aAllowClosing = false);
788 bool isSessionSpawning();
789
790 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
791 ComPtr<IInternalSessionControl> *aControl = NULL)
792 { return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
793
794 bool checkForSpawnFailure();
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 // public initializer/uninitializer for internal purposes only
1041 HRESULT init(Machine *aMachine);
1042 void uninit() { uninit(Uninit::Unexpected); }
1043
1044 // util::Lockable interface
1045 RWLockHandle *lockHandle() const;
1046
1047 // IInternalMachineControl methods
1048 STDMETHOD(SetRemoveSavedStateFile)(BOOL aRemove);
1049 STDMETHOD(UpdateState)(MachineState_T machineState);
1050 STDMETHOD(BeginPowerUp)(IProgress *aProgress);
1051 STDMETHOD(EndPowerUp)(LONG iResult);
1052 STDMETHOD(BeginPoweringDown)(IProgress **aProgress);
1053 STDMETHOD(EndPoweringDown)(LONG aResult, IN_BSTR aErrMsg);
1054 STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
1055 STDMETHOD(CaptureUSBDevice)(IN_BSTR aId);
1056 STDMETHOD(DetachUSBDevice)(IN_BSTR aId, BOOL aDone);
1057 STDMETHOD(AutoCaptureUSBDevices)();
1058 STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
1059 STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
1060 STDMETHOD(BeginSavingState)(IProgress **aProgress, BSTR *aStateFilePath);
1061 STDMETHOD(EndSavingState)(LONG aResult, IN_BSTR aErrMsg);
1062 STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
1063 STDMETHOD(BeginTakingSnapshot)(IConsole *aInitiator,
1064 IN_BSTR aName,
1065 IN_BSTR aDescription,
1066 IProgress *aConsoleProgress,
1067 BOOL fTakingSnapshotOnline,
1068 BSTR *aStateFilePath);
1069 STDMETHOD(EndTakingSnapshot)(BOOL aSuccess);
1070 STDMETHOD(DeleteSnapshot)(IConsole *aInitiator, IN_BSTR aStartId,
1071 IN_BSTR aEndID, BOOL fDeleteAllChildren,
1072 MachineState_T *aMachineState, IProgress **aProgress);
1073 STDMETHOD(FinishOnlineMergeMedium)(IMediumAttachment *aMediumAttachment,
1074 IMedium *aSource, IMedium *aTarget,
1075 BOOL fMergeForward,
1076 IMedium *pParentForTarget,
1077 ComSafeArrayIn(IMedium *, aChildrenToReparent));
1078 STDMETHOD(RestoreSnapshot)(IConsole *aInitiator,
1079 ISnapshot *aSnapshot,
1080 MachineState_T *aMachineState,
1081 IProgress **aProgress);
1082 STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
1083 ComSafeArrayOut(LONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
1084 STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
1085 LONG64 aTimestamp, IN_BSTR aFlags);
1086 STDMETHOD(LockMedia)();
1087 STDMETHOD(UnlockMedia)();
1088 STDMETHOD(EjectMedium)(IMediumAttachment *aAttachment,
1089 IMediumAttachment **aNewAttachment);
1090 STDMETHOD(ReportVmStatistics)(ULONG aValidStats, ULONG aCpuUser,
1091 ULONG aCpuKernel, ULONG aCpuIdle,
1092 ULONG aMemTotal, ULONG aMemFree,
1093 ULONG aMemBalloon, ULONG aMemShared,
1094 ULONG aMemCache, ULONG aPageTotal,
1095 ULONG aAllocVMM, ULONG aFreeVMM,
1096 ULONG aBalloonedVMM, ULONG aSharedVMM,
1097 ULONG aVmNetRx, ULONG aVmNetTx);
1098
1099 // public methods only for internal purposes
1100
1101 virtual bool isSessionMachine() const
1102 {
1103 return true;
1104 }
1105
1106 bool checkForDeath();
1107
1108 void getTokenId(Utf8Str &strTokenId);
1109 // getClientToken must be only used by callers who can guarantee that
1110 // the object cannot be deleted in the mean time, i.e. have a caller/lock.
1111 ClientToken *getClientToken();
1112
1113 HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
1114 HRESULT onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
1115 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort);
1116 HRESULT onStorageControllerChange();
1117 HRESULT onMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce);
1118 HRESULT onSerialPortChange(ISerialPort *serialPort);
1119 HRESULT onParallelPortChange(IParallelPort *parallelPort);
1120 HRESULT onCPUChange(ULONG aCPU, BOOL aRemove);
1121 HRESULT onVRDEServerChange(BOOL aRestart);
1122 HRESULT onVideoCaptureChange();
1123 HRESULT onUSBControllerChange();
1124 HRESULT onUSBDeviceAttach(IUSBDevice *aDevice,
1125 IVirtualBoxErrorInfo *aError,
1126 ULONG aMaskedIfs);
1127 HRESULT onUSBDeviceDetach(IN_BSTR aId,
1128 IVirtualBoxErrorInfo *aError);
1129 HRESULT onSharedFolderChange();
1130 HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode);
1131 HRESULT onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode);
1132 HRESULT onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup);
1133 HRESULT onStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent);
1134 HRESULT onCPUExecutionCapChange(ULONG aCpuExecutionCap);
1135
1136 bool hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1137
1138 HRESULT lockMedia();
1139 void unlockMedia();
1140
1141private:
1142
1143 struct ConsoleTaskData
1144 {
1145 ConsoleTaskData()
1146 : mLastState(MachineState_Null)
1147 { }
1148
1149 MachineState_T mLastState;
1150 ComObjPtr<Progress> mProgress;
1151
1152 // used when taking snapshot
1153 ComObjPtr<Snapshot> mSnapshot;
1154
1155 // used when saving state (either as part of a snapshot or separate)
1156 Utf8Str strStateFilePath;
1157 };
1158
1159 struct Uninit
1160 {
1161 enum Reason { Unexpected, Abnormal, Normal };
1162 };
1163
1164 struct SnapshotTask;
1165 struct DeleteSnapshotTask;
1166 struct RestoreSnapshotTask;
1167
1168 friend struct DeleteSnapshotTask;
1169 friend struct RestoreSnapshotTask;
1170
1171 void uninit(Uninit::Reason aReason);
1172
1173 HRESULT endSavingState(HRESULT aRC, const Utf8Str &aErrMsg);
1174 void releaseSavedStateFile(const Utf8Str &strSavedStateFile, Snapshot *pSnapshotToIgnore);
1175
1176 void deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1177 void restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1178
1179 HRESULT prepareDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1180 const Guid &machineId,
1181 const Guid &snapshotId,
1182 bool fOnlineMergePossible,
1183 MediumLockList *aVMMALockList,
1184 ComObjPtr<Medium> &aSource,
1185 ComObjPtr<Medium> &aTarget,
1186 bool &fMergeForward,
1187 ComObjPtr<Medium> &pParentForTarget,
1188 MediaList &aChildrenToReparent,
1189 bool &fNeedOnlineMerge,
1190 MediumLockList * &aMediumLockList);
1191 void cancelDeleteSnapshotMedium(const ComObjPtr<Medium> &aHD,
1192 const ComObjPtr<Medium> &aSource,
1193 const MediaList &aChildrenToReparent,
1194 bool fNeedsOnlineMerge,
1195 MediumLockList *aMediumLockList,
1196 const Guid &aMediumId,
1197 const Guid &aSnapshotId);
1198 HRESULT onlineMergeMedium(const ComObjPtr<MediumAttachment> &aMediumAttachment,
1199 const ComObjPtr<Medium> &aSource,
1200 const ComObjPtr<Medium> &aTarget,
1201 bool fMergeForward,
1202 const ComObjPtr<Medium> &pParentForTarget,
1203 const MediaList &aChildrenToReparent,
1204 MediumLockList *aMediumLockList,
1205 ComObjPtr<Progress> &aProgress,
1206 bool *pfNeedsMachineSaveSettings);
1207
1208 HRESULT setMachineState(MachineState_T aMachineState);
1209 HRESULT updateMachineStateOnClient();
1210
1211 HRESULT mRemoveSavedState;
1212
1213 ConsoleTaskData mConsoleTaskData;
1214
1215 /** client token for this machine */
1216 ClientToken *mClientToken;
1217
1218 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
1219};
1220
1221// SnapshotMachine class
1222////////////////////////////////////////////////////////////////////////////////
1223
1224/**
1225 * @note Notes on locking objects of this class:
1226 * SnapshotMachine shares some data with the primary Machine instance (pointed
1227 * to by the |mPeer| member). In order to provide data consistency it also
1228 * shares its lock handle. This means that whenever you lock a SessionMachine
1229 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1230 * instance is also locked in the same lock mode. Keep it in mind.
1231 */
1232class ATL_NO_VTABLE SnapshotMachine :
1233 public Machine
1234{
1235public:
1236 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotMachine, IMachine)
1237
1238 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1239
1240 DECLARE_PROTECT_FINAL_CONSTRUCT()
1241
1242 BEGIN_COM_MAP(SnapshotMachine)
1243 VBOX_DEFAULT_INTERFACE_ENTRIES(IMachine)
1244 END_COM_MAP()
1245
1246 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1247
1248 HRESULT FinalConstruct();
1249 void FinalRelease();
1250
1251 // public initializer/uninitializer for internal purposes only
1252 HRESULT init(SessionMachine *aSessionMachine,
1253 IN_GUID aSnapshotId,
1254 const Utf8Str &aStateFilePath);
1255 HRESULT initFromSettings(Machine *aMachine,
1256 const settings::Hardware &hardware,
1257 const settings::Debugging *pDbg,
1258 const settings::Autostart *pAutostart,
1259 const settings::Storage &storage,
1260 IN_GUID aSnapshotId,
1261 const Utf8Str &aStateFilePath);
1262 void uninit();
1263
1264 // util::Lockable interface
1265 RWLockHandle *lockHandle() const;
1266
1267 // public methods only for internal purposes
1268
1269 virtual bool isSnapshotMachine() const
1270 {
1271 return true;
1272 }
1273
1274 HRESULT onSnapshotChange(Snapshot *aSnapshot);
1275
1276 // unsafe inline public methods for internal purposes only (ensure there is
1277 // a caller and a read lock before calling them!)
1278
1279 const Guid& getSnapshotId() const { return mSnapshotId; }
1280
1281private:
1282
1283 Guid mSnapshotId;
1284 /** This field replaces mPeer for SessionMachine instances, as having
1285 * a peer reference is plain meaningless and causes many subtle problems
1286 * with saving settings and the like. */
1287 Machine * const mMachine;
1288
1289 friend class Snapshot;
1290};
1291
1292// third party methods that depend on SnapshotMachine definition
1293
1294inline const Guid &Machine::getSnapshotId() const
1295{
1296 return (isSnapshotMachine())
1297 ? static_cast<const SnapshotMachine*>(this)->getSnapshotId()
1298 : Guid::Empty;
1299}
1300
1301
1302#endif // ____H_MACHINEIMPL
1303/* 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