refactor: thread trait

Author: AsakuraMizu

src/lib.rs

@@ -8,12 +8,10 @@ extern crate alloc;
 mod process;
 mod process_group;
 mod session;
-mod thread;
 
 /// A process ID, also used as session ID, process group ID, and thread ID.
 pub type Pid = u32;
 
-pub use process::{Process, init_proc};
+pub use process::{Process, Thread, init_proc};
 pub use process_group::ProcessGroup;
 pub use session::Session;
-pub use thread::Thread;

src/process.rs

@@ -11,10 +11,16 @@ use kspin::SpinNoIrq;
 use lazyinit::LazyInit;
 use weak_map::{StrongMap, WeakMap};
 
-use crate::{Pid, ProcessGroup, Session, Thread};
+use crate::{Pid, ProcessGroup, Session};
+
+/// Represents a thread belonging to a process.
+pub trait Thread: Send + Sync {
+    /// The thread ID.
+    fn tid(&self) -> Pid;
+}
 
 pub(crate) struct ThreadGroup {
-    pub(crate) threads: WeakMap<Pid, Weak<Thread>>,
+    pub(crate) threads: WeakMap<Pid, Weak<dyn Thread>>,
     pub(crate) exit_code: i32,
     pub(crate) group_exited: bool,
 }
@@ -35,7 +41,7 @@ pub struct Process {
     is_zombie: AtomicBool,
     pub(crate) tg: SpinNoIrq<ThreadGroup>,
 
-    // TODO: child subreaper
+    // TODO: child subreaper9
     children: SpinNoIrq<StrongMap<Pid, Arc<Process>>>,
     parent: SpinNoIrq<Weak<Process>>,
 
@@ -156,15 +162,26 @@ impl Process {
 
 /// Threads
 impl Process {
-    /// Creates a new [`Thread`] in this [`Process`].
-    pub fn new_thread(self: &Arc<Self>, tid: Pid) -> Arc<Thread> {
-        let thread = Arc::new(Thread::new(tid, self.clone()));
-        self.tg.lock().threads.insert(tid, &thread);
-        thread
+    /// Adds a [`Thread`] to this [`Process`] with the given thread ID.
+    pub fn add_thread(self: &Arc<Self>, thread: &Arc<dyn Thread>) {
+        self.tg.lock().threads.insert(thread.tid(), thread);
+    }
+
+    /// Removes a [`Thread`] from this [`Process`] and sets the exit code if the
+    /// group has not exited.
+    ///
+    /// Returns `true` if this was the last thread in the process.
+    pub fn exit_thread(self: &Arc<Self>, thread: &dyn Thread, exit_code: i32) -> bool {
+        let mut tg = self.tg.lock();
+        if !tg.group_exited {
+            tg.exit_code = exit_code;
+        }
+        tg.threads.remove(&thread.tid());
+        tg.threads.is_empty()
     }
 
-    /// The [`Thread`]s in this [`Process`].
-    pub fn threads(&self) -> Vec<Arc<Thread>> {
+    /// Get all [`Thread`]s in this [`Process`].
+    pub fn threads(&self) -> Vec<Arc<dyn Thread>> {
         self.tg.lock().threads.values().collect()
     }