diff --git a/distribution/manifest b/distribution/manifest
index 4ef3d1d..9e2eed7 100644
--- a/distribution/manifest
+++ b/distribution/manifest
@@ -208,6 +208,14 @@ tests/reverser/tags/1.1/reverser.scm
 tests/rev-app.scm
 tests/signal-tests.scm
 tests/version-tests.scm
+tests/scheduler-fdset-2.scm
+tests/scheduler-fdset-2a.scm
+tests/scheduler-fdset-3.scm
+tests/scheduler-fdset-4.scm
+tests/scheduler-fdset.scm
+tests/scheduler-test.scm
+tests/cat.scm
+tests/sink.c
 tweaks.scm
 utils.scm
 apply-hack.x86.S
diff --git a/scheduler.scm b/scheduler.scm
index e31f6c8..9538569 100644
--- a/scheduler.scm
+++ b/scheduler.scm
@@ -32,7 +32,8 @@
 	##sys#update-thread-state-buffer ##sys#restore-thread-state-buffer
 	remove-from-ready-queue ##sys#unblock-threads-for-i/o ##sys#force-primordial
 	fdset-set fdset-test create-fdset stderr
-	##sys#clear-i/o-state-for-thread! ##sys#abandon-mutexes) 
+	##sys#clear-i/o-state-for-thread! ##sys#abandon-mutexes
+        ##sys#interrupt-hook-continuation) 
   (not inline ##sys#interrupt-hook)
   (unsafe)
   (foreign-declare #<<EOF
@@ -148,7 +149,15 @@ EOF
   (syntax-rules ()
     ((_ msg) (##core#inline "C_halt" msg))))
 
+;; See ##sys#interrupt-hook later in the file.
+(define ##sys#scheduler-in-interrupt-handler #f)
+(define ##sys#scheduler-interrupt-hook-continuation #f)
+
 (define (##sys#schedule)
+  (when ##sys#scheduler-in-interrupt-handler
+    (if (not (##sys#slot ##sys#current-thread 11))
+      (##sys#add-to-ready-queue ##sys#current-thread))
+    (##sys#scheduler-interrupt-hook-continuation 'schedule))
   (define (switch thread)
     (dbg "switching to " thread)
     (set! ##sys#current-thread thread)
@@ -261,14 +270,59 @@ EOF
     (set! ##sys#current-exception-handler (##sys#slot buf 4))
     (set! ##sys#current-parameter-vector (##sys#slot buf 5)) ) )
 
+;; See http://wiki.call-cc.org/scheduler-interrupt-hook for additional
+;; information on the interrupt hook.
 (set! ##sys#interrupt-hook
-  (let ([oldhook ##sys#interrupt-hook])
+  (let ((oldhook ##sys#interrupt-hook))
     (lambda (reason state)
-      (when (fx= reason 255)		; C_TIMER_INTERRUPT_NUMBER
-	(let ([ct ##sys#current-thread])
-	  (##sys#setslot ct 1 (lambda () (oldhook reason state))) 
-	  (##sys#schedule) ) )		; expected not to return!
-      (oldhook reason state) ) ) )
+      (dbg "##sys#interrupt-hook: reason " reason)
+      (let ((ct ##sys#current-thread)
+            (in-handler ##sys#scheduler-in-interrupt-handler)
+            (continuation ##sys#scheduler-interrupt-hook-continuation))
+        (when (fx= reason 255)		; C_TIMER_INTERRUPT_NUMBER
+          (##sys#setslot ct 1 (lambda () (oldhook reason state))) 
+          (##sys#schedule))		; expected not to return!
+        (let ((handler-thread
+                (##sys#make-thread
+                 (lambda () (panic "##sys#interrupt-hook: interrupt-handler thread: I should not be called!"))
+                 'running
+                 (gensym 'interrupt-handler)
+                 ##sys#default-thread-quantum))
+              (reset
+                (lambda ()
+                  (set! ##sys#scheduler-in-interrupt-handler in-handler)
+                  (set! ##sys#scheduler-interrupt-hook-continuation continuation)
+                  (set! ##sys#current-thread ct)))
+              (result #f)
+              (returned #f))
+          (set! ##sys#current-thread handler-thread)
+          (case (##sys#call-with-current-continuation
+                 (lambda (return)
+                   (set! ##sys#scheduler-in-interrupt-handler #t)
+                   (set! ##sys#scheduler-interrupt-hook-continuation return)
+                   (set! result (oldhook reason (lambda ()
+                                                  (dbg "##sys#interrupt-hook: Returned from oldhook.")
+                                                  (if returned
+                                                    (return 'thread))
+                                                  (reset)
+                                                  (if (procedure? state)
+                                                    (state)
+                                                    (##sys#context-switch state)))))
+                   (return 'oldhook)))
+            ((oldhook)
+             (dbg "##sys#interrupt-hook: Returned after oldhook.")
+             result)
+            ((schedule)
+             (dbg "##sys#interrupt-hook: Returned due to ##sys#schedule.")
+             (set! returned #t)
+             (reset)
+             (if (procedure? state)
+               (state)
+               (##sys#context-switch state)))
+            ((thread)
+             (dbg "##sys#interrupt-hook: Returned due to thread.")
+             (##sys#thread-kill! handler-thread 'dead)
+             (##sys#schedule))))))))
 
 (define ##sys#timeout-list '())
 
@@ -385,16 +439,31 @@ EOF
 
 (define (create-fdset)
   ((foreign-lambda void "C_prepare_fdset" int) (##sys#length ##sys#fd-list))
-  (let loop ((lst ##sys#fd-list))
-    (unless (null? lst)
-      (let ((fd (caar lst)))
-	(for-each
-	 (lambda (t)
-	   (let ((p (##sys#slot t 11)))
-             (when (pair? p) ; (FD . RWFLAGS)? (can also be mutex or thread)
-               (fdset-set fd (cdr p)))))
-	 (cdar lst))
-	(loop (cdr lst))))))
+  (for-each
+    (lambda (item)
+      (let* ((fd (car item))
+             (ts (cdr item))
+             ; Determine what we should watch this fd for.
+             ; If any of the threads are waiting for both read and write
+             ; readiness, we need to wait for both.
+             ; Likewise, if one thread is waiting for read readiness and
+             ; another for write readiness, we need to wait for both.
+             ; If all of the threads are only waiting for one of read or write
+             ; readiness, then we only need to wait for that.
+             (on (##sys#call-with-current-continuation
+                  (lambda (return)
+                    (return
+                      (foldl (lambda (a l)
+                               (let* ((p (##sys#slot l 11))
+                                      (rw (cdr p)))
+                                 (if (or (eq? rw #:all) (not (eq? a rw)))
+                                   (return #:all)
+                                   (else rw))))
+                             (cdr (##sys#slot (car ts) 11))
+                             (cdr ts)))))))
+        (dbg "create-fdset: fdset-set " fd " on " on)
+        (fdset-set fd on)))
+    ##sys#fd-list))
 
 (define (fdset-set fd i/o)
   (let ((fdset-add! (foreign-lambda void "C_fdset_add" int bool bool)))
diff --git a/srfi-18.scm b/srfi-18.scm
index 7c908f2..4e7beee 100644
--- a/srfi-18.scm
+++ b/srfi-18.scm
@@ -363,9 +363,10 @@
 		 (##sys#setslot wt 8 (cons mutex (##sys#slot wt 8)))
 		 (##sys#setslot wt 11 #f)
 		 (when (eq? wts 'sleeping) (##sys#add-to-ready-queue wt) ) ) ) )
-	   (if (eq? (##sys#slot ct 3) 'running)
-	       (return #t)
-	       (##sys#schedule)) ) ) ) ) ))
+           (when (eq? (##sys#slot ct 3) 'running)
+             (##sys#setslot ct 11 #f)
+             (return #t))
+           (##sys#schedule)))))))
 
 ;;; Condition variables:
 
diff --git a/tests/cat.scm b/tests/cat.scm
new file mode 100644
index 0000000..4fd6c16
--- /dev/null
+++ b/tests/cat.scm
@@ -0,0 +1,12 @@
+(use posix srfi-18)
+
+(set-signal-handler! signal/int
+  (lambda (sig)
+    (exit 1)))
+
+(let loop ()
+  (define line (read-line))
+  (unless (eof-object? line)
+    (write-line line)
+    (thread-yield!)
+    (loop)))
diff --git a/tests/runtests.bat b/tests/runtests.bat
index b6ef378..bcfa4b1 100644
--- a/tests/runtests.bat
+++ b/tests/runtests.bat
@@ -18,7 +18,7 @@ set compile2=..\csc -compiler %CHICKEN% -v -I%TEST_DIR%/.. -L%TEST_DIR%/.. -incl
 set compile_s=..\csc -s -types %TYPESDB% -ignore-repository -compiler %CHICKEN% -v -I%TEST_DIR%/.. -L%TEST_DIR%/.. -include-path %TEST_DIR%/..
 set interpret=..\csi -n -include-path %TEST_DIR%/..
 
-del /f /q *.exe *.so *.o *.import.* ..\foo.import.*
+del /f /q *.exe *.so *.o *.import.* ..\foo.import.* sink
 
 echo ======================================== version tests ...
 %interpret% -s version-tests.scm
@@ -105,6 +105,12 @@ if errorlevel 1 (
   exit /b 1
 )
 
+echo ======================================== scheduler tests ...
+
+gcc sink.c -o sink
+%interpret% -s scheduler-test.scm
+if errorlevel 1 exit /b 1
+
 echo ======================================== runtime tests ...
 %interpret% -s apply-test.scm
 if errorlevel 1 exit /b 1
diff --git a/tests/runtests.sh b/tests/runtests.sh
index 7e078ff..09b3edd 100755
--- a/tests/runtests.sh
+++ b/tests/runtests.sh
@@ -68,7 +68,7 @@ compile2="../csc -compiler $CHICKEN -v -I${TEST_DIR}/.. -L${TEST_DIR}.. -include
 compile_s="../csc -s -types ${TYPESDB} -ignore-repository ${COMPILE_OPTIONS} -v -I${TEST_DIR}/.. -L${TEST_DIR}/.. -include-path ${TEST_DIR}/.."
 interpret="../csi -n -include-path ${TEST_DIR}/.."
 
-rm -f *.exe *.so *.o *.import.* a.out ../foo.import.*
+rm -f *.exe *.so *.o *.import.* a.out ../foo.import.* sink
 
 echo "======================================== version tests ..."
 $interpret -s version-tests.scm
@@ -136,6 +136,11 @@ else
     echo "double-return from callback failed as it should."
 fi
 
+echo "======================================== scheduler tests ..."
+
+gcc sink.c -o sink
+$interpret -s scheduler-test.scm
+
 echo "======================================== runtime tests ..."
 $interpret -s apply-test.scm
 $compile apply-test.scm
diff --git a/tests/scheduler-fdset-2.scm b/tests/scheduler-fdset-2.scm
new file mode 100644
index 0000000..10bfecf
--- /dev/null
+++ b/tests/scheduler-fdset-2.scm
@@ -0,0 +1,75 @@
+; Test case #2 to trigger the scheduler assert error:
+; csi: scheduler.c:77: C_fd_ready: Assertion `fd == C_fdset_set[pos].fd' failed.
+;
+; Also triggers in the case when there is buggy handling of two threads blocked
+; on the same fd, or when the interrupt handler causes the scheduler to hang.
+;
+; Instructions:
+; You will need to compile sink.c in the tests directory: `gcc sink.c -o sink`
+;
+; 1. Run the test
+; 2. Wait a short bit for the child processes to start
+; 3. Start netcat in a new terminal with `nc -l 8123`
+; 4. Send SIGINT (e.g. with ^C)
+; 5. Verify that the process is not using 100% CPU
+; 6. Type `hi` in the terminal with netcat
+; 7. The test should exit without error
+;
+; Requires srfi-18 -- if this is removed from core, this test could be written,
+; but it would involve using more low-level procedures.
+(use posix tcp)
+(use srfi-18)
+
+(define m (make-mutex))
+(define o1 #f)
+(define o2 #f)
+
+(define (discard in)
+  (let loop ()
+    (let ((c (read-char in)))
+      (if (not (eof-object? c))
+        (loop)))))
+
+(set-signal-handler!
+  signal/int
+  (lambda (sig)
+    (print "locking...")
+    (mutex-lock! m)
+    (print "unlocking...")
+    ; If we have changed the fd-list in a bad way, a deadlock might occur.
+    ; If the create-fdset code is still skipping the thread, then a scheduler
+    ; assert about the fdset will fail
+    (mutex-unlock! m)
+    (print "unlocked...")
+
+    (print "yielding")
+    (thread-yield!)
+    (print "yielded")
+
+    (print "receiving...")
+    (print "100% CPU if buggy")
+    ; We sleep one second to make it more likely it has started its listener
+    ; before we try to connect.
+    (process "csi" '("-s" "scheduler-fdset-2a.scm"))
+    (sleep 1)
+    (receive (in out) (tcp-connect "localhost" 8123)
+      (read-line in))
+    (print "received")
+          
+    (write-char #\newline o1)
+    (write-char #\newline o2)
+    ))
+
+(thread-start!
+  (make-thread
+    (lambda ()
+      (receive (in out pid) (process "./sink")
+        (set! o1 out)
+        (discard in))))) 
+
+; Make another, just in case...
+(receive (in out pid) (process "./sink")
+  (set! o2 out)
+  (discard in))
+
+(print "done!")
diff --git a/tests/scheduler-fdset-2a.scm b/tests/scheduler-fdset-2a.scm
new file mode 100644
index 0000000..a1570b7
--- /dev/null
+++ b/tests/scheduler-fdset-2a.scm
@@ -0,0 +1,8 @@
+(use posix tcp)
+
+(define listener (tcp-listen 8123))
+
+(let loop ()
+  (receive (in out)
+    (tcp-accept listener)
+    (write-line "fin" out)))
diff --git a/tests/scheduler-fdset-3.scm b/tests/scheduler-fdset-3.scm
new file mode 100644
index 0000000..d8af767
--- /dev/null
+++ b/tests/scheduler-fdset-3.scm
@@ -0,0 +1,9 @@
+(use posix)
+
+(set-signal-handler! signal/int
+  (lambda (sig)
+    (write-line (read-line))))
+
+(write-line (read-line))
+
+(##sys#thread-yield!)
diff --git a/tests/scheduler-fdset-4.scm b/tests/scheduler-fdset-4.scm
new file mode 100644
index 0000000..6b4b9ae
--- /dev/null
+++ b/tests/scheduler-fdset-4.scm
@@ -0,0 +1,10 @@
+(use posix)
+
+(set-signal-handler! signal/int
+  (lambda (sig)
+    (write-line (read-line))
+    (##sys#thread-yield!)))
+
+(write-line (read-line))
+
+(##sys#thread-yield!)
diff --git a/tests/scheduler-fdset.scm b/tests/scheduler-fdset.scm
new file mode 100644
index 0000000..830c4e2
--- /dev/null
+++ b/tests/scheduler-fdset.scm
@@ -0,0 +1,52 @@
+; Test case to trigger the scheduler assert error:
+; cat: scheduler.c:77: C_fd_ready: Assertion `fd == C_fdset_set[pos].fd' failed.
+;
+; Instructions:
+; 1. Run with cat or csc.
+; 2. Send SIGINT (e.g. with Ctrl-C)
+; 3. The test should write "locking... unlocking... unlocked" and then exit without error.
+;
+; Requires srfi-18 -- if this is removed from core, this test could be written,
+; but it would involve using more low-level procedures.
+(use posix)
+(use srfi-18)
+
+(define m (make-mutex))
+(define o1 #f)
+(define o2 #f)
+
+(define (discard in)
+  (let loop ()
+    (let ((c (read-char in)))
+      (if (not (eof-object? c))
+        (loop)))))
+
+(set-signal-handler!
+  signal/int
+  (lambda (sig)
+    (print "locking...")
+    (mutex-lock! m)
+    (print "unlocking...")
+    ; If we have changed the fd-list in a bad way, a deadlock might occur.
+    ; If the create-fdset code is still skipping the thread, then a scheduler
+    ; assert about the fdset will fail
+    (mutex-unlock! m)
+    (print "unlocked...")  
+          
+    (write-char #\newline o1)
+    (write-char #\newline o2)
+    ))
+
+(thread-start!
+  (make-thread
+    (lambda ()
+      (receive (in out pid) (process "csi" '("-s" "cat.scm"))
+        (set! o1 out)
+        (discard in))))) 
+
+; Make another, just in case...
+(receive (in out pid) (process "csi" '("-s" "cat.scm"))
+  (set! o2 out)
+  (discard in))
+
+(print "done!")
diff --git a/tests/scheduler-test.scm b/tests/scheduler-test.scm
new file mode 100644
index 0000000..54c1ab3
--- /dev/null
+++ b/tests/scheduler-test.scm
@@ -0,0 +1,103 @@
+(use posix irregex)
+
+(define (close-i/o in out)
+  (close-input-port in)
+  (close-output-port out))
+
+(define (process-children pid)
+  (case (build-platform)
+    ((mingw32)
+     (receive (in out pid)
+       (process "wmic" `("process" "where" ,(format "(ParentProcessId=~A)" pid) "get" "ProcessId"))
+       ; Discard "ProcessId" header line.
+       (read-line in)
+       (define children
+         (let loop ((ls '()))
+           (define l (read-line in))
+           (if (or (eof-object? l) (string=? l ""))
+             ls
+             (loop (cons (string->number l) ls)))))
+       (close-i/o in out)
+       children))
+    (else
+      (receive (in out pid)
+        (process "pgrep" `("-P" ,(number->string pid)))
+        (define line (read-line in))
+        (define children '())
+        (unless (eof-object? line)
+          (set! children
+            (map string->number (irregex-split " " line))))
+        (close-i/o in out)
+        children))))
+
+(define (interpret script #!optional (args '()))
+  (process-run "csi" (append `("-s" ,script) args)))
+
+(define (assert-good-exit*! pid normal code)
+  (if (not (and normal (= code 0)))
+    (exit code)))
+
+(define (assert-good-exit! pid)
+  (call-with-values (lambda () (process-wait pid)) assert-good-exit*!))
+
+(define (assert-exited! pid)
+  (receive (pid normal code)
+    (process-wait pid #t)
+    (when (= pid 0)
+      (with-output-to-port (current-error-port)
+        (lambda ()
+          (print "Process did not exit as expected.")
+          (exit 1))))
+    (assert-good-exit*! pid normal code)))
+
+; scheduler-fdset.scm
+(print "=== Test #1")
+(let ((pid (interpret "scheduler-fdset.scm")))
+  (sleep 1)
+  (process-signal pid signal/int)
+  (for-each (lambda (p) (process-signal p signal/int)) (process-children pid))
+  (assert-good-exit! pid))
+(print "=== Test #1 passed!")
+
+; scheduler-fdset-2.scm
+(print "=== Test #2")
+(let ((pid (interpret "scheduler-fdset-2.scm")))
+  (sleep 1)
+  (process-signal pid signal/int)
+  (sleep 2)
+  (assert-exited! pid))
+(print "=== Test #2 passed!")
+
+; scheduler-fdset-3.scm
+(print "=== Test #3")
+(receive (in out pid)
+  (process "csi" '("-s" "scheduler-fdset-3.scm"))
+  (sleep 1)
+  (process-signal pid signal/int)
+  (sleep 1)
+  (process-signal pid signal/int)
+  (sleep 1)
+  (write-line "a" out)
+  (write-line "b" out)
+  (write-line "c" out)
+  (assert (string=? "a" (read-line in)))
+  (assert (string=? "b" (read-line in)))
+  (assert (string=? "c" (read-line in)))
+  (read-line in)
+  (assert-exited! pid))
+(print "=== Test #3 passed!")
+
+; scheduler-fdset-4.scm
+(print "=== Test #4")
+(receive (in out pid)
+  (process "csi" '("-s" "scheduler-fdset-4.scm"))
+  (sleep 1)
+  (process-signal pid signal/int)
+  (sleep 1)
+  (write-line "a" out)
+  (write-line "b" out)
+  (assert (string=? "a" (read-line in)))
+  (assert (string=? "b" (read-line in)))
+  (read-line in)
+  (assert-exited! pid))
+(print "=== Test #4 passed!")
diff --git a/tests/sink.c b/tests/sink.c
new file mode 100644
index 0000000..6c1461b
--- /dev/null
+++ b/tests/sink.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <signal.h>
+
+void ignore(int signal)
+{
+}
+
+int main(int argc, char** argv)
+{
+    signal(SIGINT, ignore);
+
+    char in = getchar();
+    return 0;
+}