[project @ 2000-02-14 10:58:05 by sewardj]

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

diff --git a/ghc/rts/Signals.c b/ghc/rts/Signals.c
index 7062102..9c6e058 100644 (file)
--- a/ghc/rts/Signals.c
+++ b/ghc/rts/Signals.c
@@ -1,5 +1,7 @@
 /* -----------------------------------------------------------------------------
- * $Id: Signals.c,v 1.3 1999/01/26 11:12:49 simonm Exp $
+ * $Id: Signals.c,v 1.12 2000/01/13 12:40:16 simonmar Exp $
+ *
+ * (c) The GHC Team, 1998-1999
  *
  * Signal processing / handling.
  *
@@ -7,11 +9,14 @@
 
 #include "Rts.h"
 #include "SchedAPI.h"
+#include "Schedule.h"
 #include "Signals.h"
 #include "RtsUtils.h"
 #include "RtsFlags.h"
 #include "StablePriv.h"
 
+#ifndef mingw32_TARGET_OS
+
 #ifndef PAR
 
 static StgInt *handlers = NULL; /* Dynamically grown array of signal handlers */
@@ -34,21 +39,20 @@ more_handlers(I_ sig)
     I_ i;
 
     if (sig < nHandlers)
-       return;
+      return;
 
     if (handlers == NULL)
-       handlers = (I_ *) malloc((sig + 1) * sizeof(I_));
+      handlers = (I_ *) malloc((sig + 1) * sizeof(I_));
     else
-       handlers = (I_ *) realloc(handlers, (sig + 1) * sizeof(I_));
+      handlers = (I_ *) realloc(handlers, (sig + 1) * sizeof(I_));
 
     if (handlers == NULL) {
-       fflush(stdout);
-       fprintf(stderr, "VM exhausted (in more_handlers)\n");
-       exit(EXIT_FAILURE);
+      /* 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;
+      /* Fill in the new slots with default actions */
+      handlers[i] = STG_SIG_DFL;
 
     nHandlers = sig + 1;
 }
@@ -69,7 +73,7 @@ generic_handler(int sig)
        either.  However, we have to schedule a new thread somehow.
 
        It's probably ok to request a context switch and allow the
-       scheduler to  start the handler thread, but how to we
+       scheduler to  start the handler thread, but how do we
        communicate this to the scheduler?
 
        We need some kind of locking, but with low overhead (i.e. no
@@ -104,6 +108,8 @@ generic_handler(int sig)
     sigemptyset(&signals);
     sigaddset(&signals, sig);
     sigprocmask(SIG_UNBLOCK, &signals, NULL);
+
+    context_switch = 1;
 }
 
 /* -----------------------------------------------------------------------------
@@ -165,11 +171,13 @@ sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask)
        sigdelset(&userSignals, sig);
         action.sa_handler = SIG_DFL;
        break;
+
     case STG_SIG_HAN:
        handlers[sig] = (I_)handler;
        sigaddset(&userSignals, sig);
        action.sa_handler = generic_handler;
        break;
+
     default:
         barf("sig_install: bad spi");
     }
@@ -209,10 +217,6 @@ start_signal_handlers(void)
 
     next_pending_handler--;
 
-    /* create*Thread  puts the thread on the head of the runnable
-     * queue, hence it will be run next.  Poor man's priority
-     * scheduling.
-     */
     createIOThread(RtsFlags.GcFlags.initialStkSize, 
                   (StgClosure *) *next_pending_handler);
   }
@@ -224,10 +228,8 @@ start_signal_handlers(void)
 StgInt 
 sig_install(StgInt sig, StgInt spi, StgStablePtr handler, sigset_t *mask)
 {
-    fflush(stdout);
-    fprintf(stderr,
-           "No signal handling support in a parallel implementation.\n");
-    exit(EXIT_FAILURE);
+  /* don't fflush(stdout); WORKAROUND bug in Linux glibc */
+  barf("no signal handling support in a parallel implementation");
 }
 
 void
@@ -235,3 +237,63 @@ start_signal_handlers(void)
 {
 }
 #endif
+
+/* -----------------------------------------------------------------------------
+   SIGINT handler.
+
+   We like to shutdown nicely after receiving a SIGINT, write out the
+   stats, write profiling info, close open files and flush buffers etc.
+   -------------------------------------------------------------------------- */
+
+#ifdef SMP
+pthread_t startup_guy;
+#endif
+
+static void
+shutdown_handler(int sig STG_UNUSED)
+{
+#ifdef SMP
+  /* if I'm a worker thread, send this signal to the guy who
+   * originally called startupHaskell().  Since we're handling
+   * the signal, it won't be a "send to all threads" type of signal
+   * (according to the POSIX threads spec).
+   */
+  if (pthread_self() != startup_guy) {
+    pthread_kill(startup_guy, sig);
+  } else
+#endif
+
+  shutdownHaskellAndExit(EXIT_INTERRUPTED);
+}
+
+/*
+ * The RTS installs a default signal handler for catching
+ * SIGINT, so that we can perform an orderly shutdown.
+ *
+ * Haskell code may install their own SIGINT handler, which is
+ * fine, provided they're so kind as to put back the old one
+ * when they de-install.
+ */
+void
+init_shutdown_handler()
+{
+    struct sigaction action,oact;
+
+#ifdef SMP
+    startup_guy = pthread_self();
+#endif
+    action.sa_handler = shutdown_handler;
+    sigemptyset(&action.sa_mask);
+    action.sa_flags = 0;
+    if (sigaction(SIGINT, &action, &oact) != 0) {
+      /* Oh well, at least we tried. */
+#ifdef DEBUG
+      fprintf(stderr, "init_shutdown_handler: failed to reg SIGINT handler");
+#endif
+    }
+}
+
+
+
+
+#endif /*! mingw32_TARGET_OS */