From 4562774792d2bad595580107bd13c6d7741eee6f Mon Sep 17 00:00:00 2001 From: Daniel Bittman Date: Fri, 10 Jan 2025 17:10:42 -0800 Subject: [PATCH] Add support for delete and sync via the kernel. --- Cargo.lock | 1 - src/abi | 2 +- src/bin/init/src/main.rs | 8 +++ src/kernel/src/memory/context/virtmem.rs | 2 +- src/kernel/src/pager.rs | 28 ++++++++ src/kernel/src/pager/inflight.rs | 49 ++++++++++--- src/kernel/src/pager/queues.rs | 61 ++++++++++++---- src/kernel/src/pager/request.rs | 40 ++++++++--- src/kernel/src/syscall/mod.rs | 12 ++++ src/kernel/src/syscall/object.rs | 17 ++++- src/kernel/src/time.rs | 2 +- src/lib/twizzler-abi/src/pager.rs | 29 +++++++- .../src/syscall/object_control.rs | 6 +- src/rt/reference/src/runtime/file.rs | 72 ++++++++++++++++++- src/rt/reference/src/syms.rs | 3 +- src/srv/pager-srv/src/request_handle.rs | 16 ++++- toolchain/src/rust | 2 +- 17 files changed, 300 insertions(+), 50 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 692a07f6..e1406e1d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3624,7 +3624,6 @@ dependencies = [ name = "naming-srv" version = "0.1.0" dependencies = [ - "arrayvec", "lazy_static", "secgate", "twizzler-abi", diff --git a/src/abi b/src/abi index 05f36729..937c8182 160000 --- a/src/abi +++ b/src/abi @@ -1 +1 @@ -Subproject commit 05f36729494dbcc1843d881393787f32774be2b5 +Subproject commit 937c81825bef5648d855a9b43ee19b6889faab88 diff --git a/src/bin/init/src/main.rs b/src/bin/init/src/main.rs index 00416fd7..6674ffe5 100644 --- a/src/bin/init/src/main.rs +++ b/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() { diff --git a/src/kernel/src/memory/context/virtmem.rs b/src/kernel/src/memory/context/virtmem.rs index 4f681d8c..37b540e7 100644 --- a/src/kernel/src/memory/context/virtmem.rs +++ b/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, diff --git a/src/kernel/src/pager.rs b/src/kernel/src/pager.rs index d8a68144..a6a729d2 100644 --- a/src/kernel/src/pager.rs +++ b/src/kernel/src/pager.rs @@ -66,3 +66,31 @@ pub fn lookup_object_and_wait(id: ObjID) -> Option { }; } } + +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)); +} diff --git a/src/kernel/src/pager/inflight.rs b/src/kernel/src/pager/inflight.rs index 2dcd4046..7acc0087 100644 --- a/src/kernel/src/pager/inflight.rs +++ b/src/kernel/src/pager/inflight.rs @@ -1,7 +1,10 @@ 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}; @@ -9,15 +12,29 @@ 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 { - 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)) } } @@ -25,6 +42,7 @@ impl Inflight { struct PerObjectData { page_map: BTreeMap>, info_list: BTreeSet, + sync_list: BTreeSet, } 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"); } diff --git a/src/kernel/src/pager/queues.rs b/src/kernel/src/pager/queues.rs index 44016163..212dfe22 100644 --- a/src/kernel/src/pager/queues.rs +++ b/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)); diff --git a/src/kernel/src/pager/request.rs b/src/kernel/src/pager/request.rs index e71f6179..57dd7de8 100644 --- a/src/kernel/src/pager/request.rs +++ b/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,10 +25,22 @@ 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 { match self { - ReqKind::Info(_) => (0..0).into_iter(), ReqKind::PageData(_, start, len) => (*start..(*start + *len)).into_iter(), + _ => (0..0).into_iter(), } } @@ -33,10 +48,17 @@ impl ReqKind { 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, - info_ready: Option, + cmd_ready: bool, waiting_threads: Vec, } @@ -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) { diff --git a/src/kernel/src/syscall/mod.rs b/src/kernel/src/syscall/mod.rs index bf12161d..2a6f3a60 100644 --- a/src/kernel/src/syscall/mod.rs +++ b/src/kernel/src/syscall/mod.rs @@ -1,5 +1,6 @@ use core::mem::MaybeUninit; +use object::object_ctrl; use twizzler_abi::{ kso::{KactionCmd, KactionError, KactionValue}, object::{ObjID, Protections, MAX_SIZE}, @@ -400,6 +401,17 @@ pub fn syscall_entry(context: &mut T) { context.set_return_values(code, val); return; } + Syscall::ObjectCtrl => { + let id = ObjID::from_parts([context.arg0(), context.arg1()]); + let cmd = (context.arg2::(), context.arg3::()).try_into(); + if let Ok(cmd) = cmd { + let (code, val) = object_ctrl(id, cmd); + context.set_return_values(code, val); + } else { + context.set_return_values(1u64, 0u64); + } + return; + } Syscall::ReadClockInfo => { let result = type_read_clock_info(context.arg0(), context.arg1(), context.arg2()); let (code, val) = convert_result_to_codes(result, zero_ok, one_err); diff --git a/src/kernel/src/syscall/object.rs b/src/kernel/src/syscall/object.rs index 47d9b5bd..9b58fae3 100644 --- a/src/kernel/src/syscall/object.rs +++ b/src/kernel/src/syscall/object.rs @@ -6,8 +6,9 @@ use alloc::{ use twizzler_abi::{ object::{ObjID, Protections}, syscall::{ - CreateTieSpec, HandleType, MapFlags, MapInfo, NewHandleError, ObjectCreate, - ObjectCreateError, ObjectMapError, ObjectReadMapError, ObjectSource, SctxAttachError, + CreateTieSpec, HandleType, MapFlags, MapInfo, NewHandleError, ObjectControlCmd, + ObjectCreate, ObjectCreateError, ObjectMapError, ObjectReadMapError, ObjectSource, + SctxAttachError, }, }; @@ -185,3 +186,15 @@ pub fn sys_sctx_attach(id: ObjID) -> Result { Ok(0) } + +pub fn object_ctrl(id: ObjID, cmd: ObjectControlCmd) -> (u64, u64) { + logln!("object ctrl: {} {:?}", id, cmd); + match cmd { + ObjectControlCmd::Sync => { + crate::pager::sync_object(id); + } + ObjectControlCmd::Delete(_) => {} + _ => {} + } + (0, 0) +} diff --git a/src/kernel/src/time.rs b/src/kernel/src/time.rs index 3e9fcf3d..de489764 100644 --- a/src/kernel/src/time.rs +++ b/src/kernel/src/time.rs @@ -33,7 +33,7 @@ where // best real-time or monotonic clock and then // TICK_SOURCES to read the data. References with Arc around // them still point to the same memory location. - if core::intrinsics::unlikely(clk_id == 0) { + if unsafe { core::intrinsics::unlikely(clk_id == 0) } { // reserve space for the real-time clock clock_list.push(clk.clone()); // offset location of this clock source diff --git a/src/lib/twizzler-abi/src/pager.rs b/src/lib/twizzler-abi/src/pager.rs index 41a16594..f639bd8d 100644 --- a/src/lib/twizzler-abi/src/pager.rs +++ b/src/lib/twizzler-abi/src/pager.rs @@ -1,5 +1,7 @@ use twizzler_rt_abi::object::ObjID; +use crate::object::NULLPAGE_SIZE; + #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)] pub struct RequestFromKernel { cmd: KernelCommand, @@ -20,6 +22,9 @@ pub enum KernelCommand { EchoReq, PageDataReq(ObjID, ObjectRange), ObjectInfoReq(ObjID), + ObjectSync(ObjID), + ObjectDel(ObjID), + ObjectCreate(ObjectInfo), } #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)] @@ -39,9 +44,11 @@ impl CompletionToKernel { #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)] pub enum KernelCompletionData { + Error, EchoResp, - PageDataCompletion(PhysRange), + PageDataCompletion(ObjID, ObjectRange, PhysRange), ObjectInfoCompletion(ObjectInfo), + SyncOkay(ObjID), } #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)] @@ -98,8 +105,8 @@ pub enum PagerCompletionData { } pub struct PageDataReq { - objID: ObjID, - object_range: ObjectRange, + pub objID: ObjID, + pub object_range: ObjectRange, } #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)] @@ -133,10 +140,26 @@ impl PhysRange { pub fn len(&self) -> usize { (self.end - self.start) as usize } + + pub fn pages(&self) -> impl Iterator { + let first_page = self.start / NULLPAGE_SIZE as u64; + let last_page = self.end / NULLPAGE_SIZE as u64; + first_page..last_page + } } impl ObjectRange { pub fn new(start: u64, end: u64) -> Self { Self { start, end } } + + pub fn len(&self) -> usize { + (self.end - self.start) as usize + } + + pub fn pages(&self) -> impl Iterator { + let first_page = self.start / NULLPAGE_SIZE as u64; + let last_page = self.end / NULLPAGE_SIZE as u64; + first_page..last_page + } } diff --git a/src/lib/twizzler-abi/src/syscall/object_control.rs b/src/lib/twizzler-abi/src/syscall/object_control.rs index a8b2979f..f56cd0e7 100644 --- a/src/lib/twizzler-abi/src/syscall/object_control.rs +++ b/src/lib/twizzler-abi/src/syscall/object_control.rs @@ -48,6 +48,8 @@ pub enum ObjectControlCmd { CreateCommit, /// Delete an object. Delete(DeleteFlags), + /// Sync an entire object (non-transactionally) + Sync, } impl From for (u64, u64) { @@ -55,6 +57,7 @@ impl From for (u64, u64) { match c { ObjectControlCmd::CreateCommit => (0, 0), ObjectControlCmd::Delete(x) => (1, x.bits()), + ObjectControlCmd::Sync => (2, 0), } } } @@ -65,6 +68,7 @@ impl TryFrom<(u64, u64)> for ObjectControlCmd { Ok(match value.0 { 0 => ObjectControlCmd::CreateCommit, 1 => ObjectControlCmd::Delete(DeleteFlags::from_bits(value.1).ok_or(())?), + 2 => ObjectControlCmd::Sync, _ => return Err(()), }) } @@ -72,7 +76,7 @@ impl TryFrom<(u64, u64)> for ObjectControlCmd { /// Perform a kernel operation on this object. pub fn sys_object_ctrl(id: ObjID, cmd: ObjectControlCmd) -> Result<(), ObjectControlError> { - let (hi, lo) = id.split(); + let [hi, lo] = id.parts(); let (cmd, opts) = cmd.into(); let args = [hi, lo, cmd, opts]; let (code, val) = unsafe { raw_syscall(Syscall::ObjectCtrl, &args) }; diff --git a/src/rt/reference/src/runtime/file.rs b/src/rt/reference/src/runtime/file.rs index 93f8f1aa..a2fcb120 100644 --- a/src/rt/reference/src/runtime/file.rs +++ b/src/rt/reference/src/runtime/file.rs @@ -10,7 +10,10 @@ use lru::LruCache; use stable_vec::{self, StableVec}; use twizzler_abi::{ object::{ObjID, NULLPAGE_SIZE}, - syscall::{sys_object_create, BackingType, LifetimeType, ObjectCreate, ObjectCreateFlags}, + syscall::{ + sys_object_create, BackingType, DeleteFlags, LifetimeType, ObjectControlCmd, ObjectCreate, + ObjectCreateFlags, + }, }; use twizzler_rt_abi::{ bindings::io_vec, @@ -246,6 +249,73 @@ impl ReferenceRuntime { Some(twizzler_rt_abi::bindings::fd_info { flags: 0 }) } + pub fn fd_cmd(&self, fd: RawFd, cmd: u32, arg: *const u8, ret: *mut u8) -> u32 { + tracing::warn!("fd_cmd: unimp: {} {}", fd, cmd); + let binding = get_fd_slots().lock().unwrap(); + + let Some(FdKind::File(bind)) = binding.get(fd.try_into().unwrap()) else { + return 1; + }; + let file = bind.lock().unwrap(); + + let metadata_handle: &FileMetadata = unsafe { + file.handle + .start() + .offset(NULLPAGE_SIZE as isize) + .cast::() + .as_ref() + .unwrap() + }; + match cmd { + twizzler_rt_abi::bindings::FD_CMD_SYNC => { + let mut ok = true; + for id in &metadata_handle.direct { + if twizzler_abi::syscall::sys_object_ctrl(*id, ObjectControlCmd::Sync).is_err() + { + ok = false; + } + } + if twizzler_abi::syscall::sys_object_ctrl(file.handle.id(), ObjectControlCmd::Sync) + .is_err() + { + return 1; + } + if ok { + 0 + } else { + 1 + } + } + twizzler_rt_abi::bindings::FD_CMD_DELETE => { + let mut ok = true; + for id in &metadata_handle.direct { + if twizzler_abi::syscall::sys_object_ctrl( + *id, + ObjectControlCmd::Delete(DeleteFlags::empty()), + ) + .is_err() + { + ok = false; + } + } + if twizzler_abi::syscall::sys_object_ctrl( + file.handle.id(), + ObjectControlCmd::Delete(DeleteFlags::empty()), + ) + .is_err() + { + return 1; + } + if ok { + 0 + } else { + 1 + } + } + _ => 1, + } + } + pub fn write(&self, fd: RawFd, buf: &[u8]) -> Result { let binding = get_fd_slots().lock().unwrap(); let file_desc = binding diff --git a/src/rt/reference/src/syms.rs b/src/rt/reference/src/syms.rs index 520686d9..473f6d5d 100644 --- a/src/rt/reference/src/syms.rs +++ b/src/rt/reference/src/syms.rs @@ -328,8 +328,7 @@ pub unsafe extern "C-unwind" fn twz_rt_fd_cmd( arg: *mut ::core::ffi::c_void, ret: *mut ::core::ffi::c_void, ) -> twizzler_rt_abi::bindings::fd_cmd_err { - // TODO. Right now, just return an error value (non-zero). - 1 + OUR_RUNTIME.fd_cmd(fd, cmd, arg.cast(), ret.cast()) } check_ffi_type!(twz_rt_fd_cmd, _, _, _, _); diff --git a/src/srv/pager-srv/src/request_handle.rs b/src/srv/pager-srv/src/request_handle.rs index a982cc30..cf2a4878 100644 --- a/src/srv/pager-srv/src/request_handle.rs +++ b/src/srv/pager-srv/src/request_handle.rs @@ -32,7 +32,7 @@ pub async fn handle_kernel_request( ); let phys_range = page_data_req(data, obj_id, range); Some(CompletionToKernel::new( - KernelCompletionData::PageDataCompletion(phys_range), + KernelCompletionData::PageDataCompletion(obj_id, range, phys_range), )) } KernelCommand::ObjectInfoReq(obj_id) => { @@ -46,5 +46,19 @@ pub async fn handle_kernel_request( tracing::trace!("handling EchoReq"); Some(CompletionToKernel::new(KernelCompletionData::EchoResp)) } + KernelCommand::ObjectSync(obj_id) => { + tracing::warn!("unimp: object sync: {}", obj_id); + Some(CompletionToKernel::new(KernelCompletionData::SyncOkay( + obj_id, + ))) + } + KernelCommand::ObjectDel(obj_id) => { + tracing::warn!("unimp: object del: {}", obj_id); + Some(CompletionToKernel::new(KernelCompletionData::Error)) + } + KernelCommand::ObjectCreate(object_info) => { + tracing::warn!("unimp: object create: {}", object_info.obj_id); + Some(CompletionToKernel::new(KernelCompletionData::Error)) + } } } diff --git a/toolchain/src/rust b/toolchain/src/rust index e561b1c1..9ee4c45f 160000 --- a/toolchain/src/rust +++ b/toolchain/src/rust @@ -1 +1 @@ -Subproject commit e561b1c105f903a34a324591d002b3ee21d7906f +Subproject commit 9ee4c45fcc0072f72dd06133f19b7164663803d0