VirtualBox

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

Last change on this file since 36058 was 36058, checked in by vboxsync, 14 years ago

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

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