fix(signal): deduplicate process-group delivery

DragonOS links every thread into PIDTYPE_PGID, unlike Linux which links only thread-group leaders. Process-group delivery therefore sent one process-directed signal per thread, allowing a blocked sibling to leave a duplicate shared pending SIGHUP that later terminated pty_test.

Select physical leader entries, deduplicate transient leaders by stable TGID identity, and prefer the live leader during de_thread handoff. Add a realtime-signal regression test that proves one killpg call creates exactly one pending instance per thread group.

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

Author: fslongjin

kernel/src/ipc/kill.rs

@@ -3,6 +3,7 @@ use crate::ipc::syscall::sys_kill::check_signal_permission_pcb_with_sig;
 use crate::process::pid::{Pid, PidType};
 use crate::process::{ProcessControlBlock, ProcessManager, RawPid};
 use crate::{arch::ipc::signal::Signal, ipc::signal_types::SigCode};
+use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::sync::atomic::compiler_fence;
@@ -73,8 +74,28 @@ pub fn send_signal_to_pcb(
 /// 参考 https://code.dragonos.org.cn/xref/linux-6.6.21/kernel/signal.c?fi=kill_pgrp#1921
 #[inline(never)]
 pub fn send_signal_to_pgid(pgid: &Arc<Pid>, sig: Signal) -> Result<usize, SystemError> {
-    // 先收集进程组中的所有进程，避免在持有锁时调用复杂操作
-    let tasks: Vec<Arc<ProcessControlBlock>> = pgid.tasks_iter(PidType::PGID).collect();
+    // Linux only links thread-group leaders into PIDTYPE_PGID. DragonOS
+    // currently links every thread, so only use physical leader entries and
+    // group them by their stable TGID identity. TGID grouping also covers the
+    // brief old/new leader overlap during de_thread().
+    let mut thread_groups: BTreeMap<usize, Arc<ProcessControlBlock>> = BTreeMap::new();
+    let physical_tasks: Vec<Arc<ProcessControlBlock>> =
+        pgid.tasks_iter(PidType::PGID).collect();
+    for task in physical_tasks {
+        if !task.is_thread_group_leader() {
+            continue;
+        }
+        let Some(tgid) = task.task_pid_ptr(PidType::TGID) else {
+            continue;
+        };
+        let representative = thread_groups
+            .entry(Arc::as_ptr(&tgid) as usize)
+            .or_insert_with(|| task.clone());
+        if !representative.is_live_thread_group_member() && task.is_live_thread_group_member() {
+            *representative = task;
+        }
+    }
+    let tasks: Vec<Arc<ProcessControlBlock>> = thread_groups.into_values().collect();
 
     // 如果进程组中没有任何进程，返回 ESRCH
     if tasks.is_empty() {

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

@@ -73,6 +73,15 @@ void* PauseForeverThread(void*) {
     return nullptr;
 }
 
+void* ReadyPauseThread(void* arg) {
+    int ready_fd = *static_cast<int*>(arg);
+    WriteByteOrExit(ready_fd, 'R');
+    for (;;) {
+        pause();
+    }
+    return nullptr;
+}
+
 void RunMultithreadedSignalChild(int ready_fd) {
     pthread_t threads[3] {};
     for (pthread_t& thread : threads) {
@@ -175,6 +184,55 @@ TEST(ProcessSignalFork, ProcessDirectedSigkillKillsStoppedChildWithPendingStopEv
     EXPECT_EQ(SIGKILL, WTERMSIG(status));
 }
 
+TEST(ProcessSignalFork, ProcessGroupSignalIsDeliveredOncePerThreadGroup) {
+    pid_t child = fork();
+    ASSERT_GE(child, 0) << "fork failed: errno=" << errno << " (" << strerror(errno) << ")";
+
+    if (child == 0) {
+        if (setsid() < 0) {
+            _exit(120);
+        }
+
+        const int signal = SIGRTMIN;
+        sigset_t blocked;
+        sigemptyset(&blocked);
+        sigaddset(&blocked, signal);
+        if (sigprocmask(SIG_BLOCK, &blocked, nullptr) != 0) {
+            _exit(121);
+        }
+
+        int ready_pipe[2] = {-1, -1};
+        if (pipe(ready_pipe) != 0) {
+            _exit(122);
+        }
+        pthread_t thread {};
+        if (pthread_create(&thread, nullptr, ReadyPauseThread, &ready_pipe[1]) != 0
+            || !ReadByte(ready_pipe[0])) {
+            _exit(123);
+        }
+
+        if (kill(0, signal) != 0) {
+            _exit(124);
+        }
+
+        timespec timeout {};
+        timeout.tv_nsec = 10 * 1000 * 1000;
+        if (sigtimedwait(&blocked, nullptr, &timeout) != signal) {
+            _exit(125);
+        }
+        errno = 0;
+        if (sigtimedwait(&blocked, nullptr, &timeout) != -1 || errno != EAGAIN) {
+            _exit(126);
+        }
+        _exit(0);
+    }
+
+    int status = 0;
+    ASSERT_EQ(child, waitpid(child, &status, 0));
+    ASSERT_TRUE(WIFEXITED(status)) << "child status=" << status;
+    EXPECT_EQ(0, WEXITSTATUS(status));
+}
+
 TEST(ProcessSignalFork, ProcessDirectedSigkillKillsMultithreadedChild) {
     int ready_pipe[2] = {-1, -1};
     ASSERT_EQ(0, pipe(ready_pipe)) << "pipe failed: " << strerror(errno);