-time we reacquire LOCK and return to the caller."
- (unwind-protect
- (progn
- (get-spinlock queue 2 (current-thread-id))
- (wait-on-queue queue lock))
- ;; If we are interrupted while waiting, we should do these things
- ;; before returning. Ideally, in the case of an unhandled signal,
- ;; we should do them before entering the debugger, but this is
- ;; better than nothing.
- (with-spinlock (queue)
- (dequeue queue))
- (get-mutex lock)))
-
-(defun condition-notify (queue)
- "Notify one of the processes waiting on QUEUE"
- (signal-queue-head queue))
-
-
-;;;; multiple independent listeners
-
-(defvar *session-lock* nil)
-
-(defun make-listener-thread (tty-name)
- (assert (probe-file tty-name))
- ;; FIXME probably still need to do some tty stuff to get signals
- ;; delivered correctly.
- ;; FIXME
- (let* ((in (sb!unix:unix-open (namestring tty-name) sb!unix:o_rdwr #o666))
- (out (sb!unix:unix-dup in))
- (err (sb!unix:unix-dup in)))
- (labels ((thread-repl ()
- (sb!unix::unix-setsid)
- (let* ((*session-lock*
- (make-mutex :name (format nil "lock for ~A" tty-name)))
- (sb!impl::*stdin*
- (sb!sys:make-fd-stream in :input t :buffering :line))
- (sb!impl::*stdout*
- (sb!sys:make-fd-stream out :output t :buffering :line))
- (sb!impl::*stderr*
- (sb!sys:make-fd-stream err :output t :buffering :line))
- (sb!impl::*tty*
- (sb!sys:make-fd-stream err :input t :output t :buffering :line))
- (sb!impl::*descriptor-handlers* nil))
- (get-mutex *session-lock*)
- (sb!sys:enable-interrupt :sigint #'sb!unix::sigint-handler)
- (unwind-protect
- (sb!impl::toplevel-repl nil)
- (sb!int:flush-standard-output-streams)))))
- (make-thread #'thread-repl))))
-
-;;;; job control
-
-(defvar *background-threads-wait-for-debugger* t)
-;;; may be T, NIL, or a function called with a stream and thread id
-;;; as its two arguments, returning NIl or T
+time we reacquire MUTEX and return to the caller."
+ #!-sb-thread (declare (ignore queue))
+ (assert mutex)
+ #!-sb-thread (error "Not supported in unithread builds.")
+ #!+sb-thread
+ (let ((value (mutex-value mutex)))
+ (unwind-protect
+ (let ((me *current-thread*))
+ ;; XXX we should do something to ensure that the result of this setf
+ ;; is visible to all CPUs
+ (setf (waitqueue-data queue) me)
+ (release-mutex mutex)
+ ;; Now we go to sleep using futex-wait. If anyone else
+ ;; manages to grab MUTEX and call CONDITION-NOTIFY during
+ ;; this comment, it will change queue->data, and so
+ ;; futex-wait returns immediately instead of sleeping.
+ ;; Ergo, no lost wakeup
+ (with-pinned-objects (queue me)
+ (futex-wait (waitqueue-data-address queue)
+ (sb!kernel:get-lisp-obj-address me))))
+ ;; If we are interrupted while waiting, we should do these things
+ ;; before returning. Ideally, in the case of an unhandled signal,
+ ;; we should do them before entering the debugger, but this is
+ ;; better than nothing.
+ (get-mutex mutex value))))
+
+(defun condition-notify (queue &optional (n 1))
+ #!+sb-doc
+ "Notify N threads waiting on QUEUE."
+ #!-sb-thread (declare (ignore queue n))
+ #!-sb-thread (error "Not supported in unithread builds.")
+ #!+sb-thread
+ (declare (type (and fixnum (integer 1)) n))
+ #!+sb-thread
+ (let ((me *current-thread*))
+ ;; no problem if >1 thread notifies during the comment in
+ ;; condition-wait: as long as the value in queue-data isn't the
+ ;; waiting thread's id, it matters not what it is
+ ;; XXX we should do something to ensure that the result of this setf
+ ;; is visible to all CPUs
+ (setf (waitqueue-data queue) me)
+ (with-pinned-objects (queue)
+ (futex-wake (waitqueue-data-address queue) n))))
+
+(defun condition-broadcast (queue)
+ #!+sb-doc
+ "Notify all threads waiting on QUEUE."
+ (condition-notify queue most-positive-fixnum))
+
+;;;; semaphores
+
+(defstruct (semaphore (:constructor %make-semaphore))
+ #!+sb-doc
+ "Semaphore type."
+ (name nil :type (or null simple-string))
+ (count 0 :type (integer 0))
+ (mutex (make-mutex))
+ (queue (make-waitqueue)))
+
+(defun make-semaphore (&key name (count 0))
+ #!+sb-doc
+ "Create a semaphore with the supplied COUNT."
+ (%make-semaphore :name name :count count))
+
+(setf (sb!kernel:fdocumentation 'semaphore-name 'function)
+ "The name of the semaphore. Setfable.")
+
+(defun wait-on-semaphore (sem)
+ #!+sb-doc
+ "Decrement the count of SEM if the count would not be negative. Else
+block until the semaphore can be decremented."
+ ;; a more direct implementation based directly on futexes should be
+ ;; possible
+ (with-mutex ((semaphore-mutex sem))
+ (loop until (> (semaphore-count sem) 0)
+ do (condition-wait (semaphore-queue sem) (semaphore-mutex sem))
+ finally (decf (semaphore-count sem)))))
+
+(defun signal-semaphore (sem &optional (n 1))
+ #!+sb-doc
+ "Increment the count of SEM by N. If there are threads waiting on
+this semaphore, then N of them is woken up."
+ (declare (type (and fixnum (integer 1)) n))
+ (with-mutex ((semaphore-mutex sem))
+ (when (= n (incf (semaphore-count sem) n))
+ (condition-notify (semaphore-queue sem) n))))
+
+;;;; job control, independent listeners
+
+(defstruct session
+ (lock (make-mutex :name "session lock"))
+ (threads nil)
+ (interactive-threads nil)
+ (interactive-threads-queue (make-waitqueue)))
+
+(defvar *session* nil)
+
+;;; the debugger itself tries to acquire the session lock, don't let
+;;; funny situations (like getting a sigint while holding the session
+;;; lock) occur
+(defmacro with-session-lock ((session) &body body)
+ #!-sb-thread (declare (ignore session))
+ #!-sb-thread
+ `(locally ,@body)
+ #!+sb-thread
+ `(without-interrupts
+ (with-mutex ((session-lock ,session))
+ ,@body)))
+
+(defun new-session ()
+ (make-session :threads (list *current-thread*)
+ :interactive-threads (list *current-thread*)))
+
+(defun init-job-control ()
+ (setf *session* (new-session)))
+
+(defun %delete-thread-from-session (thread session)
+ (with-session-lock (session)
+ (setf (session-threads session)
+ (delete thread (session-threads session))
+ (session-interactive-threads session)
+ (delete thread (session-interactive-threads session)))))
+
+(defun call-with-new-session (fn)
+ (%delete-thread-from-session *current-thread* *session*)
+ (let ((*session* (new-session)))
+ (funcall fn)))
+
+(defmacro with-new-session (args &body forms)
+ (declare (ignore args)) ;for extensibility
+ (sb!int:with-unique-names (fb-name)
+ `(labels ((,fb-name () ,@forms))
+ (call-with-new-session (function ,fb-name)))))
+
+;;; Remove thread from its session, if it has one.
+#!+sb-thread
+(defun handle-thread-exit (thread)
+ (with-mutex (*all-threads-lock*)
+ (setq *all-threads* (delete thread *all-threads*)))
+ (when *session*
+ (%delete-thread-from-session thread *session*)))
+
+(defun terminate-session ()
+ #!+sb-doc
+ "Kill all threads in session except for this one. Does nothing if current
+thread is not the foreground thread."
+ ;; FIXME: threads created in other threads may escape termination
+ (let ((to-kill
+ (with-session-lock (*session*)
+ (and (eq *current-thread*
+ (car (session-interactive-threads *session*)))
+ (session-threads *session*)))))
+ ;; do the kill after dropping the mutex; unwind forms in dying
+ ;; threads may want to do session things
+ (dolist (thread to-kill)
+ (unless (eq thread *current-thread*)
+ ;; terminate the thread but don't be surprised if it has
+ ;; exited in the meantime
+ (handler-case (terminate-thread thread)
+ (interrupt-thread-error ()))))))