;;; sets *interrupt-pending* and returns without handling the signal.
;;;
;;; When we drop out the without interrupts, we check to see whether
-;;; *interrupt-pending* has been set. If so, we call
-;;; do-pending-interrupt, which generates a SIGTRAP. The C code
+;;; *INTERRUPT-PENDING* has been set. If so, we call
+;;; RECEIVE-PENDING-INTERRUPT, which generates a SIGTRAP. The C code
;;; invokes the handler for the saved signal instead of the SIGTRAP
;;; after replacing the signal mask in the signal context with the
;;; saved value. When that hander returns, the original signal mask is
;;; installed, allowing any other pending signals to be handled.
;;;
-;;; This means that the cost of without-interrupts is just a special
+;;; This means that the cost of WITHOUT-INTERRUPTS is just a special
;;; binding in the case when no signals are delivered (the normal
;;; case). It's only when a signal is actually delivered that we use
;;; any system calls, and by then the cost of the extra system calls
;;; are lost in the noise when compared with the cost of delivering
;;; the signal in the first place.
-#!-gengc (progn
-
(defvar *interrupts-enabled* t)
(defvar *interrupt-pending* nil)
(sb!xc:defmacro without-interrupts (&body body)
#!+sb-doc
"Execute BODY in a context impervious to interrupts."
- (let ((name (gensym)))
+ (let ((name (gensym "WITHOUT-INTERRUPTS-BODY-")))
`(flet ((,name () ,@body))
(if *interrupts-enabled*
(unwind-protect
;; whether interrupts are pending before executing themselves
;; immediately?
(when *interrupt-pending*
- (do-pending-interrupt)))
+ (receive-pending-interrupt)))
(,name)))))
(sb!xc:defmacro with-interrupts (&body body)
(,name)
(let ((*interrupts-enabled* t))
(when *interrupt-pending*
- (do-pending-interrupt))
+ (receive-pending-interrupt))
(,name))))))
-
-) ; PROGN
-
-;;; On the GENGC system, we have to do it slightly differently because of the
-;;; existence of threads. Each thread has a suspends_disabled_count in its
-;;; mutator structure. When this value is other then zero, the low level stuff
-;;; will not suspend the thread, but will instead set the suspend_pending flag
-;;; (also in the mutator). So when we finish the without-interrupts, we just
-;;; check the suspend_pending flag and trigger a do-pending-interrupt if
-;;; necessary.
-
-#!+gengc
-(defmacro without-interrupts (&body body)
- `(unwind-protect
- (progn
- (locally
- (declare (optimize (speed 3) (safety 0)))
- (incf (sb!kernel:mutator-interrupts-disabled-count)))
- ,@body)
- (locally
- (declare (optimize (speed 3) (safety 0)))
- (when (and (zerop (decf (sb!kernel:mutator-interrupts-disabled-count)))
- (not (zerop (sb!kernel:mutator-interrupt-pending))))
- (do-pending-interrupt)))))
\f
;;;; utilities for dealing with signal names and numbers
(:constructor make-unix-signal (%name %number))
(:copier nil))
;; signal keyword (e.g. :SIGINT for the Unix SIGINT signal)
- (%name (required-argument) :type keyword :read-only t)
+ (%name (missing-arg) :type keyword :read-only t)
;; signal number
- (%number (required-argument) :type integer :read-only t))
+ (%number (missing-arg) :type integer :read-only t))
;;; list of all defined UNIX-SIGNALs
(defvar *unix-signals* nil)