1 /* Emergency actions in case of a fatal signal.
2 Copyright (C) 2003-2004, 2006 Free Software Foundation, Inc.
3 Written by Bruno Haible <bruno@clisp.org>, 2003.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software Foundation,
17 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
23 #include "fatal-signal.h"
32 #define SIZEOF(a) (sizeof(a) / sizeof(a[0]))
35 /* ========================================================================= */
38 /* The list of fatal signals.
39 These are those signals whose default action is to terminate the process
40 without a core dump, except
41 SIGKILL - because it cannot be caught,
42 SIGALRM SIGUSR1 SIGUSR2 SIGPOLL SIGIO SIGLOST - because applications
43 often use them for their own purpose,
44 SIGPROF SIGVTALRM - because they are used for profiling,
45 SIGSTKFLT - because it is more similar to SIGFPE, SIGSEGV, SIGBUS,
46 SIGSYS - because it is more similar to SIGABRT, SIGSEGV,
47 SIGPWR - because it of too special use,
48 SIGRTMIN...SIGRTMAX - because they are reserved for application use.
50 SIGXCPU, SIGXFSZ - because they are quite similar to SIGTERM. */
52 static int fatal_signals[] =
54 /* ISO C 99 signals. */
61 /* POSIX:2001 signals. */
78 #define num_fatal_signals (SIZEOF (fatal_signals) - 1)
80 /* Eliminate signals whose signal handler is SIG_IGN. */
83 init_fatal_signals (void)
85 static bool fatal_signals_initialized = false;
86 if (!fatal_signals_initialized)
91 for (i = 0; i < num_fatal_signals; i++)
93 struct sigaction action;
95 if (sigaction (fatal_signals[i], NULL, &action) >= 0
96 && action.sa_handler == SIG_IGN)
97 fatal_signals[i] = -1;
101 fatal_signals_initialized = true;
106 /* ========================================================================= */
109 typedef void (*action_t) (void);
111 /* Type of an entry in the actions array.
112 The 'action' field is accessed from within the fatal_signal_handler(),
113 therefore we mark it as 'volatile'. */
116 volatile action_t action;
120 /* The registered cleanup actions. */
121 static actions_entry_t static_actions[32];
122 static actions_entry_t * volatile actions = static_actions;
123 static sig_atomic_t volatile actions_count = 0;
124 static size_t actions_allocated = SIZEOF (static_actions);
127 /* Uninstall the handlers. */
129 uninstall_handlers ()
133 for (i = 0; i < num_fatal_signals; i++)
134 if (fatal_signals[i] >= 0)
135 signal (fatal_signals[i], SIG_DFL);
139 /* The signal handler. It gets called asynchronously. */
141 fatal_signal_handler (int sig)
145 /* Get the last registered cleanup action, in a reentrant way. */
147 size_t n = actions_count;
152 action = actions[n].action;
153 /* Execute the action. */
157 /* Now execute the signal's default action.
158 If signal() blocks the signal being delivered for the duration of the
159 signal handler's execution, the re-raised signal is delivered when this
160 handler returns; otherwise it is delivered already during raise(). */
161 uninstall_handlers ();
165 kill (getpid (), sig);
170 /* Install the handlers. */
176 for (i = 0; i < num_fatal_signals; i++)
177 if (fatal_signals[i] >= 0)
178 signal (fatal_signals[i], &fatal_signal_handler);
182 /* Register a cleanup function to be executed when a catchable fatal signal
185 at_fatal_signal (action_t action)
187 static bool cleanup_initialized = false;
188 if (!cleanup_initialized)
190 init_fatal_signals ();
192 cleanup_initialized = true;
195 if (actions_count == actions_allocated)
197 /* Extend the actions array. Note that we cannot use xrealloc(),
198 because then the cleanup() function could access an already
199 deallocated array. */
200 actions_entry_t *old_actions = actions;
201 size_t old_actions_allocated = actions_allocated;
202 size_t new_actions_allocated = 2 * actions_allocated;
203 actions_entry_t *new_actions =
204 xmalloc (new_actions_allocated * sizeof (actions_entry_t));
207 /* Don't use memcpy() here, because memcpy takes non-volatile arguments
208 and is therefore not guaranteed to complete all memory stores before
209 the next statement. */
210 for (k = 0; k < old_actions_allocated; k++)
211 new_actions[k] = old_actions[k];
212 actions = new_actions;
213 actions_allocated = new_actions_allocated;
214 /* Now we can free the old actions array. */
215 if (old_actions != static_actions)
218 /* The two uses of 'volatile' in the types above (and ISO C 99 section
219 5.1.2.3.(5)) ensure that we increment the actions_count only after
220 the new action has been written to the memory location
221 actions[actions_count]. */
222 actions[actions_count].action = action;
227 /* ========================================================================= */
230 #if HAVE_POSIX_SIGNALBLOCKING
232 static sigset_t fatal_signal_set;
235 init_fatal_signal_set ()
237 static bool fatal_signal_set_initialized = false;
238 if (!fatal_signal_set_initialized)
242 init_fatal_signals ();
244 sigemptyset (&fatal_signal_set);
245 for (i = 0; i < num_fatal_signals; i++)
246 if (fatal_signals[i] >= 0)
247 sigaddset (&fatal_signal_set, fatal_signals[i]);
249 fatal_signal_set_initialized = true;
253 /* Temporarily delay the catchable fatal signals. */
255 block_fatal_signals ()
257 init_fatal_signal_set ();
258 sigprocmask (SIG_BLOCK, &fatal_signal_set, NULL);
261 /* Stop delaying the catchable fatal signals. */
263 unblock_fatal_signals ()
265 init_fatal_signal_set ();
266 sigprocmask (SIG_UNBLOCK, &fatal_signal_set, NULL);
271 /* Don't bother caring about the old systems which don't have POSIX signal
275 block_fatal_signals ()
280 unblock_fatal_signals ()