VirtualBox

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

Last change on this file since 40532 was 40432, checked in by vboxsync, 13 years ago

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