commit | 151e78cc127a20af138bce33c651e8358511645c | [log] [tgz] |
---|---|---|
author | Matthew Maurer <mmaurer@google.com> | Tue May 31 17:59:24 2022 +0000 |
committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | Tue May 31 17:59:24 2022 +0000 |
tree | 0d341d1e7ff03e34c59140bef5d7aa22d35c4d95 | |
parent | 0ea93d7d7c90197ee82b42cbdf27c5fbfe2c5ff3 [diff] | |
parent | fde0ecbcfe332f0d167257c7657f0fa6566c70eb [diff] |
Update TEST_MAPPING am: 6b5472c3fa am: 2f3add0fb8 am: afdf22ac76 am: fde0ecbcfe Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/shared_child/+/2107131 Change-Id: I6a934fde7e898e7feefbfaa932a553e09971abe3 Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
A library for awaiting and killing child processes from multiple threads.
The std::process::Child
type in the standard library provides wait
and kill
methods that take &mut self
, making it impossible to kill a child process while another thread is waiting on it. That design works around a race condition in Unix's waitpid
function, where a PID might get reused as soon as the wait returns, so a signal sent around the same time could accidentally get delivered to the wrong process.
However with the newer POSIX waitid
function, we can wait on a child without freeing its PID for reuse. That makes it safe to send signals concurrently. Windows has actually always supported this, by preventing PID reuse while there are still open handles to a child process. This library wraps std::process::Child
for concurrent use, backed by these APIs.
Compatibility note: The libc
crate doesn't currently support waitid
on NetBSD or OpenBSD, or on older versions of OSX. There might also be some version of OSX where the waitid
function exists but is broken. We can add a "best effort" workaround using waitpid
for these platforms as we run into them. Please file an issue if you hit this.
use shared_child::SharedChild; use std::process::Command; use std::sync::Arc; // Spawn a child that will just sleep for a long time, // and put it in an Arc to share between threads. let mut command = Command::new("python"); command.arg("-c").arg("import time; time.sleep(1000000000)"); let shared_child = SharedChild::spawn(&mut command).unwrap(); let child_arc = Arc::new(shared_child); // On another thread, wait on the child process. let child_arc_clone = child_arc.clone(); let thread = std::thread::spawn(move || { child_arc_clone.wait().unwrap() }); // While the other thread is waiting, kill the child process. // This wouldn't be possible with e.g. Arc<Mutex<Child>> from // the standard library, because the waiting thread would be // holding the mutex. child_arc.kill().unwrap(); // Join the waiting thread and get the exit status. let exit_status = thread.join().unwrap(); assert!(!exit_status.success());