X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FSignals.c;h=4773006dadf92b2c5d0a412d3f48de91ec523901;hb=5e9fd7ed27f970084b4795c5c4619c30a953174f;hp=b94ad6d8e5c8e7d049b03c222cc01f68f4a81907;hpb=cd147bc3e6bb999893c379c58a7042bf311a2e5c;p=ghc-hetmet.git diff --git a/ghc/rts/Signals.c b/ghc/rts/Signals.c index b94ad6d..4773006 100644 --- a/ghc/rts/Signals.c +++ b/ghc/rts/Signals.c @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------------- - * $Id: Signals.c,v 1.25 2002/07/02 12:24:48 simonmar Exp $ + * $Id: Signals.c,v 1.37 2003/04/01 15:05:22 sof Exp $ * * (c) The GHC Team, 1998-1999 * @@ -19,12 +19,27 @@ #include "StablePriv.h" #ifdef alpha_TARGET_ARCH -#include +# include #endif -#ifndef mingw32_TARGET_OS +#ifdef HAVE_UNISTD_H +# include +#endif + +#ifdef HAVE_SIGNAL_H +# include +#endif + +#include + +/* 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 */ @@ -37,7 +52,21 @@ static nat n_haskell_handlers = 0; 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. @@ -52,14 +81,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; @@ -95,6 +120,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. @@ -127,7 +165,8 @@ generic_handler(int sig) // stack full? if (next_pending_handler == &pending_handler_buf[N_PENDING_HANDLERS]) { - barf("too many pending signals"); + prog_belch("too many pending signals"); + stg_exit(EXIT_FAILURE); } // re-establish the signal handler, and carry on @@ -159,7 +198,7 @@ initUserSignals(void) void blockUserSignals(void) { - sigprocmask(SIG_SETMASK, &userSignals, &savedSignals); + sigprocmask(SIG_BLOCK, &userSignals, &savedSignals); } void @@ -186,17 +225,17 @@ awaitUserSignals(void) * Install a Haskell signal handler. * -------------------------------------------------------------------------- */ -StgInt -stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) +int +stg_sig_install(int sig, int spi, StgStablePtr *handler, void *mask) { - sigset_t signals; + sigset_t signals, osignals; struct sigaction action; StgInt previous_spi; // Block the signal until we figure out what to do // Count on this to fail if the signal number is invalid if (sig < 0 || sigemptyset(&signals) || - sigaddset(&signals, sig) || sigprocmask(SIG_BLOCK, &signals, NULL)) { + sigaddset(&signals, sig) || sigprocmask(SIG_BLOCK, &signals, &osignals)) { return STG_SIG_ERR; } @@ -204,6 +243,8 @@ stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) previous_spi = handlers[sig]; + action.sa_flags = 0; + switch(spi) { case STG_SIG_IGN: handlers[sig] = STG_SIG_IGN; @@ -218,9 +259,13 @@ stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) break; case STG_SIG_HAN: - handlers[sig] = (StgInt)handler; + case STG_SIG_RST: + handlers[sig] = (StgInt)*handler; sigaddset(&userSignals, sig); action.sa_handler = generic_handler; + if (spi == STG_SIG_RST) { + action.sa_flags = SA_RESETHAND; + } n_haskell_handlers++; break; @@ -228,15 +273,15 @@ stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) barf("stg_sig_install: bad spi"); } - if (mask != 0) - action.sa_mask = *mask; + if (mask != NULL) + action.sa_mask = *(sigset_t *)mask; else sigemptyset(&action.sa_mask); - action.sa_flags = sig == SIGCHLD && nocldstop ? SA_NOCLDSTOP : 0; + action.sa_flags |= sig == SIGCHLD && nocldstop ? SA_NOCLDSTOP : 0; if (sigaction(sig, &action, NULL) || - sigprocmask(SIG_UNBLOCK, &signals, NULL)) + sigprocmask(SIG_SETMASK, &osignals, NULL)) { // need to return an error code, so avoid a stable pointer leak // by freeing the previous handler if there was one. @@ -247,7 +292,13 @@ stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) return STG_SIG_ERR; } - return previous_spi; + if (previous_spi == STG_SIG_DFL || previous_spi == STG_SIG_IGN + || previous_spi == STG_SIG_ERR) { + return previous_spi; + } else { + *handler = (StgStablePtr)previous_spi; + return STG_SIG_HAN; + } } /* ----------------------------------------------------------------------------- @@ -270,20 +321,41 @@ startSignalHandlers(void) unblockUserSignals(); } -#else // PAR -StgInt -stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask) +/* ---------------------------------------------------------------------------- + * Mark signal handlers during GC. + * + * We do this rather than trying to start all the signal handlers + * prior to GC, because that requires extra heap for the new threads. + * Signals must be blocked (see blockUserSignals() above) during GC to + * avoid race conditions. + * -------------------------------------------------------------------------- */ + +void +markSignalHandlers (evac_fn evac) { - // don't fflush(stdout); WORKAROUND bug in Linux glibc - barf("no signal handling support in a parallel implementation"); + StgPtr *p; + + p = next_pending_handler; + while (p != pending_handler_buf) { + p--; + evac((StgClosure **)p); + } } -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. * @@ -306,13 +378,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(); } @@ -341,6 +424,9 @@ initDefaultHandlers() #ifdef SMP startup_guy = pthread_self(); #endif +#ifdef RTS_SUPPORTS_THREADS + handleSignalsInThisThread(); +#endif // install the SIGINT handler action.sa_handler = shutdown_handler; @@ -386,4 +472,4 @@ initDefaultHandlers() #endif } -#endif /*! mingw32_TARGET_OS */ +#endif /* RTS_USER_SIGNALS */