(not (zerop (ldb (byte 1 7) status)))))))))
\f
;;;; process control stuff
-#-win32
(defvar *active-processes* nil
#+sb-doc
"List of process structures for all active processes.")
;;; *ACTIVE-PROCESSES* can be accessed from multiple threads so a
;;; mutex is needed. More importantly the sigchld signal handler also
;;; accesses it, that's why we need without-interrupts.
-#-win32
(defmacro with-active-processes-lock (() &body body)
+ #-win32
`(without-interrupts
(sb-thread:with-mutex (*active-processes-lock*)
- ,@body)))
+ ,@body))
+ #+win32
+ `(progn ,@body))
(defstruct (process (:copier nil))
pid ; PID of child process
#+sb-doc
(setf (documentation 'process-pid 'function) "The pid of the child process.")
+#+win32
+(define-alien-routine ("GetExitCodeProcess@8" get-exit-code-process)
+ int
+ (handle unsigned) (exit-code unsigned :out))
+
(defun process-status (process)
#+sb-doc
"Return the current status of PROCESS. The result is one of :RUNNING,
:STOPPED, :EXITED, or :SIGNALED."
- #-win32
- (get-processes-status-changes)
+ (get-processes-status-changes)
(process-%status process))
#+sb-doc
(setf (documentation 'process-plist 'function)
"A place for clients to stash things.")
-#-win32
(defun process-wait (process &optional check-for-stopped)
#+sb-doc
- "Wait for PROCESS to quit running for some reason.
- When CHECK-FOR-STOPPED is T, also returns when PROCESS is
- stopped. Returns PROCESS."
+ "Wait for PROCESS to quit running for some reason. When
+CHECK-FOR-STOPPED is T, also returns when PROCESS is stopped. Returns
+PROCESS."
(loop
(case (process-status process)
(:running)
(t
t)))))
-#-win32
(defun process-alive-p (process)
#+sb-doc
"Return T if PROCESS is still alive, NIL otherwise."
t
nil)))
-#-win32
(defun process-close (process)
#+sb-doc
- "Close all streams connected to PROCESS and stop maintaining the status slot."
+ "Close all streams connected to PROCESS and stop maintaining the
+status slot."
(macrolet ((frob (stream abort)
`(when ,stream (close ,stream :abort ,abort))))
- (frob (process-pty process) t) ; Don't FLUSH-OUTPUT to dead process, ..
- (frob (process-input process) t) ; .. 'cause it will generate SIGPIPE.
+ #-win32
+ (frob (process-pty process) t) ; Don't FLUSH-OUTPUT to dead process,
+ (frob (process-input process) t) ; .. 'cause it will generate SIGPIPE.
(frob (process-output process) nil)
- (frob (process-error process) nil))
+ (frob (process-error process) nil))
+ ;; FIXME: Given that the status-slot is no longer updated,
+ ;; maybe it should be set to :CLOSED, or similar?
(with-active-processes-lock ()
(setf *active-processes* (delete process *active-processes*)))
process)
(declare (ignore ignore1 ignore2 ignore3))
(get-processes-status-changes))
-#-win32
(defun get-processes-status-changes ()
+ #-win32
(loop
- (multiple-value-bind (pid what code core)
- (wait3 t t)
- (unless pid
- (return))
- (let ((proc (with-active-processes-lock ()
- (find pid *active-processes* :key #'process-pid))))
- (when proc
- (setf (process-%status proc) what)
- (setf (process-exit-code proc) code)
- (setf (process-core-dumped proc) core)
- (when (process-status-hook proc)
- (funcall (process-status-hook proc) proc))
- (when (position what #(:exited :signaled))
- (with-active-processes-lock ()
- (setf *active-processes*
- (delete proc *active-processes*)))))))))
+ (multiple-value-bind (pid what code core)
+ (wait3 t t)
+ (unless pid
+ (return))
+ (let ((proc (with-active-processes-lock ()
+ (find pid *active-processes* :key #'process-pid))))
+ (when proc
+ (setf (process-%status proc) what)
+ (setf (process-exit-code proc) code)
+ (setf (process-core-dumped proc) core)
+ (when (process-status-hook proc)
+ (funcall (process-status-hook proc) proc))
+ (when (position what #(:exited :signaled))
+ (with-active-processes-lock ()
+ (setf *active-processes*
+ (delete proc *active-processes*))))))))
+ #+win32
+ (let (exited)
+ (with-active-processes-lock ()
+ (setf *active-processes*
+ (delete-if (lambda (proc)
+ (multiple-value-bind (ok code)
+ (get-exit-code-process (process-pid proc))
+ (when (and (plusp ok) (/= code 259))
+ (setf (process-%status proc) :exited
+ (process-exit-code proc) code)
+ (when (process-status-hook proc)
+ (push proc exited))
+ t)))
+ *active-processes*)))
+ ;; Can't call the hooks before all the processes have been deal
+ ;; with, as calling a hook may cause re-entry to
+ ;; GET-PROCESS-STATUS-CHANGES. That may be OK when using wait3,
+ ;; but in the Windows implementation is would be deeply bad.
+ (dolist (proc exited)
+ (let ((hook (process-status-hook proc)))
+ (when hook
+ (funcall hook proc))))))
\f
;;;; RUN-PROGRAM and close friends
:error error-stream
:status-hook status-hook
:cookie cookie))))))))))
+ ;; FIXME: this should probably use PROCESS-WAIT instead instead
+ ;; of special argument to SPAWN.
+ (unless wait
+ (push proc *active-processes*))
+ (when (and wait status-hook)
+ (funcall status-hook proc))
proc))
;;; Install a handler for any input that shows up on the file
(write-string string stream
:end count)))))))))))
+(defun get-stream-fd (stream direction)
+ (typecase stream
+ (sb-sys:fd-stream
+ (values (sb-sys:fd-stream-fd stream) nil))
+ (synonym-stream
+ (get-stream-fd (symbol-value (synonym-stream-symbol stream)) direction))
+ (two-way-stream
+ (ecase direction
+ (:input
+ (get-stream-fd (two-way-stream-input-stream stream) direction))
+ (:output
+ (get-stream-fd (two-way-stream-output-stream stream) direction))))))
+
;;; Find a file descriptor to use for object given the direction.
;;; Returns the descriptor. If object is :STREAM, returns the created
;;; stream as the second value.
(t
(error "couldn't duplicate file descriptor: ~A"
(strerror errno)))))))
- ((sb-sys:fd-stream-p object)
- (values (sb-sys:fd-stream-fd object) nil))
((streamp object)
(ecase direction
(:input
- ;; FIXME: We could use a better way of setting up
- ;; temporary files, both here and in LOAD-FOREIGN.
- (dotimes (count
- 256
- (error "could not open a temporary file in /tmp"))
- (let* ((name (coerce (format nil "/tmp/.run-program-~D" count)
- 'base-string))
- (fd (sb-unix:unix-open name
- (logior sb-unix:o_rdwr
- sb-unix:o_creat
- sb-unix:o_excl)
- #o666)))
- (sb-unix:unix-unlink name)
- (when fd
- (let ((newline (string #\Newline)))
- (loop
- (multiple-value-bind
- (line no-cr)
- (read-line object nil nil)
- (unless line
- (return))
- (sb-unix:unix-write
- fd
- ;; FIXME: this really should be
- ;; (STRING-TO-OCTETS :EXTERNAL-FORMAT ...).
- ;; RUN-PROGRAM should take an
- ;; external-format argument, which should
- ;; be passed down to here. Something
- ;; similar should happen on :OUTPUT, too.
- (map '(vector (unsigned-byte 8)) #'char-code line)
- 0 (length line))
- (if no-cr
- (return)
- (sb-unix:unix-write fd newline 0 1)))))
- (sb-unix:unix-lseek fd 0 sb-unix:l_set)
- (push fd *close-in-parent*)
- (return (values fd nil))))))
+ (or (get-stream-fd object :input)
+ ;; FIXME: We could use a better way of setting up
+ ;; temporary files
+ (dotimes (count
+ 256
+ (error "could not open a temporary file in /tmp"))
+ (let* ((name (coerce (format nil "/tmp/.run-program-~D" count)
+ 'base-string))
+ (fd (sb-unix:unix-open name
+ (logior sb-unix:o_rdwr
+ sb-unix:o_creat
+ sb-unix:o_excl)
+ #o666)))
+ (sb-unix:unix-unlink name)
+ (when fd
+ (let ((newline (string #\Newline)))
+ (loop
+ (multiple-value-bind
+ (line no-cr)
+ (read-line object nil nil)
+ (unless line
+ (return))
+ (sb-unix:unix-write
+ fd
+ ;; FIXME: this really should be
+ ;; (STRING-TO-OCTETS :EXTERNAL-FORMAT ...).
+ ;; RUN-PROGRAM should take an
+ ;; external-format argument, which should
+ ;; be passed down to here. Something
+ ;; similar should happen on :OUTPUT, too.
+ (map '(vector (unsigned-byte 8)) #'char-code line)
+ 0 (length line))
+ (if no-cr
+ (return)
+ (sb-unix:unix-write fd newline 0 1)))))
+ (sb-unix:unix-lseek fd 0 sb-unix:l_set)
+ (push fd *close-in-parent*)
+ (return (values fd nil)))))))
(:output
- (multiple-value-bind (read-fd write-fd)
- (sb-unix:unix-pipe)
- (unless read-fd
- (error "couldn't create pipe: ~S" (strerror write-fd)))
- (copy-descriptor-to-stream read-fd object cookie)
- (push read-fd *close-on-error*)
- (push write-fd *close-in-parent*)
- (values write-fd nil)))))
+ (or (get-stream-fd object :output)
+ (multiple-value-bind (read-fd write-fd)
+ (sb-unix:unix-pipe)
+ (unless read-fd
+ (error "couldn't create pipe: ~S" (strerror write-fd)))
+ (copy-descriptor-to-stream read-fd object cookie)
+ (push read-fd *close-on-error*)
+ (push write-fd *close-in-parent*)
+ (values write-fd nil))))))
(t
(error "invalid option to RUN-PROGRAM: ~S" object))))
projects / sbcl.git / blobdiff