X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FSignals.c;h=67fbf42ab46dff1d1015f5b1233b764cac0d6c34;hb=153b9cb9b11e05c4edb1b6bc0a7b972660e41f70;hp=8e33d9dc88f01c5074733a530ec2a37f98f134a4;hpb=e65d8f387cccbcfd60a4a820024f8d8286f97ac2;p=ghc-hetmet.git diff --git a/ghc/rts/Signals.c b/ghc/rts/Signals.c index 8e33d9d..67fbf42 100644 --- a/ghc/rts/Signals.c +++ b/ghc/rts/Signals.c @@ -1,5 +1,4 @@ /* ----------------------------------------------------------------------------- - * $Id: Signals.c,v 1.32 2003/01/10 22:08:20 wolfgang Exp $ * * (c) The GHC Team, 1998-1999 * @@ -16,10 +15,13 @@ #include "Signals.h" #include "RtsUtils.h" #include "RtsFlags.h" -#include "StablePriv.h" -#ifdef alpha_TARGET_ARCH -# include +#ifdef alpha_HOST_ARCH +# if defined(linux_HOST_OS) +# include +# else +# include +# endif #endif #ifdef HAVE_UNISTD_H @@ -32,9 +34,14 @@ #include -#ifndef mingw32_TARGET_OS +/* This curious flag is provided for the benefit of the Haskell binding + * to POSIX.1 to control whether or not to include SA_NOCLDSTOP when + * installing a SIGCHLD handler. + * + */ +StgInt nocldstop = 0; -#ifndef PAR +#if defined(RTS_USER_SIGNALS) /* SUP: The type of handlers is a little bit, well, doubtful... */ static StgInt *handlers = NULL; /* Dynamically grown array of signal handlers */ @@ -47,7 +54,24 @@ static nat n_haskell_handlers = 0; StgPtr pending_handler_buf[N_PENDING_HANDLERS]; StgPtr *next_pending_handler = pending_handler_buf; -StgInt nocldstop = 0; +/* ----------------------------------------------------------------------------- + * Signal handling + * -------------------------------------------------------------------------- */ + +#ifdef RTS_SUPPORTS_THREADS +pthread_t signalHandlingThread; +#endif + +// Handle all signals in the current thread. +// Called from Capability.c whenever the main capability is granted to a thread +// and in installDefaultHandlers +void +handleSignalsInThisThread(void) +{ +#ifdef RTS_SUPPORTS_THREADS + signalHandlingThread = pthread_self(); +#endif +} /* ----------------------------------------------------------------------------- * Allocate/resize the table of signal handlers. @@ -62,14 +86,10 @@ more_handlers(I_ sig) return; if (handlers == NULL) - handlers = (StgInt *) malloc((sig + 1) * sizeof(StgInt)); + handlers = (StgInt *)stgMallocBytes((sig + 1) * sizeof(StgInt), "more_handlers"); else - handlers = (StgInt *) realloc(handlers, (sig + 1) * sizeof(StgInt)); + handlers = (StgInt *)stgReallocBytes(handlers, (sig + 1) * sizeof(StgInt), "more_handlers"); - if (handlers == NULL) { - // don't fflush(stdout); WORKAROUND bug in Linux glibc - barf("VM exhausted (in more_handlers)"); - } for(i = nHandlers; i <= sig; i++) // Fill in the new slots with default actions handlers[i] = STG_SIG_DFL; @@ -105,6 +125,19 @@ generic_handler(int sig) { sigset_t signals; +#if defined(THREADED_RTS) + // Make the thread that currently holds the main capability + // handle the signal. + // This makes sure that awaitEvent() is interrupted + // and it (hopefully) prevents race conditions + // (signal handlers are not atomic with respect to other threads) + + if(pthread_self() != signalHandlingThread) { + pthread_kill(signalHandlingThread, sig); + return; + } +#endif + /* Can't call allocate from here. Probably can't call malloc either. However, we have to schedule a new thread somehow. @@ -137,7 +170,7 @@ generic_handler(int sig) // stack full? if (next_pending_handler == &pending_handler_buf[N_PENDING_HANDLERS]) { - prog_belch("too many pending signals"); + errorBelch("too many pending signals"); stg_exit(EXIT_FAILURE); } @@ -215,6 +248,8 @@ stg_sig_install(int sig, int spi, StgStablePtr *handler, void *mask) previous_spi = handlers[sig]; + action.sa_flags = 0; + switch(spi) { case STG_SIG_IGN: handlers[sig] = STG_SIG_IGN; @@ -261,7 +296,7 @@ stg_sig_install(int sig, int spi, StgStablePtr *handler, void *mask) } return STG_SIG_ERR; } - + if (previous_spi == STG_SIG_DFL || previous_spi == STG_SIG_IGN || previous_spi == STG_SIG_ERR) { return previous_spi; @@ -312,20 +347,20 @@ markSignalHandlers (evac_fn evac) } } -#else // PAR +#else /* !RTS_USER_SIGNALS */ StgInt -stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) +stg_sig_install(StgInt sig STG_UNUSED, + StgInt spi STG_UNUSED, + StgStablePtr* handler STG_UNUSED, + void* mask STG_UNUSED) { - // don't fflush(stdout); WORKAROUND bug in Linux glibc - barf("no signal handling support in a parallel implementation"); + //barf("User signals not supported"); + return STG_SIG_DFL; } -void -startSignalHandlers(void) -{ -} #endif +#if defined(RTS_USER_SIGNALS) /* ----------------------------------------------------------------------------- * SIGINT handler. * @@ -348,13 +383,24 @@ shutdown_handler(int sig STG_UNUSED) pthread_kill(startup_guy, sig); return; } + // ToDo: The code for the threaded RTS below does something very + // similar. Maybe the SMP special case is not needed + // -- Wolfgang Thaller +#elif defined(THREADED_RTS) + // Make the thread that currently holds the main capability + // handle the signal. + // This makes sure that awaitEvent() is interrupted + if(pthread_self() != signalHandlingThread) { + pthread_kill(signalHandlingThread, sig); + return; + } #endif // If we're already trying to interrupt the RTS, terminate with // extreme prejudice. So the first ^C tries to exit the program // cleanly, and the second one just kills it. if (interrupted) { - exit(EXIT_INTERRUPTED); + stg_exit(EXIT_INTERRUPTED); } else { interruptStgRts(); } @@ -383,16 +429,19 @@ initDefaultHandlers() #ifdef SMP startup_guy = pthread_self(); #endif +#ifdef RTS_SUPPORTS_THREADS + handleSignalsInThisThread(); +#endif // install the SIGINT handler action.sa_handler = shutdown_handler; sigemptyset(&action.sa_mask); action.sa_flags = 0; if (sigaction(SIGINT, &action, &oact) != 0) { - prog_belch("warning: failed to install SIGINT handler"); + errorBelch("warning: failed to install SIGINT handler"); } -#ifndef cygwin32_TARGET_OS +#if defined(HAVE_SIGINTERRUPT) siginterrupt(SIGINT, 1); // isn't this the default? --SDM #endif @@ -401,7 +450,7 @@ initDefaultHandlers() sigemptyset(&action.sa_mask); action.sa_flags = 0; if (sigaction(SIGCONT, &action, &oact) != 0) { - prog_belch("warning: failed to install SIGCONT handler"); + errorBelch("warning: failed to install SIGCONT handler"); } // install the SIGFPE handler @@ -419,13 +468,13 @@ initDefaultHandlers() sigemptyset(&action.sa_mask); action.sa_flags = 0; if (sigaction(SIGFPE, &action, &oact) != 0) { - prog_belch("warning: failed to install SIGFPE handler"); + errorBelch("warning: failed to install SIGFPE handler"); } #endif -#ifdef alpha_TARGET_ARCH +#ifdef alpha_HOST_ARCH ieee_set_fp_control(0); #endif } -#endif /*! mingw32_TARGET_OS */ +#endif /* RTS_USER_SIGNALS */