Add support for delete and sync via the kernel

src/bin/init/src/main.rs

@@ -30,6 +30,14 @@ fn initialize_pager() {
     .unwrap();
 
     pager::pager_start(queue.object().id(), queue2.object().id());
+
+    tracing::info!("sync call test");
+    twizzler_abi::syscall::sys_object_ctrl(
+        queue.object().id(),
+        twizzler_abi::syscall::ObjectControlCmd::Sync,
+    )
+    .unwrap();
+    tracing::info!("sync call done!");
 }
 
 fn main() {

src/kernel/src/memory/context/virtmem.rs

@@ -1,7 +1,7 @@
 //! This mod implements [UserContext] and [KernelMemoryContext] for virtual memory systems.
 
 use alloc::{collections::BTreeMap, sync::Arc, vec::Vec};
-use core::{intrinsics::size_of, marker::PhantomData, ptr::NonNull};
+use core::{marker::PhantomData, mem::size_of, ptr::NonNull};
 
 use twizzler_abi::{
     device::CacheType,

src/kernel/src/pager.rs

@@ -66,3 +66,31 @@ pub fn lookup_object_and_wait(id: ObjID) -> Option<ObjectRef> {
         };
     }
 }
+
+fn cmd_object(req: ReqKind) {
+    let mut mgr = INFLIGHT_MGR.lock();
+    let inflight = mgr.add_request(req);
+    drop(mgr);
+    if let Some(pager_req) = inflight.pager_req() {
+        queues::submit_pager_request(pager_req);
+    }
+
+    let mut mgr = INFLIGHT_MGR.lock();
+    let thread = current_thread_ref().unwrap();
+    if let Some(guard) = mgr.setup_wait(&inflight, &thread) {
+        drop(mgr);
+        finish_blocking(guard);
+    };
+}
+
+pub fn sync_object(id: ObjID) {
+    cmd_object(ReqKind::new_sync(id));
+}
+
+pub fn del_object(id: ObjID) {
+    cmd_object(ReqKind::new_del(id));
+}
+
+pub fn create_object(id: ObjID) {
+    cmd_object(ReqKind::new_create(id));
+}

src/kernel/src/pager/inflight.rs

@@ -1,30 +1,48 @@
 use alloc::collections::{btree_map::BTreeMap, btree_set::BTreeSet};
 
 use stable_vec::StableVec;
-use twizzler_abi::{object::ObjID, pager::RequestFromKernel};
+use twizzler_abi::{
+    object::{ObjID, NULLPAGE_SIZE},
+    pager::{KernelCommand, ObjectRange, RequestFromKernel},
+};
 
 use super::{request::ReqKind, Request};
 use crate::thread::{CriticalGuard, ThreadRef};
 
 pub struct Inflight {
     id: usize,
     rk: ReqKind,
+    needs_send: bool,
 }
 
 impl Inflight {
-    pub(super) fn new(id: usize, rk: ReqKind) -> Self {
-        Self { id, rk }
+    pub(super) fn new(id: usize, rk: ReqKind, needs_send: bool) -> Self {
+        Self { id, rk, needs_send }
     }
 
     pub(super) fn pager_req(&self) -> Option<RequestFromKernel> {
-        todo!()
+        if !self.needs_send {
+            return None;
+        }
+        let cmd = match self.rk {
+            ReqKind::Info(obj_id) => KernelCommand::ObjectInfoReq(obj_id),
+            ReqKind::PageData(obj_id, s, e) => KernelCommand::PageDataReq(
+                obj_id,
+                ObjectRange::new((s * NULLPAGE_SIZE) as u64, (e * NULLPAGE_SIZE) as u64),
+            ),
+            ReqKind::Sync(obj_id) => KernelCommand::ObjectSync(obj_id),
+            ReqKind::Del(obj_id) => todo!(),
+            ReqKind::Create(obj_id) => todo!(),
+        };
+        Some(RequestFromKernel::new(cmd))
     }
 }
 
 #[derive(Default)]
 struct PerObjectData {
     page_map: BTreeMap<usize, BTreeSet<usize>>,
     info_list: BTreeSet<usize>,
+    sync_list: BTreeSet<usize>,
 }
 
 impl PerObjectData {
@@ -35,6 +53,9 @@ impl PerObjectData {
         if rk.needs_info() {
             self.info_list.insert(id);
         }
+        if rk.needs_sync() {
+            self.sync_list.insert(id);
+        }
     }
 
     fn remove_all(&mut self, rk: ReqKind, id: usize) {
@@ -44,6 +65,9 @@ impl PerObjectData {
         if rk.needs_info() {
             self.info_list.remove(&id);
         }
+        if rk.needs_sync() {
+            self.sync_list.remove(&id);
+        }
     }
 }
 
@@ -64,7 +88,7 @@ impl InflightManager {
 
     pub fn add_request(&mut self, rk: ReqKind) -> Inflight {
         if let Some(id) = self.req_map.get(&rk) {
-            return Inflight::new(*id, rk);
+            return Inflight::new(*id, rk, false);
         }
         let id = self.requests.next_push_index();
         let request = Request::new(id, rk);
@@ -75,7 +99,7 @@ impl InflightManager {
             .entry(rk.objid())
             .or_insert_with(|| PerObjectData::default());
         per_obj.insert(rk, id);
-        Inflight::new(id, rk)
+        Inflight::new(id, rk, true)
     }
 
     fn remove_request(&mut self, id: usize) {
@@ -99,11 +123,15 @@ impl InflightManager {
         request.setup_wait(thread)
     }
 
-    pub fn info_ready(&mut self, objid: ObjID) {
+    pub fn cmd_ready(&mut self, objid: ObjID, sync: bool) {
         if let Some(po) = self.per_object.get_mut(&objid) {
-            for id in &po.info_list {
+            let list = if sync { &po.sync_list } else { &po.info_list };
+            for id in list {
                 if let Some(req) = self.requests.get_mut(*id) {
-                    req.info_ready();
+                    req.cmd_ready();
+                    if req.done() {
+                        req.signal();
+                    }
                 } else {
                     logln!("[pager] warning -- stale ID");
                 }
@@ -118,6 +146,9 @@ impl InflightManager {
                     for id in idset {
                         if let Some(req) = self.requests.get_mut(*id) {
                             req.page_ready(page);
+                            if req.done() {
+                                req.signal();
+                            }
                         } else {
                             logln!("[pager] warning -- stale ID");
                         }

src/kernel/src/pager/queues.rs

@@ -1,25 +1,22 @@
 use twizzler_abi::{
     device::CacheType,
-    object::{ObjID, Protections},
+    object::{ObjID, Protections, NULLPAGE_SIZE},
     pager::{
-        CompletionToKernel, CompletionToPager, KernelCommand, ObjectRange, PagerCompletionData,
-        PagerRequest, PhysRange, RequestFromKernel, RequestFromPager,
+        CompletionToKernel, CompletionToPager, ObjectRange, PagerCompletionData, PagerRequest,
+        PhysRange, RequestFromKernel, RequestFromPager,
     },
 };
 
-use super::request::ReqKind;
+use super::INFLIGHT_MGR;
 use crate::{
-    arch::{PhysAddr, VirtAddr},
+    arch::PhysAddr,
     idcounter::{IdCounter, SimpleId},
     memory::context::{kernel_context, KernelMemoryContext, ObjectContextInfo},
-    obj::{lookup_object, LookupFlags},
+    obj::{lookup_object, pages::Page, LookupFlags, PageNumber},
     once::Once,
     pager::PAGER_MEMORY,
-    queue::{ManagedQueueReceiver, ManagedQueueSender, QueueObject},
-    syscall::object::sys_sctx_attach,
-    thread::{
-        current_memory_context, current_thread_ref, entry::start_new_kernel, priority::Priority,
-    },
+    queue::{ManagedQueueReceiver, QueueObject},
+    thread::{entry::start_new_kernel, priority::Priority},
 };
 
 static SENDER: Once<(
@@ -91,7 +88,7 @@ fn pager_test_request() -> CompletionToPager {
 pub(super) fn pager_request_handler_main() {
     let receiver = RECEIVER.wait();
     loop {
-        receiver.handle_request(|id, req| match req.cmd() {
+        receiver.handle_request(|_id, req| match req.cmd() {
             PagerRequest::EchoReq => {
                 CompletionToPager::new(twizzler_abi::pager::PagerCompletionData::EchoResp)
             }
@@ -124,11 +121,45 @@ pub(super) fn pager_compl_handler_main() {
             twizzler_abi::pager::KernelCompletionData::EchoResp => {
                 //logln!("got echo response");
             }
-            twizzler_abi::pager::KernelCompletionData::PageDataCompletion(phys_range) => {
-                //logln!("got physical range {:?}", phys_range);
+            twizzler_abi::pager::KernelCompletionData::PageDataCompletion(
+                objid,
+                obj_range,
+                phys_range,
+            ) => {
+                logln!(
+                    "kernel: pager compl: got physical range {:?} for object {} range {:?}",
+                    phys_range,
+                    objid,
+                    obj_range
+                );
+                if let Ok(object) = lookup_object(objid, LookupFlags::empty()).ok_or(()) {
+                    let mut object_tree = object.lock_page_tree();
+
+                    for (objpage_nr, physpage_nr) in obj_range.pages().zip(phys_range.pages()) {
+                        let pn = PageNumber::from(objpage_nr as usize);
+                        let pa = PhysAddr::new(physpage_nr * NULLPAGE_SIZE as u64).unwrap();
+                        logln!("kernel adding object {} page {} => {:?}", objid, pn, pa);
+                        object_tree.add_page(pn, Page::new_wired(pa, CacheType::WriteBack));
+                    }
+                    drop(object_tree);
+
+                    INFLIGHT_MGR
+                        .lock()
+                        .pages_ready(objid, obj_range.pages().map(|x| x as usize));
+                } else {
+                    logln!("kernel: pager: got unknown object ID");
+                }
             }
             twizzler_abi::pager::KernelCompletionData::ObjectInfoCompletion(obj_info) => {
-                //logln!("got object info {:?}", obj_info);
+                logln!("kernel: pager compl: got object info {:?}", obj_info);
+                INFLIGHT_MGR.lock().cmd_ready(obj_info.obj_id, false);
+            }
+            twizzler_abi::pager::KernelCompletionData::SyncOkay(objid) => {
+                logln!("kernel: pager compl: got object sync {:?}", objid);
+                INFLIGHT_MGR.lock().cmd_ready(objid, true);
+            }
+            twizzler_abi::pager::KernelCompletionData::Error => {
+                logln!("pager returned error");
             }
         }
         sender.0.release_simple(SimpleId::from(completion.0));

src/kernel/src/pager/request.rs

@@ -8,9 +8,12 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub(super) enum ReqKind {
+pub enum ReqKind {
     Info(ObjID),
     PageData(ObjID, usize, usize),
+    Sync(ObjID),
+    Del(ObjID),
+    Create(ObjID),
 }
 
 impl ReqKind {
@@ -22,21 +25,40 @@ impl ReqKind {
         ReqKind::PageData(obj_id, start, len)
     }
 
+    pub fn new_sync(obj_id: ObjID) -> Self {
+        ReqKind::Sync(obj_id)
+    }
+
+    pub fn new_del(obj_id: ObjID) -> Self {
+        ReqKind::Del(obj_id)
+    }
+
+    pub fn new_create(obj_id: ObjID) -> Self {
+        ReqKind::Create(obj_id)
+    }
+
     pub fn pages(&self) -> impl Iterator<Item = usize> {
         match self {
-            ReqKind::Info(_) => (0..0).into_iter(),
             ReqKind::PageData(_, start, len) => (*start..(*start + *len)).into_iter(),
+            _ => (0..0).into_iter(),
         }
     }
 
     pub fn needs_info(&self) -> bool {
         matches!(self, ReqKind::Info(_))
     }
 
+    pub fn needs_sync(&self) -> bool {
+        matches!(self, ReqKind::Sync(_)) || matches!(self, ReqKind::Del(_))
+    }
+
     pub fn objid(&self) -> ObjID {
         match self {
             ReqKind::Info(obj_id) => *obj_id,
             ReqKind::PageData(obj_id, _, _) => *obj_id,
+            ReqKind::Sync(obj_id) => *obj_id,
+            ReqKind::Del(obj_id) => *obj_id,
+            ReqKind::Create(obj_id) => *obj_id,
         }
     }
 }
@@ -45,7 +67,7 @@ pub struct Request {
     id: usize,
     reqkind: ReqKind,
     remaining_pages: BTreeSet<usize>,
-    info_ready: Option<bool>,
+    cmd_ready: bool,
     waiting_threads: Vec<ThreadRef>,
 }
 
@@ -58,11 +80,7 @@ impl Request {
         Self {
             id,
             reqkind,
-            info_ready: if reqkind.needs_info() {
-                Some(false)
-            } else {
-                None
-            },
+            cmd_ready: !(reqkind.needs_info() || reqkind.needs_sync()),
             waiting_threads: Vec::new(),
             remaining_pages,
         }
@@ -73,7 +91,7 @@ impl Request {
     }
 
     pub fn done(&self) -> bool {
-        self.info_ready.unwrap_or(true) && self.remaining_pages.is_empty()
+        self.cmd_ready && self.remaining_pages.is_empty()
     }
 
     pub fn signal(&mut self) {
@@ -82,8 +100,8 @@ impl Request {
         }
     }
 
-    pub fn info_ready(&mut self) {
-        self.info_ready.as_mut().map(|b| *b = true);
+    pub fn cmd_ready(&mut self) {
+        self.cmd_ready = true;
     }
 
     pub fn page_ready(&mut self, page: usize) {