X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-signal.lisp;h=2ae4a88feaf5ce67b33852ad56662debc96f4ee9;hb=7bb4c044e09f02a2115095af3733b0673b98a726;hp=e08e38d2ea25f66cb4c565b15b88280d8c15eeac;hpb=1e7fc4730aa0cafb0aba5278e8cdbdba566b8725;p=sbcl.git

diff --git a/src/code/target-signal.lisp b/src/code/target-signal.lisp
index e08e38d..2ae4a88 100644
--- a/src/code/target-signal.lisp
+++ b/src/code/target-signal.lisp
@@ -12,22 +12,16 @@
 (in-package "SB!UNIX")
 
 (defmacro with-interrupt-bindings (&body body)
-  (with-unique-names (empty)
-    `(let*
-         ;; KLUDGE: Whatever is on the PCL stacks before the interrupt
-         ;; handler runs doesn't really matter, since we're not on the
-         ;; same call stack, really -- and if we don't bind these (esp.
-         ;; the cache one) we can get a bogus metacircle if an interrupt
-         ;; handler calls a GF that was being computed when the interrupt
-         ;; hit.
-         ((sb!pcl::*cache-miss-values-stack* nil)
-          (sb!pcl::*dfun-miss-gfs-on-stack* nil)
-          ;; Unless we do this, ADJUST-ARRAY and SORT would need to
-          ;; disable interrupts.
-          (,empty (vector))
-          (sb!impl::*zap-array-data-temp* ,empty)
-          (sb!impl::*merge-sort-temp-vector* ,empty))
-       ,@body)))
+  `(let*
+       ;; KLUDGE: Whatever is on the PCL stacks before the interrupt
+       ;; handler runs doesn't really matter, since we're not on the
+       ;; same call stack, really -- and if we don't bind these (esp.
+       ;; the cache one) we can get a bogus metacircle if an interrupt
+       ;; handler calls a GF that was being computed when the interrupt
+       ;; hit.
+       ((sb!pcl::*cache-miss-values-stack* nil)
+        (sb!pcl::*dfun-miss-gfs-on-stack* nil))
+     ,@body))
 
 ;;; Evaluate CLEANUP-FORMS iff PROTECTED-FORM does a non-local exit.
 (defmacro nlx-protect (protected-form &rest cleanup-froms)
@@ -53,19 +47,20 @@
     (let ((*unblock-deferrables-on-enabling-interrupts-p* t))
       (with-interrupt-bindings
         (let ((sb!debug:*stack-top-hint*
-               (nth-value 1 (sb!kernel:find-interrupted-name-and-frame))))
-          (allow-with-interrupts
-            (nlx-protect (funcall function)
-                         ;; We've been running with deferrables
-                         ;; blocked in Lisp called by a C signal
-                         ;; handler. If we return normally the sigmask
-                         ;; in the interrupted context is restored.
-                         ;; However, if we do an nlx the operating
-                         ;; system will not restore it for us.
-                         (when *unblock-deferrables-on-enabling-interrupts-p*
-                           ;; This means that storms of interrupts
-                           ;; doing an nlx can still run out of stack.
-                           (unblock-deferrable-signals)))))))))
+                (nth-value 1 (sb!kernel:find-interrupted-name-and-frame))))
+          (sb!thread::without-thread-waiting-for (:already-without-interrupts t)
+              (allow-with-interrupts
+                (nlx-protect (funcall function)
+                             ;; We've been running with deferrables
+                             ;; blocked in Lisp called by a C signal
+                             ;; handler. If we return normally the sigmask
+                             ;; in the interrupted context is restored.
+                             ;; However, if we do an nlx the operating
+                             ;; system will not restore it for us.
+                             (when *unblock-deferrables-on-enabling-interrupts-p*
+                               ;; This means that storms of interrupts
+                               ;; doing an nlx can still run out of stack.
+                               (unblock-deferrable-signals))))))))))
 
 (defmacro in-interruption ((&key) &body body)
   #!+sb-doc
@@ -185,9 +180,13 @@
   (flet ((interrupt-it ()
            (with-alien ((context (* os-context-t) context))
              (with-interrupts
-               (%break 'sigint 'interactive-interrupt
-                       :context context
-                       :address (sap-int (sb!vm:context-pc context)))))))
+               (let ((int (make-condition 'interactive-interrupt
+                                          :context context
+                                          :address (sap-int (sb!vm:context-pc context)))))
+                 ;; First SIGNAL, so that handlers can run.
+                 (signal int)
+                 ;; Then enter the debugger like BREAK.
+                 (%break 'sigint int))))))
     (sb!thread:interrupt-thread (sb!thread::foreground-thread)
                                 #'interrupt-it)))