VirtualBoxBase.cpp@ 44591

Last change on this file since 44591 was 41214, checked in by vboxsync, 13 years ago
Main: move handleUnexpectedExceptions method to VirtualBoxBase
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.6 KB

Line
1	/* $Id: VirtualBoxBase.cpp 41214 2012-05-08 17:59:43Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM base classes implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2012 Oracle Corporation
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
20	#include <iprt/semaphore.h>
21	#include <iprt/asm.h>
22	#include <iprt/cpp/exception.h>
23
24	#include <typeinfo>
25
26	#if !defined (VBOX_WITH_XPCOM)
27	#include <windows.h>
28	#include <dbghelp.h>
29	#else /* !defined (VBOX_WITH_XPCOM) */
30	/// @todo remove when VirtualBoxErrorInfo goes away from here
31	#include <nsIServiceManager.h>
32	#include <nsIExceptionService.h>
33	#endif /* !defined (VBOX_WITH_XPCOM) */
34
35	#include "VirtualBoxBase.h"
36	#include "AutoCaller.h"
37	#include "VirtualBoxErrorInfoImpl.h"
38	#include "Logging.h"
39
40	#include "VBox/com/ErrorInfo.h"
41	#include "VBox/com/MultiResult.h"
42
43	////////////////////////////////////////////////////////////////////////////////
44	//
45	// VirtualBoxBase
46	//
47	////////////////////////////////////////////////////////////////////////////////
48
49	VirtualBoxBase::VirtualBoxBase()
50	: mStateLock(LOCKCLASS_OBJECTSTATE)
51	{
52	mState = NotReady;
53	mStateChangeThread = NIL_RTTHREAD;
54	mCallers = 0;
55	mZeroCallersSem = NIL_RTSEMEVENT;
56	mInitUninitSem = NIL_RTSEMEVENTMULTI;
57	mInitUninitWaiters = 0;
58	mObjectLock = NULL;
59	}
60
61	VirtualBoxBase::~VirtualBoxBase()
62	{
63	if (mObjectLock)
64	delete mObjectLock;
65	Assert(mInitUninitWaiters == 0);
66	Assert(mInitUninitSem == NIL_RTSEMEVENTMULTI);
67	if (mZeroCallersSem != NIL_RTSEMEVENT)
68	RTSemEventDestroy (mZeroCallersSem);
69	mCallers = 0;
70	mStateChangeThread = NIL_RTTHREAD;
71	mState = NotReady;
72	}
73
74	/**
75	* This virtual method returns an RWLockHandle that can be used to
76	* protect instance data. This RWLockHandle is generally referred to
77	* as the "object lock"; its locking class (for lock order validation)
78	* must be returned by another virtual method, getLockingClass(), which
79	* by default returns LOCKCLASS_OTHEROBJECT but is overridden by several
80	* subclasses such as VirtualBox, Host, Machine and others.
81	*
82	* On the first call this method lazily creates the RWLockHandle.
83	*
84	* @return
85	*/
86	/* virtual */
87	RWLockHandle *VirtualBoxBase::lockHandle() const
88	{
89	/* lazy initialization */
90	if (RT_UNLIKELY(!mObjectLock))
91	{
92	AssertCompile (sizeof (RWLockHandle ) == sizeof (void ));
93
94	// getLockingClass() is overridden by many subclasses to return
95	// one of the locking classes listed at the top of AutoLock.h
96	RWLockHandle *objLock = new RWLockHandle(getLockingClass());
97	if (!ASMAtomicCmpXchgPtr(&mObjectLock, objLock, NULL))
98	{
99	delete objLock;
100	objLock = ASMAtomicReadPtrT(&mObjectLock, RWLockHandle *);
101	}
102	return objLock;
103	}
104	return mObjectLock;
105	}
106
107	/**
108	* Increments the number of calls to this object by one.
109	*
110	* After this method succeeds, it is guaranteed that the object will remain
111	* in the Ready (or in the Limited) state at least until #releaseCaller() is
112	* called.
113	*
114	* This method is intended to mark the beginning of sections of code within
115	* methods of COM objects that depend on the readiness (Ready) state. The
116	* Ready state is a primary "ready to serve" state. Usually all code that
117	* works with component's data depends on it. On practice, this means that
118	* almost every public method, setter or getter of the object should add
119	* itself as an object's caller at the very beginning, to protect from an
120	* unexpected uninitialization that may happen on a different thread.
121	*
122	* Besides the Ready state denoting that the object is fully functional,
123	* there is a special Limited state. The Limited state means that the object
124	* is still functional, but its functionality is limited to some degree, so
125	* not all operations are possible. The @a aLimited argument to this method
126	* determines whether the caller represents this limited functionality or
127	* not.
128	*
129	* This method succeeds (and increments the number of callers) only if the
130	* current object's state is Ready. Otherwise, it will return E_ACCESSDENIED
131	* to indicate that the object is not operational. There are two exceptions
132	* from this rule:
133	* <ol>
134	* <li>If the @a aLimited argument is \|true\|, then this method will also
135	* succeed if the object's state is Limited (or Ready, of course).
136	* </li>
137	* <li>If this method is called from the same thread that placed
138	* the object to InInit or InUninit state (i.e. either from within the
139	* AutoInitSpan or AutoUninitSpan scope), it will succeed as well (but
140	* will not increase the number of callers).
141	* </li>
142	* </ol>
143	*
144	* Normally, calling addCaller() never blocks. However, if this method is
145	* called by a thread created from within the AutoInitSpan scope and this
146	* scope is still active (i.e. the object state is InInit), it will block
147	* until the AutoInitSpan destructor signals that it has finished
148	* initialization.
149	*
150	* When this method returns a failure, the caller must not use the object
151	* and should return the failed result code to its own caller.
152	*
153	* @param aState Where to store the current object's state (can be
154	* used in overridden methods to determine the cause of
155	* the failure).
156	* @param aLimited \|true\| to add a limited caller.
157	*
158	* @return S_OK on success or E_ACCESSDENIED on failure.
159	*
160	* @note It is preferable to use the #addLimitedCaller() rather than
161	* calling this method with @a aLimited = \|true\|, for better
162	* self-descriptiveness.
163	*
164	* @sa #addLimitedCaller()
165	* @sa #releaseCaller()
166	*/
167	HRESULT VirtualBoxBase::addCaller(State aState / = NULL */,
168	bool aLimited /* = false */)
169	{
170	AutoWriteLock stateLock(mStateLock COMMA_LOCKVAL_SRC_POS);
171
172	HRESULT rc = E_ACCESSDENIED;
173
174	if (mState == Ready \|\| (aLimited && mState == Limited))
175	{
176	/* if Ready or allows Limited, increase the number of callers */
177	++ mCallers;
178	rc = S_OK;
179	}
180	else
181	if (mState == InInit \|\| mState == InUninit)
182	{
183	if (mStateChangeThread == RTThreadSelf())
184	{
185	/* Called from the same thread that is doing AutoInitSpan or
186	* AutoUninitSpan, just succeed */
187	rc = S_OK;
188	}
189	else if (mState == InInit)
190	{
191	/* addCaller() is called by a "child" thread while the "parent"
192	* thread is still doing AutoInitSpan/AutoReinitSpan, so wait for
193	* the state to become either Ready/Limited or InitFailed (in
194	* case of init failure).
195	*
196	* Note that we increase the number of callers anyway -- to
197	* prevent AutoUninitSpan from early completion if we are
198	* still not scheduled to pick up the posted semaphore when
199	* uninit() is called.
200	*/
201	++ mCallers;
202
203	/* lazy semaphore creation */
204	if (mInitUninitSem == NIL_RTSEMEVENTMULTI)
205	{
206	RTSemEventMultiCreate (&mInitUninitSem);
207	Assert(mInitUninitWaiters == 0);
208	}
209
210	++ mInitUninitWaiters;
211
212	LogFlowThisFunc(("Waiting for AutoInitSpan/AutoReinitSpan to finish...\n"));
213
214	stateLock.release();
215	RTSemEventMultiWait (mInitUninitSem, RT_INDEFINITE_WAIT);
216	stateLock.acquire();
217
218	if (-- mInitUninitWaiters == 0)
219	{
220	/* destroy the semaphore since no more necessary */
221	RTSemEventMultiDestroy (mInitUninitSem);
222	mInitUninitSem = NIL_RTSEMEVENTMULTI;
223	}
224
225	if (mState == Ready \|\| (aLimited && mState == Limited))
226	rc = S_OK;
227	else
228	{
229	Assert(mCallers != 0);
230	-- mCallers;
231	if (mCallers == 0 && mState == InUninit)
232	{
233	/* inform AutoUninitSpan ctor there are no more callers */
234	RTSemEventSignal(mZeroCallersSem);
235	}
236	}
237	}
238	}
239
240	if (aState)
241	*aState = mState;
242
243	if (FAILED(rc))
244	{
245	if (mState == VirtualBoxBase::Limited)
246	rc = setError(rc, "The object functionality is limited");
247	else
248	rc = setError(rc, "The object is not ready");
249	}
250
251	return rc;
252	}
253
254	/**
255	* Decreases the number of calls to this object by one.
256	*
257	* Must be called after every #addCaller() or #addLimitedCaller() when
258	* protecting the object from uninitialization is no more necessary.
259	*/
260	void VirtualBoxBase::releaseCaller()
261	{
262	AutoWriteLock stateLock(mStateLock COMMA_LOCKVAL_SRC_POS);
263
264	if (mState == Ready \|\| mState == Limited)
265	{
266	/* if Ready or Limited, decrease the number of callers */
267	AssertMsgReturn(mCallers != 0, ("mCallers is ZERO!"), (void) 0);
268	--mCallers;
269
270	return;
271	}
272
273	if (mState == InInit \|\| mState == InUninit)
274	{
275	if (mStateChangeThread == RTThreadSelf())
276	{
277	/* Called from the same thread that is doing AutoInitSpan or
278	* AutoUninitSpan: just succeed */
279	return;
280	}
281
282	if (mState == InUninit)
283	{
284	/* the caller is being released after AutoUninitSpan has begun */
285	AssertMsgReturn(mCallers != 0, ("mCallers is ZERO!"), (void) 0);
286	--mCallers;
287
288	if (mCallers == 0)
289	/* inform the AutoUninitSpan ctor there are no more callers /
290	RTSemEventSignal(mZeroCallersSem);
291
292	return;
293	}
294	}
295
296	AssertMsgFailed (("mState = %d!", mState));
297	}
298
299	/**
300	* Handles unexpected exceptions by turning them into COM errors in release
301	* builds or by hitting a breakpoint in the release builds.
302	*
303	* Usage pattern:
304	* @code
305	try
306	{
307	// ...
308	}
309	catch (LaLalA)
310	{
311	// ...
312	}
313	catch (...)
314	{
315	rc = VirtualBox::handleUnexpectedExceptions(this, RT_SRC_POS);
316	}
317	* @endcode
318	*
319	* @param aThis object where the exception happened
320	* @param RT_SRC_POS_DECL "RT_SRC_POS" macro instantiation.
321	* */
322	/* static */
323	HRESULT VirtualBoxBase::handleUnexpectedExceptions(VirtualBoxBase *const aThis, RT_SRC_POS_DECL)
324	{
325	try
326	{
327	/* re-throw the current exception */
328	throw;
329	}
330	catch (const RTCError &err) // includes all XML exceptions
331	{
332	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
333	Utf8StrFmt(tr("%s.\n%s[%d] (%s)"),
334	err.what(),
335	pszFile, iLine, pszFunction).c_str(),
336	false /* aWarning */,
337	true /* aLogIt */);
338	}
339	catch (const std::exception &err)
340	{
341	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
342	Utf8StrFmt(tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
343	err.what(), typeid(err).name(),
344	pszFile, iLine, pszFunction).c_str(),
345	false /* aWarning */,
346	true /* aLogIt */);
347	}
348	catch (...)
349	{
350	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
351	Utf8StrFmt(tr("Unknown exception\n%s[%d] (%s)"),
352	pszFile, iLine, pszFunction).c_str(),
353	false /* aWarning */,
354	true /* aLogIt */);
355	}
356
357	/* should not get here */
358	AssertFailed();
359	return E_FAIL;
360	}
361
362	/**
363	* Sets error info for the current thread. This is an internal function that
364	* gets eventually called by all public variants. If @a aWarning is
365	* @c true, then the highest (31) bit in the @a aResultCode value which
366	* indicates the error severity is reset to zero to make sure the receiver will
367	* recognize that the created error info object represents a warning rather
368	* than an error.
369	*/
370	/* static */
371	HRESULT VirtualBoxBase::setErrorInternal(HRESULT aResultCode,
372	const GUID &aIID,
373	const char *pcszComponent,
374	Utf8Str aText,
375	bool aWarning,
376	bool aLogIt)
377	{
378	/* whether multi-error mode is turned on */
379	bool preserve = MultiResult::isMultiEnabled();
380
381	if (aLogIt)
382	LogRel(("%s [COM]: aRC=%Rhrc (%#08x) aIID={%RTuuid} aComponent={%s} aText={%s}, preserve=%RTbool\n",
383	aWarning ? "WARNING" : "ERROR",
384	aResultCode,
385	aResultCode,
386	&aIID,
387	pcszComponent,
388	aText.c_str(),
389	aWarning,
390	preserve));
391
392	/* these are mandatory, others -- not */
393	AssertReturn((!aWarning && FAILED(aResultCode)) \|\|
394	(aWarning && aResultCode != S_OK),
395	E_FAIL);
396
397	/* reset the error severity bit if it's a warning */
398	if (aWarning)
399	aResultCode &= ~0x80000000;
400
401	HRESULT rc = S_OK;
402
403	if (aText.isEmpty())
404	{
405	/* Some default info */
406	switch (aResultCode)
407	{
408	case E_INVALIDARG: aText = "A parameter has an invalid value"; break;
409	case E_POINTER: aText = "A parameter is an invalid pointer"; break;
410	case E_UNEXPECTED: aText = "The result of the operation is unexpected"; break;
411	case E_ACCESSDENIED: aText = "The access to an object is not allowed"; break;
412	case E_OUTOFMEMORY: aText = "The allocation of new memory failed"; break;
413	case E_NOTIMPL: aText = "The requested operation is not implemented"; break;
414	case E_NOINTERFACE: aText = "The requested interface is not implemented"; break;
415	case E_FAIL: aText = "A general error occurred"; break;
416	case E_ABORT: aText = "The operation was canceled"; break;
417	case VBOX_E_OBJECT_NOT_FOUND: aText = "Object corresponding to the supplied arguments does not exist"; break;
418	case VBOX_E_INVALID_VM_STATE: aText = "Current virtual machine state prevents the operation"; break;
419	case VBOX_E_VM_ERROR: aText = "Virtual machine error occurred attempting the operation"; break;
420	case VBOX_E_FILE_ERROR: aText = "File not accessible or erroneous file contents"; break;
421	case VBOX_E_IPRT_ERROR: aText = "Runtime subsystem error"; break;
422	case VBOX_E_PDM_ERROR: aText = "Pluggable Device Manager error"; break;
423	case VBOX_E_INVALID_OBJECT_STATE: aText = "Current object state prohibits operation"; break;
424	case VBOX_E_HOST_ERROR: aText = "Host operating system related error"; break;
425	case VBOX_E_NOT_SUPPORTED: aText = "Requested operation is not supported"; break;
426	case VBOX_E_XML_ERROR: aText = "Invalid XML found"; break;
427	case VBOX_E_INVALID_SESSION_STATE: aText = "Current session state prohibits operation"; break;
428	case VBOX_E_OBJECT_IN_USE: aText = "Object being in use prohibits operation"; break;
429	default: aText = "Unknown error"; break;
430	}
431	}
432
433	do
434	{
435	ComObjPtr<VirtualBoxErrorInfo> info;
436	rc = info.createObject();
437	if (FAILED(rc)) break;
438
439	#if !defined (VBOX_WITH_XPCOM)
440
441	ComPtr<IVirtualBoxErrorInfo> curInfo;
442	if (preserve)
443	{
444	/* get the current error info if any */
445	ComPtr<IErrorInfo> err;
446	rc = ::GetErrorInfo (0, err.asOutParam());
447	if (FAILED(rc)) break;
448	rc = err.queryInterfaceTo(curInfo.asOutParam());
449	if (FAILED(rc))
450	{
451	/* create a IVirtualBoxErrorInfo wrapper for the native
452	* IErrorInfo object */
453	ComObjPtr<VirtualBoxErrorInfo> wrapper;
454	rc = wrapper.createObject();
455	if (SUCCEEDED(rc))
456	{
457	rc = wrapper->init (err);
458	if (SUCCEEDED(rc))
459	curInfo = wrapper;
460	}
461	}
462	}
463	/* On failure, curInfo will stay null */
464	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
465
466	/* set the current error info and preserve the previous one if any */
467	rc = info->init(aResultCode, aIID, pcszComponent, aText, curInfo);
468	if (FAILED(rc)) break;
469
470	ComPtr<IErrorInfo> err;
471	rc = info.queryInterfaceTo(err.asOutParam());
472	if (SUCCEEDED(rc))
473	rc = ::SetErrorInfo (0, err);
474
475	#else // !defined (VBOX_WITH_XPCOM)
476
477	nsCOMPtr <nsIExceptionService> es;
478	es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
479	if (NS_SUCCEEDED(rc))
480	{
481	nsCOMPtr <nsIExceptionManager> em;
482	rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
483	if (FAILED(rc)) break;
484
485	ComPtr<IVirtualBoxErrorInfo> curInfo;
486	if (preserve)
487	{
488	/* get the current error info if any */
489	ComPtr<nsIException> ex;
490	rc = em->GetCurrentException (ex.asOutParam());
491	if (FAILED(rc)) break;
492	rc = ex.queryInterfaceTo(curInfo.asOutParam());
493	if (FAILED(rc))
494	{
495	/* create a IVirtualBoxErrorInfo wrapper for the native
496	* nsIException object */
497	ComObjPtr<VirtualBoxErrorInfo> wrapper;
498	rc = wrapper.createObject();
499	if (SUCCEEDED(rc))
500	{
501	rc = wrapper->init (ex);
502	if (SUCCEEDED(rc))
503	curInfo = wrapper;
504	}
505	}
506	}
507	/* On failure, curInfo will stay null */
508	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
509
510	/* set the current error info and preserve the previous one if any */
511	rc = info->init(aResultCode, aIID, pcszComponent, Bstr(aText), curInfo);
512	if (FAILED(rc)) break;
513
514	ComPtr<nsIException> ex;
515	rc = info.queryInterfaceTo(ex.asOutParam());
516	if (SUCCEEDED(rc))
517	rc = em->SetCurrentException (ex);
518	}
519	else if (rc == NS_ERROR_UNEXPECTED)
520	{
521	/*
522	* It is possible that setError() is being called by the object
523	* after the XPCOM shutdown sequence has been initiated
524	* (for example, when XPCOM releases all instances it internally
525	* references, which can cause object's FinalConstruct() and then
526	* uninit()). In this case, do_GetService() above will return
527	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
528	* set the exception (nobody will be able to read it).
529	*/
530	LogWarningFunc(("Will not set an exception because nsIExceptionService is not available "
531	"(NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
532	rc = NS_OK;
533	}
534
535	#endif // !defined (VBOX_WITH_XPCOM)
536	}
537	while (0);
538
539	AssertComRC (rc);
540
541	return SUCCEEDED(rc) ? aResultCode : rc;
542	}
543
544	/**
545	* Shortcut instance method to calling the static setErrorInternal with the
546	* class interface ID and component name inserted correctly. This uses the
547	* virtual getClassIID() and getComponentName() methods which are automatically
548	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
549	* @param aResultCode
550	* @param pcsz
551	* @return
552	*/
553	HRESULT VirtualBoxBase::setError(HRESULT aResultCode)
554	{
555	return setErrorInternal(aResultCode,
556	this->getClassIID(),
557	this->getComponentName(),
558	"",
559	false /* aWarning */,
560	true /* aLogIt */);
561	}
562
563	/**
564	* Shortcut instance method to calling the static setErrorInternal with the
565	* class interface ID and component name inserted correctly. This uses the
566	* virtual getClassIID() and getComponentName() methods which are automatically
567	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
568	* @param aResultCode
569	* @return
570	*/
571	HRESULT VirtualBoxBase::setError(HRESULT aResultCode, const char *pcsz, ...)
572	{
573	va_list args;
574	va_start(args, pcsz);
575	HRESULT rc = setErrorInternal(aResultCode,
576	this->getClassIID(),
577	this->getComponentName(),
578	Utf8Str(pcsz, args),
579	false /* aWarning */,
580	true /* aLogIt */);
581	va_end(args);
582	return rc;
583	}
584
585	/**
586	* Shortcut instance method to calling the static setErrorInternal with the
587	* class interface ID and component name inserted correctly. This uses the
588	* virtual getClassIID() and getComponentName() methods which are automatically
589	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
590	* @param ei
591	* @return
592	*/
593	HRESULT VirtualBoxBase::setError(const com::ErrorInfo &ei)
594	{
595	/* whether multi-error mode is turned on */
596	bool preserve = MultiResult::isMultiEnabled();
597
598	HRESULT rc = S_OK;
599
600	do
601	{
602	ComObjPtr<VirtualBoxErrorInfo> info;
603	rc = info.createObject();
604	if (FAILED(rc)) break;
605
606	#if !defined (VBOX_WITH_XPCOM)
607
608	ComPtr<IVirtualBoxErrorInfo> curInfo;
609	if (preserve)
610	{
611	/* get the current error info if any */
612	ComPtr<IErrorInfo> err;
613	rc = ::GetErrorInfo (0, err.asOutParam());
614	if (FAILED(rc)) break;
615	rc = err.queryInterfaceTo(curInfo.asOutParam());
616	if (FAILED(rc))
617	{
618	/* create a IVirtualBoxErrorInfo wrapper for the native
619	* IErrorInfo object */
620	ComObjPtr<VirtualBoxErrorInfo> wrapper;
621	rc = wrapper.createObject();
622	if (SUCCEEDED(rc))
623	{
624	rc = wrapper->init (err);
625	if (SUCCEEDED(rc))
626	curInfo = wrapper;
627	}
628	}
629	}
630	/* On failure, curInfo will stay null */
631	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
632
633	/* set the current error info and preserve the previous one if any */
634	rc = info->init(ei, curInfo);
635	if (FAILED(rc)) break;
636
637	ComPtr<IErrorInfo> err;
638	rc = info.queryInterfaceTo(err.asOutParam());
639	if (SUCCEEDED(rc))
640	rc = ::SetErrorInfo (0, err);
641
642	#else // !defined (VBOX_WITH_XPCOM)
643
644	nsCOMPtr <nsIExceptionService> es;
645	es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
646	if (NS_SUCCEEDED(rc))
647	{
648	nsCOMPtr <nsIExceptionManager> em;
649	rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
650	if (FAILED(rc)) break;
651
652	ComPtr<IVirtualBoxErrorInfo> curInfo;
653	if (preserve)
654	{
655	/* get the current error info if any */
656	ComPtr<nsIException> ex;
657	rc = em->GetCurrentException (ex.asOutParam());
658	if (FAILED(rc)) break;
659	rc = ex.queryInterfaceTo(curInfo.asOutParam());
660	if (FAILED(rc))
661	{
662	/* create a IVirtualBoxErrorInfo wrapper for the native
663	* nsIException object */
664	ComObjPtr<VirtualBoxErrorInfo> wrapper;
665	rc = wrapper.createObject();
666	if (SUCCEEDED(rc))
667	{
668	rc = wrapper->init (ex);
669	if (SUCCEEDED(rc))
670	curInfo = wrapper;
671	}
672	}
673	}
674	/* On failure, curInfo will stay null */
675	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
676
677	/* set the current error info and preserve the previous one if any */
678	rc = info->init(ei, curInfo);
679	if (FAILED(rc)) break;
680
681	ComPtr<nsIException> ex;
682	rc = info.queryInterfaceTo(ex.asOutParam());
683	if (SUCCEEDED(rc))
684	rc = em->SetCurrentException (ex);
685	}
686	else if (rc == NS_ERROR_UNEXPECTED)
687	{
688	/*
689	* It is possible that setError() is being called by the object
690	* after the XPCOM shutdown sequence has been initiated
691	* (for example, when XPCOM releases all instances it internally
692	* references, which can cause object's FinalConstruct() and then
693	* uninit()). In this case, do_GetService() above will return
694	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
695	* set the exception (nobody will be able to read it).
696	*/
697	LogWarningFunc(("Will not set an exception because nsIExceptionService is not available "
698	"(NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
699	rc = NS_OK;
700	}
701
702	#endif // !defined (VBOX_WITH_XPCOM)
703	}
704	while (0);
705
706	AssertComRC (rc);
707
708	return SUCCEEDED(rc) ? ei.getResultCode() : rc;
709	}
710
711	/**
712	* Like setError(), but sets the "warning" bit in the call to setErrorInternal().
713	* @param aResultCode
714	* @param pcsz
715	* @return
716	*/
717	HRESULT VirtualBoxBase::setWarning(HRESULT aResultCode, const char *pcsz, ...)
718	{
719	va_list args;
720	va_start(args, pcsz);
721	HRESULT rc = setErrorInternal(aResultCode,
722	this->getClassIID(),
723	this->getComponentName(),
724	Utf8Str(pcsz, args),
725	true /* aWarning */,
726	true /* aLogIt */);
727	va_end(args);
728	return rc;
729	}
730
731	/**
732	* Like setError(), but disables the "log" flag in the call to setErrorInternal().
733	* @param aResultCode
734	* @param pcsz
735	* @return
736	*/
737	HRESULT VirtualBoxBase::setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...)
738	{
739	va_list args;
740	va_start(args, pcsz);
741	HRESULT rc = setErrorInternal(aResultCode,
742	this->getClassIID(),
743	this->getComponentName(),
744	Utf8Str(pcsz, args),
745	false /* aWarning */,
746	false /* aLogIt */);
747	va_end(args);
748	return rc;
749	}
750
751	/**
752	* Clear the current error information.
753	*/
754	/static/
755	void VirtualBoxBase::clearError(void)
756	{
757	#if !defined(VBOX_WITH_XPCOM)
758	::SetErrorInfo (0, NULL);
759	#else
760	HRESULT rc = S_OK;
761	nsCOMPtr <nsIExceptionService> es;
762	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
763	if (NS_SUCCEEDED(rc))
764	{
765	nsCOMPtr <nsIExceptionManager> em;
766	rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
767	if (SUCCEEDED(rc))
768	em->SetCurrentException(NULL);
769	}
770	#endif
771	}
772
773
774	////////////////////////////////////////////////////////////////////////////////
775	//
776	// AutoInitSpan methods
777	//
778	////////////////////////////////////////////////////////////////////////////////
779
780	/**
781	* Creates a smart initialization span object that places the object to
782	* InInit state.
783	*
784	* Please see the AutoInitSpan class description for more info.
785	*
786	* @param aObj \|this\| pointer of the managed VirtualBoxBase object whose
787	* init() method is being called.
788	* @param aResult Default initialization result.
789	*/
790	AutoInitSpan::AutoInitSpan(VirtualBoxBase *aObj,
791	Result aResult /* = Failed */)
792	: mObj(aObj),
793	mResult(aResult),
794	mOk(false)
795	{
796	Assert(aObj);
797
798	AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
799
800	mOk = mObj->mState == VirtualBoxBase::NotReady;
801	AssertReturnVoid (mOk);
802
803	mObj->setState(VirtualBoxBase::InInit);
804	}
805
806	/**
807	* Places the managed VirtualBoxBase object to Ready/Limited state if the
808	* initialization succeeded or partly succeeded, or places it to InitFailed
809	* state and calls the object's uninit() method.
810	*
811	* Please see the AutoInitSpan class description for more info.
812	*/
813	AutoInitSpan::~AutoInitSpan()
814	{
815	/* if the state was other than NotReady, do nothing */
816	if (!mOk)
817	return;
818
819	AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
820
821	Assert(mObj->mState == VirtualBoxBase::InInit);
822
823	if (mObj->mCallers > 0)
824	{
825	Assert(mObj->mInitUninitWaiters > 0);
826
827	/* We have some pending addCaller() calls on other threads (created
828	* during InInit), signal that InInit is finished and they may go on. */
829	RTSemEventMultiSignal(mObj->mInitUninitSem);
830	}
831
832	if (mResult == Succeeded)
833	{
834	mObj->setState(VirtualBoxBase::Ready);
835	}
836	else
837	if (mResult == Limited)
838	{
839	mObj->setState(VirtualBoxBase::Limited);
840	}
841	else
842	{
843	mObj->setState(VirtualBoxBase::InitFailed);
844	/* release the lock to prevent nesting when uninit() is called */
845	stateLock.release();
846	/* call uninit() to let the object uninit itself after failed init() */
847	mObj->uninit();
848	/* Note: the object may no longer exist here (for example, it can call
849	* the destructor in uninit()) */
850	}
851	}
852
853	// AutoReinitSpan methods
854	////////////////////////////////////////////////////////////////////////////////
855
856	/**
857	* Creates a smart re-initialization span object and places the object to
858	* InInit state.
859	*
860	* Please see the AutoInitSpan class description for more info.
861	*
862	* @param aObj \|this\| pointer of the managed VirtualBoxBase object whose
863	* re-initialization method is being called.
864	*/
865	AutoReinitSpan::AutoReinitSpan(VirtualBoxBase *aObj)
866	: mObj(aObj),
867	mSucceeded(false),
868	mOk(false)
869	{
870	Assert(aObj);
871
872	AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
873
874	mOk = mObj->mState == VirtualBoxBase::Limited;
875	AssertReturnVoid (mOk);
876
877	mObj->setState(VirtualBoxBase::InInit);
878	}
879
880	/**
881	* Places the managed VirtualBoxBase object to Ready state if the
882	* re-initialization succeeded (i.e. #setSucceeded() has been called) or back to
883	* Limited state otherwise.
884	*
885	* Please see the AutoInitSpan class description for more info.
886	*/
887	AutoReinitSpan::~AutoReinitSpan()
888	{
889	/* if the state was other than Limited, do nothing */
890	if (!mOk)
891	return;
892
893	AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
894
895	Assert(mObj->mState == VirtualBoxBase::InInit);
896
897	if (mObj->mCallers > 0 && mObj->mInitUninitWaiters > 0)
898	{
899	/* We have some pending addCaller() calls on other threads (created
900	* during InInit), signal that InInit is finished and they may go on. */
901	RTSemEventMultiSignal(mObj->mInitUninitSem);
902	}
903
904	if (mSucceeded)
905	{
906	mObj->setState(VirtualBoxBase::Ready);
907	}
908	else
909	{
910	mObj->setState(VirtualBoxBase::Limited);
911	}
912	}
913
914	// AutoUninitSpan methods
915	////////////////////////////////////////////////////////////////////////////////
916
917	/**
918	* Creates a smart uninitialization span object and places this object to
919	* InUninit state.
920	*
921	* Please see the AutoInitSpan class description for more info.
922	*
923	* @note This method blocks the current thread execution until the number of
924	* callers of the managed VirtualBoxBase object drops to zero!
925	*
926	* @param aObj \|this\| pointer of the VirtualBoxBase object whose uninit()
927	* method is being called.
928	*/
929	AutoUninitSpan::AutoUninitSpan(VirtualBoxBase *aObj)
930	: mObj(aObj),
931	mInitFailed(false),
932	mUninitDone(false)
933	{
934	Assert(aObj);
935
936	AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
937
938	Assert(mObj->mState != VirtualBoxBase::InInit);
939
940	/* Set mUninitDone to \|true\| if this object is already uninitialized
941	* (NotReady) or if another AutoUninitSpan is currently active on some
942	* other thread (InUninit). */
943	mUninitDone = mObj->mState == VirtualBoxBase::NotReady
944	\|\| mObj->mState == VirtualBoxBase::InUninit;
945
946	if (mObj->mState == VirtualBoxBase::InitFailed)
947	{
948	/* we've been called by init() on failure */
949	mInitFailed = true;
950	}
951	else
952	{
953	if (mUninitDone)
954	{
955	/* do nothing if already uninitialized */
956	if (mObj->mState == VirtualBoxBase::NotReady)
957	return;
958
959	/* otherwise, wait until another thread finishes uninitialization.
960	* This is necessary to make sure that when this method returns, the
961	* object is NotReady and therefore can be deleted (for example). */
962
963	/* lazy semaphore creation */
964	if (mObj->mInitUninitSem == NIL_RTSEMEVENTMULTI)
965	{
966	RTSemEventMultiCreate(&mObj->mInitUninitSem);
967	Assert(mObj->mInitUninitWaiters == 0);
968	}
969	++mObj->mInitUninitWaiters;
970
971	LogFlowFunc(("{%p}: Waiting for AutoUninitSpan to finish...\n",
972	mObj));
973
974	stateLock.release();
975	RTSemEventMultiWait(mObj->mInitUninitSem, RT_INDEFINITE_WAIT);
976	stateLock.acquire();
977
978	if (--mObj->mInitUninitWaiters == 0)
979	{
980	/* destroy the semaphore since no more necessary */
981	RTSemEventMultiDestroy(mObj->mInitUninitSem);
982	mObj->mInitUninitSem = NIL_RTSEMEVENTMULTI;
983	}
984
985	return;
986	}
987	}
988
989	/* go to InUninit to prevent from adding new callers */
990	mObj->setState(VirtualBoxBase::InUninit);
991
992	/* wait for already existing callers to drop to zero */
993	if (mObj->mCallers > 0)
994	{
995	/* lazy creation */
996	Assert(mObj->mZeroCallersSem == NIL_RTSEMEVENT);
997	RTSemEventCreate(&mObj->mZeroCallersSem);
998
999	/* wait until remaining callers release the object */
1000	LogFlowFunc(("{%p}: Waiting for callers (%d) to drop to zero...\n",
1001	mObj, mObj->mCallers));
1002
1003	stateLock.release();
1004	RTSemEventWait(mObj->mZeroCallersSem, RT_INDEFINITE_WAIT);
1005	}
1006	}
1007
1008	/**
1009	* Places the managed VirtualBoxBase object to the NotReady state.
1010	*/
1011	AutoUninitSpan::~AutoUninitSpan()
1012	{
1013	/* do nothing if already uninitialized */
1014	if (mUninitDone)
1015	return;
1016
1017	AutoWriteLock stateLock(mObj->mStateLock COMMA_LOCKVAL_SRC_POS);
1018
1019	Assert(mObj->mState == VirtualBoxBase::InUninit);
1020
1021	mObj->setState(VirtualBoxBase::NotReady);
1022	}
1023
1024	////////////////////////////////////////////////////////////////////////////////
1025	//
1026	// MultiResult methods
1027	//
1028	////////////////////////////////////////////////////////////////////////////////
1029
1030	RTTLS MultiResult::sCounter = NIL_RTTLS;
1031
1032	/static/
1033	void MultiResult::incCounter()
1034	{
1035	if (sCounter == NIL_RTTLS)
1036	{
1037	sCounter = RTTlsAlloc();
1038	AssertReturnVoid(sCounter != NIL_RTTLS);
1039	}
1040
1041	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
1042	++counter;
1043	RTTlsSet(sCounter, (void*)counter);
1044	}
1045
1046	/static/
1047	void MultiResult::decCounter()
1048	{
1049	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
1050	AssertReturnVoid(counter != 0);
1051	--counter;
1052	RTTlsSet(sCounter, (void*)counter);
1053	}
1054
1055	/static/
1056	bool MultiResult::isMultiEnabled()
1057	{
1058	if (sCounter == NIL_RTTLS)
1059	return false;
1060
1061	return ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
1062	}
1063

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

source: vbox/trunk/src/VBox/Main/src-all/VirtualBoxBase.cpp@ 44591

Download in other formats: