Bug: 184003702

Clone this repo:
  1. df5219d Update Android.bp by running cargo_embargo am: a9876df6f4 by James Farrell · 8 weeks ago main master
  2. a9876df Update Android.bp by running cargo_embargo by James Farrell · 9 weeks ago
  3. de04c5f Migrate to cargo_embargo. am: 8725301739 am: 2b1166aff1 am: f420b5a6dd by Andrew Walbran · 8 months ago android14-qpr3-release android14-qpr3-s2-release android-14.0.0_r50 android-14.0.0_r51 android-14.0.0_r52 android-14.0.0_r53 android-14.0.0_r54
  4. 0af49ca Migrate to cargo_embargo. am: 8725301739 am: 6973449a66 am: 42f297dca9 by Andrew Walbran · 8 months ago
  5. f420b5a Migrate to cargo_embargo. am: 8725301739 am: 2b1166aff1 by Andrew Walbran · 8 months ago

shared_child.rs Actions Status crates.io docs.rs

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.

Example

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());