VirtualBox

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

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

#3281: Introduced a 'version' attribute on the <Hardware> element setting it to '1' during conversion if a saved state was found, otherwise using the default of '2'.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 39.5 KB
Line 
1/* $Id: MachineImpl.h 15582 2008-12-16 13:22:33Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class declaration
6 */
7
8/*
9 * Copyright (C) 2006-2007 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 "DVDDriveImpl.h"
32#include "FloppyDriveImpl.h"
33#include "HardDiskAttachmentImpl.h"
34#include "Collection.h"
35#include "NetworkAdapterImpl.h"
36#include "AudioAdapterImpl.h"
37#include "SerialPortImpl.h"
38#include "ParallelPortImpl.h"
39#include "BIOSSettingsImpl.h"
40#include "SATAControllerImpl.h"
41#ifdef VBOX_WITH_RESOURCE_USAGE_API
42#include "PerformanceImpl.h"
43#endif /* VBOX_WITH_RESOURCE_USAGE_API */
44
45// generated header
46#include "SchemaDefs.h"
47
48#include <VBox/types.h>
49
50#include <iprt/file.h>
51#include <iprt/thread.h>
52#include <iprt/time.h>
53
54#include <list>
55
56// defines
57////////////////////////////////////////////////////////////////////////////////
58
59// helper declarations
60////////////////////////////////////////////////////////////////////////////////
61
62class VirtualBox;
63class Progress;
64class CombinedProgress;
65class Keyboard;
66class Mouse;
67class Display;
68class MachineDebugger;
69class USBController;
70class Snapshot;
71class SharedFolder;
72class HostUSBDevice;
73
74class SessionMachine;
75
76// Machine class
77////////////////////////////////////////////////////////////////////////////////
78
79class ATL_NO_VTABLE Machine :
80 public VirtualBoxBaseWithChildrenNEXT,
81 public VirtualBoxSupportErrorInfoImpl <Machine, IMachine>,
82 public VirtualBoxSupportTranslation <Machine>,
83 public IMachine
84{
85 Q_OBJECT
86
87public:
88
89 enum InstanceType { IsMachine, IsSessionMachine, IsSnapshotMachine };
90
91 /**
92 * Internal machine data.
93 *
94 * Only one instance of this data exists per every machine --
95 * it is shared by the Machine, SessionMachine and all SnapshotMachine
96 * instances associated with the given machine using the util::Shareable
97 * template through the mData variable.
98 *
99 * @note |const| members are persistent during lifetime so can be
100 * accessed without locking.
101 *
102 * @note There is no need to lock anything inside init() or uninit()
103 * methods, because they are always serialized (see AutoCaller).
104 */
105 struct Data
106 {
107 /**
108 * Data structure to hold information about sessions opened for the
109 * given machine.
110 */
111 struct Session
112 {
113 /** Control of the direct session opened by openSession() */
114 ComPtr <IInternalSessionControl> mDirectControl;
115
116 typedef std::list <ComPtr <IInternalSessionControl> > RemoteControlList;
117
118 /** list of controls of all opened remote sessions */
119 RemoteControlList mRemoteControls;
120
121 /** openRemoteSession() and OnSessionEnd() progress indicator */
122 ComObjPtr <Progress> mProgress;
123
124 /**
125 * PID of the session object that must be passed to openSession()
126 * to finalize the openRemoteSession() request
127 * (i.e., PID of the process created by openRemoteSession())
128 */
129 RTPROCESS mPid;
130
131 /** Current session state */
132 SessionState_T mState;
133
134 /** Session type string (for indirect sessions) */
135 Bstr mType;
136
137 /** Sesison machine object */
138 ComObjPtr <SessionMachine> mMachine;
139 };
140
141 Data();
142 ~Data();
143
144 const Guid mUuid;
145 BOOL mRegistered;
146
147 Bstr mConfigFile;
148 Bstr mConfigFileFull;
149
150 Utf8Str mSettingsFileVersion;
151
152 BOOL mAccessible;
153 com::ErrorInfo mAccessError;
154
155 MachineState_T mMachineState;
156 RTTIMESPEC mLastStateChange;
157
158 /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
159 uint32_t mMachineStateDeps;
160 RTSEMEVENTMULTI mMachineStateDepsSem;
161 uint32_t mMachineStateChangePending;
162
163 BOOL mCurrentStateModified;
164
165 RTFILE mHandleCfgFile;
166
167 Session mSession;
168
169 ComObjPtr <Snapshot> mFirstSnapshot;
170 ComObjPtr <Snapshot> mCurrentSnapshot;
171
172 };
173
174 /**
175 * Saved state data.
176 *
177 * It's actually only the state file path string, but it needs to be
178 * separate from Data, because Machine and SessionMachine instances
179 * share it, while SnapshotMachine does not.
180 *
181 * The data variable is |mSSData|.
182 */
183 struct SSData
184 {
185 Bstr mStateFilePath;
186 };
187
188 /**
189 * User changeable machine data.
190 *
191 * This data is common for all machine snapshots, i.e. it is shared
192 * by all SnapshotMachine instances associated with the given machine
193 * using the util::Backupable template through the |mUserData| variable.
194 *
195 * SessionMachine instances can alter this data and discard changes.
196 *
197 * @note There is no need to lock anything inside init() or uninit()
198 * methods, because they are always serialized (see AutoCaller).
199 */
200 struct UserData
201 {
202 UserData();
203 ~UserData();
204
205 bool operator== (const UserData &that) const
206 {
207 return this == &that ||
208 (mName == that.mName &&
209 mNameSync == that.mNameSync &&
210 mDescription == that.mDescription &&
211 mOSTypeId == that.mOSTypeId &&
212 mSnapshotFolderFull == that.mSnapshotFolderFull);
213 }
214
215 Bstr mName;
216 BOOL mNameSync;
217 Bstr mDescription;
218 Bstr mOSTypeId;
219 Bstr mSnapshotFolder;
220 Bstr mSnapshotFolderFull;
221 };
222
223 /**
224 * Hardware data.
225 *
226 * This data is unique for a machine and for every machine snapshot.
227 * Stored using the util::Backupable template in the |mHWData| variable.
228 *
229 * SessionMachine instances can alter this data and discard changes.
230 */
231 struct HWData
232 {
233 /**
234 * Data structure to hold information about a guest property.
235 */
236 struct GuestProperty {
237 /** Property name */
238 Bstr mName;
239 /** Property value */
240 Bstr mValue;
241 /** Property timestamp */
242 ULONG64 mTimestamp;
243 /** Property flags */
244 ULONG mFlags;
245 };
246
247 HWData();
248 ~HWData();
249
250 bool operator== (const HWData &that) const;
251
252 Bstr mHWVersion;
253 ULONG mMemorySize;
254 ULONG mMemoryBalloonSize;
255 ULONG mStatisticsUpdateInterval;
256 ULONG mVRAMSize;
257 ULONG mMonitorCount;
258 TSBool_T mHWVirtExEnabled;
259 BOOL mHWVirtExNestedPagingEnabled;
260 BOOL mHWVirtExVPIDEnabled;
261 BOOL mAccelerate3DEnabled;
262 BOOL mPAEEnabled;
263 ULONG mCPUCount;
264
265 DeviceType_T mBootOrder [SchemaDefs::MaxBootPosition];
266
267 typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
268 SharedFolderList mSharedFolders;
269 ClipboardMode_T mClipboardMode;
270 typedef std::list <GuestProperty> GuestPropertyList;
271 GuestPropertyList mGuestProperties;
272 BOOL mPropertyServiceActive;
273 Bstr mGuestPropertyNotificationPatterns;
274 };
275
276 /**
277 * Hard disk data.
278 *
279 * The usage policy is the same as for HWData, but a separate structure
280 * is necessary because hard disk data requires different procedures when
281 * taking or discarding snapshots, etc.
282 *
283 * The data variable is |mHWData|.
284 */
285 struct HDData
286 {
287 HDData();
288 ~HDData();
289
290 bool operator== (const HDData &that) const;
291
292 typedef std::list <ComObjPtr <HardDisk2Attachment> > AttachmentList;
293 AttachmentList mAttachments;
294 };
295
296 enum StateDependency
297 {
298 AnyStateDep = 0, MutableStateDep, MutableOrSavedStateDep
299 };
300
301 /**
302 * Helper class that safely manages the machine state dependency by
303 * calling Machine::addStateDependency() on construction and
304 * Machine::releaseStateDependency() on destruction. Intended for Machine
305 * children. The usage pattern is:
306 *
307 * @code
308 * AutoCaller autoCaller (this);
309 * CheckComRCReturnRC (autoCaller.rc());
310 *
311 * Machine::AutoStateDependency <MutableStateDep> adep (mParent);
312 * CheckComRCReturnRC (stateDep.rc());
313 * ...
314 * // code that depends on the particular machine state
315 * ...
316 * @endcode
317 *
318 * Note that it is more convenient to use the following individual
319 * shortcut classes instead of using this template directly:
320 * AutoAnyStateDependency, AutoMutableStateDependency and
321 * AutoMutableOrSavedStateDependency. The usage pattern is exactly the
322 * same as above except that there is no need to specify the template
323 * argument because it is already done by the shortcut class.
324 *
325 * @param taDepType Dependecy type to manage.
326 */
327 template <StateDependency taDepType = AnyStateDep>
328 class AutoStateDependency
329 {
330 public:
331
332 AutoStateDependency (Machine *aThat)
333 : mThat (aThat), mRC (S_OK)
334 , mMachineState (MachineState_Null)
335 , mRegistered (FALSE)
336 {
337 Assert (aThat);
338 mRC = aThat->addStateDependency (taDepType, &mMachineState,
339 &mRegistered);
340 }
341 ~AutoStateDependency()
342 {
343 if (SUCCEEDED (mRC))
344 mThat->releaseStateDependency();
345 }
346
347 /** Decreases the number of dependencies before the instance is
348 * destroyed. Note that will reset #rc() to E_FAIL. */
349 void release()
350 {
351 AssertReturnVoid (SUCCEEDED (mRC));
352 mThat->releaseStateDependency();
353 mRC = E_FAIL;
354 }
355
356 /** Restores the number of callers after by #release(). #rc() will be
357 * reset to the result of calling addStateDependency() and must be
358 * rechecked to ensure the operation succeeded. */
359 void add()
360 {
361 AssertReturnVoid (!SUCCEEDED (mRC));
362 mRC = mThat->addStateDependency (taDepType, &mMachineState,
363 &mRegistered);
364 }
365
366 /** Returns the result of Machine::addStateDependency(). */
367 HRESULT rc() const { return mRC; }
368
369 /** Shortcut to SUCCEEDED (rc()). */
370 bool isOk() const { return SUCCEEDED (mRC); }
371
372 /** Returns the machine state value as returned by
373 * Machine::addStateDependency(). */
374 MachineState_T machineState() const { return mMachineState; }
375
376 /** Returns the machine state value as returned by
377 * Machine::addStateDependency(). */
378 BOOL machineRegistered() const { return mRegistered; }
379
380 protected:
381
382 Machine *mThat;
383 HRESULT mRC;
384 MachineState_T mMachineState;
385 BOOL mRegistered;
386
387 private:
388
389 DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (AutoStateDependency)
390 DECLARE_CLS_NEW_DELETE_NOOP (AutoStateDependency)
391 };
392
393 /**
394 * Shortcut to AutoStateDependency <AnyStateDep>.
395 * See AutoStateDependency to get the usage pattern.
396 *
397 * Accepts any machine state and guarantees the state won't change before
398 * this object is destroyed. If the machine state cannot be protected (as
399 * a result of the state change currently in progress), this instance's
400 * #rc() method will indicate a failure, and the caller is not allowed to
401 * rely on any particular machine state and should return the failed
402 * result code to the upper level.
403 */
404 typedef AutoStateDependency <AnyStateDep> AutoAnyStateDependency;
405
406 /**
407 * Shortcut to AutoStateDependency <MutableStateDep>.
408 * See AutoStateDependency to get the usage pattern.
409 *
410 * Succeeds only if the machine state is in one of the mutable states, and
411 * guarantees the given mutable state won't change before this object is
412 * destroyed. If the machine is not mutable, this instance's #rc() method
413 * will indicate a failure, and the caller is not allowed to rely on any
414 * particular machine state and should return the failed result code to
415 * the upper level.
416 *
417 * Intended to be used within all setter methods of IMachine
418 * children objects (DVDDrive, NetworkAdapter, AudioAdapter, etc.) to
419 * provide data protection and consistency.
420 */
421 typedef AutoStateDependency <MutableStateDep> AutoMutableStateDependency;
422
423 /**
424 * Shortcut to AutoStateDependency <MutableOrSavedStateDep>.
425 * See AutoStateDependency to get the usage pattern.
426 *
427 * Succeeds only if the machine state is in one of the mutable states, or
428 * if the machine is in the Saved state, and guarantees the given mutable
429 * state won't change before this object is destroyed. If the machine is
430 * not mutable, this instance's #rc() method will indicate a failure, and
431 * the caller is not allowed to rely on any particular machine state and
432 * should return the failed result code to the upper level.
433 *
434 * Intended to be used within setter methods of IMachine
435 * children objects that may also operate on Saved machines.
436 */
437 typedef AutoStateDependency <MutableOrSavedStateDep> AutoMutableOrSavedStateDependency;
438
439
440 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (Machine)
441
442 DECLARE_NOT_AGGREGATABLE(Machine)
443
444 DECLARE_PROTECT_FINAL_CONSTRUCT()
445
446 BEGIN_COM_MAP(Machine)
447 COM_INTERFACE_ENTRY(ISupportErrorInfo)
448 COM_INTERFACE_ENTRY(IMachine)
449 END_COM_MAP()
450
451 NS_DECL_ISUPPORTS
452
453 DECLARE_EMPTY_CTOR_DTOR (Machine)
454
455 HRESULT FinalConstruct();
456 void FinalRelease();
457
458 enum InitMode { Init_New, Init_Existing, Init_Registered };
459
460 // public initializer/uninitializer for internal purposes only
461 HRESULT init (VirtualBox *aParent, CBSTR aConfigFile,
462 InitMode aMode, CBSTR aName = NULL,
463 GuestOSType *aOsType = NULL,
464 BOOL aNameSync = TRUE, const Guid *aId = NULL);
465 void uninit();
466
467 // IMachine properties
468 STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
469 STDMETHOD(COMGETTER(Accessible)) (BOOL *aAccessible);
470 STDMETHOD(COMGETTER(AccessError)) (IVirtualBoxErrorInfo **aAccessError);
471 STDMETHOD(COMGETTER(Name))(BSTR *aName);
472 STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
473 STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
474 STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
475 STDMETHOD(COMGETTER(Id))(OUT_GUID aId);
476 STDMETHOD(COMGETTER(OSTypeId)) (BSTR *aOSTypeId);
477 STDMETHOD(COMSETTER(OSTypeId)) (IN_BSTR aOSTypeId);
478 STDMETHOD(COMGETTER(HardwareVersion))(BSTR *aVersion);
479 STDMETHOD(COMSETTER(HardwareVersion))(IN_BSTR aVersion);
480 STDMETHOD(COMGETTER(MemorySize))(ULONG *memorySize);
481 STDMETHOD(COMSETTER(MemorySize))(ULONG memorySize);
482 STDMETHOD(COMGETTER(CPUCount))(ULONG *cpuCount);
483 STDMETHOD(COMSETTER(CPUCount))(ULONG cpuCount);
484 STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
485 STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
486 STDMETHOD(COMGETTER(StatisticsUpdateInterval))(ULONG *statisticsUpdateInterval);
487 STDMETHOD(COMSETTER(StatisticsUpdateInterval))(ULONG statisticsUpdateInterval);
488 STDMETHOD(COMGETTER(VRAMSize))(ULONG *memorySize);
489 STDMETHOD(COMSETTER(VRAMSize))(ULONG memorySize);
490 STDMETHOD(COMGETTER(MonitorCount))(ULONG *monitorCount);
491 STDMETHOD(COMSETTER(MonitorCount))(ULONG monitorCount);
492 STDMETHOD(COMGETTER(Accelerate3DEnabled))(BOOL *enabled);
493 STDMETHOD(COMSETTER(Accelerate3DEnabled))(BOOL enabled);
494 STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **biosSettings);
495 STDMETHOD(COMGETTER(HWVirtExEnabled))(TSBool_T *enabled);
496 STDMETHOD(COMSETTER(HWVirtExEnabled))(TSBool_T enabled);
497 STDMETHOD(COMGETTER(HWVirtExNestedPagingEnabled))(BOOL *enabled);
498 STDMETHOD(COMSETTER(HWVirtExNestedPagingEnabled))(BOOL enabled);
499 STDMETHOD(COMGETTER(HWVirtExVPIDEnabled))(BOOL *enabled);
500 STDMETHOD(COMSETTER(HWVirtExVPIDEnabled))(BOOL enabled);
501 STDMETHOD(COMGETTER(PAEEnabled))(BOOL *enabled);
502 STDMETHOD(COMSETTER(PAEEnabled))(BOOL enabled);
503 STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
504 STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSavedStateFolder);
505 STDMETHOD(COMGETTER(HardDisk2Attachments))(ComSafeArrayOut (IHardDisk2Attachment *, aAttachments));
506 STDMETHOD(COMGETTER(VRDPServer))(IVRDPServer **vrdpServer);
507 STDMETHOD(COMGETTER(DVDDrive))(IDVDDrive **dvdDrive);
508 STDMETHOD(COMGETTER(FloppyDrive))(IFloppyDrive **floppyDrive);
509 STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
510 STDMETHOD(COMGETTER(USBController)) (IUSBController * *aUSBController);
511 STDMETHOD(COMGETTER(SATAController)) (ISATAController **aSATAController);
512 STDMETHOD(COMGETTER(SettingsFilePath)) (BSTR *aFilePath);
513 STDMETHOD(COMGETTER(SettingsFileVersion)) (BSTR *aSettingsFileVersion);
514 STDMETHOD(COMGETTER(SettingsModified)) (BOOL *aModified);
515 STDMETHOD(COMGETTER(SessionState)) (SessionState_T *aSessionState);
516 STDMETHOD(COMGETTER(SessionType)) (BSTR *aSessionType);
517 STDMETHOD(COMGETTER(SessionPid)) (ULONG *aSessionPid);
518 STDMETHOD(COMGETTER(State)) (MachineState_T *machineState);
519 STDMETHOD(COMGETTER(LastStateChange)) (LONG64 *aLastStateChange);
520 STDMETHOD(COMGETTER(StateFilePath)) (BSTR *aStateFilePath);
521 STDMETHOD(COMGETTER(LogFolder)) (BSTR *aLogFolder);
522 STDMETHOD(COMGETTER(CurrentSnapshot)) (ISnapshot **aCurrentSnapshot);
523 STDMETHOD(COMGETTER(SnapshotCount)) (ULONG *aSnapshotCount);
524 STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
525 STDMETHOD(COMGETTER(SharedFolders)) (ISharedFolderCollection **aSharedFolders);
526 STDMETHOD(COMGETTER(ClipboardMode)) (ClipboardMode_T *aClipboardMode);
527 STDMETHOD(COMSETTER(ClipboardMode)) (ClipboardMode_T aClipboardMode);
528 STDMETHOD(COMGETTER(GuestPropertyNotificationPatterns)) (BSTR *aPattern);
529 STDMETHOD(COMSETTER(GuestPropertyNotificationPatterns)) (IN_BSTR aPattern);
530
531 // IMachine methods
532 STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
533 STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
534 STDMETHOD(AttachHardDisk2) (IN_GUID aId, StorageBus_T aBus,
535 LONG aChannel, LONG aDevice);
536 STDMETHOD(GetHardDisk2) (StorageBus_T aBus, LONG aChannel, LONG aDevice,
537 IHardDisk2 **aHardDisk);
538 STDMETHOD(DetachHardDisk2) (StorageBus_T aBus, LONG aChannel, LONG aDevice);
539 STDMETHOD(GetSerialPort) (ULONG slot, ISerialPort **port);
540 STDMETHOD(GetParallelPort) (ULONG slot, IParallelPort **port);
541 STDMETHOD(GetNetworkAdapter) (ULONG slot, INetworkAdapter **adapter);
542 STDMETHOD(GetNextExtraDataKey)(IN_BSTR aKey, BSTR *aNextKey, BSTR *aNextValue);
543 STDMETHOD(GetExtraData)(IN_BSTR aKey, BSTR *aValue);
544 STDMETHOD(SetExtraData)(IN_BSTR aKey, IN_BSTR aValue);
545 STDMETHOD(SaveSettings)();
546 STDMETHOD(SaveSettingsWithBackup) (BSTR *aBakFileName);
547 STDMETHOD(DiscardSettings)();
548 STDMETHOD(DeleteSettings)();
549 STDMETHOD(GetSnapshot) (IN_GUID aId, ISnapshot **aSnapshot);
550 STDMETHOD(FindSnapshot) (IN_BSTR aName, ISnapshot **aSnapshot);
551 STDMETHOD(SetCurrentSnapshot) (IN_GUID aId);
552 STDMETHOD(CreateSharedFolder) (IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable);
553 STDMETHOD(RemoveSharedFolder) (IN_BSTR aName);
554 STDMETHOD(CanShowConsoleWindow) (BOOL *aCanShow);
555 STDMETHOD(ShowConsoleWindow) (ULONG64 *aWinId);
556 STDMETHOD(GetGuestProperty) (IN_BSTR aName, BSTR *aValue, ULONG64 *aTimestamp, BSTR *aFlags);
557 STDMETHOD(GetGuestPropertyValue) (IN_BSTR aName, BSTR *aValue);
558 STDMETHOD(GetGuestPropertyTimestamp) (IN_BSTR aName, ULONG64 *aTimestamp);
559 STDMETHOD(SetGuestProperty) (IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags);
560 STDMETHOD(SetGuestPropertyValue) (IN_BSTR aName, IN_BSTR aValue);
561 STDMETHOD(EnumerateGuestProperties) (IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
562
563 // public methods only for internal purposes
564
565 InstanceType type() const { return mType; }
566
567 /// @todo (dmik) add lock and make non-inlined after revising classes
568 // that use it. Note: they should enter Machine lock to keep the returned
569 // information valid!
570 bool isRegistered() { return !!mData->mRegistered; }
571
572 // unsafe inline public methods for internal purposes only (ensure there is
573 // a caller and a read lock before calling them!)
574
575 /**
576 * Returns the VirtualBox object this machine belongs to.
577 *
578 * @note This method doesn't check this object's readiness. Intended to be
579 * used by ready Machine children (whose readiness is bound to the parent's
580 * one) or after doing addCaller() manually.
581 */
582 const ComObjPtr <VirtualBox, ComWeakRef> &virtualBox() const { return mParent; }
583
584 /**
585 * Returns this machine ID.
586 *
587 * @note This method doesn't check this object's readiness. Intended to be
588 * used by ready Machine children (whose readiness is bound to the parent's
589 * one) or after adding a caller manually.
590 */
591 const Guid &id() const { return mData->mUuid; }
592
593 /**
594 * Returns the snapshot ID this machine represents or an empty UUID if this
595 * instance is not SnapshotMachine.
596 *
597 * @note This method doesn't check this object's readiness. Intended to be
598 * used by ready Machine children (whose readiness is bound to the parent's
599 * one) or after adding a caller manually.
600 */
601 inline const Guid &snapshotId() const;
602
603 /**
604 * Returns this machine's full settings file path.
605 *
606 * @note This method doesn't lock this object or check its readiness.
607 * Intended to be used only after doing addCaller() manually and locking it
608 * for reading.
609 */
610 const Bstr &settingsFileFull() const { return mData->mConfigFileFull; }
611
612 /**
613 * Returns this machine name.
614 *
615 * @note This method doesn't lock this object or check its readiness.
616 * Intended to be used only after doing addCaller() manually and locking it
617 * for reading.
618 */
619 const Bstr &name() const { return mUserData->mName; }
620
621 // callback handlers
622 virtual HRESULT onDVDDriveChange() { return S_OK; }
623 virtual HRESULT onFloppyDriveChange() { return S_OK; }
624 virtual HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter) { return S_OK; }
625 virtual HRESULT onSerialPortChange(ISerialPort *serialPort) { return S_OK; }
626 virtual HRESULT onParallelPortChange(IParallelPort *ParallelPort) { return S_OK; }
627 virtual HRESULT onVRDPServerChange() { return S_OK; }
628 virtual HRESULT onUSBControllerChange() { return S_OK; }
629 virtual HRESULT onSATAControllerChange() { return S_OK; }
630 virtual HRESULT onSharedFolderChange() { return S_OK; }
631
632 HRESULT saveRegistryEntry (settings::Key &aEntryNode);
633
634 int calculateFullPath (const char *aPath, Utf8Str &aResult);
635 void calculateRelativePath (const char *aPath, Utf8Str &aResult);
636
637 void getLogFolder (Utf8Str &aLogFolder);
638
639 HRESULT openSession (IInternalSessionControl *aControl);
640 HRESULT openRemoteSession (IInternalSessionControl *aControl,
641 IN_BSTR aType, IN_BSTR aEnvironment,
642 Progress *aProgress);
643 HRESULT openExistingSession (IInternalSessionControl *aControl);
644
645#if defined (RT_OS_WINDOWS)
646
647 bool isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
648 ComPtr <IInternalSessionControl> *aControl = NULL,
649 HANDLE *aIPCSem = NULL, bool aAllowClosing = false);
650 bool isSessionSpawning (RTPROCESS *aPID = NULL);
651
652 bool isSessionOpenOrClosing (ComObjPtr <SessionMachine> &aMachine,
653 ComPtr <IInternalSessionControl> *aControl = NULL,
654 HANDLE *aIPCSem = NULL)
655 { return isSessionOpen (aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
656
657#elif defined (RT_OS_OS2)
658
659 bool isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
660 ComPtr <IInternalSessionControl> *aControl = NULL,
661 HMTX *aIPCSem = NULL, bool aAllowClosing = false);
662
663 bool isSessionSpawning (RTPROCESS *aPID = NULL);
664
665 bool isSessionOpenOrClosing (ComObjPtr <SessionMachine> &aMachine,
666 ComPtr <IInternalSessionControl> *aControl = NULL,
667 HMTX *aIPCSem = NULL)
668 { return isSessionOpen (aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
669
670#else
671
672 bool isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
673 ComPtr <IInternalSessionControl> *aControl = NULL,
674 bool aAllowClosing = false);
675 bool isSessionSpawning();
676
677 bool isSessionOpenOrClosing (ComObjPtr <SessionMachine> &aMachine,
678 ComPtr <IInternalSessionControl> *aControl = NULL)
679 { return isSessionOpen (aMachine, aControl, true /* aAllowClosing */); }
680
681#endif
682
683 bool checkForSpawnFailure();
684
685 HRESULT trySetRegistered (BOOL aRegistered);
686
687 HRESULT getSharedFolder (CBSTR aName,
688 ComObjPtr <SharedFolder> &aSharedFolder,
689 bool aSetError = false)
690 {
691 AutoWriteLock alock (this);
692 return findSharedFolder (aName, aSharedFolder, aSetError);
693 }
694
695 HRESULT addStateDependency (StateDependency aDepType = AnyStateDep,
696 MachineState_T *aState = NULL,
697 BOOL *aRegistered = NULL);
698 void releaseStateDependency();
699
700 // for VirtualBoxSupportErrorInfoImpl
701 static const wchar_t *getComponentName() { return L"Machine"; }
702
703protected:
704
705 HRESULT registeredInit();
706
707 HRESULT checkStateDependency (StateDependency aDepType);
708
709 inline Machine *machine();
710
711 HRESULT initDataAndChildObjects();
712 void uninitDataAndChildObjects();
713
714 void ensureNoStateDependencies();
715
716 virtual HRESULT setMachineState (MachineState_T aMachineState);
717
718 HRESULT findSharedFolder (CBSTR aName,
719 ComObjPtr <SharedFolder> &aSharedFolder,
720 bool aSetError = false);
721
722 HRESULT loadSettings (bool aRegistered);
723 HRESULT loadSnapshot (const settings::Key &aNode, const Guid &aCurSnapshotId,
724 Snapshot *aParentSnapshot);
725 HRESULT loadHardware (const settings::Key &aNode);
726 HRESULT loadHardDisks (const settings::Key &aNode, bool aRegistered,
727 const Guid *aSnapshotId = NULL);
728
729 HRESULT findSnapshotNode (Snapshot *aSnapshot, settings::Key &aMachineNode,
730 settings::Key *aSnapshotsNode,
731 settings::Key *aSnapshotNode);
732
733 HRESULT findSnapshot (const Guid &aId, ComObjPtr <Snapshot> &aSnapshot,
734 bool aSetError = false);
735 HRESULT findSnapshot (IN_BSTR aName, ComObjPtr <Snapshot> &aSnapshot,
736 bool aSetError = false);
737
738 enum
739 {
740 /* flags for #saveSettings() */
741 SaveS_ResetCurStateModified = 0x01,
742 SaveS_InformCallbacksAnyway = 0x02,
743 /* ops for #saveSnapshotSettings() */
744 SaveSS_NoOp = 0x00, SaveSS_AddOp = 0x01,
745 SaveSS_UpdateAttrsOp = 0x02, SaveSS_UpdateAllOp = 0x03,
746 SaveSS_OpMask = 0xF,
747 /* flags for #saveSnapshotSettings() */
748 SaveSS_CurStateModified = 0x40,
749 SaveSS_CurrentId = 0x80,
750 /* flags for #saveStateSettings() */
751 SaveSTS_CurStateModified = 0x20,
752 SaveSTS_StateFilePath = 0x40,
753 SaveSTS_StateTimeStamp = 0x80,
754 };
755
756 HRESULT prepareSaveSettings (bool &aRenamed, bool &aNew);
757 HRESULT saveSettings (int aFlags = 0);
758
759 HRESULT saveSnapshotSettings (Snapshot *aSnapshot, int aOpFlags);
760 HRESULT saveSnapshotSettingsWorker (settings::Key &aMachineNode,
761 Snapshot *aSnapshot, int aOpFlags);
762
763 HRESULT saveSnapshot (settings::Key &aNode, Snapshot *aSnapshot, bool aAttrsOnly);
764 HRESULT saveHardware (settings::Key &aNode);
765 HRESULT saveHardDisks (settings::Key &aNode);
766
767 HRESULT saveStateSettings (int aFlags);
768
769 HRESULT createImplicitDiffs (const Bstr &aFolder,
770 ComObjPtr <Progress> &aProgress,
771 bool aOnline);
772 HRESULT deleteImplicitDiffs();
773
774 void fixupHardDisks2 (bool aCommit, bool aOnline = false);
775
776 HRESULT lockConfig();
777 HRESULT unlockConfig();
778
779 /** @note This method is not thread safe */
780 BOOL isConfigLocked()
781 {
782 return !!mData && mData->mHandleCfgFile != NIL_RTFILE;
783 }
784
785 bool isInOwnDir (Utf8Str *aSettingsDir = NULL);
786
787 bool isModified();
788 bool isReallyModified (bool aIgnoreUserData = false);
789 void rollback (bool aNotify);
790 void commit();
791 void copyFrom (Machine *aThat);
792
793#ifdef VBOX_WITH_RESOURCE_USAGE_API
794 void registerMetrics (PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
795 void unregisterMetrics (PerformanceCollector *aCollector, Machine *aMachine);
796#endif /* VBOX_WITH_RESOURCE_USAGE_API */
797
798 const InstanceType mType;
799
800 const ComObjPtr <Machine, ComWeakRef> mPeer;
801
802 const ComObjPtr <VirtualBox, ComWeakRef> mParent;
803
804 Shareable <Data> mData;
805 Shareable <SSData> mSSData;
806
807 Backupable <UserData> mUserData;
808 Backupable <HWData> mHWData;
809 Backupable <HDData> mHDData;
810
811 // the following fields need special backup/rollback/commit handling,
812 // so they cannot be a part of HWData
813
814 const ComObjPtr <VRDPServer> mVRDPServer;
815 const ComObjPtr <DVDDrive> mDVDDrive;
816 const ComObjPtr <FloppyDrive> mFloppyDrive;
817 const ComObjPtr <SerialPort>
818 mSerialPorts [SchemaDefs::SerialPortCount];
819 const ComObjPtr <ParallelPort>
820 mParallelPorts [SchemaDefs::ParallelPortCount];
821 const ComObjPtr <AudioAdapter> mAudioAdapter;
822 const ComObjPtr <USBController> mUSBController;
823 const ComObjPtr <SATAController> mSATAController;
824 const ComObjPtr <BIOSSettings> mBIOSSettings;
825 const ComObjPtr <NetworkAdapter>
826 mNetworkAdapters [SchemaDefs::NetworkAdapterCount];
827
828 friend class SessionMachine;
829 friend class SnapshotMachine;
830};
831
832// SessionMachine class
833////////////////////////////////////////////////////////////////////////////////
834
835/**
836 * @note Notes on locking objects of this class:
837 * SessionMachine shares some data with the primary Machine instance (pointed
838 * to by the |mPeer| member). In order to provide data consistency it also
839 * shares its lock handle. This means that whenever you lock a SessionMachine
840 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
841 * instance is also locked in the same lock mode. Keep it in mind.
842 */
843class ATL_NO_VTABLE SessionMachine :
844 public VirtualBoxSupportTranslation <SessionMachine>,
845 public Machine,
846 public IInternalMachineControl
847{
848public:
849
850 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SessionMachine)
851
852 DECLARE_NOT_AGGREGATABLE(SessionMachine)
853
854 DECLARE_PROTECT_FINAL_CONSTRUCT()
855
856 BEGIN_COM_MAP(SessionMachine)
857 COM_INTERFACE_ENTRY(ISupportErrorInfo)
858 COM_INTERFACE_ENTRY(IMachine)
859 COM_INTERFACE_ENTRY(IInternalMachineControl)
860 END_COM_MAP()
861
862 NS_DECL_ISUPPORTS
863
864 DECLARE_EMPTY_CTOR_DTOR (SessionMachine)
865
866 HRESULT FinalConstruct();
867 void FinalRelease();
868
869 // public initializer/uninitializer for internal purposes only
870 HRESULT init (Machine *aMachine);
871 void uninit() { uninit (Uninit::Unexpected); }
872
873 // util::Lockable interface
874 RWLockHandle *lockHandle() const;
875
876 // IInternalMachineControl methods
877 STDMETHOD(UpdateState)(MachineState_T machineState);
878 STDMETHOD(GetIPCId)(BSTR *id);
879 STDMETHOD(RunUSBDeviceFilters) (IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
880 STDMETHOD(CaptureUSBDevice) (IN_GUID aId);
881 STDMETHOD(DetachUSBDevice) (IN_GUID aId, BOOL aDone);
882 STDMETHOD(AutoCaptureUSBDevices)();
883 STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
884 STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
885 STDMETHOD(BeginSavingState) (IProgress *aProgress, BSTR *aStateFilePath);
886 STDMETHOD(EndSavingState) (BOOL aSuccess);
887 STDMETHOD(AdoptSavedState) (IN_BSTR aSavedStateFile);
888 STDMETHOD(BeginTakingSnapshot) (IConsole *aInitiator,
889 IN_BSTR aName, IN_BSTR aDescription,
890 IProgress *aProgress, BSTR *aStateFilePath,
891 IProgress **aServerProgress);
892 STDMETHOD(EndTakingSnapshot) (BOOL aSuccess);
893 STDMETHOD(DiscardSnapshot) (IConsole *aInitiator, IN_GUID aId,
894 MachineState_T *aMachineState, IProgress **aProgress);
895 STDMETHOD(DiscardCurrentState) (
896 IConsole *aInitiator, MachineState_T *aMachineState, IProgress **aProgress);
897 STDMETHOD(DiscardCurrentSnapshotAndState) (
898 IConsole *aInitiator, MachineState_T *aMachineState, IProgress **aProgress);
899 STDMETHOD(PullGuestProperties) (ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
900 ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
901 STDMETHOD(PushGuestProperties) (ComSafeArrayIn(IN_BSTR, aNames), ComSafeArrayIn(IN_BSTR, aValues),
902 ComSafeArrayIn(ULONG64, aTimestamps), ComSafeArrayIn(IN_BSTR, aFlags));
903 STDMETHOD(PushGuestProperty) (IN_BSTR aName, IN_BSTR aValue,
904 ULONG64 aTimestamp, IN_BSTR aFlags);
905
906 // public methods only for internal purposes
907
908 bool checkForDeath();
909
910 HRESULT onDVDDriveChange();
911 HRESULT onFloppyDriveChange();
912 HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter);
913 HRESULT onSerialPortChange(ISerialPort *serialPort);
914 HRESULT onParallelPortChange(IParallelPort *parallelPort);
915 HRESULT onVRDPServerChange();
916 HRESULT onUSBControllerChange();
917 HRESULT onUSBDeviceAttach (IUSBDevice *aDevice,
918 IVirtualBoxErrorInfo *aError,
919 ULONG aMaskedIfs);
920 HRESULT onUSBDeviceDetach (IN_GUID aId,
921 IVirtualBoxErrorInfo *aError);
922 HRESULT onSharedFolderChange();
923
924 bool hasMatchingUSBFilter (const ComObjPtr <HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
925
926private:
927
928 struct SnapshotData
929 {
930 SnapshotData() : mLastState (MachineState_Null) {}
931
932 MachineState_T mLastState;
933
934 // used when taking snapshot
935 ComObjPtr <Snapshot> mSnapshot;
936 ComObjPtr <Progress> mServerProgress;
937 ComObjPtr <CombinedProgress> mCombinedProgress;
938
939 // used when saving state
940 Guid mProgressId;
941 Bstr mStateFilePath;
942 };
943
944 struct Uninit
945 {
946 enum Reason { Unexpected, Abnormal, Normal };
947 };
948
949 struct Task;
950 struct TakeSnapshotTask;
951 struct DiscardSnapshotTask;
952 struct DiscardCurrentStateTask;
953
954 friend struct TakeSnapshotTask;
955 friend struct DiscardSnapshotTask;
956 friend struct DiscardCurrentStateTask;
957
958 void uninit (Uninit::Reason aReason);
959
960 HRESULT endSavingState (BOOL aSuccess);
961 HRESULT endTakingSnapshot (BOOL aSuccess);
962
963 typedef std::map <ComObjPtr <Machine>, MachineState_T> AffectedMachines;
964
965 void takeSnapshotHandler (TakeSnapshotTask &aTask);
966 void discardSnapshotHandler (DiscardSnapshotTask &aTask);
967 void discardCurrentStateHandler (DiscardCurrentStateTask &aTask);
968
969 HRESULT setMachineState (MachineState_T aMachineState);
970 HRESULT updateMachineStateOnClient();
971
972 SnapshotData mSnapshotData;
973
974 /** interprocess semaphore handle for this machine */
975#if defined (RT_OS_WINDOWS)
976 HANDLE mIPCSem;
977 Bstr mIPCSemName;
978 friend bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
979 ComPtr <IInternalSessionControl> *aControl,
980 HANDLE *aIPCSem, bool aAllowClosing);
981#elif defined (RT_OS_OS2)
982 HMTX mIPCSem;
983 Bstr mIPCSemName;
984 friend bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
985 ComPtr <IInternalSessionControl> *aControl,
986 HMTX *aIPCSem, bool aAllowClosing);
987#elif defined (VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
988 int mIPCSem;
989#else
990# error "Port me!"
991#endif
992
993 static DECLCALLBACK(int) taskHandler (RTTHREAD thread, void *pvUser);
994};
995
996// SnapshotMachine class
997////////////////////////////////////////////////////////////////////////////////
998
999/**
1000 * @note Notes on locking objects of this class:
1001 * SnapshotMachine shares some data with the primary Machine instance (pointed
1002 * to by the |mPeer| member). In order to provide data consistency it also
1003 * shares its lock handle. This means that whenever you lock a SessionMachine
1004 * instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
1005 * instance is also locked in the same lock mode. Keep it in mind.
1006 */
1007class ATL_NO_VTABLE SnapshotMachine :
1008 public VirtualBoxSupportTranslation <SnapshotMachine>,
1009 public Machine
1010{
1011public:
1012
1013 VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SnapshotMachine)
1014
1015 DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
1016
1017 DECLARE_PROTECT_FINAL_CONSTRUCT()
1018
1019 BEGIN_COM_MAP(SnapshotMachine)
1020 COM_INTERFACE_ENTRY(ISupportErrorInfo)
1021 COM_INTERFACE_ENTRY(IMachine)
1022 END_COM_MAP()
1023
1024 NS_DECL_ISUPPORTS
1025
1026 DECLARE_EMPTY_CTOR_DTOR (SnapshotMachine)
1027
1028 HRESULT FinalConstruct();
1029 void FinalRelease();
1030
1031 // public initializer/uninitializer for internal purposes only
1032 HRESULT init (SessionMachine *aSessionMachine,
1033 IN_GUID aSnapshotId, IN_BSTR aStateFilePath);
1034 HRESULT init (Machine *aMachine,
1035 const settings::Key &aHWNode, const settings::Key &aHDAsNode,
1036 IN_GUID aSnapshotId, IN_BSTR aStateFilePath);
1037 void uninit();
1038
1039 // util::Lockable interface
1040 RWLockHandle *lockHandle() const;
1041
1042 // public methods only for internal purposes
1043
1044 HRESULT onSnapshotChange (Snapshot *aSnapshot);
1045
1046 // unsafe inline public methods for internal purposes only (ensure there is
1047 // a caller and a read lock before calling them!)
1048
1049 const Guid &snapshotId() const { return mSnapshotId; }
1050
1051private:
1052
1053 Guid mSnapshotId;
1054
1055 friend class Snapshot;
1056};
1057
1058// third party methods that depend on SnapshotMachine definiton
1059
1060inline const Guid &Machine::snapshotId() const
1061{
1062 return mType != IsSnapshotMachine ? Guid::Empty :
1063 static_cast <const SnapshotMachine *> (this)->snapshotId();
1064}
1065
1066////////////////////////////////////////////////////////////////////////////////
1067
1068/**
1069 * Returns a pointer to the Machine object for this machine that acts like a
1070 * parent for complex machine data objects such as shared folders, etc.
1071 *
1072 * For primary Machine objects and for SnapshotMachine objects, returns this
1073 * object's pointer itself. For SessoinMachine objects, returns the peer
1074 * (primary) machine pointer.
1075 */
1076inline Machine *Machine::machine()
1077{
1078 if (mType == IsSessionMachine)
1079 return mPeer;
1080 return this;
1081}
1082
1083#endif // ____H_MACHINEIMPL
1084/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use