manual death signal

Author: nia-e

src/alloc_addresses/mod.rs

@@ -480,7 +480,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// provenances should be exposed. Note that if `prepare_exposed_for_native_call` was not
     /// called before the FFI (with `paranoid` set to false) then some of the writes may be
     /// lost!
-    #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+    #[cfg(target_os = "linux")]
     fn apply_events(&mut self, _events: crate::shims::trace::MemEvents) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let _exposed: Vec<AllocId> =

src/bin/miri.rs

@@ -130,6 +130,15 @@ fn entry_fn(tcx: TyCtxt<'_>) -> (DefId, MiriEntryFnType) {
     }
 }
 
+/// If for whatever reason the supervisor process exists but can't see that
+/// we died, inform it manually.
+#[inline]
+fn exit(return_code: i32) -> ! {
+    #[cfg(target_os = "linux")]
+    miri::kill_sv(return_code);
+    std::process::exit(return_code)
+}
+
 impl rustc_driver::Callbacks for MiriCompilerCalls {
     fn config(&mut self, config: &mut Config) {
         config.override_queries = Some(|_, providers| {
@@ -213,7 +222,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                     if !many_seeds.keep_going {
                         // `abort_if_errors` would actually not stop, since `par_for_each` waits for the
                         // rest of the to finish, so we just exit immediately.
-                        std::process::exit(return_code);
+                        exit(return_code);
                     }
                     exit_code.store(return_code, Ordering::Relaxed);
                     num_failed.fetch_add(1, Ordering::Relaxed);
@@ -223,15 +232,15 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
             if num_failed > 0 {
                 eprintln!("{num_failed}/{total} SEEDS FAILED", total = many_seeds.seeds.count());
             }
-            std::process::exit(exit_code.0.into_inner());
+            exit(exit_code.0.into_inner());
         } else {
             let return_code = miri::eval_entry(tcx, entry_def_id, entry_type, &config, None)
                 .unwrap_or_else(|| {
                     tcx.dcx().abort_if_errors();
                     rustc_driver::EXIT_FAILURE
                 });
 
-            std::process::exit(return_code);
+            exit(return_code);
         }
 
         // Unreachable.
@@ -328,7 +337,7 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
 
 fn show_error(msg: &impl std::fmt::Display) -> ! {
     eprintln!("fatal error: {msg}");
-    std::process::exit(1)
+    exit(1)
 }
 
 macro_rules! show_error {
@@ -402,7 +411,7 @@ fn run_compiler_and_exit(
     // Invoke compiler, and handle return code.
     let exit_code =
         rustc_driver::catch_with_exit_code(move || rustc_driver::run_compiler(args, callbacks));
-    std::process::exit(exit_code)
+    exit(exit_code)
 }
 
 /// Parses a comma separated list of `T` from the given string:
@@ -481,7 +490,7 @@ fn main() {
     let env_snapshot = env::vars_os().collect::<Vec<_>>();
 
     let args = rustc_driver::catch_fatal_errors(|| rustc_driver::args::raw_args(&early_dcx))
-        .unwrap_or_else(|_| std::process::exit(rustc_driver::EXIT_FAILURE));
+        .unwrap_or_else(|_| exit(rustc_driver::EXIT_FAILURE));
 
     // Install the ctrlc handler that sets `rustc_const_eval::CTRL_C_RECEIVED`, even if
     // MIRI_BE_RUSTC is set.

src/lib.rs

@@ -76,7 +76,7 @@ mod borrow_tracker;
 mod clock;
 mod concurrency;
 mod diagnostics;
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 mod discrete_alloc;
 mod eval;
 mod helpers;
@@ -99,6 +99,10 @@ pub use rustc_const_eval::interpret::{self, AllocMap, Provenance as _};
 use rustc_middle::{bug, span_bug};
 use tracing::{info, trace};
 
+// Let bin/miri.rs kill the supervisor process.
+#[cfg(target_os = "linux")]
+pub use crate::shims::trace::kill_sv;
+
 // Type aliases that set the provenance parameter.
 pub type Pointer = interpret::Pointer<Option<machine::Provenance>>;
 pub type StrictPointer = interpret::Pointer<machine::Provenance>;

src/machine.rs

@@ -739,7 +739,7 @@ impl<'tcx> MiriMachine<'tcx> {
                 // undefined behaviour in Miri itself!
                 (
                     unsafe {
-                        #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+                        #[cfg(target_os = "linux")]
                         discrete_alloc::MachineAlloc::enable();
                         libloading::Library::new(lib_file_path)
                             .expect("failed to read specified extern shared object file")

src/shims/mod.rs

@@ -19,7 +19,7 @@ pub mod os_str;
 pub mod panic;
 pub mod time;
 pub mod tls;
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 pub mod trace;
 
 pub use self::files::FdTable;

src/shims/native_lib.rs

@@ -181,15 +181,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
 
         // Prepare all exposed memory, depending on whether we have a supervisor process.
-        #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+        #[cfg(target_os = "linux")]
         if super::trace::Supervisor::init().is_ok() {
             this.prepare_exposed_for_native_call(false)?;
         } else {
             //this.prepare_exposed_for_native_call(true)?;
             //eprintln!("Oh noes!")
             panic!("No ptrace!");
         }
-        #[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+        #[cfg(not(target_os = "linux"))]
         this.prepare_exposed_for_native_call(true)?;
 
         // Convert them to `libffi::high::Arg` type.
@@ -200,7 +200,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Call the function and store output, depending on return type in the function signature.
         let ret = this.call_native_with_args(link_name, dest, code_ptr, libffi_args)?;
-        #[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+        #[cfg(target_os = "linux")]
         if let Some(events) = super::trace::Supervisor::get_events() {
             this.apply_events(events)?;
         }
@@ -209,7 +209,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 }
 
-#[cfg(all(unix, any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(target_os = "linux")]
 unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<'_>]) -> T {
     use shims::trace::Supervisor;
 
@@ -221,7 +221,7 @@ unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<
     }
 }
 
-#[cfg(not(all(unix, any(target_arch = "x86", target_arch = "x86_64"))))]
+#[cfg(not(target_os = "linux"))]
 #[inline(always)]
 unsafe fn do_native_call<T: libffi::high::CType>(ptr: CodePtr, args: &[ffi::Arg<'_>]) -> T {
     unsafe { ffi::call(ptr, args) }

src/shims/trace.rs

@@ -82,6 +82,15 @@ pub struct Supervisor {
     r_event: ipc::IpcReceiver<MemEvents>,
 }
 
+pub fn kill_sv(code: i32) {
+    if let Ok(mut sv_guard) = SUPERVISOR.lock() {
+        if let Some(sv) = sv_guard.take() {
+            let _ = sv.t_message.send(TraceRequest::Die(code));
+            *sv_guard = Some(sv);
+        }
+    }
+}
+
 impl Supervisor {
     pub fn init() -> Result<(), ()> {
         let ptrace_status = std::fs::read_to_string("/proc/sys/kernel/yama/ptrace_scope");
@@ -185,7 +194,7 @@ impl Supervisor {
 pub enum TraceRequest {
     BeginFfi(Vec<u64>),
     EndFfi,
-    Die,
+    Die(i32),
 }
 
 #[derive(serde::Serialize, serde::Deserialize, Debug)]
@@ -427,7 +436,10 @@ fn sv_loop(listener: ChildListener, t_event: ipc::IpcSender<MemEvents>) -> ! {
                         signal::kill(main_pid, signal::SIGCONT).unwrap();
                     }
 
-                    TraceRequest::Die => break 'listen,
+                    TraceRequest::Die(child_code) => {
+                        retcode = child_code;
+                        break 'listen;
+                    }
                 },
             ExecEvent::Died(child_code) => {
                 if child_code != 0 {