VirtualBoxBase.cpp@ 8486

Last change on this file since 8486 was 8155, checked in by vboxsync, 17 years ago
The Big Sun Rebranding Header Change
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.6 KB

Line
1	/* $Id: VirtualBoxBase.cpp 8155 2008-04-18 15:16:47Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM base classes 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	#if !defined (VBOX_WITH_XPCOM)
25	#include <windows.h>
26	#include <dbghelp.h>
27	#else /* !defined (VBOX_WITH_XPCOM) */
28	#include <nsIServiceManager.h>
29	#include <nsIExceptionService.h>
30	#endif /* !defined (VBOX_WITH_XPCOM) */
31
32	#include "VirtualBoxBase.h"
33	#include "VirtualBoxErrorInfoImpl.h"
34	#include "Logging.h"
35
36	#include <iprt/semaphore.h>
37
38	// VirtualBoxBaseNEXT_base methods
39	////////////////////////////////////////////////////////////////////////////////
40
41	VirtualBoxBaseNEXT_base::VirtualBoxBaseNEXT_base()
42	{
43	mState = NotReady;
44	mStateChangeThread = NIL_RTTHREAD;
45	mCallers = 0;
46	mZeroCallersSem = NIL_RTSEMEVENT;
47	mInitDoneSem = NIL_RTSEMEVENTMULTI;
48	mInitDoneSemUsers = 0;
49	mObjectLock = NULL;
50	}
51
52	VirtualBoxBaseNEXT_base::~VirtualBoxBaseNEXT_base()
53	{
54	if (mObjectLock)
55	delete mObjectLock;
56	Assert (mInitDoneSemUsers == 0);
57	Assert (mInitDoneSem == NIL_RTSEMEVENTMULTI);
58	if (mZeroCallersSem != NIL_RTSEMEVENT)
59	RTSemEventDestroy (mZeroCallersSem);
60	mCallers = 0;
61	mStateChangeThread = NIL_RTTHREAD;
62	mState = NotReady;
63	}
64
65	// util::Lockable interface
66	RWLockHandle *VirtualBoxBaseNEXT_base::lockHandle() const
67	{
68	/* lasy initialization */
69	if (!mObjectLock)
70	mObjectLock = new RWLockHandle;
71	return mObjectLock;
72	}
73
74	/**
75	* Increments the number of calls to this object by one.
76	*
77	* After this method succeeds, it is guaranted that the object will remain in
78	* the Ready (or in the Limited) state at least until #releaseCaller() is
79	* called.
80	*
81	* This method is intended to mark the beginning of sections of code within
82	* methods of COM objects that depend on the readiness (Ready) state. The
83	* Ready state is a primary "ready to serve" state. Usually all code that
84	* works with component's data depends on it. On practice, this means that
85	* almost every public method, setter or getter of the object should add
86	* itself as an object's caller at the very beginning, to protect from an
87	* unexpected uninitialization that may happen on a different thread.
88	*
89	* Besides the Ready state denoting that the object is fully functional,
90	* there is a special Limited state. The Limited state means that the object
91	* is still functional, but its functionality is limited to some degree, so
92	* not all operations are possible. The @a aLimited argument to this method
93	* determines whether the caller represents this limited functionality or not.
94	*
95	* This method succeeeds (and increments the number of callers) only if the
96	* current object's state is Ready. Otherwise, it will return E_UNEXPECTED to
97	* indicate that the object is not operational. There are two exceptions from
98	* this rule:
99	* <ol>
100	* <li>If the @a aLimited argument is \|true\|, then this method will also
101	* succeeed if the object's state is Limited (or Ready, of course).</li>
102	* <li>If this method is called from the same thread that placed the object
103	* to InInit or InUninit state (i.e. either from within the AutoInitSpan
104	* or AutoUninitSpan scope), it will succeed as well (but will not
105	* increase the number of callers).</li>
106	* </ol>
107	*
108	* Normally, calling addCaller() never blocks. However, if this method is
109	* called by a thread created from within the AutoInitSpan scope and this
110	* scope is still active (i.e. the object state is InInit), it will block
111	* until the AutoInitSpan destructor signals that it has finished
112	* initialization.
113	*
114	* When this method returns a failure, the caller must not use the object
115	* and can return the failed result code to his caller.
116	*
117	* @param aState where to store the current object's state
118	* (can be used in overriden methods to determine the
119	* cause of the failure)
120	* @param aLimited \|true\| to add a limited caller.
121	* @return S_OK on success or E_UNEXPECTED on failure
122	*
123	* @note It is preferrable to use the #addLimitedCaller() rather than calling
124	* this method with @a aLimited = \|true\|, for better
125	* self-descriptiveness.
126	*
127	* @sa #addLimitedCaller()
128	* @sa #releaseCaller()
129	*/
130	HRESULT VirtualBoxBaseNEXT_base::addCaller (State aState / = NULL */,
131	bool aLimited /* = false */)
132	{
133	AutoWriteLock stateLock (mStateLock);
134
135	HRESULT rc = E_UNEXPECTED;
136
137	if (mState == Ready \|\| (aLimited && mState == Limited))
138	{
139	/* if Ready or allows Limited, increase the number of callers */
140	++ mCallers;
141	rc = S_OK;
142	}
143	else
144	if ((mState == InInit \|\| mState == InUninit))
145	{
146	if (mStateChangeThread == RTThreadSelf())
147	{
148	/*
149	* Called from the same thread that is doing AutoInitSpan or
150	* AutoUninitSpan, just succeed
151	*/
152	rc = S_OK;
153	}
154	else if (mState == InInit)
155	{
156	/* addCaller() is called by a "child" thread while the "parent"
157	* thread is still doing AutoInitSpan/AutoReadySpan. Wait for the
158	* state to become either Ready/Limited or InitFailed/InInit/NotReady
159	* (in case of init failure). Note that we increase the number of
160	* callers anyway to prevent AutoUninitSpan from early completion.
161	*/
162	++ mCallers;
163
164	/* lazy creation */
165	if (mInitDoneSem == NIL_RTSEMEVENTMULTI)
166	RTSemEventMultiCreate (&mInitDoneSem);
167	++ mInitDoneSemUsers;
168
169	LogFlowThisFunc (("Waiting for AutoInitSpan/AutoReadySpan to finish...\n"));
170
171	stateLock.leave();
172	RTSemEventMultiWait (mInitDoneSem, RT_INDEFINITE_WAIT);
173	stateLock.enter();
174
175	if (-- mInitDoneSemUsers == 0)
176	{
177	/* destroy the semaphore since no more necessary */
178	RTSemEventMultiDestroy (mInitDoneSem);
179	mInitDoneSem = NIL_RTSEMEVENTMULTI;
180	}
181
182	if (mState == Ready)
183	rc = S_OK;
184	else
185	{
186	AssertMsg (mCallers != 0, ("mCallers is ZERO!"));
187	-- mCallers;
188	if (mCallers == 0 && mState == InUninit)
189	{
190	/* inform AutoUninitSpan ctor there are no more callers */
191	RTSemEventSignal (mZeroCallersSem);
192	}
193	}
194	}
195	}
196
197	if (aState)
198	*aState = mState;
199
200	return rc;
201	}
202
203	/**
204	* Decrements the number of calls to this object by one.
205	* Must be called after every #addCaller() or #addLimitedCaller() when the
206	* object is no more necessary.
207	*/
208	void VirtualBoxBaseNEXT_base::releaseCaller()
209	{
210	AutoWriteLock stateLock (mStateLock);
211
212	if (mState == Ready \|\| mState == Limited)
213	{
214	/* if Ready or Limited, decrease the number of callers */
215	AssertMsgReturn (mCallers != 0, ("mCallers is ZERO!"), (void) 0);
216	-- mCallers;
217
218	return;
219	}
220
221	if ((mState == InInit \|\| mState == InUninit))
222	{
223	if (mStateChangeThread == RTThreadSelf())
224	{
225	/*
226	* Called from the same thread that is doing AutoInitSpan or
227	* AutoUninitSpan, just succeed
228	*/
229	return;
230	}
231
232	if (mState == InUninit)
233	{
234	/* the caller is being released after AutoUninitSpan has begun */
235	AssertMsgReturn (mCallers != 0, ("mCallers is ZERO!"), (void) 0);
236	-- mCallers;
237
238	if (mCallers == 0)
239	{
240	/* inform the AutoUninitSpan ctor there are no more callers */
241	RTSemEventSignal (mZeroCallersSem);
242	}
243
244	return;
245	}
246	}
247
248	AssertMsgFailed (("mState = %d!", mState));
249	}
250
251	// VirtualBoxBaseNEXT_base::AutoInitSpan methods
252	////////////////////////////////////////////////////////////////////////////////
253
254	/**
255	* Creates a smart initialization span object and places the object to
256	* InInit state.
257	*
258	* @param aObj \|this\| pointer of the managed VirtualBoxBase object whose
259	* init() method is being called
260	* @param aStatus initial initialization status for this span
261	*/
262	VirtualBoxBaseNEXT_base::AutoInitSpan::
263	AutoInitSpan (VirtualBoxBaseNEXT_base aObj, Status aStatus / = Failed */)
264	: mObj (aObj), mStatus (aStatus), mOk (false)
265	{
266	Assert (aObj);
267
268	AutoWriteLock stateLock (mObj->mStateLock);
269
270	Assert (mObj->mState != InInit && mObj->mState != InUninit &&
271	mObj->mState != InitFailed);
272
273	mOk = mObj->mState == NotReady;
274	if (!mOk)
275	return;
276
277	mObj->setState (InInit);
278	}
279
280	/**
281	* Places the managed VirtualBoxBase object to Ready/Limited state if the
282	* initialization succeeded or partly succeeded, or places it to InitFailed
283	* state and calls the object's uninit() method otherwise.
284	*/
285	VirtualBoxBaseNEXT_base::AutoInitSpan::~AutoInitSpan()
286	{
287	/* if the state was other than NotReady, do nothing */
288	if (!mOk)
289	return;
290
291	AutoWriteLock stateLock (mObj->mStateLock);
292
293	Assert (mObj->mState == InInit);
294
295	if (mObj->mCallers > 0)
296	{
297	Assert (mObj->mInitDoneSemUsers > 0);
298
299	/* We have some pending addCaller() calls on other threads (created
300	* during InInit), signal that InInit is finished. */
301	RTSemEventMultiSignal (mObj->mInitDoneSem);
302	}
303
304	if (mStatus == Succeeded)
305	{
306	mObj->setState (Ready);
307	}
308	else
309	if (mStatus == Limited)
310	{
311	mObj->setState (VirtualBoxBaseNEXT_base::Limited);
312	}
313	else
314	{
315	mObj->setState (InitFailed);
316	/* leave the lock to prevent nesting when uninit() is called */
317	stateLock.leave();
318	/* call uninit() to let the object uninit itself after failed init() */
319	mObj->uninit();
320	/* Note: the object may no longer exist here (for example, it can call
321	* the destructor in uninit()) */
322	}
323	}
324
325	// VirtualBoxBaseNEXT_base::AutoReadySpan methods
326	////////////////////////////////////////////////////////////////////////////////
327
328	/**
329	* Creates a smart re-initialization span object and places the object to
330	* InInit state.
331	*
332	* @param aObj \|this\| pointer of the managed VirtualBoxBase object whose
333	* re-initialization method is being called
334	*/
335	VirtualBoxBaseNEXT_base::AutoReadySpan::
336	AutoReadySpan (VirtualBoxBaseNEXT_base *aObj)
337	: mObj (aObj), mSucceeded (false), mOk (false)
338	{
339	Assert (aObj);
340
341	AutoWriteLock stateLock (mObj->mStateLock);
342
343	Assert (mObj->mState != InInit && mObj->mState != InUninit &&
344	mObj->mState != InitFailed);
345
346	mOk = mObj->mState == Limited;
347	if (!mOk)
348	return;
349
350	mObj->setState (InInit);
351	}
352
353	/**
354	* Places the managed VirtualBoxBase object to Ready state if the
355	* re-initialization succeeded (i.e. #setSucceeded() has been called) or
356	* back to Limited state otherwise.
357	*/
358	VirtualBoxBaseNEXT_base::AutoReadySpan::~AutoReadySpan()
359	{
360	/* if the state was other than Limited, do nothing */
361	if (!mOk)
362	return;
363
364	AutoWriteLock stateLock (mObj->mStateLock);
365
366	Assert (mObj->mState == InInit);
367
368	if (mObj->mCallers > 0 && mObj->mInitDoneSemUsers > 0)
369	{
370	/* We have some pending addCaller() calls on other threads,
371	* signal that InInit is finished. */
372	RTSemEventMultiSignal (mObj->mInitDoneSem);
373	}
374
375	if (mSucceeded)
376	{
377	mObj->setState (Ready);
378	}
379	else
380	{
381	mObj->setState (Limited);
382	}
383	}
384
385	// VirtualBoxBaseNEXT_base::AutoUninitSpan methods
386	////////////////////////////////////////////////////////////////////////////////
387
388	/**
389	* Creates a smart uninitialization span object and places this object to
390	* InUninit state.
391	*
392	* @note This method blocks the current thread execution until the number of
393	* callers of the managed VirtualBoxBase object drops to zero!
394	*
395	* @param aObj \|this\| pointer of the VirtualBoxBase object whose uninit()
396	* method is being called
397	*/
398	VirtualBoxBaseNEXT_base::AutoUninitSpan::AutoUninitSpan (VirtualBoxBaseNEXT_base *aObj)
399	: mObj (aObj), mInitFailed (false), mUninitDone (false)
400	{
401	Assert (aObj);
402
403	AutoWriteLock stateLock (mObj->mStateLock);
404
405	Assert (mObj->mState != InInit);
406
407	/*
408	* Set mUninitDone to \|true\| if this object is already uninitialized
409	* (NotReady) or if another AutoUninitSpan is currently active on some
410	* other thread (InUninit).
411	*/
412	mUninitDone = mObj->mState == NotReady \|\|
413	mObj->mState == InUninit;
414
415	if (mObj->mState == InitFailed)
416	{
417	/* we've been called by init() on failure */
418	mInitFailed = true;
419	}
420	else
421	{
422	/* do nothing if already uninitialized */
423	if (mUninitDone)
424	return;
425	}
426
427	/* go to InUninit to prevent from adding new callers */
428	mObj->setState (InUninit);
429
430	if (mObj->mCallers > 0)
431	{
432	/* lazy creation */
433	Assert (mObj->mZeroCallersSem == NIL_RTSEMEVENT);
434	RTSemEventCreate (&mObj->mZeroCallersSem);
435
436	/* wait until remaining callers release the object */
437	LogFlowThisFunc (("Waiting for callers (%d) to drop to zero...\n",
438	mObj->mCallers));
439
440	stateLock.leave();
441	RTSemEventWait (mObj->mZeroCallersSem, RT_INDEFINITE_WAIT);
442	}
443	}
444
445	/**
446	* Places the managed VirtualBoxBase object to the NotReady state.
447	*/
448	VirtualBoxBaseNEXT_base::AutoUninitSpan::~AutoUninitSpan()
449	{
450	/* do nothing if already uninitialized */
451	if (mUninitDone)
452	return;
453
454	AutoWriteLock stateLock (mObj->mStateLock);
455
456	Assert (mObj->mState == InUninit);
457
458	mObj->setState (NotReady);
459	}
460
461	// VirtualBoxBase methods
462	////////////////////////////////////////////////////////////////////////////////
463
464	/**
465	* Translates the given text string according to the currently installed
466	* translation table and current context. The current context is determined
467	* by the context parameter. Additionally, a comment to the source text
468	* string text can be given. This comment (which is NULL by default)
469	* is helpful in sutuations where it is necessary to distinguish between
470	* two or more semantically different roles of the same source text in the
471	* same context.
472	*
473	* @param context the context of the the translation (can be NULL
474	* to indicate the global context)
475	* @param sourceText the string to translate
476	* @param comment the comment to the string (NULL means no comment)
477	*
478	* @return
479	* the translated version of the source string in UTF-8 encoding,
480	* or the source string itself if the translation is not found
481	* in the given context.
482	*/
483	// static
484	const char VirtualBoxBase::translate (const char context, const char *sourceText,
485	const char *comment)
486	{
487	#if 0
488	Log(("VirtualBoxBase::translate:\n"
489	" context={%s}\n"
490	" sourceT={%s}\n"
491	" comment={%s}\n",
492	context, sourceText, comment));
493	#endif
494
495	/// @todo (dmik) incorporate Qt translation file parsing and lookup
496
497	return sourceText;
498	}
499
500	// VirtualBoxSupportTranslationBase methods
501	////////////////////////////////////////////////////////////////////////////////
502
503	/**
504	* Modifies the given argument so that it will contain only a class name
505	* (null-terminated). The argument must point to a <b>non-constant</b>
506	* string containing a valid value, as it is generated by the
507	* __PRETTY_FUNCTION__ built-in macro of the GCC compiler, or by the
508	* __FUNCTION__ macro of any other compiler.
509	*
510	* The function assumes that the macro is used within the member of the
511	* class derived from the VirtualBoxSupportTranslation<> template.
512	*
513	* @param prettyFunctionName string to modify
514	* @return
515	* true on success and false otherwise
516	*/
517	bool VirtualBoxSupportTranslationBase::cutClassNameFrom__PRETTY_FUNCTION__ (char *fn)
518	{
519	Assert (fn);
520	if (!fn)
521	return false;
522
523	#if defined (__GNUC__)
524
525	// the format is like:
526	// VirtualBoxSupportTranslation<C>::VirtualBoxSupportTranslation() [with C = VirtualBox]
527
528	#define START " = "
529	#define END "]"
530
531	#elif defined (_MSC_VER)
532
533	// the format is like:
534	// VirtualBoxSupportTranslation<class VirtualBox>::__ctor
535
536	#define START "<class "
537	#define END ">::"
538
539	#endif
540
541	char *start = strstr (fn, START);
542	Assert (start);
543	if (start)
544	{
545	start += sizeof (START) - 1;
546	char *end = strstr (start, END);
547	Assert (end && (end > start));
548	if (end && (end > start))
549	{
550	size_t len = end - start;
551	memmove (fn, start, len);
552	fn [len] = 0;
553	return true;
554	}
555	}
556
557	#undef END
558	#undef START
559
560	return false;
561	}
562
563	// VirtualBoxSupportErrorInfoImplBase methods
564	////////////////////////////////////////////////////////////////////////////////
565
566	RTTLS VirtualBoxSupportErrorInfoImplBase::MultiResult::sCounter = NIL_RTTLS;
567
568	void VirtualBoxSupportErrorInfoImplBase::MultiResult::init()
569	{
570	if (sCounter == NIL_RTTLS)
571	{
572	sCounter = RTTlsAlloc();
573	AssertReturnVoid (sCounter != NIL_RTTLS);
574	}
575
576	uintptr_t counter = (uintptr_t) RTTlsGet (sCounter);
577	++ counter;
578	RTTlsSet (sCounter, (void *) counter);
579	}
580
581	VirtualBoxSupportErrorInfoImplBase::MultiResult::~MultiResult()
582	{
583	uintptr_t counter = (uintptr_t) RTTlsGet (sCounter);
584	AssertReturnVoid (counter != 0);
585	-- counter;
586	RTTlsSet (sCounter, (void *) counter);
587	}
588
589	/**
590	* Sets error info for the current thread. This is an internal function that
591	* gets eventually called by all public variants. If @a aWarning is
592	* @c true, then the highest (31) bit in the @a aResultCode value which
593	* indicates the error severity is reset to zero to make sure the receiver will
594	* recognize that the created error info object represents a warning rather
595	* than an error.
596	*/
597	/* static */
598	HRESULT VirtualBoxSupportErrorInfoImplBase::setErrorInternal (
599	HRESULT aResultCode, const GUID &aIID,
600	const Bstr &aComponent, const Bstr &aText,
601	bool aWarning)
602	{
603	/* whether multi-error mode is turned on */
604	bool preserve = ((uintptr_t) RTTlsGet (MultiResult::sCounter)) > 0;
605
606	LogRel (("ERROR [COM]: aRC=%#08x aIID={%Vuuid} aComponent={%ls} aText={%ls} "
607	"aWarning=%RTbool, preserve=%RTbool\n",
608	aResultCode, &aIID, aComponent.raw(), aText.raw(), aWarning,
609	preserve));
610
611	/* these are mandatory, others -- not */
612	AssertReturn ((!aWarning && FAILED (aResultCode)) \|\|
613	(aWarning && aResultCode != S_OK),
614	E_FAIL);
615	AssertReturn (!aText.isEmpty(), E_FAIL);
616
617	/* reset the error severity bit if it's a warning */
618	if (aWarning)
619	aResultCode &= ~0x80000000;
620
621	HRESULT rc = S_OK;
622
623	do
624	{
625	ComObjPtr <VirtualBoxErrorInfo> info;
626	rc = info.createObject();
627	CheckComRCBreakRC (rc);
628
629	#if !defined (VBOX_WITH_XPCOM)
630
631	ComPtr <IVirtualBoxErrorInfo> curInfo;
632	if (preserve)
633	{
634	/* get the current error info if any */
635	ComPtr <IErrorInfo> err;
636	rc = ::GetErrorInfo (0, err.asOutParam());
637	CheckComRCBreakRC (rc);
638	rc = err.queryInterfaceTo (curInfo.asOutParam());
639	if (FAILED (rc))
640	{
641	/* create a IVirtualBoxErrorInfo wrapper for the native
642	* IErrorInfo object */
643	ComObjPtr <VirtualBoxErrorInfo> wrapper;
644	rc = wrapper.createObject();
645	if (SUCCEEDED (rc))
646	{
647	rc = wrapper->init (err);
648	if (SUCCEEDED (rc))
649	curInfo = wrapper;
650	}
651	}
652	}
653	/* On failure, curInfo will stay null */
654	Assert (SUCCEEDED (rc) \|\| curInfo.isNull());
655
656	/* set the current error info and preserve the previous one if any */
657	rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
658	CheckComRCBreakRC (rc);
659
660	ComPtr <IErrorInfo> err;
661	rc = info.queryInterfaceTo (err.asOutParam());
662	if (SUCCEEDED (rc))
663	rc = ::SetErrorInfo (0, err);
664
665	#else // !defined (VBOX_WITH_XPCOM)
666
667	nsCOMPtr <nsIExceptionService> es;
668	es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
669	if (NS_SUCCEEDED (rc))
670	{
671	nsCOMPtr <nsIExceptionManager> em;
672	rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
673	CheckComRCBreakRC (rc);
674
675	ComPtr <IVirtualBoxErrorInfo> curInfo;
676	if (preserve)
677	{
678	/* get the current error info if any */
679	ComPtr <nsIException> ex;
680	rc = em->GetCurrentException (ex.asOutParam());
681	CheckComRCBreakRC (rc);
682	rc = ex.queryInterfaceTo (curInfo.asOutParam());
683	if (FAILED (rc))
684	{
685	/* create a IVirtualBoxErrorInfo wrapper for the native
686	* nsIException object */
687	ComObjPtr <VirtualBoxErrorInfo> wrapper;
688	rc = wrapper.createObject();
689	if (SUCCEEDED (rc))
690	{
691	rc = wrapper->init (ex);
692	if (SUCCEEDED (rc))
693	curInfo = wrapper;
694	}
695	}
696	}
697	/* On failure, curInfo will stay null */
698	Assert (SUCCEEDED (rc) \|\| curInfo.isNull());
699
700	/* set the current error info and preserve the previous one if any */
701	rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
702	CheckComRCBreakRC (rc);
703
704	ComPtr <nsIException> ex;
705	rc = info.queryInterfaceTo (ex.asOutParam());
706	if (SUCCEEDED (rc))
707	rc = em->SetCurrentException (ex);
708	}
709	else if (rc == NS_ERROR_UNEXPECTED)
710	{
711	/*
712	* It is possible that setError() is being called by the object
713	* after the XPCOM shutdown sequence has been initiated
714	* (for example, when XPCOM releases all instances it internally
715	* references, which can cause object's FinalConstruct() and then
716	* uninit()). In this case, do_GetService() above will return
717	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
718	* set the exception (nobody will be able to read it).
719	*/
720	LogWarningFunc (("Will not set an exception because "
721	"nsIExceptionService is not available "
722	"(NS_ERROR_UNEXPECTED). "
723	"XPCOM is being shutdown?\n"));
724	rc = NS_OK;
725	}
726
727	#endif // !defined (VBOX_WITH_XPCOM)
728	}
729	while (0);
730
731	AssertComRC (rc);
732
733	return SUCCEEDED (rc) ? aResultCode : rc;
734	}
735
736	// VirtualBoxBaseWithChildren methods
737	////////////////////////////////////////////////////////////////////////////////
738
739	/**
740	* Uninitializes all dependent children registered with #addDependentChild().
741	*
742	* @note
743	* This method will call uninit() methods of children. If these methods
744	* access the parent object, uninitDependentChildren() must be called
745	* either at the beginning of the parent uninitialization sequence (when
746	* it is still operational) or after setReady(false) is called to
747	* indicate the parent is out of action.
748	*/
749	void VirtualBoxBaseWithChildren::uninitDependentChildren()
750	{
751	/// @todo (r=dmik) see todo in VirtualBoxBase.h, in
752	// template <class C> void removeDependentChild (C *child)
753
754	LogFlowThisFuncEnter();
755
756	AutoWriteLock alock (this);
757	AutoWriteLock mapLock (mMapLock);
758
759	LogFlowThisFunc (("count=%d...\n", mDependentChildren.size()));
760
761	if (mDependentChildren.size())
762	{
763	/* We keep the lock until we have enumerated all children.
764	* Those ones that will try to call #removeDependentChild() from
765	* a different thread will have to wait */
766
767	Assert (mUninitDoneSem == NIL_RTSEMEVENT);
768	int vrc = RTSemEventCreate (&mUninitDoneSem);
769	AssertRC (vrc);
770
771	Assert (mChildrenLeft == 0);
772	mChildrenLeft = (unsigned)mDependentChildren.size();
773
774	for (DependentChildren::iterator it = mDependentChildren.begin();
775	it != mDependentChildren.end(); ++ it)
776	{
777	VirtualBoxBase child = (it).second;
778	Assert (child);
779	if (child)
780	child->uninit();
781	}
782
783	mDependentChildren.clear();
784	}
785
786	/* Wait until all children started uninitializing on their own
787	* (and therefore are waiting for some parent's method or for
788	* #removeDependentChild() to return) are finished uninitialization */
789
790	if (mUninitDoneSem != NIL_RTSEMEVENT)
791	{
792	/* let stuck children run */
793	mapLock.leave();
794	alock.leave();
795
796	LogFlowThisFunc (("Waiting for uninitialization of all children...\n"));
797
798	RTSemEventWait (mUninitDoneSem, RT_INDEFINITE_WAIT);
799
800	alock.enter();
801	mapLock.enter();
802
803	RTSemEventDestroy (mUninitDoneSem);
804	mUninitDoneSem = NIL_RTSEMEVENT;
805	Assert (mChildrenLeft == 0);
806	}
807
808	LogFlowThisFuncLeave();
809	}
810
811	/**
812	* Returns a pointer to the dependent child corresponding to the given
813	* interface pointer (used as a key in the map) or NULL if the interface
814	* pointer doesn't correspond to any child registered using
815	* #addDependentChild().
816	*
817	* @param unk
818	* Pointer to map to the dependent child object (it is ComPtr <IUnknown>
819	* rather than IUnknown , to guarantee IUnknown identity)
820	* @return
821	* Pointer to the dependent child object
822	*/
823	VirtualBoxBase *VirtualBoxBaseWithChildren::getDependentChild (
824	const ComPtr <IUnknown> &unk)
825	{
826	AssertReturn (!!unk, NULL);
827
828	AutoWriteLock alock (mMapLock);
829	if (mUninitDoneSem != NIL_RTSEMEVENT)
830	return NULL;
831
832	DependentChildren::const_iterator it = mDependentChildren.find (unk);
833	if (it == mDependentChildren.end())
834	return NULL;
835	return (*it).second;
836	}
837
838	/** Helper for addDependentChild() template method */
839	void VirtualBoxBaseWithChildren::addDependentChild (
840	const ComPtr <IUnknown> &unk, VirtualBoxBase *child)
841	{
842	AssertReturn (!!unk && child, (void) 0);
843
844	AutoWriteLock alock (mMapLock);
845
846	if (mUninitDoneSem != NIL_RTSEMEVENT)
847	{
848	// for this very unlikely case, we have to increase the number of
849	// children left, for symmetry with #removeDependentChild()
850	++ mChildrenLeft;
851	return;
852	}
853
854	std::pair <DependentChildren::iterator, bool> result =
855	mDependentChildren.insert (DependentChildren::value_type (unk, child));
856	AssertMsg (result.second, ("Failed to insert a child to the map\n"));
857	}
858
859	/** Helper for removeDependentChild() template method */
860	void VirtualBoxBaseWithChildren::removeDependentChild (const ComPtr <IUnknown> &unk)
861	{
862	/// @todo (r=dmik) see todo in VirtualBoxBase.h, in
863	// template <class C> void removeDependentChild (C *child)
864
865	AssertReturn (!!unk, (void) 0);
866
867	AutoWriteLock alock (mMapLock);
868
869	if (mUninitDoneSem != NIL_RTSEMEVENT)
870	{
871	// uninitDependentChildren() is in action, just increase the number
872	// of children left and signal a semaphore when it reaches zero
873	Assert (mChildrenLeft != 0);
874	-- mChildrenLeft;
875	if (mChildrenLeft == 0)
876	{
877	int vrc = RTSemEventSignal (mUninitDoneSem);
878	AssertRC (vrc);
879	}
880	return;
881	}
882
883	DependentChildren::size_type result = mDependentChildren.erase (unk);
884	AssertMsg (result == 1, ("Failed to remove a child from the map\n"));
885	NOREF (result);
886	}
887
888	// VirtualBoxBaseWithChildrenNEXT methods
889	////////////////////////////////////////////////////////////////////////////////
890
891	/**
892	* Uninitializes all dependent children registered with #addDependentChild().
893	*
894	* Typically called from the uninit() method. Note that this method will call
895	* uninit() methods of child objects. If these methods need to call the parent
896	* object during initialization, uninitDependentChildren() must be called before
897	* the relevant part of the parent is uninitialized, usually at the begnning of
898	* the parent uninitialization sequence.
899	*/
900	void VirtualBoxBaseWithChildrenNEXT::uninitDependentChildren()
901	{
902	LogFlowThisFuncEnter();
903
904	AutoWriteLock mapLock (mMapLock);
905
906	LogFlowThisFunc (("count=%u...\n", mDependentChildren.size()));
907
908	if (mDependentChildren.size())
909	{
910	/* We keep the lock until we have enumerated all children.
911	* Those ones that will try to call removeDependentChild() from a
912	* different thread will have to wait */
913
914	Assert (mUninitDoneSem == NIL_RTSEMEVENT);
915	int vrc = RTSemEventCreate (&mUninitDoneSem);
916	AssertRC (vrc);
917
918	Assert (mChildrenLeft == 0);
919	mChildrenLeft = mDependentChildren.size();
920
921	for (DependentChildren::iterator it = mDependentChildren.begin();
922	it != mDependentChildren.end(); ++ it)
923	{
924	VirtualBoxBase child = (it).second;
925	Assert (child);
926	if (child)
927	child->uninit();
928	}
929
930	mDependentChildren.clear();
931	}
932
933	/* Wait until all children that called uninit() on their own on other
934	* threads but stuck waiting for the map lock in removeDependentChild() have
935	* finished uninitialization. */
936
937	if (mUninitDoneSem != NIL_RTSEMEVENT)
938	{
939	/* let stuck children run */
940	mapLock.leave();
941
942	LogFlowThisFunc (("Waiting for uninitialization of all children...\n"));
943
944	RTSemEventWait (mUninitDoneSem, RT_INDEFINITE_WAIT);
945
946	mapLock.enter();
947
948	RTSemEventDestroy (mUninitDoneSem);
949	mUninitDoneSem = NIL_RTSEMEVENT;
950	Assert (mChildrenLeft == 0);
951	}
952
953	LogFlowThisFuncLeave();
954	}
955
956	/**
957	* Returns a pointer to the dependent child corresponding to the given
958	* interface pointer (used as a key in the map of dependent children) or NULL
959	* if the interface pointer doesn't correspond to any child registered using
960	* #addDependentChild().
961	*
962	* Note that ComPtr <IUnknown> is used as an argument instead of IUnknown * in
963	* order to guarantee IUnknown identity and disambiguation by doing
964	* QueryInterface (IUnknown) rather than a regular C cast.
965	*
966	* @param aUnk Pointer to map to the dependent child object.
967	* @return Pointer to the dependent child object.
968	*/
969	VirtualBoxBaseNEXT *
970	VirtualBoxBaseWithChildrenNEXT::getDependentChild (const ComPtr <IUnknown> &aUnk)
971	{
972	AssertReturn (!!aUnk, NULL);
973
974	AutoWriteLock alock (mMapLock);
975
976	/* return NULL if uninitDependentChildren() is in action */
977	if (mUninitDoneSem != NIL_RTSEMEVENT)
978	return NULL;
979
980	DependentChildren::const_iterator it = mDependentChildren.find (aUnk);
981	if (it == mDependentChildren.end())
982	return NULL;
983	return (*it).second;
984	}
985
986	void VirtualBoxBaseWithChildrenNEXT::doAddDependentChild (
987	IUnknown aUnk, VirtualBoxBaseNEXT aChild)
988	{
989	AssertReturnVoid (aUnk && aChild);
990
991	AutoWriteLock alock (mMapLock);
992
993	if (mUninitDoneSem != NIL_RTSEMEVENT)
994	{
995	/* uninitDependentChildren() is being run. For this very unlikely case,
996	* we have to increase the number of children left, for symmetry with
997	* a later #removeDependentChild() call. */
998	++ mChildrenLeft;
999	return;
1000	}
1001
1002	std::pair <DependentChildren::iterator, bool> result =
1003	mDependentChildren.insert (DependentChildren::value_type (aUnk, aChild));
1004	AssertMsg (result.second, ("Failed to insert a child to the map\n"));
1005	}
1006
1007	void VirtualBoxBaseWithChildrenNEXT::doRemoveDependentChild (IUnknown *aUnk)
1008	{
1009	AssertReturnVoid (aUnk);
1010
1011	AutoWriteLock alock (mMapLock);
1012
1013	if (mUninitDoneSem != NIL_RTSEMEVENT)
1014	{
1015	/* uninitDependentChildren() is being run. Just decrease the number of
1016	* children left and signal a semaphore if it reaches zero. */
1017	Assert (mChildrenLeft != 0);
1018	-- mChildrenLeft;
1019	if (mChildrenLeft == 0)
1020	{
1021	int vrc = RTSemEventSignal (mUninitDoneSem);
1022	AssertRC (vrc);
1023	}
1024	return;
1025	}
1026
1027	DependentChildren::size_type result = mDependentChildren.erase (aUnk);
1028	AssertMsg (result == 1, ("Failed to remove the child %p from the map\n",
1029	aUnk));
1030	NOREF (result);
1031	}
1032
1033	// VirtualBoxBaseWithTypedChildrenNEXT methods
1034	////////////////////////////////////////////////////////////////////////////////
1035
1036	/**
1037	* Uninitializes all dependent children registered with
1038	* #addDependentChild().
1039	*
1040	* @note This method will call uninit() methods of children. If these
1041	* methods access the parent object, uninitDependentChildren() must be
1042	* called either at the beginning of the parent uninitialization
1043	* sequence (when it is still operational) or after setReady(false) is
1044	* called to indicate the parent is out of action.
1045	*/
1046	template <class C>
1047	void VirtualBoxBaseWithTypedChildrenNEXT <C>::uninitDependentChildren()
1048	{
1049	AutoWriteLock mapLock (mMapLock);
1050
1051	if (mDependentChildren.size())
1052	{
1053	/* set flag to ignore #removeDependentChild() called from
1054	* child->uninit() */
1055	mInUninit = true;
1056
1057	/* leave the locks to let children waiting for
1058	* #removeDependentChild() run */
1059	mapLock.leave();
1060
1061	for (typename DependentChildren::iterator it = mDependentChildren.begin();
1062	it != mDependentChildren.end(); ++ it)
1063	{
1064	C child = (it);
1065	Assert (child);
1066	if (child)
1067	child->uninit();
1068	}
1069	mDependentChildren.clear();
1070
1071	mapLock.enter();
1072
1073	mInUninit = false;
1074	}
1075	}
1076
1077	// Settings API additions
1078	////////////////////////////////////////////////////////////////////////////////
1079
1080	#if defined VBOX_MAIN_SETTINGS_ADDONS
1081
1082	namespace settings
1083	{
1084
1085	template<> stdx::char_auto_ptr
1086	ToString <com::Bstr> (const com::Bstr &aValue, unsigned int aExtra)
1087	{
1088	stdx::char_auto_ptr result;
1089
1090	if (aValue.raw() == NULL)
1091	throw ENoValue();
1092
1093	/* The only way to cause RTUtf16ToUtf8Ex return a number of bytes needed
1094	* w/o allocating the result buffer itself is to provide that both cch
1095	* and ppsz are not NULL. /
1096	char dummy [1];
1097	char *dummy2 = dummy;
1098	size_t strLen = 1;
1099
1100	int vrc = RTUtf16ToUtf8Ex (aValue.raw(), RTSTR_MAX,
1101	&dummy2, strLen, &strLen);
1102	if (RT_SUCCESS (vrc))
1103	{
1104	/* the string only contains '\0' :) */
1105	result.reset (new char [1]);
1106	result.get() [0] = '\0';
1107	return result;
1108	}
1109
1110	if (vrc == VERR_BUFFER_OVERFLOW)
1111	{
1112	result.reset (new char [strLen + 1]);
1113	char *buf = result.get();
1114	vrc = RTUtf16ToUtf8Ex (aValue.raw(), RTSTR_MAX, &buf, strLen + 1, NULL);
1115	}
1116
1117	if (RT_FAILURE (vrc))
1118	throw LogicError (RT_SRC_POS);
1119
1120	return result;
1121	}
1122
1123	template<> com::Guid FromString <com::Guid> (const char *aValue)
1124	{
1125	if (aValue == NULL)
1126	throw ENoValue();
1127
1128	/* For settings, the format is always {XXX...XXX} */
1129	char buf [RTUUID_STR_LENGTH];
1130	if (aValue == NULL \|\| *aValue != '{' \|\|
1131	strlen (aValue) != RTUUID_STR_LENGTH + 1 \|\|
1132	aValue [RTUUID_STR_LENGTH] != '}')
1133	throw ENoConversion (FmtStr ("'%s' is not Guid", aValue));
1134
1135	/* strip { and } */
1136	memcpy (buf, aValue + 1, RTUUID_STR_LENGTH - 1);
1137	buf [RTUUID_STR_LENGTH - 1] = '\0';
1138	/* we don't use Guid (const char *) because we want to throw
1139	* ENoConversion on format error */
1140	RTUUID uuid;
1141	int vrc = RTUuidFromStr (&uuid, buf);
1142	if (RT_FAILURE (vrc))
1143	throw ENoConversion (FmtStr ("'%s' is not Guid (%Vrc)", aValue, vrc));
1144
1145	return com::Guid (uuid);
1146	}
1147
1148	template<> stdx::char_auto_ptr
1149	ToString <com::Guid> (const com::Guid &aValue, unsigned int aExtra)
1150	{
1151	/* For settings, the format is always {XXX...XXX} */
1152	stdx::char_auto_ptr result (new char [RTUUID_STR_LENGTH + 2]);
1153
1154	int vrc = RTUuidToStr (aValue.raw(), result.get() + 1, RTUUID_STR_LENGTH);
1155	if (RT_FAILURE (vrc))
1156	throw LogicError (RT_SRC_POS);
1157
1158	result.get() [0] = '{';
1159	result.get() [RTUUID_STR_LENGTH] = '}';
1160	result.get() [RTUUID_STR_LENGTH + 1] = '\0';
1161
1162	return result;
1163	}
1164
1165	} /* namespace settings */
1166
1167	#endif /* VBOX_MAIN_SETTINGS_ADDONS */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/VirtualBoxBase.cpp@ 8486

Download in other formats: