feat: adjust Cell granularity for CapEntry

kernel/src/main.rs

@@ -3,6 +3,7 @@
 #![no_main]
 // Features
 #![feature(asm_const)]
+#![feature(cell_update)]
 #![feature(concat_idents)]
 #![feature(const_mut_refs)]
 #![feature(extern_types)]

kernel/src/objects/cap.rs

@@ -1,8 +1,9 @@
 use api::cap::ObjectType;
+use core::{cell::Cell, ptr::NonNull};
 use vspace::addr::PhysAddr;
 
 /// RawCap is the specific implementation of capability which stores in CNode
-#[derive(Clone, Copy, Default)]
+#[derive(Copy, Clone, Default)]
 pub struct RawCap {
     // TODO: this could be an enum, figure out a way to do this
     /// args: in vanilla seL4 implementation, a cap use two 64-bit words to store all information,
@@ -25,3 +26,44 @@ impl RawCap {
         }
     }
 }
+
+#[derive(Copy, Clone, Default)]
+pub struct Link {
+    pub prev: Option<NonNull<CapEntry>>,
+    pub next: Option<NonNull<CapEntry>>,
+}
+
+pub struct CapEntry {
+    pub cap:  Cell<RawCap>,
+    pub link: Cell<Link>,
+}
+
+impl CapEntry {
+    pub fn new(cap: RawCap) -> Self {
+        Self {
+            cap:  Cell::new(cap),
+            link: Cell::new(Link::default()),
+        }
+    }
+
+    pub fn init(&mut self) {
+        self.cap = Cell::new(RawCap::default());
+        self.link = Cell::new(Link::default());
+    }
+
+    pub fn prev(&self) -> Option<NonNull<CapEntry>> {
+        self.link.get().prev
+    }
+
+    pub fn next(&self) -> Option<NonNull<CapEntry>> {
+        self.link.get().next
+    }
+
+    pub fn set_prev(&mut self, prev: Option<NonNull<CapEntry>>) {
+        self.link.get_mut().prev = prev;
+    }
+
+    pub fn set_next(&mut self, next: Option<NonNull<CapEntry>>) {
+        self.link.get_mut().next = next;
+    }
+}

kernel/src/objects/cnode.rs

@@ -1,6 +1,7 @@
-use core::cell::Cell;
-
-use super::{cap::RawCap, Cap, KernelObject};
+use super::{
+    cap::{CapEntry, RawCap},
+    Cap, KernelObject,
+};
 use crate::arch::layout::mmap_phys_to_virt;
 use api::{cap::ObjectType, error::CapFault};
 use utils::MASK;
@@ -8,7 +9,7 @@ use vspace::addr::{AddressOps, PhysAddr};
 
 /// CNodeObject is a array of Capabilities (`RawCap`)
 /// The size of the array is stored in CNodeCap
-pub type CNodeObject = [Cell<RawCap>];
+pub type CNodeObject = [CapEntry];
 
 impl KernelObject for CNodeObject {
     const OBJ_TYPE: ObjectType = ObjectType::CNode;
@@ -41,29 +42,29 @@ impl<'a> CNodeCap<'a> {
         let arg0 = ((radix & Self::RADIX_MASK) << Self::RADIX_OFFSET)
             | ((guard_size & Self::GUARD_SIZE_MASK) << Self::GUARD_SIZE_OFFSET);
         let arg1 = guard;
+        let cap: RawCap = RawCap::new(arg0, arg1, ptr, ObjectType::CNode);
 
-        let cap = RawCap::new(arg0, arg1, ptr, ObjectType::CNode);
-        CNodeCap::try_from(&Cell::new(cap))
+        // init memory
+        let cte = super::cap::CapEntry::new(cap);
+        CNodeCap::try_from(&cte)
             .unwrap()
-            .as_object()
-            .iter()
-            .for_each(|cell| {
-                cell.set(RawCap::default());
-            });
+            .as_object_mut()
+            .iter_mut()
+            .for_each(|cap| cap.init());
 
         cap
     }
 
     fn radix(&self) -> usize {
-        (self.cap.get().args[0] >> Self::RADIX_OFFSET) & Self::RADIX_MASK
+        (self.cte.cap.get().args[0] >> Self::RADIX_OFFSET) & Self::RADIX_MASK
     }
 
     fn guard_size(&self) -> usize {
-        (self.cap.get().args[0] >> Self::GUARD_SIZE_OFFSET) & Self::GUARD_SIZE_MASK
+        (self.cte.cap.get().args[0] >> Self::GUARD_SIZE_OFFSET) & Self::GUARD_SIZE_MASK
     }
 
     fn guard(&self) -> usize {
-        self.cap.get().args[1]
+        self.cte.cap.get().args[1]
     }
 
     /// CNodeObject length
@@ -76,14 +77,21 @@ impl<'a> CNodeCap<'a> {
 
     fn as_object(&self) -> &CNodeObject {
         unsafe {
-            let virt = mmap_phys_to_virt(self.cap.get().ptr);
+            let virt = mmap_phys_to_virt(self.cte.cap.get().ptr);
             core::slice::from_raw_parts(virt.as_const_ptr(), self.length())
         }
     }
 
-    fn resolve_address_bits(&self, cap_ptr: usize, n_bits: usize) -> Result<&Cell<RawCap>, CapFault> {
+    fn as_object_mut(&mut self) -> &mut CNodeObject {
+        unsafe {
+            let virt = mmap_phys_to_virt(self.cte.cap.get().ptr);
+            core::slice::from_raw_parts_mut(virt.as_mut_ptr(), self.length())
+        }
+    }
+
+    fn resolve_address_bits(&self, cap_ptr: usize, n_bits: usize) -> Result<&CapEntry, CapFault> {
         let mut bits_remaining = n_bits;
-        let mut slot = self.cap;
+        let mut slot = self.cte;
 
         while let Ok(cnode) = CNodeCap::try_from(slot) {
             let radix_bits = cnode.radix();

kernel/src/objects/mod.rs

@@ -18,8 +18,8 @@ use api::{
     cap::ObjectType,
     error::{SysError, SysResult},
 };
-use cap::RawCap;
-use core::{cell::Cell, marker::PhantomData};
+use cap::CapEntry;
+use core::{marker::PhantomData, ptr::NonNull};
 
 pub mod cap;
 pub mod cnode;
@@ -30,25 +30,49 @@ pub mod untyped;
 /// For the typed objects, we should bound it with an empty traits `KernelObject`
 /// And for those objects, at least implement `mint` method and `decodeInvocation` (not enforcing in `KernelObject` for complexity)
 pub struct Cap<'a, T: KernelObject + ?Sized> {
-    cap:      &'a Cell<RawCap>, // use Cell to avoid lifetime issues
+    cte:      &'a CapEntry,
     cap_type: PhantomData<T>,
 }
 
-impl<'a, T: KernelObject + ?Sized> TryFrom<&'a Cell<RawCap>> for Cap<'a, T> {
+impl<'a, T: KernelObject + ?Sized> TryFrom<&'a CapEntry> for Cap<'a, T> {
     type Error = SysError;
 
-    fn try_from(new: &'a Cell<RawCap>) -> SysResult<Self> {
-        if new.get().cap_type != T::OBJ_TYPE {
+    fn try_from(new: &'a CapEntry) -> SysResult<Self> {
+        if new.cap.get().cap_type != T::OBJ_TYPE {
             Err(SysError::CapTypeMismatch)
         } else {
             Ok(Self {
-                cap:      new,
+                cte:      new,
                 cap_type: PhantomData,
             })
         }
     }
 }
 
+impl<'a, T: KernelObject + ?Sized> Cap<'a, T> {
+    pub fn append(&mut self, new: &mut CapEntry) {
+        let next = self.cte.next();
+
+        // update new cap's link
+        new.set_prev(Some(NonNull::from(self.cte)));
+        new.set_next(next);
+
+        // record new cap's addr
+        let new_addr = Some(NonNull::from(new));
+
+        // update next cap's link.prev
+        if let Some(mut next) = next {
+            unsafe { next.as_mut().set_prev(new_addr) };
+        }
+
+        // update self's link.next
+        self.cte.link.update(|mut link| {
+            link.next = new_addr;
+            link
+        });
+    }
+}
+
 /// KernelObject is the base trait for all kernel objects
 pub trait KernelObject {
     // this should be optimized by compiler?

kernel/src/objects/untyped.rs

@@ -43,26 +43,29 @@ impl UntypedCap<'_> {
     }
 
     fn free_offset(&self) -> usize {
-        self.cap.get().args[0]
+        self.cte.cap.get().args[0]
     }
 
-    fn set_free_offset(&self, free_offset: usize) {
-        self.cap.get().args[0] = free_offset;
+    fn set_free_offset(&mut self, free_offset: usize) {
+        self.cte.cap.update(|mut c| {
+            c.args[0] = free_offset;
+            c
+        });
     }
 
     fn is_device(&self) -> bool {
-        (self.cap.get().args[1] >> 6) & 1 == 1
+        (self.cte.cap.get().args[1] >> 6) & 1 == 1
     }
 
     fn block_bits(&self) -> usize {
-        self.cap.get().args[1] & MASK!(6)
+        self.cte.cap.get().args[1] & MASK!(6)
     }
 
     fn block_size(&self) -> usize {
         1 << self.block_bits()
     }
 
-    pub fn retype(&self, obj_type: ObjectType, user_obj_bits: usize, slots: &CNodeObject) -> SysResult<()> {
+    pub fn retype(&mut self, obj_type: ObjectType, user_obj_bits: usize, slots: &mut CNodeObject) -> SysResult<()> {
         /*
          * vallina seL4: `decode_untiped_invocation`
          * - _service    CPTR to an untyped object.
@@ -85,7 +88,7 @@ impl UntypedCap<'_> {
         // Make sure all slots are empty
         slots
             .iter()
-            .any(|cap: &core::cell::Cell<RawCap>| NullCap::try_from(cap).is_err())
+            .any(|cte| NullCap::try_from(cte).is_err())
             .then_ok((), SysError::CapTypeMismatch)?;
 
         // Start allocating from free_offset
@@ -108,8 +111,8 @@ impl UntypedCap<'_> {
         }
 
         // Create new capabilities in slot
-        for (i, slot) in slots.iter().enumerate() {
-            let addr = self.cap.get().ptr + start_offset + i * obj_size;
+        for (i, slot) in slots.iter_mut().enumerate() {
+            let addr = self.cte.cap.get().ptr + start_offset + i * obj_size;
             let new_cap = match obj_type {
                 ObjectType::Untyped => UntypedCap::mint(0, obj_type.bits(user_obj_bits), self.is_device(), addr),
                 ObjectType::CNode => CNodeCap::mint(user_obj_bits, 0, 0, addr),
@@ -117,8 +120,8 @@ impl UntypedCap<'_> {
                 _ => return Err(SysError::InvalidArgument),
             };
 
-            slot.set(new_cap);
-            // TODO: insert into linked list
+            slot.cap.set(new_cap);
+            self.append(slot);
         }
 
         // Update free_offset