Add test, address review comments, fix implementation

Co-authored-by: Copilot <copilot@github.com>

Author: Arshia001

lib/wasix/src/syscalls/mod.rs

@@ -340,11 +340,18 @@ where
             if let Poll::Ready(res) = Pin::new(&mut self.pinned_work).poll(cx) {
                 return Poll::Ready(Ok(res));
             }
-            WasiEnv::do_pending_link_operations(self.ctx, false);
+            if let Err(err) = WasiEnv::do_pending_link_operations(self.ctx, false) {
+                return Poll::Ready(Err(err));
+            }
             if let Some(signals) = self.ctx.data().thread.pop_signals_or_subscribe(cx.waker()) {
+                let only_sigwakeup = signals.iter().all(|sig| matches!(sig, Signal::Sigwakeup));
                 if let Err(err) = WasiEnv::process_signals_internal(self.ctx, signals) {
                     return Poll::Ready(Err(err));
                 }
+                if only_sigwakeup {
+                    self.ctx.data().thread.signals_subscribe(cx.waker());
+                    return Poll::Pending;
+                }
                 return Poll::Ready(Ok(Err(Errno::Intr)));
             }
             Poll::Pending
@@ -382,7 +389,9 @@ where
             return Poll::Ready(Ok(res));
         }
 
-        WasiEnv::do_pending_link_operations(self.ctx, false);
+        if let Err(err) = WasiEnv::do_pending_link_operations(self.ctx, false) {
+            return Poll::Ready(Err(err));
+        }
 
         let env = self.ctx.data();
         if let Some(forced_exit) = env.thread.try_join() {

lib/wasix/src/syscalls/wasi/fd_read.rs

@@ -307,12 +307,14 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
                     for buf in unsafe { iov_bufs.iter_uninit_slices_mut() } {
                         let local_read = socket
                             .recv(tasks.deref(), buf, Some(timeout), nonblocking, false)
-                            .await?;
+                            .await;
+                        let local_read = match local_read {
+                            Ok(n) => n,
+                            Err(Errno::Again) | Err(Errno::Timedout) if total_read > 0 => break,
+                            Err(err) => return Err(err),
+                        };
                         total_read += local_read;
-                        // A zero-byte return signals connection closed (EOF);
-                        // a short read is normal for stream sockets and does NOT
-                        // indicate end-of-stream.
-                        if local_read == 0 {
+                        if local_read < buf.len() {
                             break;
                         }
                     }
@@ -338,14 +340,17 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
                 let res = __asyncify(ctx, asyncify_timeout, async move {
                     let mut total_read = 0usize;
                     for buf in unsafe { iov_bufs.iter_slices_mut() } {
-                        let buf_len = buf.len();
                         let local_read = if nonblocking {
-                            rx.try_read(buf).ok_or(Errno::Again)?
+                            match rx.try_read(buf) {
+                                Some(n) => n,
+                                None if total_read > 0 => break,
+                                None => return Err(Errno::Again),
+                            }
                         } else {
                             virtual_fs::AsyncReadExt::read(&mut rx, buf).await?
                         };
                         total_read += local_read;
-                        if local_read < buf_len {
+                        if local_read < buf.len() {
                             break;
                         }
                     }
@@ -364,14 +369,17 @@ pub(crate) fn fd_read_internal<M: MemorySize>(
                 let res = __asyncify(ctx, asyncify_timeout, async move {
                     let mut total_read = 0usize;
                     for buf in unsafe { iov_bufs.iter_slices_mut() } {
-                        let buf_len = buf.len();
                         let local_read = if nonblocking {
-                            pipe.try_read(buf).ok_or(Errno::Again)?
+                            match pipe.try_read(buf) {
+                                Some(n) => n,
+                                None if total_read > 0 => break,
+                                None => return Err(Errno::Again),
+                            }
                         } else {
                             virtual_fs::AsyncReadExt::read(&mut pipe, buf).await?
                         };
                         total_read += local_read;
-                        if local_read < buf_len {
+                        if local_read < buf.len() {
                             break;
                         }
                     }

lib/wasix/tests/wasm_tests/fd_tests.rs

@@ -1,7 +1,35 @@
-use super::{run_build_script, run_wasm};
+use super::{run_build_script, run_wasm, run_wasm_with_stdin};
+use wasmer_wasix::Pipe;
 
 #[test]
 fn test_fd_allocate() {
     let wasm = run_build_script(file!(), "fd-allocate").unwrap();
     run_wasm(&wasm, wasm.parent().unwrap()).unwrap();
 }
+
+/// Regression test for fd_read blocking DL operations.
+///
+/// One WASM thread blocks inside `fd_read` on stdin (which never produces
+/// data). While that thread is parked, the main WASM thread must be able to
+/// call `dlopen` and load a shared library without deadlocking.  Before the
+/// fix, `fd_read` held a lock that prevented DL operations from proceeding.
+#[test]
+fn test_stdin_read_does_not_block_dlopen() {
+    let wasm = run_build_script(file!(), "stdin-dlopen-race").unwrap();
+
+    // Keep the write end alive so stdin remains blocked for the whole guest
+    // run; the guest exits explicitly after proving dlopen works.
+    let (_pipe_tx, pipe_rx) = Pipe::channel();
+
+    let result =
+        run_wasm_with_stdin(&wasm, wasm.parent().unwrap(), Box::new(pipe_rx)).unwrap();
+
+    let stdout = String::from_utf8_lossy(&result.stdout);
+    assert_eq!(
+        stdout.trim(),
+        "reader_ready\ndlopen_succeeded_after_reader_ready\nside_value=42\nsequence_ok",
+        "stderr: {}",
+        String::from_utf8_lossy(&result.stderr)
+    );
+    assert_eq!(result.exit_code, Some(0));
+}

lib/wasix/tests/wasm_tests/fd_tests/stdin-dlopen-race/build.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -ex
+
+export WASIXCC_PIC=yes
+
+# Compile the shared library
+$CC -shared side.c -o libside.so
+
+# Compile the main executable
+$CC main.c -o main

lib/wasix/tests/wasm_tests/fd_tests/stdin-dlopen-race/main.c

@@ -0,0 +1,72 @@
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static int reader_ready = 0;
+
+typedef int (*side_value_t)(void);
+
+static void *reader_thread(void *arg) {
+    (void)arg;
+
+    /* Signal to the main thread that we are about to enter fd_read. */
+    pthread_mutex_lock(&mutex);
+    reader_ready = 1;
+    pthread_cond_signal(&cond);
+    pthread_mutex_unlock(&mutex);
+
+    /* Block in fd_read on stdin.  The host provides a pipe whose write end is
+     * never written to, so this call parks indefinitely.  The process will be
+     * terminated by main() returning before this ever unblocks. */
+    char buf[64];
+    read(STDIN_FILENO, buf, sizeof(buf));
+
+    return NULL;
+}
+
+int main(void) {
+    pthread_t t;
+    pthread_create(&t, NULL, reader_thread, NULL);
+
+    /* Wait until the reader thread has set reader_ready (it is about to call
+     * read(), if it hasn't already). */
+    pthread_mutex_lock(&mutex);
+    while (!reader_ready)
+        pthread_cond_wait(&cond, &mutex);
+    pthread_mutex_unlock(&mutex);
+
+    printf("reader_ready\n");
+
+    /* Give the reader thread time to actually enter the blocking read before
+     * attempting dlopen, so this test exercises the intended race reliably. */
+    sleep(1);
+
+    /* Load a shared library while the other thread is blocked in fd_read.
+     * Before the fix this would deadlock because fd_read held a lock that
+     * the DL subsystem also needed. */
+    void *handle = dlopen("libside.so", RTLD_NOW | RTLD_LOCAL);
+    if (!handle) {
+        fprintf(stderr, "dlopen failed: %s\n", dlerror());
+        return 1;
+    }
+
+    printf("dlopen_succeeded_after_reader_ready\n");
+
+    side_value_t side_value = (side_value_t)dlsym(handle, "side_value");
+    if (!side_value) {
+        fprintf(stderr, "dlsym failed: %s\n", dlerror());
+        dlclose(handle);
+        return 1;
+    }
+
+    printf("side_value=%d\n", side_value());
+    printf("sequence_ok\n");
+    dlclose(handle);
+
+    fflush(stdout);
+    _Exit(0);
+}

lib/wasix/tests/wasm_tests/fd_tests/stdin-dlopen-race/side.c

@@ -0,0 +1 @@
+int side_value(void) { return 42; }

lib/wasix/tests/wasm_tests/mod.rs

@@ -422,6 +422,102 @@ pub fn run_wasm_with_result(
     })
 }
 
+/// Run a compiled WASM file using WasiRunner with a custom stdin.
+///
+/// Useful for testing syscalls that block on stdin (e.g. fd_read): pass the
+/// receiving end of a `Pipe::channel()` and keep the sending end alive in the
+/// caller so that stdin never returns EOF while the guest is running.
+#[allow(unused)]
+pub fn run_wasm_with_stdin(
+    wasm_path: &PathBuf,
+    dir: &Path,
+    stdin: Box<dyn wasmer_wasix::VirtualFile + Send + Sync>,
+) -> Result<WasmRunResult, anyhow::Error> {
+    let wasm_bytes = std::fs::read(wasm_path)?;
+    let engine = create_engine_for_wasm(&wasm_bytes);
+    let module_data = HashedModuleData::new(wasm_bytes);
+    let hash = *module_data.hash();
+
+    let stdout_buffer = Arc::new(Mutex::new(Vec::new()));
+    let stderr_buffer = Arc::new(Mutex::new(Vec::new()));
+    let stdout_capture = Box::new(CaptureFile::new(stdout_buffer.clone()));
+    let stderr_capture = Box::new(CaptureFile::new(stderr_buffer.clone()));
+
+    let rt = create_runtime();
+    let result = rt.block_on(async {
+        let cache_dir = get_cache_dir();
+        std::fs::create_dir_all(&cache_dir).ok();
+
+        let rt_handle = wasmer_wasix::runtime::task_manager::tokio::RuntimeOrHandle::Handle(
+            tokio::runtime::Handle::current(),
+        );
+        let tokio_task_manager =
+            Arc::new(wasmer_wasix::runtime::task_manager::tokio::TokioTaskManager::new(rt_handle));
+        let module_cache = wasmer_wasix::runtime::module_cache::SharedCache::default()
+            .with_fallback(wasmer_wasix::runtime::module_cache::FileSystemCache::new(
+                cache_dir,
+                tokio_task_manager,
+            ));
+        let arc_cache = Arc::new(module_cache);
+
+        let module = wasmer_wasix::runtime::load_module(
+            &engine,
+            &arc_cache,
+            wasmer_wasix::runtime::ModuleInput::Hashed(Cow::Borrowed(&module_data)),
+            None,
+        )
+        .await
+        .map_err(|e| anyhow::anyhow!("Failed to load module: {}", e))?;
+
+        tokio::task::block_in_place(move || {
+            let mut runner = WasiRunner::new();
+            runner
+                .with_mapped_directories([MappedDirectory {
+                    guest: dir.to_string_lossy().to_string(),
+                    host: dir.to_path_buf(),
+                }])
+                .with_mapped_directories([MappedDirectory {
+                    guest: "/lib".to_string(),
+                    host: dir.to_path_buf(),
+                }])
+                .with_current_dir(dir.to_string_lossy().to_string())
+                .with_stdin(stdin)
+                .with_stdout(stdout_capture)
+                .with_stderr(stderr_capture);
+            runner.run_wasm(
+                RuntimeOrEngine::Engine(engine),
+                wasm_path.to_string_lossy().as_ref(),
+                module,
+                hash,
+            )
+        })
+    });
+
+    let stdout = stdout_buffer.lock().unwrap().clone();
+    let stderr = stderr_buffer.lock().unwrap().clone();
+    let exit_code = match &result {
+        Ok(_) => Some(0),
+        Err(e) => {
+            let error_msg = e.to_string();
+            if let Some(code_str) = error_msg.split("ExitCode::").nth(1) {
+                if let Some(code) = code_str.split_whitespace().next() {
+                    code.parse::<i32>().ok()
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        }
+    };
+
+    Ok(WasmRunResult {
+        stdout,
+        stderr,
+        exit_code,
+    })
+}
+
 /// Run a compiled WASM file using WasiRunner
 #[allow(unused)]
 pub fn run_wasm(wasm_path: &PathBuf, dir: &Path) -> Result<(), anyhow::Error> {