From 6af58c3c72ef8cc721c239c3046ea923dcd3f8f5 Mon Sep 17 00:00:00 2001 From: levine Date: Mon, 22 Sep 1997 18:08:24 +0000 Subject: preallocate locks for Filecache and Signal in ACE_Object_Manager --- ace/Signal.cpp | 353 +++++++++++++++++++++++++++++++-------------------------- 1 file changed, 190 insertions(+), 163 deletions(-) (limited to 'ace/Signal.cpp') diff --git a/ace/Signal.cpp b/ace/Signal.cpp index 34235a124e0..9a08772c35e 100644 --- a/ace/Signal.cpp +++ b/ace/Signal.cpp @@ -4,6 +4,7 @@ #define ACE_BUILD_DLL #include "ace/Synch_T.h" #include "ace/Signal.h" +#include "ace/Object_Manager.h" #if !defined (__ACE_INLINE__) #include "ace/Signal.i" @@ -40,10 +41,6 @@ static ACE_SignalHandler ace_signal_handlers_dispatcher = ACE_SignalHandler (ACE #endif /* ACE_HAS_BROKEN_HPUX_TEMPLATES */ #endif /* ACE_HAS_SIG_C_FUNC */ -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) -ACE_Recursive_Thread_Mutex ACE_Sig_Handler::ace_sig_handler_lock_; -#endif /* ACE_MT_SAFE */ - // Array of Event_Handlers that will handle the signals. ACE_Event_Handler *ACE_Sig_Handler::signal_handlers_[NSIG]; @@ -89,8 +86,8 @@ ACE_Sig_Action::ACE_Sig_Action (void) } ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - sigset_t *sig_mask, - int sig_flags) + sigset_t *sig_mask, + int sig_flags) { // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); this->sa_.sa_flags = sig_flags; @@ -108,8 +105,8 @@ ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, } ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - ACE_Sig_Set &sig_mask, - int sig_flags) + ACE_Sig_Set &sig_mask, + int sig_flags) { // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); this->sa_.sa_flags = sig_flags; @@ -125,9 +122,9 @@ ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, } ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - int signum, - sigset_t *sig_mask, - int sig_flags) + int signum, + sigset_t *sig_mask, + int sig_flags) { // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); this->sa_.sa_flags = sig_flags; @@ -146,9 +143,9 @@ ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, } ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - int signum, - ACE_Sig_Set &sig_mask, - int sig_flags) + int signum, + ACE_Sig_Set &sig_mask, + int sig_flags) { // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); this->sa_.sa_flags = sig_flags; @@ -176,7 +173,10 @@ sig_atomic_t ACE_Sig_Handler::sig_pending (void) { ACE_TRACE ("ACE_Sig_Handler::sig_pending"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); return ACE_Sig_Handler::sig_pending_; } @@ -184,7 +184,10 @@ void ACE_Sig_Handler::sig_pending (sig_atomic_t pending) { ACE_TRACE ("ACE_Sig_Handler::sig_pending"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); ACE_Sig_Handler::sig_pending_ = pending; } @@ -192,7 +195,10 @@ ACE_Event_Handler * ACE_Sig_Handler::handler (int signum) { ACE_TRACE ("ACE_Sig_Handler::handler"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); if (ACE_Sig_Handler::in_range (signum)) return ACE_Sig_Handler::signal_handlers_[signum]; @@ -204,7 +210,10 @@ ACE_Event_Handler * ACE_Sig_Handler::handler (int signum, ACE_Event_Handler *new_sh) { ACE_TRACE ("ACE_Sig_Handler::handler"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); if (ACE_Sig_Handler::in_range (signum)) { @@ -221,13 +230,16 @@ ACE_Sig_Handler::handler (int signum, ACE_Event_Handler *new_sh) int ACE_Sig_Handler::register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **old_sh, - ACE_Sig_Action *old_disp) + ACE_Event_Handler *new_sh, + ACE_Sig_Action *new_disp, + ACE_Event_Handler **old_sh, + ACE_Sig_Action *old_disp) { ACE_TRACE ("ACE_Sig_Handler::register_handler"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); if (ACE_Sig_Handler::in_range (signum)) { @@ -237,7 +249,7 @@ ACE_Sig_Handler::register_handler (int signum, // Stack the old ACE_Sig_Handler if the user gives us a pointer // to a object. if (old_sh != 0) - *old_sh = sh; + *old_sh = sh; // Make sure that new_disp points to a valid location if the // user doesn't care... @@ -256,19 +268,22 @@ ACE_Sig_Handler::register_handler (int signum, int ACE_Sig_Handler::remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int) + ACE_Sig_Action *new_disp, + ACE_Sig_Action *old_disp, + int) { ACE_TRACE ("ACE_Sig_Handler::remove_handler"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); if (ACE_Sig_Handler::in_range (signum)) { ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0); // Define the default disposition. if (new_disp == 0) - new_disp = &sa; + new_disp = &sa; ACE_Sig_Handler::signal_handlers_[signum] = 0; @@ -284,11 +299,14 @@ ACE_Sig_Handler::remove_handler (int signum, void ACE_Sig_Handler::dispatch (int signum, - siginfo_t *siginfo, - ucontext_t *ucontext) + siginfo_t *siginfo, + ucontext_t *ucontext) { ACE_TRACE ("ACE_Sig_Handler::dispatch"); - ACE_MT (ACE_TSS_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_TSS_Guard m (*lock)); // Preserve errno across callbacks! int old_errno = errno; @@ -325,7 +343,7 @@ ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Sig_Action &sa, int sigkey) } ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Event_Handler *eh, - int sigkey) + int sigkey) : sigkey_ (sigkey), type_ (ACE_HANDLER), eh_ (eh) @@ -334,7 +352,7 @@ ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Event_Handler *eh, } ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Sig_Handler_Ex sig_func, - int sigkey) + int sigkey) : sigkey_ (sigkey), type_ (C_FUNCTION), sig_func_ (sig_func) @@ -351,8 +369,8 @@ ACE_Sig_Adapter::sigkey (void) int ACE_Sig_Adapter::handle_signal (int signum, - siginfo_t *siginfo, - ucontext_t *ucontext) + siginfo_t *siginfo, + ucontext_t *ucontext) { ACE_TRACE ("ACE_Sig_Adapter::handle_signal"); @@ -360,21 +378,21 @@ ACE_Sig_Adapter::handle_signal (int signum, { case SIG_ACTION: { - // We have to dispatch a handler that was registered by a - // third-party library. + // We have to dispatch a handler that was registered by a + // third-party library. - ACE_Sig_Action old_disp; + ACE_Sig_Action old_disp; - // Make sure this handler executes in the context it was - // expecting... - this->sa_.register_action (signum, &old_disp); + // Make sure this handler executes in the context it was + // expecting... + this->sa_.register_action (signum, &old_disp); - ACE_Sig_Handler_Ex sig_func = ACE_Sig_Handler_Ex (this->sa_.handler ()); + ACE_Sig_Handler_Ex sig_func = ACE_Sig_Handler_Ex (this->sa_.handler ()); - (*sig_func) (signum, siginfo, ucontext); - // Restore the original disposition. - old_disp.register_action (signum); - break; + (*sig_func) (signum, siginfo, ucontext); + // Restore the original disposition. + old_disp.register_action (signum); + break; } case ACE_HANDLER: this->eh_->handle_signal (signum, siginfo, ucontext); @@ -405,9 +423,9 @@ int ACE_Sig_Handlers::third_party_sig_handler_ = 0; // Make life easier by defining typedefs... typedef ACE_Fixed_Set - ACE_SIG_HANDLERS_SET; + ACE_SIG_HANDLERS_SET; typedef ACE_Fixed_Set_Iterator - ACE_SIG_HANDLERS_ITERATOR; + ACE_SIG_HANDLERS_ITERATOR; class ACE_Sig_Handlers_Set { @@ -447,13 +465,16 @@ ACE_Sig_Handlers::dump (void) const int ACE_Sig_Handlers::register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **, - ACE_Sig_Action *old_disp) + ACE_Event_Handler *new_sh, + ACE_Sig_Action *new_disp, + ACE_Event_Handler **, + ACE_Sig_Action *old_disp) { ACE_TRACE ("ACE_Sig_Handlers::register_handler"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); if (ACE_Sig_Handler::in_range (signum)) { @@ -468,35 +489,35 @@ ACE_Sig_Handlers::register_handler (int signum, // handling disposition... if (!(sa.handler () == ace_signal_handlers_dispatcher - || sa.handler () == ACE_SignalHandler (SIG_IGN) - || sa.handler () == ACE_SignalHandler (SIG_DFL))) - { - // Drat, a 3rd party library has already installed a signal ;-( - - // Upto here we never disabled RESTART_MODE. Thus, - // RESTART_MODE can only be changed by 3rd party libraries. - - if (ACE_BIT_DISABLED (sa.flags (), SA_RESTART) - && ACE_Sig_Handlers::third_party_sig_handler_) - // Toggling is disallowed since we might break 3rd party - // code. - return -1; - - // Note that we've seen a 3rd party handler... - ACE_Sig_Handlers::third_party_sig_handler_ = 1; - - // Create a new 3rd party disposition, remembering its - // preferred signal blocking etc...; - ACE_NEW_RETURN (extern_sh, ACE_Sig_Adapter (sa, ++ACE_Sig_Handlers::sigkey_), -1); - - // Add the external signal handler to the set of handlers - // for this signal. - if (ACE_Sig_Handlers_Set::instance (signum)->insert (extern_sh) == -1) - { - delete extern_sh; - return -1; - } - } + || sa.handler () == ACE_SignalHandler (SIG_IGN) + || sa.handler () == ACE_SignalHandler (SIG_DFL))) + { + // Drat, a 3rd party library has already installed a signal ;-( + + // Upto here we never disabled RESTART_MODE. Thus, + // RESTART_MODE can only be changed by 3rd party libraries. + + if (ACE_BIT_DISABLED (sa.flags (), SA_RESTART) + && ACE_Sig_Handlers::third_party_sig_handler_) + // Toggling is disallowed since we might break 3rd party + // code. + return -1; + + // Note that we've seen a 3rd party handler... + ACE_Sig_Handlers::third_party_sig_handler_ = 1; + + // Create a new 3rd party disposition, remembering its + // preferred signal blocking etc...; + ACE_NEW_RETURN (extern_sh, ACE_Sig_Adapter (sa, ++ACE_Sig_Handlers::sigkey_), -1); + + // Add the external signal handler to the set of handlers + // for this signal. + if (ACE_Sig_Handlers_Set::instance (signum)->insert (extern_sh) == -1) + { + delete extern_sh; + return -1; + } + } // Add our new handler at this point. ACE_NEW_RETURN (ace_sig_adapter, ACE_Sig_Adapter (new_sh, ++ACE_Sig_Handlers::sigkey_), -1); @@ -504,55 +525,55 @@ ACE_Sig_Handlers::register_handler (int signum, // signal (make sure it goes before the external one if there is // one of these). if (ACE_Sig_Handlers_Set::instance (signum)->insert (ace_sig_adapter) == -1) - { - // We couldn't reinstall our handler, so let's pretend like - // none of this happened... - if (extern_sh) - { - ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh); - delete extern_sh; - } - delete ace_sig_adapter; - return -1; - } + { + // We couldn't reinstall our handler, so let's pretend like + // none of this happened... + if (extern_sh) + { + ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh); + delete extern_sh; + } + delete ace_sig_adapter; + return -1; + } // If ACE_Sig_Handlers::dispatch() was set we're done. else if (sa.handler () == ace_signal_handlers_dispatcher) - return ace_sig_adapter->sigkey (); + return ace_sig_adapter->sigkey (); // Otherwise, we need to register our handler function so that // all signals will be dispatched through ACE. else - { - // Make sure that new_disp points to a valid location if the - // user doesn't care... - if (new_disp == 0) - new_disp = &sa; - - new_disp->handler (ace_signal_handlers_dispatcher); - - // Default is to restart signal handlers. - new_disp->flags (new_disp->flags () | SA_RESTART); - new_disp->flags (new_disp->flags () | SA_SIGINFO); - - // Finally install (possibly reinstall) the ACE signal - // handler disposition with the SA_RESTART mode enabled. - if (new_disp->register_action (signum, old_disp) == -1) - { - // Yikes, lots of roll back at this point... - ACE_Sig_Handlers_Set::instance (signum)->remove (ace_sig_adapter); - delete ace_sig_adapter; - - if (extern_sh) - { - ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh); - delete extern_sh; - } - return -1; - } - else // Return the signal key so that programs can cancel this - // handler if they want! - return ace_sig_adapter->sigkey (); - } + { + // Make sure that new_disp points to a valid location if the + // user doesn't care... + if (new_disp == 0) + new_disp = &sa; + + new_disp->handler (ace_signal_handlers_dispatcher); + + // Default is to restart signal handlers. + new_disp->flags (new_disp->flags () | SA_RESTART); + new_disp->flags (new_disp->flags () | SA_SIGINFO); + + // Finally install (possibly reinstall) the ACE signal + // handler disposition with the SA_RESTART mode enabled. + if (new_disp->register_action (signum, old_disp) == -1) + { + // Yikes, lots of roll back at this point... + ACE_Sig_Handlers_Set::instance (signum)->remove (ace_sig_adapter); + delete ace_sig_adapter; + + if (extern_sh) + { + ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh); + delete extern_sh; + } + return -1; + } + else // Return the signal key so that programs can cancel this + // handler if they want! + return ace_sig_adapter->sigkey (); + } } else return -1; @@ -565,53 +586,56 @@ ACE_Sig_Handlers::register_handler (int signum, int ACE_Sig_Handlers::remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int sigkey) + ACE_Sig_Action *new_disp, + ACE_Sig_Action *old_disp, + int sigkey) { ACE_TRACE ("ACE_Sig_Handlers::remove_handler"); - ACE_MT (ACE_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_Guard m (*lock)); if (ACE_Sig_Handler::in_range (signum)) { ACE_SIG_HANDLERS_SET *handler_set = - ACE_Sig_Handlers_Set::instance (signum); + ACE_Sig_Handlers_Set::instance (signum); ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set); // Iterate through the set of handlers for this signal. for (ACE_Event_Handler **eh; - handler_iterator.next (eh) != 0; - handler_iterator.advance ()) - { - // Type-safe downcast would be nice here... - ACE_Sig_Adapter *sh = (ACE_Sig_Adapter *) *eh; - - // Remove the handler if (1) it's key matches the key we've - // been told to remove or (2) if we've been told to remove - // *all* handlers (i.e., == -1). - - if (sh->sigkey () == sigkey || sigkey == -1) - { - handler_set->remove (*eh); - delete *eh; - } - } + handler_iterator.next (eh) != 0; + handler_iterator.advance ()) + { + // Type-safe downcast would be nice here... + ACE_Sig_Adapter *sh = (ACE_Sig_Adapter *) *eh; + + // Remove the handler if (1) it's key matches the key we've + // been told to remove or (2) if we've been told to remove + // *all* handlers (i.e., == -1). + + if (sh->sigkey () == sigkey || sigkey == -1) + { + handler_set->remove (*eh); + delete *eh; + } + } if (handler_set->size () == 0) - { - // If there are no more handlers left for a signal then - // register the new disposition or restore the default - // disposition. + { + // If there are no more handlers left for a signal then + // register the new disposition or restore the default + // disposition. - ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0); + ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0); - if (new_disp == 0) - new_disp = &sa; + if (new_disp == 0) + new_disp = &sa; - return new_disp->register_action (signum, old_disp); - } + return new_disp->register_action (signum, old_disp); + } return 0; } else @@ -623,11 +647,14 @@ ACE_Sig_Handlers::remove_handler (int signum, void ACE_Sig_Handlers::dispatch (int signum, - siginfo_t *siginfo, - ucontext_t *ucontext) + siginfo_t *siginfo, + ucontext_t *ucontext) { ACE_TRACE ("ACE_Sig_Handlers::dispatch"); - ACE_MT (ACE_TSS_Guard m (ACE_Sig_Handler::ace_sig_handler_lock_)); + ACE_MT (ACE_Recursive_Thread_Mutex *lock = + ACE_Managed_Object::get_preallocated_object + (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); + ACE_TSS_Guard m (*lock)); // Preserve errno across callbacks! int old_errno = errno; @@ -647,10 +674,10 @@ ACE_Sig_Handlers::dispatch (int signum, handler_iterator.advance ()) { if ((*eh)->handle_signal (signum, siginfo, ucontext) == -1) - { - handler_set->remove (*eh); - delete *eh; - } + { + handler_set->remove (*eh); + delete *eh; + } } // Restore error when callback completes. -- cgit v1.2.1