VirtualBox

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

Last change on this file since 23928 was 23928, checked in by vboxsync, 15 years ago

API: make necessary adjustments to support DVD passthrough again, together with the necessary client code changes. Unfortunately it is not possible to define the API in the ideal way due to how settings are handled in MachineImpl.cpp.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 43.5 KB
Line 
1/* $Id: MachineImpl.h 23928 2009-10-21 10:17:08Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class declaration
6 */
7
8/*
9 * Copyright (C) 2006-2009 Sun Microsystems, Inc.
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20 * Clara, CA 95054 USA or visit http://www.sun.com if you need
21 * additional information or have any questions.
22 */
23
24#ifndef ____H_MACHINEIMPL
25#define ____H_MACHINEIMPL
26
27#include "VirtualBoxBase.h"
28#include "ProgressImpl.h"
29#include "SnapshotImpl.h"
30#include "VRDPServerImpl.h"
31#include "MediumAttachmentImpl.h"
32#include "NetworkAdapterImpl.h"
33#include "AudioAdapterImpl.h"
34#include "SerialPortImpl.h"
35#include "ParallelPortImpl.h"
36#include "BIOSSettingsImpl.h"
37#include "StorageControllerImpl.h" // required for MachineImpl.h to compile on Windows
38#ifdef VBOX_WITH_RESOURCE_USAGE_API
39#include "PerformanceImpl.h"
40#endif /* VBOX_WITH_RESOURCE_USAGE_API */
41
42// generated header
43#include "SchemaDefs.h"
44
45#include <VBox/types.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 VirtualBox;
60class Progress;
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 VirtualBoxBaseWithChildrenNEXT,
88 public VirtualBoxSupportErrorInfoImpl<Machine, IMachine>,
89 public VirtualBoxSupportTranslation<Machine>,
90 VBOX_SCRIPTABLE_IMPL(IMachine)
91{
92 Q_OBJECT
93
94public:
95
96 enum InstanceType { IsMachine, IsSessionMachine, IsSnapshotMachine };
97
98 enum InitMode { Init_New, Init_Import, Init_Registered };
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 openSession() */
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 /** openRemoteSession() and OnSessionEnd() progress indicator */
131 ComObjPtr<Progress> mProgress;
132
133 /**
134 * PID of the session object that must be passed to openSession() to
135 * finalize the openRemoteSession() request (i.e., PID of the
136 * process created by openRemoteSession())
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 /**
150 * Successfully locked media list. The 2nd value in the pair is true
151 * if the medium is locked for writing and false if locked for
152 * reading.
153 */
154 typedef std::list<std::pair<ComPtr<IMedium>, bool > > LockedMedia;
155 LockedMedia mLockedMedia;
156 };
157
158 Data();
159 ~Data();
160
161 const Guid mUuid;
162 BOOL mRegistered;
163 InitMode mInitMode;
164
165 /** Flag indicating that the config file is read-only. */
166 BOOL mConfigFileReadonly;
167 Utf8Str m_strConfigFile;
168 Utf8Str m_strConfigFileFull;
169
170 // machine settings XML file
171 settings::MachineConfigFile *m_pMachineConfigFile;
172
173 BOOL mAccessible;
174 com::ErrorInfo mAccessError;
175
176 MachineState_T mMachineState;
177 RTTIMESPEC mLastStateChange;
178
179 /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
180 uint32_t mMachineStateDeps;
181 RTSEMEVENTMULTI mMachineStateDepsSem;
182 uint32_t mMachineStateChangePending;
183
184 BOOL mCurrentStateModified;
185
186 RTFILE mHandleCfgFile;
187
188 Session mSession;
189
190 ComObjPtr<Snapshot> mFirstSnapshot;
191 ComObjPtr<Snapshot> mCurrentSnapshot;
192
193 // protectes the snapshots tree of this machine
194 RWLockHandle mSnapshotsTreeLockHandle;
195 };
196
197 /**
198 * Saved state data.
199 *
200 * It's actually only the state file path string, but it needs to be
201 * separate from Data, because Machine and SessionMachine instances
202 * share it, while SnapshotMachine does not.
203 *
204 * The data variable is |mSSData|.
205 */
206 struct SSData
207 {
208 Bstr mStateFilePath;
209 };
210
211 /**
212 * User changeable machine data.
213 *
214 * This data is common for all machine snapshots, i.e. it is shared
215 * by all SnapshotMachine instances associated with the given machine
216 * using the util::Backupable template through the |mUserData| variable.
217 *
218 * SessionMachine instances can alter this data and discard changes.
219 *
220 * @note There is no need to lock anything inside init() or uninit()
221 * methods, because they are always serialized (see AutoCaller).
222 */
223 struct UserData
224 {
225 UserData();
226 ~UserData();
227
228 bool operator==(const UserData &that) const
229 {
230 return this == &that
231 || ( mName == that.mName
232 && mNameSync == that.mNameSync
233 && mDescription == that.mDescription
234 && mOSTypeId == that.mOSTypeId
235 && mSnapshotFolderFull == that.mSnapshotFolderFull
236 && mTeleporterEnabled == that.mTeleporterEnabled
237 && mTeleporterPort == that.mTeleporterPort
238 && mTeleporterAddress == that.mTeleporterAddress
239 && mTeleporterPassword == that.mTeleporterPassword);
240 }
241
242 Bstr mName;
243 BOOL mNameSync;
244 Bstr mDescription;
245 Bstr mOSTypeId;
246 Bstr mSnapshotFolder;
247 Bstr mSnapshotFolderFull;
248 BOOL mTeleporterEnabled;
249 ULONG mTeleporterPort;
250 Bstr mTeleporterAddress;
251 Bstr mTeleporterPassword;
252 };
253
254 /**
255 * Hardware data.
256 *
257 * This data is unique for a machine and for every machine snapshot.
258 * Stored using the util::Backupable template in the |mHWData| variable.
259 *
260 * SessionMachine instances can alter this data and discard changes.
261 */
262 struct HWData
263 {
264 /**
265 * Data structure to hold information about a guest property.
266 */
267 struct GuestProperty {
268 /** Property name */
269 Utf8Str strName;
270 /** Property value */
271 Utf8Str strValue;
272 /** Property timestamp */
273 ULONG64 mTimestamp;
274 /** Property flags */
275 ULONG mFlags;
276 };
277
278 HWData();
279 ~HWData();
280
281 bool operator==(const HWData &that) const;
282
283 Bstr mHWVersion;
284 ULONG mMemorySize;
285 ULONG mMemoryBalloonSize;
286 ULONG mStatisticsUpdateInterval;
287 ULONG mVRAMSize;
288 ULONG mMonitorCount;
289 BOOL mHWVirtExEnabled;
290 BOOL mHWVirtExExclusive;
291 BOOL mHWVirtExNestedPagingEnabled;
292 BOOL mHWVirtExVPIDEnabled;
293 BOOL mAccelerate2DVideoEnabled;
294 BOOL mPAEEnabled;
295 BOOL mSyntheticCpu;
296 ULONG mCPUCount;
297 BOOL mAccelerate3DEnabled;
298
299 DeviceType_T mBootOrder[SchemaDefs::MaxBootPosition];
300
301 typedef std::list< ComObjPtr<SharedFolder> > SharedFolderList;
302 SharedFolderList mSharedFolders;
303
304 ClipboardMode_T mClipboardMode;
305
306 typedef std::list<GuestProperty> GuestPropertyList;
307 GuestPropertyList mGuestProperties;
308 BOOL mPropertyServiceActive;
309 Bstr mGuestPropertyNotificationPatterns;
310
311 FirmwareType_T mFirmwareType;
312 };
313
314 /**
315 * Hard disk and other media data.
316 *
317 * The usage policy is the same as for HWData, but a separate structure
318 * is necessary because hard disk data requires different procedures when
319 * taking or discarding snapshots, etc.
320 *
321 * The data variable is |mMediaData|.
322 */
323 struct MediaData
324 {
325 MediaData();
326 ~MediaData();
327
328 bool operator==(const MediaData &that) const;
329
330 typedef std::list< ComObjPtr<MediumAttachment> > AttachmentList;
331 AttachmentList mAttachments;
332 };
333
334 enum StateDependency
335 {
336 AnyStateDep = 0, MutableStateDep, MutableOrSavedStateDep
337 };
338
339 /**
340 * Helper class that safely manages the machine state dependency by
341 * calling Machine::addStateDependency() on construction and
342 * Machine::releaseStateDependency() on destruction. Intended for Machine
343 * children. The usage pattern is:
344 *
345 * @code
346 * AutoCaller autoCaller(this);
347 * CheckComRCReturnRC(autoCaller.rc());
348 *
349 * Machine::AutoStateDependency<MutableStateDep> adep(mParent);
350 * CheckComRCReturnRC(stateDep.rc());
351 * ...
352 * // code that depends on the particular machine state
353 * ...
354 * @endcode
355 *
356 * Note that it is more convenient to use the following individual
357 * shortcut classes instead of using this template directly:
358 * AutoAnyStateDependency, AutoMutableStateDependency and
359 * AutoMutableOrSavedStateDependency. The usage pattern is exactly the
360 * same as above except that there is no need to specify the template
361 * argument because it is already done by the shortcut class.
362 *
363 * @param taDepType Dependecy type to manage.
364 */
365 template <StateDependency taDepType = AnyStateDep>
366 class AutoStateDependency
367 {
368 public:
369
370 AutoStateDependency(Machine *aThat)
371 : mThat(aThat), mRC(S_OK)
372 , mMachineState(MachineState_Null)
373 , mRegistered(FALSE)
374 {
375 Assert(aThat);
376 mRC = aThat->addStateDependency(taDepType, &mMachineState,
377 &mRegistered);
378 }
379 ~AutoStateDependency()
380 {
381 if (SUCCEEDED(mRC))
382 mThat->releaseStateDependency();
383 }
384
385 /** Decreases the number of dependencies before the instance is
386 * destroyed. Note that will reset #rc() to E_FAIL. */
387 void release()
388 {
389 AssertReturnVoid(SUCCEEDED(mRC));
390 mThat->releaseStateDependency();
391 mRC = E_FAIL;
392 }
393
394 /** Restores the number of callers after by #release(). #rc() will be
395 * reset to the result of calling addStateDependency() and must be
396 * rechecked to ensure the operation succeeded. */
397 void add()
398 {
399 AssertReturnVoid(!SUCCEEDED(mRC));
400 mRC = mThat->addStateDependency(taDepType, &mMachineState,
401 &mRegistered);
402 }
403
404 /** Returns the result of Machine::addStateDependency(). */
405 HRESULT rc() const { return mRC; }
406
407 /** Shortcut to SUCCEEDED(rc()). */
408 bool isOk() const { return SUCCEEDED(mRC); }
409
410 /** Returns the machine state value as returned by
411 * Machine::addStateDependency(). */
412 MachineState_T machineState() const { return mMachineState; }
413
414 /** Returns the machine state value as returned by
415 * Machine::addStateDependency(). */
416 BOOL machineRegistered() const { return mRegistered; }
417
418 protected:
419
420 Machine *mThat;
421 HRESULT mRC;
422 MachineState_T mMachineState;
423 BOOL mRegistered;
424
425 private:
426
427 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoStateDependency)
428 DECLARE_CLS_NEW_DELETE_NOOP(AutoStateDependency)
429 };
430
431 /**
432 * Shortcut to AutoStateDependency<AnyStateDep>.
433 * See AutoStateDependency to get the usage pattern.
434 *
435 * Accepts any machine state and guarantees the state won't change before
436 * this object is destroyed. If the machine state cannot be protected (as
437 * a result of the state change currently in progress), this instance's
438 * #rc() method will indicate a failure, and the caller is not allowed to
439 * rely on any particular machine state and should return the failed
440 * result code to the upper level.
441 */
442 typedef AutoStateDependency<AnyStateDep> AutoAnyStateDependency;
443
444 /**
445 * Shortcut to AutoStateDependency<MutableStateDep>.
446 * See AutoStateDependency to get the usage pattern.
447 *
448 * Succeeds only if the machine state is in one of the mutable states, and
449 * guarantees the given mutable state won't change before this object is
450 * destroyed. If the machine is not mutable, this instance's #rc() method
451 * will indicate a failure, and the caller is not allowed to rely on any
452 * particular machine state and should return the failed result code to
453 * the upper level.
454 *
455 * Intended to be used within all setter methods of IMachine
456 * children objects (DVDDrive, NetworkAdapter, AudioAdapter, etc.) to
457 * provide data protection and consistency.
458 */
459 typedef AutoStateDependency<MutableStateDep> AutoMutableStateDependency;
460
461 /**
462 * Shortcut to AutoStateDependency<MutableOrSavedStateDep>.
463 * See AutoStateDependency to get the usage pattern.
464 *
465 * Succeeds only if the machine state is in one of the mutable states, or
466 * if the machine is in the Saved state, and guarantees the given mutable
467 * state won't change before this object is destroyed. If the machine is
468 * not mutable, this instance's #rc() method will indicate a failure, and
469 * the caller is not allowed to rely on any particular machine state and
470 * should return the failed result code to the upper level.
471 *
472 * Intended to be used within setter methods of IMachine
473 * children objects that may also operate on Saved machines.
474 */
475 typedef AutoStateDependency<MutableOrSavedStateDep> AutoMutableOrSavedStateDependency;
476
477
478 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine)
479
480 DECLARE_NOT_AGGREGATABLE(Machine)
481
482 DECLARE_PROTECT_FINAL_CONSTRUCT()
483
484 BEGIN_COM_MAP(Machine)
485 COM_INTERFACE_ENTRY(ISupportErrorInfo)
486 COM_INTERFACE_ENTRY(IMachine)
487 COM_INTERFACE_ENTRY(IDispatch)
488 END_COM_MAP()
489
490 DECLARE_EMPTY_CTOR_DTOR(Machine)
491
492 HRESULT FinalConstruct();
493 void FinalRelease();
494
495 // public initializer/uninitializer for internal purposes only
496 HRESULT init(VirtualBox *aParent,
497 const Utf8Str &strConfigFile,
498 InitMode aMode,
499 CBSTR aName = NULL,
500 GuestOSType *aOsType = NULL,
501 BOOL aNameSync = TRUE,
502 const Guid *aId = NULL);
503 void uninit();
504
505protected:
506 HRESULT initDataAndChildObjects();
507 void uninitDataAndChildObjects();
508
509public:
510 // IMachine properties
511 STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
512 STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible);
513 STDMETHOD(COMGETTER(AccessError))(IVirtualBoxErrorInfo **aAccessError);
514 STDMETHOD(COMGETTER(Name))(BSTR *aName);
515 STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
516 STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
517 STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
518 STDMETHOD(COMGETTER(Id))(BSTR *aId);
519 STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId);
520 STDMETHOD(COMSETTER(OSTypeId))(IN_BSTR aOSTypeId);
521 STDMETHOD(COMGETTER(HardwareVersion))(BSTR *aVersion);
522 STDMETHOD(COMSETTER(HardwareVersion))(IN_BSTR aVersion);
523 STDMETHOD(COMGETTER(MemorySize))(ULONG *memorySize);
524 STDMETHOD(COMSETTER(MemorySize))(ULONG memorySize);
525 STDMETHOD(COMGETTER(CPUCount))(ULONG *cpuCount);
526 STDMETHOD(COMSETTER(CPUCount))(ULONG cpuCount);
527 STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
528 STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
529 STDMETHOD(COMGETTER(StatisticsUpdateInterval))(ULONG *statisticsUpdateInterval);
530 STDMETHOD(COMSETTER(StatisticsUpdateInterval))(ULONG statisticsUpdateInterval);
531 STDMETHOD(COMGETTER(VRAMSize))(ULONG *memorySize);
532 STDMETHOD(COMSETTER(VRAMSize))(ULONG memorySize);
533 STDMETHOD(COMGETTER(MonitorCount))(ULONG *monitorCount);
534 STDMETHOD(COMSETTER(MonitorCount))(ULONG monitorCount);
535 STDMETHOD(COMGETTER(Accelerate3DEnabled))(BOOL *enabled);
536 STDMETHOD(COMSETTER(Accelerate3DEnabled))(BOOL enabled);
537 STDMETHOD(COMGETTER(Accelerate2DVideoEnabled))(BOOL *enabled);
538 STDMETHOD(COMSETTER(Accelerate2DVideoEnabled))(BOOL enabled);
539 STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **biosSettings);
540 STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
541 STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSavedStateFolder);
542 STDMETHOD(COMGETTER(MediumAttachments))(ComSafeArrayOut(IMediumAttachment *, aAttachments));
543 STDMETHOD(COMGETTER(VRDPServer))(IVRDPServer **vrdpServer);
544 STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
545 STDMETHOD(COMGETTER(USBController))(IUSBController * *aUSBController);
546 STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aFilePath);
547 STDMETHOD(COMGETTER(SettingsModified))(BOOL *aModified);
548 STDMETHOD(COMGETTER(SessionState))(SessionState_T *aSessionState);
549 STDMETHOD(COMGETTER(SessionType))(BSTR *aSessionType);
550 STDMETHOD(COMGETTER(SessionPid))(ULONG *aSessionPid);
551 STDMETHOD(COMGETTER(State))(MachineState_T *machineState);
552 STDMETHOD(COMGETTER(LastStateChange))(LONG64 *aLastStateChange);
553 STDMETHOD(COMGETTER(StateFilePath))(BSTR *aStateFilePath);
554 STDMETHOD(COMGETTER(LogFolder))(BSTR *aLogFolder);
555 STDMETHOD(COMGETTER(CurrentSnapshot))(ISnapshot **aCurrentSnapshot);
556 STDMETHOD(COMGETTER(SnapshotCount))(ULONG *aSnapshotCount);
557 STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
558 STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
559 STDMETHOD(COMGETTER(ClipboardMode))(ClipboardMode_T *aClipboardMode);
560 STDMETHOD(COMSETTER(ClipboardMode))(ClipboardMode_T aClipboardMode);
561 STDMETHOD(COMGETTER(GuestPropertyNotificationPatterns))(BSTR *aPattern);
562 STDMETHOD(COMSETTER(GuestPropertyNotificationPatterns))(IN_BSTR aPattern);
563 STDMETHOD(COMGETTER(StorageControllers))(ComSafeArrayOut(IStorageController *, aStorageControllers));
564 STDMETHOD(COMGETTER(TeleporterEnabled))(BOOL *aEnabled);
565 STDMETHOD(COMSETTER(TeleporterEnabled))(BOOL aEnabled);
566 STDMETHOD(COMGETTER(TeleporterPort))(ULONG *aPort);
567 STDMETHOD(COMSETTER(TeleporterPort))(ULONG aPort);
568 STDMETHOD(COMGETTER(TeleporterAddress))(BSTR *aAddress);
569 STDMETHOD(COMSETTER(TeleporterAddress))(IN_BSTR aAddress);
570 STDMETHOD(COMGETTER(TeleporterPassword))(BSTR *aPassword);
571 STDMETHOD(COMSETTER(TeleporterPassword))(IN_BSTR aPassword);
572
573 // IMachine methods
574 STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
575 STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
576 STDMETHOD(AttachDevice)(IN_BSTR aControllerName, LONG aControllerPort,
577 LONG aDevice, DeviceType_T aType, IN_BSTR aId);
578 STDMETHOD(DetachDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice);
579 STDMETHOD(PassthroughDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aPassthrough);
580 STDMETHOD(MountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
581 LONG aDevice, IN_BSTR aId);
582 STDMETHOD(GetMedium)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice,
583 IMedium **aMedium);
584 STDMETHOD(GetSerialPort)(ULONG slot, ISerialPort **port);
585 STDMETHOD(GetParallelPort)(ULONG slot, IParallelPort **port);
586 STDMETHOD(GetNetworkAdapter)(ULONG slot, INetworkAdapter **adapter);
587 STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
588 STDMETHOD(GetExtraData)(IN_BSTR aKey, BSTR *aValue);
589 STDMETHOD(SetExtraData)(IN_BSTR aKey, IN_BSTR aValue);
590 STDMETHOD(GetCpuProperty)(CpuPropertyType_T property, BOOL *aVal);
591 STDMETHOD(SetCpuProperty)(CpuPropertyType_T property, BOOL aVal);
592 STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL *aVal);
593 STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL aVal);
594 STDMETHOD(SaveSettings)();
595 STDMETHOD(DiscardSettings)();
596 STDMETHOD(DeleteSettings)();
597 STDMETHOD(Export)(IAppliance *aAppliance, IVirtualSystemDescription **aDescription);
598 STDMETHOD(GetSnapshot)(IN_BSTR aId, ISnapshot **aSnapshot);
599 STDMETHOD(FindSnapshot)(IN_BSTR aName, ISnapshot **aSnapshot);
600 STDMETHOD(SetCurrentSnapshot)(IN_BSTR aId);
601 STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable);
602 STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
603 STDMETHOD(CanShowConsoleWindow)(BOOL *aCanShow);
604 STDMETHOD(ShowConsoleWindow)(ULONG64 *aWinId);
605 STDMETHOD(GetGuestProperty)(IN_BSTR aName, BSTR *aValue, ULONG64 *aTimestamp, BSTR *aFlags);
606 STDMETHOD(GetGuestPropertyValue)(IN_BSTR aName, BSTR *aValue);
607 STDMETHOD(GetGuestPropertyTimestamp)(IN_BSTR aName, ULONG64 *aTimestamp);
608 STDMETHOD(SetGuestProperty)(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags);
609 STDMETHOD(SetGuestPropertyValue)(IN_BSTR aName, IN_BSTR aValue);
610 STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
611 STDMETHOD(GetMediumAttachmentsOfController)(IN_BSTR aName, ComSafeArrayOut(IMediumAttachment *, aAttachments));
612 STDMETHOD(GetMediumAttachment)(IN_BSTR aConstrollerName, LONG aControllerPort, LONG aDevice, IMediumAttachment **aAttachment);
613 STDMETHOD(AddStorageController)(IN_BSTR aName, StorageBus_T aConnectionType, IStorageController **controller);
614 STDMETHOD(RemoveStorageController(IN_BSTR aName));
615 STDMETHOD(GetStorageControllerByName(IN_BSTR aName, IStorageController **storageController));
616 STDMETHOD(COMGETTER(FirmwareType)) (FirmwareType_T *aFirmware);
617 STDMETHOD(COMSETTER(FirmwareType)) (FirmwareType_T aFirmware);
618
619 // public methods only for internal purposes
620
621 InstanceType type() const { return mType; }
622
623 /// @todo (dmik) add lock and make non-inlined after revising classes
624 // that use it. Note: they should enter Machine lock to keep the returned
625 // information valid!
626 bool isRegistered() { return !!mData->mRegistered; }
627
628 // unsafe inline public methods for internal purposes only (ensure there is
629 // a caller and a read lock before calling them!)
630
631 /**
632 * Returns the VirtualBox object this machine belongs to.
633 *
634 * @note This method doesn't check this object's readiness. Intended to be
635 * used by ready Machine children (whose readiness is bound to the parent's
636 * one) or after doing addCaller() manually.
637 */
638 const ComObjPtr<VirtualBox, ComWeakRef> &virtualBox() const { return mParent; }
639
640 /**
641 * Returns this machine ID.
642 *
643 * @note This method doesn't check this object's readiness. Intended to be
644 * used by ready Machine children (whose readiness is bound to the parent's
645 * one) or after adding a caller manually.
646 */
647 const Guid &id() const { return mData->mUuid; }
648
649 /**
650 * Returns the snapshot ID this machine represents or an empty UUID if this
651 * instance is not SnapshotMachine.
652 *
653 * @note This method doesn't check this object's readiness. Intended to be
654 * used by ready Machine children (whose readiness is bound to the parent's
655 * one) or after adding a caller manually.
656 */
657 inline const Guid &snapshotId() const;
658
659 /**
660 * Returns this machine's full settings file path.
661 *
662 * @note This method doesn't lock this object or check its readiness.
663 * Intended to be used only after doing addCaller() manually and locking it
664 * for reading.
665 */
666 const Utf8Str &settingsFileFull() const { return mData->m_strConfigFileFull; }
667
668 /**
669 * Returns this machine name.
670 *
671 * @note This method doesn't lock this object or check its readiness.
672 * Intended to be used only after doing addCaller() manually and locking it
673 * for reading.
674 */
675 const Bstr &name() const { return mUserData->mName; }
676
677 // callback handlers
678 virtual HRESULT onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
679 virtual HRESULT onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
680 virtual HRESULT onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
681 virtual HRESULT onVRDPServerChange() { return S_OK; }
682 virtual HRESULT onUSBControllerChange() { return S_OK; }
683 virtual HRESULT onStorageControllerChange() { return S_OK; }
684 virtual HRESULT onMediumChange(IMediumAttachment * /* mediumAttachment */) { return S_OK; }
685 virtual HRESULT onSharedFolderChange() { return S_OK; }
686
687 HRESULT saveRegistryEntry(settings::MachineRegistryEntry &data);
688
689 int calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
690 void calculateRelativePath(const Utf8Str &strPath, Utf8Str &aResult);
691
692 void getLogFolder(Utf8Str &aLogFolder);
693
694 HRESULT openSession(IInternalSessionControl *aControl);
695 HRESULT openRemoteSession(IInternalSessionControl *aControl,
696 IN_BSTR aType, IN_BSTR aEnvironment,
697 Progress *aProgress);
698 HRESULT openExistingSession(IInternalSessionControl *aControl);
699
700#if defined(RT_OS_WINDOWS)
701
702 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
703 ComPtr<IInternalSessionControl> *aControl = NULL,
704 HANDLE *aIPCSem = NULL, bool aAllowClosing = false);
705 bool isSessionSpawning(RTPROCESS *aPID = NULL);
706
707 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
708 ComPtr<IInternalSessionControl> *aControl = NULL,
709 HANDLE *aIPCSem = NULL)
710 { return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
711
712#elif defined(RT_OS_OS2)
713
714 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
715 ComPtr<IInternalSessionControl> *aControl = NULL,
716 HMTX *aIPCSem = NULL, bool aAllowClosing = false);
717
718 bool isSessionSpawning(RTPROCESS *aPID = NULL);
719
720 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
721 ComPtr<IInternalSessionControl> *aControl = NULL,
722 HMTX *aIPCSem = NULL)
723 { return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
724
725#else
726
727 bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
728 ComPtr<IInternalSessionControl> *aControl = NULL,
729 bool aAllowClosing = false);
730 bool isSessionSpawning();
731
732 bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
733 ComPtr<IInternalSessionControl> *aControl = NULL)
734 { return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
735
736#endif
737
738 bool checkForSpawnFailure();
739
740 HRESULT trySetRegistered(BOOL aRegistered);
741
742 HRESULT getSharedFolder(CBSTR aName,
743 ComObjPtr<SharedFolder> &aSharedFolder,
744 bool aSetError = false)
745 {
746 AutoWriteLock alock(this);
747 return findSharedFolder(aName, aSharedFolder, aSetError);
748 }
749
750 HRESULT addStateDependency(StateDependency aDepType = AnyStateDep,
751 MachineState_T *aState = NULL,
752 BOOL *aRegistered = NULL);
753 void releaseStateDependency();
754
755 // for VirtualBoxSupportErrorInfoImpl
756 static const wchar_t *getComponentName() { return L"Machine"; }
757
758 /**
759 * Returns the handle of the snapshots tree lock. This lock is
760 * machine-specific because there is one snapshots tree per
761 * IMachine; the lock protects the "first snapshot" member in
762 * IMachine and all the children and parent links in snapshot
763 * objects pointed to therefrom.
764 *
765 * Locking order:
766 * a) object lock of the machine;
767 * b) snapshots tree lock of the machine;
768 * c) individual snapshot object locks in parent->child order,
769 * if needed; they are _not_ needed for the tree itself
770 * (as defined above).
771 */
772 RWLockHandle* snapshotsTreeLockHandle() const
773 {
774 return &mData->mSnapshotsTreeLockHandle;
775 }
776
777protected:
778
779 HRESULT registeredInit();
780
781 HRESULT checkStateDependency(StateDependency aDepType);
782
783 inline Machine *machine();
784
785 void ensureNoStateDependencies();
786
787 virtual HRESULT setMachineState(MachineState_T aMachineState);
788
789 HRESULT findSharedFolder(CBSTR aName,
790 ComObjPtr<SharedFolder> &aSharedFolder,
791 bool aSetError = false);
792
793 HRESULT loadSettings(bool aRegistered);
794 HRESULT loadSnapshot(const settings::Snapshot &data,
795 const Guid &aCurSnapshotId,
796 Snapshot *aParentSnapshot);
797 HRESULT loadHardware(const settings::Hardware &data);
798 HRESULT loadStorageControllers(const settings::Storage &data,
799 bool aRegistered,
800 const Guid *aSnapshotId = NULL);
801 HRESULT loadStorageDevices(StorageController *aStorageController,
802 const settings::StorageController &data,
803 bool aRegistered,
804 const Guid *aSnapshotId = NULL);
805
806 HRESULT findSnapshot(const Guid &aId, ComObjPtr<Snapshot> &aSnapshot,
807 bool aSetError = false);
808 HRESULT findSnapshot(IN_BSTR aName, ComObjPtr<Snapshot> &aSnapshot,
809 bool aSetError = false);
810
811 HRESULT getStorageControllerByName(const Utf8Str &aName,
812 ComObjPtr<StorageController> &aStorageController,
813 bool aSetError = false);
814
815 HRESULT getMediumAttachmentsOfController(CBSTR aName,
816 MediaData::AttachmentList &aAttachments);
817
818 enum
819 {
820 /* flags for #saveSettings() */
821 SaveS_ResetCurStateModified = 0x01,
822 SaveS_InformCallbacksAnyway = 0x02,
823 /* flags for #saveSnapshotSettings() */
824 SaveSS_CurStateModified = 0x40,
825 SaveSS_CurrentId = 0x80,
826 /* flags for #saveStateSettings() */
827 SaveSTS_CurStateModified = 0x20,
828 SaveSTS_StateFilePath = 0x40,
829 SaveSTS_StateTimeStamp = 0x80,
830 };
831
832 HRESULT prepareSaveSettings(bool &aRenamed, bool &aNew);
833 HRESULT saveSettings(int aFlags = 0);
834
835 HRESULT saveAllSnapshots();
836
837 HRESULT saveHardware(settings::Hardware &data);
838 HRESULT saveStorageControllers(settings::Storage &data);
839 HRESULT saveStorageDevices(ComObjPtr<StorageController> aStorageController,
840 settings::StorageController &data);
841
842 HRESULT saveStateSettings(int aFlags);
843
844 HRESULT createImplicitDiffs(const Bstr &aFolder,
845 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 void fixupMedia(bool aCommit, bool aOnline = false);
860
861 bool isInOwnDir(Utf8Str *aSettingsDir = NULL);
862
863 bool isModified();
864 bool isReallyModified(bool aIgnoreUserData = false);
865 void rollback(bool aNotify);
866 void commit();
867 void copyFrom(Machine *aThat);
868
869#ifdef VBOX_WITH_RESOURCE_USAGE_API
870 void registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
871 void unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
872#endif /* VBOX_WITH_RESOURCE_USAGE_API */
873
874 const InstanceType mType;
875
876 const ComObjPtr<Machine, ComWeakRef> mPeer;
877
878 const ComObjPtr<VirtualBox, ComWeakRef> mParent;
879
880 Shareable<Data> mData;
881 Shareable<SSData> mSSData;
882
883 Backupable<UserData> mUserData;
884 Backupable<HWData> mHWData;
885 Backupable<MediaData> mMediaData;
886
887 // the following fields need special backup/rollback/commit handling,
888 // so they cannot be a part of HWData
889
890 const ComObjPtr<VRDPServer> mVRDPServer;
891 const ComObjPtr<SerialPort>
892 mSerialPorts [SchemaDefs::SerialPortCount];
893 const ComObjPtr<ParallelPort>
894 mParallelPorts [SchemaDefs::ParallelPortCount];
895 const ComObjPtr<AudioAdapter> mAudioAdapter;
896 const ComObjPtr<USBController> mUSBController;
897 const ComObjPtr<BIOSSettings> mBIOSSettings;
898 const ComObjPtr<NetworkAdapter>
899 mNetworkAdapters [SchemaDefs::NetworkAdapterCount];
900
901 typedef std::list< ComObjPtr<StorageController> > StorageControllerList;
902 Backupable<StorageControllerList> mStorageControllers;
903
904 friend class SessionMachine;
905 friend class SnapshotMachine;
906};
907
908// SessionMachine class
909////////////////////////////////////////////////////////////////////////////////
910
911/**
912 * @note Notes on locking objects of this class:
913 * SessionMachine shares some data with the primary Machine instance (pointed
914 * to by the |mPeer| member). In order to provide data consistency it also
915 * shares its lock handle. This means that whenever you lock a SessionMachine
916 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
917 * instance is also locked in the same lock mode. Keep it in mind.
918 */
919class ATL_NO_VTABLE SessionMachine :
920 public VirtualBoxSupportTranslation<SessionMachine>,
921 public Machine,
922 VBOX_SCRIPTABLE_IMPL(IInternalMachineControl)
923{
924public:
925
926 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SessionMachine)
927
928 DECLARE_NOT_AGGREGATABLE(SessionMachine)
929
930 DECLARE_PROTECT_FINAL_CONSTRUCT()
931
932 BEGIN_COM_MAP(SessionMachine)
933 COM_INTERFACE_ENTRY2(IDispatch, IMachine)
934 COM_INTERFACE_ENTRY(ISupportErrorInfo)
935 COM_INTERFACE_ENTRY(IMachine)
936 COM_INTERFACE_ENTRY(IInternalMachineControl)
937 END_COM_MAP()
938
939 DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
940
941 HRESULT FinalConstruct();
942 void FinalRelease();
943
944 // public initializer/uninitializer for internal purposes only
945 HRESULT init(Machine *aMachine);
946 void uninit() { uninit(Uninit::Unexpected); }
947
948 // util::Lockable interface
949 RWLockHandle *lockHandle() const;
950
951 // IInternalMachineControl methods
952 STDMETHOD(SetRemoveSavedState)(BOOL aRemove);
953 STDMETHOD(UpdateState)(MachineState_T machineState);
954 STDMETHOD(GetIPCId)(BSTR *id);
955 STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
956 STDMETHOD(CaptureUSBDevice)(IN_BSTR aId);
957 STDMETHOD(DetachUSBDevice)(IN_BSTR aId, BOOL aDone);
958 STDMETHOD(AutoCaptureUSBDevices)();
959 STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
960 STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
961 STDMETHOD(BeginSavingState)(IProgress *aProgress, BSTR *aStateFilePath);
962 STDMETHOD(EndSavingState)(BOOL aSuccess);
963 STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
964 STDMETHOD(BeginTakingSnapshot)(IConsole *aInitiator,
965 IN_BSTR aName,
966 IN_BSTR aDescription,
967 IProgress *aConsoleProgress,
968 BOOL fTakingSnapshotOnline,
969 BSTR *aStateFilePath);
970 STDMETHOD(EndTakingSnapshot)(BOOL aSuccess);
971 STDMETHOD(DeleteSnapshot)(IConsole *aInitiator, IN_BSTR aId,
972 MachineState_T *aMachineState, IProgress **aProgress);
973 STDMETHOD(RestoreSnapshot)(IConsole *aInitiator,
974 ISnapshot *aSnapshot,
975 MachineState_T *aMachineState,
976 IProgress **aProgress);
977 STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
978 ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
979 STDMETHOD(PushGuestProperties)(ComSafeArrayIn(IN_BSTR, aNames), ComSafeArrayIn(IN_BSTR, aValues),
980 ComSafeArrayIn(ULONG64, aTimestamps), ComSafeArrayIn(IN_BSTR, aFlags));
981 STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
982 ULONG64 aTimestamp, IN_BSTR aFlags);
983 STDMETHOD(LockMedia)() { return lockMedia(); }
984
985 // public methods only for internal purposes
986
987 bool checkForDeath();
988
989 HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
990 HRESULT onStorageControllerChange();
991 HRESULT onMediumChange(IMediumAttachment *aMediumAttachment);
992 HRESULT onSerialPortChange(ISerialPort *serialPort);
993 HRESULT onParallelPortChange(IParallelPort *parallelPort);
994 HRESULT onVRDPServerChange();
995 HRESULT onUSBControllerChange();
996 HRESULT onUSBDeviceAttach(IUSBDevice *aDevice,
997 IVirtualBoxErrorInfo *aError,
998 ULONG aMaskedIfs);
999 HRESULT onUSBDeviceDetach(IN_BSTR aId,
1000 IVirtualBoxErrorInfo *aError);
1001 HRESULT onSharedFolderChange();
1002
1003 bool hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
1004
1005private:
1006
1007 struct SnapshotData
1008 {
1009 SnapshotData() : mLastState(MachineState_Null) {}
1010
1011 MachineState_T mLastState;
1012
1013 // used when taking snapshot
1014 ComObjPtr<Snapshot> mSnapshot;
1015
1016 // used when saving state
1017 Guid mProgressId;
1018 Bstr mStateFilePath;
1019 };
1020
1021 struct Uninit
1022 {
1023 enum Reason { Unexpected, Abnormal, Normal };
1024 };
1025
1026 struct Task;
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(BOOL aSuccess);
1036 HRESULT endTakingSnapshot(BOOL aSuccess);
1037
1038 typedef std::map<ComObjPtr<Machine>, MachineState_T> AffectedMachines;
1039
1040 void deleteSnapshotHandler(DeleteSnapshotTask &aTask);
1041 void restoreSnapshotHandler(RestoreSnapshotTask &aTask);
1042
1043 HRESULT lockMedia();
1044 void unlockMedia();
1045
1046 HRESULT setMachineState(MachineState_T aMachineState);
1047 HRESULT updateMachineStateOnClient();
1048
1049 HRESULT mRemoveSavedState;
1050
1051 SnapshotData mSnapshotData;
1052
1053 /** interprocess semaphore handle for this machine */
1054#if defined(RT_OS_WINDOWS)
1055 HANDLE mIPCSem;
1056 Bstr mIPCSemName;
1057 friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
1058 ComPtr<IInternalSessionControl> *aControl,
1059 HANDLE *aIPCSem, bool aAllowClosing);
1060#elif defined(RT_OS_OS2)
1061 HMTX mIPCSem;
1062 Bstr mIPCSemName;
1063 friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
1064 ComPtr<IInternalSessionControl> *aControl,
1065 HMTX *aIPCSem, bool aAllowClosing);
1066#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
1067 int mIPCSem;
1068# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
1069 Bstr mIPCKey;
1070# endif /*VBOX_WITH_NEW_SYS_V_KEYGEN */
1071#else
1072# error "Port me!"
1073#endif
1074
1075 static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
1076};
1077
1078// SnapshotMachine class
1079////////////////////////////////////////////////////////////////////////////////
1080
1081/**
1082 * @note Notes on locking objects of this class:
1083 * SnapshotMachine shares some data with the primary Machine instance (pointed
1084 * to by the |mPeer| member). In order to provide data consistency it also
1085 * shares its lock handle. This means that whenever you lock a SessionMachine
1086 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1087 * instance is also locked in the same lock mode. Keep it in mind.
1088 */
1089class ATL_NO_VTABLE SnapshotMachine :
1090 public VirtualBoxSupportTranslation<SnapshotMachine>,
1091 public Machine
1092{
1093public:
1094
1095 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SnapshotMachine)
1096
1097 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1098
1099 DECLARE_PROTECT_FINAL_CONSTRUCT()
1100
1101 BEGIN_COM_MAP(SnapshotMachine)
1102 COM_INTERFACE_ENTRY2(IDispatch, IMachine)
1103 COM_INTERFACE_ENTRY(ISupportErrorInfo)
1104 COM_INTERFACE_ENTRY(IMachine)
1105 END_COM_MAP()
1106
1107 DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
1108
1109 HRESULT FinalConstruct();
1110 void FinalRelease();
1111
1112 // public initializer/uninitializer for internal purposes only
1113 HRESULT init(SessionMachine *aSessionMachine,
1114 IN_GUID aSnapshotId,
1115 const Utf8Str &aStateFilePath);
1116 HRESULT init(Machine *aMachine,
1117 const settings::Hardware &hardware,
1118 const settings::Storage &storage,
1119 IN_GUID aSnapshotId,
1120 const Utf8Str &aStateFilePath);
1121 void uninit();
1122
1123 // util::Lockable interface
1124 RWLockHandle *lockHandle() const;
1125
1126 // public methods only for internal purposes
1127
1128 HRESULT onSnapshotChange(Snapshot *aSnapshot);
1129
1130 // unsafe inline public methods for internal purposes only (ensure there is
1131 // a caller and a read lock before calling them!)
1132
1133 const Guid &snapshotId() const { return mSnapshotId; }
1134
1135private:
1136
1137 Guid mSnapshotId;
1138
1139 friend class Snapshot;
1140};
1141
1142// third party methods that depend on SnapshotMachine definiton
1143
1144inline const Guid &Machine::snapshotId() const
1145{
1146 return mType != IsSnapshotMachine ? Guid::Empty :
1147 static_cast<const SnapshotMachine *>(this)->snapshotId();
1148}
1149
1150////////////////////////////////////////////////////////////////////////////////
1151
1152/**
1153 * Returns a pointer to the Machine object for this machine that acts like a
1154 * parent for complex machine data objects such as shared folders, etc.
1155 *
1156 * For primary Machine objects and for SnapshotMachine objects, returns this
1157 * object's pointer itself. For SessoinMachine objects, returns the peer
1158 * (primary) machine pointer.
1159 */
1160inline Machine *Machine::machine()
1161{
1162 if (mType == IsSessionMachine)
1163 return mPeer;
1164 return this;
1165}
1166
1167
1168#endif // ____H_MACHINEIMPL
1169/* 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