00001
00002
00003 #include "ace/Sig_Handler.h"
00004 #include "ace/Sig_Adapter.h"
00005 #include "ace/Signal.h"
00006 #include "ace/Recursive_Thread_Mutex.h"
00007 #include "ace/Managed_Object.h"
00008 #include "ace/Containers.h"
00009 #include "ace/Guard_T.h"
00010
00011 #if !defined (__ACE_INLINE__)
00012 #include "ace/Sig_Handler.inl"
00013 #endif
00014
00015 ACE_RCSID(ace, Sig_Handler, "$Id: Sig_Handler.cpp 88360 2009-12-30 08:42:20Z olli $")
00016
00017 #if defined (ACE_HAS_SIG_C_FUNC)
00018
00019 extern "C" void
00020 ace_sig_handler_dispatch (int signum, siginfo_t *info, ucontext_t *context)
00021 {
00022 ACE_TRACE ("ace_sig_handler_dispatch");
00023 ACE_Sig_Handler::dispatch (signum, info, context);
00024 }
00025
00026 #define ace_signal_handler_dispatcher ACE_SignalHandler(ace_sig_handler_dispatch)
00027
00028 extern "C" void
00029 ace_sig_handlers_dispatch (int signum, siginfo_t *info, ucontext_t *context)
00030 {
00031 ACE_TRACE ("ace_sig_handlers_dispatch");
00032 ACE_Sig_Handlers::dispatch (signum, info, context);
00033 }
00034
00035 #define ace_signal_handlers_dispatcher ACE_SignalHandler(ace_sig_handlers_dispatch)
00036
00037 #else
00038 #define ace_signal_handler_dispatcher ACE_SignalHandler(ACE_Sig_Handler::dispatch)
00039
00040 #define ace_signal_handlers_dispatcher ACE_SignalHandler(ACE_Sig_Handlers::dispatch)
00041 #endif
00042
00043
00044 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00045
00046
00047 ACE_Event_Handler *ACE_Sig_Handler::signal_handlers_[ACE_NSIG];
00048
00049
00050 sig_atomic_t ACE_Sig_Handler::sig_pending_ = 0;
00051
00052
00053 ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Handler)
00054
00055 ACE_Sig_Handler::~ACE_Sig_Handler (void)
00056 {
00057 }
00058
00059 void
00060 ACE_Sig_Handler::dump (void) const
00061 {
00062 #if defined (ACE_HAS_DUMP)
00063 ACE_TRACE ("ACE_Sig_Handler::dump");
00064 #endif
00065 }
00066
00067 int
00068 ACE_Sig_Handler::sig_pending (void)
00069 {
00070 ACE_TRACE ("ACE_Sig_Handler::sig_pending");
00071 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00072 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00073 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00074 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00075 return ACE_Sig_Handler::sig_pending_ != 0;
00076 }
00077
00078 void
00079 ACE_Sig_Handler::sig_pending (int pending)
00080 {
00081 ACE_TRACE ("ACE_Sig_Handler::sig_pending");
00082
00083 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00084 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00085 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00086 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00087 ACE_Sig_Handler::sig_pending_ = pending;
00088 }
00089
00090 ACE_Event_Handler *
00091 ACE_Sig_Handler::handler (int signum)
00092 {
00093 ACE_TRACE ("ACE_Sig_Handler::handler");
00094 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00095 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00096 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00097 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00098
00099 if (ACE_Sig_Handler::in_range (signum))
00100 return ACE_Sig_Handler::signal_handlers_[signum];
00101 else
00102 return 0;
00103 }
00104
00105 ACE_Event_Handler *
00106 ACE_Sig_Handler::handler_i (int signum,
00107 ACE_Event_Handler *new_sh)
00108 {
00109 ACE_TRACE ("ACE_Sig_Handler::handler_i");
00110
00111 if (ACE_Sig_Handler::in_range (signum))
00112 {
00113 ACE_Event_Handler *sh = ACE_Sig_Handler::signal_handlers_[signum];
00114
00115 ACE_Sig_Handler::signal_handlers_[signum] = new_sh;
00116 return sh;
00117 }
00118 else
00119 return 0;
00120 }
00121
00122 ACE_Event_Handler *
00123 ACE_Sig_Handler::handler (int signum,
00124 ACE_Event_Handler *new_sh)
00125 {
00126 ACE_TRACE ("ACE_Sig_Handler::handler");
00127 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00128 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00129 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00130 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00131
00132 return ACE_Sig_Handler::handler_i (signum, new_sh);
00133 }
00134
00135
00136
00137
00138
00139 int
00140 ACE_Sig_Handler::register_handler_i (int signum,
00141 ACE_Event_Handler *new_sh,
00142 ACE_Sig_Action *new_disp,
00143 ACE_Event_Handler **old_sh,
00144 ACE_Sig_Action *old_disp)
00145 {
00146 ACE_TRACE ("ACE_Sig_Handler::register_handler_i");
00147
00148 if (ACE_Sig_Handler::in_range (signum))
00149 {
00150 ACE_Sig_Action sa;
00151 ACE_Event_Handler *sh = ACE_Sig_Handler::handler_i (signum, new_sh);
00152
00153
00154
00155 if (old_sh != 0)
00156 *old_sh = sh;
00157
00158
00159
00160 if (new_disp == 0)
00161 new_disp = &sa;
00162
00163 new_disp->handler (ace_signal_handler_dispatcher);
00164 #if !defined (ACE_HAS_LYNXOS4_SIGNALS)
00165 new_disp->flags (new_disp->flags () | SA_SIGINFO);
00166 #endif
00167 return new_disp->register_action (signum, old_disp);
00168 }
00169 else
00170 return -1;
00171 }
00172
00173
00174
00175
00176
00177 int
00178 ACE_Sig_Handler::register_handler (int signum,
00179 ACE_Event_Handler *new_sh,
00180 ACE_Sig_Action *new_disp,
00181 ACE_Event_Handler **old_sh,
00182 ACE_Sig_Action *old_disp)
00183 {
00184 ACE_TRACE ("ACE_Sig_Handler::register_handler");
00185 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00186 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00187 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00188 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00189
00190 return ACE_Sig_Handler::register_handler_i (signum,
00191 new_sh,
00192 new_disp,
00193 old_sh,
00194 old_disp);
00195 }
00196
00197
00198
00199 int
00200 ACE_Sig_Handler::remove_handler (int signum,
00201 ACE_Sig_Action *new_disp,
00202 ACE_Sig_Action *old_disp,
00203 int)
00204 {
00205 ACE_TRACE ("ACE_Sig_Handler::remove_handler");
00206 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00207 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00208 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00209 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00210
00211 if (ACE_Sig_Handler::in_range (signum))
00212 {
00213 ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0);
00214
00215 if (new_disp == 0)
00216 new_disp = &sa;
00217
00218 ACE_Sig_Handler::signal_handlers_[signum] = 0;
00219
00220
00221 return new_disp->register_action (signum, old_disp);
00222 }
00223
00224 return -1;
00225 }
00226
00227
00228
00229
00230 void
00231 ACE_Sig_Handler::dispatch (int signum,
00232 siginfo_t *siginfo,
00233 ucontext_t *ucontext)
00234 {
00235 ACE_TRACE ("ACE_Sig_Handler::dispatch");
00236
00237
00238 ACE_Errno_Guard error (errno);
00239
00240
00241
00242 ACE_Sig_Handler::sig_pending_ = 1;
00243
00244
00245 ACE_ASSERT (ACE_Sig_Handler::in_range (signum));
00246
00247 ACE_Event_Handler *eh = ACE_Sig_Handler::signal_handlers_[signum];
00248
00249 if (eh != 0)
00250 {
00251 if (eh->handle_signal (signum, siginfo, ucontext) == -1)
00252 {
00253
00254 ACE_Sig_Action sa ((ACE_SignalHandler) SIG_DFL, (sigset_t *) 0);
00255
00256 ACE_Sig_Handler::signal_handlers_[signum] = 0;
00257
00258
00259
00260 sa.register_action (signum);
00261
00262
00263 eh->handle_close (ACE_INVALID_HANDLE,
00264 ACE_Event_Handler::SIGNAL_MASK);
00265 }
00266 #if defined (ACE_WIN32)
00267 else
00268
00269
00270
00271
00272
00273 ACE_Sig_Handler::register_handler_i (signum,
00274 eh);
00275 #endif
00276 }
00277 }
00278
00279
00280
00281
00282
00283
00284 #define ACE_MAX_SIGNAL_HANDLERS ((size_t) 20)
00285
00286
00287
00288
00289 int ACE_Sig_Handlers::sigkey_ = 0;
00290
00291
00292
00293 bool ACE_Sig_Handlers::third_party_sig_handler_ = false;
00294
00295
00296 typedef ACE_Fixed_Set <ACE_Event_Handler *, ACE_MAX_SIGNAL_HANDLERS> ACE_SIG_HANDLERS_SET;
00297 typedef ACE_Fixed_Set_Iterator <ACE_Event_Handler *, ACE_MAX_SIGNAL_HANDLERS> ACE_SIG_HANDLERS_ITERATOR;
00298
00299 class ACE_Sig_Handlers_Set
00300 {
00301 public:
00302 static ACE_SIG_HANDLERS_SET *instance (int signum);
00303
00304 private:
00305 static ACE_SIG_HANDLERS_SET *sig_handlers_[ACE_NSIG];
00306 };
00307
00308
00309 ACE_SIG_HANDLERS_SET *ACE_Sig_Handlers_Set::sig_handlers_[ACE_NSIG];
00310
00311
00312 ACE_SIG_HANDLERS_SET *
00313 ACE_Sig_Handlers_Set::instance (int signum)
00314 {
00315 if (signum <= 0 || signum >= ACE_NSIG)
00316 return 0;
00317 else if (ACE_Sig_Handlers_Set::sig_handlers_[signum] == 0)
00318 ACE_NEW_RETURN (ACE_Sig_Handlers_Set::sig_handlers_[signum],
00319 ACE_SIG_HANDLERS_SET,
00320 0);
00321 return ACE_Sig_Handlers_Set::sig_handlers_[signum];
00322 }
00323
00324 ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Handlers)
00325
00326 void
00327 ACE_Sig_Handlers::dump (void) const
00328 {
00329 #if defined (ACE_HAS_DUMP)
00330 ACE_TRACE ("ACE_Sig_Handlers::dump");
00331 #endif
00332 }
00333
00334
00335
00336
00337 int
00338 ACE_Sig_Handlers::register_handler (int signum,
00339 ACE_Event_Handler *new_sh,
00340 ACE_Sig_Action *new_disp,
00341 ACE_Event_Handler **,
00342 ACE_Sig_Action *old_disp)
00343 {
00344 ACE_TRACE ("ACE_Sig_Handlers::register_handler");
00345 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00346 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00347 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00348 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00349
00350 if (ACE_Sig_Handler::in_range (signum))
00351 {
00352 ACE_Sig_Adapter *ace_sig_adapter = 0;
00353 ACE_Sig_Adapter *extern_sh = 0;
00354 ACE_Sig_Action sa;
00355
00356
00357 sa.retrieve_action (signum);
00358
00359
00360
00361
00362 if (!(sa.handler () == ace_signal_handlers_dispatcher
00363 || sa.handler () == ACE_SignalHandler (SIG_IGN)
00364 || sa.handler () == ACE_SignalHandler (SIG_DFL)))
00365 {
00366
00367
00368
00369
00370
00371 if (ACE_BIT_DISABLED (sa.flags (), SA_RESTART)
00372 && ACE_Sig_Handlers::third_party_sig_handler_)
00373
00374
00375 return -1;
00376
00377
00378 ACE_Sig_Handlers::third_party_sig_handler_ = true;
00379
00380
00381
00382 ACE_NEW_RETURN (extern_sh,
00383 ACE_Sig_Adapter (sa,
00384 ++ACE_Sig_Handlers::sigkey_),
00385 -1);
00386
00387
00388 if (ACE_Sig_Handlers_Set::instance (signum)->insert (extern_sh) == -1)
00389 {
00390 delete extern_sh;
00391 return -1;
00392 }
00393 }
00394
00395 ACE_NEW_RETURN (ace_sig_adapter,
00396 ACE_Sig_Adapter (new_sh,
00397 ++ACE_Sig_Handlers::sigkey_),
00398 -1);
00399
00400
00401
00402
00403 int result = ACE_Sig_Handlers_Set::instance (signum)->insert (ace_sig_adapter);
00404
00405 if (result == -1)
00406 {
00407
00408
00409 if (extern_sh)
00410 {
00411 ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh);
00412 delete extern_sh;
00413 }
00414 delete ace_sig_adapter;
00415 return -1;
00416 }
00417
00418 else if (sa.handler () == ace_signal_handlers_dispatcher)
00419 return ace_sig_adapter->sigkey ();
00420
00421
00422
00423 else
00424 {
00425
00426
00427 if (new_disp == 0)
00428 new_disp = &sa;
00429
00430 new_disp->handler (ace_signal_handlers_dispatcher);
00431
00432
00433 new_disp->flags (new_disp->flags () | SA_RESTART);
00434 #if !defined (ACE_HAS_LYNXOS4_SIGNALS)
00435 new_disp->flags (new_disp->flags () | SA_SIGINFO);
00436 #endif
00437
00438
00439
00440 if (new_disp->register_action (signum, old_disp) == -1)
00441 {
00442
00443 ACE_Sig_Handlers_Set::instance (signum)->remove (ace_sig_adapter);
00444 delete ace_sig_adapter;
00445
00446 if (extern_sh)
00447 {
00448 ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh);
00449 delete extern_sh;
00450 }
00451 return -1;
00452 }
00453 else
00454
00455 return ace_sig_adapter->sigkey ();
00456 }
00457 }
00458
00459 return -1;
00460 }
00461
00462
00463
00464
00465
00466
00467 int
00468 ACE_Sig_Handlers::remove_handler (int signum,
00469 ACE_Sig_Action *new_disp,
00470 ACE_Sig_Action *old_disp,
00471 int sigkey)
00472 {
00473 ACE_TRACE ("ACE_Sig_Handlers::remove_handler");
00474 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00475 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00476 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00477 ACE_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00478
00479 if (ACE_Sig_Handler::in_range (signum))
00480 {
00481 ACE_SIG_HANDLERS_SET *handler_set =
00482 ACE_Sig_Handlers_Set::instance (signum);
00483
00484 ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set);
00485
00486
00487
00488 for (ACE_Event_Handler **eh;
00489 handler_iterator.next (eh) != 0;
00490 )
00491 {
00492
00493 ACE_Sig_Adapter *sh = (ACE_Sig_Adapter *) *eh;
00494
00495
00496
00497
00498
00499 if (sh->sigkey () == sigkey || sigkey == -1)
00500 {
00501 handler_set->remove (*eh);
00502 delete *eh;
00503 }
00504 }
00505
00506 if (handler_set->size () == 0)
00507 {
00508
00509
00510
00511
00512 ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0);
00513
00514 if (new_disp == 0)
00515 new_disp = &sa;
00516
00517 return new_disp->register_action (signum, old_disp);
00518 }
00519 return 0;
00520 }
00521 else
00522 return -1;
00523 }
00524
00525
00526
00527
00528 void
00529 ACE_Sig_Handlers::dispatch (int signum,
00530 siginfo_t *siginfo,
00531 ucontext_t *ucontext)
00532 {
00533 ACE_TRACE ("ACE_Sig_Handlers::dispatch");
00534
00535
00536 #if 0
00537 ACE_MT (ACE_Recursive_Thread_Mutex *lock =
00538 ACE_Managed_Object<ACE_Recursive_Thread_Mutex>::get_preallocated_object
00539 (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK);
00540 ACE_TSS_Guard<ACE_Recursive_Thread_Mutex> m (*lock));
00541 #endif
00542
00543
00544 ACE_Errno_Guard error (errno);
00545
00546 ACE_Sig_Handler::sig_pending_ = 1;
00547
00548
00549 ACE_ASSERT (ACE_Sig_Handler::in_range (signum));
00550
00551 ACE_SIG_HANDLERS_SET *handler_set =
00552 ACE_Sig_Handlers_Set::instance (signum);
00553
00554 ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set);
00555
00556 for (ACE_Event_Handler **eh = 0;
00557 handler_iterator.next (eh) != 0;
00558 )
00559 if ((*eh)->handle_signal (signum, siginfo, ucontext) == -1)
00560 {
00561 handler_set->remove (*eh);
00562 delete *eh;
00563 }
00564 }
00565
00566
00567
00568
00569
00570 ACE_Event_Handler *
00571 ACE_Sig_Handlers::handler (int signum)
00572 {
00573 ACE_TRACE ("ACE_Sig_Handlers::handler");
00574 ACE_SIG_HANDLERS_SET *handler_set =
00575 ACE_Sig_Handlers_Set::instance (signum);
00576 ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set);
00577 ACE_Event_Handler **eh = 0;
00578 handler_iterator.next (eh);
00579 return *eh;
00580 }
00581
00582
00583
00584
00585
00586
00587
00588 ACE_Event_Handler *
00589 ACE_Sig_Handlers::handler (int signum, ACE_Event_Handler *new_sh)
00590 {
00591 ACE_TRACE ("ACE_Sig_Handlers::handler");
00592 ACE_SIG_HANDLERS_SET *handler_set =
00593 ACE_Sig_Handlers_Set::instance (signum);
00594 ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set);
00595 ACE_Event_Handler **eh = 0;
00596
00597
00598 handler_iterator.next (eh);
00599
00600
00601 handler_set->remove (*eh);
00602
00603
00604
00605
00606 ACE_Sig_Adapter *temp = 0;
00607
00608 ACE_NEW_RETURN (temp,
00609 ACE_Sig_Adapter (new_sh,
00610 ++ACE_Sig_Handlers::sigkey_),
00611 0);
00612 handler_set->insert (temp);
00613 return *eh;
00614 }
00615
00616 ACE_END_VERSIONED_NAMESPACE_DECL