X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Ffatal-signal.c;h=4c612635b271e39704297efebb3d6b2ff10f4d69;hb=062cad2d07081f9a60adbb90fc1184a435a1a93f;hp=7654d1f4f2286ec993316bd93b5313630e32e865;hpb=640cd5a77a3e334811fe60f6bbc0ae215854b91a;p=gnulib.git diff --git a/lib/fatal-signal.c b/lib/fatal-signal.c index 7654d1f4f..4c612635b 100644 --- a/lib/fatal-signal.c +++ b/lib/fatal-signal.c @@ -1,5 +1,5 @@ /* Emergency actions in case of a fatal signal. - Copyright (C) 2003-2004, 2006-2008 Free Software Foundation, Inc. + Copyright (C) 2003-2004, 2006-2010 Free Software Foundation, Inc. Written by Bruno Haible , 2003. This program is free software: you can redistribute it and/or modify @@ -26,11 +26,11 @@ #include #include +#include "sig-handler.h" #include "xalloc.h" #define SIZEOF(a) (sizeof(a) / sizeof(a[0])) - /* ========================================================================= */ @@ -88,22 +88,16 @@ init_fatal_signals (void) static bool fatal_signals_initialized = false; if (!fatal_signals_initialized) { -#if HAVE_SIGACTION size_t i; for (i = 0; i < num_fatal_signals; i++) - { - struct sigaction action; - - if (sigaction (fatal_signals[i], NULL, &action) >= 0 - /* POSIX says that SIG_IGN can only occur when action.sa_flags - does not contain SA_SIGINFO. But in Linux 2.4, for example, - SA_SIGINFO can actually be set and is ignored when sa_handler - is SIG_IGN. So don't bother testing for SA_SIGINFO. */ - && action.sa_handler == SIG_IGN) - fatal_signals[i] = -1; - } -#endif + { + struct sigaction action; + + if (sigaction (fatal_signals[i], NULL, &action) >= 0 + && get_handler (&action) == SIG_IGN) + fatal_signals[i] = -1; + } fatal_signals_initialized = true; } @@ -131,6 +125,11 @@ static sig_atomic_t volatile actions_count = 0; static size_t actions_allocated = SIZEOF (static_actions); +/* The saved signal handlers. + Size 32 would not be sufficient: On HP-UX, SIGXCPU = 33, SIGXFSZ = 34. */ +static struct sigaction saved_sigactions[64]; + + /* Uninstall the handlers. */ static inline void uninstall_handlers () @@ -139,7 +138,12 @@ uninstall_handlers () for (i = 0; i < num_fatal_signals; i++) if (fatal_signals[i] >= 0) - signal (fatal_signals[i], SIG_DFL); + { + int sig = fatal_signals[i]; + if (saved_sigactions[sig].sa_handler == SIG_IGN) + saved_sigactions[sig].sa_handler = SIG_DFL; + sigaction (sig, &saved_sigactions[sig], NULL); + } } @@ -153,7 +157,7 @@ fatal_signal_handler (int sig) action_t action; size_t n = actions_count; if (n == 0) - break; + break; n--; actions_count = n; action = actions[n].action; @@ -162,9 +166,10 @@ fatal_signal_handler (int sig) } /* Now execute the signal's default action. - If signal() blocks the signal being delivered for the duration of the - signal handler's execution, the re-raised signal is delivered when this - handler returns; otherwise it is delivered already during raise(). */ + If the signal being delivered was blocked, the re-raised signal would be + delivered when this handler returns. But the way we install this handler, + no signal is blocked, and the re-raised signal is delivered already + during raise(). */ uninstall_handlers (); raise (sig); } @@ -175,10 +180,23 @@ static inline void install_handlers () { size_t i; - + struct sigaction action; + + action.sa_handler = &fatal_signal_handler; + /* If we get a fatal signal while executing fatal_signal_handler, enter + fatal_signal_handler recursively, since it is reentrant. Hence no + SA_RESETHAND. */ + action.sa_flags = SA_NODEFER; + sigemptyset (&action.sa_mask); for (i = 0; i < num_fatal_signals; i++) if (fatal_signals[i] >= 0) - signal (fatal_signals[i], &fatal_signal_handler); + { + int sig = fatal_signals[i]; + + if (!(sig < sizeof (saved_sigactions) / sizeof (saved_sigactions[0]))) + abort (); + sigaction (sig, &action, &saved_sigactions[sig]); + } } @@ -198,25 +216,25 @@ at_fatal_signal (action_t action) if (actions_count == actions_allocated) { /* Extend the actions array. Note that we cannot use xrealloc(), - because then the cleanup() function could access an already - deallocated array. */ + because then the cleanup() function could access an already + deallocated array. */ actions_entry_t *old_actions = actions; size_t old_actions_allocated = actions_allocated; size_t new_actions_allocated = 2 * actions_allocated; actions_entry_t *new_actions = - XNMALLOC (new_actions_allocated, actions_entry_t); + XNMALLOC (new_actions_allocated, actions_entry_t); size_t k; /* Don't use memcpy() here, because memcpy takes non-volatile arguments - and is therefore not guaranteed to complete all memory stores before - the next statement. */ + and is therefore not guaranteed to complete all memory stores before + the next statement. */ for (k = 0; k < old_actions_allocated; k++) - new_actions[k] = old_actions[k]; + new_actions[k] = old_actions[k]; actions = new_actions; actions_allocated = new_actions_allocated; /* Now we can free the old actions array. */ if (old_actions != static_actions) - free (old_actions); + free (old_actions); } /* The two uses of 'volatile' in the types above (and ISO C 99 section 5.1.2.3.(5)) ensure that we increment the actions_count only after @@ -244,8 +262,8 @@ init_fatal_signal_set () sigemptyset (&fatal_signal_set); for (i = 0; i < num_fatal_signals; i++) - if (fatal_signals[i] >= 0) - sigaddset (&fatal_signal_set, fatal_signals[i]); + if (fatal_signals[i] >= 0) + sigaddset (&fatal_signal_set, fatal_signals[i]); fatal_signal_set_initialized = true; }