/* Emergency actions in case of a fatal signal.
- Copyright (C) 2003-2004, 2006 Free Software Foundation, Inc.
+ Copyright (C) 2003-2004, 2006-2014 Free Software Foundation, Inc.
Written by Bruno Haible <bruno@clisp.org>, 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
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 <http://www.gnu.org/licenses/>. */
#include <config.h>
#include <signal.h>
#include <unistd.h>
-#include "sigprocmask.h"
+#include "sig-handler.h"
#include "xalloc.h"
#define SIZEOF(a) (sizeof(a) / sizeof(a[0]))
-
/* ========================================================================= */
#ifdef SIGXFSZ
SIGXFSZ,
#endif
- /* Woe32 signals. */
+ /* Native Windows signals. */
#ifdef SIGBREAK
SIGBREAK,
#endif
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;
}
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 ()
+static void
+uninstall_handlers (void)
{
size_t i;
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);
+ }
}
action_t action;
size_t n = actions_count;
if (n == 0)
- break;
+ break;
n--;
actions_count = n;
action = actions[n].action;
}
/* 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
}
/* Install the handlers. */
-static inline void
-install_handlers ()
+static void
+install_handlers (void)
{
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]);
+ }
}
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 =
- (actions_entry_t *)
- 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
static sigset_t fatal_signal_set;
static void
-init_fatal_signal_set ()
+init_fatal_signal_set (void)
{
static bool fatal_signal_set_initialized = false;
if (!fatal_signal_set_initialized)
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;
}
/* Temporarily delay the catchable fatal signals. */
void
-block_fatal_signals ()
+block_fatal_signals (void)
{
init_fatal_signal_set ();
sigprocmask (SIG_BLOCK, &fatal_signal_set, NULL);
/* Stop delaying the catchable fatal signals. */
void
-unblock_fatal_signals ()
+unblock_fatal_signals (void)
{
init_fatal_signal_set ();
sigprocmask (SIG_UNBLOCK, &fatal_signal_set, NULL);
projects / gnulib.git / blobdiff