00001
00002
00003 #include "ace/Object_Manager.h"
00004 #if !defined (ACE_LACKS_ACE_TOKEN)
00005 # include "ace/Token_Manager.h"
00006 #endif
00007 #include "ace/Thread_Manager.h"
00008 #if !defined (ACE_LACKS_ACE_SVCCONF)
00009 # include "ace/Service_Manager.h"
00010 # include "ace/Service_Config.h"
00011 #endif
00012 #include "ace/Signal.h"
00013 #include "ace/Log_Msg.h"
00014 #include "ace/Malloc.h"
00015 #include "ace/Sig_Adapter.h"
00016 #include "ace/Framework_Component.h"
00017 #include "ace/DLL_Manager.h"
00018 #include "ace/Atomic_Op.h"
00019 #include "ace/OS_NS_sys_time.h"
00020
00021 #if defined (ACE_HAS_TRACE)
00022 #include "ace/Trace.h"
00023 #endif
00024
00025 #if !defined (__ACE_INLINE__)
00026 # include "ace/Object_Manager.inl"
00027 #endif
00028
00029 #include "ace/Guard_T.h"
00030 #include "ace/Null_Mutex.h"
00031 #include "ace/Mutex.h"
00032 #include "ace/RW_Thread_Mutex.h"
00033 #if defined (ACE_DISABLE_WIN32_ERROR_WINDOWS) && \
00034 defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) \
00035 && (_MSC_VER >= 1400) // VC++ 8.0 and above.
00036 #include "ace/OS_NS_stdlib.h"
00037 #endif // ACE_DISABLE_WIN32_ERROR_WINDOWS && ACE_WIN32 && !ACE_HAS_WINCE && (_MSC_VER >= 1400)
00038
00039 ACE_RCSID(ace, Object_Manager, "$Id: Object_Manager.cpp 84218 2009-01-22 19:21:39Z mitza $")
00040
00041 #if ! defined (ACE_APPLICATION_PREALLOCATED_OBJECT_DEFINITIONS)
00042 # define ACE_APPLICATION_PREALLOCATED_OBJECT_DEFINITIONS
00043 #endif
00044
00045 #if ! defined (ACE_APPLICATION_PREALLOCATED_ARRAY_DEFINITIONS)
00046 # define ACE_APPLICATION_PREALLOCATED_ARRAY_DEFINITIONS
00047 #endif
00048
00049 #if ! defined (ACE_APPLICATION_PREALLOCATED_OBJECT_DELETIONS)
00050 # define ACE_APPLICATION_PREALLOCATED_OBJECT_DELETIONS
00051 #endif
00052
00053 #if ! defined (ACE_APPLICATION_PREALLOCATED_ARRAY_DELETIONS)
00054 # define ACE_APPLICATION_PREALLOCATED_ARRAY_DELETIONS
00055 #endif
00056
00057 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00058
00059
00060
00061 #if defined (ACE_DISABLE_WIN32_ERROR_WINDOWS) && \
00062 defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) && \
00063 (_MSC_VER >= 1400) && defined (_M_IX86)
00064 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI ACEdisableSetUnhandledExceptionFilter (
00065 LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter)
00066 {
00067 return 0;
00068 }
00069 #endif // ACE_DISABLE_WIN32_ERROR_WINDOWS && ACE_WIN32 && !ACE_HAS_WINCE && (_MSC_VER >= 1400) && _M_IX86
00070
00071
00072 ACE_Object_Manager *ACE_Object_Manager::instance_ = 0;
00073
00074 void *ACE_Object_Manager::preallocated_object[
00075 ACE_Object_Manager::ACE_PREALLOCATED_OBJECTS] = { 0 };
00076
00077 void *ACE_Object_Manager::preallocated_array[
00078 ACE_Object_Manager::ACE_PREALLOCATED_ARRAYS] = { 0 };
00079
00080
00081
00082
00083 #if defined (ACE_HAS_STATIC_PREALLOCATION)
00084 # define ACE_PREALLOCATE_OBJECT(TYPE, ID)\
00085 {\
00086 static ACE_Cleanup_Adapter<TYPE> obj;\
00087 preallocated_object[ID] = &obj;\
00088 }
00089 # define ACE_PREALLOCATE_ARRAY(TYPE, ID, COUNT)\
00090 {\
00091 static ACE_Cleanup_Adapter<TYPE> obj[COUNT];\
00092 preallocated_array[ID] = &obj;\
00093 }
00094 #else
00095 # define ACE_PREALLOCATE_OBJECT(TYPE, ID)\
00096 {\
00097 ACE_Cleanup_Adapter<TYPE> *obj_p;\
00098 ACE_NEW_RETURN (obj_p, ACE_Cleanup_Adapter<TYPE>, -1);\
00099 preallocated_object[ID] = obj_p;\
00100 }
00101 # define ACE_PREALLOCATE_ARRAY(TYPE, ID, COUNT)\
00102 {\
00103 ACE_Cleanup_Adapter<TYPE[COUNT]> *array_p;\
00104 ACE_NEW_RETURN (array_p, ACE_Cleanup_Adapter<TYPE[COUNT]>, -1);\
00105 preallocated_array[ID] = array_p;\
00106 }
00107 # define ACE_DELETE_PREALLOCATED_OBJECT(TYPE, ID)\
00108 ACE_CLEANUP_DESTROYER_NAME (\
00109 (ACE_Cleanup_Adapter<TYPE> *) preallocated_object[ID], 0);\
00110 preallocated_object[ID] = 0;
00111 # define ACE_DELETE_PREALLOCATED_ARRAY(TYPE, ID, COUNT)\
00112 delete (ACE_Cleanup_Adapter<TYPE[COUNT]> *) preallocated_array[ID];\
00113 preallocated_array[ID] = 0;
00114 #endif
00115
00116 #if !defined (ACE_LACKS_ACE_SVCCONF)
00117
00118
00119
00120
00121
00122
00123
00124 class ACE_Object_Manager_Preallocations
00125 {
00126 public:
00127 ACE_Object_Manager_Preallocations (void);
00128 ~ACE_Object_Manager_Preallocations (void);
00129
00130 private:
00131 ACE_Static_Svc_Descriptor ace_svc_desc_ACE_Service_Manager;
00132 };
00133
00134 ACE_Object_Manager_Preallocations::ACE_Object_Manager_Preallocations (void)
00135 {
00136 ACE_STATIC_SVC_DEFINE (ACE_Service_Manager_initializer,
00137 ACE_TEXT ("ACE_Service_Manager"),
00138 ACE_SVC_OBJ_T,
00139 &ACE_SVC_NAME (ACE_Service_Manager),
00140 ACE_Service_Type::DELETE_THIS |
00141 ACE_Service_Type::DELETE_OBJ,
00142 0)
00143
00144
00145
00146 ace_svc_desc_ACE_Service_Manager =
00147 ace_svc_desc_ACE_Service_Manager_initializer;
00148
00149
00150 ACE_Service_Config::static_svcs ()->
00151 insert (&ace_svc_desc_ACE_Service_Manager);
00152 }
00153
00154 ACE_Object_Manager_Preallocations::~ACE_Object_Manager_Preallocations (void)
00155 {
00156 }
00157
00158 #endif
00159
00160 int
00161 ACE_Object_Manager::starting_up (void)
00162 {
00163 return ACE_Object_Manager::instance_ ? instance_->starting_up_i () : 1;
00164 }
00165
00166 int
00167 ACE_Object_Manager::shutting_down (void)
00168 {
00169 return ACE_Object_Manager::instance_ ? instance_->shutting_down_i () : 1;
00170 }
00171
00172 #if defined (ACE_DISABLE_WIN32_ERROR_WINDOWS)
00173
00174 LONG _stdcall ACE_UnhandledExceptionFilter (PEXCEPTION_POINTERS pExceptionInfo)
00175 {
00176 DWORD dwExceptionCode = pExceptionInfo->ExceptionRecord->ExceptionCode;
00177
00178 if (dwExceptionCode == EXCEPTION_ACCESS_VIOLATION)
00179 ACE_ERROR ((LM_ERROR, ACE_TEXT ("\nERROR: ACCESS VIOLATION\n")));
00180 else
00181 ACE_ERROR ((LM_ERROR, ACE_TEXT ("\nERROR: UNHANDLED EXCEPTION\n")));
00182
00183 return EXCEPTION_EXECUTE_HANDLER;
00184 }
00185 #endif
00186
00187
00188
00189
00190
00191
00192 int
00193 ACE_Object_Manager::init (void)
00194 {
00195 if (starting_up_i ())
00196 {
00197
00198
00199 object_manager_state_ = OBJ_MAN_INITIALIZING;
00200
00201
00202
00203 if (this == instance_)
00204 {
00205
00206
00207 ACE_OS_Object_Manager::instance ()->next_ = this;
00208
00209 # if defined (ACE_HAS_BUILTIN_ATOMIC_OP)
00210 ACE_Atomic_Op<ACE_Thread_Mutex, long>::init_functions ();
00211 ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long>::init_functions ();
00212 # endif
00213
00214 # if !defined (ACE_LACKS_ACE_SVCCONF)
00215
00216 ACE_NEW_RETURN (ace_service_config_sig_handler_,
00217 ACE_Sig_Adapter (&ACE_Service_Config::handle_signal), -1);
00218 ACE_Service_Config::signal_handler (ace_service_config_sig_handler_);
00219 # endif
00220
00221
00222 ACE_PREALLOCATE_OBJECT (ACE_SYNCH_RW_MUTEX, ACE_FILECACHE_LOCK)
00223 # if defined (ACE_HAS_THREADS)
00224 ACE_PREALLOCATE_OBJECT (ACE_Recursive_Thread_Mutex,
00225 ACE_STATIC_OBJECT_LOCK)
00226 # endif
00227 # if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00228 ACE_PREALLOCATE_OBJECT (ACE_Thread_Mutex,
00229 ACE_MT_CORBA_HANDLER_LOCK)
00230 ACE_PREALLOCATE_OBJECT (ACE_Thread_Mutex, ACE_DUMP_LOCK)
00231 ACE_PREALLOCATE_OBJECT (ACE_Recursive_Thread_Mutex,
00232 ACE_SIG_HANDLER_LOCK)
00233 ACE_PREALLOCATE_OBJECT (ACE_Null_Mutex, ACE_SINGLETON_NULL_LOCK)
00234 ACE_PREALLOCATE_OBJECT (ACE_Recursive_Thread_Mutex,
00235 ACE_SINGLETON_RECURSIVE_THREAD_LOCK)
00236 ACE_PREALLOCATE_OBJECT (ACE_Thread_Mutex, ACE_THREAD_EXIT_LOCK)
00237 #if !defined (ACE_LACKS_ACE_TOKEN) && defined (ACE_HAS_TOKENS_LIBRARY)
00238 ACE_PREALLOCATE_OBJECT (ACE_TOKEN_CONST::MUTEX,
00239 ACE_TOKEN_MANAGER_CREATION_LOCK)
00240 ACE_PREALLOCATE_OBJECT (ACE_TOKEN_CONST::MUTEX,
00241 ACE_TOKEN_INVARIANTS_CREATION_LOCK)
00242 #endif
00243 ACE_PREALLOCATE_OBJECT (ACE_Thread_Mutex,
00244 ACE_PROACTOR_EVENT_LOOP_LOCK)
00245 # endif
00246 }
00247
00248 if (this == instance_)
00249 {
00250
00251 ACE_APPLICATION_PREALLOCATED_OBJECT_DEFINITIONS
00252 ACE_APPLICATION_PREALLOCATED_ARRAY_DEFINITIONS
00253
00254 # if defined (ACE_HAS_TSS_EMULATION)
00255
00256 if (!ts_storage_initialized_)
00257 {
00258 ACE_TSS_Emulation::tss_open (ts_storage_);
00259 ts_storage_initialized_ = true;
00260 }
00261 # endif
00262
00263 #if defined (ACE_DISABLE_WIN32_ERROR_WINDOWS) && \
00264 defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
00265 #if defined (_DEBUG) && (defined (_MSC_VER) || defined (__INTEL_COMPILER))
00266 _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
00267 _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
00268 _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
00269 _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
00270 #endif
00271
00272
00273 SetErrorMode(SEM_FAILCRITICALERRORS);
00274
00275
00276 SetUnhandledExceptionFilter (&ACE_UnhandledExceptionFilter);
00277
00278 # if (_MSC_VER >= 1400) // VC++ 8.0 and above.
00279
00280 _set_abort_behavior( 0, _CALL_REPORTFAULT);
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296 # ifdef _M_IX86
00297 HMODULE hKernel32 = ACE_TEXT_LoadLibrary (ACE_TEXT ("kernel32.dll"));
00298 if (hKernel32)
00299 {
00300 void *pOrgEntry =
00301 GetProcAddress (hKernel32, "SetUnhandledExceptionFilter");
00302 if (pOrgEntry)
00303 {
00304 unsigned char newJump[ 100 ];
00305 DWORD dwOrgEntryAddr = reinterpret_cast<DWORD> (pOrgEntry);
00306 dwOrgEntryAddr += 5;
00307 void *pNewFunc = &ACEdisableSetUnhandledExceptionFilter;
00308 DWORD dwNewEntryAddr = reinterpret_cast<DWORD> (pNewFunc);
00309 DWORD dwRelativeAddr = dwNewEntryAddr - dwOrgEntryAddr;
00310
00311 newJump[ 0 ] = 0xE9;
00312 ACE_OS::memcpy (&newJump[ 1 ], &dwRelativeAddr, sizeof (pNewFunc));
00313 SIZE_T bytesWritten;
00314 WriteProcessMemory (
00315 GetCurrentProcess (),
00316 pOrgEntry,
00317 newJump,
00318 sizeof (pNewFunc) + 1,
00319 &bytesWritten);
00320 }
00321 }
00322 # endif // _M_IX86
00323 # endif // (_MSC_VER >= 1400) // VC++ 8.0 and above.
00324 #endif
00325
00326
00327 # if !defined (ACE_LACKS_ACE_SVCCONF)
00328 ACE_NEW_RETURN (preallocations_,
00329 ACE_Object_Manager_Preallocations,
00330 -1);
00331 # endif
00332
00333
00334 if (0 == ACE_LOG_MSG)
00335 return -1;
00336 }
00337
00338
00339
00340 object_manager_state_ = OBJ_MAN_INITIALIZED;
00341
00342 #if defined (ACE_HAS_TRACE)
00343
00344 ACE_Trace::start_tracing ();
00345 #endif
00346
00347 return 0;
00348 } else {
00349
00350 return 1;
00351 }
00352 }
00353
00354 #if defined (ACE_HAS_TSS_EMULATION)
00355 int
00356 ACE_Object_Manager::init_tss (void)
00357 {
00358 return ACE_Object_Manager::instance ()->init_tss_i ();
00359 }
00360
00361 int
00362 ACE_Object_Manager::init_tss_i (void)
00363 {
00364 ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
00365 *instance_->internal_lock_, -1));
00366
00367 if (!ts_storage_initialized_)
00368 {
00369 ACE_TSS_Emulation::tss_open (ts_storage_);
00370 ts_storage_initialized_ = true;
00371 }
00372
00373 return 0;
00374 }
00375
00376 #endif
00377
00378 ACE_Object_Manager::ACE_Object_Manager (void)
00379
00380
00381 : exit_info_ ()
00382 #if !defined (ACE_LACKS_ACE_SVCCONF)
00383 , preallocations_ (0)
00384 , ace_service_config_sig_handler_ (0)
00385 #endif
00386 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00387 , singleton_null_lock_ (0)
00388 , singleton_recursive_lock_ (0)
00389 #endif
00390 #if defined (ACE_HAS_TSS_EMULATION)
00391 , ts_storage_initialized_ (false)
00392 #endif
00393 {
00394 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00395 ACE_NEW (internal_lock_, ACE_Recursive_Thread_Mutex);
00396 # endif
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408 if (instance_ == 0)
00409 instance_ = this;
00410
00411 init ();
00412 }
00413
00414 ACE_Object_Manager::~ACE_Object_Manager (void)
00415 {
00416 dynamically_allocated_ = false;
00417 fini ();
00418 }
00419
00420 ACE_Object_Manager *
00421 ACE_Object_Manager::instance (void)
00422 {
00423
00424
00425
00426
00427 if (instance_ == 0)
00428 {
00429 ACE_Object_Manager *instance_pointer = 0;
00430
00431 ACE_NEW_RETURN (instance_pointer,
00432 ACE_Object_Manager,
00433 0);
00434 ACE_ASSERT (instance_pointer == instance_);
00435
00436 instance_pointer->dynamically_allocated_ = true;
00437
00438 return instance_pointer;
00439 }
00440 else
00441 return instance_;
00442 }
00443
00444 int
00445 ACE_Object_Manager::at_exit_i (void *object,
00446 ACE_CLEANUP_FUNC cleanup_hook,
00447 void *param,
00448 const char* name)
00449 {
00450 ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
00451 *instance_->internal_lock_, -1));
00452
00453 if (shutting_down_i ())
00454 {
00455 errno = EAGAIN;
00456 return -1;
00457 }
00458
00459 if (exit_info_.find (object))
00460 {
00461
00462 errno = EEXIST;
00463 return -1;
00464 }
00465
00466 return exit_info_.at_exit_i (object, cleanup_hook, param, name);
00467 }
00468
00469 int
00470 ACE_Object_Manager::remove_at_exit_i (void *object)
00471 {
00472 ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
00473 *instance_->internal_lock_, -1));
00474
00475 if (shutting_down_i ())
00476 {
00477 errno = EAGAIN;
00478 return -1;
00479 }
00480
00481 return exit_info_.remove (object);
00482 }
00483
00484 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00485
00486 int
00487 ACE_Object_Manager::get_singleton_lock (ACE_Null_Mutex *&lock)
00488 {
00489 if (starting_up () || shutting_down ())
00490 {
00491
00492
00493
00494
00495
00496
00497 if (ACE_Object_Manager::instance ()->singleton_null_lock_ == 0)
00498 {
00499 ACE_NEW_RETURN (ACE_Object_Manager::instance ()->
00500 singleton_null_lock_,
00501 ACE_Cleanup_Adapter<ACE_Null_Mutex>,
00502 -1);
00503
00504
00505
00506
00507 }
00508
00509 if (ACE_Object_Manager::instance ()->singleton_null_lock_ != 0)
00510 lock = &ACE_Object_Manager::instance ()->singleton_null_lock_->
00511 object ();
00512 }
00513 else
00514
00515 lock = ACE_Managed_Object<ACE_Null_Mutex>::get_preallocated_object
00516 (ACE_Object_Manager::ACE_SINGLETON_NULL_LOCK);
00517
00518 return 0;
00519 }
00520
00521 int
00522 ACE_Object_Manager::get_singleton_lock (ACE_Thread_Mutex *&lock)
00523 {
00524 if (lock == 0)
00525 {
00526 if (starting_up () || shutting_down ())
00527 {
00528
00529
00530
00531
00532
00533
00534 ACE_NEW_RETURN (lock,
00535 ACE_Thread_Mutex,
00536 -1);
00537 }
00538 else
00539 {
00540
00541
00542 ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
00543 ace_mon,
00544 *ACE_Object_Manager::instance ()->
00545 internal_lock_,
00546 -1));
00547
00548 if (lock == 0)
00549 {
00550 ACE_Cleanup_Adapter<ACE_Thread_Mutex> *lock_adapter = 0;
00551 ACE_NEW_RETURN (lock_adapter,
00552 ACE_Cleanup_Adapter<ACE_Thread_Mutex>,
00553 -1);
00554 lock = &lock_adapter->object ();
00555
00556
00557
00558
00559
00560 ACE_Object_Manager::at_exit (lock_adapter,
00561 0,
00562 typeid (*lock_adapter).name ());
00563 }
00564 }
00565 }
00566
00567 return 0;
00568 }
00569
00570 int
00571 ACE_Object_Manager::get_singleton_lock (ACE_Mutex *&lock)
00572 {
00573 if (lock == 0)
00574 {
00575 if (starting_up () || shutting_down ())
00576 {
00577
00578
00579
00580
00581
00582
00583
00584 ACE_NEW_RETURN (lock,
00585 ACE_Mutex,
00586 -1);
00587 }
00588 else
00589 {
00590
00591
00592 ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
00593 ace_mon,
00594 *ACE_Object_Manager::instance ()->
00595 internal_lock_,
00596 -1));
00597
00598 if (lock == 0)
00599 {
00600 ACE_Cleanup_Adapter<ACE_Mutex> *lock_adapter = 0;
00601 ACE_NEW_RETURN (lock_adapter,
00602 ACE_Cleanup_Adapter<ACE_Mutex>,
00603 -1);
00604 lock = &lock_adapter->object ();
00605
00606
00607
00608
00609
00610 ACE_Object_Manager::at_exit (lock_adapter);
00611 }
00612 }
00613 }
00614
00615 return 0;
00616 }
00617
00618 int
00619 ACE_Object_Manager::get_singleton_lock (ACE_Recursive_Thread_Mutex *&lock)
00620 {
00621 if (starting_up () || shutting_down ())
00622 {
00623
00624
00625
00626
00627
00628
00629 if (ACE_Object_Manager::instance ()->singleton_recursive_lock_ == 0)
00630 ACE_NEW_RETURN (ACE_Object_Manager::instance ()->
00631 singleton_recursive_lock_,
00632 ACE_Cleanup_Adapter<ACE_Recursive_Thread_Mutex>,
00633 -1);
00634
00635
00636
00637
00638
00639 if (ACE_Object_Manager::instance ()->singleton_recursive_lock_ != 0)
00640 lock = &ACE_Object_Manager::instance ()->singleton_recursive_lock_->
00641 object ();
00642 }
00643 else
00644 {
00645
00646 lock = ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::
00647 get_preallocated_object (ACE_Object_Manager::
00648 ACE_SINGLETON_RECURSIVE_THREAD_LOCK);
00649 }
00650
00651 return 0;
00652 }
00653
00654 int
00655 ACE_Object_Manager::get_singleton_lock (ACE_RW_Thread_Mutex *&lock)
00656 {
00657 if (lock == 0)
00658 {
00659 if (starting_up () || shutting_down ())
00660 {
00661
00662
00663
00664
00665
00666
00667
00668 ACE_NEW_RETURN (lock,
00669 ACE_RW_Thread_Mutex,
00670 -1);
00671 }
00672 else
00673 {
00674
00675
00676 ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex,
00677 ace_mon,
00678 *ACE_Object_Manager::instance ()->
00679 internal_lock_,
00680 -1));
00681
00682 if (lock == 0)
00683 {
00684 ACE_Cleanup_Adapter<ACE_RW_Thread_Mutex> *lock_adapter = 0;
00685 ACE_NEW_RETURN (lock_adapter,
00686 ACE_Cleanup_Adapter<ACE_RW_Thread_Mutex>,
00687 -1);
00688 lock = &lock_adapter->object ();
00689
00690
00691
00692
00693
00694
00695 ACE_Object_Manager::at_exit (lock_adapter);
00696 }
00697 }
00698 }
00699
00700 return 0;
00701 }
00702 #endif
00703
00704
00705
00706
00707
00708
00709 int
00710 ACE_Object_Manager::fini (void)
00711 {
00712 if (shutting_down_i ())
00713
00714
00715 return object_manager_state_ == OBJ_MAN_SHUT_DOWN ? 1 : -1;
00716
00717
00718
00719
00720
00721
00722 object_manager_state_ = OBJ_MAN_SHUTTING_DOWN;
00723
00724
00725
00726 exit_info_.call_hooks ();
00727
00728 if (this == instance_)
00729 {
00730 #if !defined (ACE_LACKS_ACE_SVCCONF)
00731 delete preallocations_;
00732 preallocations_ = 0;
00733 #endif
00734
00735 #if defined (ACE_HAS_TRACE)
00736 ACE_Trace::stop_tracing ();
00737 #endif
00738
00739 #if !defined (ACE_LACKS_ACE_SVCCONF)
00740
00741
00742 ACE_Service_Config::fini_svcs ();
00743
00744
00745
00746 ACE_Service_Config::close ();
00747 #endif
00748
00749
00750
00751 ACE_Framework_Repository::close_singleton ();
00752 ACE_DLL_Manager::close_singleton ();
00753
00754 # if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS)
00755 ACE_Thread_Manager::close_singleton ();
00756 # endif
00757
00758
00759 ACE_OS::cleanup_tss (1 );
00760
00761
00762
00763
00764
00765
00766 ACE_Allocator::close_singleton ();
00767
00768 #if ! defined (ACE_HAS_STATIC_PREALLOCATION)
00769
00770
00771 ACE_APPLICATION_PREALLOCATED_ARRAY_DELETIONS
00772 ACE_APPLICATION_PREALLOCATED_OBJECT_DELETIONS
00773
00774
00775
00776
00777
00778 ACE_DELETE_PREALLOCATED_OBJECT (ACE_SYNCH_RW_MUTEX, ACE_FILECACHE_LOCK)
00779 #if defined (ACE_HAS_THREADS)
00780 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Recursive_Thread_Mutex,
00781 ACE_STATIC_OBJECT_LOCK)
00782 #endif
00783 # if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00784 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Thread_Mutex,
00785 ACE_MT_CORBA_HANDLER_LOCK)
00786 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Thread_Mutex, ACE_DUMP_LOCK)
00787 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Recursive_Thread_Mutex,
00788 ACE_SIG_HANDLER_LOCK)
00789 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Null_Mutex,
00790 ACE_SINGLETON_NULL_LOCK)
00791 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Recursive_Thread_Mutex,
00792 ACE_SINGLETON_RECURSIVE_THREAD_LOCK)
00793 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Thread_Mutex, ACE_THREAD_EXIT_LOCK)
00794 #if !defined (ACE_LACKS_ACE_TOKEN) && defined (ACE_HAS_TOKENS_LIBRARY)
00795 ACE_DELETE_PREALLOCATED_OBJECT (ACE_TOKEN_CONST::MUTEX,
00796 ACE_TOKEN_MANAGER_CREATION_LOCK)
00797 ACE_DELETE_PREALLOCATED_OBJECT (ACE_TOKEN_CONST::MUTEX,
00798 ACE_TOKEN_INVARIANTS_CREATION_LOCK)
00799 #endif
00800 ACE_DELETE_PREALLOCATED_OBJECT (ACE_Thread_Mutex,
00801 ACE_PROACTOR_EVENT_LOOP_LOCK)
00802 # endif
00803 #endif
00804
00805 #if defined (ACE_HAS_THREADS)
00806 ACE_Static_Object_Lock::cleanup_lock ();
00807 #endif
00808 }
00809
00810 #if !defined (ACE_LACKS_ACE_SVCCONF)
00811 delete ace_service_config_sig_handler_;
00812 ace_service_config_sig_handler_ = 0;
00813 #endif
00814
00815 #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
00816 delete internal_lock_;
00817 internal_lock_ = 0;
00818
00819 delete singleton_null_lock_;
00820 singleton_null_lock_ = 0;
00821
00822 delete singleton_recursive_lock_;
00823 singleton_recursive_lock_ = 0;
00824 #endif
00825
00826
00827 object_manager_state_ = OBJ_MAN_SHUT_DOWN;
00828
00829
00830 if (this == instance_ && ACE_OS_Object_Manager::instance_)
00831 ACE_OS_Object_Manager::instance_->fini ();
00832
00833 if (dynamically_allocated_)
00834 {
00835 delete this;
00836 }
00837
00838 if (this == instance_)
00839 instance_ = 0;
00840
00841 return 0;
00842 }
00843
00844
00845 #if !defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER)
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856 class ACE_Export ACE_Object_Manager_Manager
00857 {
00858 public:
00859 ACE_Object_Manager_Manager (void);
00860 ~ACE_Object_Manager_Manager (void);
00861
00862 private:
00863
00864 ACE_thread_t saved_main_thread_id_;
00865 };
00866
00867 ACE_Object_Manager_Manager::ACE_Object_Manager_Manager (void)
00868 : saved_main_thread_id_ (ACE_OS::thr_self ())
00869 {
00870
00871
00872
00873
00874 (void) ACE_Object_Manager::instance ();
00875 }
00876
00877 ACE_Object_Manager_Manager::~ACE_Object_Manager_Manager (void)
00878 {
00879 if (ACE_OS::thr_equal (ACE_OS::thr_self (),
00880 saved_main_thread_id_))
00881 {
00882 delete ACE_Object_Manager::instance_;
00883 ACE_Object_Manager::instance_ = 0;
00884 }
00885
00886
00887
00888 }
00889
00890 static ACE_Object_Manager_Manager ACE_Object_Manager_Manager_instance;
00891 #endif
00892
00893 #if defined (ACE_HAS_THREADS)
00894
00895
00896 #if !defined (ACE_IS_SPLITTING)
00897
00898
00899 typedef ACE_Cleanup_Adapter<ACE_Recursive_Thread_Mutex> ACE_Static_Object_Lock_Type;
00900 static ACE_Static_Object_Lock_Type *ACE_Static_Object_Lock_lock = 0;
00901 #endif
00902
00903
00904
00905
00906
00907
00908 ACE_Recursive_Thread_Mutex *
00909 ACE_Static_Object_Lock::instance (void)
00910 {
00911 if (ACE_Object_Manager::starting_up () ||
00912 ACE_Object_Manager::shutting_down ())
00913 {
00914
00915
00916
00917
00918
00919
00920 if (ACE_Static_Object_Lock_lock == 0)
00921 {
00922 # if defined (ACE_SHOULD_MALLOC_STATIC_OBJECT_LOCK)
00923
00924
00925 void *buffer =
00926 ACE_OS::malloc (sizeof (*ACE_Static_Object_Lock_lock));
00927 if (buffer == 0)
00928 {
00929 return 0;
00930 }
00931
00932 ACE_Static_Object_Lock_lock = new (buffer)
00933 ACE_Static_Object_Lock_Type ();
00934
00935 # else
00936 ACE_NEW_RETURN (ACE_Static_Object_Lock_lock,
00937 ACE_Cleanup_Adapter<ACE_Recursive_Thread_Mutex>,
00938 0);
00939 # endif
00940 }
00941
00942
00943
00944
00945
00946 return &ACE_Static_Object_Lock_lock->object ();
00947 }
00948 else
00949
00950 return
00951 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00952 (ACE_Object_Manager::ACE_STATIC_OBJECT_LOCK);
00953 }
00954
00955 void
00956 ACE_Static_Object_Lock::cleanup_lock (void)
00957 {
00958 # if defined(ACE_SHOULD_MALLOC_STATIC_OBJECT_LOCK)
00959
00960
00961 ACE_DES_FREE (ACE_Static_Object_Lock_lock,
00962 ACE_OS::free,
00963 ACE_Static_Object_Lock_Type);
00964 # else
00965 delete ACE_Static_Object_Lock_lock;
00966 # endif
00967 ACE_Static_Object_Lock_lock = 0;
00968 }
00969 #endif
00970
00971 ACE_END_VERSIONED_NAMESPACE_DECL