---

yaml
---
r: 150356
b: refs/heads/try2
c: 68c2706
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: fd4f15ea6b04fcacc8c8446c5d725c25daab0624
+refs/heads/try2: 68c2706780031e3aac6cccea0f7b867ad5eff13a
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libnative/io/process.rs

@@ -134,18 +134,6 @@ impl rtio::RtioProcess for Process {
     }
 
     fn kill(&mut self, signum: int) -> Result<(), io::IoError> {
-        // 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 self.exit_code.is_none() {
-            match waitpid_nowait(self.pid) {
-                Some(code) => { self.exit_code = Some(code); }
-                None => {}
-            }
-        }
-
         // 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
@@ -674,31 +662,6 @@ fn free_handle(_handle: *()) {
     // unix has no process handle object, just a pid
 }
 
-#[cfg(unix)]
-fn translate_status(status: c_int) -> p::ProcessExit {
-    #[cfg(target_os = "linux")]
-    #[cfg(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(target_os = "macos")]
-    #[cfg(target_os = "freebsd")]
-    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) {
-        p::ExitStatus(imp::WEXITSTATUS(status) as int)
-    } else {
-        p::ExitSignal(imp::WTERMSIG(status) as int)
-    }
-}
-
 /**
  * Waits for a process to exit and returns the exit code, failing
  * if there is no process with the specified id.
@@ -760,31 +723,33 @@ fn waitpid(pid: pid_t) -> p::ProcessExit {
     #[cfg(unix)]
     fn waitpid_os(pid: pid_t) -> p::ProcessExit {
         use std::libc::funcs::posix01::wait;
-        let mut status = 0 as c_int;
-        match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
-            -1 => fail!("unknown waitpid error: {}", super::last_error()),
-            _ => translate_status(status),
-        }
-    }
-}
 
-fn waitpid_nowait(pid: pid_t) -> Option<p::ProcessExit> {
-    return waitpid_os(pid);
+        #[cfg(target_os = "linux")]
+        #[cfg(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 }
+        }
 
-    // This code path isn't necessary on windows
-    #[cfg(windows)]
-    fn waitpid_os(_pid: pid_t) -> Option<p::ProcessExit> { None }
+        #[cfg(target_os = "macos")]
+        #[cfg(target_os = "freebsd")]
+        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 }
+        }
 
-    #[cfg(unix)]
-    fn waitpid_os(pid: pid_t) -> Option<p::ProcessExit> {
-        use std::libc::funcs::posix01::wait;
         let mut status = 0 as c_int;
-        match retry(|| unsafe {
-            wait::waitpid(pid, &mut status, libc::WNOHANG)
-        }) {
-            n if n == pid => Some(translate_status(status)),
-            0 => None,
-            n => fail!("unknown waitpid error `{}`: {}", n, super::last_error()),
+        match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
+            -1 => fail!("unknown waitpid error: {}", super::last_error()),
+            _ => {
+                if imp::WIFEXITED(status) {
+                    p::ExitStatus(imp::WEXITSTATUS(status) as int)
+                } else {
+                    p::ExitSignal(imp::WTERMSIG(status) as int)
+                }
+            }
         }
     }
 }

branches/try2/src/libnative/lib.rs

@@ -97,6 +97,24 @@ pub fn start(argc: int, argv: **u8, main: proc()) -> int {
     // frames above our current position.
     let my_stack_bottom = my_stack_top + 20000 - OS_DEFAULT_STACK_ESTIMATE;
 
+    // When using libgreen, one of the first things that we do is to turn off
+    // the SIGPIPE signal (set it to ignore). By default, some platforms will
+    // send a *signal* when a EPIPE error would otherwise be delivered. This
+    // runtime doesn't install a SIGPIPE handler, causing it to kill the
+    // program, which isn't exactly what we want!
+    //
+    // Hence, we set SIGPIPE to ignore when the program starts up in order to
+    // prevent this problem.
+    #[cfg(windows)] fn ignore_sigpipe() {}
+    #[cfg(unix)] fn ignore_sigpipe() {
+        use std::libc;
+        use std::libc::funcs::posix01::signal::signal;
+        unsafe {
+            assert!(signal(libc::SIGPIPE, libc::SIG_IGN) != -1);
+        }
+    }
+    ignore_sigpipe();
+
     rt::init(argc, argv);
     let mut exit_code = None;
     let mut main = Some(main);

branches/try2/src/libstd/io/process.rs

@@ -331,9 +331,7 @@ impl Process {
     /// signals (SIGTERM/SIGKILL/SIGINT) are translated to `TerminateProcess`.
     ///
     /// Additionally, a signal number of 0 can check for existence of the target
-    /// process. Note, though, that on some platforms signals will continue to
-    /// be successfully delivered if the child has exited, but not yet been
-    /// reaped.
+    /// process.
     pub fn kill(id: libc::pid_t, signal: int) -> IoResult<()> {
         LocalIo::maybe_raise(|io| io.kill(id, signal))
     }
@@ -344,16 +342,8 @@ impl Process {
     /// Sends the specified signal to the child process, returning whether the
     /// signal could be delivered or not.
     ///
-    /// Note that signal 0 is interpreted as a poll to check whether the child
-    /// process is still alive or not. If an error is returned, then the child
-    /// process has exited.
-    ///
-    /// On some unix platforms signals will continue to be received after a
-    /// child has exited but not yet been reaped. In order to report the status
-    /// of signal delivery correctly, unix implementations may invoke
-    /// `waitpid()` with `WNOHANG` in order to reap the child as necessary.
-    ///
-    /// # Errors
+    /// Note that this is purely a wrapper around libuv's `uv_process_kill`
+    /// function.
     ///
     /// If the signal delivery fails, the corresponding error is returned.
     pub fn signal(&mut self, signal: int) -> IoResult<()> {
@@ -843,17 +833,4 @@ mod tests {
         p.signal_kill().unwrap();
         assert!(!p.wait().success());
     })
-
-    iotest!(fn test_zero() {
-        let mut p = sleeper();
-        p.signal_kill().unwrap();
-        for _ in range(0, 20) {
-            if p.signal(0).is_err() {
-                assert!(!p.wait().success());
-                return
-            }
-            timer::sleep(100);
-        }
-        fail!("never saw the child go away");
-    })
 }

branches/try2/src/libstd/libc.rs

@@ -266,6 +266,8 @@ pub mod types {
                 }
 
                 pub enum timezone {}
+
+                pub type sighandler_t = size_t;
             }
             pub mod bsd44 {
                 use libc::types::os::arch::c95::{c_char, c_int, c_uint};
@@ -637,6 +639,8 @@ pub mod types {
                 }
 
                 pub enum timezone {}
+
+                pub type sighandler_t = size_t;
             }
             pub mod bsd44 {
                 use libc::types::os::arch::c95::{c_char, c_int, c_uint};
@@ -1206,6 +1210,8 @@ pub mod types {
                 }
 
                 pub enum timezone {}
+
+                pub type sighandler_t = size_t;
             }
 
             pub mod bsd44 {
@@ -2292,6 +2298,8 @@ pub mod consts {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             pub static SIGTRAP : c_int = 5;
+            pub static SIGPIPE: c_int = 13;
+            pub static SIG_IGN: size_t = 1;
 
             pub static GLOB_ERR      : c_int = 1 << 0;
             pub static GLOB_MARK     : c_int = 1 << 1;
@@ -2356,8 +2364,6 @@ pub mod consts {
 
             pub static CLOCK_REALTIME: c_int = 0;
             pub static CLOCK_MONOTONIC: c_int = 1;
-
-            pub static WNOHANG: c_int = 1;
         }
         pub mod posix08 {
         }
@@ -2743,6 +2749,8 @@ pub mod consts {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             pub static SIGTRAP : c_int = 5;
+            pub static SIGPIPE: c_int = 13;
+            pub static SIG_IGN: size_t = 1;
 
             pub static GLOB_APPEND   : c_int = 0x0001;
             pub static GLOB_DOOFFS   : c_int = 0x0002;
@@ -2804,8 +2812,6 @@ pub mod consts {
 
             pub static CLOCK_REALTIME: c_int = 0;
             pub static CLOCK_MONOTONIC: c_int = 4;
-
-            pub static WNOHANG: c_int = 1;
         }
         pub mod posix08 {
         }
@@ -3140,6 +3146,8 @@ pub mod consts {
             use libc::types::os::arch::c95::{c_int, size_t};
 
             pub static SIGTRAP : c_int = 5;
+            pub static SIGPIPE: c_int = 13;
+            pub static SIG_IGN: size_t = 1;
 
             pub static GLOB_APPEND   : c_int = 0x0001;
             pub static GLOB_DOOFFS   : c_int = 0x0002;
@@ -3191,8 +3199,6 @@ pub mod consts {
             pub static PTHREAD_CREATE_JOINABLE: c_int = 1;
             pub static PTHREAD_CREATE_DETACHED: c_int = 2;
             pub static PTHREAD_STACK_MIN: size_t = 8192;
-
-            pub static WNOHANG: c_int = 1;
         }
         pub mod posix08 {
         }
@@ -3844,6 +3850,24 @@ pub mod funcs {
             }
         }
 
+        pub mod signal {
+            use libc::types::os::arch::c95::c_int;
+            use libc::types::os::common::posix01::sighandler_t;
+
+            #[cfg(not(target_os = "android"))]
+            extern {
+                pub fn signal(signum: c_int,
+                              handler: sighandler_t) -> sighandler_t;
+            }
+
+            #[cfg(target_os = "android")]
+            extern {
+                #[link_name = "bsd_signal"]
+                pub fn signal(signum: c_int,
+                              handler: sighandler_t) -> sighandler_t;
+            }
+        }
+
         pub mod wait {
             use libc::types::os::arch::c95::{c_int};
             use libc::types::os::arch::posix88::{pid_t};

branches/try2/src/test/run-pass/core-run-destroy.rs

@@ -22,12 +22,6 @@ extern crate native;
 extern crate green;
 extern crate rustuv;
 
-use std::io::Process;
-
-macro_rules! succeed( ($e:expr) => (
-    match $e { Ok(..) => {}, Err(e) => fail!("failure: {}", e) }
-) )
-
 macro_rules! iotest (
     { fn $name:ident() $b:block $($a:attr)* } => (
         mod $name {
@@ -59,29 +53,28 @@ fn start(argc: int, argv: **u8) -> int {
 }
 
 iotest!(fn test_destroy_once() {
-    let mut p = sleeper();
-    match p.signal_exit() {
-        Ok(()) => {}
-        Err(e) => fail!("error: {}", e),
-    }
-})
+    #[cfg(not(target_os="android"))]
+    static mut PROG: &'static str = "echo";
 
-#[cfg(unix)]
-pub fn sleeper() -> Process {
-    Process::new("sleep", [~"1000"]).unwrap()
-}
-#[cfg(windows)]
-pub fn sleeper() -> Process {
-    // There's a `timeout` command on windows, but it doesn't like having
-    // its output piped, so instead just ping ourselves a few times with
-    // gaps inbetweeen so we're sure this process is alive for awhile
-    Process::new("ping", [~"127.0.0.1", ~"-n", ~"1000"]).unwrap()
-}
+    #[cfg(target_os="android")]
+    static mut PROG: &'static str = "ls"; // android don't have echo binary
+
+    let mut p = unsafe {Process::new(PROG, []).unwrap()};
+    p.signal_exit().unwrap(); // this shouldn't crash (and nor should the destructor)
+})
 
 iotest!(fn test_destroy_twice() {
-    let mut p = sleeper();
-    succeed!(p.signal_exit()); // this shouldnt crash...
-    let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
+    #[cfg(not(target_os="android"))]
+    static mut PROG: &'static str = "echo";
+    #[cfg(target_os="android")]
+    static mut PROG: &'static str = "ls"; // android don't have echo binary
+
+    let mut p = match unsafe{Process::new(PROG, [])} {
+        Ok(p) => p,
+        Err(e) => fail!("wut: {}", e),
+    };
+    p.signal_exit().unwrap(); // this shouldnt crash...
+    p.signal_exit().unwrap(); // ...and nor should this (and nor should the destructor)
 })
 
 pub fn test_destroy_actually_kills(force: bool) {

branches/try2/src/test/run-pass/sigpipe-should-be-ignored.rs

@@ -0,0 +1,36 @@
+// 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.
+
+// ignore-fast
+
+// Be sure that when a SIGPIPE would have been received that the entire process
+// doesn't die in a ball of fire, but rather it's gracefully handled.
+
+use std::os;
+use std::io::{PipeStream, Process};
+
+fn test() {
+    let os::Pipe { input, out } = os::pipe();
+    let input = PipeStream::open(input);
+    let mut out = PipeStream::open(out);
+    drop(input);
+
+    let _ = out.write([1]);
+}
+
+fn main() {
+    let args = os::args();
+    if args.len() > 1 && args[1].as_slice() == "test" {
+        return test();
+    }
+
+    let mut p = Process::new(args[0], [~"test"]).unwrap();
+    assert!(p.wait().success());
+}