Terminate child containers on program termination.

Upon receiving a termination signal, ensuring any spawned containers are also terminated. This is required since we intentional do not attach stdint to the container. This means, however, that interrupts such as Ctrl+C did not stop the build process. Likewise, termination signals such as SIGTERM merely exited cross, and did not terminate the container.

Author: Alexhuszagh

src/docker/local.rs

@@ -1,6 +1,7 @@
 use std::io;
 use std::path::Path;
 use std::process::{Command, ExitStatus};
+use std::sync::atomic::Ordering;
 
 use super::shared::*;
 use crate::errors::Result;
@@ -50,6 +51,8 @@ pub(crate) fn run(
         msg_info,
     )?;
 
+    let container = toolchain_dirs.unique_container_identifier(options.target.target())?;
+    docker.args(["--name", &container]);
     docker.arg("--rm");
 
     docker_seccomp(&mut docker, engine.kind, &options.target, &paths.metadata)
@@ -121,9 +124,22 @@ pub(crate) fn run(
             .wrap_err("when building custom image")?;
     }
 
-    docker
+    Container::create(engine.clone(), container)?;
+    let status = docker
         .arg(&image_name)
         .args(["sh", "-c", &build_command(toolchain_dirs, &cmd)])
         .run_and_get_status(msg_info, false)
-        .map_err(Into::into)
+        .map_err(Into::into);
+
+    // `cargo` generally returns 0 or 101 on completion, but isn't guaranteed
+    // to. `ExitStatus::code()` may be None if a signal caused the process to
+    // terminate or it may be a known interrupt return status (130, 137, 143).
+    // simpler: just test if the program termination handler was called.
+    // SAFETY: an atomic load.
+    let is_terminated = unsafe { crate::errors::TERMINATED.load(Ordering::SeqCst) };
+    if !is_terminated {
+        Container::exit_static();
+    }
+
+    status
 }

src/docker/shared.rs

@@ -549,6 +549,19 @@ impl Container {
         unsafe { CONTAINER.exists() }
     }
 
+    // when the `docker run` command finished.
+    // the container has already exited, so no cleanup required.
+    pub fn exit(&mut self) {
+        self.exists.store(false, Ordering::SeqCst);
+    }
+
+    pub fn exit_static() {
+        // SAFETY: an atomic store.
+        unsafe {
+            CONTAINER.exit();
+        }
+    }
+
     // when the `docker exec` command finished.
     pub fn finish(&mut self, is_tty: bool, msg_info: &mut MessageInfo) {
         // relax the no-timeout and lack of output

src/errors.rs

@@ -104,7 +104,8 @@ unsafe fn termination_handler() {
     // makes this safe regardless.
     docker::CONTAINER.terminate();
 
-    // EOWNERDEAD, seems to be the same on linux, macos, and bash on windows.
+    // all termination exit codes are 128 + signal code. the exit code is
+    // 130 for Ctrl+C or SIGINT (signal code 2) for linux, macos, and windows.
     std::process::exit(130);
 }