fix the early init

Author: nia-e

src/bin/miri.rs

@@ -795,14 +795,12 @@ fn main() {
 
     debug!("rustc arguments: {:?}", rustc_args);
     debug!("crate arguments: {:?}", miri_config.args);
-
     #[cfg(target_os = "linux")]
     if !miri_config.native_lib.is_empty() && !miri_config.force_old_native_lib {
         // FIXME: This should display a diagnostic / warning on error
         // SAFETY: No other threads have spawned yet
         let _ = unsafe { miri::init_sv() };
     }
-
     run_compiler_and_exit(
         &rustc_args,
         &mut MiriCompilerCalls::new(miri_config, many_seeds, genmc_config),

src/shims/trace/child.rs

@@ -25,6 +25,7 @@ pub struct Supervisor {
 }
 
 /// Marker representing that an error occurred during creation of the supervisor.
+#[derive(Debug)]
 pub struct SvInitError;
 
 impl Supervisor {
@@ -185,12 +186,8 @@ pub unsafe fn init_sv() -> Result<(), SvInitError> {
                 // The child process is free to unwind, so we won't to avoid doubly freeing
                 // system resources
                 let init = std::panic::catch_unwind(|| {
-                    let listener = ChildListener {
-                        message_rx,
-                        pid: child,
-                        attached: false,
-                        override_retcode: None,
-                    };
+                    let listener =
+                        ChildListener { message_rx, attached: false, override_retcode: None };
                     // Trace as many things as possible, to be able to handle them as needed
                     let options = ptrace::Options::PTRACE_O_TRACESYSGOOD
                         | ptrace::Options::PTRACE_O_TRACECLONE
@@ -199,8 +196,8 @@ pub unsafe fn init_sv() -> Result<(), SvInitError> {
                     match ptrace::seize(child, options) {
                         // Ptrace works :D
                         Ok(_) => {
-                            let code =
-                                sv_loop(listener, event_tx, confirm_tx, page_size).unwrap_err();
+                            let code = sv_loop(listener, child, event_tx, confirm_tx, page_size)
+                                .unwrap_err();
                             // If a return code of 0 is not explicitly given, assume something went
                             // wrong and return 1
                             std::process::exit(code.unwrap_or(1))
@@ -236,7 +233,7 @@ pub unsafe fn init_sv() -> Result<(), SvInitError> {
 /// Instruct the supervisor process to return a particular code. Useful if for
 /// whatever reason this code fails to be intercepted normally. In the case of
 /// `abort_if_errors()` used in `bin/miri.rs`, the return code is erroneously
-/// given as a if this is not used.
+/// given as a 0 if this is not used.
 pub fn register_retcode_sv(code: i32) {
     let mut sv_guard = SUPERVISOR.lock().unwrap();
     if let Some(sv) = sv_guard.take() {

src/shims/trace/messages.rs

@@ -12,7 +12,7 @@
 //! ```
 //! `TraceRequest::OverrideRetcode` can be sent at any point in the above, including
 //! before or after all of them.
-//! 
+//!
 //! NB: sending these events out of order, skipping steps, etc. will result in
 //! unspecified behaviour from the supervisor process, so use the abstractions
 //! in `super::child` (namely `start_ffi()` and `end_ffi()`) to handle this. It is

src/shims/trace/parent.rs

@@ -125,8 +125,6 @@ pub enum ExecEvent {
 pub struct ChildListener {
     /// The matching channel for the child's `Supervisor` struct.
     pub message_rx: ipc::IpcReceiver<TraceRequest>,
-    /// The main child process' pid.
-    pub pid: unistd::Pid,
     /// Whether an FFI call is currently ongoing.
     pub attached: bool,
     /// If `Some`, overrides the return code with the given value.
@@ -179,11 +177,8 @@ impl Iterator for ChildListener {
                                     return Some(ExecEvent::Status(pid, signal));
                                 }
                             } else {
-                                // Log that this happened and pass along the signal.
-                                // If we don't do the kill, the child will instead
-                                // act as if it never received this signal!
-                                eprintln!("Ignoring PtraceEvent {signal:?}");
-                                signal::kill(pid, signal).unwrap();
+                                // Just pass along the signal
+                                ptrace::cont(pid, signal).unwrap();
                             },
                         // Child was stopped at the given signal. Same logic as for
                         // WaitStatus::PtraceEvent
@@ -196,8 +191,7 @@ impl Iterator for ChildListener {
                                     return Some(ExecEvent::Status(pid, signal));
                                 }
                             } else {
-                                eprintln!("Ignoring Stopped {signal:?}");
-                                signal::kill(pid, signal).unwrap();
+                                ptrace::cont(pid, signal).unwrap();
                             },
                         _ => (),
                     },
@@ -242,6 +236,7 @@ enum ExecError {
 /// created before the fork - like statics - are the same).
 pub fn sv_loop(
     listener: ChildListener,
+    init_pid: unistd::Pid,
     event_tx: ipc::IpcSender<MemEvents>,
     confirm_tx: ipc::IpcSender<Confirmation>,
     page_size: usize,
@@ -256,18 +251,18 @@ pub fn sv_loop(
     // An instance of the Capstone disassembler, so we don't spawn one on every access
     let cs = get_disasm();
 
-    // The pid of the process that we forked from, used by default if we don't
-    // have a reason to use another one.
-    let main_pid = listener.pid;
+    // The pid of the last process we interacted with, used by default if we don't have a
+    // reason to use a different one
+    let mut curr_pid = init_pid;
 
     // There's an initial sigstop we need to deal with
-    wait_for_signal(main_pid, signal::SIGSTOP, false).map_err(|e| {
+    wait_for_signal(Some(curr_pid), signal::SIGSTOP, false).map_err(|e| {
         match e {
             ExecError::Died(code) => code,
             ExecError::Shrug => None,
         }
     })?;
-    ptrace::cont(main_pid, None).unwrap();
+    ptrace::cont(curr_pid, None).unwrap();
 
     for evt in listener {
         match evt {
@@ -283,9 +278,11 @@ pub fn sv_loop(
                 // raise a SIGSTOP. We need it to be signal-stopped *and waited for* in
                 // order to do most ptrace operations!
                 confirm_tx.send(Confirmation).unwrap();
-                wait_for_signal(main_pid, signal::SIGSTOP, false).unwrap();
+                // We can't trust simply calling `Pid::this()` in the child process to give the right
+                // PID for us, so we get it this way
+                curr_pid = wait_for_signal(None, signal::SIGSTOP, false).unwrap();
 
-                ptrace::syscall(main_pid, None).unwrap();
+                ptrace::syscall(curr_pid, None).unwrap();
             }
             // end_ffi was called by the child
             ExecEvent::End => {
@@ -296,7 +293,7 @@ pub fn sv_loop(
                 ch_stack = None;
 
                 // No need to monitor syscalls anymore, they'd just be ignored
-                ptrace::cont(main_pid, None).unwrap();
+                ptrace::cont(curr_pid, None).unwrap();
             }
             // Child process was stopped by a signal
             ExecEvent::Status(pid, signal) =>
@@ -370,41 +367,45 @@ fn get_disasm() -> capstone::Capstone {
 
 /// Waits for `wait_signal`. If `init_cont`, it will first do a `ptrace::cont`.
 /// We want to avoid that in some cases, like at the beginning of FFI.
+///
+/// If `pid` is `None`, only one wait will be done and `init_cont` should be false.
 fn wait_for_signal(
-    pid: unistd::Pid,
+    pid: Option<unistd::Pid>,
     wait_signal: signal::Signal,
     init_cont: bool,
-) -> Result<(), ExecError> {
+) -> Result<unistd::Pid, ExecError> {
     if init_cont {
-        ptrace::cont(pid, None).unwrap();
+        ptrace::cont(pid.unwrap(), None).unwrap();
     }
     // Repeatedly call `waitid` until we get the signal we want, or the process dies
     loop {
-        let stat =
-            wait::waitid(wait::Id::Pid(pid), WAIT_FLAGS).map_err(|_| ExecError::Died(None))?;
-        let signal = match stat {
+        let wait_id = match pid {
+            Some(pid) => wait::Id::Pid(pid),
+            None => wait::Id::All,
+        };
+        let stat = wait::waitid(wait_id, WAIT_FLAGS).map_err(|_| ExecError::Died(None))?;
+        let (signal, pid) = match stat {
             // Report the cause of death, if we know it
             wait::WaitStatus::Exited(_, code) => {
                 //eprintln!("Exited sig1 {code}");
                 return Err(ExecError::Died(Some(code)));
             }
             wait::WaitStatus::Signaled(_, _, _) => return Err(ExecError::Died(None)),
-            wait::WaitStatus::Stopped(_, signal) => signal,
-            wait::WaitStatus::PtraceEvent(_, signal, _) => signal,
+            wait::WaitStatus::Stopped(pid, signal) => (signal, pid),
+            wait::WaitStatus::PtraceEvent(pid, signal, _) => (signal, pid),
             // This covers PtraceSyscall and variants that are impossible with
             // the flags set (e.g. WaitStatus::StillAlive)
             _ => {
-                ptrace::cont(pid, None).unwrap();
+                ptrace::cont(pid.unwrap(), None).unwrap();
                 continue;
             }
         };
         if signal == wait_signal {
-            break;
+            return Ok(pid);
         } else {
             ptrace::cont(pid, None).map_err(|_| ExecError::Died(None))?;
         }
     }
-    Ok(())
 }
 
 /// Grabs the access that caused a segfault and logs it down if it's to our memory,
@@ -582,7 +583,7 @@ fn handle_segfault(
         ptrace::setregs(pid, new_regs).unwrap();
 
         // Our mempr_* functions end with a raise(SIGSTOP)
-        wait_for_signal(pid, signal::SIGSTOP, true)?;
+        wait_for_signal(Some(pid), signal::SIGSTOP, true)?;
 
         // Step 1 instruction
         ptrace::setregs(pid, regs_bak).unwrap();
@@ -625,7 +626,7 @@ fn handle_segfault(
         new_regs.set_ip(mempr_on as usize);
         new_regs.set_sp(stack_ptr);
         ptrace::setregs(pid, new_regs).unwrap();
-        wait_for_signal(pid, signal::SIGSTOP, true)?;
+        wait_for_signal(Some(pid), signal::SIGSTOP, true)?;
 
         ptrace::setregs(pid, regs_bak).unwrap();
         ptrace::syscall(pid, None).unwrap();