preallocate locks for Filecache and Signal in ACE_Object_Manager

1 files changed, 190 insertions, 163 deletions

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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_TSS_Guard<ACE_Recursive_Thread_Mutex> 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_Event_Handler *, ACE_MAX_SIGNAL_HANDLERS>
-	ACE_SIG_HANDLERS_SET;
+        ACE_SIG_HANDLERS_SET;
 typedef ACE_Fixed_Set_Iterator <ACE_Event_Handler *, ACE_MAX_SIGNAL_HANDLERS>
-	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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_Guard<ACE_Recursive_Thread_Mutex> 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., <sigkey> == -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., <sigkey> == -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<ACE_Recursive_Thread_Mutex> m (ACE_Sig_Handler::ace_sig_handler_lock_));
+  ACE_MT (ACE_Recursive_Thread_Mutex *lock =
+    ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
+      (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
+    ACE_TSS_Guard<ACE_Recursive_Thread_Mutex> 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.