VirtualBoxBase.cpp@ 8707

Last change on this file since 8707 was 8683, checked in by vboxsync, 17 years ago
Use %hrc.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.9 KB

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

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

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

Download in other formats: