fix(process): serialize non-leader exec handoff (#2156)

Model non-leader exec as an owned group-exec transaction that serializes sibling teardown, old-leader exit, fatal cancellation, identity migration, and observer visibility.

Atomically preserve PID/TGID/PGID/SID membership, raw-PID lookup, cgroup placement, parent-child ownership, ptrace relations, pidfd identity, session state, and accumulated resource usage across the leader handoff.

Align wait, SIGCHLD, ptrace exit notification, fatal thread-group signals, and process-group delivery with Linux 6.6 semantics. Preserve exited-thread CPU accounting and publish child-exit state before waking signal and wait observers.

Serialize controlling-TTY ownership and PTY peer lifetime transitions to prevent stale session updates, duplicate group signals, premature ctty removal, and slave-open races.

Add deterministic dunitest coverage for non-leader exec identity, pidfd visibility, fatal-signal races, wait ownership, resource accounting, process groups, ptrace siginfo, and PTY lifetime behavior.

Fixes #2153

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

Author: fslongjin

kernel/src/driver/tty/pty/unix98pty.rs

@@ -814,6 +814,13 @@ impl TtyOperation for Unix98PtyDriverInner {
         if subtype == TtyDriverSubType::PtySlave {
             if let Some(hook_arc) = tty.private_fields() {
                 if let Some(hook) = hook_arc.as_any().downcast_ref::<PtyDevPtsLink>() {
+                    // Pin the master before publishing this in-flight slave
+                    // open. The link is weak, so the last master file could
+                    // otherwise drop it between begin_slave_open() and
+                    // pty_common_open(), leaking ENODEV from the latter.
+                    // A concurrent master close is reported as EIO below,
+                    // matching Linux pts open semantics.
+                    let _master = tty.link().ok_or(SystemError::EIO)?;
                     hook.begin_slave_open()?;
                     return match PtyCommon::pty_common_open(tty) {
                         Ok(()) => {

kernel/src/driver/tty/tty_core.rs

@@ -141,6 +141,7 @@ impl TtyCore {
             read_wq: EventWaitQueue::new(),
             write_wq: EventWaitQueue::new(),
             write_lock: TtySleepLock::new(),
+            job_control_lock: TtySleepLock::new(),
             port: RwLock::new(None),
             index,
             vc_index: AtomicUsize::new(usize::MAX),
@@ -263,6 +264,7 @@ impl TtyCore {
     }
 
     pub fn tty_vhangup(tty: Arc<TtyCore>) {
+        let _job_control_guard = tty.core().job_control_lock().lock();
         {
             let mut flags = tty.core().flags_write();
             if flags.intersects(TtyFlag::HUPPED | TtyFlag::HUPPING) {
@@ -276,10 +278,7 @@ impl TtyCore {
         // every pre-hangup open file description.
         tty.core().fasync_items.clear();
 
-        let (sid, pgid) = {
-            let ctrl = tty.core().contorl_info_irqsave();
-            (ctrl.session.clone(), ctrl.pgid.clone())
-        };
+        let pgid = TtyJobCtrlManager::remove_session_tty_job_locked(&tty, None);
 
         if let Some(pgrp) = pgid {
             let _ = crate::ipc::kill::send_signal_to_pgid(&pgrp, Signal::SIGHUP);
@@ -290,13 +289,8 @@ impl TtyCore {
 
         {
             let mut ctrl = tty.core().contorl_info_irqsave();
-            ctrl.session = None;
-            ctrl.pgid = None;
             ctrl.pktstatus = TtyPacketStatus::empty();
         }
-        if let Some(sid) = sid {
-            TtyJobCtrlManager::session_clear_tty(sid);
-        }
 
         {
             let mut flags = tty.core().flags_write();
@@ -666,6 +660,8 @@ pub struct TtyCoreData {
     write_wq: EventWaitQueue,
     /// 串行化整个 tty write 调用，等价于 Linux tty->atomic_write_lock。
     write_lock: TtySleepLock,
+    /// Serializes controlling-session changes with hangup.
+    job_control_lock: TtySleepLock,
     /// 端口
     port: RwLock<Option<Arc<dyn TtyPort>>>,
     /// 前台进程
@@ -875,6 +871,11 @@ impl TtyCoreData {
         &self.write_lock
     }
 
+    #[inline]
+    pub fn job_control_lock(&self) -> &TtySleepLock {
+        &self.job_control_lock
+    }
+
     #[inline]
     pub fn contorl_info_irqsave(&self) -> SpinLockGuard<'_, TtyControlInfo> {
         self.ctrl.lock_irqsave()
@@ -1094,15 +1095,21 @@ impl TtyOperation for TtyCore {
         let subtype = tty.core().driver().tty_driver_sub_type();
         let is_pty_slave_last = cnt == 1 && subtype == TtyDriverSubType::PtySlave;
         let is_pty_master_last = cnt == 1 && subtype == TtyDriverSubType::PtyMaster;
-        if !self.core().count_valid() || is_pty_slave_last || is_pty_master_last {
+        let final_release = !self.core().count_valid();
+        if final_release || is_pty_slave_last || is_pty_master_last {
             // log::debug!(
             //     "TtyCore close: ref count: {}, tty: {}",
             //     cnt,
             //     tty.core().name()
             // );
             let r = self.core().tty_driver.driver_funcs().close(tty.clone());
-            // 如果计数为0或者无效，表示tty已经关闭
-            TtyJobCtrlManager::remove_session_tty(&tty);
+            // Linux pty_close() runs when the last user fd closes even though
+            // the peer keeps the tty structure count at one. The controlling
+            // session remains attached in that case and may reopen /dev/tty;
+            // only a true final structure release clears it here.
+            if final_release {
+                let _ = TtyJobCtrlManager::remove_session_tty(&tty);
+            }
             return r;
         }
         Ok(())

kernel/src/driver/tty/tty_device.rs

@@ -347,22 +347,13 @@ impl IndexNode for TtyDevice {
         let driver = tty.core().driver();
         // 考虑 O_NOCTTY：显式指定则不设置控制终端；pty master 也不会成为控制终端。
         if !(mode.contains(FileFlags::O_NOCTTY)
+            || mode.is_write_only()
             || (driver.tty_driver_type() == TtyDriverType::Pty
                 && driver.tty_driver_sub_type() == TtyDriverSubType::PtyMaster))
         {
-            let pcb = ProcessManager::current_pcb();
-            let pcb_tty = pcb.sig_info_irqsave().tty();
-            let is_session_leader = pcb.sig_info_irqsave().is_session_leader;
-            let tty_session_is_none = tty.core().contorl_info_irqsave().session.is_none();
-            // Linux tty_open_proc_set_tty 语义：必须是会话首进程、尚无 controlling tty、
-            // tty 当前未被会话占用，且本次 open 具备读权限（不是 O_WRONLY）。
-            if is_session_leader
-                && pcb_tty.is_none()
-                && tty_session_is_none
-                && !mode.is_write_only()
-            {
-                TtyJobCtrlManager::proc_set_tty(tty);
-            }
+            // The helper revalidates and commits the controlling-tty state as
+            // one membership/tty/signal transaction.
+            TtyJobCtrlManager::proc_set_tty(tty);
         }
 
         Ok(())