X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Finterrupt.c;h=f63dbf972387477bc156a4e00f8832c2d502d0a6;hb=e9c546b14771ebe96447c3920a75e9e580f9075f;hp=6824f3b9b9a6c3fc75e921714856dbc95c0ca424;hpb=4a3c4dc2899b799cbfa4f76dfc80123dc855f281;p=sbcl.git

diff --git a/src/runtime/interrupt.c b/src/runtime/interrupt.c
index 6824f3b..f63dbf9 100644
--- a/src/runtime/interrupt.c
+++ b/src/runtime/interrupt.c
@@ -63,6 +63,7 @@
 #include "alloc.h"
 #include "dynbind.h"
 #include "interr.h"
+#include "pseudo-atomic.h"
 #include "genesis/fdefn.h"
 #include "genesis/simple-fun.h"
 #include "genesis/cons.h"
@@ -74,6 +75,15 @@ static void store_signal_data_for_later (struct interrupt_data *data,
                                          siginfo_t *info,
                                          os_context_t *context);
 
+static void
+fill_current_sigmask(sigset_t *sigset)
+{
+    /* Get the current sigmask, by blocking the empty set. */
+    sigset_t empty;
+    sigemptyset(&empty);
+    thread_sigmask(SIG_BLOCK, &empty, sigset);
+}
+
 void
 sigaddset_deferrable(sigset_t *s)
 {
@@ -95,25 +105,17 @@ sigaddset_deferrable(sigset_t *s)
     sigaddset(s, SIGPROF);
     sigaddset(s, SIGWINCH);
 
-#if !((defined(LISP_FEATURE_DARWIN) || defined(LISP_FEATURE_FREEBSD)) && defined(LISP_FEATURE_SB_THREAD))
-    sigaddset(s, SIGUSR1);
-    sigaddset(s, SIGUSR2);
-#endif
-
 #ifdef LISP_FEATURE_SB_THREAD
     sigaddset(s, SIG_INTERRUPT_THREAD);
 #endif
 }
 
 void
-sigaddset_blockable(sigset_t *s)
+sigaddset_blockable(sigset_t *sigset)
 {
-    sigaddset_deferrable(s);
+    sigaddset_deferrable(sigset);
 #ifdef LISP_FEATURE_SB_THREAD
-#ifdef SIG_RESUME_FROM_GC
-    sigaddset(s, SIG_RESUME_FROM_GC);
-#endif
-    sigaddset(s, SIG_STOP_FOR_GC);
+    sigaddset(sigset,SIG_STOP_FOR_GC);
 #endif
 }
 
@@ -123,6 +125,40 @@ sigset_t blockable_sigset;
 #endif
 
 void
+check_deferrables_unblocked_in_sigset_or_lose(sigset_t *sigset)
+{
+#if !defined(LISP_FEATURE_WIN32)
+    int i;
+    for(i = 1; i < NSIG; i++) {
+        if (sigismember(&deferrable_sigset, i) && sigismember(sigset, i))
+            lose("deferrable signal %d blocked\n",i);
+    }
+#endif
+}
+
+void
+check_deferrables_blocked_in_sigset_or_lose(sigset_t *sigset)
+{
+#if !defined(LISP_FEATURE_WIN32)
+    int i;
+    for(i = 1; i < NSIG; i++) {
+        if (sigismember(&deferrable_sigset, i) && !sigismember(sigset, i))
+            lose("deferrable signal %d not blocked\n",i);
+    }
+#endif
+}
+
+void
+check_deferrables_blocked_or_lose(void)
+{
+#if !defined(LISP_FEATURE_WIN32)
+    sigset_t current;
+    fill_current_sigmask(&current);
+    check_deferrables_blocked_in_sigset_or_lose(&current);
+#endif
+}
+
+void
 check_blockables_blocked_or_lose(void)
 {
 #if !defined(LISP_FEATURE_WIN32)
@@ -162,6 +198,76 @@ check_interrupts_enabled_or_lose(os_context_t *context)
         lose ("in pseudo atomic section\n");
 }
 
+/* Are we leaving WITH-GCING and already running with interrupts
+ * enabled, without the protection of *GC-INHIBIT* T and there is gc
+ * (or stop for gc) pending, but we haven't trapped yet? */
+int
+in_leaving_without_gcing_race_p(struct thread *thread)
+{
+    return ((SymbolValue(IN_WITHOUT_GCING,thread) != NIL) &&
+            (SymbolValue(INTERRUPTS_ENABLED,thread) != NIL) &&
+            (SymbolValue(GC_INHIBIT,thread) == NIL) &&
+            ((SymbolValue(GC_PENDING,thread) != NIL)
+#if defined(LISP_FEATURE_SB_THREAD)
+             || (SymbolValue(STOP_FOR_GC_PENDING,thread) != NIL)
+#endif
+             ));
+}
+
+/* Check our baroque invariants. */
+void
+check_interrupt_context_or_lose(os_context_t *context)
+{
+    struct thread *thread = arch_os_get_current_thread();
+    struct interrupt_data *data = thread->interrupt_data;
+    int interrupt_deferred_p = (data->pending_handler != 0);
+    int interrupt_pending = (SymbolValue(INTERRUPT_PENDING,thread) != NIL);
+    /* On PPC pseudo_atomic_interrupted is cleared when coming out of
+     * handle_allocation_trap. */
+#if defined(LISP_FEATURE_GENCGC) && !defined(LISP_FEATURE_PPC)
+#if 0
+    int interrupts_enabled = (SymbolValue(INTERRUPTS_ENABLED,thread) != NIL);
+#endif
+    int gc_inhibit = (SymbolValue(GC_INHIBIT,thread) != NIL);
+    int gc_pending = (SymbolValue(GC_PENDING,thread) == T);
+    int pseudo_atomic_interrupted = get_pseudo_atomic_interrupted(thread);
+    int in_race_p = in_leaving_without_gcing_race_p(thread);
+    /* In the time window between leaving the *INTERRUPTS-ENABLED* NIL
+     * section and trapping, a SIG_STOP_FOR_GC would see the next
+     * check fail, for this reason sig_stop_for_gc handler does not
+     * call this function. Plus, there may be interrupt lossage when a
+     * pseudo atomic is interrupted by a deferrable signal and gc is
+     * triggered, too. */
+#if 0
+    if (interrupt_deferred_p)
+        if (!(!interrupts_enabled || pseudo_atomic_interrupted || in_race_p))
+            lose("Stray deferred interrupt.");
+#endif
+#if 0
+    if (gc_pending)
+        if (!(pseudo_atomic_interrupted || gc_inhibit || in_race_p))
+            lose("GC_PENDING, but why?.");
+#if defined(LISP_FEATURE_SB_THREAD)
+    {
+        int stop_for_gc_pending =
+            (SymbolValue(STOP_FOR_GC_PENDING,thread) != NIL);
+        if (stop_for_gc_pending)
+            if (!(pseudo_atomic_interrupted || gc_inhibit || in_race_p))
+                lose("STOP_FOR_GC_PENDING, but why?.");
+    }
+#endif
+#endif
+#endif
+    if (interrupt_pending && !interrupt_deferred_p)
+        lose("INTERRUPT_PENDING but not pending handler.");
+    if (interrupt_deferred_p)
+        check_deferrables_blocked_in_sigset_or_lose
+            (os_context_sigmask_addr(context));
+    else
+        check_deferrables_unblocked_in_sigset_or_lose
+            (os_context_sigmask_addr(context));
+}
+
 /* When we catch an internal error, should we pass it back to Lisp to
  * be handled in a high-level way? (Early in cold init, the answer is
  * 'no', because Lisp is still too brain-dead to handle anything.
@@ -174,33 +280,27 @@ static void (*interrupt_low_level_handlers[NSIG]) (int, siginfo_t*, void*);
 #endif
 union interrupt_handler interrupt_handlers[NSIG];
 
-/* At the toplevel repl we routinely call this function.  The signal
- * mask ought to be clear anyway most of the time, but may be non-zero
- * if we were interrupted e.g. while waiting for a queue.  */
-
 void
-reset_signal_mask(void)
+block_blockable_signals(void)
 {
 #ifndef LISP_FEATURE_WIN32
-    sigset_t new;
-    sigemptyset(&new);
-    thread_sigmask(SIG_SETMASK,&new,0);
+    thread_sigmask(SIG_BLOCK, &blockable_sigset, 0);
 #endif
 }
 
 void
-block_blockable_signals(void)
+block_deferrable_signals(void)
 {
 #ifndef LISP_FEATURE_WIN32
-    thread_sigmask(SIG_BLOCK, &blockable_sigset, 0);
+    thread_sigmask(SIG_BLOCK, &deferrable_sigset, 0);
 #endif
 }
 
 void
-block_deferrable_signals(void)
+unblock_deferrable_signals(void)
 {
 #ifndef LISP_FEATURE_WIN32
-    thread_sigmask(SIG_BLOCK, &deferrable_sigset, 0);
+    thread_sigmask(SIG_UNBLOCK, &deferrable_sigset, 0);
 #endif
 }
 
@@ -374,6 +474,16 @@ interrupt_internal_error(os_context_t *context, boolean continuable)
     thread_sigmask(SIG_SETMASK, os_context_sigmask_addr(context), 0);
 #endif
 
+#if defined(LISP_FEATURE_LINUX) && defined(LISP_FEATURE_MIPS)
+    /* Workaround for blocked SIGTRAP. */
+    {
+        sigset_t newset;
+        sigemptyset(&newset);
+        sigaddset(&newset, SIGTRAP);
+        thread_sigmask(SIG_UNBLOCK, &newset, 0);
+    }
+#endif
+
     SHOW("in interrupt_internal_error");
 #ifdef QSHOW
     /* Display some rudimentary debugging information about the
@@ -407,14 +517,8 @@ interrupt_handle_pending(os_context_t *context)
 
     struct thread *thread;
 
-    /* Punt if in PA section, marking it as interrupted. This can
-     * happenat least if we pick up a GC request while in a
-     * WITHOUT-GCING with an outer PA -- it is not immediately clear
-     * to me that this should/could ever happen, but better safe then
-     * sorry. --NS 2007-05-15 */
     if (arch_pseudo_atomic_atomic(context)) {
-        arch_set_pseudo_atomic_interrupted(context);
-        return;
+        lose("Handling pending interrupt in pseduo atomic.");
     }
 
     thread = arch_os_get_current_thread();
@@ -435,7 +539,10 @@ interrupt_handle_pending(os_context_t *context)
             sig_stop_for_gc_handler(SIG_STOP_FOR_GC,NULL,context);
         } else
 #endif
-        if (SymbolValue(GC_PENDING,thread) != NIL) {
+         /* Test for T and not for != NIL since the value :IN-PROGRESS
+          * is used in SUB-GC as part of the mechanism to supress
+          * recursive gcs.*/
+        if (SymbolValue(GC_PENDING,thread) == T) {
             /* GC_PENDING is cleared in SUB-GC, or if another thread
              * is doing a gc already we will get a SIG_STOP_FOR_GC and
              * that will clear it. */
@@ -471,7 +578,6 @@ interrupt_handle_pending(os_context_t *context)
              * blocked signals are unblocked */
             sigcopyset(os_context_sigmask_addr(context), &data->pending_mask);
 
-            sigemptyset(&data->pending_mask);
             /* This will break on sparc linux: the deferred handler really wants
              * to be called with a void_context */
             run_deferred_handler(data,(void *)context);
@@ -632,16 +738,23 @@ maybe_defer_handler(void *handler, struct interrupt_data *data,
 
     if (SymbolValue(INTERRUPT_PENDING,thread) != NIL)
         lose("interrupt already pending\n");
+    check_interrupt_context_or_lose(context);
     /* If interrupts are disabled then INTERRUPT_PENDING is set and
      * not PSEDUO_ATOMIC_INTERRUPTED. This is important for a pseudo
      * atomic section inside a WITHOUT-INTERRUPTS.
+     *
+     * Also, if in_leaving_without_gcing_race_p then
+     * interrupt_handle_pending is going to be called soon, so
+     * stashing the signal away is safe.
      */
-    if (SymbolValue(INTERRUPTS_ENABLED,thread) == NIL) {
+    if ((SymbolValue(INTERRUPTS_ENABLED,thread) == NIL) ||
+        in_leaving_without_gcing_race_p(thread)) {
         store_signal_data_for_later(data,handler,signal,info,context);
         SetSymbolValue(INTERRUPT_PENDING, T,thread);
         FSHOW_SIGNAL((stderr,
                       "/maybe_defer_handler(%x,%d): deferred\n",
                       (unsigned int)handler,signal));
+        check_interrupt_context_or_lose(context);
         return 1;
     }
     /* a slightly confusing test. arch_pseudo_atomic_atomic() doesn't
@@ -653,6 +766,7 @@ maybe_defer_handler(void *handler, struct interrupt_data *data,
         FSHOW_SIGNAL((stderr,
                       "/maybe_defer_handler(%x,%d): deferred(PA)\n",
                       (unsigned int)handler,signal));
+        check_interrupt_context_or_lose(context);
         return 1;
     }
     FSHOW_SIGNAL((stderr,
@@ -743,15 +857,16 @@ sig_stop_for_gc_handler(int signal, siginfo_t *info, void *void_context)
     struct thread *thread=arch_os_get_current_thread();
     sigset_t ss;
 
-    if (arch_pseudo_atomic_atomic(context)) {
+    /* Test for GC_INHIBIT _first_, else we'd trap on every single
+     * pseudo atomic until gc is finally allowed. */
+    if (SymbolValue(GC_INHIBIT,thread) != NIL) {
         SetSymbolValue(STOP_FOR_GC_PENDING,T,thread);
-        arch_set_pseudo_atomic_interrupted(context);
-        FSHOW_SIGNAL((stderr, "sig_stop_for_gc deferred (PA)\n"));
+        FSHOW_SIGNAL((stderr, "sig_stop_for_gc deferred (*GC-INHIBIT*)\n"));
         return;
-    }
-    else if (SymbolValue(GC_INHIBIT,thread) != NIL) {
+    } else if (arch_pseudo_atomic_atomic(context)) {
         SetSymbolValue(STOP_FOR_GC_PENDING,T,thread);
-        FSHOW_SIGNAL((stderr, "sig_stop_for_gc deferred (*GC-INHIBIT*)\n"));
+        arch_set_pseudo_atomic_interrupted(context);
+        FSHOW_SIGNAL((stderr,"sig_stop_for_gc deferred (PA)\n"));
         return;
     }
 
@@ -768,41 +883,25 @@ sig_stop_for_gc_handler(int signal, siginfo_t *info, void *void_context)
     SetSymbolValue(GC_PENDING,NIL,thread);
     SetSymbolValue(STOP_FOR_GC_PENDING,NIL,thread);
 
-    if(thread->state!=STATE_RUNNING) {
+    if(thread_state(thread)!=STATE_RUNNING) {
         lose("sig_stop_for_gc_handler: wrong thread state: %ld\n",
              fixnum_value(thread->state));
     }
 
-    thread->state=STATE_SUSPENDED;
+    set_thread_state(thread,STATE_SUSPENDED);
     FSHOW_SIGNAL((stderr,"suspended\n"));
 
-    sigemptyset(&ss);
-#if defined(SIG_RESUME_FROM_GC)
-    sigaddset(&ss,SIG_RESUME_FROM_GC);
-#else
-    sigaddset(&ss,SIG_STOP_FOR_GC);
-#endif
-
-    /* It is possible to get SIGCONT (and probably other non-blockable
-     * signals) here. */
-#ifdef SIG_RESUME_FROM_GC
-    {
-        int sigret;
-        do { sigwait(&ss, &sigret); }
-        while (sigret != SIG_RESUME_FROM_GC);
-    }
-#else
-    while (sigwaitinfo(&ss,0) != SIG_STOP_FOR_GC);
-#endif
-
+    wait_for_thread_state_change(thread, STATE_SUSPENDED);
     FSHOW_SIGNAL((stderr,"resumed\n"));
-    if(thread->state!=STATE_RUNNING) {
+
+    if(thread_state(thread)!=STATE_RUNNING) {
         lose("sig_stop_for_gc_handler: wrong thread state on wakeup: %ld\n",
-             fixnum_value(thread->state));
+             fixnum_value(thread_state(thread)));
     }
 
     undo_fake_foreign_function_call(context);
 }
+
 #endif
 
 void