[project @ 2002-11-05 14:10:44 by simonpj]

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

diff --git a/ghc/rts/Select.c b/ghc/rts/Select.c
index 644bb41..dc19cbf 100644 (file)
--- a/ghc/rts/Select.c
+++ b/ghc/rts/Select.c
@@ -1,14 +1,14 @@
 /* -----------------------------------------------------------------------------
- * $Id: Select.c,v 1.15 2001/02/27 12:43:45 rrt Exp $
+ * $Id: Select.c,v 1.22 2002/07/24 03:38:58 sof Exp $
  *
- * (c) The GHC Team 1995-1999
+ * (c) The GHC Team 1995-2002
  *
  * Support for concurrent non-blocking I/O and thread waiting.
  *
  * ---------------------------------------------------------------------------*/
 
 /* we're outside the realms of POSIX here... */
-#define NON_POSIX_SOURCE
+/* #include "PosixSource.h" */
 
 #include "Rts.h"
 #include "Schedule.h"
@@ -26,18 +26,15 @@
 # endif
 
 # ifdef mingw32_TARGET_OS
-#  include <w32api/windows.h>
+#  include <windows.h>
 # endif
 
+#include <errno.h>
+#include <string.h>
+
 /* last timestamp */
 nat timestamp = 0;
 
-/* keep track of the number of ticks since we last called
- * gettimeofday(), to avoid having to call it every time we need
- * a timestamp.
- */
-nat ticks_since_timestamp = 0;
-
 /* There's a clever trick here to avoid problems when the time wraps
  * around.  Since our maximum delay is smaller than 31 bits of ticks
  * (it's actually 31 bits of microseconds), we can safely check
@@ -92,12 +89,13 @@ awaitEvent(rtsBool wait)
     int maxfd = -1;
 #endif
     rtsBool select_succeeded = rtsTrue;
+    rtsBool unblock_all = rtsFalse;
     struct timeval tv;
     lnat min, ticks;
 
     tv.tv_sec  = 0;
     tv.tv_usec = 0;
-
+    
     IF_DEBUG(scheduler,
             belch("scheduler: checking for threads blocked on I/O");
             if (wait) {
@@ -114,7 +112,6 @@ awaitEvent(rtsBool wait)
     do {
 
       ticks = timestamp = getourtimeofday();
-      ticks_since_timestamp = 0;
       if (wakeUpSleepingThreads(ticks)) { 
          return;
       }
@@ -181,11 +178,32 @@ awaitEvent(rtsBool wait)
 
       while ((numFound = select(maxfd+1, &rfd, &wfd, NULL, &tv)) < 0) {
          if (errno != EINTR) {
-
-             printf("%d\n", errno);
-             fflush(stdout);
-             perror("select");
+           /* Handle bad file descriptors by unblocking all the
+              waiting threads. Why? Because a thread might have been
+              a bit naughty and closed a file descriptor while another
+              was blocked waiting. This is less-than-good programming
+              practice, but having the RTS as a result fall over isn't
+              acceptable, so we simply unblock all the waiting threads
+              should we see a bad file descriptor & give the threads
+              a chance to clean up their act. 
+              
+              Note: assume here that threads becoming unblocked
+              will try to read/write the file descriptor before trying
+              to issue a threadWaitRead/threadWaitWrite again (==> an
+              IOError will result for the thread that's got the bad
+              file descriptor.) Hence, there's no danger of a bad
+              file descriptor being repeatedly select()'ed on, so
+              the RTS won't loop.
+           */
+           if ( errno == EBADF ) {
+             unblock_all = rtsTrue;
+             break;
+           } else {
+             fprintf(stderr,"%d\n", errno);
+             fflush(stderr);
+             perror("select");
              barf("select failed");
+           }
          }
 #else /* on mingwin */
       while (1) {
@@ -201,7 +219,7 @@ awaitEvent(rtsBool wait)
           */
          if (signals_pending()) {
              RELEASE_LOCK(&sched_mutex); /* ToDo: kill */
-             start_signal_handlers();
+             startSignalHandlers();
              ACQUIRE_LOCK(&sched_mutex);
              return; /* still hold the lock */
          }
@@ -234,15 +252,15 @@ awaitEvent(rtsBool wait)
        */
 
       prev = NULL;
-      if (select_succeeded) {
+      if (select_succeeded || unblock_all) {
          for(tso = blocked_queue_hd; tso != END_TSO_QUEUE; tso = next) {
              next = tso->link;
              switch (tso->why_blocked) {
              case BlockedOnRead:
-                 ready = FD_ISSET(tso->block_info.fd, &rfd);
+                 ready = unblock_all || FD_ISSET(tso->block_info.fd, &rfd);
                  break;
              case BlockedOnWrite:
-                 ready = FD_ISSET(tso->block_info.fd, &wfd);
+                 ready = unblock_all || FD_ISSET(tso->block_info.fd, &wfd);
                  break;
              default:
                  barf("awaitEvent");