VirtualBox

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

Last change on this file since 61644 was 61326, checked in by vboxsync, 9 years ago

Main/VirtualBoxBase: Need to use Utf8StrFmt here

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 27.7 KB
Line 
1/* $Id: VirtualBoxBase.cpp 61326 2016-05-31 09:24:14Z 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 <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
50CLASSFACTORY_STAT g_aClassFactoryStats[CLASSFACTORYSTATS_MAX] =
51{
52 { "--- totals ---", 0 },
53 { NULL, 0 }
54};
55
56RWLockHandle *g_pClassFactoryStatsLock = NULL;
57
58
59VirtualBoxBase::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
74VirtualBoxBase::~VirtualBoxBase()
75{
76 Assert(iFactoryStat == ~0U);
77 if (mObjectLock)
78 delete mObjectLock;
79}
80
81HRESULT 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
123void 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
151void 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 */
178RWLockHandle *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 */
221HRESULT 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 */
269HRESULT 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 */
451HRESULT 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 */
469HRESULT 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 */
491HRESULT 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 */
619HRESULT 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 */
640HRESULT 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 */
667HRESULT 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 */
692HRESULT 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 */
713HRESULT 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 */
733HRESULT 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*/
751void 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
776RTTLS MultiResult::sCounter = NIL_RTTLS;
777
778/*static*/
779void 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*/
793void 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*/
802bool 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.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette