fix(signal): preserve fatal thread-group semantics

Start fatal group exit for thread-directed signals as Linux does, so tgkill(SIGKILL) cannot terminate only the selected pthread and leave its process leader alive.

Separate the private SIGKILL used by de_thread and an already-committed group exit from ordinary signal delivery. This keeps exec sibling teardown local without confusing external fatal signals or re-entering group-exit selection.

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

Author: fslongjin

kernel/src/ipc/generic_signal.rs

@@ -407,14 +407,14 @@ fn sig_terminate(sig: Signal) {
 
     if sig == Signal::SIGKILL {
         let current = ProcessManager::current_pcb();
-        if !current.is_thread_group_leader() {
-            // 线程级 SIGKILL：仅终止当前线程，避免误杀整个线程组
-            ProcessManager::exit(sig as usize);
-        }
         let sighand = current.sighand();
         if sighand.flags_contains(SignalFlags::GROUP_EXEC) {
             if let Some(exec_task) = sighand.group_exec_task() {
                 if !Arc::ptr_eq(&exec_task, &current) {
+                    // de_thread() privately injects SIGKILL into the siblings
+                    // that the exec owner is replacing. Only those siblings
+                    // exit individually; an externally delivered SIGKILL
+                    // targeting the exec owner remains process-fatal.
                     ProcessManager::exit(sig as usize);
                 }
             }

kernel/src/ipc/signal.rs

@@ -466,9 +466,7 @@ impl Signal {
             return;
         };
 
-        if !is_thread_target
-            && self.start_fatal_group_exit_if_needed(pcb.clone(), target_pcb.clone())
-        {
+        if self.start_fatal_group_exit_if_needed(pcb.clone(), target_pcb.clone()) {
             return;
         }
 
@@ -495,7 +493,7 @@ impl Signal {
 
         let tasks = ProcessManager::thread_group_tasks_snapshot(target);
         for task in tasks {
-            Self::queue_group_kill_to_thread(&task);
+            Self::queue_private_sigkill_to_thread(&task);
         }
 
         true
@@ -525,7 +523,13 @@ impl Signal {
         true
     }
 
-    fn queue_group_kill_to_thread(task: &Arc<ProcessControlBlock>) {
+    /// Queue the private SIGKILL used after the kernel has already committed
+    /// to tearing down sibling threads for group-exit or de_thread().
+    ///
+    /// Unlike normal signal delivery, this must not run complete_signal()
+    /// again: during de_thread() the exec owner is intentionally preserved,
+    /// while during group-exit the shared exit state is already committed.
+    pub(crate) fn queue_private_sigkill_to_thread(task: &Arc<ProcessControlBlock>) {
         if task.flags().contains(ProcessFlags::EXITING) || task.is_zombie() || task.is_dead() {
             return;
         }

kernel/src/process/exec.rs

@@ -402,7 +402,7 @@ fn de_thread(pcb: &Arc<ProcessControlBlock>) -> Result<(), SystemError> {
     }
 
     for task in kill_list {
-        let _ = Signal::SIGKILL.send_signal_info_to_pcb(None, task, PidType::PID);
+        Signal::queue_private_sigkill_to_thread(&task);
     }
 
     let pending_wait = sighand.wait_group_exec_event_killable(

kernel/src/process/manager/exit.rs

@@ -15,7 +15,6 @@ use crate::{
     driver::tty::tty_job_control::TtyJobCtrlManager,
     exception::InterruptArch,
     ipc::sighand::{NaturalParentNotifyToken, ReapTransition},
-    ipc::signal_types::{SigCode, SigInfo, SigType},
     libs::futex::{
         constant::{FutexFlag, FUTEX_BITSET_MATCH_ANY},
         futex::{Futex, RobustListHead},
@@ -476,20 +475,7 @@ impl ProcessManager {
                     if task.flags().contains(ProcessFlags::EXITING) {
                         return;
                     }
-                    let mut info = SigInfo::new(
-                        Signal::SIGKILL,
-                        0,
-                        SigCode::Kernel,
-                        SigType::Kill {
-                            pid: RawPid::new(0),
-                            uid: 0,
-                        },
-                    );
-                    let _ = Signal::SIGKILL.send_signal_info_to_pcb(
-                        Some(&mut info),
-                        task,
-                        PidType::PID,
-                    );
+                    Signal::queue_private_sigkill_to_thread(&task);
                 };
 
                 // Obtain the full thread list from the thread group leader's