fix(starry): preserve vfork parent blocking

os/StarryOS/kernel/src/syscall/task/clone.rs

@@ -155,6 +155,14 @@ impl CloneArgs {
             None
         };
 
+        // NOTE: This intentionally differs from Linux: Linux blocks the parent
+        // for every CLONE_VFORK clone regardless of the stack argument.
+        // StarryOS only blocks for bare vfork(), where the child reuses the
+        // parent's user stack. CLONE_VM | CLONE_VFORK with a private child
+        // stack is allowed to synchronize in user space, as posix_spawn-style
+        // runtimes do.
+        let needs_vfork_block = flags.contains(CloneFlags::VFORK) && stack == 0;
+
         let mut new_uctx = *uctx;
         new_uctx.prepare_clone_child_return_state();
         if stack != 0 {
@@ -283,10 +291,12 @@ impl CloneArgs {
         }
         *new_task.task_ext_mut() = Some(AxTaskExt::from_impl(thr));
 
-        // CLONE_VFORK: wire a shared `PollSet` to the child so it can wake us
-        // (PollSet, not WaitQueue, so the parent's wait is interruptible by
-        // `task.interrupt()` — see `wait_vfork_done`).
-        if flags.contains(CloneFlags::VFORK) {
+        // Bare vfork(2) reuses the parent's user stack, so the parent must
+        // sleep until the child execs or exits. posix_spawn-style clones pass
+        // a private child stack with CLONE_VM|CLONE_VFORK and synchronize in
+        // user space; blocking here can deadlock that handshake. Use PollSet
+        // so the parent's wait remains interruptible by task.interrupt().
+        if needs_vfork_block {
             let poll = Arc::new(axpoll::PollSet::new());
             new_proc_data.set_vfork_done(poll);
         }
@@ -302,7 +312,7 @@ impl CloneArgs {
         crate::kcov::on_fork(tid);
 
         // Block the parent until the child exec's or exits.
-        if flags.contains(CloneFlags::VFORK) {
+        if needs_vfork_block {
             new_proc_data.wait_vfork_done();
         }
 

test-suit/starryos/normal/qemu-smp1/syscall/test-vfork/c/src/main.c

@@ -1,5 +1,7 @@
+#define _GNU_SOURCE
 #define _DEFAULT_SOURCE
 #define _POSIX_C_SOURCE 199309L
+#include <sched.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
@@ -34,6 +36,12 @@ static inline pid_t raw_vfork(void) {
 #define do_vfork() vfork()
 #endif
 
+static int clone_child_sleep(void *arg) {
+    (void)arg;
+    sleep(2);
+    _exit(0);
+}
+
 /* Test 1: Memory Sniff - Check if vfork shares address space */
 int test_vfork_memory_sniff(void) {
     volatile int stack_var = 0;
@@ -92,15 +100,49 @@ int test_vfork_execution_order(void) {
     return 0;
 }
 
+/* Test 3: StarryOS-specific behavior. Linux blocks the parent for every
+   CLONE_VFORK clone, regardless of the stack argument, so this case would
+   fail there. StarryOS only blocks for bare vfork() with stack == 0; a
+   posix_spawn-style clone with a private child stack synchronizes in user
+   space instead. */
+int test_vfork_clone_child_stack_nonblocking(void) {
+    static char child_stack[16384];
+    char *stack_top = child_stack + sizeof(child_stack);
+    struct timespec start, end;
+
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    int pid = clone(clone_child_sleep, stack_top, CLONE_VM | CLONE_VFORK | SIGCHLD, NULL);
+    if (pid < 0) {
+        perror("clone(CLONE_VM|CLONE_VFORK) failed");
+        return -1;
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &end);
+
+    int status = 0;
+    waitpid(pid, &status, 0);
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+        return 0;
+    }
+
+    long elapsed_ms = (end.tv_sec - start.tv_sec) * 1000 +
+                      (end.tv_nsec - start.tv_nsec) / 1000000;
+
+    return (elapsed_ms < 1000) ? 1 : 0;
+}
+
 int main(void) {
-    int vfork_mem_pass = 0, vfork_exec_pass = 0;
+    int vfork_mem_pass = 0, vfork_exec_pass = 0, clone_stack_pass = 0;
 
     /* Test 1: vfork memory sharing */
     vfork_mem_pass = test_vfork_memory_sniff();
 
     /* Test 2: vfork execution blocking */
     vfork_exec_pass = test_vfork_execution_order();
 
+    /* Test 3: CLONE_VFORK with a private child stack does not block parent */
+    clone_stack_pass = test_vfork_clone_child_stack_nonblocking();
+
     /* Report results */
     if (vfork_mem_pass > 0) {
         printf("VFORK: PASS (Memory shared)\n");
@@ -114,8 +156,14 @@ int main(void) {
         printf("VFORK: FAIL (Parent NOT blocked)\n");
     }
 
-    /* Return success only if both vfork tests pass */
-    if (vfork_mem_pass > 0 && vfork_exec_pass > 0) {
+    if (clone_stack_pass > 0) {
+        printf("VFORK: PASS (Child stack clone did not block parent)\n");
+    } else {
+        printf("VFORK: FAIL (Child stack clone blocked parent)\n");
+    }
+
+    /* Return success only if all vfork-related tests pass */
+    if (vfork_mem_pass > 0 && vfork_exec_pass > 0 && clone_stack_pass > 0) {
         printf("VFORK TEST: ALL TESTS PASSED\n");
         return 0;
     } else {