X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fthread.c;h=71a976e79e945fe907a607c907f829fe3934e2a5;hb=007bcd5aac2f3a1e714563bd39f7a2db2d0bf7c2;hp=e1586801591e56ac236de9d0f41caff73989a5e8;hpb=e5d96999ae4388181ddb0c113313f26afbe997e8;p=sbcl.git

diff --git a/src/runtime/thread.c b/src/runtime/thread.c
index e158680..71a976e 100644
--- a/src/runtime/thread.c
+++ b/src/runtime/thread.c
@@ -133,6 +133,9 @@ initial_thread_trampoline(struct thread *th)
     link_thread(th);
     th->os_thread=thread_self();
 #ifndef LISP_FEATURE_WIN32
+    protect_control_stack_hard_guard_page(1, NULL);
+    protect_binding_stack_hard_guard_page(1, NULL);
+    protect_alien_stack_hard_guard_page(1, NULL);
     protect_control_stack_guard_page(1, NULL);
     protect_binding_stack_guard_page(1, NULL);
     protect_alien_stack_guard_page(1, NULL);
@@ -258,8 +261,8 @@ new_thread_trampoline(struct thread *th)
     int result, lock_ret;
 
     FSHOW((stderr,"/creating thread %lu\n", thread_self()));
-    check_deferrables_blocked_or_lose();
-    check_gc_signals_unblocked_or_lose();
+    check_deferrables_blocked_or_lose(0);
+    check_gc_signals_unblocked_or_lose(0);
     function = th->no_tls_value_marker;
     th->no_tls_value_marker = NO_TLS_VALUE_MARKER_WIDETAG;
     if(arch_os_thread_init(th)==0) {
@@ -284,7 +287,7 @@ new_thread_trampoline(struct thread *th)
     result = funcall0(function);
 
     /* Block GC */
-    block_blockable_signals();
+    block_blockable_signals(0, 0);
     set_thread_state(th, STATE_DEAD);
 
     /* SIG_STOP_FOR_GC is blocked and GC might be waiting for this
@@ -472,6 +475,9 @@ create_thread_struct(lispobj initial_function) {
     }
     th->interrupt_data->pending_handler = 0;
     th->interrupt_data->gc_blocked_deferrables = 0;
+#ifdef LISP_FEATURE_PPC
+    th->interrupt_data->allocation_trap_context = 0;
+#endif
     th->no_tls_value_marker=initial_function;
 
     th->stepping = NIL;
@@ -514,7 +520,7 @@ boolean create_os_thread(struct thread *th,os_thread_t *kid_tid)
     /* Blocking deferrable signals is enough, no need to block
      * SIG_STOP_FOR_GC because the child process is not linked onto
      * all_threads until it's ready. */
-    thread_sigmask(SIG_BLOCK, &deferrable_sigset, &oldset);
+    block_deferrable_signals(0, &oldset);
 
 #ifdef LOCK_CREATE_THREAD
     retcode = pthread_mutex_lock(&create_thread_lock);
@@ -523,13 +529,15 @@ boolean create_os_thread(struct thread *th,os_thread_t *kid_tid)
 #endif
 
     if((initcode = pthread_attr_init(th->os_attr)) ||
-       /* call_into_lisp_first_time switches the stack for the initial thread. For the
-        * others, we use this. */
-       (pthread_attr_setstack(th->os_attr,th->control_stack_start,thread_control_stack_size)) ||
+       /* call_into_lisp_first_time switches the stack for the initial
+        * thread. For the others, we use this. */
+       (pthread_attr_setstack(th->os_attr,th->control_stack_start,
+                              thread_control_stack_size)) ||
        (retcode = pthread_create
         (kid_tid,th->os_attr,(void *(*)(void *))new_thread_trampoline,th))) {
         FSHOW_SIGNAL((stderr, "init = %d\n", initcode));
-        FSHOW_SIGNAL((stderr, printf("pthread_create returned %d, errno %d\n", retcode, errno)));
+        FSHOW_SIGNAL((stderr, "pthread_create returned %d, errno %d\n",
+                      retcode, errno));
         if(retcode < 0) {
             perror("create_os_thread");
         }
@@ -699,7 +707,7 @@ kill_safely(os_thread_t os_thread, int signal)
         struct thread *thread;
         /* pthread_kill is not async signal safe and we don't want to be
          * interrupted while holding the lock. */
-        thread_sigmask(SIG_BLOCK, &deferrable_sigset, &oldset);
+        block_deferrable_signals(0, &oldset);
         pthread_mutex_lock(&all_threads_lock);
         for (thread = all_threads; thread; thread = thread->next) {
             if (thread->os_thread == os_thread) {
@@ -719,7 +727,18 @@ kill_safely(os_thread_t os_thread, int signal)
         int status;
         if (os_thread != 0)
             lose("kill_safely: who do you want to kill? %d?\n", os_thread);
+        /* Dubious (as in don't know why it works) workaround for the
+         * signal sometimes not being generated on darwin. */
+#ifdef LISP_FEATURE_DARWIN
+        {
+            sigset_t oldset;
+            sigprocmask(SIG_BLOCK, &deferrable_sigset, &oldset);
+            status = raise(signal);
+            sigprocmask(SIG_SETMASK,&oldset,0);
+        }
+#else
         status = raise(signal);
+#endif
         if (status == 0) {
             return 0;
         } else {