Signal EINTR + Asyncify updates (349 update) (#906)

* update PR to integrated signal EINTR with lind-boot

* Remove spurious set_stack_pointer call in fork child path

The set_stack_pointer call was carried over from the old asyncify branch
but is not needed in the new architecture. The fork child's stack pointer
is correctly managed by the asyncify rewind mechanism. Calling
set_stack_pointer before the rewind interfered with the fork process,
causing all fork-based tests to deadlock/timeout.

* Rewrite eintr_fork_signal test to use spin loop instead of blocking read

The original test used alarm(1) + blocking read(pipe), but RawPOSIX's
read() calls host libc::read() directly, which blocks in the host kernel.
Since SIGALRM is delivered via epoch callback (which requires wasm to be
executing), the blocking read can never be interrupted. Rewrite to use a
spin loop that allows the epoch to fire and deliver the signal.

Author: rennergade

src/wasmtime/crates/lind-common/src/lib.rs

@@ -10,7 +10,7 @@ use threei::threei::{
 };
 use threei::threei_const;
 use typemap::path_conversion::get_cstr;
-use wasmtime::Caller;
+use wasmtime::{AsContext, AsContextMut, AsyncifyState, Caller};
 use wasmtime_lind_multi_process::{get_memory_base, LindHost};
 // These syscalls (`clone`, `exec`, `exit`, `fork`) require special handling
 // inside Lind Wasmtime before delegating to RawPOSIX. For example, they may
@@ -126,6 +126,19 @@ fn add_syscall_to_linker<
                 }
             }
 
+            // If we are reaching here at rewind state, that means fork was called within
+            // a syscall-interrupted signal handler. We should restore the saved return value
+            // of the syscall that was interrupted, rather than re-executing it.
+            if let AsyncifyState::Rewind(_) = caller.as_context().get_asyncify_state() {
+                let retval = caller
+                    .as_context_mut()
+                    .get_current_syscall_rewind_data()
+                    .unwrap();
+                // let signal handler finish rest of the rewinding process
+                wasmtime_lind_multi_process::signal::signal_handler(&mut caller);
+                return retval;
+            }
+
             // Some thread-related operations must be executed against a specific thread's
             // VMContext (e.g., pthread_create/exit). Because syscalls may be interposed/routed
             // through 3i functionality and the effective thread instance cannot be reliably derived
@@ -144,7 +157,7 @@ fn add_syscall_to_linker<
                 arg2
             };
 
-            make_syscall(
+            let retval = make_syscall(
                 self_cageid,
                 call_number as u64,
                 call_name,
@@ -161,7 +174,23 @@ fn add_syscall_to_linker<
                 arg5cageid,
                 arg6,
                 arg6cageid,
-            )
+            );
+
+            // If the syscall was interrupted by a signal (EINTR), invoke the signal handler.
+            // If fork is called within the signal handler, asyncify will unwind the stack;
+            // we save the syscall return value so it can be restored on rewind.
+            if -retval == sysdefs::constants::Errno::EINTR as i32 {
+                caller.as_context_mut().append_syscall_asyncify_data(retval);
+                wasmtime_lind_multi_process::signal::signal_handler(&mut caller);
+
+                if caller.as_context().get_asyncify_state() == AsyncifyState::Unwind {
+                    return 0;
+                } else {
+                    caller.as_context_mut().pop_syscall_asyncify_data();
+                }
+            }
+
+            retval
         },
     )?;
     Ok(())

src/wasmtime/crates/lind-multi-process/src/lib.rs

@@ -305,6 +305,7 @@ impl<
         // set up unwind callback function
         let store = caller.as_context_mut().0;
         let signal_asyncify_data = store.get_signal_asyncify_data();
+        let syscall_asyncify_data = store.get_syscall_asyncify_data();
         let is_parent_thread = store.is_thread();
         store.set_on_called(Box::new(move |mut store| {
             // unwind finished and we need to stop the unwind
@@ -462,6 +463,9 @@ impl<
                         store
                             .as_context_mut()
                             .set_signal_asyncify_data(signal_asyncify_data);
+                        store
+                            .as_context_mut()
+                            .set_syscall_asyncify_data(syscall_asyncify_data);
 
                         let invoke_res = child_start_func.call(&mut store, &values, &mut results);
 

src/wasmtime/crates/wasmtime/src/runtime/store.rs

@@ -338,8 +338,15 @@ pub struct StoreOpaque {
     host_globals: Vec<StoreBox<VMHostGlobalContext>>,
 
     asyncify_state: AsyncifyState,
+    // signal asyncify data, holds the sequence of the parameters for signal handler
     signal_asyncify_data: Vec<SignalAsyncifyData>,
     signal_asyncify_counter: u64,
+    // syscall asyncify data, holds the sequence of syscall return values
+    // used to preserve syscall results across asyncify unwind/rewind cycles
+    // (e.g., when fork is called within a signal handler that interrupted a syscall)
+    syscall_asyncify_data: Vec<i32>,
+    syscall_asyncify_counter: u64,
+
     // stack top
     stack_top: u64,
     // stack bottom
@@ -548,6 +555,8 @@ impl<T> Store<T> {
                 asyncify_state: super::AsyncifyState::Normal,
                 signal_asyncify_data: Vec::new(),
                 signal_asyncify_counter: 0,
+                syscall_asyncify_data: Vec::new(),
+                syscall_asyncify_counter: 0,
                 #[cfg(feature = "component-model")]
                 num_component_instances: 0,
                 signal_handler: None,
@@ -660,6 +669,8 @@ impl<T> Store<T> {
             asyncify_state: super::AsyncifyState::Normal,
             signal_asyncify_data: Vec::new(),
             signal_asyncify_counter: 0,
+            syscall_asyncify_data: Vec::new(),
+            syscall_asyncify_counter: 0,
             #[cfg(feature = "component-model")]
             num_component_instances: 0,
             signal_handler: None,
@@ -1428,6 +1439,39 @@ impl<'a, T> StoreContextMut<'a, T> {
         self.0.signal_asyncify_counter = 0;
     }
 
+    // append the syscall retval information
+    pub fn append_syscall_asyncify_data(&mut self, retval: i32) {
+        self.0.syscall_asyncify_data.push(retval);
+    }
+
+    // pop the syscall retval information
+    pub fn pop_syscall_asyncify_data(&mut self) {
+        self.0.syscall_asyncify_data.pop();
+    }
+
+    // get the current syscall retval information
+    pub fn get_current_syscall_rewind_data(&mut self) -> Option<i32> {
+        let data = self
+            .0
+            .syscall_asyncify_data
+            .get(self.0.syscall_asyncify_counter as usize)
+            .cloned();
+        let length = self.0.syscall_asyncify_data.len();
+        if self.0.syscall_asyncify_counter == (length - 1) as u64 {
+            self.0.syscall_asyncify_counter = 0;
+        } else {
+            self.0.syscall_asyncify_counter += 1;
+        }
+        data
+    }
+
+    // set the syscall retval information
+    // used by fork to copy asyncify information
+    pub fn set_syscall_asyncify_data(&mut self, data: Vec<i32>) {
+        self.0.syscall_asyncify_data = data;
+        self.0.syscall_asyncify_counter = 0;
+    }
+
     /// get stack top
     pub fn get_stack_top(&self) -> u64 {
         self.0.stack_top
@@ -2988,6 +3032,10 @@ impl<T> StoreInner<T> {
         self.signal_asyncify_data.clone()
     }
 
+    pub fn get_syscall_asyncify_data(&mut self) -> Vec<i32> {
+        self.syscall_asyncify_data.clone()
+    }
+
     pub fn is_thread(&self) -> bool {
         self.is_thread
     }

tests/unit-tests/signal_tests/deterministic/eintr_fork_signal.c

@@ -0,0 +1,77 @@
+/*
+ * Test: fork() inside a signal handler (via epoch-delivered SIGALRM).
+ *
+ * Scenario:
+ *   1. Register a SIGALRM handler that calls fork()
+ *   2. Set alarm(1) then spin-wait (wasm execution allows epoch to fire)
+ *   3. SIGALRM fires via epoch callback, signal handler runs
+ *   4. Signal handler forks: child exits 42, parent saves child pid
+ *   5. Parent verifies child exited with status 42
+ *
+ * This exercises the asyncify unwind/rewind cycle that fork triggers
+ * inside a signal handler. The signal_asyncify_data must be preserved
+ * correctly for the child to start and the parent to resume.
+ *
+ * NOTE: Testing the EINTR-specific code path (fork inside a signal
+ * handler that interrupted a *blocking* syscall) requires RawPOSIX to
+ * support interrupting host blocking calls, which is not yet implemented.
+ */
+
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static volatile pid_t child_pid = -1;
+static volatile sig_atomic_t handler_ran = 0;
+
+static void alarm_handler(int sig)
+{
+    (void)sig;
+    pid_t pid = fork();
+    if (pid == 0) {
+        /* child: exit with a recognizable status */
+        _exit(42);
+    }
+    /* parent: save child pid for later waitpid */
+    child_pid = pid;
+    handler_ran = 1;
+}
+
+int main(void)
+{
+    int ret;
+
+    struct sigaction sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = alarm_handler;
+    sa.sa_flags = 0;
+    sigemptyset(&sa.sa_mask);
+    ret = sigaction(SIGALRM, &sa, NULL);
+    assert(ret == 0);
+
+    /* fire SIGALRM in 1 second */
+    alarm(1);
+
+    /* spin until handler fires — epoch will deliver SIGALRM
+     * during wasm execution */
+    while (!handler_ran)
+        ;
+
+    /* signal handler should have forked */
+    assert(child_pid > 0);
+
+    /* wait for the child */
+    int status;
+    pid_t waited = waitpid(child_pid, &status, 0);
+    assert(waited == child_pid);
+    assert(WIFEXITED(status));
+    assert(WEXITSTATUS(status) == 42);
+
+    printf("fork-in-signal-handler test passed\n");
+    fflush(stdout);
+    return 0;
+}