VirtualBoxBase.cpp@ 62873

Last change on this file since 62873 was 62679, checked in by vboxsync, 8 years ago
Use the iprt/win/windows.h wrapper for Windows.h
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 62679 2016-07-29 12:52:10Z 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	/* should not get here */
256	AssertFailed();
257	return E_FAIL;
258	}
259
260	/**
261	* Sets error info for the current thread. This is an internal function that
262	* gets eventually called by all public variants. If @a aWarning is
263	* @c true, then the highest (31) bit in the @a aResultCode value which
264	* indicates the error severity is reset to zero to make sure the receiver will
265	* recognize that the created error info object represents a warning rather
266	* than an error.
267	*/
268	/* static */
269	HRESULT VirtualBoxBase::setErrorInternal(HRESULT aResultCode,
270	const GUID &aIID,
271	const char *pcszComponent,
272	Utf8Str aText,
273	bool aWarning,
274	bool aLogIt,
275	LONG aResultDetail /* = 0*/)
276	{
277	/* whether multi-error mode is turned on */
278	bool preserve = MultiResult::isMultiEnabled();
279
280	if (aLogIt)
281	LogRel(("%s [COM]: aRC=%Rhrc (%#08x) aIID={%RTuuid} aComponent={%s} aText={%s}, preserve=%RTbool aResultDetail=%d\n",
282	aWarning ? "WARNING" : "ERROR",
283	aResultCode,
284	aResultCode,
285	&aIID,
286	pcszComponent,
287	aText.c_str(),
288	preserve,
289	aResultDetail));
290
291	/* these are mandatory, others -- not */
292	AssertReturn((!aWarning && FAILED(aResultCode)) \|\|
293	(aWarning && aResultCode != S_OK),
294	E_FAIL);
295
296	/* reset the error severity bit if it's a warning */
297	if (aWarning)
298	aResultCode &= ~0x80000000;
299
300	HRESULT rc = S_OK;
301
302	if (aText.isEmpty())
303	{
304	/* Some default info */
305	switch (aResultCode)
306	{
307	case E_INVALIDARG: aText = "A parameter has an invalid value"; break;
308	case E_POINTER: aText = "A parameter is an invalid pointer"; break;
309	case E_UNEXPECTED: aText = "The result of the operation is unexpected"; break;
310	case E_ACCESSDENIED: aText = "The access to an object is not allowed"; break;
311	case E_OUTOFMEMORY: aText = "The allocation of new memory failed"; break;
312	case E_NOTIMPL: aText = "The requested operation is not implemented"; break;
313	case E_NOINTERFACE: aText = "The requested interface is not implemented"; break;
314	case E_FAIL: aText = "A general error occurred"; break;
315	case E_ABORT: aText = "The operation was canceled"; break;
316	case VBOX_E_OBJECT_NOT_FOUND: aText = "Object corresponding to the supplied arguments does not exist"; break;
317	case VBOX_E_INVALID_VM_STATE: aText = "Current virtual machine state prevents the operation"; break;
318	case VBOX_E_VM_ERROR: aText = "Virtual machine error occurred attempting the operation"; break;
319	case VBOX_E_FILE_ERROR: aText = "File not accessible or erroneous file contents"; break;
320	case VBOX_E_IPRT_ERROR: aText = "Runtime subsystem error"; break;
321	case VBOX_E_PDM_ERROR: aText = "Pluggable Device Manager error"; break;
322	case VBOX_E_INVALID_OBJECT_STATE: aText = "Current object state prohibits operation"; break;
323	case VBOX_E_HOST_ERROR: aText = "Host operating system related error"; break;
324	case VBOX_E_NOT_SUPPORTED: aText = "Requested operation is not supported"; break;
325	case VBOX_E_XML_ERROR: aText = "Invalid XML found"; break;
326	case VBOX_E_INVALID_SESSION_STATE: aText = "Current session state prohibits operation"; break;
327	case VBOX_E_OBJECT_IN_USE: aText = "Object being in use prohibits operation"; break;
328	default: aText = "Unknown error"; break;
329	}
330	}
331
332	do
333	{
334	ComObjPtr<VirtualBoxErrorInfo> info;
335	rc = info.createObject();
336	if (FAILED(rc)) break;
337
338	#if !defined(VBOX_WITH_XPCOM)
339
340	ComPtr<IVirtualBoxErrorInfo> curInfo;
341	if (preserve)
342	{
343	/* get the current error info if any */
344	ComPtr<IErrorInfo> err;
345	rc = ::GetErrorInfo(0, err.asOutParam());
346	if (FAILED(rc)) break;
347	rc = err.queryInterfaceTo(curInfo.asOutParam());
348	if (FAILED(rc))
349	{
350	/* create a IVirtualBoxErrorInfo wrapper for the native
351	* IErrorInfo object */
352	ComObjPtr<VirtualBoxErrorInfo> wrapper;
353	rc = wrapper.createObject();
354	if (SUCCEEDED(rc))
355	{
356	rc = wrapper->init(err);
357	if (SUCCEEDED(rc))
358	curInfo = wrapper;
359	}
360	}
361	}
362	/* On failure, curInfo will stay null */
363	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
364
365	/* set the current error info and preserve the previous one if any */
366	rc = info->initEx(aResultCode, aResultDetail, aIID, pcszComponent, aText, curInfo);
367	if (FAILED(rc)) break;
368
369	ComPtr<IErrorInfo> err;
370	rc = info.queryInterfaceTo(err.asOutParam());
371	if (SUCCEEDED(rc))
372	rc = ::SetErrorInfo(0, err);
373
374	#else // !defined(VBOX_WITH_XPCOM)
375
376	nsCOMPtr <nsIExceptionService> es;
377	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
378	if (NS_SUCCEEDED(rc))
379	{
380	nsCOMPtr <nsIExceptionManager> em;
381	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
382	if (FAILED(rc)) break;
383
384	ComPtr<IVirtualBoxErrorInfo> curInfo;
385	if (preserve)
386	{
387	/* get the current error info if any */
388	ComPtr<nsIException> ex;
389	rc = em->GetCurrentException(ex.asOutParam());
390	if (FAILED(rc)) break;
391	rc = ex.queryInterfaceTo(curInfo.asOutParam());
392	if (FAILED(rc))
393	{
394	/* create a IVirtualBoxErrorInfo wrapper for the native
395	* nsIException object */
396	ComObjPtr<VirtualBoxErrorInfo> wrapper;
397	rc = wrapper.createObject();
398	if (SUCCEEDED(rc))
399	{
400	rc = wrapper->init(ex);
401	if (SUCCEEDED(rc))
402	curInfo = wrapper;
403	}
404	}
405	}
406	/* On failure, curInfo will stay null */
407	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
408
409	/* set the current error info and preserve the previous one if any */
410	rc = info->initEx(aResultCode, aResultDetail, aIID, pcszComponent, Bstr(aText), curInfo);
411	if (FAILED(rc)) break;
412
413	ComPtr<nsIException> ex;
414	rc = info.queryInterfaceTo(ex.asOutParam());
415	if (SUCCEEDED(rc))
416	rc = em->SetCurrentException(ex);
417	}
418	else if (rc == NS_ERROR_UNEXPECTED)
419	{
420	/*
421	* It is possible that setError() is being called by the object
422	* after the XPCOM shutdown sequence has been initiated
423	* (for example, when XPCOM releases all instances it internally
424	* references, which can cause object's FinalConstruct() and then
425	* uninit()). In this case, do_GetService() above will return
426	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
427	* set the exception (nobody will be able to read it).
428	*/
429	Log1WarningFunc(("Will not set an exception because nsIExceptionService is not available (NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
430	rc = NS_OK;
431	}
432
433	#endif // !defined(VBOX_WITH_XPCOM)
434	}
435	while (0);
436
437	AssertComRC(rc);
438
439	return SUCCEEDED(rc) ? aResultCode : rc;
440	}
441
442	/**
443	* Shortcut instance method to calling the static setErrorInternal with the
444	* class interface ID and component name inserted correctly. This uses the
445	* virtual getClassIID() and getComponentName() methods which are automatically
446	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
447	* @param aResultCode
448	* @param pcsz
449	* @return
450	*/
451	HRESULT VirtualBoxBase::setError(HRESULT aResultCode)
452	{
453	return setErrorInternal(aResultCode,
454	this->getClassIID(),
455	this->getComponentName(),
456	"",
457	false /* aWarning */,
458	true /* aLogIt */);
459	}
460
461	/**
462	* Shortcut instance method to calling the static setErrorInternal with the
463	* class interface ID and component name inserted correctly. This uses the
464	* virtual getClassIID() and getComponentName() methods which are automatically
465	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
466	* @param aResultCode
467	* @return
468	*/
469	HRESULT VirtualBoxBase::setError(HRESULT aResultCode, const char *pcsz, ...)
470	{
471	va_list args;
472	va_start(args, pcsz);
473	HRESULT rc = setErrorInternal(aResultCode,
474	this->getClassIID(),
475	this->getComponentName(),
476	Utf8Str(pcsz, args),
477	false /* aWarning */,
478	true /* aLogIt */);
479	va_end(args);
480	return rc;
481	}
482
483	/**
484	* Shortcut instance method to calling the static setErrorInternal with the
485	* class interface ID and component name inserted correctly. This uses the
486	* virtual getClassIID() and getComponentName() methods which are automatically
487	* defined by the VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT macro.
488	* @param ei
489	* @return
490	*/
491	HRESULT VirtualBoxBase::setError(const com::ErrorInfo &ei)
492	{
493	/* whether multi-error mode is turned on */
494	bool preserve = MultiResult::isMultiEnabled();
495
496	HRESULT rc = S_OK;
497
498	do
499	{
500	ComObjPtr<VirtualBoxErrorInfo> info;
501	rc = info.createObject();
502	if (FAILED(rc)) break;
503
504	#if !defined(VBOX_WITH_XPCOM)
505
506	ComPtr<IVirtualBoxErrorInfo> curInfo;
507	if (preserve)
508	{
509	/* get the current error info if any */
510	ComPtr<IErrorInfo> err;
511	rc = ::GetErrorInfo(0, err.asOutParam());
512	if (FAILED(rc)) break;
513	rc = err.queryInterfaceTo(curInfo.asOutParam());
514	if (FAILED(rc))
515	{
516	/* create a IVirtualBoxErrorInfo wrapper for the native
517	* IErrorInfo object */
518	ComObjPtr<VirtualBoxErrorInfo> wrapper;
519	rc = wrapper.createObject();
520	if (SUCCEEDED(rc))
521	{
522	rc = wrapper->init(err);
523	if (SUCCEEDED(rc))
524	curInfo = wrapper;
525	}
526	}
527	}
528	/* On failure, curInfo will stay null */
529	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
530
531	/* set the current error info and preserve the previous one if any */
532	rc = info->init(ei, curInfo);
533	if (FAILED(rc)) break;
534
535	ComPtr<IErrorInfo> err;
536	rc = info.queryInterfaceTo(err.asOutParam());
537	if (SUCCEEDED(rc))
538	rc = ::SetErrorInfo(0, err);
539
540	#else // !defined(VBOX_WITH_XPCOM)
541
542	nsCOMPtr <nsIExceptionService> es;
543	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
544	if (NS_SUCCEEDED(rc))
545	{
546	nsCOMPtr <nsIExceptionManager> em;
547	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
548	if (FAILED(rc)) break;
549
550	ComPtr<IVirtualBoxErrorInfo> curInfo;
551	if (preserve)
552	{
553	/* get the current error info if any */
554	ComPtr<nsIException> ex;
555	rc = em->GetCurrentException(ex.asOutParam());
556	if (FAILED(rc)) break;
557	rc = ex.queryInterfaceTo(curInfo.asOutParam());
558	if (FAILED(rc))
559	{
560	/* create a IVirtualBoxErrorInfo wrapper for the native
561	* nsIException object */
562	ComObjPtr<VirtualBoxErrorInfo> wrapper;
563	rc = wrapper.createObject();
564	if (SUCCEEDED(rc))
565	{
566	rc = wrapper->init(ex);
567	if (SUCCEEDED(rc))
568	curInfo = wrapper;
569	}
570	}
571	}
572	/* On failure, curInfo will stay null */
573	Assert(SUCCEEDED(rc) \|\| curInfo.isNull());
574
575	/* set the current error info and preserve the previous one if any */
576	rc = info->init(ei, curInfo);
577	if (FAILED(rc)) break;
578
579	ComPtr<nsIException> ex;
580	rc = info.queryInterfaceTo(ex.asOutParam());
581	if (SUCCEEDED(rc))
582	rc = em->SetCurrentException(ex);
583	}
584	else if (rc == NS_ERROR_UNEXPECTED)
585	{
586	/*
587	* It is possible that setError() is being called by the object
588	* after the XPCOM shutdown sequence has been initiated
589	* (for example, when XPCOM releases all instances it internally
590	* references, which can cause object's FinalConstruct() and then
591	* uninit()). In this case, do_GetService() above will return
592	* NS_ERROR_UNEXPECTED and it doesn't actually make sense to
593	* set the exception (nobody will be able to read it).
594	*/
595	Log1WarningFunc(("Will not set an exception because nsIExceptionService is not available (NS_ERROR_UNEXPECTED). XPCOM is being shutdown?\n"));
596	rc = NS_OK;
597	}
598
599	#endif // !defined(VBOX_WITH_XPCOM)
600	}
601	while (0);
602
603	AssertComRC(rc);
604
605	return SUCCEEDED(rc) ? ei.getResultCode() : rc;
606	}
607
608	/**
609	* Converts the VBox status code a COM one and sets the error info.
610	*
611	* The VBox status code is made available to the API user via
612	* IVirtualBoxErrorInfo::resultDetail attribute.
613	*
614	* @param vrc The VBox status code.
615	* @return COM status code appropriate for @a vrc.
616	*
617	* @sa VirtualBoxBase::setError(HRESULT)
618	*/
619	HRESULT VirtualBoxBase::setErrorVrc(int vrc)
620	{
621	return setErrorInternal(Global::vboxStatusCodeToCOM(vrc),
622	this->getClassIID(),
623	this->getComponentName(),
624	Utf8StrFmt("%Rrc", vrc),
625	false /* aWarning */,
626	true /* aLogIt */,
627	vrc /* aResultDetail */);
628	}
629
630	/**
631	* Converts the VBox status code a COM one and sets the error info.
632	*
633	* @param vrc The VBox status code.
634	* @param pcszMsgFmt Error message format string.
635	* @param ... Argument specified in the @a pcszMsgFmt
636	* @return COM status code appropriate for @a vrc.
637	*
638	* @sa VirtualBoxBase::setError(HRESULT, const char *, ...)
639	*/
640	HRESULT VirtualBoxBase::setErrorVrc(int vrc, const char *pcszMsgFmt, ...)
641	{
642	va_list va;
643	va_start(va, pcszMsgFmt);
644	HRESULT hrc = setErrorInternal(Global::vboxStatusCodeToCOM(vrc),
645	this->getClassIID(),
646	this->getComponentName(),
647	Utf8Str(pcszMsgFmt, va),
648	false /* aWarning */,
649	true /* aLogIt */,
650	vrc /* aResultDetail */);
651	va_end(va);
652	return hrc;
653	}
654
655	/**
656	* Sets error info with both a COM status and an VBox status code.
657	*
658	* The VBox status code is made available to the API user via
659	* IVirtualBoxErrorInfo::resultDetail attribute.
660	*
661	* @param hrc The COM status code to return.
662	* @param vrc The VBox status code.
663	* @return Most likely @a hrc, see setErrorInternal.
664	*
665	* @sa VirtualBoxBase::setError(HRESULT)
666	*/
667	HRESULT VirtualBoxBase::setErrorBoth(HRESULT hrc, int vrc)
668	{
669	return setErrorInternal(hrc,
670	this->getClassIID(),
671	this->getComponentName(),
672	Utf8StrFmt("%Rrc", vrc),
673	false /* aWarning */,
674	true /* aLogIt */,
675	vrc /* aResultDetail */);
676	}
677
678	/**
679	* Sets error info with a message and both a COM status and an VBox status code.
680	*
681	* The VBox status code is made available to the API user via
682	* IVirtualBoxErrorInfo::resultDetail attribute.
683	*
684	* @param hrc The COM status code to return.
685	* @param vrc The VBox status code.
686	* @param pcszMsgFmt Error message format string.
687	* @param ... Argument specified in the @a pcszMsgFmt
688	* @return Most likely @a hrc, see setErrorInternal.
689	*
690	* @sa VirtualBoxBase::setError(HRESULT, const char *, ...)
691	*/
692	HRESULT VirtualBoxBase::setErrorBoth(HRESULT hrc, int vrc, const char *pcszMsgFmt, ...)
693	{
694	va_list va;
695	va_start(va, pcszMsgFmt);
696	hrc = setErrorInternal(hrc,
697	this->getClassIID(),
698	this->getComponentName(),
699	Utf8Str(pcszMsgFmt, va),
700	false /* aWarning */,
701	true /* aLogIt */,
702	vrc /* aResultDetail */);
703	va_end(va);
704	return hrc;
705	}
706
707	/**
708	* Like setError(), but sets the "warning" bit in the call to setErrorInternal().
709	* @param aResultCode
710	* @param pcsz
711	* @return
712	*/
713	HRESULT VirtualBoxBase::setWarning(HRESULT aResultCode, const char *pcsz, ...)
714	{
715	va_list args;
716	va_start(args, pcsz);
717	HRESULT rc = setErrorInternal(aResultCode,
718	this->getClassIID(),
719	this->getComponentName(),
720	Utf8Str(pcsz, args),
721	true /* aWarning */,
722	true /* aLogIt */);
723	va_end(args);
724	return rc;
725	}
726
727	/**
728	* Like setError(), but disables the "log" flag in the call to setErrorInternal().
729	* @param aResultCode
730	* @param pcsz
731	* @return
732	*/
733	HRESULT VirtualBoxBase::setErrorNoLog(HRESULT aResultCode, const char *pcsz, ...)
734	{
735	va_list args;
736	va_start(args, pcsz);
737	HRESULT rc = setErrorInternal(aResultCode,
738	this->getClassIID(),
739	this->getComponentName(),
740	Utf8Str(pcsz, args),
741	false /* aWarning */,
742	false /* aLogIt */);
743	va_end(args);
744	return rc;
745	}
746
747	/**
748	* Clear the current error information.
749	*/
750	/static/
751	void VirtualBoxBase::clearError(void)
752	{
753	#if !defined(VBOX_WITH_XPCOM)
754	::SetErrorInfo(0, NULL);
755	#else
756	HRESULT rc = S_OK;
757	nsCOMPtr <nsIExceptionService> es;
758	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
759	if (NS_SUCCEEDED(rc))
760	{
761	nsCOMPtr <nsIExceptionManager> em;
762	rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
763	if (SUCCEEDED(rc))
764	em->SetCurrentException(NULL);
765	}
766	#endif
767	}
768
769
770	////////////////////////////////////////////////////////////////////////////////
771	//
772	// MultiResult methods
773	//
774	////////////////////////////////////////////////////////////////////////////////
775
776	RTTLS MultiResult::sCounter = NIL_RTTLS;
777
778	/static/
779	void MultiResult::incCounter()
780	{
781	if (sCounter == NIL_RTTLS)
782	{
783	sCounter = RTTlsAlloc();
784	AssertReturnVoid(sCounter != NIL_RTTLS);
785	}
786
787	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
788	++counter;
789	RTTlsSet(sCounter, (void*)counter);
790	}
791
792	/static/
793	void MultiResult::decCounter()
794	{
795	uintptr_t counter = (uintptr_t)RTTlsGet(sCounter);
796	AssertReturnVoid(counter != 0);
797	--counter;
798	RTTlsSet(sCounter, (void*)counter);
799	}
800
801	/static/
802	bool MultiResult::isMultiEnabled()
803	{
804	if (sCounter == NIL_RTTLS)
805	return false;
806
807	return ((uintptr_t)RTTlsGet(MultiResult::sCounter)) > 0;
808	}
809

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

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

Download in other formats: