fix(process): report leader identity in SIGCHLD

Build child-exit siginfo from the explicitly notified group leader instead of the thread that happens to complete the notification transaction. Map the leader PID and UID through the parent's namespaces and report Linux-compatible CLD status and CPU times.

Add a deterministic multithreaded regression test that keeps the leader and final worker on one CPU, waits for the leader to become a zombie, differentiates the worker credentials, and verifies the parent's SIGCHLD metadata.

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

Author: fslongjin

kernel/src/ipc/signal_types.rs

@@ -572,6 +572,26 @@ impl SigInfo {
                     },
                 },
             },
+            SigType::SigChild {
+                pid,
+                uid,
+                status,
+                utime,
+                stime,
+            } => PosixSigInfo {
+                si_signo: self.sig_no,
+                si_errno: self.errno,
+                si_code: self.sig_code.as_i32(),
+                _sifields: PosixSiginfoFields {
+                    _sigchld: PosixSiginfoSigchld {
+                        si_pid: pid.data() as i32,
+                        si_uid: uid,
+                        si_status: status,
+                        si_utime: utime,
+                        si_stime: stime,
+                    },
+                },
+            },
             SigType::Alarm(pid) => PosixSigInfo {
                 si_signo: self.sig_no,
                 si_errno: self.errno,
@@ -679,6 +699,14 @@ pub enum SigType {
         uid: u32,
         sigval: PosixSigval,
     },
+    /// Kernel-generated child state notification (CLD_*).
+    SigChild {
+        pid: RawPid,
+        uid: u32,
+        status: i32,
+        utime: i64,
+        stime: i64,
+    },
     Alarm(RawPid),
     /// POSIX interval timer 发送的信号（SI_TIMER）。
     /// - `timerid`: 对应用户态 `siginfo_t::si_timerid`
@@ -708,7 +736,6 @@ pub enum SigType {
     // 后续完善下列中的具体字段
     // Timer,
     // Rt,
-    // SigChild,
     // SigFault,
     // SigSys,
 }

kernel/src/process/exit.rs

@@ -31,7 +31,7 @@ fn wstatus_to_waitid_status(raw_wstatus: i32) -> i32 {
 }
 
 #[inline(always)]
-fn wstatus_to_waitid_exit_info(raw_wstatus: i32) -> (i32, i32) {
+pub(crate) fn wstatus_to_waitid_exit_info(raw_wstatus: i32) -> (i32, i32) {
     let signal = raw_wstatus & 0x7f;
     if signal == 0 {
         (

kernel/src/process/manager/exit.rs

@@ -14,23 +14,32 @@ use crate::{
     },
     driver::tty::tty_job_control::TtyJobCtrlManager,
     exception::InterruptArch,
-    ipc::sighand::{NaturalParentNotifyToken, ReapTransition},
+    ipc::{
+        sighand::{NaturalParentNotifyToken, ReapTransition},
+        signal_types::{SigCode, SigInfo, SigType},
+    },
     libs::futex::{
         constant::{FutexFlag, FUTEX_BITSET_MATCH_ANY},
         futex::{Futex, RobustListHead},
     },
     mm::IDLE_PROCESS_ADDRESS_SPACE,
     process::{
+        exit::wstatus_to_waitid_exit_info,
         kthread::KernelThreadMechanism,
+        namespace::user_namespace::map_id_up,
         pid::{Pid, PidType},
-        ptrace, ProcessControlBlock, ProcessFlags, ProcessManager, ProcessState, RawPid,
+        ptrace,
+        resource::RUsageWho,
+        ProcessControlBlock, ProcessFlags, ProcessManager, ProcessState, RawPid,
     },
-    sched::{SchedMode, __schedule_with_current},
+    sched::{cputime::ns_to_clock_t, SchedMode, __schedule_with_current},
     smp::core::smp_get_processor_id,
     syscall::user_access::clear_user_protected,
 };
 
 impl ProcessManager {
+    const DEFAULT_OVERFLOW_UID: u32 = 65534;
+
     /// Notify the parent process after a child process exits.
     #[inline(never)]
     fn exit_notify(current: &Arc<ProcessControlBlock>) {
@@ -169,6 +178,44 @@ impl ProcessManager {
         }
     }
 
+    fn child_exit_siginfo(
+        child: &Arc<ProcessControlBlock>,
+        parent: &Arc<ProcessControlBlock>,
+        signal: Signal,
+    ) -> SigInfo {
+        let raw_status = child
+            .sched_info()
+            .state()
+            .raw_wstatus()
+            .expect("natural-parent exit notification requires an exited child")
+            as i32;
+        let (status, code) = wstatus_to_waitid_exit_info(raw_status);
+        let pid = child
+            .task_pid_nr_ns(PidType::PID, Some(parent.active_pid_ns()))
+            .unwrap_or(RawPid::new(0));
+        let child_uid =
+            u32::try_from(child.cred().uid.data()).unwrap_or(Self::DEFAULT_OVERFLOW_UID);
+        let parent_user_ns = parent.cred().user_ns.clone();
+        let uid = map_id_up(&parent_user_ns.inner.lock().uid_map, child_uid)
+            .unwrap_or(Self::DEFAULT_OVERFLOW_UID);
+        let rusage = child.get_rusage(RUsageWho::RUsageSelf).unwrap_or_default();
+        let utime = i64::try_from(ns_to_clock_t(rusage.ru_utime.to_ns())).unwrap_or(i64::MAX);
+        let stime = i64::try_from(ns_to_clock_t(rusage.ru_stime.to_ns())).unwrap_or(i64::MAX);
+
+        SigInfo::new(
+            signal,
+            0,
+            SigCode::Raw(code),
+            SigType::SigChild {
+                pid,
+                uid,
+                status,
+                utime,
+                stime,
+            },
+        )
+    }
+
     /// Complete the unique natural-parent notification transaction. Signal
     /// delivery and an optional owner-authorized autoreap happen while the
     /// phase is Pending; Done is then published before the final parent wake.
@@ -193,8 +240,10 @@ impl ProcessManager {
         let autoreap = exit_signal == Signal::SIGCHLD as i32 && (ignored || no_cldwait);
 
         if exit_signal > 0 && !(autoreap && ignored) {
+            let signal = Signal::from(exit_signal);
+            let mut info = Self::child_exit_siginfo(child, &parent, signal);
             if let Err(e) =
-                crate::ipc::kill::send_signal_to_pcb(parent.clone(), Signal::from(exit_signal))
+                signal.send_signal_info_to_pcb(Some(&mut info), parent.clone(), PidType::TGID)
             {
                 warn!(
                     "failed to send exit signal for {:?} to parent {:?}: {:?}",

user/apps/tests/dunitest/suites/normal/process_signal_fork.cc

@@ -12,7 +12,9 @@ TEST(ProcessSignalFork, PosixForkAndJobControlUnavailableOnWindows) {
 #include <pthread.h>
 #include <sched.h>
 #include <signal.h>
+#include <stdio.h>
 #include <string.h>
+#include <sys/syscall.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
@@ -89,6 +91,90 @@ class ChildProcessGuard {
     pid_t child_;
 };
 
+class SignalMaskGuard {
+public:
+    explicit SignalMaskGuard(const sigset_t& blocked) : valid_(false) {
+        valid_ = sigprocmask(SIG_BLOCK, &blocked, &old_mask_) == 0;
+    }
+    SignalMaskGuard(const SignalMaskGuard&) = delete;
+    SignalMaskGuard& operator=(const SignalMaskGuard&) = delete;
+
+    ~SignalMaskGuard() {
+        if (valid_) {
+            sigprocmask(SIG_SETMASK, &old_mask_, nullptr);
+        }
+    }
+
+    bool valid() const { return valid_; }
+
+private:
+    sigset_t old_mask_ {};
+    bool valid_;
+};
+
+struct LastThreadExitArgs {
+    int ready_fd;
+    pid_t leader_tid;
+};
+
+bool PinCurrentTaskToOneAllowedCpu() {
+    cpu_set_t available;
+    CPU_ZERO(&available);
+    if (sched_getaffinity(0, sizeof(available), &available) != 0) {
+        return false;
+    }
+
+    for (int cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
+        if (!CPU_ISSET(cpu, &available)) {
+            continue;
+        }
+        cpu_set_t target;
+        CPU_ZERO(&target);
+        CPU_SET(cpu, &target);
+        return sched_setaffinity(0, sizeof(target), &target) == 0;
+    }
+    errno = EINVAL;
+    return false;
+}
+
+char ReadProcTaskState(pid_t tgid, pid_t tid) {
+    char path[128] {};
+    snprintf(path, sizeof(path), "/proc/%d/task/%d/stat", tgid, tid);
+    FILE* stat_file = fopen(path, "r");
+    if (stat_file == nullptr) {
+        return '\0';
+    }
+
+    char line[1024] {};
+    char state = '\0';
+    if (fgets(line, sizeof(line), stat_file) != nullptr) {
+        char* comm_end = strrchr(line, ')');
+        if (comm_end != nullptr && comm_end[1] == ' ') {
+            state = comm_end[2];
+        }
+    }
+    fclose(stat_file);
+    return state;
+}
+
+void* ExitAfterLeaderThread(void* raw_args) {
+    auto* args = static_cast<LastThreadExitArgs*>(raw_args);
+    const int ready_fd = args->ready_fd;
+    const pid_t leader_tid = args->leader_tid;
+    WriteIntOrExit(ready_fd, static_cast<int>(syscall(SYS_gettid)));
+
+    for (int i = 0; i < 5000; ++i) {
+        if (ReadProcTaskState(leader_tid, leader_tid) == 'Z') {
+            if (getuid() == 0 && syscall(SYS_setuid, 1234) != 0) {
+                _exit(124);
+            }
+            return nullptr;
+        }
+        SleepForMillis(1);
+    }
+    _exit(123);
+}
+
 void* PauseForeverThread(void*) {
     for (;;) {
         pause();
@@ -121,6 +207,60 @@ void RunMultithreadedSignalChild(int ready_fd) {
 
 }  // namespace
 
+TEST(ProcessSignalFork, SigchldInfoUsesGroupLeaderWhenLastNonleaderExits) {
+    const uid_t leader_uid = getuid();
+    sigset_t blocked;
+    sigemptyset(&blocked);
+    sigaddset(&blocked, SIGCHLD);
+    SignalMaskGuard mask_guard(blocked);
+    ASSERT_TRUE(mask_guard.valid()) << "sigprocmask failed: errno=" << errno << " ("
+                                    << strerror(errno) << ")";
+
+    int ready_pipe[2] = {-1, -1};
+    ASSERT_EQ(0, pipe(ready_pipe)) << "pipe failed: " << strerror(errno);
+
+    pid_t child = fork();
+    ASSERT_GE(child, 0) << "fork failed: errno=" << errno << " (" << strerror(errno) << ")";
+    if (child == 0) {
+        close(ready_pipe[0]);
+        if (!PinCurrentTaskToOneAllowedCpu()) {
+            _exit(120);
+        }
+        LastThreadExitArgs args {ready_pipe[1], getpid()};
+        pthread_t worker {};
+        if (pthread_create(&worker, nullptr, ExitAfterLeaderThread, &args) != 0) {
+            _exit(121);
+        }
+        syscall(SYS_exit, 0);
+        _exit(122);
+    }
+    ChildProcessGuard child_guard(child);
+
+    close(ready_pipe[1]);
+    int worker_tid = -1;
+    ASSERT_TRUE(ReadInt(ready_pipe[0], &worker_tid)) << "worker did not report its tid";
+    close(ready_pipe[0]);
+    ASSERT_GT(worker_tid, 0);
+    ASSERT_NE(worker_tid, child);
+
+    siginfo_t info {};
+    timespec timeout {};
+    timeout.tv_sec = 5;
+    ASSERT_EQ(SIGCHLD, sigtimedwait(&blocked, &info, &timeout))
+        << "sigtimedwait failed: errno=" << errno << " (" << strerror(errno) << ")";
+    EXPECT_EQ(child, info.si_pid);
+    EXPECT_NE(worker_tid, info.si_pid);
+    EXPECT_EQ(leader_uid, info.si_uid);
+    EXPECT_EQ(CLD_EXITED, info.si_code);
+    EXPECT_EQ(0, info.si_status);
+
+    int status = 0;
+    ASSERT_EQ(child, waitpid(child, &status, 0));
+    child_guard.Release();
+    ASSERT_TRUE(WIFEXITED(status)) << "child status=" << status;
+    EXPECT_EQ(0, WEXITSTATUS(status));
+}
+
 TEST(ProcessSignalFork, StopContinueRaceDoesNotLeaveChildStuck) {
     pid_t child = fork();
     ASSERT_GE(child, 0) << "fork failed: errno=" << errno << " (" << strerror(errno) << ")";