MachineImpl.h revision 0a90c7a0df11e88ee3ac85afb235d7acedbb0af7
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/* $Id$ */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/** @file
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * VirtualBox COM class declaration
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/*
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Copyright (C) 2006-2009 Sun Microsystems, Inc.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * available from http://www.virtualbox.org. This file is free software;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * you can redistribute it and/or modify it under the terms of the GNU
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * General Public License (GPL) as published by the Free Software
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * additional information or have any questions.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#ifndef ____H_MACHINEIMPL
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#define ____H_MACHINEIMPL
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "VirtualBoxBase.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "ProgressImpl.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "SnapshotImpl.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "VRDPServerImpl.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "MediumAttachmentImpl.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "NetworkAdapterImpl.h"
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#include "AudioAdapterImpl.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "SerialPortImpl.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "ParallelPortImpl.h"
28626a5957b49791b505bf66131448a847043763vboxsync#include "BIOSSettingsImpl.h"
2f827df539da232220444c27f2b207a707a045b0vboxsync#include "StorageControllerImpl.h" // required for MachineImpl.h to compile on Windows
ae6cc8f82ba26e3940022ea7d26078bec3d2a05fvboxsync#ifdef VBOX_WITH_RESOURCE_USAGE_API
2f827df539da232220444c27f2b207a707a045b0vboxsync#include "PerformanceImpl.h"
2f827df539da232220444c27f2b207a707a045b0vboxsync#endif /* VBOX_WITH_RESOURCE_USAGE_API */
2f827df539da232220444c27f2b207a707a045b0vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// generated header
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "SchemaDefs.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync#include <VBox/types.h>
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync#include <iprt/file.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <iprt/thread.h>
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync#include <iprt/time.h>
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync#include <list>
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync// defines
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync////////////////////////////////////////////////////////////////////////////////
2f827df539da232220444c27f2b207a707a045b0vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync// helper declarations
2f827df539da232220444c27f2b207a707a045b0vboxsync////////////////////////////////////////////////////////////////////////////////
2f827df539da232220444c27f2b207a707a045b0vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass VirtualBox;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass Progress;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass Keyboard;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass Mouse;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass Display;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass MachineDebugger;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass USBController;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass Snapshot;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass SharedFolder;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass HostUSBDevice;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass StorageController;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass SessionMachine;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncnamespace settings
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync class MachineConfigFile;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync struct Snapshot;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync struct Hardware;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync struct Storage;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync struct StorageController;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync struct MachineRegistryEntry;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// Machine class
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync////////////////////////////////////////////////////////////////////////////////
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncclass ATL_NO_VTABLE Machine :
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync public VirtualBoxBaseWithChildrenNEXT,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync public VirtualBoxSupportErrorInfoImpl<Machine, IMachine>,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync public VirtualBoxSupportTranslation<Machine>,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync VBOX_SCRIPTABLE_IMPL(IMachine)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Q_OBJECT
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncpublic:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync enum InstanceType { IsMachine, IsSessionMachine, IsSnapshotMachine };
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync enum InitMode { Init_New, Init_Import, Init_Registered };
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /**
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Internal machine data.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Only one instance of this data exists per every machine -- it is shared
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * by the Machine, SessionMachine and all SnapshotMachine instances
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * associated with the given machine using the util::Shareable template
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * through the mData variable.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync * @note |const| members are persistent during lifetime so can be
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync * accessed without locking.
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync *
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync * @note There is no need to lock anything inside init() or uninit()
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync * methods, because they are always serialized (see AutoCaller).
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync */
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync struct Data
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync {
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync /**
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync * Data structure to hold information about sessions opened for the
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync * given machine.
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync */
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync struct Session
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync {
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync /** Control of the direct session opened by openSession() */
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync ComPtr<IInternalSessionControl> mDirectControl;
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync typedef std::list<ComPtr<IInternalSessionControl> > RemoteControlList;
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /** list of controls of all opened remote sessions */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RemoteControlList mRemoteControls;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /** openRemoteSession() and OnSessionEnd() progress indicator */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComObjPtr<Progress> mProgress;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /**
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * PID of the session object that must be passed to openSession() to
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * finalize the openRemoteSession() request (i.e., PID of the
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * process created by openRemoteSession())
2f827df539da232220444c27f2b207a707a045b0vboxsync */
2f827df539da232220444c27f2b207a707a045b0vboxsync RTPROCESS mPid;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync /** Current session state */
2f827df539da232220444c27f2b207a707a045b0vboxsync SessionState_T mState;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /** Session type string (for indirect sessions) */
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync Bstr mType;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /** Session machine object */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComObjPtr<SessionMachine> mMachine;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /**
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Successfully locked media list. The 2nd value in the pair is true
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * if the medium is locked for writing and false if locked for
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * reading.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync typedef std::list<std::pair<ComPtr<IMedium>, bool > > LockedMedia;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync LockedMedia mLockedMedia;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync };
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Data();
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ~Data();
2f827df539da232220444c27f2b207a707a045b0vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync const Guid mUuid;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync BOOL mRegistered;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync InitMode mInitMode;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync /** Flag indicating that the config file is read-only. */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync BOOL mConfigFileReadonly;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Utf8Str m_strConfigFile;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Utf8Str m_strConfigFileFull;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync // machine settings XML file
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync settings::MachineConfigFile *m_pMachineConfigFile;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync BOOL mAccessible;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync com::ErrorInfo mAccessError;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync MachineState_T mMachineState;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTTIMESPEC mLastStateChange;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /* Note: These are guarded by VirtualBoxBase::stateLockHandle() */
38754ce3fec7064c34ccedb1dbce89cdfba65953vboxsync uint32_t mMachineStateDeps;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTSEMEVENTMULTI mMachineStateDepsSem;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync uint32_t mMachineStateChangePending;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mCurrentStateModified;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTFILE mHandleCfgFile;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Session mSession;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComObjPtr<Snapshot> mFirstSnapshot;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ComObjPtr<Snapshot> mCurrentSnapshot;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync // protectes the snapshots tree of this machine
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RWLockHandle mSnapshotsTreeLockHandle;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync };
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /**
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Saved state data.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * It's actually only the state file path string, but it needs to be
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * separate from Data, because Machine and SessionMachine instances
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * share it, while SnapshotMachine does not.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * The data variable is |mSSData|.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync */
2f827df539da232220444c27f2b207a707a045b0vboxsync struct SSData
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Bstr mStateFilePath;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync };
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync /**
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * User changeable machine data.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * This data is common for all machine snapshots, i.e. it is shared
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * by all SnapshotMachine instances associated with the given machine
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * using the util::Backupable template through the |mUserData| variable.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * SessionMachine instances can alter this data and discard changes.
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * @note There is no need to lock anything inside init() or uninit()
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * methods, because they are always serialized (see AutoCaller).
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync struct UserData
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync UserData();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ~UserData();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync bool operator==(const UserData &that) const
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync return this == &that
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync || ( mName == that.mName
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mNameSync == that.mNameSync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mDescription == that.mDescription
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mOSTypeId == that.mOSTypeId
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mSnapshotFolderFull == that.mSnapshotFolderFull
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mTeleporterEnabled == that.mTeleporterEnabled
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mTeleporterPort == that.mTeleporterPort
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mTeleporterAddress == that.mTeleporterAddress
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync && mTeleporterPassword == that.mTeleporterPassword);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mName;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync BOOL mNameSync;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mDescription;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mOSTypeId;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mSnapshotFolder;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mSnapshotFolderFull;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mTeleporterEnabled;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mTeleporterPort;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mTeleporterAddress;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mTeleporterPassword;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync };
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /**
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Hardware data.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * This data is unique for a machine and for every machine snapshot.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Stored using the util::Backupable template in the |mHWData| variable.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * SessionMachine instances can alter this data and discard changes.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync struct HWData
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /**
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Data structure to hold information about a guest property.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync struct GuestProperty {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /** Property name */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Utf8Str strName;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /** Property value */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Utf8Str strValue;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /** Property timestamp */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG64 mTimestamp;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /** Property flags */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mFlags;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync };
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync HWData();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ~HWData();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync bool operator==(const HWData &that) const;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mHWVersion;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mMemorySize;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ULONG mMemoryBalloonSize;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mStatisticsUpdateInterval;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mVRAMSize;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mMonitorCount;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync BOOL mHWVirtExEnabled;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mHWVirtExExclusive;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mHWVirtExNestedPagingEnabled;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mHWVirtExVPIDEnabled;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mAccelerate2DVideoEnabled;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mPAEEnabled;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mSyntheticCpu;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ULONG mCPUCount;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mAccelerate3DEnabled;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync DeviceType_T mBootOrder[SchemaDefs::MaxBootPosition];
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync typedef std::list< ComObjPtr<SharedFolder> > SharedFolderList;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync SharedFolderList mSharedFolders;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ClipboardMode_T mClipboardMode;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync typedef std::list<GuestProperty> GuestPropertyList;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync GuestPropertyList mGuestProperties;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL mPropertyServiceActive;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Bstr mGuestPropertyNotificationPatterns;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync FirmwareType_T mFirmwareType;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync };
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /**
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Hard disk and other media data.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * The usage policy is the same as for HWData, but a separate structure
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * is necessary because hard disk data requires different procedures when
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * taking or discarding snapshots, etc.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * The data variable is |mMediaData|.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync struct MediaData
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync MediaData();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ~MediaData();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync bool operator==(const MediaData &that) const;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync typedef std::list< ComObjPtr<MediumAttachment> > AttachmentList;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync AttachmentList mAttachments;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync };
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync enum StateDependency
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync AnyStateDep = 0, MutableStateDep, MutableOrSavedStateDep
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync };
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /**
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Helper class that safely manages the machine state dependency by
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * calling Machine::addStateDependency() on construction and
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Machine::releaseStateDependency() on destruction. Intended for Machine
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * children. The usage pattern is:
2f827df539da232220444c27f2b207a707a045b0vboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * @code
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * AutoCaller autoCaller(this);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * CheckComRCReturnRC(autoCaller.rc());
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Machine::AutoStateDependency<MutableStateDep> adep(mParent);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * CheckComRCReturnRC(stateDep.rc());
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * ...
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * // code that depends on the particular machine state
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * ...
2f827df539da232220444c27f2b207a707a045b0vboxsync * @endcode
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Note that it is more convenient to use the following individual
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * shortcut classes instead of using this template directly:
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * AutoAnyStateDependency, AutoMutableStateDependency and
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * AutoMutableOrSavedStateDependency. The usage pattern is exactly the
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * same as above except that there is no need to specify the template
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * argument because it is already done by the shortcut class.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @param taDepType Dependecy type to manage.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync template <StateDependency taDepType = AnyStateDep>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync class AutoStateDependency
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync public:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync AutoStateDependency(Machine *aThat)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync : mThat(aThat), mRC(S_OK)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync , mMachineState(MachineState_Null)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync , mRegistered(FALSE)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Assert(aThat);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync mRC = aThat->addStateDependency(taDepType, &mMachineState,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync &mRegistered);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ~AutoStateDependency()
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (SUCCEEDED(mRC))
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync mThat->releaseStateDependency();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /** Decreases the number of dependencies before the instance is
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * destroyed. Note that will reset #rc() to E_FAIL. */
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync void release()
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync AssertReturnVoid(SUCCEEDED(mRC));
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync mThat->releaseStateDependency();
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync mRC = E_FAIL;
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync /** Restores the number of callers after by #release(). #rc() will be
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * reset to the result of calling addStateDependency() and must be
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * rechecked to ensure the operation succeeded. */
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync void add()
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
7cc5e93b9f64360aceb38f7ff4c756a5d8475009vboxsync AssertReturnVoid(!SUCCEEDED(mRC));
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync mRC = mThat->addStateDependency(taDepType, &mMachineState,
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync &mRegistered);
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync /** Returns the result of Machine::addStateDependency(). */
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync HRESULT rc() const { return mRC; }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /** Shortcut to SUCCEEDED(rc()). */
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync bool isOk() const { return SUCCEEDED(mRC); }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync /** Returns the machine state value as returned by
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync * Machine::addStateDependency(). */
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync MachineState_T machineState() const { return mMachineState; }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync /** Returns the machine state value as returned by
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * Machine::addStateDependency(). */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync BOOL machineRegistered() const { return mRegistered; }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync protected:
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync Machine *mThat;
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync HRESULT mRC;
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync MachineState_T mMachineState;
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync BOOL mRegistered;
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync private:
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AutoStateDependency)
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync DECLARE_CLS_NEW_DELETE_NOOP(AutoStateDependency)
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync };
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync /**
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * Shortcut to AutoStateDependency<AnyStateDep>.
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * See AutoStateDependency to get the usage pattern.
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync *
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * Accepts any machine state and guarantees the state won't change before
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * this object is destroyed. If the machine state cannot be protected (as
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * a result of the state change currently in progress), this instance's
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * #rc() method will indicate a failure, and the caller is not allowed to
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * rely on any particular machine state and should return the failed
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * result code to the upper level.
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync typedef AutoStateDependency<AnyStateDep> AutoAnyStateDependency;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync /**
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * Shortcut to AutoStateDependency<MutableStateDep>.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * See AutoStateDependency to get the usage pattern.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * Succeeds only if the machine state is in one of the mutable states, and
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * guarantees the given mutable state won't change before this object is
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * destroyed. If the machine is not mutable, this instance's #rc() method
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync * will indicate a failure, and the caller is not allowed to rely on any
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * particular machine state and should return the failed result code to
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync * the upper level.
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync *
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * Intended to be used within all setter methods of IMachine
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * children objects (DVDDrive, NetworkAdapter, AudioAdapter, etc.) to
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync * provide data protection and consistency.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync typedef AutoStateDependency<MutableStateDep> AutoMutableStateDependency;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /**
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Shortcut to AutoStateDependency<MutableOrSavedStateDep>.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * See AutoStateDependency to get the usage pattern.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Succeeds only if the machine state is in one of the mutable states, or
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * if the machine is in the Saved state, and guarantees the given mutable
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * state won't change before this object is destroyed. If the machine is
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * not mutable, this instance's #rc() method will indicate a failure, and
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * the caller is not allowed to rely on any particular machine state and
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * should return the failed result code to the upper level.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Intended to be used within setter methods of IMachine
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * children objects that may also operate on Saved machines.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync typedef AutoStateDependency<MutableOrSavedStateDep> AutoMutableOrSavedStateDependency;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Machine)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync DECLARE_NOT_AGGREGATABLE(Machine)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync DECLARE_PROTECT_FINAL_CONSTRUCT()
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync BEGIN_COM_MAP(Machine)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync COM_INTERFACE_ENTRY(ISupportErrorInfo)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync COM_INTERFACE_ENTRY(IMachine)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync COM_INTERFACE_ENTRY(IDispatch)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync END_COM_MAP()
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync DECLARE_EMPTY_CTOR_DTOR(Machine)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync HRESULT FinalConstruct();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync void FinalRelease();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // public initializer/uninitializer for internal purposes only
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync HRESULT init(VirtualBox *aParent,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync const Utf8Str &strConfigFile,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync InitMode aMode,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CBSTR aName = NULL,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync GuestOSType *aOsType = NULL,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync BOOL aNameSync = TRUE,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync const Guid *aId = NULL);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync void uninit();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncprotected:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync HRESULT initDataAndChildObjects();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync void uninitDataAndChildObjects();
public:
// IMachine properties
STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible);
STDMETHOD(COMGETTER(AccessError))(IVirtualBoxErrorInfo **aAccessError);
STDMETHOD(COMGETTER(Name))(BSTR *aName);
STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
STDMETHOD(COMGETTER(Id))(BSTR *aId);
STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId);
STDMETHOD(COMSETTER(OSTypeId))(IN_BSTR aOSTypeId);
STDMETHOD(COMGETTER(HardwareVersion))(BSTR *aVersion);
STDMETHOD(COMSETTER(HardwareVersion))(IN_BSTR aVersion);
STDMETHOD(COMGETTER(MemorySize))(ULONG *memorySize);
STDMETHOD(COMSETTER(MemorySize))(ULONG memorySize);
STDMETHOD(COMGETTER(CPUCount))(ULONG *cpuCount);
STDMETHOD(COMSETTER(CPUCount))(ULONG cpuCount);
STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *memoryBalloonSize);
STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG memoryBalloonSize);
STDMETHOD(COMGETTER(StatisticsUpdateInterval))(ULONG *statisticsUpdateInterval);
STDMETHOD(COMSETTER(StatisticsUpdateInterval))(ULONG statisticsUpdateInterval);
STDMETHOD(COMGETTER(VRAMSize))(ULONG *memorySize);
STDMETHOD(COMSETTER(VRAMSize))(ULONG memorySize);
STDMETHOD(COMGETTER(MonitorCount))(ULONG *monitorCount);
STDMETHOD(COMSETTER(MonitorCount))(ULONG monitorCount);
STDMETHOD(COMGETTER(Accelerate3DEnabled))(BOOL *enabled);
STDMETHOD(COMSETTER(Accelerate3DEnabled))(BOOL enabled);
STDMETHOD(COMGETTER(Accelerate2DVideoEnabled))(BOOL *enabled);
STDMETHOD(COMSETTER(Accelerate2DVideoEnabled))(BOOL enabled);
STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **biosSettings);
STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSavedStateFolder);
STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSavedStateFolder);
STDMETHOD(COMGETTER(MediumAttachments))(ComSafeArrayOut(IMediumAttachment *, aAttachments));
STDMETHOD(COMGETTER(VRDPServer))(IVRDPServer **vrdpServer);
STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **audioAdapter);
STDMETHOD(COMGETTER(USBController))(IUSBController * *aUSBController);
STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aFilePath);
STDMETHOD(COMGETTER(SettingsModified))(BOOL *aModified);
STDMETHOD(COMGETTER(SessionState))(SessionState_T *aSessionState);
STDMETHOD(COMGETTER(SessionType))(BSTR *aSessionType);
STDMETHOD(COMGETTER(SessionPid))(ULONG *aSessionPid);
STDMETHOD(COMGETTER(State))(MachineState_T *machineState);
STDMETHOD(COMGETTER(LastStateChange))(LONG64 *aLastStateChange);
STDMETHOD(COMGETTER(StateFilePath))(BSTR *aStateFilePath);
STDMETHOD(COMGETTER(LogFolder))(BSTR *aLogFolder);
STDMETHOD(COMGETTER(CurrentSnapshot))(ISnapshot **aCurrentSnapshot);
STDMETHOD(COMGETTER(SnapshotCount))(ULONG *aSnapshotCount);
STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
STDMETHOD(COMGETTER(ClipboardMode))(ClipboardMode_T *aClipboardMode);
STDMETHOD(COMSETTER(ClipboardMode))(ClipboardMode_T aClipboardMode);
STDMETHOD(COMGETTER(GuestPropertyNotificationPatterns))(BSTR *aPattern);
STDMETHOD(COMSETTER(GuestPropertyNotificationPatterns))(IN_BSTR aPattern);
STDMETHOD(COMGETTER(StorageControllers))(ComSafeArrayOut(IStorageController *, aStorageControllers));
STDMETHOD(COMGETTER(TeleporterEnabled))(BOOL *aEnabled);
STDMETHOD(COMSETTER(TeleporterEnabled))(BOOL aEnabled);
STDMETHOD(COMGETTER(TeleporterPort))(ULONG *aPort);
STDMETHOD(COMSETTER(TeleporterPort))(ULONG aPort);
STDMETHOD(COMGETTER(TeleporterAddress))(BSTR *aAddress);
STDMETHOD(COMSETTER(TeleporterAddress))(IN_BSTR aAddress);
STDMETHOD(COMGETTER(TeleporterPassword))(BSTR *aPassword);
STDMETHOD(COMSETTER(TeleporterPassword))(IN_BSTR aPassword);
// IMachine methods
STDMETHOD(SetBootOrder)(ULONG aPosition, DeviceType_T aDevice);
STDMETHOD(GetBootOrder)(ULONG aPosition, DeviceType_T *aDevice);
STDMETHOD(AttachDevice)(IN_BSTR aControllerName, LONG aControllerPort,
LONG aDevice, DeviceType_T aType, IN_BSTR aId);
STDMETHOD(DetachDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice);
STDMETHOD(PassthroughDevice)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice, BOOL aPassthrough);
STDMETHOD(MountMedium)(IN_BSTR aControllerName, LONG aControllerPort,
LONG aDevice, IN_BSTR aId);
STDMETHOD(GetMedium)(IN_BSTR aControllerName, LONG aControllerPort, LONG aDevice,
IMedium **aMedium);
STDMETHOD(GetSerialPort)(ULONG slot, ISerialPort **port);
STDMETHOD(GetParallelPort)(ULONG slot, IParallelPort **port);
STDMETHOD(GetNetworkAdapter)(ULONG slot, INetworkAdapter **adapter);
STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
STDMETHOD(GetExtraData)(IN_BSTR aKey, BSTR *aValue);
STDMETHOD(SetExtraData)(IN_BSTR aKey, IN_BSTR aValue);
STDMETHOD(GetCpuProperty)(CpuPropertyType_T property, BOOL *aVal);
STDMETHOD(SetCpuProperty)(CpuPropertyType_T property, BOOL aVal);
STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL *aVal);
STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T property, BOOL aVal);
STDMETHOD(SaveSettings)();
STDMETHOD(DiscardSettings)();
STDMETHOD(DeleteSettings)();
STDMETHOD(Export)(IAppliance *aAppliance, IVirtualSystemDescription **aDescription);
STDMETHOD(GetSnapshot)(IN_BSTR aId, ISnapshot **aSnapshot);
STDMETHOD(FindSnapshot)(IN_BSTR aName, ISnapshot **aSnapshot);
STDMETHOD(SetCurrentSnapshot)(IN_BSTR aId);
STDMETHOD(CreateSharedFolder)(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable);
STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
STDMETHOD(CanShowConsoleWindow)(BOOL *aCanShow);
STDMETHOD(ShowConsoleWindow)(ULONG64 *aWinId);
STDMETHOD(GetGuestProperty)(IN_BSTR aName, BSTR *aValue, ULONG64 *aTimestamp, BSTR *aFlags);
STDMETHOD(GetGuestPropertyValue)(IN_BSTR aName, BSTR *aValue);
STDMETHOD(GetGuestPropertyTimestamp)(IN_BSTR aName, ULONG64 *aTimestamp);
STDMETHOD(SetGuestProperty)(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags);
STDMETHOD(SetGuestPropertyValue)(IN_BSTR aName, IN_BSTR aValue);
STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPattern, ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues), ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
STDMETHOD(GetMediumAttachmentsOfController)(IN_BSTR aName, ComSafeArrayOut(IMediumAttachment *, aAttachments));
STDMETHOD(GetMediumAttachment)(IN_BSTR aConstrollerName, LONG aControllerPort, LONG aDevice, IMediumAttachment **aAttachment);
STDMETHOD(AddStorageController)(IN_BSTR aName, StorageBus_T aConnectionType, IStorageController **controller);
STDMETHOD(RemoveStorageController(IN_BSTR aName));
STDMETHOD(GetStorageControllerByName(IN_BSTR aName, IStorageController **storageController));
STDMETHOD(COMGETTER(FirmwareType)) (FirmwareType_T *aFirmware);
STDMETHOD(COMSETTER(FirmwareType)) (FirmwareType_T aFirmware);
// public methods only for internal purposes
InstanceType type() const { return mType; }
/// @todo (dmik) add lock and make non-inlined after revising classes
// that use it. Note: they should enter Machine lock to keep the returned
// information valid!
bool isRegistered() { return !!mData->mRegistered; }
// unsafe inline public methods for internal purposes only (ensure there is
// a caller and a read lock before calling them!)
/**
* Returns the VirtualBox object this machine belongs to.
*
* @note This method doesn't check this object's readiness. Intended to be
* used by ready Machine children (whose readiness is bound to the parent's
* one) or after doing addCaller() manually.
*/
const ComObjPtr<VirtualBox, ComWeakRef> &virtualBox() const { return mParent; }
/**
* Returns this machine ID.
*
* @note This method doesn't check this object's readiness. Intended to be
* used by ready Machine children (whose readiness is bound to the parent's
* one) or after adding a caller manually.
*/
const Guid &id() const { return mData->mUuid; }
/**
* Returns the snapshot ID this machine represents or an empty UUID if this
* instance is not SnapshotMachine.
*
* @note This method doesn't check this object's readiness. Intended to be
* used by ready Machine children (whose readiness is bound to the parent's
* one) or after adding a caller manually.
*/
inline const Guid &snapshotId() const;
/**
* Returns this machine's full settings file path.
*
* @note This method doesn't lock this object or check its readiness.
* Intended to be used only after doing addCaller() manually and locking it
* for reading.
*/
const Utf8Str &settingsFileFull() const { return mData->m_strConfigFileFull; }
/**
* Returns this machine name.
*
* @note This method doesn't lock this object or check its readiness.
* Intended to be used only after doing addCaller() manually and locking it
* for reading.
*/
const Bstr &name() const { return mUserData->mName; }
// callback handlers
virtual HRESULT onNetworkAdapterChange(INetworkAdapter * /* networkAdapter */, BOOL /* changeAdapter */) { return S_OK; }
virtual HRESULT onSerialPortChange(ISerialPort * /* serialPort */) { return S_OK; }
virtual HRESULT onParallelPortChange(IParallelPort * /* parallelPort */) { return S_OK; }
virtual HRESULT onVRDPServerChange() { return S_OK; }
virtual HRESULT onUSBControllerChange() { return S_OK; }
virtual HRESULT onStorageControllerChange() { return S_OK; }
virtual HRESULT onMediumChange(IMediumAttachment * /* mediumAttachment */) { return S_OK; }
virtual HRESULT onSharedFolderChange() { return S_OK; }
HRESULT saveRegistryEntry(settings::MachineRegistryEntry &data);
int calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult);
void calculateRelativePath(const Utf8Str &strPath, Utf8Str &aResult);
void getLogFolder(Utf8Str &aLogFolder);
HRESULT openSession(IInternalSessionControl *aControl);
HRESULT openRemoteSession(IInternalSessionControl *aControl,
IN_BSTR aType, IN_BSTR aEnvironment,
Progress *aProgress);
HRESULT openExistingSession(IInternalSessionControl *aControl);
#if defined(RT_OS_WINDOWS)
bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl = NULL,
HANDLE *aIPCSem = NULL, bool aAllowClosing = false);
bool isSessionSpawning(RTPROCESS *aPID = NULL);
bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl = NULL,
HANDLE *aIPCSem = NULL)
{ return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
#elif defined(RT_OS_OS2)
bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl = NULL,
HMTX *aIPCSem = NULL, bool aAllowClosing = false);
bool isSessionSpawning(RTPROCESS *aPID = NULL);
bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl = NULL,
HMTX *aIPCSem = NULL)
{ return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
#else
bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl = NULL,
bool aAllowClosing = false);
bool isSessionSpawning();
bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl = NULL)
{ return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
#endif
bool checkForSpawnFailure();
HRESULT trySetRegistered(BOOL aRegistered);
HRESULT getSharedFolder(CBSTR aName,
ComObjPtr<SharedFolder> &aSharedFolder,
bool aSetError = false)
{
AutoWriteLock alock(this);
return findSharedFolder(aName, aSharedFolder, aSetError);
}
HRESULT addStateDependency(StateDependency aDepType = AnyStateDep,
MachineState_T *aState = NULL,
BOOL *aRegistered = NULL);
void releaseStateDependency();
// for VirtualBoxSupportErrorInfoImpl
static const wchar_t *getComponentName() { return L"Machine"; }
/**
* Returns the handle of the snapshots tree lock. This lock is
* machine-specific because there is one snapshots tree per
* IMachine; the lock protects the "first snapshot" member in
* IMachine and all the children and parent links in snapshot
* objects pointed to therefrom.
*
* Locking order:
* a) object lock of the machine;
* b) snapshots tree lock of the machine;
* c) individual snapshot object locks in parent->child order,
* if needed; they are _not_ needed for the tree itself
* (as defined above).
*/
RWLockHandle* snapshotsTreeLockHandle() const
{
return &mData->mSnapshotsTreeLockHandle;
}
protected:
HRESULT registeredInit();
HRESULT checkStateDependency(StateDependency aDepType);
inline Machine *machine();
void ensureNoStateDependencies();
virtual HRESULT setMachineState(MachineState_T aMachineState);
HRESULT findSharedFolder(CBSTR aName,
ComObjPtr<SharedFolder> &aSharedFolder,
bool aSetError = false);
HRESULT loadSettings(bool aRegistered);
HRESULT loadSnapshot(const settings::Snapshot &data,
const Guid &aCurSnapshotId,
Snapshot *aParentSnapshot);
HRESULT loadHardware(const settings::Hardware &data);
HRESULT loadStorageControllers(const settings::Storage &data,
bool aRegistered,
const Guid *aSnapshotId = NULL);
HRESULT loadStorageDevices(StorageController *aStorageController,
const settings::StorageController &data,
bool aRegistered,
const Guid *aSnapshotId = NULL);
HRESULT findSnapshot(const Guid &aId, ComObjPtr<Snapshot> &aSnapshot,
bool aSetError = false);
HRESULT findSnapshot(IN_BSTR aName, ComObjPtr<Snapshot> &aSnapshot,
bool aSetError = false);
HRESULT getStorageControllerByName(const Utf8Str &aName,
ComObjPtr<StorageController> &aStorageController,
bool aSetError = false);
HRESULT getMediumAttachmentsOfController(CBSTR aName,
MediaData::AttachmentList &aAttachments);
enum
{
/* flags for #saveSettings() */
SaveS_ResetCurStateModified = 0x01,
SaveS_InformCallbacksAnyway = 0x02,
/* flags for #saveSnapshotSettings() */
SaveSS_CurStateModified = 0x40,
SaveSS_CurrentId = 0x80,
/* flags for #saveStateSettings() */
SaveSTS_CurStateModified = 0x20,
SaveSTS_StateFilePath = 0x40,
SaveSTS_StateTimeStamp = 0x80,
};
HRESULT prepareSaveSettings(bool &aRenamed, bool &aNew);
HRESULT saveSettings(int aFlags = 0);
HRESULT saveAllSnapshots();
HRESULT saveHardware(settings::Hardware &data);
HRESULT saveStorageControllers(settings::Storage &data);
HRESULT saveStorageDevices(ComObjPtr<StorageController> aStorageController,
settings::StorageController &data);
HRESULT saveStateSettings(int aFlags);
HRESULT createImplicitDiffs(const Bstr &aFolder,
IProgress *aProgress,
ULONG aWeight,
bool aOnline);
HRESULT deleteImplicitDiffs();
MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
IN_BSTR aControllerName,
LONG aControllerPort,
LONG aDevice);
MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
ComObjPtr<Medium> pMedium);
MediumAttachment* findAttachment(const MediaData::AttachmentList &ll,
Guid &id);
void fixupMedia(bool aCommit, bool aOnline = false);
bool isInOwnDir(Utf8Str *aSettingsDir = NULL);
bool isModified();
bool isReallyModified(bool aIgnoreUserData = false);
void rollback(bool aNotify);
void commit();
void copyFrom(Machine *aThat);
#ifdef VBOX_WITH_RESOURCE_USAGE_API
void registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid);
void unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine);
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
const InstanceType mType;
const ComObjPtr<Machine, ComWeakRef> mPeer;
const ComObjPtr<VirtualBox, ComWeakRef> mParent;
Shareable<Data> mData;
Shareable<SSData> mSSData;
Backupable<UserData> mUserData;
Backupable<HWData> mHWData;
Backupable<MediaData> mMediaData;
// the following fields need special backup/rollback/commit handling,
// so they cannot be a part of HWData
const ComObjPtr<VRDPServer> mVRDPServer;
const ComObjPtr<SerialPort>
mSerialPorts [SchemaDefs::SerialPortCount];
const ComObjPtr<ParallelPort>
mParallelPorts [SchemaDefs::ParallelPortCount];
const ComObjPtr<AudioAdapter> mAudioAdapter;
const ComObjPtr<USBController> mUSBController;
const ComObjPtr<BIOSSettings> mBIOSSettings;
const ComObjPtr<NetworkAdapter>
mNetworkAdapters [SchemaDefs::NetworkAdapterCount];
typedef std::list< ComObjPtr<StorageController> > StorageControllerList;
Backupable<StorageControllerList> mStorageControllers;
friend class SessionMachine;
friend class SnapshotMachine;
};
// SessionMachine class
////////////////////////////////////////////////////////////////////////////////
/**
* @note Notes on locking objects of this class:
* SessionMachine shares some data with the primary Machine instance (pointed
* to by the |mPeer| member). In order to provide data consistency it also
* shares its lock handle. This means that whenever you lock a SessionMachine
* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
* instance is also locked in the same lock mode. Keep it in mind.
*/
class ATL_NO_VTABLE SessionMachine :
public VirtualBoxSupportTranslation<SessionMachine>,
public Machine,
VBOX_SCRIPTABLE_IMPL(IInternalMachineControl)
{
public:
VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SessionMachine)
DECLARE_NOT_AGGREGATABLE(SessionMachine)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(SessionMachine)
COM_INTERFACE_ENTRY2(IDispatch, IMachine)
COM_INTERFACE_ENTRY(ISupportErrorInfo)
COM_INTERFACE_ENTRY(IMachine)
COM_INTERFACE_ENTRY(IInternalMachineControl)
END_COM_MAP()
DECLARE_EMPTY_CTOR_DTOR(SessionMachine)
HRESULT FinalConstruct();
void FinalRelease();
// public initializer/uninitializer for internal purposes only
HRESULT init(Machine *aMachine);
void uninit() { uninit(Uninit::Unexpected); }
// util::Lockable interface
RWLockHandle *lockHandle() const;
// IInternalMachineControl methods
STDMETHOD(SetRemoveSavedState)(BOOL aRemove);
STDMETHOD(UpdateState)(MachineState_T machineState);
STDMETHOD(GetIPCId)(BSTR *id);
STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aUSBDevice, BOOL *aMatched, ULONG *aMaskedIfs);
STDMETHOD(CaptureUSBDevice)(IN_BSTR aId);
STDMETHOD(DetachUSBDevice)(IN_BSTR aId, BOOL aDone);
STDMETHOD(AutoCaptureUSBDevices)();
STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
STDMETHOD(OnSessionEnd)(ISession *aSession, IProgress **aProgress);
STDMETHOD(BeginSavingState)(IProgress *aProgress, BSTR *aStateFilePath);
STDMETHOD(EndSavingState)(BOOL aSuccess);
STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
STDMETHOD(BeginTakingSnapshot)(IConsole *aInitiator,
IN_BSTR aName,
IN_BSTR aDescription,
IProgress *aConsoleProgress,
BOOL fTakingSnapshotOnline,
BSTR *aStateFilePath);
STDMETHOD(EndTakingSnapshot)(BOOL aSuccess);
STDMETHOD(DeleteSnapshot)(IConsole *aInitiator, IN_BSTR aId,
MachineState_T *aMachineState, IProgress **aProgress);
STDMETHOD(RestoreSnapshot)(IConsole *aInitiator,
ISnapshot *aSnapshot,
MachineState_T *aMachineState,
IProgress **aProgress);
STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames), ComSafeArrayOut(BSTR, aValues),
ComSafeArrayOut(ULONG64, aTimestamps), ComSafeArrayOut(BSTR, aFlags));
STDMETHOD(PushGuestProperties)(ComSafeArrayIn(IN_BSTR, aNames), ComSafeArrayIn(IN_BSTR, aValues),
ComSafeArrayIn(ULONG64, aTimestamps), ComSafeArrayIn(IN_BSTR, aFlags));
STDMETHOD(PushGuestProperty)(IN_BSTR aName, IN_BSTR aValue,
ULONG64 aTimestamp, IN_BSTR aFlags);
STDMETHOD(LockMedia)() { return lockMedia(); }
// public methods only for internal purposes
bool checkForDeath();
HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
HRESULT onStorageControllerChange();
HRESULT onMediumChange(IMediumAttachment *aMediumAttachment);
HRESULT onSerialPortChange(ISerialPort *serialPort);
HRESULT onParallelPortChange(IParallelPort *parallelPort);
HRESULT onVRDPServerChange();
HRESULT onUSBControllerChange();
HRESULT onUSBDeviceAttach(IUSBDevice *aDevice,
IVirtualBoxErrorInfo *aError,
ULONG aMaskedIfs);
HRESULT onUSBDeviceDetach(IN_BSTR aId,
IVirtualBoxErrorInfo *aError);
HRESULT onSharedFolderChange();
bool hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs);
private:
struct SnapshotData
{
SnapshotData() : mLastState(MachineState_Null) {}
MachineState_T mLastState;
// used when taking snapshot
ComObjPtr<Snapshot> mSnapshot;
// used when saving state
Guid mProgressId;
Bstr mStateFilePath;
};
struct Uninit
{
enum Reason { Unexpected, Abnormal, Normal };
};
struct Task;
struct DeleteSnapshotTask;
struct RestoreSnapshotTask;
friend struct DeleteSnapshotTask;
friend struct RestoreSnapshotTask;
void uninit(Uninit::Reason aReason);
HRESULT endSavingState(BOOL aSuccess);
HRESULT endTakingSnapshot(BOOL aSuccess);
typedef std::map<ComObjPtr<Machine>, MachineState_T> AffectedMachines;
void deleteSnapshotHandler(DeleteSnapshotTask &aTask);
void restoreSnapshotHandler(RestoreSnapshotTask &aTask);
HRESULT lockMedia();
void unlockMedia();
HRESULT setMachineState(MachineState_T aMachineState);
HRESULT updateMachineStateOnClient();
HRESULT mRemoveSavedState;
SnapshotData mSnapshotData;
/** interprocess semaphore handle for this machine */
#if defined(RT_OS_WINDOWS)
HANDLE mIPCSem;
Bstr mIPCSemName;
friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl,
HANDLE *aIPCSem, bool aAllowClosing);
#elif defined(RT_OS_OS2)
HMTX mIPCSem;
Bstr mIPCSemName;
friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
ComPtr<IInternalSessionControl> *aControl,
HMTX *aIPCSem, bool aAllowClosing);
#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
int mIPCSem;
# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
Bstr mIPCKey;
# endif /*VBOX_WITH_NEW_SYS_V_KEYGEN */
#else
# error "Port me!"
#endif
static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);
};
// SnapshotMachine class
////////////////////////////////////////////////////////////////////////////////
/**
* @note Notes on locking objects of this class:
* SnapshotMachine shares some data with the primary Machine instance (pointed
* to by the |mPeer| member). In order to provide data consistency it also
* shares its lock handle. This means that whenever you lock a SessionMachine
* instance using Auto[Reader]Lock or AutoMultiLock, the corresponding Machine
* instance is also locked in the same lock mode. Keep it in mind.
*/
class ATL_NO_VTABLE SnapshotMachine :
public VirtualBoxSupportTranslation<SnapshotMachine>,
public Machine
{
public:
VIRTUALBOXSUPPORTTRANSLATION_OVERRIDE(SnapshotMachine)
DECLARE_NOT_AGGREGATABLE(SnapshotMachine)
DECLARE_PROTECT_FINAL_CONSTRUCT()
BEGIN_COM_MAP(SnapshotMachine)
COM_INTERFACE_ENTRY2(IDispatch, IMachine)
COM_INTERFACE_ENTRY(ISupportErrorInfo)
COM_INTERFACE_ENTRY(IMachine)
END_COM_MAP()
DECLARE_EMPTY_CTOR_DTOR(SnapshotMachine)
HRESULT FinalConstruct();
void FinalRelease();
// public initializer/uninitializer for internal purposes only
HRESULT init(SessionMachine *aSessionMachine,
IN_GUID aSnapshotId,
const Utf8Str &aStateFilePath);
HRESULT init(Machine *aMachine,
const settings::Hardware &hardware,
const settings::Storage &storage,
IN_GUID aSnapshotId,
const Utf8Str &aStateFilePath);
void uninit();
// util::Lockable interface
RWLockHandle *lockHandle() const;
// public methods only for internal purposes
HRESULT onSnapshotChange(Snapshot *aSnapshot);
// unsafe inline public methods for internal purposes only (ensure there is
// a caller and a read lock before calling them!)
const Guid &snapshotId() const { return mSnapshotId; }
private:
Guid mSnapshotId;
friend class Snapshot;
};
// third party methods that depend on SnapshotMachine definiton
inline const Guid &Machine::snapshotId() const
{
return mType != IsSnapshotMachine ? Guid::Empty :
static_cast<const SnapshotMachine *>(this)->snapshotId();
}
////////////////////////////////////////////////////////////////////////////////
/**
* Returns a pointer to the Machine object for this machine that acts like a
* parent for complex machine data objects such as shared folders, etc.
*
* For primary Machine objects and for SnapshotMachine objects, returns this
* object's pointer itself. For SessoinMachine objects, returns the peer
* (primary) machine pointer.
*/
inline Machine *Machine::machine()
{
if (mType == IsSessionMachine)
return mPeer;
return this;
}
#endif // ____H_MACHINEIMPL
/* vi: set tabstop=4 shiftwidth=4 expandtab: */