X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FSignals.c;h=425d90a77a7a787c003b51e6e26b859999fa9b30;hb=55472d778c441b65e013d27f5228283eef85986c;hp=355cf147cc2b99cb246370630bcabd3a524e8283;hpb=4be00ac12eb12a88abadce5d38a17d53fc9339a9;p=ghc-hetmet.git diff --git a/ghc/rts/Signals.c b/ghc/rts/Signals.c index 355cf14..425d90a 100644 --- a/ghc/rts/Signals.c +++ b/ghc/rts/Signals.c @@ -1,5 +1,4 @@ /* ----------------------------------------------------------------------------- - * $Id: Signals.c,v 1.35 2003/03/25 17:15:07 sof 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,17 @@ #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 +/* ----------------------------------------------------------------------------- + * The table of signal handlers + * -------------------------------------------------------------------------- */ + +#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 */ @@ -42,30 +52,6 @@ static StgInt nHandlers = 0; /* Size of handlers array */ static nat n_haskell_handlers = 0; -#define N_PENDING_HANDLERS 16 - -StgPtr pending_handler_buf[N_PENDING_HANDLERS]; -StgPtr *next_pending_handler = pending_handler_buf; - -StgInt nocldstop = 0; - - -#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() -{ -#ifdef RTS_SUPPORTS_THREADS - signalHandlingThread = pthread_self(); -#endif -} - - /* ----------------------------------------------------------------------------- * Allocate/resize the table of signal handlers. * -------------------------------------------------------------------------- */ @@ -91,6 +77,53 @@ more_handlers(I_ sig) } /* ----------------------------------------------------------------------------- + * Pending Handlers + * + * The mechanism for starting handlers differs between the threaded + * (RTS_SUPPORTS_THREADS) and non-threaded versions of the RTS. + * + * When the RTS is single-threaded, we just write the pending signal + * handlers into a buffer, and start a thread for each one in the + * scheduler loop. + * + * When RTS_SUPPORTS_THREADS, the problem is that signals might be + * delivered to multiple threads, so we would need to synchronise + * access to pending_handler_buf somehow. Using thread + * synchronisation from a signal handler isn't possible in general + * (some OSs support it, eg. MacOS X, but not all). So instead: + * + * - the signal handler writes the signal number into the pipe + * managed by the IO manager thread (see GHC.Conc). + * - the IO manager picks up the signal number and calls + * startSignalHandler() to start the thread. + * + * This also has the nice property that we don't need to arrange to + * wake up a worker task to start the signal handler: the IO manager + * wakes up when we write into the pipe. + * + * -------------------------------------------------------------------------- */ + +// Here's the pipe into which we will send our signals +static int io_manager_pipe = -1; + +void +setIOManagerPipe (int fd) +{ + // only called when RTS_SUPPORTS_THREADS, but unconditionally + // compiled here because GHC.Conc depends on it. + io_manager_pipe = fd; +} + +#if !defined(RTS_SUPPORTS_THREADS) + +#define N_PENDING_HANDLERS 16 + +StgPtr pending_handler_buf[N_PENDING_HANDLERS]; +StgPtr *next_pending_handler = pending_handler_buf; + +#endif /* RTS_SUPPORTS_THREADS */ + +/* ----------------------------------------------------------------------------- * SIGCONT handler * * It seems that shells tend to put stdin back into blocking mode @@ -118,18 +151,20 @@ 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 defined(RTS_SUPPORTS_THREADS) - if(pthread_self() != signalHandlingThread) { - pthread_kill(signalHandlingThread, sig); - return; + if (io_manager_pipe != -1) + { + // Write the signal number into the pipe as a single byte. We + // hope that signals fit into a byte... + StgWord8 csig = (StgWord8)sig; + write(io_manager_pipe, &csig, 1); } -#endif + // If the IO manager hasn't told us what the FD of the write end + // of its pipe is, there's not much we can do here, so just ignore + // the signal.. + +#else /* not RTS_SUPPORTS_THREADS */ /* Can't call allocate from here. Probably can't call malloc either. However, we have to schedule a new thread somehow. @@ -163,10 +198,12 @@ 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); } +#endif /* RTS_SUPPORTS_THREADS */ + // re-establish the signal handler, and carry on sigemptyset(&signals); sigaddset(&signals, sig); @@ -211,6 +248,7 @@ anyUserHandlers(void) return n_haskell_handlers != 0; } +#if !defined(RTS_SUPPORTS_THREADS) void awaitUserSignals(void) { @@ -218,6 +256,7 @@ awaitUserSignals(void) pause(); } } +#endif /* ----------------------------------------------------------------------------- * Install a Haskell signal handler. @@ -289,7 +328,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; @@ -300,11 +339,29 @@ stg_sig_install(int sig, int spi, StgStablePtr *handler, void *mask) } /* ----------------------------------------------------------------------------- - * Creating new threads for the pending signal handlers. + * Creating new threads for signal handlers. * -------------------------------------------------------------------------- */ + +void +startSignalHandler(int sig) // called by the IO manager, see GHC.Conc +{ +#if defined(RTS_SUPPORTS_THREADS) + // ToDo: fix race window between the time at which the signal is + // delivered and the deRefStablePtr() call here. There's no way + // to safely uninstall a signal handler. + scheduleThread( + createIOThread(RtsFlags.GcFlags.initialStkSize, + (StgClosure *)deRefStablePtr((StgStablePtr)handlers[sig])) + ); +#else + (void)sig; /* keep gcc -Wall happy */ +#endif +} + void startSignalHandlers(void) { +#if !defined(RTS_SUPPORTS_THREADS) blockUserSignals(); while (next_pending_handler != pending_handler_buf) { @@ -317,6 +374,7 @@ startSignalHandlers(void) } unblockUserSignals(); +#endif } /* ---------------------------------------------------------------------------- @@ -328,6 +386,7 @@ startSignalHandlers(void) * avoid race conditions. * -------------------------------------------------------------------------- */ +#if !defined(RTS_SUPPORTS_THREADS) void markSignalHandlers (evac_fn evac) { @@ -339,21 +398,27 @@ markSignalHandlers (evac_fn evac) evac((StgClosure **)p); } } - -#else // PAR -StgInt -stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) +#else +void +markSignalHandlers (evac_fn evac STG_UNUSED) { - // don't fflush(stdout); WORKAROUND bug in Linux glibc - barf("no signal handling support in a parallel implementation"); } +#endif -void -startSignalHandlers(void) +#else /* !RTS_USER_SIGNALS */ +StgInt +stg_sig_install(StgInt sig STG_UNUSED, + StgInt spi STG_UNUSED, + StgStablePtr* handler STG_UNUSED, + void* mask STG_UNUSED) { + //barf("User signals not supported"); + return STG_SIG_DFL; } + #endif +#if defined(RTS_USER_SIGNALS) /* ----------------------------------------------------------------------------- * SIGINT handler. * @@ -376,17 +441,6 @@ 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 @@ -422,19 +476,16 @@ 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 @@ -443,7 +494,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 @@ -461,26 +512,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 } -#else /* mingw32_TARGET_OS */ - -// 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() -{ -#ifdef RTS_SUPPORTS_THREADS -#error "handleSignalsInThread needs to be sorted out for MinGW32" - /* signalHandlingThread = pthread_self();*/ -#endif -} -#endif /* mingw32_TARGET_OS */ +#endif /* RTS_USER_SIGNALS */