Runtime removal: refactor process
This patch continues the runtime removal by moving and refactoring the process implementation into the new `sys` module. Because this eliminates APIs in `libnative` and `librustrt`, it is a: [breaking-change] This functionality is likely to be available publicly, in some form, from `std` in the future.
This commit is contained in:
Aaron Turon
parent
3d195482a4
commit
0f98e75b69
@ -29,13 +29,6 @@ use std::os;
|
||||
use std::rt::rtio::{mod, IoResult, IoError};
|
||||
use std::num;
|
||||
|
||||
// Local re-exports
|
||||
pub use self::process::Process;
|
||||
|
||||
// Native I/O implementations
|
||||
pub mod process;
|
||||
mod util;
|
||||
|
||||
#[cfg(any(target_os = "macos",
|
||||
target_os = "ios",
|
||||
target_os = "freebsd",
|
||||
@ -123,19 +116,6 @@ impl rtio::IoFactory for IoFactory {
|
||||
fn timer_init(&mut self) -> IoResult<Box<rtio::RtioTimer + Send>> {
|
||||
timer::Timer::new().map(|t| box t as Box<rtio::RtioTimer + Send>)
|
||||
}
|
||||
fn spawn(&mut self, cfg: rtio::ProcessConfig)
|
||||
-> IoResult<(Box<rtio::RtioProcess + Send>,
|
||||
Vec<Option<Box<rtio::RtioPipe + Send>>>)> {
|
||||
process::Process::spawn(cfg).map(|(p, io)| {
|
||||
(box p as Box<rtio::RtioProcess + Send>,
|
||||
io.into_iter().map(|p| p.map(|p| {
|
||||
box p as Box<rtio::RtioPipe + Send>
|
||||
})).collect())
|
||||
})
|
||||
}
|
||||
fn kill(&mut self, pid: libc::pid_t, signum: int) -> IoResult<()> {
|
||||
process::Process::kill(pid, signum)
|
||||
}
|
||||
#[cfg(unix)]
|
||||
fn tty_open(&mut self, fd: c_int, _readable: bool)
|
||||
-> IoResult<Box<rtio::RtioTTY + Send>> {
|
||||
|
||||
@ -46,61 +46,6 @@ pub trait RemoteCallback {
|
||||
fn fire(&mut self);
|
||||
}
|
||||
|
||||
/// Data needed to spawn a process. Serializes the `std::io::process::Command`
|
||||
/// builder.
|
||||
pub struct ProcessConfig<'a> {
|
||||
/// Path to the program to run.
|
||||
pub program: &'a CString,
|
||||
|
||||
/// Arguments to pass to the program (doesn't include the program itself).
|
||||
pub args: &'a [CString],
|
||||
|
||||
/// Optional environment to specify for the program. If this is None, then
|
||||
/// it will inherit the current process's environment.
|
||||
pub env: Option<&'a [(&'a CString, &'a CString)]>,
|
||||
|
||||
/// Optional working directory for the new process. If this is None, then
|
||||
/// the current directory of the running process is inherited.
|
||||
pub cwd: Option<&'a CString>,
|
||||
|
||||
/// Configuration for the child process's stdin handle (file descriptor 0).
|
||||
/// This field defaults to `CreatePipe(true, false)` so the input can be
|
||||
/// written to.
|
||||
pub stdin: StdioContainer,
|
||||
|
||||
/// Configuration for the child process's stdout handle (file descriptor 1).
|
||||
/// This field defaults to `CreatePipe(false, true)` so the output can be
|
||||
/// collected.
|
||||
pub stdout: StdioContainer,
|
||||
|
||||
/// Configuration for the child process's stdout handle (file descriptor 2).
|
||||
/// This field defaults to `CreatePipe(false, true)` so the output can be
|
||||
/// collected.
|
||||
pub stderr: StdioContainer,
|
||||
|
||||
/// Any number of streams/file descriptors/pipes may be attached to this
|
||||
/// process. This list enumerates the file descriptors and such for the
|
||||
/// process to be spawned, and the file descriptors inherited will start at
|
||||
/// 3 and go to the length of this array. The first three file descriptors
|
||||
/// (stdin/stdout/stderr) are configured with the `stdin`, `stdout`, and
|
||||
/// `stderr` fields.
|
||||
pub extra_io: &'a [StdioContainer],
|
||||
|
||||
/// Sets the child process's user id. This translates to a `setuid` call in
|
||||
/// the child process. Setting this value on windows will cause the spawn to
|
||||
/// fail. Failure in the `setuid` call on unix will also cause the spawn to
|
||||
/// fail.
|
||||
pub uid: Option<uint>,
|
||||
|
||||
/// Similar to `uid`, but sets the group id of the child process. This has
|
||||
/// the same semantics as the `uid` field.
|
||||
pub gid: Option<uint>,
|
||||
|
||||
/// If true, the child process is spawned in a detached state. On unix, this
|
||||
/// means that the child is the leader of a new process group.
|
||||
pub detach: bool,
|
||||
}
|
||||
|
||||
pub struct LocalIo<'a> {
|
||||
factory: &'a mut IoFactory+'a,
|
||||
}
|
||||
@ -170,10 +115,6 @@ impl<'a> LocalIo<'a> {
|
||||
|
||||
pub trait IoFactory {
|
||||
fn timer_init(&mut self) -> IoResult<Box<RtioTimer + Send>>;
|
||||
fn spawn(&mut self, cfg: ProcessConfig)
|
||||
-> IoResult<(Box<RtioProcess + Send>,
|
||||
Vec<Option<Box<RtioPipe + Send>>>)>;
|
||||
fn kill(&mut self, pid: libc::pid_t, signal: int) -> IoResult<()>;
|
||||
fn tty_open(&mut self, fd: c_int, readable: bool)
|
||||
-> IoResult<Box<RtioTTY + Send>>;
|
||||
}
|
||||
@ -184,13 +125,6 @@ pub trait RtioTimer {
|
||||
fn period(&mut self, msecs: u64, cb: Box<Callback + Send>);
|
||||
}
|
||||
|
||||
pub trait RtioProcess {
|
||||
fn id(&self) -> libc::pid_t;
|
||||
fn kill(&mut self, signal: int) -> IoResult<()>;
|
||||
fn wait(&mut self) -> IoResult<ProcessExit>;
|
||||
fn set_timeout(&mut self, timeout: Option<u64>);
|
||||
}
|
||||
|
||||
pub trait RtioPipe {
|
||||
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint>;
|
||||
fn write(&mut self, buf: &[u8]) -> IoResult<()>;
|
||||
|
||||
@ -20,14 +20,17 @@ use os;
|
||||
use io::{IoResult, IoError};
|
||||
use io;
|
||||
use libc;
|
||||
use mem;
|
||||
use rt::rtio::{RtioProcess, ProcessConfig, IoFactory, LocalIo};
|
||||
use rt::rtio;
|
||||
use c_str::CString;
|
||||
use collections::HashMap;
|
||||
use hash::Hash;
|
||||
#[cfg(windows)]
|
||||
use std::hash::sip::SipState;
|
||||
use io::pipe::{PipeStream, PipePair};
|
||||
use path::BytesContainer;
|
||||
|
||||
use sys;
|
||||
use sys::fs::FileDesc;
|
||||
use sys::process::Process as ProcessImp;
|
||||
|
||||
/// Signal a process to exit, without forcibly killing it. Corresponds to
|
||||
/// SIGTERM on unix platforms.
|
||||
@ -62,24 +65,29 @@ use std::hash::sip::SipState;
|
||||
/// assert!(child.wait().unwrap().success());
|
||||
/// ```
|
||||
pub struct Process {
|
||||
handle: Box<RtioProcess + Send>,
|
||||
handle: ProcessImp,
|
||||
forget: bool,
|
||||
|
||||
/// None until wait() is called.
|
||||
exit_code: Option<ProcessExit>,
|
||||
|
||||
/// Manually delivered signal
|
||||
exit_signal: Option<int>,
|
||||
|
||||
/// Deadline after which wait() will return
|
||||
deadline: u64,
|
||||
|
||||
/// Handle to the child's stdin, if the `stdin` field of this process's
|
||||
/// `ProcessConfig` was `CreatePipe`. By default, this handle is `Some`.
|
||||
pub stdin: Option<io::PipeStream>,
|
||||
pub stdin: Option<PipeStream>,
|
||||
|
||||
/// Handle to the child's stdout, if the `stdout` field of this process's
|
||||
/// `ProcessConfig` was `CreatePipe`. By default, this handle is `Some`.
|
||||
pub stdout: Option<io::PipeStream>,
|
||||
pub stdout: Option<PipeStream>,
|
||||
|
||||
/// Handle to the child's stderr, if the `stderr` field of this process's
|
||||
/// `ProcessConfig` was `CreatePipe`. By default, this handle is `Some`.
|
||||
pub stderr: Option<io::PipeStream>,
|
||||
|
||||
/// Extra I/O handles as configured by the original `ProcessConfig` when
|
||||
/// this process was created. This is by default empty.
|
||||
pub extra_io: Vec<Option<io::PipeStream>>,
|
||||
pub stderr: Option<PipeStream>,
|
||||
}
|
||||
|
||||
/// A representation of environment variable name
|
||||
@ -130,6 +138,13 @@ impl PartialEq for EnvKey {
|
||||
}
|
||||
}
|
||||
|
||||
impl BytesContainer for EnvKey {
|
||||
fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
|
||||
let &EnvKey(ref k) = self;
|
||||
k.container_as_bytes()
|
||||
}
|
||||
}
|
||||
|
||||
/// A HashMap representation of environment variables.
|
||||
pub type EnvMap = HashMap<EnvKey, CString>;
|
||||
|
||||
@ -160,7 +175,6 @@ pub struct Command {
|
||||
stdin: StdioContainer,
|
||||
stdout: StdioContainer,
|
||||
stderr: StdioContainer,
|
||||
extra_io: Vec<StdioContainer>,
|
||||
uid: Option<uint>,
|
||||
gid: Option<uint>,
|
||||
detach: bool,
|
||||
@ -194,7 +208,6 @@ impl Command {
|
||||
stdin: CreatePipe(true, false),
|
||||
stdout: CreatePipe(false, true),
|
||||
stderr: CreatePipe(false, true),
|
||||
extra_io: Vec::new(),
|
||||
uid: None,
|
||||
gid: None,
|
||||
detach: false,
|
||||
@ -281,14 +294,6 @@ impl Command {
|
||||
self.stderr = cfg;
|
||||
self
|
||||
}
|
||||
/// Attaches a stream/file descriptor/pipe to the child process. Inherited
|
||||
/// file descriptors are numbered consecutively, starting at 3; the first
|
||||
/// three file descriptors (stdin/stdout/stderr) are configured with the
|
||||
/// `stdin`, `stdout`, and `stderr` methods.
|
||||
pub fn extra_io<'a>(&'a mut self, cfg: StdioContainer) -> &'a mut Command {
|
||||
self.extra_io.push(cfg);
|
||||
self
|
||||
}
|
||||
|
||||
/// Sets the child process's user id. This translates to a `setuid` call in
|
||||
/// the child process. Setting this value on windows will cause the spawn to
|
||||
@ -315,50 +320,23 @@ impl Command {
|
||||
|
||||
/// Executes the command as a child process, which is returned.
|
||||
pub fn spawn(&self) -> IoResult<Process> {
|
||||
fn to_rtio(p: StdioContainer) -> rtio::StdioContainer {
|
||||
match p {
|
||||
Ignored => rtio::Ignored,
|
||||
InheritFd(fd) => rtio::InheritFd(fd),
|
||||
CreatePipe(a, b) => rtio::CreatePipe(a, b),
|
||||
}
|
||||
}
|
||||
let extra_io: Vec<rtio::StdioContainer> =
|
||||
self.extra_io.iter().map(|x| to_rtio(*x)).collect();
|
||||
LocalIo::maybe_raise(|io| {
|
||||
let env = match self.env {
|
||||
None => None,
|
||||
Some(ref env_map) =>
|
||||
Some(env_map.iter()
|
||||
.map(|(&EnvKey(ref key), val)| (key, val))
|
||||
.collect::<Vec<_>>())
|
||||
};
|
||||
let cfg = ProcessConfig {
|
||||
program: &self.program,
|
||||
args: self.args.as_slice(),
|
||||
env: env.as_ref().map(|e| e.as_slice()),
|
||||
cwd: self.cwd.as_ref(),
|
||||
stdin: to_rtio(self.stdin),
|
||||
stdout: to_rtio(self.stdout),
|
||||
stderr: to_rtio(self.stderr),
|
||||
extra_io: extra_io.as_slice(),
|
||||
uid: self.uid,
|
||||
gid: self.gid,
|
||||
detach: self.detach,
|
||||
};
|
||||
io.spawn(cfg).map(|(p, io)| {
|
||||
let mut io = io.into_iter().map(|p| {
|
||||
p.map(|p| io::PipeStream::new(p))
|
||||
});
|
||||
Process {
|
||||
handle: p,
|
||||
forget: false,
|
||||
stdin: io.next().unwrap(),
|
||||
stdout: io.next().unwrap(),
|
||||
stderr: io.next().unwrap(),
|
||||
extra_io: io.collect(),
|
||||
}
|
||||
let (their_stdin, our_stdin) = try!(setup_io(self.stdin));
|
||||
let (their_stdout, our_stdout) = try!(setup_io(self.stdout));
|
||||
let (their_stderr, our_stderr) = try!(setup_io(self.stderr));
|
||||
|
||||
match ProcessImp::spawn(self, their_stdin, their_stdout, their_stderr) {
|
||||
Err(e) => Err(e),
|
||||
Ok(handle) => Ok(Process {
|
||||
handle: handle,
|
||||
forget: false,
|
||||
exit_code: None,
|
||||
exit_signal: None,
|
||||
deadline: 0,
|
||||
stdin: our_stdin,
|
||||
stdout: our_stdout,
|
||||
stderr: our_stderr,
|
||||
})
|
||||
}).map_err(IoError::from_rtio_error)
|
||||
}
|
||||
}
|
||||
|
||||
/// Executes the command as a child process, waiting for it to finish and
|
||||
@ -415,6 +393,58 @@ impl fmt::Show for Command {
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_io(io: StdioContainer) -> IoResult<(Option<PipeStream>, Option<PipeStream>)> {
|
||||
let ours;
|
||||
let theirs;
|
||||
match io {
|
||||
Ignored => {
|
||||
theirs = None;
|
||||
ours = None;
|
||||
}
|
||||
InheritFd(fd) => {
|
||||
theirs = Some(PipeStream::from_filedesc(FileDesc::new(fd, false)));
|
||||
ours = None;
|
||||
}
|
||||
CreatePipe(readable, _writable) => {
|
||||
let PipePair { reader, writer } = try!(PipeStream::pair());
|
||||
if readable {
|
||||
theirs = Some(reader);
|
||||
ours = Some(writer);
|
||||
} else {
|
||||
theirs = Some(writer);
|
||||
ours = Some(reader);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok((theirs, ours))
|
||||
}
|
||||
|
||||
// Allow the sys module to get access to the Command state
|
||||
impl sys::process::ProcessConfig<EnvKey, CString> for Command {
|
||||
fn program(&self) -> &CString {
|
||||
&self.program
|
||||
}
|
||||
fn args(&self) -> &[CString] {
|
||||
self.args.as_slice()
|
||||
}
|
||||
fn env(&self) -> Option<&EnvMap> {
|
||||
self.env.as_ref()
|
||||
}
|
||||
fn cwd(&self) -> Option<&CString> {
|
||||
self.cwd.as_ref()
|
||||
}
|
||||
fn uid(&self) -> Option<uint> {
|
||||
self.uid.clone()
|
||||
}
|
||||
fn gid(&self) -> Option<uint> {
|
||||
self.gid.clone()
|
||||
}
|
||||
fn detach(&self) -> bool {
|
||||
self.detach
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/// The output of a finished process.
|
||||
#[deriving(PartialEq, Eq, Clone)]
|
||||
pub struct ProcessOutput {
|
||||
@ -494,9 +524,7 @@ impl Process {
|
||||
/// be successfully delivered if the child has exited, but not yet been
|
||||
/// reaped.
|
||||
pub fn kill(id: libc::pid_t, signal: int) -> IoResult<()> {
|
||||
LocalIo::maybe_raise(|io| {
|
||||
io.kill(id, signal)
|
||||
}).map_err(IoError::from_rtio_error)
|
||||
unsafe { ProcessImp::killpid(id, signal) }
|
||||
}
|
||||
|
||||
/// Returns the process id of this child process
|
||||
@ -518,7 +546,42 @@ impl Process {
|
||||
///
|
||||
/// If the signal delivery fails, the corresponding error is returned.
|
||||
pub fn signal(&mut self, signal: int) -> IoResult<()> {
|
||||
self.handle.kill(signal).map_err(IoError::from_rtio_error)
|
||||
#[cfg(unix)] fn collect_status(p: &mut Process) {
|
||||
// On Linux (and possibly other unices), a process that has exited will
|
||||
// continue to accept signals because it is "defunct". The delivery of
|
||||
// signals will only fail once the child has been reaped. For this
|
||||
// reason, if the process hasn't exited yet, then we attempt to collect
|
||||
// their status with WNOHANG.
|
||||
if p.exit_code.is_none() {
|
||||
match p.handle.try_wait() {
|
||||
Some(code) => { p.exit_code = Some(code); }
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(windows)] fn collect_status(_p: &mut Process) {}
|
||||
|
||||
collect_status(self);
|
||||
|
||||
// if the process has finished, and therefore had waitpid called,
|
||||
// and we kill it, then on unix we might ending up killing a
|
||||
// newer process that happens to have the same (re-used) id
|
||||
if self.exit_code.is_some() {
|
||||
return Err(IoError {
|
||||
kind: io::InvalidInput,
|
||||
desc: "invalid argument: can't kill an exited process",
|
||||
detail: None,
|
||||
})
|
||||
}
|
||||
|
||||
// A successfully delivered signal that isn't 0 (just a poll for being
|
||||
// alive) is recorded for windows (see wait())
|
||||
match unsafe { self.handle.kill(signal) } {
|
||||
Ok(()) if signal == 0 => Ok(()),
|
||||
Ok(()) => { self.exit_signal = Some(signal); Ok(()) }
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/// Sends a signal to this child requesting that it exits. This is
|
||||
@ -545,10 +608,21 @@ impl Process {
|
||||
/// `set_timeout` and the timeout expires before the child exits.
|
||||
pub fn wait(&mut self) -> IoResult<ProcessExit> {
|
||||
drop(self.stdin.take());
|
||||
match self.handle.wait() {
|
||||
Ok(rtio::ExitSignal(s)) => Ok(ExitSignal(s)),
|
||||
Ok(rtio::ExitStatus(s)) => Ok(ExitStatus(s)),
|
||||
Err(e) => Err(IoError::from_rtio_error(e)),
|
||||
match self.exit_code {
|
||||
Some(code) => Ok(code),
|
||||
None => {
|
||||
let code = try!(self.handle.wait(self.deadline));
|
||||
// On windows, waitpid will never return a signal. If a signal
|
||||
// was successfully delivered to the process, however, we can
|
||||
// consider it as having died via a signal.
|
||||
let code = match self.exit_signal {
|
||||
None => code,
|
||||
Some(signal) if cfg!(windows) => ExitSignal(signal),
|
||||
Some(..) => code,
|
||||
};
|
||||
self.exit_code = Some(code);
|
||||
Ok(code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -594,7 +668,7 @@ impl Process {
|
||||
/// ```
|
||||
#[experimental = "the type of the timeout is likely to change"]
|
||||
pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
|
||||
self.handle.set_timeout(timeout_ms)
|
||||
self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0);
|
||||
}
|
||||
|
||||
/// Simultaneously wait for the child to exit and collect all remaining
|
||||
@ -653,7 +727,6 @@ impl Drop for Process {
|
||||
drop(self.stdin.take());
|
||||
drop(self.stdout.take());
|
||||
drop(self.stderr.take());
|
||||
drop(mem::replace(&mut self.extra_io, Vec::new()));
|
||||
|
||||
self.set_timeout(None);
|
||||
let _ = self.wait().unwrap();
|
||||
@ -1109,8 +1182,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn dont_close_fd_on_command_spawn() {
|
||||
use std::rt::rtio::{Truncate, Write};
|
||||
use self::native::io::file;
|
||||
use sys::fs;
|
||||
|
||||
let path = if cfg!(windows) {
|
||||
Path::new("NUL")
|
||||
@ -1118,7 +1190,7 @@ mod tests {
|
||||
Path::new("/dev/null")
|
||||
};
|
||||
|
||||
let mut fdes = match file::open(&path.to_c_str(), Truncate, Write) {
|
||||
let mut fdes = match fs::open(&path, Truncate, Write) {
|
||||
Ok(f) => f,
|
||||
Err(_) => panic!("failed to open file descriptor"),
|
||||
};
|
||||
@ -1126,7 +1198,7 @@ mod tests {
|
||||
let mut cmd = pwd_cmd();
|
||||
let _ = cmd.stdout(InheritFd(fdes.fd()));
|
||||
assert!(cmd.status().unwrap().success());
|
||||
assert!(fdes.inner_write("extra write\n".as_bytes()).is_ok());
|
||||
assert!(fdes.write("extra write\n".as_bytes()).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@ -20,8 +20,6 @@
|
||||
//! can be created in the future and there must be no active timers at that
|
||||
//! time.
|
||||
|
||||
#![macro_escape]
|
||||
|
||||
use mem;
|
||||
use rt::bookkeeping;
|
||||
use rt::mutex::StaticNativeMutex;
|
||||
@ -57,15 +55,6 @@ pub struct Helper<M> {
|
||||
pub initialized: UnsafeCell<bool>,
|
||||
}
|
||||
|
||||
macro_rules! helper_init( (static $name:ident: Helper<$m:ty>) => (
|
||||
static $name: Helper<$m> = Helper {
|
||||
lock: ::std::rt::mutex::NATIVE_MUTEX_INIT,
|
||||
chan: ::std::cell::UnsafeCell { value: 0 as *mut Sender<$m> },
|
||||
signal: ::std::cell::UnsafeCell { value: 0 },
|
||||
initialized: ::std::cell::UnsafeCell { value: false },
|
||||
};
|
||||
) )
|
||||
|
||||
impl<M: Send> Helper<M> {
|
||||
/// Lazily boots a helper thread, becoming a no-op if the helper has already
|
||||
/// been spawned.
|
||||
|
||||
@ -17,7 +17,6 @@ use prelude::*;
|
||||
use io::{mod, IoResult, IoError};
|
||||
use sys_common::mkerr_libc;
|
||||
|
||||
|
||||
macro_rules! helper_init( (static $name:ident: Helper<$m:ty>) => (
|
||||
static $name: Helper<$m> = Helper {
|
||||
lock: ::rt::mutex::NATIVE_MUTEX_INIT,
|
||||
@ -34,6 +33,7 @@ pub mod tcp;
|
||||
pub mod udp;
|
||||
pub mod pipe;
|
||||
pub mod helper_signal;
|
||||
pub mod process;
|
||||
|
||||
pub mod addrinfo {
|
||||
pub use sys_common::net::get_host_addresses;
|
||||
|
||||
587
src/libstd/sys/unix/process.rs
Normal file
587
src/libstd/sys/unix/process.rs
Normal file
@ -0,0 +1,587 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use libc::{mod, pid_t, c_void, c_int};
|
||||
use c_str::CString;
|
||||
use io::{mod, IoResult, IoError};
|
||||
use mem;
|
||||
use os;
|
||||
use ptr;
|
||||
use prelude::*;
|
||||
use io::process::{ProcessExit, ExitStatus, ExitSignal};
|
||||
use collections;
|
||||
use path::BytesContainer;
|
||||
use hash::Hash;
|
||||
|
||||
use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval};
|
||||
use sys::fs::FileDesc;
|
||||
use sys_common::helper_thread::Helper;
|
||||
use sys_common::{AsFileDesc, mkerr_libc, timeout};
|
||||
|
||||
pub use sys_common::ProcessConfig;
|
||||
|
||||
helper_init!(static HELPER: Helper<Req>)
|
||||
|
||||
/// The unique id of the process (this should never be negative).
|
||||
pub struct Process {
|
||||
pub pid: pid_t
|
||||
}
|
||||
|
||||
enum Req {
|
||||
NewChild(libc::pid_t, Sender<ProcessExit>, u64),
|
||||
}
|
||||
|
||||
impl Process {
|
||||
pub fn id(&self) -> pid_t {
|
||||
self.pid
|
||||
}
|
||||
|
||||
pub unsafe fn kill(&self, signal: int) -> IoResult<()> {
|
||||
Process::killpid(self.pid, signal)
|
||||
}
|
||||
|
||||
pub unsafe fn killpid(pid: pid_t, signal: int) -> IoResult<()> {
|
||||
let r = libc::funcs::posix88::signal::kill(pid, signal as c_int);
|
||||
mkerr_libc(r)
|
||||
}
|
||||
|
||||
pub fn spawn<K, V, C, P>(cfg: &C, in_fd: Option<P>,
|
||||
out_fd: Option<P>, err_fd: Option<P>)
|
||||
-> IoResult<Process>
|
||||
where C: ProcessConfig<K, V>, P: AsFileDesc,
|
||||
K: BytesContainer + Eq + Hash, V: BytesContainer
|
||||
{
|
||||
use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
|
||||
use libc::funcs::bsd44::getdtablesize;
|
||||
|
||||
mod rustrt {
|
||||
extern {
|
||||
pub fn rust_unset_sigprocmask();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
unsafe fn set_environ(envp: *const c_void) {
|
||||
extern { fn _NSGetEnviron() -> *mut *const c_void; }
|
||||
|
||||
*_NSGetEnviron() = envp;
|
||||
}
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
unsafe fn set_environ(envp: *const c_void) {
|
||||
extern { static mut environ: *const c_void; }
|
||||
environ = envp;
|
||||
}
|
||||
|
||||
unsafe fn set_cloexec(fd: c_int) {
|
||||
let ret = c::ioctl(fd, c::FIOCLEX);
|
||||
assert_eq!(ret, 0);
|
||||
}
|
||||
|
||||
let dirp = cfg.cwd().map(|c| c.as_ptr()).unwrap_or(ptr::null());
|
||||
|
||||
// temporary until unboxed closures land
|
||||
let cfg = unsafe {
|
||||
mem::transmute::<&ProcessConfig<K,V>,&'static ProcessConfig<K,V>>(cfg)
|
||||
};
|
||||
|
||||
with_envp(cfg.env(), proc(envp) {
|
||||
with_argv(cfg.program(), cfg.args(), proc(argv) unsafe {
|
||||
let (input, mut output) = try!(sys::os::pipe());
|
||||
|
||||
// We may use this in the child, so perform allocations before the
|
||||
// fork
|
||||
let devnull = "/dev/null".to_c_str();
|
||||
|
||||
set_cloexec(output.fd());
|
||||
|
||||
let pid = fork();
|
||||
if pid < 0 {
|
||||
return Err(super::last_error())
|
||||
} else if pid > 0 {
|
||||
drop(output);
|
||||
let mut bytes = [0, ..4];
|
||||
return match input.read(bytes) {
|
||||
Ok(4) => {
|
||||
let errno = (bytes[0] as i32 << 24) |
|
||||
(bytes[1] as i32 << 16) |
|
||||
(bytes[2] as i32 << 8) |
|
||||
(bytes[3] as i32 << 0);
|
||||
Err(super::decode_error(errno))
|
||||
}
|
||||
Err(..) => Ok(Process { pid: pid }),
|
||||
Ok(..) => panic!("short read on the cloexec pipe"),
|
||||
};
|
||||
}
|
||||
|
||||
// And at this point we've reached a special time in the life of the
|
||||
// child. The child must now be considered hamstrung and unable to
|
||||
// do anything other than syscalls really. Consider the following
|
||||
// scenario:
|
||||
//
|
||||
// 1. Thread A of process 1 grabs the malloc() mutex
|
||||
// 2. Thread B of process 1 forks(), creating thread C
|
||||
// 3. Thread C of process 2 then attempts to malloc()
|
||||
// 4. The memory of process 2 is the same as the memory of
|
||||
// process 1, so the mutex is locked.
|
||||
//
|
||||
// This situation looks a lot like deadlock, right? It turns out
|
||||
// that this is what pthread_atfork() takes care of, which is
|
||||
// presumably implemented across platforms. The first thing that
|
||||
// threads to *before* forking is to do things like grab the malloc
|
||||
// mutex, and then after the fork they unlock it.
|
||||
//
|
||||
// Despite this information, libnative's spawn has been witnessed to
|
||||
// deadlock on both OSX and FreeBSD. I'm not entirely sure why, but
|
||||
// all collected backtraces point at malloc/free traffic in the
|
||||
// child spawned process.
|
||||
//
|
||||
// For this reason, the block of code below should contain 0
|
||||
// invocations of either malloc of free (or their related friends).
|
||||
//
|
||||
// As an example of not having malloc/free traffic, we don't close
|
||||
// this file descriptor by dropping the FileDesc (which contains an
|
||||
// allocation). Instead we just close it manually. This will never
|
||||
// have the drop glue anyway because this code never returns (the
|
||||
// child will either exec() or invoke libc::exit)
|
||||
let _ = libc::close(input.fd());
|
||||
|
||||
fn fail(output: &mut FileDesc) -> ! {
|
||||
let errno = sys::os::errno();
|
||||
let bytes = [
|
||||
(errno >> 24) as u8,
|
||||
(errno >> 16) as u8,
|
||||
(errno >> 8) as u8,
|
||||
(errno >> 0) as u8,
|
||||
];
|
||||
assert!(output.write(bytes).is_ok());
|
||||
unsafe { libc::_exit(1) }
|
||||
}
|
||||
|
||||
rustrt::rust_unset_sigprocmask();
|
||||
|
||||
// If a stdio file descriptor is set to be ignored (via a -1 file
|
||||
// descriptor), then we don't actually close it, but rather open
|
||||
// up /dev/null into that file descriptor. Otherwise, the first file
|
||||
// descriptor opened up in the child would be numbered as one of the
|
||||
// stdio file descriptors, which is likely to wreak havoc.
|
||||
let setup = |src: Option<P>, dst: c_int| {
|
||||
let src = match src {
|
||||
None => {
|
||||
let flags = if dst == libc::STDIN_FILENO {
|
||||
libc::O_RDONLY
|
||||
} else {
|
||||
libc::O_RDWR
|
||||
};
|
||||
libc::open(devnull.as_ptr(), flags, 0)
|
||||
}
|
||||
Some(obj) => {
|
||||
let fd = obj.as_fd().fd();
|
||||
// Leak the memory and the file descriptor. We're in the
|
||||
// child now an all our resources are going to be
|
||||
// cleaned up very soon
|
||||
mem::forget(obj);
|
||||
fd
|
||||
}
|
||||
};
|
||||
src != -1 && retry(|| dup2(src, dst)) != -1
|
||||
};
|
||||
|
||||
if !setup(in_fd, libc::STDIN_FILENO) { fail(&mut output) }
|
||||
if !setup(out_fd, libc::STDOUT_FILENO) { fail(&mut output) }
|
||||
if !setup(err_fd, libc::STDERR_FILENO) { fail(&mut output) }
|
||||
|
||||
// close all other fds
|
||||
for fd in range(3, getdtablesize()).rev() {
|
||||
if fd != output.fd() {
|
||||
let _ = close(fd as c_int);
|
||||
}
|
||||
}
|
||||
|
||||
match cfg.gid() {
|
||||
Some(u) => {
|
||||
if libc::setgid(u as libc::gid_t) != 0 {
|
||||
fail(&mut output);
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
match cfg.uid() {
|
||||
Some(u) => {
|
||||
// When dropping privileges from root, the `setgroups` call
|
||||
// will remove any extraneous groups. If we don't call this,
|
||||
// then even though our uid has dropped, we may still have
|
||||
// groups that enable us to do super-user things. This will
|
||||
// fail if we aren't root, so don't bother checking the
|
||||
// return value, this is just done as an optimistic
|
||||
// privilege dropping function.
|
||||
extern {
|
||||
fn setgroups(ngroups: libc::c_int,
|
||||
ptr: *const libc::c_void) -> libc::c_int;
|
||||
}
|
||||
let _ = setgroups(0, 0 as *const libc::c_void);
|
||||
|
||||
if libc::setuid(u as libc::uid_t) != 0 {
|
||||
fail(&mut output);
|
||||
}
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
if cfg.detach() {
|
||||
// Don't check the error of setsid because it fails if we're the
|
||||
// process leader already. We just forked so it shouldn't return
|
||||
// error, but ignore it anyway.
|
||||
let _ = libc::setsid();
|
||||
}
|
||||
if !dirp.is_null() && chdir(dirp) == -1 {
|
||||
fail(&mut output);
|
||||
}
|
||||
if !envp.is_null() {
|
||||
set_environ(envp);
|
||||
}
|
||||
let _ = execvp(*argv, argv as *mut _);
|
||||
fail(&mut output);
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
pub fn wait(&self, deadline: u64) -> IoResult<ProcessExit> {
|
||||
use std::cmp;
|
||||
use std::comm;
|
||||
|
||||
static mut WRITE_FD: libc::c_int = 0;
|
||||
|
||||
let mut status = 0 as c_int;
|
||||
if deadline == 0 {
|
||||
return match retry(|| unsafe { c::waitpid(self.pid, &mut status, 0) }) {
|
||||
-1 => panic!("unknown waitpid error: {}", super::last_error()),
|
||||
_ => Ok(translate_status(status)),
|
||||
}
|
||||
}
|
||||
|
||||
// On unix, wait() and its friends have no timeout parameters, so there is
|
||||
// no way to time out a thread in wait(). From some googling and some
|
||||
// thinking, it appears that there are a few ways to handle timeouts in
|
||||
// wait(), but the only real reasonable one for a multi-threaded program is
|
||||
// to listen for SIGCHLD.
|
||||
//
|
||||
// With this in mind, the waiting mechanism with a timeout barely uses
|
||||
// waitpid() at all. There are a few times that waitpid() is invoked with
|
||||
// WNOHANG, but otherwise all the necessary blocking is done by waiting for
|
||||
// a SIGCHLD to arrive (and that blocking has a timeout). Note, however,
|
||||
// that waitpid() is still used to actually reap the child.
|
||||
//
|
||||
// Signal handling is super tricky in general, and this is no exception. Due
|
||||
// to the async nature of SIGCHLD, we use the self-pipe trick to transmit
|
||||
// data out of the signal handler to the rest of the application. The first
|
||||
// idea would be to have each thread waiting with a timeout to read this
|
||||
// output file descriptor, but a write() is akin to a signal(), not a
|
||||
// broadcast(), so it would only wake up one thread, and possibly the wrong
|
||||
// thread. Hence a helper thread is used.
|
||||
//
|
||||
// The helper thread here is responsible for farming requests for a
|
||||
// waitpid() with a timeout, and then processing all of the wait requests.
|
||||
// By guaranteeing that only this helper thread is reading half of the
|
||||
// self-pipe, we're sure that we'll never lose a SIGCHLD. This helper thread
|
||||
// is also responsible for select() to wait for incoming messages or
|
||||
// incoming SIGCHLD messages, along with passing an appropriate timeout to
|
||||
// select() to wake things up as necessary.
|
||||
//
|
||||
// The ordering of the following statements is also very purposeful. First,
|
||||
// we must be guaranteed that the helper thread is booted and available to
|
||||
// receive SIGCHLD signals, and then we must also ensure that we do a
|
||||
// nonblocking waitpid() at least once before we go ask the sigchld helper.
|
||||
// This prevents the race where the child exits, we boot the helper, and
|
||||
// then we ask for the child's exit status (never seeing a sigchld).
|
||||
//
|
||||
// The actual communication between the helper thread and this thread is
|
||||
// quite simple, just a channel moving data around.
|
||||
|
||||
unsafe { HELPER.boot(register_sigchld, waitpid_helper) }
|
||||
|
||||
match self.try_wait() {
|
||||
Some(ret) => return Ok(ret),
|
||||
None => {}
|
||||
}
|
||||
|
||||
let (tx, rx) = channel();
|
||||
unsafe { HELPER.send(NewChild(self.pid, tx, deadline)); }
|
||||
return match rx.recv_opt() {
|
||||
Ok(e) => Ok(e),
|
||||
Err(()) => Err(timeout("wait timed out")),
|
||||
};
|
||||
|
||||
// Register a new SIGCHLD handler, returning the reading half of the
|
||||
// self-pipe plus the old handler registered (return value of sigaction).
|
||||
//
|
||||
// Be sure to set up the self-pipe first because as soon as we register a
|
||||
// handler we're going to start receiving signals.
|
||||
fn register_sigchld() -> (libc::c_int, c::sigaction) {
|
||||
unsafe {
|
||||
let mut pipes = [0, ..2];
|
||||
assert_eq!(libc::pipe(pipes.as_mut_ptr()), 0);
|
||||
set_nonblocking(pipes[0], true).ok().unwrap();
|
||||
set_nonblocking(pipes[1], true).ok().unwrap();
|
||||
WRITE_FD = pipes[1];
|
||||
|
||||
let mut old: c::sigaction = mem::zeroed();
|
||||
let mut new: c::sigaction = mem::zeroed();
|
||||
new.sa_handler = sigchld_handler;
|
||||
new.sa_flags = c::SA_NOCLDSTOP;
|
||||
assert_eq!(c::sigaction(c::SIGCHLD, &new, &mut old), 0);
|
||||
(pipes[0], old)
|
||||
}
|
||||
}
|
||||
|
||||
// Helper thread for processing SIGCHLD messages
|
||||
fn waitpid_helper(input: libc::c_int,
|
||||
messages: Receiver<Req>,
|
||||
(read_fd, old): (libc::c_int, c::sigaction)) {
|
||||
set_nonblocking(input, true).ok().unwrap();
|
||||
let mut set: c::fd_set = unsafe { mem::zeroed() };
|
||||
let mut tv: libc::timeval;
|
||||
let mut active = Vec::<(libc::pid_t, Sender<ProcessExit>, u64)>::new();
|
||||
let max = cmp::max(input, read_fd) + 1;
|
||||
|
||||
'outer: loop {
|
||||
// Figure out the timeout of our syscall-to-happen. If we're waiting
|
||||
// for some processes, then they'll have a timeout, otherwise we
|
||||
// wait indefinitely for a message to arrive.
|
||||
//
|
||||
// FIXME: sure would be nice to not have to scan the entire array
|
||||
let min = active.iter().map(|a| *a.ref2()).enumerate().min_by(|p| {
|
||||
p.val1()
|
||||
});
|
||||
let (p, idx) = match min {
|
||||
Some((idx, deadline)) => {
|
||||
let now = sys::timer::now();
|
||||
let ms = if now < deadline {deadline - now} else {0};
|
||||
tv = ms_to_timeval(ms);
|
||||
(&mut tv as *mut _, idx)
|
||||
}
|
||||
None => (ptr::null_mut(), -1),
|
||||
};
|
||||
|
||||
// Wait for something to happen
|
||||
c::fd_set(&mut set, input);
|
||||
c::fd_set(&mut set, read_fd);
|
||||
match unsafe { c::select(max, &mut set, ptr::null_mut(),
|
||||
ptr::null_mut(), p) } {
|
||||
// interrupted, retry
|
||||
-1 if os::errno() == libc::EINTR as uint => continue,
|
||||
|
||||
// We read something, break out and process
|
||||
1 | 2 => {}
|
||||
|
||||
// Timeout, the pending request is removed
|
||||
0 => {
|
||||
drop(active.remove(idx));
|
||||
continue
|
||||
}
|
||||
|
||||
n => panic!("error in select {} ({})", os::errno(), n),
|
||||
}
|
||||
|
||||
// Process any pending messages
|
||||
if drain(input) {
|
||||
loop {
|
||||
match messages.try_recv() {
|
||||
Ok(NewChild(pid, tx, deadline)) => {
|
||||
active.push((pid, tx, deadline));
|
||||
}
|
||||
Err(comm::Disconnected) => {
|
||||
assert!(active.len() == 0);
|
||||
break 'outer;
|
||||
}
|
||||
Err(comm::Empty) => break,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If a child exited (somehow received SIGCHLD), then poll all
|
||||
// children to see if any of them exited.
|
||||
//
|
||||
// We also attempt to be responsible netizens when dealing with
|
||||
// SIGCHLD by invoking any previous SIGCHLD handler instead of just
|
||||
// ignoring any previous SIGCHLD handler. Note that we don't provide
|
||||
// a 1:1 mapping of our handler invocations to the previous handler
|
||||
// invocations because we drain the `read_fd` entirely. This is
|
||||
// probably OK because the kernel is already allowed to coalesce
|
||||
// simultaneous signals, we're just doing some extra coalescing.
|
||||
//
|
||||
// Another point of note is that this likely runs the signal handler
|
||||
// on a different thread than the one that received the signal. I
|
||||
// *think* this is ok at this time.
|
||||
//
|
||||
// The main reason for doing this is to allow stdtest to run native
|
||||
// tests as well. Both libgreen and libnative are running around
|
||||
// with process timeouts, but libgreen should get there first
|
||||
// (currently libuv doesn't handle old signal handlers).
|
||||
if drain(read_fd) {
|
||||
let i: uint = unsafe { mem::transmute(old.sa_handler) };
|
||||
if i != 0 {
|
||||
assert!(old.sa_flags & c::SA_SIGINFO == 0);
|
||||
(old.sa_handler)(c::SIGCHLD);
|
||||
}
|
||||
|
||||
// FIXME: sure would be nice to not have to scan the entire
|
||||
// array...
|
||||
active.retain(|&(pid, ref tx, _)| {
|
||||
let pr = Process { pid: pid };
|
||||
match pr.try_wait() {
|
||||
Some(msg) => { tx.send(msg); false }
|
||||
None => true,
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Once this helper thread is done, we re-register the old sigchld
|
||||
// handler and close our intermediate file descriptors.
|
||||
unsafe {
|
||||
assert_eq!(c::sigaction(c::SIGCHLD, &old, ptr::null_mut()), 0);
|
||||
let _ = libc::close(read_fd);
|
||||
let _ = libc::close(WRITE_FD);
|
||||
WRITE_FD = -1;
|
||||
}
|
||||
}
|
||||
|
||||
// Drain all pending data from the file descriptor, returning if any data
|
||||
// could be drained. This requires that the file descriptor is in
|
||||
// nonblocking mode.
|
||||
fn drain(fd: libc::c_int) -> bool {
|
||||
let mut ret = false;
|
||||
loop {
|
||||
let mut buf = [0u8, ..1];
|
||||
match unsafe {
|
||||
libc::read(fd, buf.as_mut_ptr() as *mut libc::c_void,
|
||||
buf.len() as libc::size_t)
|
||||
} {
|
||||
n if n > 0 => { ret = true; }
|
||||
0 => return true,
|
||||
-1 if wouldblock() => return ret,
|
||||
n => panic!("bad read {} ({})", os::last_os_error(), n),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Signal handler for SIGCHLD signals, must be async-signal-safe!
|
||||
//
|
||||
// This function will write to the writing half of the "self pipe" to wake
|
||||
// up the helper thread if it's waiting. Note that this write must be
|
||||
// nonblocking because if it blocks and the reader is the thread we
|
||||
// interrupted, then we'll deadlock.
|
||||
//
|
||||
// When writing, if the write returns EWOULDBLOCK then we choose to ignore
|
||||
// it. At that point we're guaranteed that there's something in the pipe
|
||||
// which will wake up the other end at some point, so we just allow this
|
||||
// signal to be coalesced with the pending signals on the pipe.
|
||||
extern fn sigchld_handler(_signum: libc::c_int) {
|
||||
let msg = 1i;
|
||||
match unsafe {
|
||||
libc::write(WRITE_FD, &msg as *const _ as *const libc::c_void, 1)
|
||||
} {
|
||||
1 => {}
|
||||
-1 if wouldblock() => {} // see above comments
|
||||
n => panic!("bad error on write fd: {} {}", n, os::errno()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn try_wait(&self) -> Option<ProcessExit> {
|
||||
let mut status = 0 as c_int;
|
||||
match retry(|| unsafe {
|
||||
c::waitpid(self.pid, &mut status, c::WNOHANG)
|
||||
}) {
|
||||
n if n == self.pid => Some(translate_status(status)),
|
||||
0 => None,
|
||||
n => panic!("unknown waitpid error `{}`: {}", n,
|
||||
super::last_error()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn with_argv<T>(prog: &CString, args: &[CString],
|
||||
cb: proc(*const *const libc::c_char) -> T) -> T {
|
||||
let mut ptrs: Vec<*const libc::c_char> = Vec::with_capacity(args.len()+1);
|
||||
|
||||
// Convert the CStrings into an array of pointers. Note: the
|
||||
// lifetime of the various CStrings involved is guaranteed to be
|
||||
// larger than the lifetime of our invocation of cb, but this is
|
||||
// technically unsafe as the callback could leak these pointers
|
||||
// out of our scope.
|
||||
ptrs.push(prog.as_ptr());
|
||||
ptrs.extend(args.iter().map(|tmp| tmp.as_ptr()));
|
||||
|
||||
// Add a terminating null pointer (required by libc).
|
||||
ptrs.push(ptr::null());
|
||||
|
||||
cb(ptrs.as_ptr())
|
||||
}
|
||||
|
||||
fn with_envp<K, V, T>(env: Option<&collections::HashMap<K, V>>,
|
||||
cb: proc(*const c_void) -> T) -> T
|
||||
where K: BytesContainer + Eq + Hash, V: BytesContainer
|
||||
{
|
||||
// On posixy systems we can pass a char** for envp, which is a
|
||||
// null-terminated array of "k=v\0" strings. Since we must create
|
||||
// these strings locally, yet expose a raw pointer to them, we
|
||||
// create a temporary vector to own the CStrings that outlives the
|
||||
// call to cb.
|
||||
match env {
|
||||
Some(env) => {
|
||||
let mut tmps = Vec::with_capacity(env.len());
|
||||
|
||||
for pair in env.iter() {
|
||||
let mut kv = Vec::new();
|
||||
kv.push_all(pair.ref0().container_as_bytes());
|
||||
kv.push('=' as u8);
|
||||
kv.push_all(pair.ref1().container_as_bytes());
|
||||
kv.push(0); // terminating null
|
||||
tmps.push(kv);
|
||||
}
|
||||
|
||||
// As with `with_argv`, this is unsafe, since cb could leak the pointers.
|
||||
let mut ptrs: Vec<*const libc::c_char> =
|
||||
tmps.iter()
|
||||
.map(|tmp| tmp.as_ptr() as *const libc::c_char)
|
||||
.collect();
|
||||
ptrs.push(ptr::null());
|
||||
|
||||
cb(ptrs.as_ptr() as *const c_void)
|
||||
}
|
||||
_ => cb(ptr::null())
|
||||
}
|
||||
}
|
||||
|
||||
fn translate_status(status: c_int) -> ProcessExit {
|
||||
#![allow(non_snake_case)]
|
||||
#[cfg(any(target_os = "linux", target_os = "android"))]
|
||||
mod imp {
|
||||
pub fn WIFEXITED(status: i32) -> bool { (status & 0xff) == 0 }
|
||||
pub fn WEXITSTATUS(status: i32) -> i32 { (status >> 8) & 0xff }
|
||||
pub fn WTERMSIG(status: i32) -> i32 { status & 0x7f }
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "macos",
|
||||
target_os = "ios",
|
||||
target_os = "freebsd",
|
||||
target_os = "dragonfly"))]
|
||||
mod imp {
|
||||
pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 }
|
||||
pub fn WEXITSTATUS(status: i32) -> i32 { status >> 8 }
|
||||
pub fn WTERMSIG(status: i32) -> i32 { status & 0o177 }
|
||||
}
|
||||
|
||||
if imp::WIFEXITED(status) {
|
||||
ExitStatus(imp::WEXITSTATUS(status) as int)
|
||||
} else {
|
||||
ExitSignal(imp::WTERMSIG(status) as int)
|
||||
}
|
||||
}
|
||||
@ -40,6 +40,7 @@ pub mod tcp;
|
||||
pub mod udp;
|
||||
pub mod pipe;
|
||||
pub mod helper_signal;
|
||||
pub mod process;
|
||||
|
||||
pub mod addrinfo {
|
||||
pub use sys_common::net::get_host_addresses;
|
||||
|
||||
511
src/libstd/sys/windows/process.rs
Normal file
511
src/libstd/sys/windows/process.rs
Normal file
@ -0,0 +1,511 @@
|
||||
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use libc::{pid_t, c_void, c_int};
|
||||
use libc;
|
||||
use c_str::CString;
|
||||
use io;
|
||||
use mem;
|
||||
use os;
|
||||
use ptr;
|
||||
use prelude::*;
|
||||
use io::process::{ProcessExit, ExitStatus, ExitSignal};
|
||||
use collections;
|
||||
use path::BytesContainer;
|
||||
use hash::Hash;
|
||||
use io::{IoResult, IoError};
|
||||
|
||||
use sys::fs;
|
||||
use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval, timer};
|
||||
use sys::fs::FileDesc;
|
||||
use sys_common::helper_thread::Helper;
|
||||
use sys_common::{AsFileDesc, mkerr_libc, timeout};
|
||||
|
||||
use io::fs::PathExtensions;
|
||||
use string::String;
|
||||
|
||||
pub use sys_common::ProcessConfig;
|
||||
|
||||
/**
|
||||
* A value representing a child process.
|
||||
*
|
||||
* The lifetime of this value is linked to the lifetime of the actual
|
||||
* process - the Process destructor calls self.finish() which waits
|
||||
* for the process to terminate.
|
||||
*/
|
||||
pub struct Process {
|
||||
/// The unique id of the process (this should never be negative).
|
||||
pid: pid_t,
|
||||
|
||||
/// A HANDLE to the process, which will prevent the pid being
|
||||
/// re-used until the handle is closed.
|
||||
handle: *mut (),
|
||||
}
|
||||
|
||||
impl Drop for Process {
|
||||
fn drop(&mut self) {
|
||||
free_handle(self.handle);
|
||||
}
|
||||
}
|
||||
|
||||
impl Process {
|
||||
pub fn id(&self) -> pid_t {
|
||||
self.pid
|
||||
}
|
||||
|
||||
pub unsafe fn kill(&self, signal: int) -> IoResult<()> {
|
||||
Process::killpid(self.pid, signal)
|
||||
}
|
||||
|
||||
pub unsafe fn killpid(pid: pid_t, signal: int) -> IoResult<()> {
|
||||
let handle = libc::OpenProcess(libc::PROCESS_TERMINATE |
|
||||
libc::PROCESS_QUERY_INFORMATION,
|
||||
libc::FALSE, pid as libc::DWORD);
|
||||
if handle.is_null() {
|
||||
return Err(super::last_error())
|
||||
}
|
||||
let ret = match signal {
|
||||
// test for existence on signal 0
|
||||
0 => {
|
||||
let mut status = 0;
|
||||
let ret = libc::GetExitCodeProcess(handle, &mut status);
|
||||
if ret == 0 {
|
||||
Err(super::last_error())
|
||||
} else if status != libc::STILL_ACTIVE {
|
||||
Err(IoError {
|
||||
kind: io::InvalidInput,
|
||||
desc: "no process to kill",
|
||||
detail: None,
|
||||
})
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
15 | 9 => { // sigterm or sigkill
|
||||
let ret = libc::TerminateProcess(handle, 1);
|
||||
super::mkerr_winbool(ret)
|
||||
}
|
||||
_ => Err(IoError {
|
||||
kind: io::IoUnavailable,
|
||||
desc: "unsupported signal on windows",
|
||||
detail: None,
|
||||
})
|
||||
};
|
||||
let _ = libc::CloseHandle(handle);
|
||||
return ret;
|
||||
}
|
||||
|
||||
pub fn spawn<K, V, C, P>(cfg: &C, in_fd: Option<P>,
|
||||
out_fd: Option<P>, err_fd: Option<P>)
|
||||
-> IoResult<Process>
|
||||
where C: ProcessConfig<K, V>, P: AsFileDesc,
|
||||
K: BytesContainer + Eq + Hash, V: BytesContainer
|
||||
{
|
||||
use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
|
||||
use libc::consts::os::extra::{
|
||||
TRUE, FALSE,
|
||||
STARTF_USESTDHANDLES,
|
||||
INVALID_HANDLE_VALUE,
|
||||
DUPLICATE_SAME_ACCESS
|
||||
};
|
||||
use libc::funcs::extra::kernel32::{
|
||||
GetCurrentProcess,
|
||||
DuplicateHandle,
|
||||
CloseHandle,
|
||||
CreateProcessW
|
||||
};
|
||||
use libc::funcs::extra::msvcrt::get_osfhandle;
|
||||
|
||||
use mem;
|
||||
use iter::Iterator;
|
||||
use str::StrPrelude;
|
||||
|
||||
if cfg.gid().is_some() || cfg.uid().is_some() {
|
||||
return Err(IoError {
|
||||
kind: io::IoUnavailable,
|
||||
desc: "unsupported gid/uid requested on windows",
|
||||
detail: None,
|
||||
})
|
||||
}
|
||||
|
||||
// To have the spawning semantics of unix/windows stay the same, we need to
|
||||
// read the *child's* PATH if one is provided. See #15149 for more details.
|
||||
let program = cfg.env().and_then(|env| {
|
||||
for (key, v) in env.iter() {
|
||||
if b"PATH" != key.container_as_bytes() { continue }
|
||||
|
||||
// Split the value and test each path to see if the
|
||||
// program exists.
|
||||
for path in os::split_paths(v.container_as_bytes()).into_iter() {
|
||||
let path = path.join(cfg.program().as_bytes_no_nul())
|
||||
.with_extension(os::consts::EXE_EXTENSION);
|
||||
if path.exists() {
|
||||
return Some(path.to_c_str())
|
||||
}
|
||||
}
|
||||
break
|
||||
}
|
||||
None
|
||||
});
|
||||
|
||||
unsafe {
|
||||
let mut si = zeroed_startupinfo();
|
||||
si.cb = mem::size_of::<STARTUPINFO>() as DWORD;
|
||||
si.dwFlags = STARTF_USESTDHANDLES;
|
||||
|
||||
let cur_proc = GetCurrentProcess();
|
||||
|
||||
// Similarly to unix, we don't actually leave holes for the stdio file
|
||||
// descriptors, but rather open up /dev/null equivalents. These
|
||||
// equivalents are drawn from libuv's windows process spawning.
|
||||
let set_fd = |fd: &Option<P>, slot: &mut HANDLE,
|
||||
is_stdin: bool| {
|
||||
match *fd {
|
||||
None => {
|
||||
let access = if is_stdin {
|
||||
libc::FILE_GENERIC_READ
|
||||
} else {
|
||||
libc::FILE_GENERIC_WRITE | libc::FILE_READ_ATTRIBUTES
|
||||
};
|
||||
let size = mem::size_of::<libc::SECURITY_ATTRIBUTES>();
|
||||
let mut sa = libc::SECURITY_ATTRIBUTES {
|
||||
nLength: size as libc::DWORD,
|
||||
lpSecurityDescriptor: ptr::null_mut(),
|
||||
bInheritHandle: 1,
|
||||
};
|
||||
let mut filename: Vec<u16> = "NUL".utf16_units().collect();
|
||||
filename.push(0);
|
||||
*slot = libc::CreateFileW(filename.as_ptr(),
|
||||
access,
|
||||
libc::FILE_SHARE_READ |
|
||||
libc::FILE_SHARE_WRITE,
|
||||
&mut sa,
|
||||
libc::OPEN_EXISTING,
|
||||
0,
|
||||
ptr::null_mut());
|
||||
if *slot == INVALID_HANDLE_VALUE {
|
||||
return Err(super::last_error())
|
||||
}
|
||||
}
|
||||
Some(ref fd) => {
|
||||
let orig = get_osfhandle(fd.as_fd().fd()) as HANDLE;
|
||||
if orig == INVALID_HANDLE_VALUE {
|
||||
return Err(super::last_error())
|
||||
}
|
||||
if DuplicateHandle(cur_proc, orig, cur_proc, slot,
|
||||
0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE {
|
||||
return Err(super::last_error())
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
};
|
||||
|
||||
try!(set_fd(&in_fd, &mut si.hStdInput, true));
|
||||
try!(set_fd(&out_fd, &mut si.hStdOutput, false));
|
||||
try!(set_fd(&err_fd, &mut si.hStdError, false));
|
||||
|
||||
let cmd_str = make_command_line(program.as_ref().unwrap_or(cfg.program()),
|
||||
cfg.args());
|
||||
let mut pi = zeroed_process_information();
|
||||
let mut create_err = None;
|
||||
|
||||
// stolen from the libuv code.
|
||||
let mut flags = libc::CREATE_UNICODE_ENVIRONMENT;
|
||||
if cfg.detach() {
|
||||
flags |= libc::DETACHED_PROCESS | libc::CREATE_NEW_PROCESS_GROUP;
|
||||
}
|
||||
|
||||
with_envp(cfg.env(), |envp| {
|
||||
with_dirp(cfg.cwd(), |dirp| {
|
||||
let mut cmd_str: Vec<u16> = cmd_str.as_slice().utf16_units().collect();
|
||||
cmd_str.push(0);
|
||||
let created = CreateProcessW(ptr::null(),
|
||||
cmd_str.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
TRUE,
|
||||
flags, envp, dirp,
|
||||
&mut si, &mut pi);
|
||||
if created == FALSE {
|
||||
create_err = Some(super::last_error());
|
||||
}
|
||||
})
|
||||
});
|
||||
|
||||
assert!(CloseHandle(si.hStdInput) != 0);
|
||||
assert!(CloseHandle(si.hStdOutput) != 0);
|
||||
assert!(CloseHandle(si.hStdError) != 0);
|
||||
|
||||
match create_err {
|
||||
Some(err) => return Err(err),
|
||||
None => {}
|
||||
}
|
||||
|
||||
// We close the thread handle because we don't care about keeping the
|
||||
// thread id valid, and we aren't keeping the thread handle around to be
|
||||
// able to close it later. We don't close the process handle however
|
||||
// because std::we want the process id to stay valid at least until the
|
||||
// calling code closes the process handle.
|
||||
assert!(CloseHandle(pi.hThread) != 0);
|
||||
|
||||
Ok(Process {
|
||||
pid: pi.dwProcessId as pid_t,
|
||||
handle: pi.hProcess as *mut ()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Waits for a process to exit and returns the exit code, failing
|
||||
* if there is no process with the specified id.
|
||||
*
|
||||
* Note that this is private to avoid race conditions on unix where if
|
||||
* a user calls waitpid(some_process.get_id()) then some_process.finish()
|
||||
* and some_process.destroy() and some_process.finalize() will then either
|
||||
* operate on a none-existent process or, even worse, on a newer process
|
||||
* with the same id.
|
||||
*/
|
||||
pub fn wait(&self, deadline: u64) -> IoResult<ProcessExit> {
|
||||
use libc::types::os::arch::extra::DWORD;
|
||||
use libc::consts::os::extra::{
|
||||
SYNCHRONIZE,
|
||||
PROCESS_QUERY_INFORMATION,
|
||||
FALSE,
|
||||
STILL_ACTIVE,
|
||||
INFINITE,
|
||||
WAIT_TIMEOUT,
|
||||
WAIT_OBJECT_0,
|
||||
};
|
||||
use libc::funcs::extra::kernel32::{
|
||||
OpenProcess,
|
||||
GetExitCodeProcess,
|
||||
CloseHandle,
|
||||
WaitForSingleObject,
|
||||
};
|
||||
|
||||
unsafe {
|
||||
let process = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION,
|
||||
FALSE,
|
||||
self.pid as DWORD);
|
||||
if process.is_null() {
|
||||
return Err(super::last_error())
|
||||
}
|
||||
|
||||
loop {
|
||||
let mut status = 0;
|
||||
if GetExitCodeProcess(process, &mut status) == FALSE {
|
||||
let err = Err(super::last_error());
|
||||
assert!(CloseHandle(process) != 0);
|
||||
return err;
|
||||
}
|
||||
if status != STILL_ACTIVE {
|
||||
assert!(CloseHandle(process) != 0);
|
||||
return Ok(ExitStatus(status as int));
|
||||
}
|
||||
let interval = if deadline == 0 {
|
||||
INFINITE
|
||||
} else {
|
||||
let now = timer::now();
|
||||
if deadline < now {0} else {(deadline - now) as u32}
|
||||
};
|
||||
match WaitForSingleObject(process, interval) {
|
||||
WAIT_OBJECT_0 => {}
|
||||
WAIT_TIMEOUT => {
|
||||
assert!(CloseHandle(process) != 0);
|
||||
return Err(timeout("process wait timed out"))
|
||||
}
|
||||
_ => {
|
||||
let err = Err(super::last_error());
|
||||
assert!(CloseHandle(process) != 0);
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO {
|
||||
libc::types::os::arch::extra::STARTUPINFO {
|
||||
cb: 0,
|
||||
lpReserved: ptr::null_mut(),
|
||||
lpDesktop: ptr::null_mut(),
|
||||
lpTitle: ptr::null_mut(),
|
||||
dwX: 0,
|
||||
dwY: 0,
|
||||
dwXSize: 0,
|
||||
dwYSize: 0,
|
||||
dwXCountChars: 0,
|
||||
dwYCountCharts: 0,
|
||||
dwFillAttribute: 0,
|
||||
dwFlags: 0,
|
||||
wShowWindow: 0,
|
||||
cbReserved2: 0,
|
||||
lpReserved2: ptr::null_mut(),
|
||||
hStdInput: libc::INVALID_HANDLE_VALUE,
|
||||
hStdOutput: libc::INVALID_HANDLE_VALUE,
|
||||
hStdError: libc::INVALID_HANDLE_VALUE,
|
||||
}
|
||||
}
|
||||
|
||||
fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMATION {
|
||||
libc::types::os::arch::extra::PROCESS_INFORMATION {
|
||||
hProcess: ptr::null_mut(),
|
||||
hThread: ptr::null_mut(),
|
||||
dwProcessId: 0,
|
||||
dwThreadId: 0
|
||||
}
|
||||
}
|
||||
|
||||
fn make_command_line(prog: &CString, args: &[CString]) -> String {
|
||||
let mut cmd = String::new();
|
||||
append_arg(&mut cmd, prog.as_str()
|
||||
.expect("expected program name to be utf-8 encoded"));
|
||||
for arg in args.iter() {
|
||||
cmd.push(' ');
|
||||
append_arg(&mut cmd, arg.as_str()
|
||||
.expect("expected argument to be utf-8 encoded"));
|
||||
}
|
||||
return cmd;
|
||||
|
||||
fn append_arg(cmd: &mut String, arg: &str) {
|
||||
// If an argument has 0 characters then we need to quote it to ensure
|
||||
// that it actually gets passed through on the command line or otherwise
|
||||
// it will be dropped entirely when parsed on the other end.
|
||||
let quote = arg.chars().any(|c| c == ' ' || c == '\t') || arg.len() == 0;
|
||||
if quote {
|
||||
cmd.push('"');
|
||||
}
|
||||
let argvec: Vec<char> = arg.chars().collect();
|
||||
for i in range(0u, argvec.len()) {
|
||||
append_char_at(cmd, argvec.as_slice(), i);
|
||||
}
|
||||
if quote {
|
||||
cmd.push('"');
|
||||
}
|
||||
}
|
||||
|
||||
fn append_char_at(cmd: &mut String, arg: &[char], i: uint) {
|
||||
match arg[i] {
|
||||
'"' => {
|
||||
// Escape quotes.
|
||||
cmd.push_str("\\\"");
|
||||
}
|
||||
'\\' => {
|
||||
if backslash_run_ends_in_quote(arg, i) {
|
||||
// Double all backslashes that are in runs before quotes.
|
||||
cmd.push_str("\\\\");
|
||||
} else {
|
||||
// Pass other backslashes through unescaped.
|
||||
cmd.push('\\');
|
||||
}
|
||||
}
|
||||
c => {
|
||||
cmd.push(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn backslash_run_ends_in_quote(s: &[char], mut i: uint) -> bool {
|
||||
while i < s.len() && s[i] == '\\' {
|
||||
i += 1;
|
||||
}
|
||||
return i < s.len() && s[i] == '"';
|
||||
}
|
||||
}
|
||||
|
||||
fn with_envp<K, V, T>(env: Option<&collections::HashMap<K, V>>,
|
||||
cb: |*mut c_void| -> T) -> T
|
||||
where K: BytesContainer + Eq + Hash, V: BytesContainer
|
||||
{
|
||||
// On Windows we pass an "environment block" which is not a char**, but
|
||||
// rather a concatenation of null-terminated k=v\0 sequences, with a final
|
||||
// \0 to terminate.
|
||||
match env {
|
||||
Some(env) => {
|
||||
let mut blk = Vec::new();
|
||||
|
||||
for pair in env.iter() {
|
||||
let kv = format!("{}={}",
|
||||
pair.ref0().container_as_str().unwrap(),
|
||||
pair.ref1().container_as_str().unwrap());
|
||||
blk.extend(kv.as_slice().utf16_units());
|
||||
blk.push(0);
|
||||
}
|
||||
|
||||
blk.push(0);
|
||||
|
||||
cb(blk.as_mut_ptr() as *mut c_void)
|
||||
}
|
||||
_ => cb(ptr::null_mut())
|
||||
}
|
||||
}
|
||||
|
||||
fn with_dirp<T>(d: Option<&CString>, cb: |*const u16| -> T) -> T {
|
||||
match d {
|
||||
Some(dir) => {
|
||||
let dir_str = dir.as_str()
|
||||
.expect("expected workingdirectory to be utf-8 encoded");
|
||||
let mut dir_str: Vec<u16> = dir_str.utf16_units().collect();
|
||||
dir_str.push(0);
|
||||
cb(dir_str.as_ptr())
|
||||
},
|
||||
None => cb(ptr::null())
|
||||
}
|
||||
}
|
||||
|
||||
fn free_handle(handle: *mut ()) {
|
||||
assert!(unsafe {
|
||||
libc::CloseHandle(mem::transmute(handle)) != 0
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_make_command_line() {
|
||||
use prelude::*;
|
||||
use str;
|
||||
use c_str::CString;
|
||||
use super::make_command_line;
|
||||
|
||||
fn test_wrapper(prog: &str, args: &[&str]) -> String {
|
||||
make_command_line(&prog.to_c_str(),
|
||||
args.iter()
|
||||
.map(|a| a.to_c_str())
|
||||
.collect::<Vec<CString>>()
|
||||
.as_slice())
|
||||
}
|
||||
|
||||
assert_eq!(
|
||||
test_wrapper("prog", ["aaa", "bbb", "ccc"]),
|
||||
"prog aaa bbb ccc".to_string()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
test_wrapper("C:\\Program Files\\blah\\blah.exe", ["aaa"]),
|
||||
"\"C:\\Program Files\\blah\\blah.exe\" aaa".to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
test_wrapper("C:\\Program Files\\test", ["aa\"bb"]),
|
||||
"\"C:\\Program Files\\test\" aa\\\"bb".to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
test_wrapper("echo", ["a b c"]),
|
||||
"echo \"a b c\"".to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
test_wrapper("\u03c0\u042f\u97f3\u00e6\u221e", []),
|
||||
"\u03c0\u042f\u97f3\u00e6\u221e".to_string()
|
||||
);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user