VirtualBoxBase.cpp@ 86115

Last change on this file since 86115 was 83787, checked in by vboxsync, 5 years ago
Main/VirtualBoxBase.cpp: Don't need dbghelp.h. bugref:8489
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.0 KB

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

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

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

Download in other formats: