;;;; which (at least in sbcl-0.6.10 on Red Hat Linux 6.2) is not
;;;; visible at GENESIS time.
-#-win32 (define-alien-routine wrapped-environ (* c-string))
-#-win32 (defun posix-environ ()
- "Return the Unix environment (\"man environ\") as a list of SIMPLE-STRINGs."
- (c-strings->string-list (wrapped-environ)))
+#-win32
+(progn
+ (define-alien-routine wrapped-environ (* c-string))
+ (defun posix-environ ()
+ "Return the Unix environment (\"man environ\") as a list of SIMPLE-STRINGs."
+ (c-strings->string-list (wrapped-environ))))
;#+win32 (sb-alien:define-alien-routine msvcrt-environ (* c-string))
(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
plist ; a place for clients to stash things
cookie) ; list of the number of pipes from the subproc
-
-
-#-win32 (defmethod print-object ((process process) stream)
+(defmethod print-object ((process process) stream)
(print-unreadable-object (process stream :type t)
- (format stream
- "~W ~S"
- (process-pid process)
- (process-status process)))
- process)
+ (let ((status (process-status process)))
+ (if (eq :exited status)
+ (format stream "~S ~S" status (process-exit-code process))
+ (format stream "~S ~S" (process-pid process) status)))
+ process))
#+sb-doc
(setf (documentation 'process-p 'function)
#+sb-doc
(setf (documentation 'process-pid 'function) "The pid of the child process.")
-#-win32
+#+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,
(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)
;;; the handler for SIGCHLD signals that RUN-PROGRAM establishes
-#-win32 (defun sigchld-handler (ignore1 ignore2 ignore3)
+#-win32
+(defun sigchld-handler (ignore1 ignore2 ignore3)
(declare (ignore ignore1 ignore2 ignore3))
(get-processes-status-changes))
-#-win32 (defun get-processes-status-changes ()
+(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
(defvar *close-in-parent* nil)
;;; list of handlers installed by RUN-PROGRAM
-#-win32 (defvar *handlers-installed* nil)
+#-win32
+(defvar *handlers-installed* nil)
;;; Find an unused pty. Return three values: the file descriptor for
;;; the master side of the pty, the file descriptor for the slave side
;;; of the pty, and the name of the tty device for the slave side.
-#-win32 (defun find-a-pty ()
+#-win32
+(defun find-a-pty ()
(dolist (char '(#\p #\q))
(dotimes (digit 16)
(let* ((master-name (coerce (format nil "/dev/pty~C~X" char digit) 'base-string))
(sb-unix:unix-close master-fd))))))
(error "could not find a pty"))
-#-win32 (defun open-pty (pty cookie)
+#-win32
+(defun open-pty (pty cookie)
(when pty
(multiple-value-bind
(master slave name)
,@body)
(sb-sys:deallocate-system-memory ,sap ,size)))))
-#-win32 (sb-alien:define-alien-routine spawn sb-alien:int
+#-win32
+(sb-alien:define-alien-routine spawn sb-alien:int
(program sb-alien:c-string)
(argv (* sb-alien:c-string))
(envp (* sb-alien:c-string))
(stdout sb-alien:int)
(stderr sb-alien:int))
-#+win32 (sb-alien:define-alien-routine spawn sb-win32::handle
+#+win32
+(sb-alien:define-alien-routine spawn sb-win32::handle
(program sb-alien:c-string)
(argv (* sb-alien:c-string))
(stdin sb-alien:int)
(wait sb-alien:int))
;;; Is UNIX-FILENAME the name of a file that we can execute?
-#-win32 (defun unix-filename-is-executable-p (unix-filename)
- (declare (type simple-string unix-filename))
- (setf unix-filename (coerce unix-filename 'base-string))
- (values (and (eq (sb-unix:unix-file-kind unix-filename) :file)
- (sb-unix:unix-access unix-filename sb-unix:x_ok))))
-
-(defun find-executable-in-search-path (pathname
- &optional
+(defun unix-filename-is-executable-p (unix-filename)
+ (let ((filename (coerce unix-filename 'base-string)))
+ (values (and (eq (sb-unix:unix-file-kind filename) :file)
+ #-win32
+ (sb-unix:unix-access filename sb-unix:x_ok)))))
+
+(defun find-executable-in-search-path (pathname &optional
(search-path (posix-getenv "PATH")))
#+sb-doc
"Find the first executable file matching PATHNAME in any of the
colon-separated list of pathnames SEARCH-PATH"
- (loop for end = (position #-win32 #\: #+win32 #\; search-path :start (if end (1+ end) 0))
- and start = 0 then (and end (1+ end))
- while start
- ;; <Krystof> the truename of a file naming a directory is the
- ;; directory, at least until pfdietz comes along and says why
- ;; that's noncompliant -- CSR, c. 2003-08-10
- for truename = (probe-file (subseq search-path start end))
- for fullpath = (when truename (merge-pathnames pathname truename))
- when #-win32 (and fullpath
- (unix-filename-is-executable-p (namestring fullpath)))
- #+win32 t
- return fullpath))
+ (let ((program #-win32 pathname
+ #+win32 (merge-pathnames pathname (make-pathname :type "exe"))))
+ (loop for end = (position #-win32 #\: #+win32 #\; search-path
+ :start (if end (1+ end) 0))
+ and start = 0 then (and end (1+ end))
+ while start
+ ;; <Krystof> the truename of a file naming a directory is the
+ ;; directory, at least until pfdietz comes along and says why
+ ;; that's noncompliant -- CSR, c. 2003-08-10
+ for truename = (probe-file (subseq search-path start end))
+ for fullpath = (when truename
+ (unix-namestring (merge-pathnames program truename)))
+ when (and fullpath (unix-filename-is-executable-p fullpath))
+ return fullpath)))
;;; FIXME: There shouldn't be two semiredundant versions of the
;;; documentation. Since this is a public extension function, the
;;; RUN-PROGRAM returns a PROCESS structure for the process if
;;; the fork worked, and NIL if it did not.
-#-win32 (defun run-program (program args
+#-win32
+(defun run-program (program args
&key
(env nil env-p)
(environment (if env-p
(if-error-exists :error)
status-hook)
#+sb-doc
- "RUN-PROGRAM creates a new Unix process running the Unix program found in
- the file specified by the PROGRAM argument. ARGS are the standard
- arguments that can be passed to a Unix program. For no arguments, use NIL
- (which means that just the name of the program is passed as arg 0).
+ "RUN-PROGRAM creates a new Unix process running the Unix program
+found in the file specified by the PROGRAM argument. ARGS are the
+standard arguments that can be passed to a Unix program. For no
+arguments, use NIL (which means that just the name of the program is
+passed as arg 0).
- RUN-PROGRAM will return a PROCESS structure or NIL on failure.
- See the CMU Common Lisp Users Manual for details about the
- PROCESS structure.
+RUN-PROGRAM will return a PROCESS structure. See the CMU Common Lisp
+Users Manual for details about the PROCESS structure.
Notes about Unix environments (as in the :ENVIRONMENT and :ENV args):
:STATUS-HOOK
This is a function the system calls whenever the status of the
process changes. The function takes the process as an argument."
-
(when (and env-p environment-p)
(error "can't specify :ENV and :ENVIRONMENT simultaneously"))
;; Make sure that the interrupt handler is installed.
(unwind-protect
(let ((pfile
(if search
- (let ((p (find-executable-in-search-path program)))
- (and p (unix-namestring p t)))
- (unix-namestring program t)))
+ (find-executable-in-search-path program)
+ (unix-namestring program)))
(cookie (list 0)))
(unless pfile
(error "no such program: ~S" program))
(process-wait proc))
proc))
-#+win32 (defun run-program (program args
+#+win32
+(defun run-program (program args
&key
(wait t)
search
(error :output)
(if-error-exists :error)
status-hook)
- "RUN-PROGRAM creates a new process specified by the PROGRAM argument.
- ARGS are the standard arguments that can be passed to a program. For no
- arguments, use NIL (which means that just the name of the program is
- passed as arg 0).
+ "RUN-PROGRAM creates a new process specified by the PROGRAM
+argument. ARGS are the standard arguments that can be passed to a
+program. For no arguments, use NIL (which means that just the name of
+the program is passed as arg 0).
- RUN-PROGRAM will either return NIL or a PROCESS structure. See the CMU
- Common Lisp Users Manual for details about the PROCESS structure.
+RUN-PROGRAM will either return a PROCESS structure. See the CMU
+Common Lisp Users Manual for details about the PROCESS structure.
The &KEY arguments have the following meanings:
:SEARCH
:STATUS-HOOK
This is a function the system calls whenever the status of the
process changes. The function takes the process as an argument."
-
;; Prepend the program to the argument list.
(push (namestring program) args)
(let (;; Clear various specials used by GET-DESCRIPTOR-FOR to
(unwind-protect
(let ((pfile
(if search
- (namestring (find-executable-in-search-path program))
- (namestring program)))
+ (find-executable-in-search-path program)
+ (unix-namestring program)))
(cookie (list 0)))
(unless pfile
- (error "no such program: ~S" program))
+ (error "No such program: ~S" program))
+ (unless (unix-filename-is-executable-p pfile)
+ (error "Not an executable: ~S" program))
(multiple-value-bind (stdin input-stream)
(get-descriptor-for input cookie
:direction :input
:direction :output
:if-exists if-error-exists))
(with-c-strvec (args-vec simple-args)
- (let ((iwait (if wait 1 0)))
- (declare (type fixnum iwait))
- (let ((child-pid
- (without-gcing
- (spawn pfile args-vec
- stdin stdout stderr
- iwait))))
- (when (< child-pid 0)
- (error "couldn't spawn program: ~A"
- (strerror)))
- (setf proc
- (if wait
- nil
- (make-process :pid child-pid
- :%status :running
- :input input-stream
- :output output-stream
- :error error-stream
- :status-hook status-hook
- :cookie cookie)))))))))))
+ (let ((handle (without-gcing
+ (spawn pfile args-vec
+ stdin stdout stderr
+ (if wait 1 0)))))
+ (when (< handle 0)
+ (error "Couldn't spawn program: ~A" (strerror)))
+ (setf proc
+ (if wait
+ (make-process :%status :exited
+ :exit-code handle)
+ (make-process :pid handle
+ :%status :running
+ :input input-stream
+ :output output-stream
+ :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
(sb-unix:unix-read descriptor
(alien-sap buf)
256)
- (cond (#-win32(or (and (null count)
- (eql errno sb-unix:eio))
- (eql count 0))
- #+win32(<= count 0)
+ (cond (#-win32(or (and (null count)
+ (eql errno sb-unix:eio))
+ (eql count 0))
+ #+win32(<= count 0)
(sb-sys:remove-fd-handler handler)
(setf handler nil)
(decf (car cookie))
(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.
(multiple-value-bind
(fd errno)
(sb-unix:unix-open #-win32 #.(coerce "/dev/null" 'base-string)
- #+win32 #.(coerce "nul" 'base-string)
+ #+win32 #.(coerce "nul" 'base-string)
(case direction
(:input sb-unix:o_rdonly)
(:output sb-unix:o_wronly)
(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