0.8.4.10

[sbcl.git] / src / runtime / thread.c

diff --git a/src/runtime/thread.c b/src/runtime/thread.c
index 78a3ec3..206511a 100644 (file)
--- a/src/runtime/thread.c
+++ b/src/runtime/thread.c
@@ -3,6 +3,7 @@
 #include <sched.h>
 #include <signal.h>
 #include <stddef.h>
+#include <errno.h>
 #ifndef CLONE_PARENT           /* lameass glibc 2.2  doesn't define this */
 #define CLONE_PARENT 0x00008000        /* even though the manpage documents it */
 #endif
@@ -23,8 +24,8 @@
 
 int dynamic_values_bytes=4096*sizeof(lispobj); /* same for all threads */
 struct thread *all_threads;
-lispobj all_threads_lock;
-int countdown_to_gc;
+volatile lispobj all_threads_lock;
+volatile int countdown_to_gc;
 extern struct interrupt_data * global_interrupt_data;
 
 void get_spinlock(lispobj *word,int value);
@@ -138,6 +139,7 @@ pid_t create_thread(lispobj initial_function) {
     th->binding_stack_pointer=th->binding_stack_start;
     th->this=th;
     th->pid=0;
+    th->state=STATE_RUNNING;
 #ifdef LISP_FEATURE_STACK_GROWS_DOWNWARD_NOT_UPWARD
     th->alien_stack_pointer=((void *)th->alien_stack_start
                             + ALIEN_STACK_SIZE-4); /* naked 4.  FIXME */
@@ -237,6 +239,7 @@ void destroy_thread (struct thread *th)
 #endif
     get_spinlock(&all_threads_lock,th->pid);
     if(countdown_to_gc>0) countdown_to_gc--;
+    th->state=STATE_STOPPED;
     if(th==all_threads) 
        all_threads=th->next;
     else {
@@ -262,6 +265,10 @@ struct thread *find_thread_by_pid(pid_t pid)
     return 0;
 }
 
+/* These are not needed unless #+SB-THREAD, and since sigwaitinfo()
+ * doesn't seem to be easily available everywhere (OpenBSD...) it's
+ * more trouble than it's worth to compile it when not needed. */
+#if defined LISP_FEATURE_SB_THREAD
 void block_sigcont(void)
 {
     /* don't allow ourselves to receive SIGCONT while we're in the
@@ -269,20 +276,19 @@ void block_sigcont(void)
      */
     sigset_t newset;
     sigemptyset(&newset);
-    sigaddset(&newset,SIGCONT);
+    sigaddset(&newset,SIG_DEQUEUE);
     sigprocmask(SIG_BLOCK, &newset, 0); 
 }
 
-/* This is not needed unless #+SB-THREAD, and since sigwaitinfo()
- * doesn't seem to be easily available everywhere (OpenBSD...) it's
- * more trouble than it's worth to compile it when not needed. */
-#if defined LISP_FEATURE_SB_THREAD
 void unblock_sigcont_and_sleep(void)
 {
     sigset_t set;
     sigemptyset(&set);
-    sigaddset(&set,SIGCONT);
-    sigwaitinfo(&set,0);
+    sigaddset(&set,SIG_DEQUEUE);
+    do {
+       errno=0;
+       sigwaitinfo(&set,0);
+    }while(errno==EINTR);
     sigprocmask(SIG_UNBLOCK,&set,0);
 }
 
@@ -294,6 +300,14 @@ int interrupt_thread(pid_t pid, lispobj function)
     return sigqueue(pid, SIG_INTERRUPT_THREAD, sigval);
 }
 
+/* stopping the world is a two-stage process.  From this thread we signal 
+ * all the others with SIG_STOP_FOR_GC.  The handler for this thread does
+ * the usual pseudo-atomic checks (we don't want to stop a thread while 
+ * it's in the middle of allocation) then kills _itself_ with SIGSTOP.
+ * At any given time, countdown_to_gc should reflect the number of threads
+ * signalled but which haven't yet come to rest
+ */
+
 void gc_stop_the_world()
 {
     /* stop all other threads by sending them SIG_STOP_FOR_GC */
@@ -309,7 +323,20 @@ void gc_stop_the_world()
             * for them on each time around */
            for(p=all_threads;p!=tail;p=p->next) {
                if(p==th) continue;
+               /* if the head of all_threads is removed during
+                * gc_stop_the_world, we may take a second trip through the 
+                * list and end up counting twice as many threads to wait for
+                * as actually exist */
+               if(p->state!=STATE_RUNNING) continue;
                countdown_to_gc++;
+               p->state=STATE_STOPPING;
+               /* Note no return value check from kill().  If the
+                * thread had been reaped already, we kill it and
+                * increment countdown_to_gc anyway.  This is to avoid
+                * complicating the logic in destroy_thread, which would 
+                * otherwise have to know whether the thread died before or
+                * after it was killed
+                */
                kill(p->pid,SIG_STOP_FOR_GC);
            }
            tail=all_threads;
@@ -327,6 +354,7 @@ void gc_start_the_world()
     get_spinlock(&all_threads_lock,th->pid);
     for(p=all_threads;p;p=p->next) {
        if(p==th) continue;
+       p->state=STATE_RUNNING;
        kill(p->pid,SIGCONT);
     }
     release_spinlock(&all_threads_lock);