VirtualBox

source: vbox/trunk/src/VBox/Main/include/VirtualBoxImpl.h@ 13837

Last change on this file since 13837 was 13713, checked in by vboxsync, 16 years ago

Main: #3276: Simplified suspend/resume event handling in VBoxSVC.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.2 KB
Line 
1/* $Id: VirtualBoxImpl.h 13713 2008-10-31 13:35:03Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
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_VIRTUALBOXIMPL
25#define ____H_VIRTUALBOXIMPL
26
27#include "VirtualBoxBase.h"
28
29#include "VBox/com/EventQueue.h"
30
31#include <list>
32#include <vector>
33#include <map>
34
35#ifdef RT_OS_WINDOWS
36# include "win/resource.h"
37#endif
38
39#ifdef VBOX_WITH_RESOURCE_USAGE_API
40#include "PerformanceImpl.h"
41#endif /* VBOX_WITH_RESOURCE_USAGE_API */
42
43
44class Machine;
45class SessionMachine;
46class HardDisk2;
47class DVDImage2;
48class FloppyImage2;
49class MachineCollection;
50class GuestOSType;
51class GuestOSTypeCollection;
52class SharedFolder;
53class Progress;
54class ProgressCollection;
55class Host;
56class SystemProperties;
57
58#ifdef RT_OS_WINDOWS
59class SVCHlpClient;
60#endif
61
62struct VMClientWatcherData;
63
64class ATL_NO_VTABLE VirtualBox :
65 public VirtualBoxBaseWithChildrenNEXT,
66 public VirtualBoxSupportErrorInfoImpl <VirtualBox, IVirtualBox>,
67 public VirtualBoxSupportTranslation <VirtualBox>,
68#ifdef RT_OS_WINDOWS
69 public IDispatchImpl<IVirtualBox, &IID_IVirtualBox, &LIBID_VirtualBox,
70 kTypeLibraryMajorVersion, kTypeLibraryMinorVersion>,
71 public CComCoClass<VirtualBox, &CLSID_VirtualBox>
72#else
73 public IVirtualBox
74#endif
75{
76
77public:
78
79 typedef std::list <ComPtr <IVirtualBoxCallback> > CallbackList;
80 typedef std::vector <ComPtr <IVirtualBoxCallback> > CallbackVector;
81
82 typedef std::vector <ComObjPtr <SessionMachine> > SessionMachineVector;
83 typedef std::vector <ComObjPtr <Machine> > MachineVector;
84
85 typedef std::vector <ComPtr <IInternalSessionControl> > InternalControlVector;
86
87 class CallbackEvent;
88 friend class CallbackEvent;
89
90 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT (VirtualBox)
91
92 DECLARE_CLASSFACTORY_SINGLETON(VirtualBox)
93
94 DECLARE_REGISTRY_RESOURCEID(IDR_VIRTUALBOX)
95 DECLARE_NOT_AGGREGATABLE(VirtualBox)
96
97 DECLARE_PROTECT_FINAL_CONSTRUCT()
98
99 BEGIN_COM_MAP(VirtualBox)
100 COM_INTERFACE_ENTRY(IDispatch)
101 COM_INTERFACE_ENTRY(ISupportErrorInfo)
102 COM_INTERFACE_ENTRY(IVirtualBox)
103 END_COM_MAP()
104
105 NS_DECL_ISUPPORTS
106
107 /* to postpone generation of the default ctor/dtor */
108 VirtualBox();
109 ~VirtualBox();
110
111 HRESULT FinalConstruct();
112 void FinalRelease();
113
114 /* public initializer/uninitializer for internal purposes only */
115 HRESULT init();
116 void uninit();
117
118 /* IVirtualBox properties */
119 STDMETHOD(COMGETTER(Version)) (BSTR *aVersion);
120 STDMETHOD(COMGETTER(Revision)) (ULONG *aRevision);
121 STDMETHOD(COMGETTER(PackageType)) (BSTR *aPackageType);
122 STDMETHOD(COMGETTER(HomeFolder)) (BSTR *aHomeFolder);
123 STDMETHOD(COMGETTER(SettingsFilePath)) (BSTR *aSettingsFilePath);
124 STDMETHOD(COMGETTER(SettingsFileVersion)) (BSTR *aSettingsFileVersion);
125 STDMETHOD(COMGETTER(SettingsFormatVersion)) (BSTR *aSettingsFormatVersion);
126 STDMETHOD(COMGETTER(Host)) (IHost **aHost);
127 STDMETHOD(COMGETTER(SystemProperties)) (ISystemProperties **aSystemProperties);
128 STDMETHOD(COMGETTER(Machines2)) (ComSafeArrayOut (IMachine *, aMachines));
129 STDMETHOD(COMGETTER(HardDisks2)) (ComSafeArrayOut (IHardDisk2 *, aHardDisks));
130 STDMETHOD(COMGETTER(DVDImages)) (ComSafeArrayOut (IDVDImage2 *, aDVDImages));
131 STDMETHOD(COMGETTER(FloppyImages)) (ComSafeArrayOut (IFloppyImage2 *, aFloppyImages));
132 STDMETHOD(COMGETTER(ProgressOperations)) (IProgressCollection **aOperations);
133 STDMETHOD(COMGETTER(GuestOSTypes)) (IGuestOSTypeCollection **aGuestOSTypes);
134 STDMETHOD(COMGETTER(SharedFolders)) (ISharedFolderCollection **aSharedFolders);
135 STDMETHOD(COMGETTER(PerformanceCollector)) (IPerformanceCollector **aPerformanceCollector);
136
137 /* IVirtualBox methods */
138
139 STDMETHOD(CreateMachine) (INPTR BSTR aBaseFolder, INPTR BSTR aName,
140 INPTR GUIDPARAM aId, IMachine **aMachine);
141 STDMETHOD(CreateLegacyMachine) (INPTR BSTR aSettingsFile, INPTR BSTR aName,
142 INPTR GUIDPARAM aId, IMachine **aMachine);
143 STDMETHOD(OpenMachine) (INPTR BSTR aSettingsFile, IMachine **aMachine);
144 STDMETHOD(RegisterMachine) (IMachine *aMachine);
145 STDMETHOD(GetMachine) (INPTR GUIDPARAM aId, IMachine **aMachine);
146 STDMETHOD(FindMachine) (INPTR BSTR aName, IMachine **aMachine);
147 STDMETHOD(UnregisterMachine) (INPTR GUIDPARAM aId, IMachine **aMachine);
148
149 STDMETHOD(CreateHardDisk2) (INPTR BSTR aFormat, INPTR BSTR aLocation,
150 IHardDisk2 **aHardDisk);
151 STDMETHOD(OpenHardDisk2) (INPTR BSTR aLocation, IHardDisk2 **aHardDisk);
152 STDMETHOD(GetHardDisk2) (INPTR GUIDPARAM aId, IHardDisk2 **aHardDisk);
153 STDMETHOD(FindHardDisk2) (INPTR BSTR aLocation, IHardDisk2 **aHardDisk);
154
155 STDMETHOD(OpenDVDImage) (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
156 IDVDImage2 **aDVDImage);
157 STDMETHOD(GetDVDImage) (INPTR GUIDPARAM aId, IDVDImage2 **aDVDImage);
158 STDMETHOD(FindDVDImage) (INPTR BSTR aLocation, IDVDImage2 **aDVDImage);
159
160 STDMETHOD(OpenFloppyImage) (INPTR BSTR aLocation, INPTR GUIDPARAM aId,
161 IFloppyImage2 **aFloppyImage);
162 STDMETHOD(GetFloppyImage) (INPTR GUIDPARAM aId, IFloppyImage2 **aFloppyImage);
163 STDMETHOD(FindFloppyImage) (INPTR BSTR aLocation, IFloppyImage2 **aFloppyImage);
164
165 STDMETHOD(GetGuestOSType) (INPTR BSTR aId, IGuestOSType **aType);
166 STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable);
167 STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
168 STDMETHOD(GetNextExtraDataKey) (INPTR BSTR aKey, BSTR *aNextKey, BSTR *aNextValue);
169 STDMETHOD(GetExtraData) (INPTR BSTR aKey, BSTR *aValue);
170 STDMETHOD(SetExtraData) (INPTR BSTR aKey, INPTR BSTR aValue);
171 STDMETHOD(OpenSession) (ISession *aSession, INPTR GUIDPARAM aMachineId);
172 STDMETHOD(OpenRemoteSession) (ISession *aSession, INPTR GUIDPARAM aMachineId,
173 INPTR BSTR aType, INPTR BSTR aEnvironment,
174 IProgress **aProgress);
175 STDMETHOD(OpenExistingSession) (ISession *aSession, INPTR GUIDPARAM aMachineId);
176
177 STDMETHOD(RegisterCallback) (IVirtualBoxCallback *aCallback);
178 STDMETHOD(UnregisterCallback) (IVirtualBoxCallback *aCallback);
179
180 STDMETHOD(WaitForPropertyChange) (INPTR BSTR aWhat, ULONG aTimeout,
181 BSTR *aChanged, BSTR *aValues);
182
183 STDMETHOD(SaveSettings)();
184 STDMETHOD(SaveSettingsWithBackup) (BSTR *aBakFileName);
185
186 /* public methods only for internal purposes */
187
188 HRESULT postEvent (Event *event);
189
190 HRESULT addProgress (IProgress *aProgress);
191 HRESULT removeProgress (INPTR GUIDPARAM aId);
192
193#ifdef RT_OS_WINDOWS
194 typedef DECLCALLBACKPTR (HRESULT, SVCHelperClientFunc)
195 (SVCHlpClient *aClient, Progress *aProgress, void *aUser, int *aVrc);
196 HRESULT startSVCHelperClient (bool aPrivileged,
197 SVCHelperClientFunc aFunc,
198 void *aUser, Progress *aProgress);
199#endif
200
201 void addProcessToReap (RTPROCESS pid);
202 void updateClientWatcher();
203
204 void onMachineStateChange (const Guid &aId, MachineState_T aState);
205 void onMachineDataChange (const Guid &aId);
206 BOOL onExtraDataCanChange(const Guid &aId, INPTR BSTR aKey, INPTR BSTR aValue,
207 Bstr &aError);
208 void onExtraDataChange(const Guid &aId, INPTR BSTR aKey, INPTR BSTR aValue);
209 void onMachineRegistered (const Guid &aId, BOOL aRegistered);
210 void onSessionStateChange (const Guid &aId, SessionState_T aState);
211
212 void onSnapshotTaken (const Guid &aMachineId, const Guid &aSnapshotId);
213 void onSnapshotDiscarded (const Guid &aMachineId, const Guid &aSnapshotId);
214 void onSnapshotChange (const Guid &aMachineId, const Guid &aSnapshotId);
215 void onGuestPropertyChange (const Guid &aMachineId, INPTR BSTR aName, INPTR BSTR aValue,
216 INPTR BSTR aFlags);
217
218 ComObjPtr <GuestOSType> getUnknownOSType();
219
220 void getOpenedMachines (SessionMachineVector &aMachines,
221 InternalControlVector *aControls = NULL);
222
223 /** Shortcut to #getOpenedMachines (aMachines, &aControls). */
224 void getOpenedMachinesAndControls (SessionMachineVector &aMachines,
225 InternalControlVector &aControls)
226 { getOpenedMachines (aMachines, &aControls); }
227
228 bool isMachineIdValid (const Guid &aId)
229 {
230 return SUCCEEDED (findMachine (aId, false /* aSetError */, NULL));
231 }
232
233 HRESULT findMachine (const Guid &aId, bool aSetError,
234 ComObjPtr <Machine> *machine = NULL);
235
236 HRESULT findHardDisk2 (const Guid *aId, const BSTR aLocation,
237 bool aSetError, ComObjPtr <HardDisk2> *aHardDisk = NULL);
238 HRESULT findDVDImage2 (const Guid *aId, const BSTR aLocation,
239 bool aSetError, ComObjPtr <DVDImage2> *aImage = NULL);
240 HRESULT findFloppyImage2 (const Guid *aId, const BSTR aLocation,
241 bool aSetError, ComObjPtr <FloppyImage2> *aImage = NULL);
242
243 const ComObjPtr <Host> &host() { return mData.mHost; }
244 const ComObjPtr <SystemProperties> &systemProperties()
245 { return mData.mSystemProperties; }
246#ifdef VBOX_WITH_RESOURCE_USAGE_API
247 const ComObjPtr <PerformanceCollector> &performanceCollector()
248 { return mData.mPerformanceCollector; }
249#endif /* VBOX_WITH_RESOURCE_USAGE_API */
250
251
252 /** Returns the VirtualBox home directory */
253 const Utf8Str &homeDir() { return mData.mHomeDir; }
254
255 int calculateFullPath (const char *aPath, Utf8Str &aResult);
256 void calculateRelativePath (const char *aPath, Utf8Str &aResult);
257
258 HRESULT registerHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
259 HRESULT unregisterHardDisk2 (HardDisk2 *aHardDisk, bool aSaveRegistry = true);
260
261 HRESULT registerDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
262 HRESULT unregisterDVDImage (DVDImage2 *aImage, bool aSaveRegistry = true);
263
264 HRESULT registerFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
265 HRESULT unregisterFloppyImage (FloppyImage2 *aImage, bool aSaveRegistry = true);
266
267 HRESULT cast (IHardDisk2 *aFrom, ComObjPtr <HardDisk2> &aTo);
268
269 HRESULT saveSettings();
270 HRESULT updateSettings (const char *aOldPath, const char *aNewPath);
271
272 const Bstr &settingsFileName() { return mData.mCfgFile.mName; }
273
274 static HRESULT ensureFilePathExists (const char *aFileName);
275
276 class SettingsTreeHelper : public settings::XmlTreeBackend::InputResolver
277 , public settings::XmlTreeBackend::AutoConverter
278 {
279 public:
280
281 // InputResolver interface
282 settings::Input *resolveEntity (const char *aURI, const char *aID);
283
284 // AutoConverter interface
285 bool needsConversion (const settings::Key &aRoot, char **aOldVersion) const;
286 const char *templateUri() const;
287 };
288
289 static HRESULT loadSettingsTree (settings::XmlTreeBackend &aTree,
290 settings::File &aFile,
291 bool aValidate,
292 bool aCatchLoadErrors,
293 bool aAddDefaults,
294 Utf8Str *aFormatVersion = NULL);
295
296 /**
297 * Shortcut to loadSettingsTree (aTree, aFile, true, true, true).
298 *
299 * Used when the settings file is to be loaded for the first time for the
300 * given object in order to recreate it from the stored settings.
301 *
302 * @param aFormatVersion Where to store the current format version of the
303 * loaded settings tree.
304 */
305 static HRESULT loadSettingsTree_FirstTime (settings::XmlTreeBackend &aTree,
306 settings::File &aFile,
307 Utf8Str &aFormatVersion)
308 {
309 return loadSettingsTree (aTree, aFile, true, true, true,
310 &aFormatVersion);
311 }
312
313 /**
314 * Shortcut to loadSettingsTree (aTree, aFile, true, false, true).
315 *
316 * Used when the settings file is loaded again (after it has been fully
317 * checked and validated by #loadSettingsTree_FirstTime()) in order to
318 * look at settings that don't have any representation within object's
319 * data fields.
320 */
321 static HRESULT loadSettingsTree_Again (settings::XmlTreeBackend &aTree,
322 settings::File &aFile)
323 {
324 return loadSettingsTree (aTree, aFile, true, false, true);
325 }
326
327 /**
328 * Shortcut to loadSettingsTree (aTree, aFile, true, false, false).
329 *
330 * Used when the settings file is loaded again (after it has been fully
331 * checked and validated by #loadSettingsTree_FirstTime()) in order to
332 * update some settings and then save them back.
333 */
334 static HRESULT loadSettingsTree_ForUpdate (settings::XmlTreeBackend &aTree,
335 settings::File &aFile)
336 {
337 return loadSettingsTree (aTree, aFile, true, false, false);
338 }
339
340 static HRESULT saveSettingsTree (settings::TreeBackend &aTree,
341 settings::File &aFile,
342 Utf8Str &aFormatVersion);
343
344 static HRESULT backupSettingsFile (const Bstr &aFileName,
345 const Utf8Str &aOldFormat,
346 Bstr &aBakFileName);
347
348 static HRESULT handleUnexpectedExceptions (RT_SRC_POS_DECL);
349
350 /**
351 * Returns a lock handle used to protect changes to the hard disk hierarchy
352 * (e.g. changing HardDisk2::mParent fields and adding/removing children).
353 */
354 RWLockHandle *hardDiskTreeHandle() { return &mHardDiskTreeHandle; }
355
356 /* for VirtualBoxSupportErrorInfoImpl */
357 static const wchar_t *getComponentName() { return L"VirtualBox"; }
358
359private:
360
361 typedef std::list <ComObjPtr <Machine> > MachineList;
362 typedef std::list <ComObjPtr <GuestOSType> > GuestOSTypeList;
363
364 typedef std::map <Guid, ComPtr <IProgress> > ProgressMap;
365
366 typedef std::list <ComObjPtr <HardDisk2> > HardDisk2List;
367 typedef std::list <ComObjPtr <DVDImage2> > DVDImage2List;
368 typedef std::list <ComObjPtr <FloppyImage2> > FloppyImage2List;
369 typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
370
371 typedef std::map <Guid, ComObjPtr <HardDisk2> > HardDisk2Map;
372
373 HRESULT checkMediaForConflicts2 (const Guid &aId, const Bstr &aLocation,
374 Utf8Str &aConflictType);
375
376 HRESULT loadMachines (const settings::Key &aGlobal);
377 HRESULT loadMedia (const settings::Key &aGlobal);
378
379 HRESULT registerMachine (Machine *aMachine);
380
381 HRESULT lockConfig();
382 HRESULT unlockConfig();
383
384 /** @note This method is not thread safe */
385 bool isConfigLocked() { return mData.mCfgFile.mHandle != NIL_RTFILE; }
386
387 /**
388 * Main VirtualBox data structure.
389 * @note |const| members are persistent during lifetime so can be accessed
390 * without locking.
391 */
392 struct Data
393 {
394 Data();
395
396 struct CfgFile
397 {
398 CfgFile() : mHandle (NIL_RTFILE) {}
399
400 const Bstr mName;
401 RTFILE mHandle;
402 };
403
404 // const data members not requiring locking
405 const Utf8Str mHomeDir;
406
407 // const objects not requiring locking
408 const ComObjPtr <Host> mHost;
409 const ComObjPtr <SystemProperties> mSystemProperties;
410#ifdef VBOX_WITH_RESOURCE_USAGE_API
411 const ComObjPtr <PerformanceCollector> mPerformanceCollector;
412#endif /* VBOX_WITH_RESOURCE_USAGE_API */
413
414 CfgFile mCfgFile;
415
416 Utf8Str mSettingsFileVersion;
417
418 MachineList mMachines;
419 GuestOSTypeList mGuestOSTypes;
420
421 ProgressMap mProgressOperations;
422
423 HardDisk2List mHardDisks2;
424 DVDImage2List mDVDImages2;
425 FloppyImage2List mFloppyImages2;
426 SharedFolderList mSharedFolders;
427
428 /// @todo NEWMEDIA do we really need this map? Used only in
429 /// find() it seems
430 HardDisk2Map mHardDisk2Map;
431
432 CallbackList mCallbacks;
433 };
434
435 Data mData;
436
437 /** Client watcher thread data structure */
438 struct ClientWatcherData
439 {
440 ClientWatcherData()
441#if defined(RT_OS_WINDOWS)
442 : mUpdateReq (NULL)
443#elif defined(RT_OS_OS2)
444 : mUpdateReq (NIL_RTSEMEVENT)
445#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
446 : mUpdateReq (NIL_RTSEMEVENT)
447#else
448# error "Port me!"
449#endif
450 , mThread (NIL_RTTHREAD) {}
451
452 // const objects not requiring locking
453#if defined(RT_OS_WINDOWS)
454 const HANDLE mUpdateReq;
455#elif defined(RT_OS_OS2)
456 const RTSEMEVENT mUpdateReq;
457#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
458 const RTSEMEVENT mUpdateReq;
459#else
460# error "Port me!"
461#endif
462 const RTTHREAD mThread;
463
464 typedef std::list <RTPROCESS> ProcessList;
465 ProcessList mProcesses;
466 };
467
468 ClientWatcherData mWatcherData;
469
470 const RTTHREAD mAsyncEventThread;
471 EventQueue * const mAsyncEventQ;
472
473 /**
474 * "Safe" lock. May only be used if guaranteed that no other locks are
475 * requested while holding it and no functions that may do so are called.
476 * Currently, protects the following:
477 *
478 * - mProgressOperations
479 */
480 RWLockHandle mSafeLock;
481
482 RWLockHandle mHardDiskTreeHandle;
483
484 static Bstr sVersion;
485 static ULONG sRevision;
486 static Bstr sPackageType;
487 static Bstr sSettingsFormatVersion;
488
489 static DECLCALLBACK(int) ClientWatcher (RTTHREAD thread, void *pvUser);
490 static DECLCALLBACK(int) AsyncEventHandler (RTTHREAD thread, void *pvUser);
491
492#ifdef RT_OS_WINDOWS
493 static DECLCALLBACK(int) SVCHelperClientThread (RTTHREAD aThread, void *aUser);
494#endif
495};
496
497////////////////////////////////////////////////////////////////////////////////
498
499/**
500 * Abstract callback event class to asynchronously call VirtualBox callbacks
501 * on a dedicated event thread. Subclasses reimplement #handleCallback()
502 * to call appropriate IVirtualBoxCallback methods depending on the event
503 * to be dispatched.
504 *
505 * @note The VirtualBox instance passed to the constructor is strongly
506 * referenced, so that the VirtualBox singleton won't be released until the
507 * event gets handled by the event thread.
508 */
509class VirtualBox::CallbackEvent : public Event
510{
511public:
512
513 CallbackEvent (VirtualBox *aVirtualBox) : mVirtualBox (aVirtualBox)
514 {
515 Assert (aVirtualBox);
516 }
517
518 void *handler();
519
520 virtual void handleCallback (const ComPtr <IVirtualBoxCallback> &aCallback) = 0;
521
522private:
523
524 /*
525 * Note that this is a weak ref -- the CallbackEvent handler thread
526 * is bound to the lifetime of the VirtualBox instance, so it's safe.
527 */
528 ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
529};
530
531#endif // ____H_VIRTUALBOXIMPL
Note: See TracBrowser for help on using the repository browser.

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