X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fthread.c;h=7a18c5a4205646119bf6c83ef4865b7c4c42f8bb;hb=90eeb9ca5bff9292afafe82a6d2139964e24f691;hp=71a976e79e945fe907a607c907f829fe3934e2a5;hpb=121a6e2e935db79d09b5e687bd4380fbaa17ed93;p=sbcl.git

diff --git a/src/runtime/thread.c b/src/runtime/thread.c
index 71a976e..7a18c5a 100644
--- a/src/runtime/thread.c
+++ b/src/runtime/thread.c
@@ -33,7 +33,6 @@
 
 #include "runtime.h"
 #include "validate.h"           /* for BINDING_STACK_SIZE etc */
-#include "alloc.h"
 #include "thread.h"
 #include "arch.h"
 #include "target-arch-os.h"
@@ -43,6 +42,7 @@
 #include "genesis/cons.h"
 #include "genesis/fdefn.h"
 #include "interr.h"             /* for lose() */
+#include "alloc.h"
 #include "gc-internal.h"
 
 #ifdef LISP_FEATURE_WIN32
@@ -92,6 +92,7 @@ static pthread_mutex_t create_thread_lock = PTHREAD_MUTEX_INITIALIZER;
 #ifdef LISP_FEATURE_GCC_TLS
 __thread struct thread *current_thread;
 #endif
+pthread_key_t lisp_thread = 0;
 #endif
 
 #if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
@@ -118,6 +119,80 @@ unlink_thread(struct thread *th)
     if (th->next)
         th->next->prev = th->prev;
 }
+
+/* Only access thread state with blockables blocked. */
+lispobj
+thread_state(struct thread *thread)
+{
+    lispobj state;
+    sigset_t old;
+    block_blockable_signals(NULL, &old);
+    os_sem_wait(thread->state_sem, "thread_state");
+    state = thread->state;
+    os_sem_post(thread->state_sem, "thread_state");
+    thread_sigmask(SIG_SETMASK, &old, NULL);
+    return state;
+}
+
+void
+set_thread_state(struct thread *thread, lispobj state)
+{
+    int i, waitcount = 0;
+    sigset_t old;
+    block_blockable_signals(NULL, &old);
+    os_sem_wait(thread->state_sem, "set_thread_state");
+    if (thread->state != state) {
+        if ((STATE_STOPPED==state) ||
+            (STATE_DEAD==state)) {
+            waitcount = thread->state_not_running_waitcount;
+            thread->state_not_running_waitcount = 0;
+            for (i=0; i<waitcount; i++)
+                os_sem_post(thread->state_not_running_sem, "set_thread_state (not running)");
+        }
+        if ((STATE_RUNNING==state) ||
+            (STATE_DEAD==state)) {
+            waitcount = thread->state_not_stopped_waitcount;
+            thread->state_not_stopped_waitcount = 0;
+            for (i=0; i<waitcount; i++)
+                os_sem_post(thread->state_not_stopped_sem, "set_thread_state (not stopped)");
+        }
+        thread->state = state;
+    }
+    os_sem_post(thread->state_sem, "set_thread_state");
+    thread_sigmask(SIG_SETMASK, &old, NULL);
+}
+
+void
+wait_for_thread_state_change(struct thread *thread, lispobj state)
+{
+    sigset_t old;
+    os_sem_t *wait_sem;
+    block_blockable_signals(NULL, &old);
+  start:
+    os_sem_wait(thread->state_sem, "wait_for_thread_state_change");
+    if (thread->state == state) {
+        switch (state) {
+        case STATE_RUNNING:
+            wait_sem = thread->state_not_running_sem;
+            thread->state_not_running_waitcount++;
+            break;
+        case STATE_STOPPED:
+            wait_sem = thread->state_not_stopped_sem;
+            thread->state_not_stopped_waitcount++;
+            break;
+        default:
+            lose("Invalid state in wait_for_thread_state_change: "OBJ_FMTX"\n", state);
+        }
+    } else {
+        wait_sem = NULL;
+    }
+    os_sem_post(thread->state_sem, "wait_for_thread_state_change");
+    if (wait_sem) {
+        os_sem_wait(wait_sem, "wait_for_thread_state_change");
+        goto start;
+    }
+    thread_sigmask(SIG_SETMASK, &old, NULL);
+}
 #endif
 
 static int
@@ -127,6 +202,13 @@ initial_thread_trampoline(struct thread *th)
 #if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
     lispobj *args = NULL;
 #endif
+#ifdef LISP_FEATURE_SB_THREAD
+    pthread_setspecific(lisp_thread, (void *)1);
+#endif
+#if defined(LISP_FEATURE_SB_THREAD) && defined(LISP_FEATURE_PPC)
+    /* SIG_STOP_FOR_GC defaults to blocked on PPC? */
+    unblock_gc_signals(0,0);
+#endif
     function = th->no_tls_value_marker;
     th->no_tls_value_marker = NO_TLS_VALUE_MARKER_WIDETAG;
     if(arch_os_thread_init(th)==0) return 1;
@@ -150,7 +232,7 @@ initial_thread_trampoline(struct thread *th)
 
 #ifdef LISP_FEATURE_SB_THREAD
 #define THREAD_STATE_LOCK_SIZE \
-    (sizeof(pthread_mutex_t))+(sizeof(pthread_cond_t))
+    ((sizeof(os_sem_t))+(sizeof(os_sem_t))+(sizeof(os_sem_t)))
 #else
 #define THREAD_STATE_LOCK_SIZE 0
 #endif
@@ -263,6 +345,7 @@ new_thread_trampoline(struct thread *th)
     FSHOW((stderr,"/creating thread %lu\n", thread_self()));
     check_deferrables_blocked_or_lose(0);
     check_gc_signals_unblocked_or_lose(0);
+    pthread_setspecific(lisp_thread, (void *)1);
     function = th->no_tls_value_marker;
     th->no_tls_value_marker = NO_TLS_VALUE_MARKER_WIDETAG;
     if(arch_os_thread_init(th)==0) {
@@ -301,20 +384,21 @@ new_thread_trampoline(struct thread *th)
     gc_assert(lock_ret == 0);
 
     if(th->tls_cookie>=0) arch_os_thread_cleanup(th);
-    pthread_mutex_destroy(th->state_lock);
-    pthread_cond_destroy(th->state_cond);
+    os_sem_destroy(th->state_sem);
+    os_sem_destroy(th->state_not_running_sem);
+    os_sem_destroy(th->state_not_stopped_sem);
 
     os_invalidate((os_vm_address_t)th->interrupt_data,
                   (sizeof (struct interrupt_data)));
 
 #ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
     FSHOW((stderr, "Deallocating mach port %x\n", THREAD_STRUCT_TO_EXCEPTION_PORT(th)));
-    mach_port_move_member(mach_task_self(),
+    mach_port_move_member(current_mach_task,
                           THREAD_STRUCT_TO_EXCEPTION_PORT(th),
                           MACH_PORT_NULL);
-    mach_port_deallocate(mach_task_self(),
+    mach_port_deallocate(current_mach_task,
                          THREAD_STRUCT_TO_EXCEPTION_PORT(th));
-    mach_port_destroy(mach_task_self(),
+    mach_port_destroy(current_mach_task,
                       THREAD_STRUCT_TO_EXCEPTION_PORT(th));
 #endif
 
@@ -335,6 +419,12 @@ free_thread_struct(struct thread *th)
                   THREAD_STRUCT_SIZE);
 }
 
+#ifdef LISP_FEATURE_SB_THREAD
+/* FIXME: should be MAX_INTERRUPTS -1 ? */
+const unsigned int tls_index_start =
+  MAX_INTERRUPTS + sizeof(struct thread)/sizeof(lispobj);
+#endif
+
 /* this is called from any other thread to create the new one, and
  * initialize all parts of it that can be initialized from another
  * thread
@@ -378,23 +468,22 @@ create_thread_struct(lispobj initial_function) {
         per_thread->dynamic_values[i] = NO_TLS_VALUE_MARKER_WIDETAG;
     if (all_threads == 0) {
         if(SymbolValue(FREE_TLS_INDEX,0)==UNBOUND_MARKER_WIDETAG) {
-            SetSymbolValue
-                (FREE_TLS_INDEX,
-                 /* FIXME: should be MAX_INTERRUPTS -1 ? */
-                 make_fixnum(MAX_INTERRUPTS+
-                             sizeof(struct thread)/sizeof(lispobj)),
-                 0);
+            SetSymbolValue(FREE_TLS_INDEX,tls_index_start << WORD_SHIFT,0);
             SetSymbolValue(TLS_INDEX_LOCK,make_fixnum(0),0);
         }
 #define STATIC_TLS_INIT(sym,field) \
   ((struct symbol *)(sym-OTHER_POINTER_LOWTAG))->tls_index= \
-  make_fixnum(THREAD_SLOT_OFFSET_WORDS(field))
+  (THREAD_SLOT_OFFSET_WORDS(field) << WORD_SHIFT)
 
         STATIC_TLS_INIT(BINDING_STACK_START,binding_stack_start);
+#ifdef BINDING_STACK_POINTER
         STATIC_TLS_INIT(BINDING_STACK_POINTER,binding_stack_pointer);
+#endif
         STATIC_TLS_INIT(CONTROL_STACK_START,control_stack_start);
         STATIC_TLS_INIT(CONTROL_STACK_END,control_stack_end);
+#ifdef ALIEN_STACK
         STATIC_TLS_INIT(ALIEN_STACK,alien_stack_pointer);
+#endif
 #if defined(LISP_FEATURE_X86) || defined (LISP_FEATURE_X86_64)
         STATIC_TLS_INIT(PSEUDO_ATOMIC_BITS,pseudo_atomic_bits);
 #endif
@@ -408,19 +497,24 @@ create_thread_struct(lispobj initial_function) {
     th->binding_stack_start=
         (lispobj*)((void*)th->control_stack_start+thread_control_stack_size);
     th->control_stack_end = th->binding_stack_start;
+    th->control_stack_guard_page_protected = T;
     th->alien_stack_start=
         (lispobj*)((void*)th->binding_stack_start+BINDING_STACK_SIZE);
-    th->binding_stack_pointer=th->binding_stack_start;
+    set_binding_stack_pointer(th,th->binding_stack_start);
     th->this=th;
     th->os_thread=0;
 #ifdef LISP_FEATURE_SB_THREAD
     th->os_attr=malloc(sizeof(pthread_attr_t));
-    th->state_lock=(pthread_mutex_t *)((void *)th->alien_stack_start +
-                                       ALIEN_STACK_SIZE);
-    pthread_mutex_init(th->state_lock, NULL);
-    th->state_cond=(pthread_cond_t *)((void *)th->state_lock +
-                                      (sizeof(pthread_mutex_t)));
-    pthread_cond_init(th->state_cond, NULL);
+    th->state_sem=(os_sem_t *)((void *)th->alien_stack_start + ALIEN_STACK_SIZE);
+    th->state_not_running_sem=(os_sem_t *)
+        ((void *)th->state_sem + (sizeof(os_sem_t)));
+    th->state_not_stopped_sem=(os_sem_t *)
+        ((void *)th->state_not_running_sem + (sizeof(os_sem_t)));
+    th->state_not_running_waitcount = 0;
+    th->state_not_stopped_waitcount = 0;
+    os_sem_init(th->state_sem, 1);
+    os_sem_init(th->state_not_running_sem, 0);
+    os_sem_init(th->state_not_stopped_sem, 0);
 #endif
     th->state=STATE_RUNNING;
 #ifdef LISP_FEATURE_STACK_GROWS_DOWNWARD_NOT_UPWARD
@@ -429,12 +523,22 @@ create_thread_struct(lispobj initial_function) {
 #else
     th->alien_stack_pointer=((void *)th->alien_stack_start);
 #endif
-#if defined(LISP_FEATURE_X86) || defined (LISP_FEATURE_X86_64)
+#if defined(LISP_FEATURE_X86) || defined (LISP_FEATURE_X86_64) || defined(LISP_FEATURE_SB_THREAD)
     th->pseudo_atomic_bits=0;
 #endif
 #ifdef LISP_FEATURE_GENCGC
     gc_set_region_empty(&th->alloc_region);
 #endif
+#ifdef LISP_FEATURE_SB_THREAD
+    /* This parallels the same logic in globals.c for the
+     * single-threaded foreign_function_call_active, KLUDGE and
+     * all. */
+#if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
+    th->foreign_function_call_active = 0;
+#else
+    th->foreign_function_call_active = 1;
+#endif
+#endif
 
 #ifndef LISP_FEATURE_SB_THREAD
     /* the tls-points-into-struct-thread trick is only good for threaded
@@ -447,12 +551,8 @@ create_thread_struct(lispobj initial_function) {
     SetSymbolValue(CONTROL_STACK_START,(lispobj)th->control_stack_start,th);
     SetSymbolValue(CONTROL_STACK_END,(lispobj)th->control_stack_end,th);
 #if defined(LISP_FEATURE_X86) || defined (LISP_FEATURE_X86_64)
-    SetSymbolValue(BINDING_STACK_POINTER,(lispobj)th->binding_stack_pointer,th);
     SetSymbolValue(ALIEN_STACK,(lispobj)th->alien_stack_pointer,th);
     SetSymbolValue(PSEUDO_ATOMIC_BITS,(lispobj)th->pseudo_atomic_bits,th);
-#else
-    current_binding_stack_pointer=th->binding_stack_pointer;
-    current_control_stack_pointer=th->control_stack_start;
 #endif
 #endif
     bind_variable(CURRENT_CATCH_BLOCK,make_fixnum(0),th);
@@ -463,9 +563,15 @@ create_thread_struct(lispobj initial_function) {
     bind_variable(ALLOW_WITH_INTERRUPTS,T,th);
     bind_variable(GC_PENDING,NIL,th);
     bind_variable(ALLOC_SIGNAL,NIL,th);
+#ifdef PINNED_OBJECTS
+    bind_variable(PINNED_OBJECTS,NIL,th);
+#endif
 #ifdef LISP_FEATURE_SB_THREAD
     bind_variable(STOP_FOR_GC_PENDING,NIL,th);
 #endif
+#ifndef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
+    access_control_stack_pointer(th)=th->control_stack_start;
+#endif
 
     th->interrupt_data = (struct interrupt_data *)
         os_validate(0,(sizeof (struct interrupt_data)));
@@ -492,10 +598,10 @@ kern_return_t mach_thread_init(mach_port_t thread_exception_port);
 
 void create_initial_thread(lispobj initial_function) {
     struct thread *th=create_thread_struct(initial_function);
-    if(th) {
-#ifdef LISP_FEATURE_MACH_EXCEPTION_HANDLER
-        setup_mach_exception_handling_thread();
+#ifdef LISP_FEATURE_SB_THREAD
+    pthread_key_create(&lisp_thread, 0);
 #endif
+    if(th) {
         initial_thread_trampoline(th); /* no return */
     } else lose("can't create initial thread\n");
 }
@@ -649,7 +755,7 @@ void gc_start_the_world()
         if (p!=th) {
             lispobj state = thread_state(p);
             if (state != STATE_DEAD) {
-                if(state != STATE_SUSPENDED) {
+                if(state != STATE_STOPPED) {
                     lose("gc_start_the_world: wrong thread state is %d\n",
                          fixnum_value(state));
                 }