X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Finterr.lisp;h=7a48c43b3416613b48b5c3cb006458cf36345f7f;hb=672b2f6cb751566526c7f3bb3de6b7d8424760e2;hp=fe81a1f75034534b114b673783c32889f3576915;hpb=84c126513a68dc127ca812ac9d30a579b815b1bd;p=sbcl.git

diff --git a/src/code/interr.lisp b/src/code/interr.lisp
index fe81a1f..7a48c43 100644
--- a/src/code/interr.lisp
+++ b/src/code/interr.lisp
@@ -282,6 +282,15 @@
          :datum object
          :expected-type '(unsigned-byte 32)))
 
+(deferr tls-exhausted-error ()
+  ;; There is nothing we can do about it. A number of entries in the
+  ;; tls could be reserved and made available for recovery but since
+  ;; tls indices are never reused it would be kind of silly and
+  ;; without it signalling an error is more than likely to end in a
+  ;; recursive error.
+  (%primitive print "Thread local storage exhausted.")
+  (sb!impl::%halt))
+
 (macrolet
     ((define-simple-array-internal-errors ()
          `(progn
@@ -418,43 +427,44 @@
          (%primitive print "can't recover from error in cold init, halting")
          (%primitive sb!c:halt))
 
-       (multiple-value-bind (name sb!debug:*stack-top-hint*)
-           (find-interrupted-name-and-frame)
-         (/show0 "back from FIND-INTERRUPTED-NAME")
-         ;; Unblock trap signal here, we unwound the stack and can't return.
-         ;; FIXME: Should we not reset the _entire_ mask, but just
-         ;; restore it to the state before we got the condition?
-         ;; FIXME 2: Signals are currently unblocked in
-         ;; interrupt.c:internal_error before we do stack unwinding, can this
-         ;; introduce a race condition?
-         #!+(or linux mips)
-         (sb!unix::reset-signal-mask)
-         (let ((fp (int-sap (sb!vm:context-register alien-context
-                                                    sb!vm::cfp-offset)))
-               (handler (and (< -1 error-number (length *internal-errors*))
-                             (svref *internal-errors* error-number))))
-           (cond ((null handler)
-                  (error 'simple-error
-                         :format-control
-                         "unknown internal error, ~D, args=~S"
-                         :format-arguments
-                         (list error-number
-                               (mapcar (lambda (sc-offset)
-                                         (sb!di::sub-access-debug-var-slot
-                                          fp sc-offset alien-context))
-                                       arguments))))
-                 ((not (functionp handler))
-                  (error 'simple-error
-                         :format-control "internal error ~D: ~A; args=~S"
-                         :format-arguments
-                         (list error-number
-                               handler
-                               (mapcar (lambda (sc-offset)
-                                         (sb!di::sub-access-debug-var-slot
-                                          fp sc-offset alien-context))
-                                       arguments))))
-                 (t
-                  (funcall handler name fp alien-context arguments)))))))))
+       (with-interrupt-bindings
+         (multiple-value-bind (name sb!debug:*stack-top-hint*)
+             (find-interrupted-name-and-frame)
+           (/show0 "back from FIND-INTERRUPTED-NAME")
+           ;; Unblock trap signal here, we unwound the stack and can't return.
+           ;; FIXME: Should we not reset the _entire_ mask, but just
+           ;; restore it to the state before we got the condition?
+           ;; FIXME 2: Signals are currently unblocked in
+           ;; interrupt.c:internal_error before we do stack unwinding, can this
+           ;; introduce a race condition?
+           #!+(and linux mips)
+           (sb!unix::reset-signal-mask)
+           (let ((fp (int-sap (sb!vm:context-register alien-context
+                                                      sb!vm::cfp-offset)))
+                 (handler (and (< -1 error-number (length *internal-errors*))
+                               (svref *internal-errors* error-number))))
+             (cond ((null handler)
+                    (error 'simple-error
+                           :format-control
+                           "unknown internal error, ~D, args=~S"
+                           :format-arguments
+                           (list error-number
+                                 (mapcar (lambda (sc-offset)
+                                           (sb!di::sub-access-debug-var-slot
+                                            fp sc-offset alien-context))
+                                         arguments))))
+                   ((not (functionp handler))
+                    (error 'simple-error
+                           :format-control "internal error ~D: ~A; args=~S"
+                           :format-arguments
+                           (list error-number
+                                 handler
+                                 (mapcar (lambda (sc-offset)
+                                           (sb!di::sub-access-debug-var-slot
+                                            fp sc-offset alien-context))
+                                         arguments))))
+                   (t
+                    (funcall handler name fp alien-context arguments))))))))))
 
 (defun control-stack-exhausted-error ()
   (let ((sb!debug:*stack-top-hint* nil))
@@ -464,9 +474,10 @@
      (error 'control-stack-exhausted))))
 
 ;;; KLUDGE: we keep a single HEAP-EXHAUSTED-ERROR object around, so
-;;; that we don't need to allocate it when running out of memory. Similarly
-;;; we pass the amounts in special variables as there may be multiple threads
-;;; running into trouble at the same time. The condition is created by GC-REINIT.
+;;; that we don't need to allocate it when running out of
+;;; memory. Similarly we pass the amounts in special variables as
+;;; there may be multiple threads running into trouble at the same
+;;; time. The condition is created by GC-REINIT.
 (defvar *heap-exhausted-error-condition*)
 (defvar *heap-exhausted-error-available-bytes*)
 (defvar *heap-exhausted-error-requested-bytes*)