Changeset 5614

Timestamp:

Dec 14, 2006, 2:50:02 PM (18 years ago)

Author:

Gary Byers

Message:

Go back to using the pseudo_sigreturn mechanism on Darwin, since
doing a real sigreturn from a fake context may not be reliable.

When handling an interrupt with a partially created temp stack
frame, do the right thing. (That basically means reset the
frame before calling out and recreating it if we return from the
callout.)

Handle SIGQUIT on the altstack, to provide a way of forcibly
terminating threads that's a bit more GC-safe than doing it
via #_pthread_cancel.

Note the tcr of the gc thread on gc entry; if an exception
happens in that thread, print a message and sleep for 60
seconds.

Note that there's still a race condition here: if thread A
gets an exception and thread B gets the mach_exception_lock
(to GC) before the exception thread can handle the message,
we deadlock (thread A would be suspended in the kernel and
can't respond to a suspend signal.) We can tell that this
has happened and make a good guess as to why it happened,
but dealing with it will require some thought. (If we've
already issued a suspend signal and eventually raise the
suspended thread's resume semaphore, it'll suspend and resume
once the mach exception thread makes it runnable. Who
cleans up its exception context in that case ? Does it
matter ?)

File:

• trunk/ccl/lisp-kernel/x86-exceptions.c (modified) (16 diffs)

trunk/ccl/lisp-kernel/x86-exceptions.c

@@ -32 +32 @@
 #include <linux/prctl.h>
 #endif
+#ifdef DARWIN
+#include <sysexits.h>
+#endif
+#include <sys/syslog.h>
+
 
 int
@@ -877 +882 @@
   }
   unlock_exception_lock_in_handler(tcr);
+#ifndef DARWIN_USE_PSEUDO_SIGRETURN
   exit_signal_handler(tcr, old_valence);
+#endif
   /* raise_pending_interrupt(tcr); */
 #ifdef DARWIN_GS_HACK
@@ -884 +891 @@
   }
 #endif
+#ifndef DARWIN_USE_PSEUDO_SIGRETURN
   SIGRETURN(context);
+#endif
 }
 
@@ -1058 +1067 @@
           int old_valence;
           signed_natural alloc_displacement = 0;
-          
+          LispObj 
+            *next_tsp = tcr->next_tsp,
+            *save_tsp = tcr->save_tsp,
+            *p,
+            q;
+            
+          if (next_tsp != save_tsp) {
+            tcr->next_tsp = save_tsp;
+          } else {
+            next_tsp = NULL;
+          }
           pc_luser_xp(context, tcr, &alloc_displacement);
           old_valence = prepare_to_wait_for_exception_lock(tcr, context);
@@ -1065 +1084 @@
           if (alloc_displacement) {
             tcr->save_allocptr -= alloc_displacement;
+          }
+          if (next_tsp) {
+            tcr->next_tsp = next_tsp;
+            p = next_tsp;
+            while (p != save_tsp) {
+              *p++ = 0;
+            }
+            q = (LispObj)save_tsp;
+            *next_tsp = q;
           }
           unlock_exception_lock_in_handler(tcr);
@@ -1217 +1245 @@
 
 void
+quit_handler(int signum, siginfo_t info, ExceptionInformation *xp)
+{
+  TCR *tcr = get_tcr(false);
+  area *a;
+  sigset_t mask;
+  
+  sigemptyset(&mask);
+
+
+  if (tcr) {
+    tcr->valence = TCR_STATE_FOREIGN;
+    a = tcr->vs_area;
+    if (a) {
+      a->active = a->high;
+    }
+    a = tcr->ts_area;
+    if (a) {
+      a->active = a->high;
+    }
+    a = tcr->cs_area;
+    if (a) {
+      a->active = a->high;
+    }
+  }
+  
+  pthread_sigmask(SIG_SETMASK,&mask,NULL);
+  pthread_exit(NULL);
+}
+
+void
+altstack_quit_handler(int signum, siginfo_t *info, ExceptionInformation *context)
+{
+#ifdef DARWIN_GS_HACK
+  Boolean gs_was_tcr = ensure_gs_pthread();
+#endif
+  TCR* tcr = get_tcr(true);
+  LispObj *foreign_rsp = find_foreign_rsp(xpGPR(context,Isp), tcr->cs_area, tcr);
+#ifdef LINUX
+  fpregset_t fpregs = NULL;
+#else
+  void *fpregs = NULL;
+#endif
+#ifdef DARWIN
+  MCONTEXT_T mcontextp = NULL;
+#endif
+
+  siginfo_t *info_copy = NULL;
+  ExceptionInformation *xp = NULL;
+
+  if (foreign_rsp) {
+#ifdef LINUX
+    foreign_rsp = copy_fpregs(context, foreign_rsp, &fpregs);
+#endif
+#ifdef DARWIN
+    foreign_rsp = copy_darwin_mcontext(UC_MCONTEXT(context), foreign_rsp, &mcontextp);
+#endif
+    foreign_rsp = copy_siginfo(info, foreign_rsp);
+    info_copy = (siginfo_t *)foreign_rsp;
+    foreign_rsp = copy_ucontext(context, foreign_rsp, fpregs);
+    xp = (ExceptionInformation *)foreign_rsp;
+#ifdef DARWIN
+    UC_MCONTEXT(xp) = mcontextp;
+#endif
+    *--foreign_rsp = (LispObj)__builtin_return_address(0);
+    switch_to_foreign_stack(foreign_rsp,quit_handler,signum,info_copy,xp);
+  }
+}
+
+void
 thread_signal_setup()
 {
@@ -1224 +1321 @@
   install_signal_handler(thread_suspend_signal, (void *)altstack_suspend_resume_handler);
   install_signal_handler(thread_resume_signal, (void *)altstack_suspend_resume_handler);
+  install_signal_handler(SIGQUIT, (void *)altstack_quit_handler);
 }
 
@@ -1523 +1621 @@
    function returned */
 
+TCR *gc_tcr = NULL;
+
 int
 gc_like_from_xp(ExceptionInformation *xp, 
@@ -1542 +1642 @@
     return 0;
   }
+
+  gc_tcr = tcr;
 
   /* This is generally necessary if the current thread invoked the GC
@@ -1577 +1679 @@
     other_tcr = other_tcr->next;
   } while (other_tcr != tcr);
+
+  gc_tcr = NULL;
 
   resume_other_threads(true);
@@ -2008 +2112 @@
 #else
 #define ts_pc(t) t.eip
+#endif
+
+#ifdef DARWIN_USE_PSEUDO_SIGRETURN
+#define DARWIN_EXCEPTION_HANDLER signal_handler
+#else
+#define DARWIN_EXCEPTION_HANDLER pseudo_signal_handler
 #endif
 
@@ -2088 +2198 @@
       if (signum) {
         kret = setup_signal_frame(thread,
-                                  (void *)pseudo_signal_handler,
+                                  (void *)DARWIN_EXCEPTION_HANDLER,
                                   signum,
                                   code,
@@ -2107 +2217 @@
   } else {
     SET_TCR_FLAG(tcr,TCR_FLAG_BIT_PENDING_EXCEPTION);
+      
 #if 0
     fprintf(stderr, "deferring pending exception in 0x%x\n", tcr);
 #endif
     kret = 0;
+    if (tcr == gc_tcr) {
+      int i;
+      write(1, "exception in GC thread. Sleeping for 60 seconds\n",sizeof("exception in GC thread.  Sleeping for 60 seconds\n"));
+      for (i = 0; i < 60; i++) {
+        sleep(1);
+      }
+      _exit(EX_SOFTWARE);
+    }
   }
   return kret;
@@ -2117 +2236 @@
 
 
+
+static mach_port_t mach_exception_thread = (mach_port_t)0;
 
 
@@ -2129 +2250 @@
   mach_port_t p = TCR_TO_EXCEPTION_PORT(arg);
 
+  mach_exception_thread = pthread_mach_thread_np(pthread_self());
   mach_msg_server(exc_server, 256, p, 0);
   /* Should never return. */
@@ -2134 +2256 @@
 }
 
+
+
+void
+mach_exception_thread_shutdown()
+{
+  kern_return_t kret;
+
+  fprintf(stderr, "terminating Mach exception thread, 'cause exit can't\n");
+  kret = thread_terminate(mach_exception_thread);
+  if (kret != KERN_SUCCESS) {
+    fprintf(stderr, "Couldn't terminate exception thread, kret = %d\n",kret);
+  }
+}