fix(signal): commit fatal group exit before wakeup

Publish the shared fatal group-exit code under the sighand lock before exposing private SIGKILL pending state. This prevents de_thread cancellation from racing ahead and replacing SIGKILL with EAGAIN. Report the shared group-exit status consistently through zombie waits and natural-parent SIGCHLD notification, matching Linux observable semantics.

Signed-off-by: longjin <longjin@dragonos.org>

Author: fslongjin

kernel/src/ipc/signal.rs

@@ -431,6 +431,26 @@ impl Signal {
         compiler_fence(core::sync::atomic::Ordering::SeqCst);
         // 根据信号类型选择添加到线程级 pending 还是进程级 shared_pending
         let is_thread_target = matches!(pt, PidType::PID);
+        let target_pcb = if is_thread_target {
+            if self.wants_signal(pcb.clone()) {
+                Some(pcb.clone())
+            } else {
+                None
+            }
+        } else {
+            self.select_group_signal_target(pcb.clone())
+        };
+
+        // Linux commits SIGNAL_GROUP_EXIT and its shared exit code under the
+        // sighand lock before making a fatal signal observable to de_thread().
+        // Otherwise the exec owner can see private SIGKILL pending, cancel
+        // exec, and win the race to publish EAGAIN as the group exit status.
+        if let Some(target_pcb) = target_pcb.as_ref() {
+            if self.start_fatal_group_exit_if_needed(pcb.clone(), target_pcb.clone()) {
+                return;
+            }
+        }
+
         if is_thread_target {
             // 线程级信号：添加到线程的 sig_pending
             pcb.sig_info_mut()
@@ -449,27 +469,13 @@ impl Signal {
         // 若目标进程存在 signalfd 监听该信号，需要唤醒其等待者/epoll。
         crate::ipc::signalfd::notify_signalfd_for_pcb(&pcb, *self);
 
-        let target_pcb = if is_thread_target {
-            if self.wants_signal(pcb.clone()) {
-                Some(pcb.clone())
-            } else {
-                None
-            }
-        } else {
-            self.select_group_signal_target(pcb.clone())
-        };
-
         let Some(target_pcb) = target_pcb else {
             if is_thread_target {
                 pcb.recalc_sigpending();
             }
             return;
         };
 
-        if self.start_fatal_group_exit_if_needed(pcb.clone(), target_pcb.clone()) {
-            return;
-        }
-
         target_pcb.recalc_sigpending();
         compiler_fence(core::sync::atomic::Ordering::SeqCst);
         signal_wake_up(target_pcb, *self == Signal::SIGKILL);

kernel/src/process/exit.rs

@@ -498,9 +498,16 @@ fn report_wait_event(
                 WaitRelation::Ptraced => reap_blocked_by_group_exec(child_pcb),
             });
     if is_zombie && !delayed_zombie && kwo.options.contains(WaitOption::WEXITED) {
-        let Some(raw_wstatus) = state.raw_wstatus().map(|status| status as i32) else {
+        let Some(task_wstatus) = state.raw_wstatus().map(|status| status as i32) else {
             return CandidateDecision::Pending { can_change: false };
         };
+        // Linux wait_task_zombie() exposes signal->group_exit_code after
+        // SIGNAL_GROUP_EXIT for both natural and ptrace zombie waits.
+        let raw_wstatus = child_pcb
+            .sighand()
+            .group_exit_code_if_set()
+            .map(|status| status as i32)
+            .unwrap_or(task_wstatus);
         let consume = !kwo.options.contains(WaitOption::WNOWAIT);
         match relation {
             WaitRelation::Natural => {

kernel/src/process/manager/exit.rs

@@ -189,6 +189,14 @@ impl ProcessManager {
             .raw_wstatus()
             .expect("natural-parent exit notification requires an exited child")
             as i32;
+        // Preserve Linux's observable group-exit status even though DragonOS
+        // stores the last task's local do_exit() argument separately (for
+        // example, de_thread() may return EAGAIN after SIGKILL committed).
+        let raw_status = child
+            .sighand()
+            .group_exit_code_if_set()
+            .map(|status| status as i32)
+            .unwrap_or(raw_status);
         let (status, code) = wstatus_to_waitid_exit_info(raw_status);
         let pid = child
             .task_pid_nr_ns(PidType::PID, Some(parent.active_pid_ns()))