X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Ffatal-signal.c;h=aca9027e9a891883f74ea35a89ba7a9f51b0fc6a;hb=46380c372f75d7a8609c6646e48099a9b84f7ec2;hp=f85b60f41865a96c00c89a4dcdc4f85731c3ad1b;hpb=fa9f85a436cb8239695046be4feb68211fe71af1;p=gnulib.git diff --git a/lib/fatal-signal.c b/lib/fatal-signal.c index f85b60f41..aca9027e9 100644 --- a/lib/fatal-signal.c +++ b/lib/fatal-signal.c @@ -1,11 +1,11 @@ /* Emergency actions in case of a fatal signal. - Copyright (C) 2003-2004, 2006 Free Software Foundation, Inc. + Copyright (C) 2003-2004, 2006-2011 Free Software Foundation, Inc. Written by Bruno Haible , 2003. - This program is free software; you can redistribute it and/or modify + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -13,8 +13,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software Foundation, - Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include @@ -27,12 +26,11 @@ #include #include -#include "sigprocmask.h" +#include "sig-handler.h" #include "xalloc.h" #define SIZEOF(a) (sizeof(a) / sizeof(a[0])) - /* ========================================================================= */ @@ -90,18 +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; + { + struct sigaction action; - if (sigaction (fatal_signals[i], NULL, &action) >= 0 - && action.sa_handler == SIG_IGN) - fatal_signals[i] = -1; - } -#endif + if (sigaction (fatal_signals[i], NULL, &action) >= 0 + && get_handler (&action) == SIG_IGN) + fatal_signals[i] = -1; + } fatal_signals_initialized = true; } @@ -129,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 () @@ -137,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); + } } @@ -151,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; @@ -160,15 +166,12 @@ 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 (); -#if HAVE_RAISE raise (sig); -#else - kill (getpid (), sig); -#endif } @@ -177,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]); + } } @@ -200,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 = - xmalloc (new_actions_allocated * sizeof (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 @@ -246,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; }