[project @ 2003-03-26 17:43:05 by sof]

[ghc-hetmet.git] / ghc / rts / Signals.c

diff --git a/ghc/rts/Signals.c b/ghc/rts/Signals.c
index d2a61e3..355cf14 100644 (file)
--- a/ghc/rts/Signals.c
+++ b/ghc/rts/Signals.c
@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------------
- * $Id: Signals.c,v 1.28 2002/09/06 14:34:13 simonmar Exp $
+ * $Id: Signals.c,v 1.35 2003/03/25 17:15:07 sof Exp $
  *
  * (c) The GHC Team, 1998-1999
  *
@@ -49,6 +49,23 @@ 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 +79,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 +118,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 +163,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 +196,7 @@ initUserSignals(void)
 void
 blockUserSignals(void)
 {
-    sigprocmask(SIG_SETMASK, &userSignals, &savedSignals);
+    sigprocmask(SIG_BLOCK, &userSignals, &savedSignals);
 }
 
 void
@@ -214,6 +241,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;
@@ -228,9 +257,13 @@ stg_sig_install(int sig, int spi, StgStablePtr *handler, void *mask)
        break;
 
     case STG_SIG_HAN:
+    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;
 
@@ -243,7 +276,7 @@ stg_sig_install(int sig, int spi, StgStablePtr *handler, void *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_SETMASK, &osignals, NULL)) 
@@ -286,6 +319,27 @@ startSignalHandlers(void)
   unblockUserSignals();
 }
 
+/* ----------------------------------------------------------------------------
+ * 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)
+{
+    StgPtr *p;
+
+    p = next_pending_handler;
+    while (p != pending_handler_buf) {
+       p--;
+       evac((StgClosure **)p);
+    }
+}
+
 #else // PAR
 StgInt 
 stg_sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask)
@@ -322,13 +376,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();
     }
@@ -357,6 +422,9 @@ initDefaultHandlers()
 #ifdef SMP
     startup_guy = pthread_self();
 #endif
+#ifdef RTS_SUPPORTS_THREADS
+       handleSignalsInThisThread();
+#endif
 
     // install the SIGINT handler
     action.sa_handler = shutdown_handler;
@@ -401,5 +469,18 @@ initDefaultHandlers()
     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 /* mingw32_TARGET_OS */