fix(process): track live thread-group members

Replace the exit-time scan of every thread-group member with a shared live-task counter, matching Linux signal_struct::live semantics. Increment the counter only when a CLONE_THREAD task is published and consume exactly one token when each task enters exit, so the unique 1-to-0 transition owns group-finalization work.

Keep the counter in ThreadInfo rather than SigHand because CLONE_SIGHAND can be shared by distinct thread groups. This removes quadratic exit behavior and shortens the global PID membership lock's irq-disabled critical section without changing group-exec or finalization ordering.

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

Author: fslongjin

kernel/src/process/fork.rs

@@ -826,8 +826,14 @@ impl ProcessManager {
         // log::debug!("fork: clone_flags: {:?}", clone_flags);
         // 设置线程组id、组长
         if clone_flags.contains(CloneFlags::CLONE_THREAD) {
-            pcb.thread.write_irqsave().group_leader =
-                current_pcb.thread.read_irqsave().group_leader.clone();
+            let current_thread = current_pcb.thread.read_irqsave();
+            let group_leader = current_thread.group_leader.clone();
+            let thread_group_live = current_thread.thread_group_live.clone();
+            drop(current_thread);
+            let mut child_thread = pcb.thread.write_irqsave();
+            child_thread.group_leader = group_leader;
+            child_thread.thread_group_live = thread_group_live;
+            drop(child_thread);
             unsafe {
                 let ptr = pcb.as_ref() as *const ProcessControlBlock as *mut ProcessControlBlock;
                 (*ptr).tgid = current_pcb.tgid;
@@ -922,6 +928,11 @@ impl ProcessManager {
                 let inherited_tty = current_pcb.sig_info_irqsave().tty();
                 pcb.sig_info_mut().set_tty(inherited_tty);
                 current_pcb.sighand().with_group_exec_check(|| {
+                    let live = pcb
+                        .threads_read_irqsave()
+                        .thread_group_live
+                        .fetch_add(1, Ordering::Relaxed);
+                    assert_ne!(live, 0, "cannot publish a thread into a dead group");
                     pcb.attach_pid(PidType::PID);
                     pcb.task_join_group_stop();
                     group_leader

kernel/src/process/info.rs

@@ -3,6 +3,7 @@ use alloc::{
     sync::{Arc, Weak},
     vec::Vec,
 };
+use core::sync::atomic::AtomicUsize;
 
 use crate::{
     arch::ipc::signal::{SigSet, Signal},
@@ -49,6 +50,12 @@ pub struct ThreadInfo {
     /// When the current thread is the group leader, this field stores the
     /// PCBs of all threads in the group.
     pub(super) group_tasks: Vec<Weak<ProcessControlBlock>>,
+    /// Number of published tasks that have not entered the exit path.
+    ///
+    /// This is shared by exactly one thread group. It must not live in
+    /// `SigHand`, because CLONE_SIGHAND may share that object across distinct
+    /// thread groups.
+    pub(super) thread_group_live: Arc<AtomicUsize>,
 }
 
 impl Default for ThreadInfo {
@@ -65,6 +72,7 @@ impl ThreadInfo {
             vfork_done: None,
             group_leader: Weak::default(),
             group_tasks: Vec::new(),
+            thread_group_live: Arc::new(AtomicUsize::new(1)),
         }
     }
 

kernel/src/process/manager/exit.rs

@@ -134,41 +134,6 @@ impl ProcessManager {
         sighand.complete_group_exec_leader_exit(current);
     }
 
-    /// Return the stable thread-group leader and whether `current`, which has
-    /// already published EXITING, is the last live task in the group.
-    ///
-    /// The caller must hold PID_MEMBERSHIP_LOCK across both mark_exiting() and
-    /// this scan, so concurrent exits cannot both miss the unique last task.
-    fn thread_group_last_live_task(
-        current: &Arc<ProcessControlBlock>,
-    ) -> (Arc<ProcessControlBlock>, bool) {
-        let leader = current
-            .threads_read_irqsave()
-            .group_leader()
-            .unwrap_or_else(|| current.clone());
-        let leader_threads = leader.threads_read_irqsave();
-        let is_live = |task: &Arc<ProcessControlBlock>| {
-            !task.flags().contains(ProcessFlags::EXITING)
-                && !task.is_exited()
-                && !task.is_zombie()
-                && !task.is_dead()
-        };
-
-        if !Arc::ptr_eq(&leader, current) && is_live(&leader) {
-            return (leader.clone(), false);
-        }
-        for weak in &leader_threads.group_tasks {
-            let Some(task) = weak.upgrade() else {
-                continue;
-            };
-            if !Arc::ptr_eq(&task, current) && is_live(&task) {
-                return (leader.clone(), false);
-            }
-        }
-        drop(leader_threads);
-        (leader, true)
-    }
-
     fn notify_ptrace_parent(tracer: Option<(Arc<ProcessControlBlock>, i32)>) {
         if let Some((tracer, signal)) = tracer {
             if signal > 0 {
@@ -364,7 +329,17 @@ impl ProcessManager {
             let (group_leader, group_dead) = {
                 let _membership_guard = crate::process::pid::pid_membership_lock();
                 pcb.mark_exiting();
-                Self::thread_group_last_live_task(&pcb)
+                let thread = pcb.threads_read_irqsave();
+                let group_leader = thread.group_leader().unwrap_or_else(|| pcb.clone());
+                let live = thread.thread_group_live.clone();
+                drop(thread);
+                // Match Linux signal_struct::live: every successfully
+                // published thread contributes once and consumes its token on
+                // first entering do_exit(). The unique 1 -> 0 transition owns
+                // thread-group finalization without scanning group_tasks.
+                let previous = live.fetch_sub(1, Ordering::AcqRel);
+                assert_ne!(previous, 0, "thread-group live count underflow");
+                (group_leader, previous == 1)
             };
             pid = pcb.pid();
             if pid.is_child_reaper() {