diff options
Diffstat (limited to 'libsigsegv/src/handler-unix.c')
| -rw-r--r-- | libsigsegv/src/handler-unix.c | 542 |
1 files changed, 542 insertions, 0 deletions
diff --git a/libsigsegv/src/handler-unix.c b/libsigsegv/src/handler-unix.c new file mode 100644 index 00000000..3718eb98 --- /dev/null +++ b/libsigsegv/src/handler-unix.c @@ -0,0 +1,542 @@ +/* Fault handler information. Unix version. + Copyright (C) 1993-1999, 2002-2003, 2006, 2008 Bruno Haible <bruno@clisp.org> + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + 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. */ + +#include "sigsegv.h" + +/* On the average Unix platform, we define + + HAVE_SIGSEGV_RECOVERY + if there is a fault-*.h include file which defines + SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS. + + HAVE_STACK_OVERFLOW_RECOVERY + if HAVE_SIGALTSTACK is set and + at least two of the following are true: + A) There is a fault-*.h include file which defines + SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_ADDRESS. + B) There is a fault-*.h include file which defines + SIGSEGV_FAULT_HANDLER_ARGLIST and SIGSEGV_FAULT_STACKPOINTER. + C) There is a stackvma-*.c, other than stackvma-none.c, which + defines sigsegv_get_vma. + + Why? Obviously, to catch stack overflow, we need an alternate signal + stack; this requires kernel support. But we also need to distinguish + (with a reasonable confidence) a stack overflow from a regular SIGSEGV. + If we have A) and B), we use the + Heuristic AB: If the fault address is near the stack pointer, it's a + stack overflow. + If we have A) and C), we use the + Heuristic AC: If the fault address is near and beyond the bottom of + the stack's virtual memory area, it's a stack overflow. + If we have B) and C), we use the + Heuristic BC: If the stack pointer is near the bottom of the stack's + virtual memory area, it's a stack overflow. + This heuristic comes in two flavours: On OSes which let the stack's + VMA grow continuously, we determine the bottom by use of getrlimit(). + On OSes which preallocate the stack's VMA with its maximum size + (like BeOS), we use the stack's VMA directly. + */ + +#include <stddef.h> /* needed for NULL on SunOS4 */ +#include <stdlib.h> +#include <signal.h> +#if HAVE_SYS_SIGNAL_H +# include <sys/signal.h> +#endif +#include <errno.h> + +/* For MacOSX. */ +#ifndef SS_DISABLE +#define SS_DISABLE SA_DISABLE +#endif + +#include "fault.h" +#include CFG_SIGNALS + +#if HAVE_STACK_OVERFLOW_RECOVERY + +#include <stdio.h> /* perror */ + +#if HAVE_GETRLIMIT +# include <sys/types.h> +# include <sys/time.h> +# include <sys/resource.h> /* declares struct rlimit */ +#endif + +/* Platform dependent: + Determine the virtual memory area of a given address. */ +#include "stackvma.h" + +/* Platform dependent: + Leaving a signal handler executing on the alternate stack. */ +#include "leave.h" + +#if HAVE_STACKVMA + +/* Address of the last byte belonging to the stack vma. */ +static unsigned long stack_top = 0; + +/* Needs to be called once only. */ +static void +remember_stack_top (void *some_variable_on_stack) +{ + struct vma_struct vma; + + if (sigsegv_get_vma ((unsigned long) some_variable_on_stack, &vma) >= 0) + stack_top = vma.end - 1; +} + +#endif /* HAVE_STACKVMA */ + +static stackoverflow_handler_t stk_user_handler = (stackoverflow_handler_t)NULL; +static unsigned long stk_extra_stack; +static unsigned long stk_extra_stack_size; + +#endif /* HAVE_STACK_OVERFLOW_RECOVERY */ + +#if HAVE_SIGSEGV_RECOVERY + +/* User's SIGSEGV handler. */ +static sigsegv_handler_t user_handler = (sigsegv_handler_t)NULL; + +#endif /* HAVE_SIGSEGV_RECOVERY */ + + +/* Our SIGSEGV handler, with OS dependent argument list. */ + +#if HAVE_SIGSEGV_RECOVERY + +static void +sigsegv_handler (SIGSEGV_FAULT_HANDLER_ARGLIST) +{ + void *address = (void *) (SIGSEGV_FAULT_ADDRESS); + +#if HAVE_STACK_OVERFLOW_RECOVERY +#if !(HAVE_STACKVMA || defined SIGSEGV_FAULT_STACKPOINTER) +#error "Insufficient heuristics for detecting a stack overflow. Either define CFG_STACKVMA and HAVE_STACKVMA correctly, or define SIGSEGV_FAULT_STACKPOINTER correctly, or undefine HAVE_STACK_OVERFLOW_RECOVERY!" +#endif + + /* Call user's handler. */ + if (user_handler && (*user_handler) (address, 0)) + { + /* Handler successful. */ + } + else + { + /* Handler declined responsibility. */ + + /* Did the user install a stack overflow handler? */ + if (stk_user_handler) + { + /* See whether it was a stack overflow. If so, longjump away. */ +#ifdef SIGSEGV_FAULT_STACKPOINTER + unsigned long old_sp = (unsigned long) (SIGSEGV_FAULT_STACKPOINTER); +#ifdef __ia64 + unsigned long old_bsp = (unsigned long) (SIGSEGV_FAULT_BSP_POINTER); +#endif +#endif + +#if HAVE_STACKVMA + /* Were we able to determine the stack top? */ + if (stack_top) + { + /* Determine stack bounds. */ + int saved_errno; + struct vma_struct vma; + int ret; + + saved_errno = errno; + ret = sigsegv_get_vma (stack_top, &vma); + errno = saved_errno; + if (ret >= 0) + { + /* Heuristic AC: If the fault_address is nearer to the stack + segment's [start,end] than to the previous segment, we + consider it a stack overflow. + In the case of IA-64, we know that the previous segment + is the up-growing bsp segment, and either of the two + stacks can overflow. */ + unsigned long addr = (unsigned long) address; + +#ifdef __ia64 + if (addr >= vma.prev_end && addr <= vma.end - 1) +#else +#if STACK_DIRECTION < 0 + if (addr >= vma.start + ? (addr <= vma.end - 1) + : vma.is_near_this (addr, &vma)) +#else + if (addr <= vma.end - 1 + ? (addr >= vma.start) + : vma.is_near_this (addr, &vma)) +#endif +#endif +#else + /* Heuristic AB: If the fault address is near the stack pointer, + it's a stack overflow. */ + unsigned long addr = (unsigned long) address; + + if ((addr <= old_sp + 4096 && old_sp <= addr + 4096) +#ifdef __ia64 + || (addr <= old_bsp + 4096 && old_bsp <= addr + 4096) +#endif + ) + { + { +#endif + { +#ifdef SIGSEGV_FAULT_STACKPOINTER + int emergency = + (old_sp >= stk_extra_stack + && old_sp <= stk_extra_stack + stk_extra_stack_size); + stackoverflow_context_t context = (SIGSEGV_FAULT_CONTEXT); +#else + int emergency = 0; + stackoverflow_context_t context = (void *) 0; +#endif + /* Call user's handler. */ + (*stk_user_handler) (emergency, context); + } + } + } + } +#endif /* HAVE_STACK_OVERFLOW_RECOVERY */ + + if (user_handler && (*user_handler) (address, 1)) + { + /* Handler successful. */ + } + else + { + /* Handler declined responsibility for real. */ + + /* Remove ourselves and dump core. */ + SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);) + } + +#if HAVE_STACK_OVERFLOW_RECOVERY + } +#endif /* HAVE_STACK_OVERFLOW_RECOVERY */ +} + +#elif HAVE_STACK_OVERFLOW_RECOVERY + +static void +#ifdef SIGSEGV_FAULT_STACKPOINTER +sigsegv_handler (SIGSEGV_FAULT_HANDLER_ARGLIST) +#else +sigsegv_handler (int sig) +#endif +{ +#if !((HAVE_GETRLIMIT && defined RLIMIT_STACK) || defined SIGSEGV_FAULT_STACKPOINTER) +#error "Insufficient heuristics for detecting a stack overflow. Either define SIGSEGV_FAULT_STACKPOINTER correctly, or undefine HAVE_STACK_OVERFLOW_RECOVERY!" +#endif + + /* Did the user install a handler? */ + if (stk_user_handler) + { + /* See whether it was a stack overflow. If so, longjump away. */ +#ifdef SIGSEGV_FAULT_STACKPOINTER + unsigned long old_sp = (unsigned long) (SIGSEGV_FAULT_STACKPOINTER); +#endif + + /* Were we able to determine the stack top? */ + if (stack_top) + { + /* Determine stack bounds. */ + int saved_errno; + struct vma_struct vma; + + saved_errno = errno; + if (sigsegv_get_vma (stack_top, &vma) >= 0) + { +#if HAVE_GETRLIMIT && defined RLIMIT_STACK + /* Heuristic BC: If the stack size has reached its maximal size, + and old_sp is near the low end, we consider it a stack + overflow. */ + struct rlimit rl; + + if (getrlimit (RLIMIT_STACK, &rl) >= 0) + { + unsigned long current_stack_size = vma.end - vma.start; + unsigned long max_stack_size = rl.rlim_cur; + if (current_stack_size <= max_stack_size + 4096 + && max_stack_size <= current_stack_size + 4096 +#else + { + if (1 +#endif +#ifdef SIGSEGV_FAULT_STACKPOINTER + /* Heuristic BC: If we know old_sp, and it is neither + near the low end, nor in the alternate stack, then + it's probably not a stack overflow. */ + && ((old_sp >= stk_extra_stack + && old_sp <= stk_extra_stack + stk_extra_stack_size) +#if STACK_DIRECTION < 0 + || (old_sp <= vma.start + 4096 + && vma.start <= old_sp + 4096)) +#else + || (old_sp <= vma.end + 4096 + && vma.end <= old_sp + 4096)) +#endif +#endif + ) + { +#ifdef SIGSEGV_FAULT_STACKPOINTER + int emergency = + (old_sp >= stk_extra_stack + && old_sp <= stk_extra_stack + stk_extra_stack_size); + stackoverflow_context_t context = (SIGSEGV_FAULT_CONTEXT); +#else + int emergency = 0; + stackoverflow_context_t context = (void *) 0; +#endif + /* Call user's handler. */ + (*stk_user_handler)(emergency,context); + } + } + } + errno = saved_errno; + } + } + + /* Remove ourselves and dump core. */ + SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);) +} + +#endif + + +static void +install_for (int sig) +{ + struct sigaction action; + +#ifdef SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO + action.sa_sigaction = &sigsegv_handler; +#else + action.sa_handler = (void (*) (int)) &sigsegv_handler; +#endif + /* Block most signals while SIGSEGV is being handled. */ + /* Signals SIGKILL, SIGSTOP cannot be blocked. */ + /* Signals SIGCONT, SIGTSTP, SIGTTIN, SIGTTOU are not blocked because + dealing with these signals seems dangerous. */ + /* Signals SIGILL, SIGABRT, SIGFPE, SIGSEGV, SIGTRAP, SIGIOT, SIGEMT, SIGBUS, + SIGSYS, SIGSTKFLT are not blocked because these are synchronous signals, + which may require immediate intervention, otherwise the process may + starve. */ + sigemptyset (&action.sa_mask); +#ifdef SIGHUP + sigaddset (&action.sa_mask,SIGHUP); +#endif +#ifdef SIGINT + sigaddset (&action.sa_mask,SIGINT); +#endif +#ifdef SIGQUIT + sigaddset (&action.sa_mask,SIGQUIT); +#endif +#ifdef SIGPIPE + sigaddset (&action.sa_mask,SIGPIPE); +#endif +#ifdef SIGALRM + sigaddset (&action.sa_mask,SIGALRM); +#endif +#ifdef SIGTERM + sigaddset (&action.sa_mask,SIGTERM); +#endif +#ifdef SIGUSR1 + sigaddset (&action.sa_mask,SIGUSR1); +#endif +#ifdef SIGUSR2 + sigaddset (&action.sa_mask,SIGUSR2); +#endif +#ifdef SIGCHLD + sigaddset (&action.sa_mask,SIGCHLD); +#endif +#ifdef SIGCLD + sigaddset (&action.sa_mask,SIGCLD); +#endif +#ifdef SIGURG + sigaddset (&action.sa_mask,SIGURG); +#endif +#ifdef SIGIO + sigaddset (&action.sa_mask,SIGIO); +#endif +#ifdef SIGPOLL + sigaddset (&action.sa_mask,SIGPOLL); +#endif +#ifdef SIGXCPU + sigaddset (&action.sa_mask,SIGXCPU); +#endif +#ifdef SIGXFSZ + sigaddset (&action.sa_mask,SIGXFSZ); +#endif +#ifdef SIGVTALRM + sigaddset (&action.sa_mask,SIGVTALRM); +#endif +#ifdef SIGPROF + sigaddset (&action.sa_mask,SIGPROF); +#endif +#ifdef SIGPWR + sigaddset (&action.sa_mask,SIGPWR); +#endif +#ifdef SIGLOST + sigaddset (&action.sa_mask,SIGLOST); +#endif +#ifdef SIGWINCH + sigaddset (&action.sa_mask,SIGWINCH); +#endif + /* Note that sigaction() implicitly adds sig itself to action.sa_mask. */ + /* Ask the OS to provide a structure siginfo_t to the handler. */ +#ifdef SIGSEGV_FAULT_ADDRESS_FROM_SIGINFO + action.sa_flags = SA_SIGINFO; +#else + action.sa_flags = 0; +#endif +#if HAVE_STACK_OVERFLOW_RECOVERY && HAVE_SIGALTSTACK /* not BeOS */ + /* Work around Linux 2.2.5 bug: If SA_ONSTACK is specified but sigaltstack() + has not been called, the kernel will busy loop, eating CPU time. So + avoid setting SA_ONSTACK until the user has requested stack overflow + handling. */ + if (stk_user_handler) + action.sa_flags |= SA_ONSTACK; +#endif + sigaction (sig, &action, (struct sigaction *) NULL); +} + +int +sigsegv_install_handler (sigsegv_handler_t handler) +{ +#if HAVE_SIGSEGV_RECOVERY + user_handler = handler; + + SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);) + + return 0; +#else + return -1; +#endif +} + +void +sigsegv_deinstall_handler (void) +{ +#if HAVE_SIGSEGV_RECOVERY + user_handler = (sigsegv_handler_t)NULL; + +#if HAVE_STACK_OVERFLOW_RECOVERY + if (!stk_user_handler) +#endif + { + SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);) + } +#endif +} + +int +sigsegv_leave_handler (void (*continuation) (void*, void*, void*), + void* cont_arg1, void* cont_arg2, void* cont_arg3) +{ +#if HAVE_STACK_OVERFLOW_RECOVERY + /* + * Reset the system's knowledge that we are executing on the alternate + * stack. If we didn't do that, siglongjmp would be needed instead of + * longjmp to leave the signal handler. + */ + sigsegv_reset_onstack_flag (); +#endif + (*continuation) (cont_arg1, cont_arg2, cont_arg3); + return 1; +} + +int +stackoverflow_install_handler (stackoverflow_handler_t handler, + void *extra_stack, unsigned long extra_stack_size) +{ +#if HAVE_STACK_OVERFLOW_RECOVERY +#if HAVE_STACKVMA + if (!stack_top) + { + int dummy; + remember_stack_top (&dummy); + if (!stack_top) + return -1; + } +#endif + + stk_user_handler = handler; + stk_extra_stack = (unsigned long) extra_stack; + stk_extra_stack_size = extra_stack_size; +#ifdef __BEOS__ + set_signal_stack (extra_stack, extra_stack_size); +#else /* HAVE_SIGALTSTACK */ + { + stack_t ss; +#if SIGALTSTACK_SS_REVERSED + ss.ss_sp = (char *) extra_stack + extra_stack_size - sizeof (void *); + ss.ss_size = extra_stack_size - sizeof (void *); +#else + ss.ss_sp = extra_stack; + ss.ss_size = extra_stack_size; +#endif + ss.ss_flags = 0; /* no SS_DISABLE */ + if (sigaltstack (&ss, (stack_t*)0) < 0) + return -1; + } +#endif + + /* Install the signal handlers with SA_ONSTACK. */ + SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);) + return 0; +#else + return -1; +#endif +} + +void +stackoverflow_deinstall_handler (void) +{ +#if HAVE_STACK_OVERFLOW_RECOVERY + stk_user_handler = (stackoverflow_handler_t) NULL; + +#if HAVE_SIGSEGV_RECOVERY + if (user_handler) + { + /* Reinstall the signal handlers without SA_ONSTACK, to avoid Linux + bug. */ + SIGSEGV_FOR_ALL_SIGNALS (sig, install_for (sig);) + } + else +#endif + { + SIGSEGV_FOR_ALL_SIGNALS (sig, signal (sig, SIG_DFL);) + } + +#ifdef __BEOS__ + /* We cannot undo the effect of set_signal_stack. */ + fprintf (stderr, "libsigsegv (stackoverflow_deinstall_handler): not supported on this platform\n"); +#else /* HAVE_SIGALTSTACK */ + { + stack_t ss; + ss.ss_flags = SS_DISABLE; + if (sigaltstack (&ss, (stack_t *) 0) < 0) + perror ("libsigsegv (stackoverflow_deinstall_handler)"); + } +#endif + +#endif +} |