VirtualBox

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

Last change on this file since 49960 was 41214, checked in by vboxsync, 13 years ago

Main: move handleUnexpectedExceptions method to VirtualBoxBase

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

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