VirtualBoxBase.cpp@ 63183

Last change on this file since 63183 was 63147, checked in by vboxsync, 8 years ago
Main: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 27.8 KB

Line
1	/* $Id: VirtualBoxBase.cpp 63147 2016-08-08 11:12:33Z vboxsync $ */
2
3	/** @file
4	*
5	* VirtualBox COM base classes implementation
6	*/
7
8	/*
9	* Copyright (C) 2006-2016 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 <iprt/win/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	#include "Global.h"
40
41	#include "VBox/com/ErrorInfo.h"
42	#include "VBox/com/MultiResult.h"
43
44	////////////////////////////////////////////////////////////////////////////////
45	//
46	// VirtualBoxBase
47	//
48	////////////////////////////////////////////////////////////////////////////////
49
50	CLASSFACTORY_STAT g_aClassFactoryStats[CLASSFACTORYSTATS_MAX] =
51	{
52	{ "--- totals ---", 0 },
53	{ NULL, 0 }
54	};
55
56	RWLockHandle *g_pClassFactoryStatsLock = NULL;
57
58
59	VirtualBoxBase::VirtualBoxBase() :
60	mState(this),
61	iFactoryStat(~0U)
62	{
63	mObjectLock = NULL;
64
65	if (!g_pClassFactoryStatsLock)
66	{
67	RWLockHandle *lock = new RWLockHandle(LOCKCLASS_OBJECTSTATE);
68	if (!ASMAtomicCmpXchgPtr(&g_pClassFactoryStatsLock, lock, NULL))
69	delete lock;
70	}
71	Assert(g_pClassFactoryStatsLock);
72	}
73
74	VirtualBoxBase::~VirtualBoxBase()
75	{
76	Assert(iFactoryStat == ~0U);
77	if (mObjectLock)
78	delete mObjectLock;
79	}
80
81	HRESULT VirtualBoxBase::BaseFinalConstruct()
82	{
83	Assert(iFactoryStat == ~0U);
84	if (g_pClassFactoryStatsLock)
85	{
86	AutoWriteLock alock(g_pClassFactoryStatsLock COMMA_LOCKVAL_SRC_POS);
87	g_aClassFactoryStats[0].current++;
88	g_aClassFactoryStats[0].overall++;
89	const char *pszName = getComponentName();
90	uint32_t i = 1;
91	while (i < CLASSFACTORYSTATS_MAX && g_aClassFactoryStats[i].psz)
92	{
93	if (g_aClassFactoryStats[i].psz == pszName)
94	break;
95	i++;
96	}
97	if (i < CLASSFACTORYSTATS_MAX)
98	{
99	if (!g_aClassFactoryStats[i].psz)
100	{
101	g_aClassFactoryStats[i].psz = pszName;
102	g_aClassFactoryStats[i].current = 0;
103	g_aClassFactoryStats[i].overall = 0;
104	}
105	iFactoryStat = i;
106	g_aClassFactoryStats[i].current++;
107	g_aClassFactoryStats[i].overall++;
108	}
109	else
110	AssertMsg(i < CLASSFACTORYSTATS_MAX, ("%u exhausts size of factory housekeeping array\n", i));
111	}
112	else
113	Assert(g_pClassFactoryStatsLock);
114
115	#ifdef RT_OS_WINDOWS
116	return CoCreateFreeThreadedMarshaler(this, //GetControllingUnknown(),
117	m_pUnkMarshaler.asOutParam());
118	#else
119	return S_OK;
120	#endif
121	}
122
123	void VirtualBoxBase::BaseFinalRelease()
124	{
125	if (g_pClassFactoryStatsLock)
126	{
127	AutoWriteLock alock(g_pClassFactoryStatsLock COMMA_LOCKVAL_SRC_POS);
128	g_aClassFactoryStats[0].current--;
129	const char *pszName = getComponentName();
130	if (iFactoryStat < CLASSFACTORYSTATS_MAX)
131	{
132	if (g_aClassFactoryStats[iFactoryStat].psz == pszName)
133	{
134	g_aClassFactoryStats[iFactoryStat].current--;
135	iFactoryStat = ~0U;
136	}
137	else
138	AssertMsgFailed(("could not find factory housekeeping array entry for %s (index %u contains %s)\n", pszName, iFactoryStat, g_aClassFactoryStats[iFactoryStat].psz));
139	}
140	else
141	AssertMsgFailed(("factory housekeeping array corruption, index %u is too large\n", iFactoryStat));
142	}
143	else
144	Assert(g_pClassFactoryStatsLock);
145
146	#ifdef RT_OS_WINDOWS
147	m_pUnkMarshaler.setNull();
148	#endif
149	}
150
151	void APIDumpComponentFactoryStats()
152	{
153	if (g_pClassFactoryStatsLock)
154	{
155	AutoReadLock alock(g_pClassFactoryStatsLock COMMA_LOCKVAL_SRC_POS);
156	for (uint32_t i = 0; i < CLASSFACTORYSTATS_MAX && g_aClassFactoryStats[i].psz; i++)
157	LogRel(("CFS: component %-30s current %-10u total %-10u\n",
158	g_aClassFactoryStats[i].psz, g_aClassFactoryStats[i].current,
159	g_aClassFactoryStats[i].overall));
160	}
161	else
162	Assert(g_pClassFactoryStatsLock);
163	}
164
165	/**
166	* This virtual method returns an RWLockHandle that can be used to
167	* protect instance data. This RWLockHandle is generally referred to
168	* as the "object lock"; its locking class (for lock order validation)
169	* must be returned by another virtual method, getLockingClass(), which
170	* by default returns LOCKCLASS_OTHEROBJECT but is overridden by several
171	* subclasses such as VirtualBox, Host, Machine and others.
172	*
173	* On the first call this method lazily creates the RWLockHandle.
174	*
175	* @return
176	*/
177	/* virtual */
178	RWLockHandle *VirtualBoxBase::lockHandle() const
179	{
180	/* lazy initialization */
181	if (RT_LIKELY(mObjectLock))
182	return mObjectLock;
183
184	AssertCompile(sizeof(RWLockHandle ) == sizeof(void ));
185
186	// getLockingClass() is overridden by many subclasses to return
187	// one of the locking classes listed at the top of AutoLock.h
188	RWLockHandle *objLock = new RWLockHandle(getLockingClass());
189	if (!ASMAtomicCmpXchgPtr(&mObjectLock, objLock, NULL))
190	{
191	delete objLock;
192	objLock = ASMAtomicReadPtrT(&mObjectLock, RWLockHandle *);
193	}
194	return objLock;
195	}
196
197	/**
198	* Handles unexpected exceptions by turning them into COM errors in release
199	* builds or by hitting a breakpoint in the release builds.
200	*
201	* Usage pattern:
202	* @code
203	try
204	{
205	// ...
206	}
207	catch (LaLalA)
208	{
209	// ...
210	}
211	catch (...)
212	{
213	rc = VirtualBox::handleUnexpectedExceptions(this, RT_SRC_POS);
214	}
215	* @endcode
216	*
217	* @param aThis object where the exception happened
218	* @param RT_SRC_POS_DECL "RT_SRC_POS" macro instantiation.
219	* */
220	/* static */
221	HRESULT VirtualBoxBase::handleUnexpectedExceptions(VirtualBoxBase *const aThis, RT_SRC_POS_DECL)
222	{
223	try
224	{
225	/* re-throw the current exception */
226	throw;
227	}
228	catch (const RTCError &err) // includes all XML exceptions
229	{
230	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
231	Utf8StrFmt(tr("%s.\n%s[%d] (%s)"),
232	err.what(),
233	pszFile, iLine, pszFunction).c_str(),
234	false /* aWarning */,
235	true /* aLogIt */);
236	}
237	catch (const std::exception &err)
238	{
239	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
240	Utf8StrFmt(tr("Unexpected exception: %s [%s]\n%s[%d] (%s)"),
241	err.what(), typeid(err).name(),
242	pszFile, iLine, pszFunction).c_str(),
243	false /* aWarning */,
244	true /* aLogIt */);
245	}
246	catch (...)
247	{
248	return setErrorInternal(E_FAIL, aThis->getClassIID(), aThis->getComponentName(),
249	Utf8StrFmt(tr("Unknown exception\n%s[%d] (%s)"),
250	pszFile, iLine, pszFunction).c_str(),
251	false /* aWarning */,
252	true /* aLogIt */);
253	}
254
255	#ifndef _MSC_VER /* (unreachable) */
256	/* should not get here */
257	AssertFailed();
258	return E_FAIL;
259	#endif
260	}
261
262	/**
263	* Sets error info for the current thread. This is an internal function that
264	* gets eventually called by all public variants. If @a aWarning is
265	* @c true, then the highest (31) bit in the @a aResultCode value which
266	* indicates the error severity is reset to zero to make sure the receiver will
267	* recognize that the created error info object represents a warning rather
268	* than an error.
269	*/
270	/* static */
271	HRESULT VirtualBoxBase::setErrorInternal(HRESULT aResultCode,
272	const GUID &aIID,
273	const char *pcszComponent,
274	Utf8Str aText,
275	bool aWarning,
276	bool aLogIt,
277	LONG aResultDetail /* = 0*/)
278	{
279	/* whether multi-error mode is turned on */
280	bool preserve = MultiResult::isMultiEnabled();
281
282	if (aLogIt)
283	LogRel(("%s [COM]: aRC=%Rhrc (%#08x) aIID={%RTuuid} aComponent={%s} aText={%s}, preserve=%RTbool aResultDetail=%d\n",
284	aWarning ? "WARNING" : "ERROR",
285	aResultCode,
286	aResultCode,
287	&aIID,
288	pcszComponent,
289	aText.c_str(),
290	preserve,
291	aResultDetail));
292
293	/* these are mandatory, others -- not */
294	AssertReturn((!aWarning && FAILED(aResultCode)) \|\|
295	(aWarning && aResultCode != S_OK),
296	E_FAIL);
297
298	/* reset the error severity bit if it's a warning */
299	if (aWarning)
300	aResultCode &= ~0x80000000;
301
302	HRESULT rc = S_OK;
303
304	if (aText.isEmpty())
305	{
306	/* Some default info */
307	switch (aResultCode)
308	{
309	case E_INVALIDARG: aText = "A parameter has an invalid value"; break;
310	case E_POINTER: aText = "A parameter is an invalid pointer"; break;
311	case E_UNEXPECTED: aText = "The result of the operation is unexpected"; break;
312	case E_ACCESSDENIED: aText = "The access to an object is not allowed"; break;
313	case E_OUTOFMEMORY: aText = "The allocation of new memory failed"; break;
314	case E_NOTIMPL: aText = "The requested operation is not implemented"; break;
315	case E_NOINTERFACE: aText = "The requested interface is not implemented"; break;
316	case E_FAIL: aText = "A general error occurred"; break;
317	case E_ABORT: aText = "The operation was canceled"; break;
318	case VBOX_E_OBJECT_NOT_FOUND: aText = "Object corresponding to the supplied arguments does not exist"; break;
319	case VBOX_E_INVALID_VM_STATE: aText = "Current virtual machine state prevents the operation"; break;
320	case VBOX_E_VM_ERROR: aText = "Virtual machine error occurred attempting the operation"; break;
321	case VBOX_E_FILE_ERROR: aText = "File not accessible or erroneous file contents"; break;
322	case VBOX_E_IPRT_ERROR: aText = "Runtime subsystem error"; break;
323	case VBOX_E_PDM_ERROR: aText = "Pluggable Device Manager error"; break;
324	case VBOX_E_INVALID_OBJECT_STATE: aText = "Current object state prohibits operation"; break;
325	case VBOX_E_HOST_ERROR: aText = "Host operating system related error"; break;
326	case VBOX_E_NOT_SUPPORTED: aText = "Requested operation is not supported"; break;
327	case VBOX_E_XML_ERROR: aText = "Invalid XML found"; break;
328	case VBOX_E_INVALID_SESSION_STATE: aText = "Current session state prohibits operation"; break;
329	case VBOX_E_OBJECT_IN_USE: aText = "Object being in use prohibits operation"; break;
330	default: aText = "Unknown error"; break;
331	}
332	}
333
334	do
335	{
336	ComObjPtr<VirtualBoxErrorInfo> info;
337	rc = info.createObject();
338	if (FAILED(rc)) break;
339
340	#if !defined(VBOX_WITH_XPCOM)
341
342	ComPtr<IVirtualBoxErrorInfo> curInfo;
343	if (preserve)
344	{
345	/* get the current error info if any */
346	ComPtr<IErrorInfo> err;
347	rc = ::GetErrorInfo(0, err.asOutParam());
348	if (FAILED(rc)) break;
349	rc = err.queryInterfaceTo(curInfo.asOutParam());
350	if (FAILED(rc))
351	{
352	/* create a IVirtualBoxErrorInfo wrapper for the native
353	* IErrorInfo object */
354	ComObjPtr<VirtualBoxErrorInfo> wrapper;
355	rc = wrapper.createObject();
356	if (SUCCEEDED(rc))
357	{
358	rc = wrapper->init(err);
359	if (SUCCEEDED(rc))
360	curInfo = wrapper;
361	}
362	}
363	}
364	/* On failure, curInfo will stay null */
365	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
366
367	/* set the current error info and preserve the previous one if any */
368	rc = info->initEx(aResultCode, aResultDetail, aIID, pcszComponent, aText, curInfo);
369	if (FAILED(rc)) break;
370
371	ComPtr<IErrorInfo> err;
372	rc = info.queryInterfaceTo(err.asOutParam());
373	if (SUCCEEDED(rc))
374	rc = ::SetErrorInfo(0, err);
375
376	#else // !defined(VBOX_WITH_XPCOM)
377
378	nsCOMPtr <nsIExceptionService> es;
379	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
380	if (NS_SUCCEEDED(rc))
381	{
382	nsCOMPtr <nsIExceptionManager> em;
383	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
384	if (FAILED(rc)) break;
385
386	ComPtr<IVirtualBoxErrorInfo> curInfo;
387	if (preserve)
388	{
389	/* get the current error info if any */
390	ComPtr<nsIException> ex;
391	rc = em->GetCurrentException(ex.asOutParam());
392	if (FAILED(rc)) break;
393	rc = ex.queryInterfaceTo(curInfo.asOutParam());
394	if (FAILED(rc))
395	{
396	/* create a IVirtualBoxErrorInfo wrapper for the native
397	* nsIException object */
398	ComObjPtr<VirtualBoxErrorInfo> wrapper;
399	rc = wrapper.createObject();
400	if (SUCCEEDED(rc))
401	{
402	rc = wrapper->init(ex);
403	if (SUCCEEDED(rc))
404	curInfo = wrapper;
405	}
406	}
407	}
408	/* On failure, curInfo will stay null */
409	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
410
411	/* set the current error info and preserve the previous one if any */
412	rc = info->initEx(aResultCode, aResultDetail, aIID, pcszComponent, Bstr(aText), curInfo);
413	if (FAILED(rc)) break;
414
415	ComPtr<nsIException> ex;
416	rc = info.queryInterfaceTo(ex.asOutParam());
417	if (SUCCEEDED(rc))
418	rc = em->SetCurrentException(ex);
419	}
420	else if (rc == NS_ERROR_UNEXPECTED)
421	{
422	/*
423	* It is possible that setError() is being called by the object
424	* after the XPCOM shutdown sequence has been initiated
425	* (for example, when XPCOM releases all instances it internally
426	* references, which can cause object's FinalConstruct() and then
427	* uninit()). In this case, do_GetService() above will return
428	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
429	* set the exception (nobody will be able to read it).
430	*/
431	Log1WarningFunc(("Will not set an exception because nsIExceptionService is not available (NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
432	rc = NS_OK;
433	}
434
435	#endif // !defined(VBOX_WITH_XPCOM)
436	}
437	while (0);
438
439	AssertComRC(rc);
440
441	return SUCCEEDED(rc) ? aResultCode : rc;
442	}
443
444	/**
445	* Shortcut instance method to calling the static setErrorInternal with the
446	* class interface ID and component name inserted correctly. This uses the
447	* virtual getClassIID() and getComponentName() methods which are automatically
448	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
449	* @param aResultCode
450	* @param pcsz
451	* @return
452	*/
453	HRESULT VirtualBoxBase::setError(HRESULT aResultCode)
454	{
455	return setErrorInternal(aResultCode,
456	this->getClassIID(),
457	this->getComponentName(),
458	"",
459	false /* aWarning */,
460	true /* aLogIt */);
461	}
462
463	/**
464	* Shortcut instance method to calling the static setErrorInternal with the
465	* class interface ID and component name inserted correctly. This uses the
466	* virtual getClassIID() and getComponentName() methods which are automatically
467	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
468	* @param aResultCode
469	* @return
470	*/
471	HRESULT VirtualBoxBase::setError(HRESULT aResultCode, const char *pcsz, ...)
472	{
473	va_list args;
474	va_start(args, pcsz);
475	HRESULT rc = setErrorInternal(aResultCode,
476	this->getClassIID(),
477	this->getComponentName(),
478	Utf8Str(pcsz, args),
479	false /* aWarning */,
480	true /* aLogIt */);
481	va_end(args);
482	return rc;
483	}
484
485	/**
486	* Shortcut instance method to calling the static setErrorInternal with the
487	* class interface ID and component name inserted correctly. This uses the
488	* virtual getClassIID() and getComponentName() methods which are automatically
489	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
490	* @param ei
491	* @return
492	*/
493	HRESULT VirtualBoxBase::setError(const com::ErrorInfo &ei)
494	{
495	/* whether multi-error mode is turned on */
496	bool preserve = MultiResult::isMultiEnabled();
497
498	HRESULT rc = S_OK;
499
500	do
501	{
502	ComObjPtr<VirtualBoxErrorInfo> info;
503	rc = info.createObject();
504	if (FAILED(rc)) break;
505
506	#if !defined(VBOX_WITH_XPCOM)
507
508	ComPtr<IVirtualBoxErrorInfo> curInfo;
509	if (preserve)
510	{
511	/* get the current error info if any */
512	ComPtr<IErrorInfo> err;
513	rc = ::GetErrorInfo(0, err.asOutParam());
514	if (FAILED(rc)) break;
515	rc = err.queryInterfaceTo(curInfo.asOutParam());
516	if (FAILED(rc))
517	{
518	/* create a IVirtualBoxErrorInfo wrapper for the native
519	* IErrorInfo object */
520	ComObjPtr<VirtualBoxErrorInfo> wrapper;
521	rc = wrapper.createObject();
522	if (SUCCEEDED(rc))
523	{
524	rc = wrapper->init(err);
525	if (SUCCEEDED(rc))
526	curInfo = wrapper;
527	}
528	}
529	}
530	/* On failure, curInfo will stay null */
531	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
532
533	/* set the current error info and preserve the previous one if any */
534	rc = info->init(ei, curInfo);
535	if (FAILED(rc)) break;
536
537	ComPtr<IErrorInfo> err;
538	rc = info.queryInterfaceTo(err.asOutParam());
539	if (SUCCEEDED(rc))
540	rc = ::SetErrorInfo(0, err);
541
542	#else // !defined(VBOX_WITH_XPCOM)
543
544	nsCOMPtr <nsIExceptionService> es;
545	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
546	if (NS_SUCCEEDED(rc))
547	{
548	nsCOMPtr <nsIExceptionManager> em;
549	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
550	if (FAILED(rc)) break;
551
552	ComPtr<IVirtualBoxErrorInfo> curInfo;
553	if (preserve)
554	{
555	/* get the current error info if any */
556	ComPtr<nsIException> ex;
557	rc = em->GetCurrentException(ex.asOutParam());
558	if (FAILED(rc)) break;
559	rc = ex.queryInterfaceTo(curInfo.asOutParam());
560	if (FAILED(rc))
561	{
562	/* create a IVirtualBoxErrorInfo wrapper for the native
563	* nsIException object */
564	ComObjPtr<VirtualBoxErrorInfo> wrapper;
565	rc = wrapper.createObject();
566	if (SUCCEEDED(rc))
567	{
568	rc = wrapper->init(ex);
569	if (SUCCEEDED(rc))
570	curInfo = wrapper;
571	}
572	}
573	}
574	/* On failure, curInfo will stay null */
575	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
576
577	/* set the current error info and preserve the previous one if any */
578	rc = info->init(ei, curInfo);
579	if (FAILED(rc)) break;
580
581	ComPtr<nsIException> ex;
582	rc = info.queryInterfaceTo(ex.asOutParam());
583	if (SUCCEEDED(rc))
584	rc = em->SetCurrentException(ex);
585	}
586	else if (rc == NS_ERROR_UNEXPECTED)
587	{
588	/*
589	* It is possible that setError() is being called by the object
590	* after the XPCOM shutdown sequence has been initiated
591	* (for example, when XPCOM releases all instances it internally
592	* references, which can cause object's FinalConstruct() and then
593	* uninit()). In this case, do_GetService() above will return
594	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
595	* set the exception (nobody will be able to read it).
596	*/
597	Log1WarningFunc(("Will not set an exception because nsIExceptionService is not available (NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
598	rc = NS_OK;
599	}
600
601	#endif // !defined(VBOX_WITH_XPCOM)
602	}
603	while (0);
604
605	AssertComRC(rc);
606
607	return SUCCEEDED(rc) ? ei.getResultCode() : rc;
608	}
609
610	/**
611	* Converts the VBox status code a COM one and sets the error info.
612	*
613	* The VBox status code is made available to the API user via
614	* IVirtualBoxErrorInfo::resultDetail attribute.
615	*
616	* @param vrc The VBox status code.
617	* @return COM status code appropriate for @a vrc.
618	*
619	* @sa VirtualBoxBase::setError(HRESULT)
620	*/
621	HRESULT VirtualBoxBase::setErrorVrc(int vrc)
622	{
623	return setErrorInternal(Global::vboxStatusCodeToCOM(vrc),
624	this->getClassIID(),
625	this->getComponentName(),
626	Utf8StrFmt("%Rrc", vrc),
627	false /* aWarning */,
628	true /* aLogIt */,
629	vrc /* aResultDetail */);
630	}
631
632	/**
633	* Converts the VBox status code a COM one and sets the error info.
634	*
635	* @param vrc The VBox status code.
636	* @param pcszMsgFmt Error message format string.
637	* @param ... Argument specified in the @a pcszMsgFmt
638	* @return COM status code appropriate for @a vrc.
639	*
640	* @sa VirtualBoxBase::setError(HRESULT, const char *, ...)
641	*/
642	HRESULT VirtualBoxBase::setErrorVrc(int vrc, const char *pcszMsgFmt, ...)
643	{
644	va_list va;
645	va_start(va, pcszMsgFmt);
646	HRESULT hrc = setErrorInternal(Global::vboxStatusCodeToCOM(vrc),
647	this->getClassIID(),
648	this->getComponentName(),
649	Utf8Str(pcszMsgFmt, va),
650	false /* aWarning */,
651	true /* aLogIt */,
652	vrc /* aResultDetail */);
653	va_end(va);
654	return hrc;
655	}
656
657	/**
658	* Sets error info with both a COM status and an VBox status code.
659	*
660	* The VBox status code is made available to the API user via
661	* IVirtualBoxErrorInfo::resultDetail attribute.
662	*
663	* @param hrc The COM status code to return.
664	* @param vrc The VBox status code.
665	* @return Most likely @a hrc, see setErrorInternal.
666	*
667	* @sa VirtualBoxBase::setError(HRESULT)
668	*/
669	HRESULT VirtualBoxBase::setErrorBoth(HRESULT hrc, int vrc)
670	{
671	return setErrorInternal(hrc,
672	this->getClassIID(),
673	this->getComponentName(),
674	Utf8StrFmt("%Rrc", vrc),
675	false /* aWarning */,
676	true /* aLogIt */,
677	vrc /* aResultDetail */);
678	}
679
680	/**
681	* Sets error info with a message and both a COM status and an VBox status code.
682	*
683	* The VBox status code is made available to the API user via
684	* IVirtualBoxErrorInfo::resultDetail attribute.
685	*
686	* @param hrc The COM status code to return.
687	* @param vrc The VBox status code.
688	* @param pcszMsgFmt Error message format string.
689	* @param ... Argument specified in the @a pcszMsgFmt
690	* @return Most likely @a hrc, see setErrorInternal.
691	*
692	* @sa VirtualBoxBase::setError(HRESULT, const char *, ...)
693	*/
694	HRESULT VirtualBoxBase::setErrorBoth(HRESULT hrc, int vrc, const char *pcszMsgFmt, ...)
695	{
696	va_list va;
697	va_start(va, pcszMsgFmt);
698	hrc = setErrorInternal(hrc,
699	this->getClassIID(),
700	this->getComponentName(),
701	Utf8Str(pcszMsgFmt, va),
702	false /* aWarning */,
703	true /* aLogIt */,
704	vrc /* aResultDetail */);
705	va_end(va);
706	return hrc;
707	}
708
709	/**
710	* Like setError(), but sets the "warning" bit in the call to setErrorInternal().
711	* @param aResultCode
712	* @param pcsz
713	* @return
714	*/
715	HRESULT VirtualBoxBase::setWarning(HRESULT aResultCode, const char *pcsz, ...)
716	{
717	va_list args;
718	va_start(args, pcsz);
719	HRESULT rc = setErrorInternal(aResultCode,
720	this->getClassIID(),
721	this->getComponentName(),
722	Utf8Str(pcsz, args),
723	true /* aWarning */,
724	true /* aLogIt */);
725	va_end(args);
726	return rc;
727	}
728
729	/**
730	* Like setError(), but disables the "log" flag in the call to setErrorInternal().
731	* @param aResultCode
732	* @param pcsz
733	* @return
734	*/
735	HRESULT VirtualBoxBase::setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...)
736	{
737	va_list args;
738	va_start(args, pcsz);
739	HRESULT rc = setErrorInternal(aResultCode,
740	this->getClassIID(),
741	this->getComponentName(),
742	Utf8Str(pcsz, args),
743	false /* aWarning */,
744	false /* aLogIt */);
745	va_end(args);
746	return rc;
747	}
748
749	/**
750	* Clear the current error information.
751	*/
752	/static/
753	void VirtualBoxBase::clearError(void)
754	{
755	#if !defined(VBOX_WITH_XPCOM)
756	::SetErrorInfo(0, NULL);
757	#else
758	HRESULT rc = S_OK;
759	nsCOMPtr <nsIExceptionService> es;
760	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
761	if (NS_SUCCEEDED(rc))
762	{
763	nsCOMPtr <nsIExceptionManager> em;
764	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
765	if (SUCCEEDED(rc))
766	em->SetCurrentException(NULL);
767	}
768	#endif
769	}
770
771
772	////////////////////////////////////////////////////////////////////////////////
773	//
774	// MultiResult methods
775	//
776	////////////////////////////////////////////////////////////////////////////////
777
778	RTTLS MultiResult::sCounter = NIL_RTTLS;
779
780	/static/
781	void MultiResult::incCounter()
782	{
783	if (sCounter == NIL_RTTLS)
784	{
785	sCounter = RTTlsAlloc();
786	AssertReturnVoid(sCounter != NIL_RTTLS);
787	}
788
789	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
790	++counter;
791	RTTlsSet(sCounter, (void*)counter);
792	}
793
794	/static/
795	void MultiResult::decCounter()
796	{
797	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
798	AssertReturnVoid(counter != 0);
799	--counter;
800	RTTlsSet(sCounter, (void*)counter);
801	}
802
803	/static/
804	bool MultiResult::isMultiEnabled()
805	{
806	if (sCounter == NIL_RTTLS)
807	return false;
808
809	return ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
810	}
811

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

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

Download in other formats: