X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FSignals.c;h=4773006dadf92b2c5d0a412d3f48de91ec523901;hb=387a411e5d6478249de6872c283f2df78ef83bf4;hp=b8d2cf3d71357c0b7e98bfe3cf51f3ed88837526;hpb=6ff1e84bcef3c4aba42c1b6e90f2eba84c8b02ac;p=ghc-hetmet.git

diff --git a/ghc/rts/Signals.c b/ghc/rts/Signals.c
index b8d2cf3..4773006 100644
--- a/ghc/rts/Signals.c
+++ b/ghc/rts/Signals.c
@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------------
- * $Id: Signals.c,v 1.30 2002/12/05 14:20:55 stolz Exp $
+ * $Id: Signals.c,v 1.37 2003/04/01 15:05:22 sof Exp $
  *
  * (c) The GHC Team, 1998-1999
  *
@@ -32,9 +32,14 @@
 
 #include <stdlib.h>
 
-#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 +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.
@@ -62,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;
@@ -105,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.
 
@@ -137,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
@@ -169,7 +198,7 @@ initUserSignals(void)
 void
 blockUserSignals(void)
 {
-    sigprocmask(SIG_SETMASK, &userSignals, &savedSignals);
+    sigprocmask(SIG_BLOCK, &userSignals, &savedSignals);
 }
 
 void
@@ -214,6 +243,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;
@@ -311,20 +342,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.
  *
@@ -347,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();
     }
@@ -382,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;
@@ -427,4 +472,4 @@ initDefaultHandlers()
 #endif
 }
 
-#endif /*! mingw32_TARGET_OS */
+#endif /* RTS_USER_SIGNALS */