X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Frun-program.lisp;h=04b5d6a5b0cac638fd7d3ae2fd3e44e997869903;hb=1e7fc4730aa0cafb0aba5278e8cdbdba566b8725;hp=99a75971528d6e56a46811cd27da66c0e4665311;hpb=76237af144bef52bc2e391c90970a1747cdf0a9e;p=sbcl.git diff --git a/src/code/run-program.lisp b/src/code/run-program.lisp index 99a7597..04b5d6a 100644 --- a/src/code/run-program.lisp +++ b/src/code/run-program.lisp @@ -45,10 +45,14 @@ ;;;; which (at least in sbcl-0.6.10 on Red Hat Linux 6.2) is not ;;;; visible at GENESIS time. -(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 +(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)) ;;; Convert as best we can from an SBCL representation of a Unix ;;; environment to a CMU CL representation. @@ -63,7 +67,7 @@ (defun unix-environment-cmucl-from-sbcl (sbcl) (mapcan (lambda (string) - (declare (type simple-base-string string)) + (declare (string string)) (let ((=-pos (position #\= string :test #'equal))) (if =-pos (list @@ -86,28 +90,30 @@ (mapcar (lambda (cons) (destructuring-bind (key . val) cons - (declare (type keyword key) (type simple-base-string val)) - (concatenate 'simple-base-string (symbol-name key) "=" val))) + (declare (type keyword key) (string val)) + (concatenate 'simple-string (symbol-name key) "=" val))) cmucl)) ;;;; Import wait3(2) from Unix. -(define-alien-routine ("wait3" c-wait3) sb-alien:int +#-win32 +(define-alien-routine ("waitpid" c-waitpid) sb-alien:int + (pid sb-alien:int) (status sb-alien:int :out) - (options sb-alien:int) - (rusage sb-alien:int)) + (options sb-alien:int)) -(defun wait3 (&optional do-not-hang check-for-stopped) - #!+sb-doc - "Return any available status information on child process. " +#-win32 +(defun waitpid (pid &optional do-not-hang check-for-stopped) + #+sb-doc + "Return any available status information on child process with PID." (multiple-value-bind (pid status) - (c-wait3 (logior (if do-not-hang - sb-unix:wnohang - 0) - (if check-for-stopped - sb-unix:wuntraced - 0)) - 0) + (c-waitpid pid + (logior (if do-not-hang + sb-unix:wnohang + 0) + (if check-for-stopped + sb-unix:wuntraced + 0))) (cond ((or (minusp pid) (zerop pid)) nil) @@ -135,11 +141,11 @@ (not (zerop (ldb (byte 1 7) status))))))))) ;;;; process control stuff - (defvar *active-processes* nil - #!+sb-doc + #+sb-doc "List of process structures for all active processes.") +#-win32 (defvar *active-processes-lock* (sb-thread:make-mutex :name "Lock for active processes.")) @@ -147,16 +153,18 @@ ;;; mutex is needed. More importantly the sigchld signal handler also ;;; accesses it, that's why we need without-interrupts. (defmacro with-active-processes-lock (() &body body) - `(without-interrupts - (sb-thread:with-mutex (*active-processes-lock*) - ,@body))) + #-win32 + `(sb-thread::with-system-mutex (*active-processes-lock*) + ,@body) + #+win32 + `(progn ,@body)) (defstruct (process (:copier nil)) pid ; PID of child process %status ; either :RUNNING, :STOPPED, :EXITED, or :SIGNALED exit-code ; either exit code or signal core-dumped ; T if a core image was dumped - pty ; stream to child's pty, or NIL + #-win32 pty ; stream to child's pty, or NIL input ; stream to child's input, or NIL output ; stream from child's output, or NIL error ; stream from child's error output, or NIL @@ -164,68 +172,71 @@ plist ; a place for clients to stash things cookie) ; list of the number of pipes from the subproc - - (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 +#+sb-doc (setf (documentation 'process-p 'function) "T if OBJECT is a PROCESS, NIL otherwise.") -#!+sb-doc +#+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 + #+sb-doc "Return the current status of PROCESS. The result is one of :RUNNING, :STOPPED, :EXITED, or :SIGNALED." (get-processes-status-changes) (process-%status process)) -#!+sb-doc +#+sb-doc (setf (documentation 'process-exit-code 'function) "The exit code or the signal of a stopped process.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-core-dumped 'function) "T if a core image was dumped by the process.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-pty 'function) "The pty stream of the process or NIL.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-input 'function) "The input stream of the process or NIL.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-output 'function) "The output stream of the process or NIL.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-error 'function) "The error stream of the process or NIL.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-status-hook 'function) "A function that is called when PROCESS changes its status. The function is called with PROCESS as its only argument.") -#!+sb-doc +#+sb-doc (setf (documentation 'process-plist 'function) "A place for clients to stash things.") (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." + #+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." (loop (case (process-status process) (:running) @@ -238,7 +249,7 @@ The function is called with PROCESS as its only argument.") (sb-sys:serve-all-events 1)) process) -#-hpux +#-win32 ;;; Find the current foreground process group id. (defun find-current-foreground-process (proc) (with-alien ((result sb-alien:int)) @@ -252,8 +263,9 @@ The function is called with PROCESS as its only argument.") result)) (process-pid proc)) +#-win32 (defun process-kill (process signal &optional (whom :pid)) - #!+sb-doc + #+sb-doc "Hand SIGNAL to PROCESS. If WHOM is :PID, use the kill Unix system call. If WHOM is :PROCESS-GROUP, use the killpg Unix system call. If WHOM is :PTY-PROCESS-GROUP deliver the signal to whichever process group is @@ -262,18 +274,11 @@ The function is called with PROCESS as its only argument.") ((:pid :process-group) (process-pid process)) (:pty-process-group - #-hpux (find-current-foreground-process process))))) (multiple-value-bind (okay errno) (case whom - #+hpux - (:pty-process-group - (sb-unix:unix-ioctl (sb-sys:fd-stream-fd (process-pty process)) - sb-unix:TIOCSIGSEND - (sb-sys:int-sap - signal))) - ((:process-group #-hpux :pty-process-group) + ((:process-group) (sb-unix:unix-killpg pid signal)) (t (sb-unix:unix-kill pid signal))) @@ -290,7 +295,7 @@ The function is called with PROCESS as its only argument.") t))))) (defun process-alive-p (process) - #!+sb-doc + #+sb-doc "Return T if PROCESS is still alive, NIL otherwise." (let ((status (process-status process))) (if (or (eq status :running) @@ -299,41 +304,61 @@ The function is called with PROCESS as its only argument.") nil))) (defun process-close (process) - #!+sb-doc - "Close all streams connected to PROCESS and stop maintaining the status slot." + #+sb-doc + "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 -(defun sigchld-handler (ignore1 ignore2 ignore3) - (declare (ignore ignore1 ignore2 ignore3)) - (get-processes-status-changes)) - (defun get-processes-status-changes () - (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*))))))))) + (let (exited) + (with-active-processes-lock () + (setf *active-processes* + (delete-if #-win32 + (lambda (proc) + ;; Wait only on pids belonging to processes + ;; started by RUN-PROGRAM. There used to be a + ;; WAIT3 call here, but that makes direct + ;; WAIT, WAITPID usage impossible due to the + ;; race with the SIGCHLD signal handler. + (multiple-value-bind (pid what code core) + (waitpid (process-pid proc) t t) + (when pid + (setf (process-%status proc) what) + (setf (process-exit-code proc) code) + (setf (process-core-dumped proc) core) + (when (process-status-hook proc) + (push proc exited)) + t))) + #+win32 + (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 waitpid, + ;; but in the Windows implementation it would be deeply bad. + (dolist (proc exited) + (let ((hook (process-status-hook proc))) + (when hook + (funcall hook proc)))))) ;;;; RUN-PROGRAM and close friends @@ -343,32 +368,78 @@ The function is called with PROCESS as its only argument.") ;;; list of file descriptors to close when RUN-PROGRAM returns in the parent (defvar *close-in-parent* nil) -;;; list of handlers installed by RUN-PROGRAM +;;; list of handlers installed by RUN-PROGRAM. FIXME: nothing seems +;;; to set this. +#-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. -(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)) - (master-fd (sb-unix:unix-open master-name - sb-unix:o_rdwr - #o666))) - (when master-fd - (let* ((slave-name (coerce (format nil "/dev/tty~C~X" char digit) 'base-string)) - (slave-fd (sb-unix:unix-open slave-name - sb-unix:o_rdwr - #o666))) - (when slave-fd - (return-from find-a-pty - (values master-fd - slave-fd - slave-name))) - (sb-unix:unix-close master-fd)))))) - (error "could not find a pty")) +#-(or win32 openbsd) +(progn + (define-alien-routine ptsname c-string (fd int)) + (define-alien-routine grantpt boolean (fd int)) + (define-alien-routine unlockpt boolean (fd int)) + (defun find-a-pty () + ;; First try to use the Unix98 pty api. + (let* ((master-name (coerce (format nil "/dev/ptmx") 'base-string)) + (master-fd (sb-unix:unix-open master-name + sb-unix:o_rdwr + #o666))) + (when master-fd + (grantpt master-fd) + (unlockpt master-fd) + (let* ((slave-name (ptsname master-fd)) + (slave-fd (sb-unix:unix-open slave-name + sb-unix:o_rdwr + #o666))) + (when slave-fd + (return-from find-a-pty + (values master-fd + slave-fd + slave-name))) + (sb-unix:unix-close master-fd)) + (error "could not find a pty"))) + ;; No dice, try using the old-school method. + (dolist (char '(#\p #\q)) + (dotimes (digit 16) + (let* ((master-name (coerce (format nil "/dev/pty~C~X" char digit) + 'base-string)) + (master-fd (sb-unix:unix-open master-name + sb-unix:o_rdwr + #o666))) + (when master-fd + (let* ((slave-name (coerce (format nil "/dev/tty~C~X" char digit) + 'base-string)) + (slave-fd (sb-unix:unix-open slave-name + sb-unix:o_rdwr + #o666))) + (when slave-fd + (return-from find-a-pty + (values master-fd + slave-fd + slave-name))) + (sb-unix:unix-close master-fd)))))) + (error "could not find a pty"))) +#+openbsd +(progn + (define-alien-routine openpty int (amaster int :out) (aslave int :out) + (name (* char)) (termp (* t)) (winp (* t))) + (defun find-a-pty () + (with-alien ((name-buf (array char 16))) + (multiple-value-bind (return-val master-fd slave-fd) + (openpty (cast name-buf (* char)) nil nil) + (if (zerop return-val) + (values master-fd + slave-fd + (sb-alien::c-string-to-string (alien-sap name-buf) + (sb-impl::default-external-format) + 'character)) + (error "could not find a pty")))))) + +#-win32 (defun open-pty (pty cookie) (when pty (multiple-value-bind @@ -384,93 +455,68 @@ The function is called with PROCESS as its only argument.") (copy-descriptor-to-stream new-fd pty cookie))) (values name (sb-sys:make-fd-stream master :input t :output t + :element-type :default :dual-channel-p t))))) (defmacro round-bytes-to-words (n) - `(logand (the fixnum (+ (the fixnum ,n) 3)) (lognot 3))) + (let ((bytes-per-word (/ sb-vm:n-machine-word-bits sb-vm:n-byte-bits))) + `(logandc2 (the fixnum (+ (the fixnum ,n) + (1- ,bytes-per-word))) (1- ,bytes-per-word)))) (defun string-list-to-c-strvec (string-list) - ;; Make a pass over STRING-LIST to calculate the amount of memory - ;; needed to hold the strvec. - (let ((string-bytes 0) - ;; We need an extra for the null, and an extra 'cause exect - ;; clobbers argv[-1]. - (vec-bytes (* #.(/ sb-vm::n-machine-word-bits sb-vm::n-byte-bits) - (+ (length string-list) 2)))) - (declare (fixnum string-bytes vec-bytes)) - (dolist (s string-list) - (enforce-type s simple-string) - (incf string-bytes (round-bytes-to-words (1+ (length s))))) - ;; Now allocate the memory and fill it in. - (let* ((total-bytes (+ string-bytes vec-bytes)) - (vec-sap (sb-sys:allocate-system-memory total-bytes)) - (string-sap (sap+ vec-sap vec-bytes)) - (i #.(/ sb-vm::n-machine-word-bits sb-vm::n-byte-bits))) - (declare (type (and unsigned-byte fixnum) total-bytes i) - (type sb-sys:system-area-pointer vec-sap string-sap)) - (dolist (s string-list) - (declare (simple-string s)) - (let ((n (length s))) - ;; Blast the string into place. - (sb-kernel:copy-ub8-to-system-area (the simple-base-string - ;; FIXME - (coerce s 'simple-base-string)) - 0 - string-sap 0 - (1+ n)) - ;; Blast the pointer to the string into place. - (setf (sap-ref-sap vec-sap i) string-sap) - (setf string-sap (sap+ string-sap (round-bytes-to-words (1+ n)))) - (incf i #.(/ sb-vm::n-machine-word-bits sb-vm::n-byte-bits)))) - ;; Blast in the last null pointer. - (setf (sap-ref-sap vec-sap i) (int-sap 0)) - (values vec-sap (sap+ vec-sap #.(/ sb-vm::n-machine-word-bits - sb-vm::n-byte-bits)) - total-bytes)))) + (let* ((bytes-per-word (/ sb-vm:n-machine-word-bits sb-vm:n-byte-bits)) + ;; We need an extra for the null, and an extra 'cause exect + ;; clobbers argv[-1]. + (vec-bytes (* bytes-per-word (+ (length string-list) 2))) + (octet-vector-list (mapcar (lambda (s) + (string-to-octets s :null-terminate t)) + string-list)) + (string-bytes (reduce #'+ octet-vector-list + :key (lambda (s) + (round-bytes-to-words (length s))))) + (total-bytes (+ string-bytes vec-bytes)) + ;; Memory to hold the vector of pointers and all the strings. + (vec-sap (sb-sys:allocate-system-memory total-bytes)) + (string-sap (sap+ vec-sap vec-bytes)) + ;; Index starts from [1]! + (vec-index-offset bytes-per-word)) + (declare (index string-bytes vec-bytes total-bytes) + (sb-sys:system-area-pointer vec-sap string-sap)) + (dolist (octets octet-vector-list) + (declare (type (simple-array (unsigned-byte 8) (*)) octets)) + (let ((size (length octets))) + ;; Copy string. + (sb-kernel:copy-ub8-to-system-area octets 0 string-sap 0 size) + ;; Put the pointer in the vector. + (setf (sap-ref-sap vec-sap vec-index-offset) string-sap) + ;; Advance string-sap for the next string. + (setf string-sap (sap+ string-sap (round-bytes-to-words size))) + (incf vec-index-offset bytes-per-word))) + ;; Final null pointer. + (setf (sap-ref-sap vec-sap vec-index-offset) (int-sap 0)) + (values vec-sap (sap+ vec-sap bytes-per-word) total-bytes))) (defmacro with-c-strvec ((var str-list) &body body) (with-unique-names (sap size) - `(multiple-value-bind - (,sap ,var ,size) - (string-list-to-c-strvec ,str-list) - (unwind-protect - (progn - ,@body) - (sb-sys:deallocate-system-memory ,sap ,size))))) + `(multiple-value-bind (,sap ,var ,size) + (string-list-to-c-strvec ,str-list) + (unwind-protect + (progn + ,@body) + (sb-sys:deallocate-system-memory ,sap ,size))))) -(sb-alien:define-alien-routine spawn sb-alien:int +(sb-alien:define-alien-routine spawn + #-win32 sb-alien:int + #+win32 sb-win32::handle (program sb-alien:c-string) (argv (* sb-alien:c-string)) - (envp (* sb-alien:c-string)) - (pty-name sb-alien:c-string) (stdin sb-alien:int) (stdout sb-alien:int) - (stderr sb-alien:int)) - -;;; Is UNIX-FILENAME the name of a file that we can execute? -(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 - (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 #\: search-path :start (if end (1+ end) 0)) - and start = 0 then (and end (1+ end)) - while start - ;; 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 (and fullpath - (unix-filename-is-executable-p (namestring fullpath))) - return fullpath)) + (stderr sb-alien:int) + (search sb-alien:int) + (envp (* sb-alien:c-string)) + (pty-name sb-alien:c-string) + (wait sb-alien:int)) ;;; FIXME: There shouldn't be two semiredundant versions of the ;;; documentation. Since this is a public extension function, the @@ -517,14 +563,15 @@ colon-separated list of pathnames SEARCH-PATH" ;;; the fork worked, and NIL if it did not. (defun run-program (program args &key - (env nil env-p) - (environment (if env-p - (unix-environment-sbcl-from-cmucl env) - (posix-environ)) - environment-p) + #-win32 (env nil env-p) + #-win32 (environment + (if env-p + (unix-environment-sbcl-from-cmucl env) + (posix-environ)) + environment-p) (wait t) search - pty + #-win32 pty input if-input-does-not-exist output @@ -532,15 +579,21 @@ colon-separated list of pathnames SEARCH-PATH" (error :output) (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). + #+sb-doc + #.(concatenate + 'string + ;; The Texinfoizer is sensitive to whitespace, so mind the + ;; placement of the #-win32 pseudosplicings. + "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 return a PROCESS structure or NIL on failure. - See the CMU Common Lisp Users Manual for details about the - PROCESS structure. +The program arguments and the environment are encoded using the +default external format for streams. + +RUN-PROGRAM will return a PROCESS structure. See the CMU Common Lisp +Users Manual for details about the PROCESS structure."#-win32" Notes about Unix environments (as in the :ENVIRONMENT and :ENV args): @@ -553,34 +606,34 @@ colon-separated list of pathnames SEARCH-PATH" else, is a mother lode of security problems. If you are contemplating doing this, read about it first. (The Perl community has a lot of good documentation about this and other security issues in script-like - programs.) + programs.)"" The &KEY arguments have the following meanings: - +"#-win32" :ENVIRONMENT - a list of SIMPLE-BASE-STRINGs describing the new Unix environment + a list of STRINGs describing the new Unix environment (as in \"man environ\"). The default is to copy the environment of the current process. :ENV an alternative lossy representation of the new Unix environment, - for compatibility with CMU CL + for compatibility with CMU CL"" :SEARCH - Look for PROGRAM in each of the directories along the $PATH + Look for PROGRAM in each of the directories in the child's $PATH environment variable. Otherwise an absolute pathname is required. - (See also FIND-EXECUTABLE-IN-SEARCH-PATH) :WAIT If non-NIL (default), wait until the created process finishes. If - NIL, continue running Lisp until the program finishes. + NIL, continue running Lisp until the program finishes."#-win32" :PTY Either T, NIL, or a stream. Unless NIL, the subprocess is established under a PTY. If :pty is a stream, all output to this pty is sent to this stream, otherwise the PROCESS-PTY slot is filled in with a stream - connected to pty that can read output and write input. + connected to pty that can read output and write input."" :INPUT Either T, NIL, a pathname, a stream, or :STREAM. If T, the standard - input for the current process is inherited. If NIL, /dev/null + input for the current process is inherited. If NIL, " + #-win32"/dev/null"#+win32"nul"" is used. If a pathname, the file so specified is used. If a stream, - all the input is read from that stream and send to the subprocess. If + all the input is read from that stream and sent to the subprocess. If :STREAM, the PROCESS-INPUT slot is filled in with a stream that sends its output to the process. Defaults to NIL. :IF-INPUT-DOES-NOT-EXIST (when :INPUT is the name of a file) @@ -590,7 +643,8 @@ colon-separated list of pathnames SEARCH-PATH" NIL (the default) to return NIL from RUN-PROGRAM :OUTPUT Either T, NIL, a pathname, a stream, or :STREAM. If T, the standard - output for the current process is inherited. If NIL, /dev/null + output for the current process is inherited. If NIL, " + #-win32"/dev/null"#+win32"nul"" is used. If a pathname, the file so specified is used. If a stream, all the output from the process is written to this stream. If :STREAM, the PROCESS-OUTPUT slot is filled in with a stream that can @@ -607,248 +661,394 @@ colon-separated list of pathnames SEARCH-PATH" same place as normal output. :STATUS-HOOK This is a function the system calls whenever the status of the - process changes. The function takes the process as an argument." - + process changes. The function takes the process as an argument.") + #-win32 (when (and env-p environment-p) (error "can't specify :ENV and :ENVIRONMENT simultaneously")) - ;; Make sure that the interrupt handler is installed. - (sb-sys:enable-interrupt sb-unix:sigchld #'sigchld-handler) ;; Prepend the program to the argument list. (push (namestring program) args) - (let (;; Clear various specials used by GET-DESCRIPTOR-FOR to - ;; communicate cleanup info. - *close-on-error* - *close-in-parent* - *handlers-installed* - ;; Establish PROC at this level so that we can return it. - proc - ;; It's friendly to allow the caller to pass any string - ;; designator, but internally we'd like SIMPLE-STRINGs. - (simple-args (mapcar (lambda (x) (coerce x 'simple-string)) args))) - (unwind-protect - (let ((pfile - (if search - (let ((p (find-executable-in-search-path program))) - (and p (unix-namestring p t))) - (unix-namestring program t))) - (cookie (list 0))) - (unless pfile - (error "no such program: ~S" program)) - (unless (unix-filename-is-executable-p pfile) - (error "not executable: ~S" program)) - (multiple-value-bind (stdin input-stream) - (get-descriptor-for input cookie - :direction :input - :if-does-not-exist if-input-does-not-exist) - (multiple-value-bind (stdout output-stream) - (get-descriptor-for output cookie - :direction :output - :if-exists if-output-exists) - (multiple-value-bind (stderr error-stream) - (if (eq error :output) - (values stdout output-stream) - (get-descriptor-for error cookie - :direction :output - :if-exists if-error-exists)) - (multiple-value-bind (pty-name pty-stream) - (open-pty pty cookie) - ;; Make sure we are not notified about the child - ;; death before we have installed the PROCESS - ;; structure in *ACTIVE-PROCESSES*. - (with-active-processes-lock () - (with-c-strvec (args-vec simple-args) - (with-c-strvec (environment-vec environment) - (let ((child-pid - (without-gcing - (spawn pfile args-vec environment-vec pty-name - stdin stdout stderr)))) - (when (< child-pid 0) - (error "couldn't fork child process: ~A" - (strerror))) - (setf proc (make-process :pid child-pid - :%status :running - :pty pty-stream - :input input-stream - :output output-stream - :error error-stream - :status-hook status-hook - :cookie cookie)) - (push proc *active-processes*)))))))))) - (dolist (fd *close-in-parent*) - (sb-unix:unix-close fd)) - (unless proc - (dolist (fd *close-on-error*) + (labels (;; It's friendly to allow the caller to pass any string + ;; designator, but internally we'd like SIMPLE-STRINGs. + ;; + ;; Huh? We let users pass in symbols and characters for + ;; the arguments, but call NAMESTRING on the program + ;; name... -- RMK + (simplify-args (args) + (loop for arg in args + as escaped-arg = (escape-arg arg) + collect (coerce escaped-arg 'simple-string))) + (escape-arg (arg) + #-win32 arg + ;; Apparently any spaces or double quotes in the arguments + ;; need to be escaped on win32. + #+win32 (if (position-if + (lambda (c) (find c '(#\" #\Space))) arg) + (write-to-string arg) + arg))) + (let (;; Clear various specials used by GET-DESCRIPTOR-FOR to + ;; communicate cleanup info. + *close-on-error* + *close-in-parent* + ;; Some other binding used only on non-Win32. FIXME: + ;; nothing seems to set this. + #-win32 *handlers-installed* + ;; Establish PROC at this level so that we can return it. + proc + (simple-args (simplify-args args)) + (progname (native-namestring program)) + ;; Gag. + (cookie (list 0))) + (unwind-protect + ;; Note: despite the WITH-* names, these macros don't + ;; expand into UNWIND-PROTECT forms. They're just + ;; syntactic sugar to make the rest of the routine slightly + ;; easier to read. + (macrolet ((with-fd-and-stream-for (((fd stream) which &rest args) + &body body) + `(multiple-value-bind (,fd ,stream) + ,(ecase which + ((:input :output) + `(get-descriptor-for ,@args)) + (:error + `(if (eq ,(first args) :output) + ;; kludge: we expand into + ;; hard-coded symbols here. + (values stdout output-stream) + (get-descriptor-for ,@args)))) + ,@body)) + (with-open-pty (((pty-name pty-stream) (pty cookie)) + &body body) + #+win32 `(declare (ignore ,pty ,cookie)) + #+win32 `(let (,pty-name ,pty-stream) ,@body) + #-win32 `(multiple-value-bind (,pty-name ,pty-stream) + (open-pty ,pty ,cookie) + ,@body)) + (with-args-vec ((vec args) &body body) + `(with-c-strvec (,vec ,args) + ,@body)) + (with-environment-vec ((vec env) &body body) + #+win32 `(let (,vec) ,@body) + #-win32 `(with-c-strvec (,vec ,env) ,@body))) + (with-fd-and-stream-for ((stdin input-stream) :input + input cookie + :direction :input + :if-does-not-exist if-input-does-not-exist + :external-format :default + :wait wait) + (with-fd-and-stream-for ((stdout output-stream) :output + output cookie + :direction :output + :if-exists if-output-exists + :external-format :default) + (with-fd-and-stream-for ((stderr error-stream) :error + error cookie + :direction :output + :if-exists if-error-exists + :external-format :default) + (with-open-pty ((pty-name pty-stream) (pty cookie)) + ;; Make sure we are not notified about the child + ;; death before we have installed the PROCESS + ;; structure in *ACTIVE-PROCESSES*. + (let (child) + (with-active-processes-lock () + (with-args-vec (args-vec simple-args) + (with-environment-vec (environment-vec environment) + (setq child (without-gcing + (spawn progname args-vec + stdin stdout stderr + (if search 1 0) + environment-vec pty-name + (if wait 1 0)))) + (when (plusp child) + (setf proc + (apply + #'make-process + :pid child + :input input-stream + :output output-stream + :error error-stream + :status-hook status-hook + :cookie cookie + #-win32 (list :pty pty-stream + :%status :running) + #+win32 (if wait + (list :%status :exited + :exit-code child) + (list :%status :running)))) + (push proc *active-processes*))))) + ;; Report the error outside the lock. + (when (= child -1) + (error "couldn't fork child process: ~A" + (strerror))))))))) + (dolist (fd *close-in-parent*) (sb-unix:unix-close fd)) - (dolist (handler *handlers-installed*) - (sb-sys:remove-fd-handler handler)))) - (when (and wait proc) - (process-wait proc)) - proc)) + (unless proc + (dolist (fd *close-on-error*) + (sb-unix:unix-close fd)) + ;; FIXME: nothing seems to set this. + #-win32 + (dolist (handler *handlers-installed*) + (sb-sys:remove-fd-handler handler)))) + #-win32 + (when (and wait proc) + (process-wait proc)) + proc))) ;;; Install a handler for any input that shows up on the file ;;; descriptor. The handler reads the data and writes it to the ;;; stream. -(defun copy-descriptor-to-stream (descriptor stream cookie) +(defun copy-descriptor-to-stream (descriptor stream cookie external-format) (incf (car cookie)) - (let ((string (make-string 256 :element-type 'base-char)) - handler) + (let* (handler + (buf (make-array 256 :element-type '(unsigned-byte 8))) + (read-end 0)) (setf handler (sb-sys:add-fd-handler descriptor - :input (lambda (fd) - (declare (ignore fd)) - (loop - (unless handler - (return)) - (multiple-value-bind - (result readable/errno) - (sb-unix:unix-select (1+ descriptor) - (ash 1 descriptor) - 0 0 0) - (cond ((null result) - (error "~@" - (strerror readable/errno))) - ((zerop result) - (return)))) - (sb-alien:with-alien ((buf (sb-alien:array - sb-alien:char - 256))) - (multiple-value-bind - (count errno) - (sb-unix:unix-read descriptor - (alien-sap buf) - 256) - (cond ((or (and (null count) - (eql errno sb-unix:eio)) - (eql count 0)) - (sb-sys:remove-fd-handler handler) - (setf handler nil) - (decf (car cookie)) - (sb-unix:unix-close descriptor) - (return)) - ((null count) - (sb-sys:remove-fd-handler handler) - (setf handler nil) - (decf (car cookie)) - (error - "~@" + (strerror readable/errno)))) + ((zerop result) + (return)))) + (multiple-value-bind (count errno) + (with-pinned-objects (buf) + (sb-unix:unix-read descriptor + (sap+ (vector-sap buf) read-end) + (- (length buf) read-end))) + (cond + ((and #-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)) + (sb-unix:unix-close descriptor) + (unless (zerop read-end) + ;; Should this be an END-OF-FILE? + (error "~@" buf)) + (return)) + ((null count) + (sb-sys:remove-fd-handler handler) + (setf handler nil) + (decf (car cookie)) + (error + "~@" - (strerror errno))) - (t - (sb-kernel:copy-ub8-from-system-area - (alien-sap buf) 0 - string 0 - count) - (write-string string stream - :end count))))))))))) + (strerror errno))) + (t + (incf read-end count) + (let* ((decode-end read-end) + (string (handler-case + (octets-to-string + buf :end read-end + :external-format external-format) + (end-of-input-in-character (e) + (setf decode-end + (octet-decoding-error-start e)) + (octets-to-string + buf :end decode-end + :external-format external-format))))) + (unless (zerop (length string)) + (write-string string stream) + (when (/= decode-end (length buf)) + (replace buf buf :start2 decode-end :end2 read-end)) + (decf read-end decode-end)))))))))))) + +;;; FIXME: something very like this is done in SB-POSIX to treat +;;; streams as file descriptor designators; maybe we can combine these +;;; two? Additionally, as we have a couple of user-defined streams +;;; libraries, maybe we should have a generic function for doing this, +;;; so user-defined streams can play nicely with RUN-PROGRAM (and +;;; maybe also with SB-POSIX)? +(defun get-stream-fd-and-external-format (stream direction) + (typecase stream + (sb-sys:fd-stream + (values (sb-sys:fd-stream-fd stream) nil (stream-external-format stream))) + (synonym-stream + (get-stream-fd-and-external-format + (symbol-value (synonym-stream-symbol stream)) direction)) + (two-way-stream + (ecase direction + (:input + (get-stream-fd-and-external-format + (two-way-stream-input-stream stream) direction)) + (:output + (get-stream-fd-and-external-format + (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. (defun get-descriptor-for (object cookie &rest keys - &key direction + &key direction (external-format :default) wait &allow-other-keys) - (cond ((eq object t) - ;; No new descriptor is needed. - (values -1 nil)) - ((eq object nil) - ;; Use /dev/null. - (multiple-value-bind - (fd errno) - (sb-unix:unix-open #.(coerce "/dev/null" 'base-string) - (case direction - (:input sb-unix:o_rdonly) - (:output sb-unix:o_wronly) - (t sb-unix:o_rdwr)) - #o666) - (unless fd - (error "~@" - (strerror errno))) - (push fd *close-in-parent*) - (values fd nil))) - ((eq object :stream) - (multiple-value-bind (read-fd write-fd) (sb-unix:unix-pipe) - (unless read-fd - (error "couldn't create pipe: ~A" (strerror write-fd))) - (case direction - (:input - (push read-fd *close-in-parent*) - (push write-fd *close-on-error*) - (let ((stream (sb-sys:make-fd-stream write-fd :output t))) - (values read-fd stream))) - (:output - (push read-fd *close-on-error*) - (push write-fd *close-in-parent*) - (let ((stream (sb-sys:make-fd-stream read-fd :input t))) - (values write-fd stream))) - (t - (sb-unix:unix-close read-fd) - (sb-unix:unix-close write-fd) - (error "Direction must be either :INPUT or :OUTPUT, not ~S." - direction))))) - ((or (pathnamep object) (stringp object)) - (with-open-stream (file (apply #'open object keys)) + (declare (ignore wait)) ;This is explained below. + ;; Our use of a temporary file dates back to very old CMUCLs, and + ;; was probably only ever intended for use with STRING-STREAMs, + ;; which are ordinarily smallish. However, as we've got + ;; user-defined stream classes, we can end up trying to copy + ;; arbitrarily much data into the temp file, and so are liable to + ;; run afoul of disk quotas or to choke on small /tmp file systems. + (flet ((make-temp-fd () + (multiple-value-bind (fd name/errno) + (sb-unix:sb-mkstemp "/tmp/.run-program-XXXXXX" #o0600) + (unless fd + (error "could not open a temporary file: ~A" + (strerror name/errno))) + (unless (sb-unix:unix-unlink name/errno) + (sb-unix:unix-close fd) + (error "failed to unlink ~A" name/errno)) + fd))) + (cond ((eq object t) + ;; No new descriptor is needed. + (values -1 nil)) + ((eq object nil) + ;; Use /dev/null. (multiple-value-bind (fd errno) - (sb-unix:unix-dup (sb-sys:fd-stream-fd file)) - (cond (fd - (push fd *close-in-parent*) - (values fd nil)) - (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-open #-win32 #.(coerce "/dev/null" 'base-string) + #+win32 #.(coerce "nul" 'base-string) + (case direction + (:input sb-unix:o_rdonly) + (:output sb-unix:o_wronly) + (t sb-unix:o_rdwr)) + #o666) + (unless fd + (error #-win32 "~@" + #+win32 "~@" + (strerror errno))) + (push fd *close-in-parent*) + (values fd nil))) + ((eq object :stream) + (multiple-value-bind (read-fd write-fd) (sb-unix:unix-pipe) + (unless read-fd + (error "couldn't create pipe: ~A" (strerror write-fd))) + (case direction + (:input + (push read-fd *close-in-parent*) + (push write-fd *close-on-error*) + (let ((stream (sb-sys:make-fd-stream write-fd :output t + :element-type :default + :external-format + external-format))) + (values read-fd stream))) + (:output + (push read-fd *close-on-error*) + (push write-fd *close-in-parent*) + (let ((stream (sb-sys:make-fd-stream read-fd :input t + :element-type :default + :external-format + external-format))) + (values write-fd stream))) + (t + (sb-unix:unix-close read-fd) + (sb-unix:unix-close write-fd) + (error "Direction must be either :INPUT or :OUTPUT, not ~S." + direction))))) + ((or (pathnamep object) (stringp object)) + ;; GET-DESCRIPTOR-FOR uses &allow-other-keys, so rather + ;; than munge the &rest list for OPEN, just disable keyword + ;; validation there. + (with-open-stream (file (apply #'open object :allow-other-keys t + keys)) + (multiple-value-bind + (fd errno) + (sb-unix:unix-dup (sb-sys:fd-stream-fd file)) + (cond (fd + (push fd *close-in-parent*) + (values fd nil)) + (t + (error "couldn't duplicate file descriptor: ~A" + (strerror errno))))))) + ((streamp object) + (ecase direction + (:input + (block nil + ;; If we can get an fd for the stream, let the child + ;; process use the fd for its descriptor. Otherwise, + ;; we copy data from the stream into a temp file, and + ;; give the temp file's descriptor to the + ;; child. + (multiple-value-bind (fd stream format) + (get-stream-fd-and-external-format object :input) + (declare (ignore format)) + (when fd + (return (values fd stream)))) + ;; FIXME: if we can't get the file descriptor, since + ;; the stream might be interactive or otherwise + ;; block-y, we can't know whether we can copy the + ;; stream's data to a temp file, so if RUN-PROGRAM was + ;; called with :WAIT NIL, we should probably error. + ;; However, STRING-STREAMs aren't fd-streams, but + ;; they're not prone to blocking; any user-defined + ;; streams that "read" from some in-memory data will + ;; probably be similar to STRING-STREAMs. So maybe we + ;; should add a STREAM-INTERACTIVE-P generic function + ;; for problems like this? Anyway, the machinery is + ;; here, if you feel like filling in the details. + #| + (when (and (null wait) #) + (error "~@" object)) + |# + (let ((fd (make-temp-fd)) + (newline (string #\Newline))) + (loop + (multiple-value-bind + (line no-cr) + (read-line object nil nil) + (unless line + (return)) + (let ((vector (string-to-octets line))) + (sb-unix:unix-write + fd vector 0 (length vector))) + (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))))) - (t - (error "invalid option to RUN-PROGRAM: ~S" object)))) + (return (values fd nil))))) + (:output + (block nil + ;; Similar to the :input trick above, except we + ;; arrange to copy data from the stream. This is + ;; slightly saner than the input case, since we don't + ;; buffer to a file, but I think we may still lose if + ;; there's unflushed data in the stream buffer and we + ;; give the file descriptor to the child. + (multiple-value-bind (fd stream format) + (get-stream-fd-and-external-format object :output) + (declare (ignore format)) + (when fd + (return (values fd stream)))) + (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 + external-format) + (push read-fd *close-on-error*) + (push write-fd *close-in-parent*) + (return (values write-fd nil))))))) + (t + (error "invalid option to RUN-PROGRAM: ~S" object)))))