VirtualBox

source: vbox/trunk/src/VBox/Main/VirtualBoxBase.cpp@ 5688

Last change on this file since 5688 was 5251, checked in by vboxsync, 17 years ago

more noise.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.3 KB
Line 
1/** @file
2 *
3 * VirtualBox COM base classes implementation
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#if !defined (VBOX_WITH_XPCOM)
19#if defined (RT_OS_WINDOWS)
20#include <windows.h>
21#include <dbghelp.h>
22#endif
23#else // !defined (VBOX_WITH_XPCOM)
24#include <nsIServiceManager.h>
25#include <nsIExceptionService.h>
26#endif // !defined (VBOX_WITH_XPCOM)
27
28#include "VirtualBoxBase.h"
29#include "VirtualBoxErrorInfoImpl.h"
30#include "Logging.h"
31
32#include <iprt/semaphore.h>
33
34// VirtualBoxBaseNEXT_base methods
35////////////////////////////////////////////////////////////////////////////////
36
37VirtualBoxBaseNEXT_base::VirtualBoxBaseNEXT_base()
38{
39 mState = NotReady;
40 mStateChangeThread = NIL_RTTHREAD;
41 mCallers = 0;
42 mZeroCallersSem = NIL_RTSEMEVENT;
43 mInitDoneSem = NIL_RTSEMEVENTMULTI;
44 mInitDoneSemUsers = 0;
45 RTCritSectInit (&mStateLock);
46 mObjectLock = NULL;
47}
48
49VirtualBoxBaseNEXT_base::~VirtualBoxBaseNEXT_base()
50{
51 if (mObjectLock)
52 delete mObjectLock;
53 RTCritSectDelete (&mStateLock);
54 Assert (mInitDoneSemUsers == 0);
55 Assert (mInitDoneSem == NIL_RTSEMEVENTMULTI);
56 if (mZeroCallersSem != NIL_RTSEMEVENT)
57 RTSemEventDestroy (mZeroCallersSem);
58 mCallers = 0;
59 mStateChangeThread = NIL_RTTHREAD;
60 mState = NotReady;
61}
62
63// AutoLock::Lockable interface
64AutoLock::Handle *VirtualBoxBaseNEXT_base::lockHandle() const
65{
66 /* lasy initialization */
67 if (!mObjectLock)
68 mObjectLock = new AutoLock::Handle;
69 return mObjectLock;
70}
71
72/**
73 * Increments the number of calls to this object by one.
74 *
75 * After this method succeeds, it is guaranted that the object will remain in
76 * the Ready (or in the Limited) state at least until #releaseCaller() is
77 * called.
78 *
79 * This method is intended to mark the beginning of sections of code within
80 * methods of COM objects that depend on the readiness (Ready) state. The
81 * Ready state is a primary "ready to serve" state. Usually all code that
82 * works with component's data depends on it. On practice, this means that
83 * almost every public method, setter or getter of the object should add
84 * itself as an object's caller at the very beginning, to protect from an
85 * unexpected uninitialization that may happen on a different thread.
86 *
87 * Besides the Ready state denoting that the object is fully functional,
88 * there is a special Limited state. The Limited state means that the object
89 * is still functional, but its functionality is limited to some degree, so
90 * not all operations are possible. The @a aLimited argument to this method
91 * determines whether the caller represents this limited functionality or not.
92 *
93 * This method succeeeds (and increments the number of callers) only if the
94 * current object's state is Ready. Otherwise, it will return E_UNEXPECTED to
95 * indicate that the object is not operational. There are two exceptions from
96 * this rule:
97 * <ol>
98 * <li>If the @a aLimited argument is |true|, then this method will also
99 * succeeed if the object's state is Limited (or Ready, of course).</li>
100 * <li>If this method is called from the same thread that placed the object
101 * to InInit or InUninit state (i.e. either from within the AutoInitSpan
102 * or AutoUninitSpan scope), it will succeed as well (but will not
103 * increase the number of callers).</li>
104 * </ol>
105 *
106 * Normally, calling addCaller() never blocks. However, if this method is
107 * called by a thread created from within the AutoInitSpan scope and this
108 * scope is still active (i.e. the object state is InInit), it will block
109 * until the AutoInitSpan destructor signals that it has finished
110 * initialization.
111 *
112 * When this method returns a failure, the caller must not use the object
113 * and can return the failed result code to his caller.
114 *
115 * @param aState where to store the current object's state
116 * (can be used in overriden methods to determine the
117 * cause of the failure)
118 * @param aLimited |true| to add a limited caller.
119 * @return S_OK on success or E_UNEXPECTED on failure
120 *
121 * @note It is preferrable to use the #addLimitedCaller() rather than calling
122 * this method with @a aLimited = |true|, for better
123 * self-descriptiveness.
124 *
125 * @sa #addLimitedCaller()
126 * @sa #releaseCaller()
127 */
128HRESULT VirtualBoxBaseNEXT_base::addCaller (State *aState /* = NULL */,
129 bool aLimited /* = false */)
130{
131 AutoLock stateLock (mStateLock);
132
133 HRESULT rc = E_UNEXPECTED;
134
135 if (mState == Ready || (aLimited && mState == Limited))
136 {
137 /* if Ready or allows Limited, increase the number of callers */
138 ++ mCallers;
139 rc = S_OK;
140 }
141 else
142 if ((mState == InInit || mState == InUninit))
143 {
144 if (mStateChangeThread == RTThreadSelf())
145 {
146 /*
147 * Called from the same thread that is doing AutoInitSpan or
148 * AutoUninitSpan, just succeed
149 */
150 rc = S_OK;
151 }
152 else if (mState == InInit)
153 {
154 /* addCaller() is called by a "child" thread while the "parent"
155 * thread is still doing AutoInitSpan/AutoReadySpan. Wait for the
156 * state to become either Ready/Limited or InitFailed/InInit/NotReady
157 * (in case of init failure). Note that we increase the number of
158 * callers anyway to prevent AutoUninitSpan from early completion.
159 */
160 ++ mCallers;
161
162 /* lazy creation */
163 if (mInitDoneSem == NIL_RTSEMEVENTMULTI)
164 RTSemEventMultiCreate (&mInitDoneSem);
165 ++ mInitDoneSemUsers;
166
167 LogFlowThisFunc (("Waiting for AutoInitSpan/AutoReadySpan to finish...\n"));
168
169 stateLock.leave();
170 RTSemEventMultiWait (mInitDoneSem, RT_INDEFINITE_WAIT);
171 stateLock.enter();
172
173 if (-- mInitDoneSemUsers == 0)
174 {
175 /* destroy the semaphore since no more necessary */
176 RTSemEventMultiDestroy (mInitDoneSem);
177 mInitDoneSem = NIL_RTSEMEVENTMULTI;
178 }
179
180 if (mState == Ready)
181 rc = S_OK;
182 else
183 {
184 AssertMsg (mCallers != 0, ("mCallers is ZERO!"));
185 -- mCallers;
186 if (mCallers == 0 && mState == InUninit)
187 {
188 /* inform AutoUninitSpan ctor there are no more callers */
189 RTSemEventSignal (mZeroCallersSem);
190 }
191 }
192 }
193 }
194
195 if (aState)
196 *aState = mState;
197
198 return rc;
199}
200
201/**
202 * Decrements the number of calls to this object by one.
203 * Must be called after every #addCaller() or #addLimitedCaller() when the
204 * object is no more necessary.
205 */
206void VirtualBoxBaseNEXT_base::releaseCaller()
207{
208 AutoLock stateLock (mStateLock);
209
210 if (mState == Ready || mState == Limited)
211 {
212 /* if Ready or Limited, decrease the number of callers */
213 AssertMsgReturn (mCallers != 0, ("mCallers is ZERO!"), (void) 0);
214 -- mCallers;
215
216 return;
217 }
218
219 if ((mState == InInit || mState == InUninit))
220 {
221 if (mStateChangeThread == RTThreadSelf())
222 {
223 /*
224 * Called from the same thread that is doing AutoInitSpan or
225 * AutoUninitSpan, just succeed
226 */
227 return;
228 }
229
230 if (mState == InUninit)
231 {
232 /* the caller is being released after AutoUninitSpan has begun */
233 AssertMsgReturn (mCallers != 0, ("mCallers is ZERO!"), (void) 0);
234 -- mCallers;
235
236 if (mCallers == 0)
237 {
238 /* inform the AutoUninitSpan ctor there are no more callers */
239 RTSemEventSignal (mZeroCallersSem);
240 }
241
242 return;
243 }
244 }
245
246 AssertMsgFailed (("mState = %d!", mState));
247}
248
249// VirtualBoxBaseNEXT_base::AutoInitSpan methods
250////////////////////////////////////////////////////////////////////////////////
251
252/**
253 * Creates a smart initialization span object and places the object to
254 * InInit state.
255 *
256 * @param aObj |this| pointer of the managed VirtualBoxBase object whose
257 * init() method is being called
258 * @param aStatus initial initialization status for this span
259 */
260VirtualBoxBaseNEXT_base::AutoInitSpan::
261AutoInitSpan (VirtualBoxBaseNEXT_base *aObj, Status aStatus /* = Failed */)
262 : mObj (aObj), mStatus (aStatus), mOk (false)
263{
264 Assert (aObj);
265
266 AutoLock stateLock (mObj->mStateLock);
267
268 Assert (mObj->mState != InInit && mObj->mState != InUninit &&
269 mObj->mState != InitFailed);
270
271 mOk = mObj->mState == NotReady;
272 if (!mOk)
273 return;
274
275 mObj->setState (InInit);
276}
277
278/**
279 * Places the managed VirtualBoxBase object to Ready/Limited state if the
280 * initialization succeeded or partly succeeded, or places it to InitFailed
281 * state and calls the object's uninit() method otherwise.
282 */
283VirtualBoxBaseNEXT_base::AutoInitSpan::~AutoInitSpan()
284{
285 /* if the state was other than NotReady, do nothing */
286 if (!mOk)
287 return;
288
289 AutoLock stateLock (mObj->mStateLock);
290
291 Assert (mObj->mState == InInit);
292
293 if (mObj->mCallers > 0)
294 {
295 Assert (mObj->mInitDoneSemUsers > 0);
296
297 /* We have some pending addCaller() calls on other threads (created
298 * during InInit), signal that InInit is finished. */
299 RTSemEventMultiSignal (mObj->mInitDoneSem);
300 }
301
302 if (mStatus == Succeeded)
303 {
304 mObj->setState (Ready);
305 }
306 else
307 if (mStatus == Limited)
308 {
309 mObj->setState (VirtualBoxBaseNEXT_base::Limited);
310 }
311 else
312 {
313 mObj->setState (InitFailed);
314 /* leave the lock to prevent nesting when uninit() is called */
315 stateLock.leave();
316 /* call uninit() to let the object uninit itself after failed init() */
317 mObj->uninit();
318 /* Note: the object may no longer exist here (for example, it can call
319 * the destructor in uninit()) */
320 }
321}
322
323// VirtualBoxBaseNEXT_base::AutoReadySpan methods
324////////////////////////////////////////////////////////////////////////////////
325
326/**
327 * Creates a smart re-initialization span object and places the object to
328 * InInit state.
329 *
330 * @param aObj |this| pointer of the managed VirtualBoxBase object whose
331 * re-initialization method is being called
332 */
333VirtualBoxBaseNEXT_base::AutoReadySpan::
334AutoReadySpan (VirtualBoxBaseNEXT_base *aObj)
335 : mObj (aObj), mSucceeded (false), mOk (false)
336{
337 Assert (aObj);
338
339 AutoLock stateLock (mObj->mStateLock);
340
341 Assert (mObj->mState != InInit && mObj->mState != InUninit &&
342 mObj->mState != InitFailed);
343
344 mOk = mObj->mState == Limited;
345 if (!mOk)
346 return;
347
348 mObj->setState (InInit);
349}
350
351/**
352 * Places the managed VirtualBoxBase object to Ready state if the
353 * re-initialization succeeded (i.e. #setSucceeded() has been called) or
354 * back to Limited state otherwise.
355 */
356VirtualBoxBaseNEXT_base::AutoReadySpan::~AutoReadySpan()
357{
358 /* if the state was other than Limited, do nothing */
359 if (!mOk)
360 return;
361
362 AutoLock stateLock (mObj->mStateLock);
363
364 Assert (mObj->mState == InInit);
365
366 if (mObj->mCallers > 0 && mObj->mInitDoneSemUsers > 0)
367 {
368 /* We have some pending addCaller() calls on other threads,
369 * signal that InInit is finished. */
370 RTSemEventMultiSignal (mObj->mInitDoneSem);
371 }
372
373 if (mSucceeded)
374 {
375 mObj->setState (Ready);
376 }
377 else
378 {
379 mObj->setState (Limited);
380 }
381}
382
383// VirtualBoxBaseNEXT_base::AutoUninitSpan methods
384////////////////////////////////////////////////////////////////////////////////
385
386/**
387 * Creates a smart uninitialization span object and places this object to
388 * InUninit state.
389 *
390 * @note This method blocks the current thread execution until the number of
391 * callers of the managed VirtualBoxBase object drops to zero!
392 *
393 * @param aObj |this| pointer of the VirtualBoxBase object whose uninit()
394 * method is being called
395 */
396VirtualBoxBaseNEXT_base::AutoUninitSpan::AutoUninitSpan (VirtualBoxBaseNEXT_base *aObj)
397 : mObj (aObj), mInitFailed (false), mUninitDone (false)
398{
399 Assert (aObj);
400
401 AutoLock stateLock (mObj->mStateLock);
402
403 Assert (mObj->mState != InInit);
404
405 /*
406 * Set mUninitDone to |true| if this object is already uninitialized
407 * (NotReady) or if another AutoUninitSpan is currently active on some
408 * other thread (InUninit).
409 */
410 mUninitDone = mObj->mState == NotReady ||
411 mObj->mState == InUninit;
412
413 if (mObj->mState == InitFailed)
414 {
415 /* we've been called by init() on failure */
416 mInitFailed = true;
417 }
418 else
419 {
420 /* do nothing if already uninitialized */
421 if (mUninitDone)
422 return;
423 }
424
425 /* go to InUninit to prevent from adding new callers */
426 mObj->setState (InUninit);
427
428 if (mObj->mCallers > 0)
429 {
430 /* lazy creation */
431 Assert (mObj->mZeroCallersSem == NIL_RTSEMEVENT);
432 RTSemEventCreate (&mObj->mZeroCallersSem);
433
434 /* wait until remaining callers release the object */
435 LogFlowThisFunc (("Waiting for callers (%d) to drop to zero...\n",
436 mObj->mCallers));
437
438 stateLock.leave();
439 RTSemEventWait (mObj->mZeroCallersSem, RT_INDEFINITE_WAIT);
440 }
441}
442
443/**
444 * Places the managed VirtualBoxBase object to the NotReady state.
445 */
446VirtualBoxBaseNEXT_base::AutoUninitSpan::~AutoUninitSpan()
447{
448 /* do nothing if already uninitialized */
449 if (mUninitDone)
450 return;
451
452 AutoLock stateLock (mObj->mStateLock);
453
454 Assert (mObj->mState == InUninit);
455
456 mObj->setState (NotReady);
457}
458
459// VirtualBoxBase methods
460////////////////////////////////////////////////////////////////////////////////
461
462/**
463 * Translates the given text string according to the currently installed
464 * translation table and current context. The current context is determined
465 * by the context parameter. Additionally, a comment to the source text
466 * string text can be given. This comment (which is NULL by default)
467 * is helpful in sutuations where it is necessary to distinguish between
468 * two or more semantically different roles of the same source text in the
469 * same context.
470 *
471 * @param context the context of the the translation (can be NULL
472 * to indicate the global context)
473 * @param sourceText the string to translate
474 * @param comment the comment to the string (NULL means no comment)
475 *
476 * @return
477 * the translated version of the source string in UTF-8 encoding,
478 * or the source string itself if the translation is not found
479 * in the given context.
480 */
481// static
482const char *VirtualBoxBase::translate (const char *context, const char *sourceText,
483 const char *comment)
484{
485// Log(("VirtualBoxBase::translate:\n"
486// " context={%s}\n"
487// " sourceT={%s}\n"
488// " comment={%s}\n",
489// context, sourceText, comment));
490
491 /// @todo (dmik) incorporate Qt translation file parsing and lookup
492
493 return sourceText;
494}
495
496/// @todo (dmik)
497// Using StackWalk() is not necessary here once we have ASMReturnAddress().
498// Delete later.
499
500#if defined(DEBUG) && 0
501
502//static
503void VirtualBoxBase::AutoLock::CritSectEnter (RTCRITSECT *aLock)
504{
505 AssertReturn (aLock, (void) 0);
506
507#if (defined(RT_OS_LINUX) || defined(RT_OS_OS2)) && defined(__GNUC__)
508
509 RTCritSectEnterDebug (aLock,
510 "AutoLock::lock()/enter() return address >>>", 0,
511 (RTUINTPTR) __builtin_return_address (1));
512
513#elif defined(RT_OS_WINDOWS)
514
515 STACKFRAME sf;
516 memset (&sf, 0, sizeof(sf));
517 {
518 __asm eip:
519 __asm mov eax, eip
520 __asm lea ebx, sf
521 __asm mov [ebx]sf.AddrPC.Offset, eax
522 __asm mov [ebx]sf.AddrStack.Offset, esp
523 __asm mov [ebx]sf.AddrFrame.Offset, ebp
524 }
525 sf.AddrPC.Mode = AddrModeFlat;
526 sf.AddrStack.Mode = AddrModeFlat;
527 sf.AddrFrame.Mode = AddrModeFlat;
528
529 HANDLE process = GetCurrentProcess();
530 HANDLE thread = GetCurrentThread();
531
532 // get our stack frame
533 BOOL ok = StackWalk (IMAGE_FILE_MACHINE_I386, process, thread,
534 &sf, NULL, NULL,
535 SymFunctionTableAccess,
536 SymGetModuleBase,
537 NULL);
538 // sanity check of the returned stack frame
539 ok = ok & (sf.AddrFrame.Offset != 0);
540 if (ok)
541 {
542 // get the stack frame of our caller which is either
543 // lock() or enter()
544 ok = StackWalk (IMAGE_FILE_MACHINE_I386, process, thread,
545 &sf, NULL, NULL,
546 SymFunctionTableAccess,
547 SymGetModuleBase,
548 NULL);
549 // sanity check of the returned stack frame
550 ok = ok & (sf.AddrFrame.Offset != 0);
551 }
552
553 if (ok)
554 {
555 // the return address here should be the code where lock() or enter()
556 // has been called from (to be more precise, where it will return)
557 RTCritSectEnterDebug (aLock,
558 "AutoLock::lock()/enter() return address >>>", 0,
559 (RTUINTPTR) sf.AddrReturn.Offset);
560 }
561 else
562 {
563 RTCritSectEnter (aLock);
564 }
565
566#else
567
568 RTCritSectEnter (aLock);
569
570#endif // defined(RT_OS_LINUX)...
571}
572
573#endif // defined(DEBUG)
574
575// VirtualBoxSupportTranslationBase methods
576////////////////////////////////////////////////////////////////////////////////
577
578/**
579 * Modifies the given argument so that it will contain only a class name
580 * (null-terminated). The argument must point to a <b>non-constant</b>
581 * string containing a valid value, as it is generated by the
582 * __PRETTY_FUNCTION__ built-in macro of the GCC compiler, or by the
583 * __FUNCTION__ macro of any other compiler.
584 *
585 * The function assumes that the macro is used within the member of the
586 * class derived from the VirtualBoxSupportTranslation<> template.
587 *
588 * @param prettyFunctionName string to modify
589 * @return
590 * true on success and false otherwise
591 */
592bool VirtualBoxSupportTranslationBase::cutClassNameFrom__PRETTY_FUNCTION__ (char *fn)
593{
594 Assert (fn);
595 if (!fn)
596 return false;
597
598#if defined (__GNUC__)
599
600 // the format is like:
601 // VirtualBoxSupportTranslation<C>::VirtualBoxSupportTranslation() [with C = VirtualBox]
602
603 #define START " = "
604 #define END "]"
605
606#elif defined (_MSC_VER)
607
608 // the format is like:
609 // VirtualBoxSupportTranslation<class VirtualBox>::__ctor
610
611 #define START "<class "
612 #define END ">::"
613
614#endif
615
616 char *start = strstr (fn, START);
617 Assert (start);
618 if (start)
619 {
620 start += sizeof (START) - 1;
621 char *end = strstr (start, END);
622 Assert (end && (end > start));
623 if (end && (end > start))
624 {
625 size_t len = end - start;
626 memmove (fn, start, len);
627 fn [len] = 0;
628 return true;
629 }
630 }
631
632 #undef END
633 #undef START
634
635 return false;
636}
637
638// VirtualBoxSupportErrorInfoImplBase methods
639////////////////////////////////////////////////////////////////////////////////
640
641/**
642 * Sets error info for the current thread. This is an internal function that
643 * gets eventually called by all public variants. If @a aPreserve is
644 * @c true, then the current error info object set on the thread before this
645 * method is called will be preserved in the IVirtualBoxErrorInfo::next
646 * attribute of the new error info object that will be then set as the
647 * current error info object.
648 */
649// static
650HRESULT VirtualBoxSupportErrorInfoImplBase::setErrorInternal (
651 HRESULT aResultCode, const GUID &aIID,
652 const Bstr &aComponent, const Bstr &aText,
653 bool aPreserve)
654{
655 LogRel (("ERROR [COM]: aRC=%#08x aIID={%Vuuid} aComponent={%ls} aText={%ls} "
656 "aPreserve=%RTbool\n",
657 aResultCode, &aIID, aComponent.raw(), aText.raw(), aPreserve));
658
659 /* these are mandatory, others -- not */
660 AssertReturn (FAILED (aResultCode), E_FAIL);
661 AssertReturn (!aText.isEmpty(), E_FAIL);
662
663 HRESULT rc = S_OK;
664
665 do
666 {
667 ComObjPtr <VirtualBoxErrorInfo> info;
668 rc = info.createObject();
669 CheckComRCBreakRC (rc);
670
671#if !defined (VBOX_WITH_XPCOM)
672#if defined (RT_OS_WINDOWS)
673
674 ComPtr <IVirtualBoxErrorInfo> curInfo;
675 if (aPreserve)
676 {
677 /* get the current error info if any */
678 ComPtr <IErrorInfo> err;
679 rc = ::GetErrorInfo (0, err.asOutParam());
680 CheckComRCBreakRC (rc);
681 rc = err.queryInterfaceTo (curInfo.asOutParam());
682 if (FAILED (rc))
683 {
684 /* create a IVirtualBoxErrorInfo wrapper for the native
685 * IErrorInfo object */
686 ComObjPtr <VirtualBoxErrorInfo> wrapper;
687 rc = wrapper.createObject();
688 if (SUCCEEDED (rc))
689 {
690 rc = wrapper->init (err);
691 if (SUCCEEDED (rc))
692 curInfo = wrapper;
693 }
694 }
695 }
696 /* On failure, curInfo will stay null */
697 Assert (SUCCEEDED (rc) || curInfo.isNull());
698
699 /* set the current error info and preserve the previous one if any */
700 rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
701 CheckComRCBreakRC (rc);
702
703 ComPtr <IErrorInfo> err;
704 rc = info.queryInterfaceTo (err.asOutParam());
705 if (SUCCEEDED (rc))
706 rc = ::SetErrorInfo (0, err);
707
708#endif
709#else // !defined (VBOX_WITH_XPCOM)
710
711 nsCOMPtr <nsIExceptionService> es;
712 es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
713 if (NS_SUCCEEDED (rc))
714 {
715 nsCOMPtr <nsIExceptionManager> em;
716 rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
717 CheckComRCBreakRC (rc);
718
719 ComPtr <IVirtualBoxErrorInfo> curInfo;
720 if (aPreserve)
721 {
722 /* get the current error info if any */
723 ComPtr <nsIException> ex;
724 rc = em->GetCurrentException (ex.asOutParam());
725 CheckComRCBreakRC (rc);
726 rc = ex.queryInterfaceTo (curInfo.asOutParam());
727 if (FAILED (rc))
728 {
729 /* create a IVirtualBoxErrorInfo wrapper for the native
730 * nsIException object */
731 ComObjPtr <VirtualBoxErrorInfo> wrapper;
732 rc = wrapper.createObject();
733 if (SUCCEEDED (rc))
734 {
735 rc = wrapper->init (ex);
736 if (SUCCEEDED (rc))
737 curInfo = wrapper;
738 }
739 }
740 }
741 /* On failure, curInfo will stay null */
742 Assert (SUCCEEDED (rc) || curInfo.isNull());
743
744 /* set the current error info and preserve the previous one if any */
745 rc = info->init (aResultCode, aIID, aComponent, aText, curInfo);
746 CheckComRCBreakRC (rc);
747
748 ComPtr <nsIException> ex;
749 rc = info.queryInterfaceTo (ex.asOutParam());
750 if (SUCCEEDED (rc))
751 rc = em->SetCurrentException (ex);
752 }
753 else if (rc == NS_ERROR_UNEXPECTED)
754 {
755 /*
756 * It is possible that setError() is being called by the object
757 * after the XPCOM shutdown sequence has been initiated
758 * (for example, when XPCOM releases all instances it internally
759 * references, which can cause object's FinalConstruct() and then
760 * uninit()). In this case, do_GetService() above will return
761 * NS_ERROR_UNEXPECTED and it doesn't actually make sense to
762 * set the exception (nobody will be able to read it).
763 */
764 LogWarningFunc (("Will not set an exception because "
765 "nsIExceptionService is not available "
766 "(NS_ERROR_UNEXPECTED). "
767 "XPCOM is being shutdown?\n"));
768 rc = NS_OK;
769 }
770
771#endif // !defined (VBOX_WITH_XPCOM)
772 }
773 while (0);
774
775 AssertComRC (rc);
776
777 return SUCCEEDED (rc) ? aResultCode : rc;
778}
779
780// VirtualBoxBaseWithChildren methods
781////////////////////////////////////////////////////////////////////////////////
782
783/**
784 * Uninitializes all dependent children registered with #addDependentChild().
785 *
786 * @note
787 * This method will call uninit() methods of children. If these methods
788 * access the parent object, uninitDependentChildren() must be called
789 * either at the beginning of the parent uninitialization sequence (when
790 * it is still operational) or after setReady(false) is called to
791 * indicate the parent is out of action.
792 */
793void VirtualBoxBaseWithChildren::uninitDependentChildren()
794{
795 /// @todo (r=dmik) see todo in VirtualBoxBase.h, in
796 // template <class C> void removeDependentChild (C *child)
797
798 LogFlowThisFuncEnter();
799
800 AutoLock alock (this);
801 AutoLock mapLock (mMapLock);
802
803 LogFlowThisFunc (("count=%d...\n", mDependentChildren.size()));
804
805 if (mDependentChildren.size())
806 {
807 /* We keep the lock until we have enumerated all children.
808 * Those ones that will try to call #removeDependentChild() from
809 * a different thread will have to wait */
810
811 Assert (mUninitDoneSem == NIL_RTSEMEVENT);
812 int vrc = RTSemEventCreate (&mUninitDoneSem);
813 AssertRC (vrc);
814
815 Assert (mChildrenLeft == 0);
816 mChildrenLeft = (unsigned)mDependentChildren.size();
817
818 for (DependentChildren::iterator it = mDependentChildren.begin();
819 it != mDependentChildren.end(); ++ it)
820 {
821 VirtualBoxBase *child = (*it).second;
822 Assert (child);
823 if (child)
824 child->uninit();
825 }
826
827 mDependentChildren.clear();
828 }
829
830 /* Wait until all children started uninitializing on their own
831 * (and therefore are waiting for some parent's method or for
832 * #removeDependentChild() to return) are finished uninitialization */
833
834 if (mUninitDoneSem != NIL_RTSEMEVENT)
835 {
836 /* let stuck children run */
837 mapLock.leave();
838 alock.leave();
839
840 LogFlowThisFunc (("Waiting for uninitialization of all children...\n"));
841
842 RTSemEventWait (mUninitDoneSem, RT_INDEFINITE_WAIT);
843
844 alock.enter();
845 mapLock.enter();
846
847 RTSemEventDestroy (mUninitDoneSem);
848 mUninitDoneSem = NIL_RTSEMEVENT;
849 Assert (mChildrenLeft == 0);
850 }
851
852 LogFlowThisFuncLeave();
853}
854
855/**
856 * Returns a pointer to the dependent child corresponding to the given
857 * interface pointer (used as a key in the map) or NULL if the interface
858 * pointer doesn't correspond to any child registered using
859 * #addDependentChild().
860 *
861 * @param unk
862 * Pointer to map to the dependent child object (it is ComPtr <IUnknown>
863 * rather than IUnknown *, to guarantee IUnknown * identity)
864 * @return
865 * Pointer to the dependent child object
866 */
867VirtualBoxBase *VirtualBoxBaseWithChildren::getDependentChild (
868 const ComPtr <IUnknown> &unk)
869{
870 AssertReturn (!!unk, NULL);
871
872 AutoLock alock (mMapLock);
873 if (mUninitDoneSem != NIL_RTSEMEVENT)
874 return NULL;
875
876 DependentChildren::const_iterator it = mDependentChildren.find (unk);
877 if (it == mDependentChildren.end())
878 return NULL;
879 return (*it).second;
880}
881
882/** Helper for addDependentChild() template method */
883void VirtualBoxBaseWithChildren::addDependentChild (
884 const ComPtr <IUnknown> &unk, VirtualBoxBase *child)
885{
886 AssertReturn (!!unk && child, (void) 0);
887
888 AutoLock alock (mMapLock);
889
890 if (mUninitDoneSem != NIL_RTSEMEVENT)
891 {
892 // for this very unlikely case, we have to increase the number of
893 // children left, for symmetry with #removeDependentChild()
894 ++ mChildrenLeft;
895 return;
896 }
897
898 std::pair <DependentChildren::iterator, bool> result =
899 mDependentChildren.insert (DependentChildren::value_type (unk, child));
900 AssertMsg (result.second, ("Failed to insert a child to the map\n"));
901}
902
903/** Helper for removeDependentChild() template method */
904void VirtualBoxBaseWithChildren::removeDependentChild (const ComPtr <IUnknown> &unk)
905{
906 /// @todo (r=dmik) see todo in VirtualBoxBase.h, in
907 // template <class C> void removeDependentChild (C *child)
908
909 AssertReturn (!!unk, (void) 0);
910
911 AutoLock alock (mMapLock);
912
913 if (mUninitDoneSem != NIL_RTSEMEVENT)
914 {
915 // uninitDependentChildren() is in action, just increase the number
916 // of children left and signal a semaphore when it reaches zero
917 Assert (mChildrenLeft != 0);
918 -- mChildrenLeft;
919 if (mChildrenLeft == 0)
920 {
921 int vrc = RTSemEventSignal (mUninitDoneSem);
922 AssertRC (vrc);
923 }
924 return;
925 }
926
927 DependentChildren::size_type result = mDependentChildren.erase (unk);
928 AssertMsg (result == 1, ("Failed to remove a child from the map\n"));
929 NOREF (result);
930}
931
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