From 55547d336ee52cec399a4a0206aeadb504107ea5 Mon Sep 17 00:00:00 2001
From: Paul Pan <i@0x7f.app>
Date: Tue, 3 Sep 2024 19:38:01 +0800
Subject: [PATCH] feat: kernel/objects/tcb: support for endpoint

---
 kernel/src/objects/tcb.rs | 89 ++++++++++++++++++++++++++-------------
 kernel/src/syscall.rs     |  2 +-
 2 files changed, 60 insertions(+), 31 deletions(-)

diff --git a/kernel/src/objects/tcb.rs b/kernel/src/objects/tcb.rs
index 1aea908..9955bb3 100644
--- a/kernel/src/objects/tcb.rs
+++ b/kernel/src/objects/tcb.rs
@@ -1,10 +1,11 @@
-use crate::arch::{layout::mmap_phys_to_virt, trap::TrapContext, vspace::*};
+use crate::arch::{trap::TrapContext, vspace::*};
 use crate::scheduler::SCHEDULER;
 use crate::syscall::handle_syscall;
 use crate::{objects::*, plat::trap::TrapContextOps, vspace::*};
 use core::fmt::Debug;
 use core::sync::atomic::{AtomicUsize, Ordering};
-use uapi::{cap::ObjectType, fault::*};
+use uapi::cap::ObjectType;
+use uapi::fault::Fault;
 use utils::{
     addr::*,
     linked_list::{Link, LinkHelper},
@@ -21,31 +22,36 @@ pub enum ThreadState {
     Inactive,
     Running,
     Restart,
-    Blocked,
+    Sending,
+    Receiving,
     Idle,
 }
 
 pub const SCHED_QUEUE_LINK_ID: usize = 1;
+pub const EP_QUEUE_LINK_ID: usize = 2;
 
 #[repr(C)]
 pub struct TcbObject {
     pub trapframe: TrapContext, // must be the first field
 
-    cspace:        CapEntry,
-    vspace:        CapEntry,
-    notification:  CapEntry,
-    buffer:        CapEntry, // CapFrame
-    fault:         Fault,
-    fault_handler: CapEntry,
+    cspace: CapEntry,
+    vspace: CapEntry,
+
+    // endpoint
+    badge:  usize,
+    buffer: CapEntry,
+    fault:  Fault,
 
     state:     ThreadState,
     time_tick: usize,
     tid:       usize,
 
     pub sched_queue: Link<Self, SCHED_QUEUE_LINK_ID>,
+    pub ep_queue:    Link<Self, EP_QUEUE_LINK_ID>,
 }
 
 LinkHelperImpl!(TcbObject { sched_queue } => SCHED_QUEUE_LINK_ID);
+LinkHelperImpl!(TcbObject { ep_queue } => EP_QUEUE_LINK_ID);
 
 const_assert_eq!(ObjectType::TCB.size(0), ObjectType::TCB.size(0x42));
 const_assert!(core::mem::size_of::<TcbObject>() <= ObjectType::TCB.size(0));
@@ -53,22 +59,28 @@ const_assert!(core::mem::size_of::<TcbObject>() <= ObjectType::TCB.size(0));
 impl TcbObject {
     pub fn new() -> Self {
         Self {
-            trapframe:     TrapContext::default(),
-            cspace:        CapEntry::new(NullCap::mint()),
-            vspace:        CapEntry::new(NullCap::mint()),
-            notification:  CapEntry::new(NullCap::mint()),
-            buffer:        CapEntry::new(NullCap::mint()),
-            fault:         Fault::Null,
-            fault_handler: CapEntry::new(NullCap::mint()),
-            state:         ThreadState::Inactive,
-            time_tick:     0,
-            tid:           TID_ALLOCATOR.fetch_add(1, Ordering::SeqCst),
-            sched_queue:   Link::default(),
+            trapframe:   TrapContext::default(),
+            cspace:      CapEntry::new(NullCap::mint()),
+            vspace:      CapEntry::new(NullCap::mint()),
+            badge:       0,
+            buffer:      CapEntry::new(NullCap::mint()),
+            fault:       Fault::Null,
+            state:       ThreadState::Inactive,
+            time_tick:   0,
+            tid:         TID_ALLOCATOR.fetch_add(1, Ordering::SeqCst),
+            sched_queue: Link::default(),
+            ep_queue:    Link::default(),
         }
     }
 
-    pub fn cspace(&self) -> &CapEntry {
-        &self.cspace
+    pub fn configure_idle_thread(&mut self) {
+        self.trapframe.configure_idle_thread();
+        self.vspace = CapEntry::new(TableCap::mint(unsafe { get_current_pagetable().paddr() }));
+        self.state = ThreadState::Idle;
+    }
+
+    pub fn cspace(&self) -> SysResult<CNodeCap> {
+        CNodeCap::try_from(&self.cspace)
     }
 
     pub fn set_cspace(&mut self, cspace: CapEntry) {
@@ -84,20 +96,38 @@ impl TcbObject {
         self.vspace = vspace;
     }
 
-    pub fn configure_idle_thread(&mut self) {
-        self.trapframe.configure_idle_thread();
-        self.vspace = CapEntry::new(TableCap::mint(unsafe { get_current_pagetable().paddr() }));
-        self.state = ThreadState::Idle;
+    pub fn badge(&self) -> usize {
+        self.badge
     }
 
-    pub fn tid(&self) -> usize {
-        self.tid
+    pub fn set_badge(&mut self, badge: usize) {
+        self.badge = badge;
+    }
+
+    pub fn buffer(&self) -> SysResult<FrameCap> {
+        FrameCap::try_from(&self.buffer)
+    }
+
+    pub fn set_buffer(&mut self, buffer: CapEntry) {
+        self.buffer = buffer;
+    }
+
+    pub fn fault(&self) -> Fault {
+        self.fault
+    }
+
+    pub fn set_fault(&mut self, fault: Fault) {
+        self.fault = fault;
     }
 
     pub fn state(&self) -> ThreadState {
         self.state
     }
 
+    pub fn tid(&self) -> usize {
+        self.tid
+    }
+
     pub fn schedulable(&self) -> bool {
         matches!(self.state, ThreadState::Idle | ThreadState::Running)
     }
@@ -163,10 +193,9 @@ impl Debug for TcbCap<'_> {
         f.debug_struct("TcbCap")
             .field("cspace", &obj.cspace)
             .field("vspace", &obj.vspace)
-            .field("notification", &obj.notification)
+            .field("badge", &obj.badge)
             .field("buffer", &obj.buffer)
             .field("fault", &obj.fault)
-            .field("fault_handler", &obj.fault_handler)
             .field("state", &obj.state)
             .field("time_tick", &obj.time_tick)
             .finish()
diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs
index ba0ba64..3250a10 100644
--- a/kernel/src/syscall.rs
+++ b/kernel/src/syscall.rs
@@ -29,7 +29,7 @@ pub fn handle_syscall(tcb: &mut TcbObject) -> SysResult {
         _ => (),
     };
 
-    let cspace = CNodeCap::try_from(tcb.cspace())?;
+    let cspace = tcb.cspace()?;
     let cap_ptr = tcb.trapframe.get_reg(REG_CAP_PTR);
     let cap = cspace.resolve_address_bits(cap_ptr, info.bits()).map_err(SysError::from)?;